code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
from .utils import utils
from discord.ext import commands
import traceback
import datetime
import discord
class Welcome(commands.Cog): #Allow to welcome new members who join guild. If it enable, will send them a message.
def __init__(self,bot):
self.bot = bot
self.redis = bot.db.redis
async de... | [
"datetime.datetime.utcnow",
"traceback.format_exc",
"discord.ext.commands.Cog.listener"
] | [((824, 847), 'discord.ext.commands.Cog.listener', 'commands.Cog.listener', ([], {}), '()\n', (845, 847), False, 'from discord.ext import commands\n'), ((626, 648), 'traceback.format_exc', 'traceback.format_exc', ([], {}), '()\n', (646, 648), False, 'import traceback\n'), ((690, 712), 'traceback.format_exc', 'traceback... |
from django.shortcuts import render
def home_page(request):
return render(request, 'mainsite/base.html') | [
"django.shortcuts.render"
] | [((73, 110), 'django.shortcuts.render', 'render', (['request', '"""mainsite/base.html"""'], {}), "(request, 'mainsite/base.html')\n", (79, 110), False, 'from django.shortcuts import render\n')] |
from service.file.FileWriteService import FileWriteService
from service.json.JSONCoder import JSONCoder
class JSONWriteService(FileWriteService):
@staticmethod
def write(obj, obj_location, extended_encoder=None):
super(JSONWriteService, JSONWriteService).write(JSONCoder.encode(obj, extended_encoder), ... | [
"service.json.JSONCoder.JSONCoder.encode"
] | [((279, 318), 'service.json.JSONCoder.JSONCoder.encode', 'JSONCoder.encode', (['obj', 'extended_encoder'], {}), '(obj, extended_encoder)\n', (295, 318), False, 'from service.json.JSONCoder import JSONCoder\n')] |
#! /usr/bin/env python3
"""Makes character_property_map.txt for tetengo::text
Copyright (C) 2019-2022 kaoru https://www.tetengo.org/
"""
import pathlib
import re
import sys
from typing import List, Optional
def main(args: List[str]) -> None:
"""The main function.
Args:
args (list[str]): Progra... | [
"pathlib.Path",
"re.match",
"sys.exit"
] | [((565, 576), 'sys.exit', 'sys.exit', (['(0)'], {}), '(0)\n', (573, 576), False, 'import sys\n'), ((626, 647), 'pathlib.Path', 'pathlib.Path', (['args[0]'], {}), '(args[0])\n', (638, 647), False, 'import pathlib\n'), ((697, 718), 'pathlib.Path', 'pathlib.Path', (['args[1]'], {}), '(args[1])\n', (709, 718), False, 'impo... |
from app import db
from models.base import BaseMixin
class VoteType(object):
UP = 1
DOWN = 2
class ArticleVote(db.Model, BaseMixin):
__tablename__ = 'article_votes'
voter_id = db.Column(db.Integer, db.ForeignKey('users.id'))
article_id = db.Column(db.Integer, db.ForeignKey('articles.id'))
ty... | [
"app.db.ForeignKey",
"app.db.Column"
] | [((325, 346), 'app.db.Column', 'db.Column', (['db.Integer'], {}), '(db.Integer)\n', (334, 346), False, 'from app import db\n'), ((218, 243), 'app.db.ForeignKey', 'db.ForeignKey', (['"""users.id"""'], {}), "('users.id')\n", (231, 243), False, 'from app import db\n'), ((284, 312), 'app.db.ForeignKey', 'db.ForeignKey', ([... |
"""Tarball creation with data filter.
"""
import sys
import io
import os
import tarfile
import time
import stat
__all__ = ['TarBall']
# mode for normal files
TAR_FILE_MODE = stat.S_IRUSR | stat.S_IWUSR | stat.S_IRGRP | stat.S_IROTH
# mode for directories
TAR_DIR_MODE = stat.S_IRWXU | stat.S_IRGRP | stat.S_IXGRP | s... | [
"io.BytesIO",
"os.walk",
"tarfile.TarInfo",
"time.time",
"sys.stdout.flush",
"tarfile.open",
"os.path.join",
"os.lstat"
] | [((3016, 3034), 'sys.stdout.flush', 'sys.stdout.flush', ([], {}), '()\n', (3032, 3034), False, 'import sys\n'), ((473, 485), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (483, 485), False, 'import io\n'), ((504, 572), 'tarfile.open', 'tarfile.open', (['"""buf.tgz"""', '"""w|gz"""', 'self.buf'], {'format': 'tarfile.PAX... |
#!/usr/bin/env python
from __future__ import print_function
import argparse
import functools
import imghdr
import sys
import time
from random import randint
import cv2 as cv
import numpy as np
def strtime(millsec, form="%i:%02i:%06.3f"):
"""
Time formating function
Args:
millsec(int): Number o... | [
"numpy.abs",
"argparse.ArgumentParser",
"cv2.bitwise_and",
"cv2.medianBlur",
"cv2.getPerspectiveTransform",
"cv2.arcLength",
"cv2.approxPolyDP",
"numpy.argmax",
"numpy.ones",
"numpy.argmin",
"cv2.floodFill",
"cv2.rectangle",
"cv2.absdiff",
"cv2.imshow",
"cv2.inRange",
"cv2.warpPerspect... | [((1006, 1027), 'functools.wraps', 'functools.wraps', (['func'], {}), '(func)\n', (1021, 1027), False, 'import functools\n'), ((33858, 33899), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': 'desc'}), '(description=desc)\n', (33881, 33899), False, 'import argparse\n'), ((1083, 1094), 'time.ti... |
import json
import os
import boto3
import logging
from time import gmtime, strftime
logger = logging.getLogger(__name__)
logging.root.setLevel(os.environ.get("LOG_LEVEL", "INFO"))
# configuration settings
SM_PIPELINE_NAME = os.environ.get("SM_PIPELINE_NAME", "")
s3 = boto3.resource('s3')
sm = boto3.client('sagemaker... | [
"boto3.client",
"time.gmtime",
"os.environ.get",
"boto3.resource",
"logging.getLogger"
] | [((94, 121), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (111, 121), False, 'import logging\n'), ((226, 264), 'os.environ.get', 'os.environ.get', (['"""SM_PIPELINE_NAME"""', '""""""'], {}), "('SM_PIPELINE_NAME', '')\n", (240, 264), False, 'import os\n'), ((271, 291), 'boto3.resource', ... |
import pandas as pd
import numpy as np
from melusine.prepare_email.body_header_extraction import extract_last_body
from melusine.prepare_email.body_header_extraction import extract_body
from melusine.prepare_email.body_header_extraction import extract_header
structured_body = [
{
"meta": {"date": None, "f... | [
"pandas.DataFrame",
"melusine.prepare_email.body_header_extraction.extract_body",
"melusine.prepare_email.body_header_extraction.extract_header",
"numpy.testing.assert_string_equal",
"pandas.Series",
"pandas.testing.assert_series_equal"
] | [((1557, 1609), 'pandas.DataFrame', 'pd.DataFrame', (["{'structured_body': [structured_body]}"], {}), "({'structured_body': [structured_body]})\n", (1569, 1609), True, 'import pandas as pd\n'), ((1627, 1676), 'pandas.Series', 'pd.Series', (["['Je vous remercie pour le document ']"], {}), "(['Je vous remercie pour le do... |
import smart_imports
smart_imports.all()
class GeneratorTests(utils_testcase.TestCase):
def setUp(self):
super(GeneratorTests, self).setUp()
self.place_1, self.place_2, self.place_3 = game_logic.create_test_map()
def test_ui_cell_serialization(self):
world_info = prototypes.WorldIn... | [
"smart_imports.all"
] | [((23, 42), 'smart_imports.all', 'smart_imports.all', ([], {}), '()\n', (40, 42), False, 'import smart_imports\n')] |
# enumeration support
from enum import Enum
import sys, pygame, random
pygame.init()
sysFont = pygame.font.SysFont(None, 36)
screenWidth = 800
screenHeight = 600
screenSize = (screenWidth, screenHeight)
# level and timing
# some information referenced from https://www.colinfahey.com/tetris/tetris.htm... | [
"pygame.quit",
"random.randint",
"pygame.font.SysFont",
"pygame.draw.rect",
"pygame.display.set_mode",
"pygame.event.get",
"pygame.Rect",
"pygame.init",
"pygame.display.flip",
"pygame.time.wait",
"pygame.transform.scale",
"pygame.image.load",
"pygame.time.get_ticks",
"sys.exit"
] | [((78, 91), 'pygame.init', 'pygame.init', ([], {}), '()\n', (89, 91), False, 'import sys, pygame, random\n'), ((105, 134), 'pygame.font.SysFont', 'pygame.font.SysFont', (['None', '(36)'], {}), '(None, 36)\n', (124, 134), False, 'import sys, pygame, random\n'), ((652, 695), 'pygame.image.load', 'pygame.image.load', (['"... |
# Copyright 2021 Huawei Technologies Co., Ltd
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to... | [
"os.mkdir",
"src.config.config.logger.info",
"src.config.config.logger.save_args",
"numpy.load",
"numpy.argmax",
"mindspore.ops.operations.Cast",
"mindspore.Tensor",
"numpy.argsort",
"src.utils.var_init.load_pretrain_model",
"src.utils.logging.get_logger",
"src.model_utils.moxing_adapter.moxing_... | [((4820, 4836), 'src.model_utils.moxing_adapter.moxing_wrapper', 'moxing_wrapper', ([], {}), '()\n', (4834, 4836), False, 'from src.model_utils.moxing_adapter import moxing_wrapper\n'), ((2158, 2201), 'src.utils.logging.get_logger', 'get_logger', (['config.outputs_dir', 'config.rank'], {}), '(config.outputs_dir, config... |
import api.bm as models
import re
from django.contrib import messages
from django.db import transaction
from django.http import HttpResponseRedirect
from django.shortcuts import render_to_response, get_object_or_404
from django.template import RequestContext
@transaction.atomic
def copy_config(request):
tpl = 'a... | [
"api.bm.Server.objects.all",
"api.bm.Conf.objects.filter",
"django.contrib.messages.get_messages",
"api.bm.User.objects.get",
"django.contrib.messages.error",
"re.match",
"api.bm.Install.objects.filter",
"api.bm.Db.objects.get",
"django.shortcuts.get_object_or_404",
"api.bm.Conf",
"django.contri... | [((368, 395), 'api.bm.Server.objects.all', 'models.Server.objects.all', ([], {}), '()\n', (393, 395), True, 'import api.bm as models\n'), ((1896, 1942), 'django.shortcuts.get_object_or_404', 'get_object_or_404', (['models.Server'], {'id': 'server_id'}), '(models.Server, id=server_id)\n', (1913, 1942), False, 'from djan... |
from django.test import TestCase
from dj_chartjs.charts import BarChart
class ContextTestCase(TestCase):
def test_barchart_context(self):
barchart = BarChart()
barchart.title = "Test title chart"
labels = ["test1", "test2", "test3", "test4"]
data = [5, 18, 6, 20]
context =... | [
"dj_chartjs.charts.BarChart"
] | [((164, 174), 'dj_chartjs.charts.BarChart', 'BarChart', ([], {}), '()\n', (172, 174), False, 'from dj_chartjs.charts import BarChart\n')] |
# This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without eve... | [
"buildbot.data.types.Integer",
"copy.deepcopy",
"twisted.internet.defer.returnValue",
"buildbot.process.metrics.MetricCountEvent.log",
"buildbot.data.types.SourcedProperties",
"future.utils.text_type",
"buildbot.util.epoch2datetime",
"buildbot.process.users.users.createUserObject",
"buildbot.util.da... | [((1654, 1679), 'twisted.internet.defer.returnValue', 'defer.returnValue', (['change'], {}), '(change)\n', (1671, 1679), False, 'from twisted.internet import defer\n'), ((3206, 3232), 'twisted.internet.defer.returnValue', 'defer.returnValue', (['results'], {}), '(results)\n', (3223, 3232), False, 'from twisted.internet... |
import setuptools
with open("readme.rst", "r") as fh:
long_description = fh.read()
setuptools.setup(
name="storystructure",
version="1.0.2",
author="<NAME>",
author_email="<EMAIL>",
description="Tools for analysing the structure of branching stories",
long_description=long_description,
... | [
"setuptools.find_packages"
] | [((431, 457), 'setuptools.find_packages', 'setuptools.find_packages', ([], {}), '()\n', (455, 457), False, 'import setuptools\n')] |
import logging
from homeassistant.core import (
HomeAssistant,
callback,
)
from homeassistant.const import (
CONF_SERVICE,
ATTR_SERVICE_DATA,
CONF_SERVICE_DATA,
CONF_DELAY,
ATTR_ENTITY_ID,
STATE_UNKNOWN,
STATE_UNAVAILABLE,
CONF_CONDITIONS,
)
from homeassistant.components.climat... | [
"homeassistant.helpers.service.async_call_from_config",
"homeassistant.helpers.event.async_call_later",
"homeassistant.helpers.dispatcher.async_dispatcher_connect",
"homeassistant.helpers.event.async_track_state_change",
"logging.getLogger"
] | [((757, 784), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (774, 784), False, 'import logging\n'), ((5125, 5212), 'homeassistant.helpers.dispatcher.async_dispatcher_connect', 'async_dispatcher_connect', (['self.hass', 'const.EVENT_STARTED', 'self.async_process_queue'], {}), '(self.hass,... |
from __future__ import absolute_import
import re
from typing import (
Dict,
Text,
)
import yaml
from yaml import FullLoader
from appyratus.enum import Enum
from .file import (
File,
FileObject,
)
EXTENSIONS = Enum.of_strings('yml', 'yaml')
class Yaml(File):
"""
# Yaml
Yaml file type
... | [
"yaml.load",
"yaml.dump_all",
"yaml.load_all",
"appyratus.enum.Enum.of_strings",
"re.match",
"yaml.dump"
] | [((230, 260), 'appyratus.enum.Enum.of_strings', 'Enum.of_strings', (['"""yml"""', '"""yaml"""'], {}), "('yml', 'yaml')\n", (245, 260), False, 'from appyratus.enum import Enum\n'), ((1643, 1675), 'yaml.load_all', 'yaml.load_all', (['data'], {}), '(data, **load_args)\n', (1656, 1675), False, 'import yaml\n'), ((1787, 181... |
"""
Search command category:
$search {insert query}
TODO:
- Make the search process more robust: mispelled words ie
'hello word' displays similar results to 'hello world'
"""
import json
import pandas as pd
import discord
from discord import Embed
from discord.ext import commands
from src import sea... | [
"src.searcher.Searcher",
"json.load",
"discord.ext.commands.command",
"discord.Embed"
] | [((543, 555), 'json.load', 'json.load', (['j'], {}), '(j)\n', (552, 555), False, 'import json\n'), ((611, 623), 'json.load', 'json.load', (['j'], {}), '(j)\n', (620, 623), False, 'import json\n'), ((1033, 1064), 'discord.ext.commands.command', 'commands.command', ([], {'name': '"""avatar"""'}), "(name='avatar')\n", (10... |
#!/usr/bin/env python
import sys
import argparse
ap = argparse.ArgumentParser(description="Filter heterozygous positions.\nOutput starts at 1.")
ap.add_argument("minCount", help="Minimum count. Remove rows below this.", type=int)
ap.add_argument("--minTotal", help="Only consider rows where the minimum coverage is abo... | [
"sys.stdout.write",
"sys.stdin.readline",
"argparse.ArgumentParser"
] | [((56, 154), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Filter heterozygous positions.\nOutput starts at 1."""'}), '(description=\n """Filter heterozygous positions.\nOutput starts at 1.""")\n', (79, 154), False, 'import argparse\n'), ((614, 634), 'sys.stdin.readline', 'sys.stdin.... |
from itertools import chain
from typing import Any
from typing import Callable
from typing import Dict
from typing import List
from typing import Optional
from typing import Text
from typing import Union
from pypinyin.constants import PHRASES_DICT
from pypinyin.constants import PINYIN_DICT
from pypinyin.constants impo... | [
"pypinyin.constants.PHRASES_DICT.update",
"pypinyin.utils._replace_tone2_style_dict_to_default",
"pypinyin.converter.DefaultConverter",
"pypinyin.converter._mixConverter",
"pypinyin.constants.PINYIN_DICT.update",
"jieba.lcut",
"pypinyin.seg.mmseg.retrain"
] | [((6085, 6103), 'pypinyin.converter.DefaultConverter', 'DefaultConverter', ([], {}), '()\n', (6101, 6103), False, 'from pypinyin.converter import DefaultConverter\n'), ((1162, 1186), 'pypinyin.seg.mmseg.retrain', 'mmseg.retrain', (['mmseg.seg'], {}), '(mmseg.seg)\n', (1175, 1186), False, 'from pypinyin.seg import mmseg... |
from datetime import datetime
from django.utils import timezone
from django.contrib import messages
from habari.apps.utils.string_utils import unslugify_text
from habari.apps.crawl.models import Article, NewsSource
from django.contrib.auth.decorators import login_required
from django.shortcuts import render, get_object... | [
"habari.apps.crawl.models.NewsSource.objects.order_by",
"rest_framework.authtoken.models.Token.objects.get",
"rest_framework.authtoken.models.Token.objects.create",
"django.shortcuts.redirect",
"django.utils.timezone.now",
"django.contrib.messages.error",
"habari.apps.crawl.models.Article.objects.filter... | [((559, 592), 'habari.apps.crawl.models.NewsSource.objects.order_by', 'NewsSource.objects.order_by', (['"""pk"""'], {}), "('pk')\n", (586, 592), False, 'from habari.apps.crawl.models import Article, NewsSource\n'), ((601, 657), 'django.shortcuts.render', 'render', (['request', '"""core/index.html"""', "{'sources': sour... |
import collections
from mnm.instances.influxdb_client import get_client
class Stat(object):
def get(self, **kwargs):
raise NotImplementedError
def get_results(self, query):
return get_client().query(query)
class InstanceFieldStat(Stat):
query = """
SELECT sum("{field}")
... | [
"collections.OrderedDict",
"mnm.instances.influxdb_client.get_client"
] | [((1129, 1154), 'collections.OrderedDict', 'collections.OrderedDict', ([], {}), '()\n', (1152, 1154), False, 'import collections\n'), ((208, 220), 'mnm.instances.influxdb_client.get_client', 'get_client', ([], {}), '()\n', (218, 220), False, 'from mnm.instances.influxdb_client import get_client\n')] |
import re
from datetime import datetime, timedelta
from typing import Union, Optional, List
from django.core.exceptions import ObjectDoesNotExist
from django.db.models import F, ExpressionWrapper, DateTimeField
from django.utils import timezone
from rest_framework import serializers
from rest_framework.settings import... | [
"admin.models.Lecture.objects.annotate",
"admin.models.Attendance.objects.create",
"admin.models.Lecture.objects.create",
"admin.models.AttendanceState.objects.values",
"django.utils.timezone.localtime",
"re.match",
"django.db.models.F",
"datetime.timedelta",
"django.db.models.DateTimeField",
"adm... | [((2002, 2034), 'django.utils.timezone.localtime', 'timezone.localtime', (['datetime_obj'], {}), '(datetime_obj)\n', (2020, 2034), False, 'from django.utils import timezone\n'), ((6549, 6590), 'admin.models.AttendanceState.objects.get', 'AttendanceState.objects.get', ([], {'default': '(True)'}), '(default=True)\n', (65... |
import tensorflow as tf
import os
import glob
import vng_model as md
import numpy as np
import csv
FLAGS = tf.app.flags.FLAGS
tf.app.flags.DEFINE_string('checkpoint_dir', '',
"""Direction where the trained weights of model is save""")
tf.app.flags.DEFINE_string('eval_data_path', '',
... | [
"tensorflow.train.Coordinator",
"tensorflow.get_collection",
"tensorflow.train.batch",
"tensorflow.app.flags.DEFINE_integer",
"os.path.join",
"tensorflow.train.start_queue_runners",
"tensorflow.placeholder",
"tensorflow.squeeze",
"tensorflow.train.string_input_producer",
"tensorflow.train.get_chec... | [((128, 236), 'tensorflow.app.flags.DEFINE_string', 'tf.app.flags.DEFINE_string', (['"""checkpoint_dir"""', '""""""', '"""Direction where the trained weights of model is save"""'], {}), "('checkpoint_dir', '',\n 'Direction where the trained weights of model is save')\n", (154, 236), True, 'import tensorflow as tf\n'... |
import datetime
class BotTwitter:
def __init__ (self):
self.cuentas = ["ivan","erick","diego","carlos"]
self.temas = ["#bitcoin","#elonmusk","#pitbulls"]
self.fechaInicial = datetime.datetime.now()
a = BotTwitter ()
b = BotTwitter ()
print(a.cuentas)
print(b.temas)
print(datet... | [
"datetime.datetime.now"
] | [((315, 338), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (336, 338), False, 'import datetime\n'), ((216, 239), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (237, 239), False, 'import datetime\n')] |
import re
import csv
import pandas as pd
import sys
maxInt = sys.maxsize
while True:
# decrease the maxInt value by factor 10
# as long as the OverflowError occurs.
try:
csv.field_size_limit(maxInt)
break
except OverflowError:
maxInt = int(maxInt/10)
def remove_headers(text):
... | [
"csv.reader",
"csv.writer",
"pandas.read_csv",
"csv.field_size_limit",
"re.search",
"re.compile"
] | [((512, 690), 're.compile', 're.compile', (["('^\\\\s{0,20}(Email:|Message-ID:|Date:|From:|To:|Sent|Sent by|' +\n 'Mime-Version:|Content-Type:' +\n '|Content-Transfer-Encoding:|X-|cc|-{4}-+|AM -{4}-+|_{4}_+).*')"], {}), "('^\\\\s{0,20}(Email:|Message-ID:|Date:|From:|To:|Sent|Sent by|' +\n 'Mime-Version:|Conten... |
#!/usr/bin/env python
import numpy as np # scientific computing lib
import sounddevice as sd # sounddevice / hostapi handling
import sys # used for printing err to std stream
import matplotlib.pyplot as plt # plots and graphs
import os ... | [
"matplotlib.pyplot.title",
"PyQt5.QtWidgets.QApplication.palette",
"PyQt5.QtWidgets.QGridLayout",
"PyQt5.QtWidgets.QPushButton",
"scipy.io.wavfile.read",
"numpy.arange",
"PyQt5.QtWidgets.QApplication",
"PyQt5.QtWidgets.QApplication.setAttribute",
"PyQt5.QtWidgets.QTabWidget",
"os.path.join",
"py... | [((1407, 1483), 'PyQt5.QtWidgets.QApplication.setAttribute', 'QtWidgets.QApplication.setAttribute', (['QtCore.Qt.AA_EnableHighDpiScaling', '(True)'], {}), '(QtCore.Qt.AA_EnableHighDpiScaling, True)\n', (1442, 1483), False, 'from PyQt5 import QtWidgets\n'), ((1504, 1577), 'PyQt5.QtWidgets.QApplication.setAttribute', 'Qt... |
# Generated by Django 2.2.13 on 2021-06-16 07:34
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('projects', '0111_auto_20210610_1427'),
]
operations = [
migrations.AddField(
model_name='documenttemplate',
name='i... | [
"django.db.models.BooleanField"
] | [((354, 419), 'django.db.models.BooleanField', 'models.BooleanField', ([], {'default': '(False)', 'verbose_name': '"""image template"""'}), "(default=False, verbose_name='image template')\n", (373, 419), False, 'from django.db import migrations, models\n')] |
# -*- coding: utf-8 -*-
# Define here the models for your scraped items
#
# See documentation in:
# https://docs.scrapy.org/en/latest/topics/items.html
import scrapy
from scrapy.loader.processors import TakeFirst, Join
class NewsScrapeItem(scrapy.Item):
# define the fields for your item here like:
headline ... | [
"scrapy.loader.processors.TakeFirst",
"scrapy.Field",
"scrapy.loader.processors.Join"
] | [((491, 505), 'scrapy.Field', 'scrapy.Field', ([], {}), '()\n', (503, 505), False, 'import scrapy\n'), ((801, 815), 'scrapy.Field', 'scrapy.Field', ([], {}), '()\n', (813, 815), False, 'import scrapy\n'), ((352, 363), 'scrapy.loader.processors.TakeFirst', 'TakeFirst', ([], {}), '()\n', (361, 363), False, 'from scrapy.l... |
import re
class Db:
@classmethod
def fetchall_dict(cls, cursor):
"""
Convert fetchall result into a dictionary(column: row_value) instead of list of tuples.
"""
desc = cursor.description
return [dict(zip([col[0] for col in desc], row)) for row in cursor.fetchall()]
... | [
"re.compile"
] | [((919, 977), 're.compile', 're.compile', (['"""^SELECT (.+) FROM"""', '(re.IGNORECASE | re.DOTALL)'], {}), "('^SELECT (.+) FROM', re.IGNORECASE | re.DOTALL)\n", (929, 977), False, 'import re\n')] |
import os, sys
from flask import Flask
from flask.ext.sqlalchemy import SQLAlchemy
app = Flask(__name__)
app.config.from_pyfile('../doc/booster.cfg.default')
app.config.from_pyfile('../booster.cfg', silent=True)
db = SQLAlchemy(app)
from booster.stuff import *
import booster.views
import booster.models
from booster... | [
"flask.ext.sqlalchemy.SQLAlchemy",
"flask.Flask"
] | [((90, 105), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (95, 105), False, 'from flask import Flask\n'), ((220, 235), 'flask.ext.sqlalchemy.SQLAlchemy', 'SQLAlchemy', (['app'], {}), '(app)\n', (230, 235), False, 'from flask.ext.sqlalchemy import SQLAlchemy\n')] |
import pickle
from compile_data import data_format
# print out the model coeficients along with which data they are for
def coefs(model_file):
with open(model_file, 'rb') as mf:
clf = pickle.load(mf)
for i, name in enumerate(data_format[1:]):
print('{}: {}'.format(name, clf.coef_[0][i]))
| [
"pickle.load"
] | [((198, 213), 'pickle.load', 'pickle.load', (['mf'], {}), '(mf)\n', (209, 213), False, 'import pickle\n')] |
# Copyright (c) 2014 ITOCHU Techno-Solutions Corporation.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required... | [
"rackclient.exceptions.CommandError",
"os.environ.get",
"rackclient.client.Client",
"ConfigParser.ConfigParser",
"rackclient.utils.keyvalue_to_dict"
] | [((8699, 8713), 'ConfigParser.ConfigParser', 'ConfigParser', ([], {}), '()\n', (8711, 8713), False, 'from ConfigParser import ConfigParser\n'), ((2119, 2222), 'rackclient.client.Client', 'client.Client', (['app_args.rack_api_version'], {'rack_url': 'app_args.rack_url', 'http_log_debug': 'app_args.debug'}), '(app_args.r... |
from __future__ import print_function
import itertools
import os
import random
import sys
import threading as thread
from typing import Callable
import gym
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import yaml
from lunar_lander_models import Luna... | [
"gym.make"
] | [((1638, 1674), 'gym.make', 'gym.make', (['"""LunarLanderContinuous-v2"""'], {}), "('LunarLanderContinuous-v2')\n", (1646, 1674), False, 'import gym\n')] |
# DDPG can be view as a special case of TD3
from hmlf.algorithms.td3.policies import CnnPolicy, MlpPolicy # noqa:F401
from hmlf.common.policy_register import register_policy
register_policy("DDPG", "MlpPolicy", MlpPolicy)
register_policy("DDPG", "CnnPolicy", CnnPolicy)
| [
"hmlf.common.policy_register.register_policy"
] | [((176, 223), 'hmlf.common.policy_register.register_policy', 'register_policy', (['"""DDPG"""', '"""MlpPolicy"""', 'MlpPolicy'], {}), "('DDPG', 'MlpPolicy', MlpPolicy)\n", (191, 223), False, 'from hmlf.common.policy_register import register_policy\n'), ((224, 271), 'hmlf.common.policy_register.register_policy', 'regist... |
# Django settings for test_project project.
import os
PROJECT_ROOT = os.path.abspath(os.path.dirname(__file__))
DEBUG = True
TEMPLATE_DEBUG = DEBUG
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': 'test.db',
},
}
# Make this unique, and don't share it with anybody.
... | [
"os.path.dirname",
"os.path.join"
] | [((86, 111), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (101, 111), False, 'import os\n'), ((1081, 1120), 'os.path.join', 'os.path.join', (['PROJECT_ROOT', '"""templates"""'], {}), "(PROJECT_ROOT, 'templates')\n", (1093, 1120), False, 'import os\n')] |
import re
import socket
import pytest
from random import randrange
try:
from server.mail_server import MailServer
except (ModuleNotFoundError, ImportError) as e:
import sys
import os
sys.path.append(os.path.dirname(__file__))
sys.path.append(os.path.dirname(os.path.dirname(__file__)))
from mail... | [
"mail_server.MailServer",
"os.path.dirname",
"random.randrange",
"socket.create_connection"
] | [((412, 435), 'random.randrange', 'randrange', (['(16000)', '(40000)'], {}), '(16000, 40000)\n', (421, 435), False, 'from random import randrange\n'), ((445, 466), 'mail_server.MailServer', 'MailServer', ([], {'port': 'PORT'}), '(port=PORT)\n', (455, 466), False, 'from mail_server import MailServer\n'), ((536, 590), 's... |
import os
import time
import paddle
from valid import validation
from data import prep_dataset, prep_loader
from utils import same_seeds, save_model, \
ReduceOnPlateauWithAnnael, NMTMetric, get_logger, get_grad_norm
from models import build_model
import paddle.distributed as dist
from paddlenlp.transformer... | [
"paddle.amp.GradScaler",
"paddle.load",
"utils.save_model",
"data.prep_loader",
"utils.same_seeds",
"os.path.isfile",
"config.get_config",
"data.prep_dataset",
"os.path.join",
"paddlenlp.transformers.CrossEntropyCriterion",
"utils.get_logger",
"paddle.optimizer.lr.CosineAnnealingDecay",
"pad... | [((1633, 1668), 'paddle.distributed.get_world_size', 'paddle.distributed.get_world_size', ([], {}), '()\n', (1666, 1668), False, 'import paddle\n'), ((1742, 1753), 'time.time', 'time.time', ([], {}), '()\n', (1751, 1753), False, 'import time\n'), ((6423, 6447), 'paddle.distributed.init_parallel_env', 'dist.init_paralle... |
import sys
import os
import errno
import gta.gxt
args = sys.argv[1:]
outDirName = os.path.splitext(args[0])[0]
def createOutputDir(path):
try:
os.makedirs( path )
except OSError as e:
if e.errno != errno.EEXIST:
raise
def readOutTable(gxt, reader, name):
createOutputDir(os.pa... | [
"os.makedirs",
"os.path.join",
"os.path.splitext"
] | [((83, 108), 'os.path.splitext', 'os.path.splitext', (['args[0]'], {}), '(args[0])\n', (99, 108), False, 'import os\n'), ((157, 174), 'os.makedirs', 'os.makedirs', (['path'], {}), '(path)\n', (168, 174), False, 'import os\n'), ((315, 345), 'os.path.join', 'os.path.join', (['outDirName', 'name'], {}), '(outDirName, name... |
# setup.py file
from setuptools import find_packages, setup
with open("README.md", "r") as fh:
long_description = fh.read()
setup(
name="my-lambdata-CurdtMillion3", # the name that you will install via pip
version="1.4",
author="<NAME>",
author_email="<EMAIL>",
description="My first attempt"... | [
"setuptools.find_packages"
] | [((557, 572), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (570, 572), False, 'from setuptools import find_packages, setup\n')] |
import torch
import inspect
from pprint import pprint
from bento_service import PytorchService
from model import TextClassificationModel
from train import get_model_params, get_tokenizer_vocab
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
tokenizer, vocab = get_tokenizer_vocab()
vocab_size... | [
"torch.load",
"bento_service.PytorchService",
"train.get_tokenizer_vocab",
"torch.cuda.is_available",
"train.get_model_params",
"model.TextClassificationModel"
] | [((288, 309), 'train.get_tokenizer_vocab', 'get_tokenizer_vocab', ([], {}), '()\n', (307, 309), False, 'from train import get_model_params, get_tokenizer_vocab\n'), ((342, 365), 'train.get_model_params', 'get_model_params', (['vocab'], {}), '(vocab)\n', (358, 365), False, 'from train import get_model_params, get_tokeni... |
__copyright__ = "Copyright (c) 2020 Jina AI Limited. All rights reserved."
__license__ = "Apache-2.0"
import os
import click
from jina.flow import Flow
RANDOM_SEED = 10 # 5
os.environ['PARALLEL'] = str(2)
os.environ['SHARDS'] = str(2)
def data_fn():
for i in os.listdir("data/fulltexts/"):
with open(f"... | [
"click.option",
"os.listdir",
"jina.flow.Flow",
"click.command"
] | [((426, 441), 'click.command', 'click.command', ([], {}), '()\n', (439, 441), False, 'import click\n'), ((443, 471), 'click.option', 'click.option', (['"""--task"""', '"""-t"""'], {}), "('--task', '-t')\n", (455, 471), False, 'import click\n'), ((473, 513), 'click.option', 'click.option', (['"""--top_k"""', '"""-k"""']... |
from scipy.spatial.distance import cdist
import numpy as np
class DBScan():
"""This is a simple implementation of clustering using the
DBScan algorithm.
My algorithm will return labels for clusters, -1 indicating
an outlier"""
def __init__(self, max_dist, min_pts):
self.data = None
... | [
"numpy.reshape"
] | [((1520, 1542), 'numpy.reshape', 'np.reshape', (['P', '(-1, 2)'], {}), '(P, (-1, 2))\n', (1530, 1542), True, 'import numpy as np\n'), ((1542, 1575), 'numpy.reshape', 'np.reshape', (['self.data[i]', '(-1, 2)'], {}), '(self.data[i], (-1, 2))\n', (1552, 1575), True, 'import numpy as np\n'), ((3100, 3133), 'numpy.reshape',... |
import os
import sys
import imp
import traceback
from .log import logger
from .module import Module
class ModuleManager(object):
def __init__(self):
self.modules = []
self.modules_directories_to_load = []
def add_module_directory_to_load(self, dirname, pack_name, pack_level):
... | [
"traceback.print_exc",
"imp.load_compiled",
"os.path.exists",
"sys.path.insert",
"imp.load_source",
"os.path.join",
"sys.exit"
] | [((748, 782), 'os.path.join', 'os.path.join', (['dirname', '"""module.py"""'], {}), "(dirname, 'module.py')\n", (760, 782), False, 'import os\n'), ((1105, 1132), 'sys.path.insert', 'sys.path.insert', (['(0)', 'dirname'], {}), '(0, dirname)\n', (1120, 1132), False, 'import sys\n'), ((802, 826), 'os.path.exists', 'os.pat... |
"""
Model definitions to representation the activitystreams for multiple sites.
"""
import datetime
from django.db import models
from django.db.models.query import Q
from django.template import Template, Context
from activitystreams.utils import PickleField
class Source(models.Model):
""" The site Source allows... | [
"django.db.models.TextField",
"django.db.models.CharField",
"django.db.models.ForeignKey",
"django.db.models.PositiveIntegerField",
"django.template.Context",
"django.db.models.SlugField",
"django.db.models.DateTimeField",
"django.template.Template",
"activitystreams.utils.PickleField"
] | [((390, 435), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(100)', 'unique': '(True)'}), '(max_length=100, unique=True)\n', (406, 435), False, 'from django.db import models\n'), ((519, 563), 'django.db.models.SlugField', 'models.SlugField', ([], {'max_length': '(50)', 'unique': '(True)'}), '(m... |
from django.views.decorators.http import require_safe
from django.shortcuts import get_object_or_404
from django.contrib.auth.models import User
from core.models import Person
from .utils import api_view, api_login_required
@require_safe
@api_view
@api_login_required
def api_person_view(request, username):
user... | [
"django.shortcuts.get_object_or_404"
] | [((323, 365), 'django.shortcuts.get_object_or_404', 'get_object_or_404', (['User'], {'username': 'username'}), '(User, username=username)\n', (340, 365), False, 'from django.shortcuts import get_object_or_404\n'), ((379, 415), 'django.shortcuts.get_object_or_404', 'get_object_or_404', (['Person'], {'user': 'user'}), '(... |
#!/usr/bin/env python3
"""Functional Python Programming
Chapter 10, Example Set 4
"""
# pylint: disable=wrong-import-position
from functools import reduce, partial
display = lambda data: reduce(lambda x, y: print(x, y), data)
sum2 = lambda data: reduce(lambda x, y: x+y**2, data, 0)
sum = lambda data: reduce(lambda x... | [
"functools.partial",
"sys.stdout.flush",
"timeit.timeit",
"functools.reduce",
"typing.TypeVar",
"doctest.testmod"
] | [((807, 820), 'typing.TypeVar', 'TypeVar', (['"""T_"""'], {}), "('T_')\n", (814, 820), False, 'from typing import Callable, Iterable, TypeVar\n'), ((2461, 2490), 'functools.partial', 'partial', (['reduce', 'operator.add'], {}), '(reduce, operator.add)\n', (2468, 2490), False, 'from functools import reduce, partial\n'),... |
from torch import nn
import torch
class upsample_transconv_relu_bn_block(nn.Module):
def __init__(self, in_channels, out_channels):
super(upsample_transconv_relu_bn_block, self).__init__()
self.seq= nn.Sequential(
nn.ConvTranspose2d(in_channels, out_channels, kernel_size= 4, pad... | [
"torch.nn.ReLU",
"torch.nn.ConvTranspose2d",
"torch.nn.Conv2d",
"torch.nn.BatchNorm2d",
"torch.nn.Linear"
] | [((255, 340), 'torch.nn.ConvTranspose2d', 'nn.ConvTranspose2d', (['in_channels', 'out_channels'], {'kernel_size': '(4)', 'padding': '(1)', 'stride': '(2)'}), '(in_channels, out_channels, kernel_size=4, padding=1,\n stride=2)\n', (273, 340), False, 'from torch import nn\n'), ((355, 364), 'torch.nn.ReLU', 'nn.ReLU', (... |
# Generated by Django 2.2.2 on 2019-07-31 12:36
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('great_international', '0061_merge_20190731_1124'),
]
operations = [
migrations.RemoveField(
model_name='investinternationalhomep... | [
"django.db.migrations.RemoveField",
"django.db.models.TextField"
] | [((248, 356), 'django.db.migrations.RemoveField', 'migrations.RemoveField', ([], {'model_name': '"""investinternationalhomepage"""', 'name': '"""capital_invest_section_content"""'}), "(model_name='investinternationalhomepage', name=\n 'capital_invest_section_content')\n", (270, 356), False, 'from django.db import mi... |
import argparse
import os
import json
from operator import index
from os.path import join
def train_line_parser():
# load default args from json
# parse settable args from terminal
parser = argparse.ArgumentParser(
add_help=True,
formatter_class=argparse.ArgumentDefaultsHelpFormatter
)... | [
"argparse.ArgumentParser",
"os.getcwd",
"os.walk",
"os.path.join",
"os.listdir"
] | [((204, 303), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'add_help': '(True)', 'formatter_class': 'argparse.ArgumentDefaultsHelpFormatter'}), '(add_help=True, formatter_class=argparse.\n ArgumentDefaultsHelpFormatter)\n', (227, 303), False, 'import argparse\n'), ((6481, 6580), 'argparse.ArgumentPars... |
#
# MIT License
#
# Copyright (c) 2018-2021 Wisconsin Autonomous
#
# See https://wa.wisc.edu
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitatio... | [
"importlib.import_module",
"os.path.realpath",
"os.path.dirname",
"os.path.splitext",
"inspect.stack"
] | [((1955, 1998), 'importlib.import_module', 'importlib.import_module', (['f"""{path}.{module}"""'], {}), "(f'{path}.{module}')\n", (1978, 1998), False, 'import importlib\n'), ((1301, 1325), 'os.path.splitext', 'os.path.splitext', (['f.name'], {}), '(f.name)\n', (1317, 1325), False, 'import os\n'), ((1490, 1514), 'os.pat... |
import telaUsuario
import datetime
class Livro():
def __init__(self):
self.nome = ""
self.emprestado = False
def set_nome(nome):
self.nome = nome
def insert(self, livro, livros):
livros.append(livro)
def remove(self, livro, livros):
livros.remove(livro)
class... | [
"datetime.datetime.now"
] | [((628, 651), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (649, 651), False, 'import datetime\n'), ((976, 999), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (997, 999), False, 'import datetime\n')] |
from hearthstone import cardxml
def test_cardxml_load():
cardid_db, _ = cardxml.load()
dbf_db, _ = cardxml.load_dbf()
assert cardid_db
assert dbf_db
for card_id, card in cardid_db.items():
assert dbf_db[card.dbf_id].id == card_id
for dbf_id, card in dbf_db.items():
assert cardid_db[card.id].dbf_id == dbf... | [
"hearthstone.cardxml.load",
"hearthstone.cardxml.load_dbf"
] | [((75, 89), 'hearthstone.cardxml.load', 'cardxml.load', ([], {}), '()\n', (87, 89), False, 'from hearthstone import cardxml\n'), ((103, 121), 'hearthstone.cardxml.load_dbf', 'cardxml.load_dbf', ([], {}), '()\n', (119, 121), False, 'from hearthstone import cardxml\n')] |
"""Example script for setting up and solving a thermal grid optimal operation problem."""
import numpy as np
import os
import pandas as pd
import pyomo.environ as pyo
import fledge.config
import fledge.database_interface
import fledge.der_models
import fledge.thermal_grid_models
import fledge.utils
def main():
... | [
"os.mkdir",
"pyomo.environ.ConcreteModel",
"os.path.join",
"pyomo.environ.SolverFactory"
] | [((407, 516), 'os.path.join', 'os.path.join', (['fledge.config.results_path', 'f"""run_thermal_grid_optimal_operation_{fledge.config.timestamp}"""'], {}), "(fledge.config.results_path,\n f'run_thermal_grid_optimal_operation_{fledge.config.timestamp}')\n", (419, 516), False, 'import os\n'), ((595, 617), 'os.mkdir', '... |
from pathlib import Path
import random
from typing import Optional
import numpy as np
import ase
from ase.utils.ff import Morse, Angle, Dihedral, VdW
from ase.calculators.ff import ForceField
from ase.optimize.precon import FF, PreconLBFGS
from ase.optimize.precon.neighbors import get_neighbours
from rdkit import Ch... | [
"random.randint",
"numpy.deg2rad",
"ase.optimize.precon.neighbors.get_neighbours",
"ase.optimize.precon.PreconLBFGS",
"rdkit.Chem.AllChem.MMFFGetMoleculeForceField",
"ase.Atom",
"ase.utils.ff.Dihedral",
"ase.calculators.ff.ForceField",
"pathlib.Path",
"ase.utils.ff.Morse",
"ase.optimize.precon.F... | [((1718, 1729), 'ase.Atoms', 'ase.Atoms', ([], {}), '()\n', (1727, 1729), False, 'import ase\n'), ((1970, 1996), 'rdkit.Chem.MolFromSmiles', 'Chem.MolFromSmiles', (['smiles'], {}), '(smiles)\n', (1988, 1996), False, 'from rdkit import Chem\n'), ((2007, 2022), 'rdkit.Chem.AddHs', 'Chem.AddHs', (['mol'], {}), '(mol)\n', ... |
from enum import unique
import mongoengine as db
import json
import re
from flask import jsonify
import os
import sys
def ensure_pythonhashseed(seed=1234):
current_seed = os.environ.get("PYTHONHASHSEED")
seed = str(seed)
if current_seed is None or current_seed != seed:
print(f'Setting PYTHONHASHSEED... | [
"os.environ.get",
"flask.jsonify",
"mongoengine.IntField",
"mongoengine.LongField",
"mongoengine.StringField"
] | [((175, 207), 'os.environ.get', 'os.environ.get', (['"""PYTHONHASHSEED"""'], {}), "('PYTHONHASHSEED')\n", (189, 207), False, 'import os\n'), ((518, 532), 'mongoengine.LongField', 'db.LongField', ([], {}), '()\n', (530, 532), True, 'import mongoengine as db\n'), ((548, 564), 'mongoengine.StringField', 'db.StringField', ... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
目标持仓调整功能
证券和期货兼容
"""
import shelve
import copy
import os
from time import sleep
from xapi import *
from xapi.XStruct import *
from xapi.utils import *
from xapi.symbol import *
class MyXSpi(XSpi):
"""
继承XSpi可以实现回调方法的各种功能
"""
def __init__(self, root_d... | [
"shelve.open",
"os.path.join",
"time.sleep",
"copy.copy"
] | [((825, 875), 'os.path.join', 'os.path.join', (['self.root_dir', '"""target_position.csv"""'], {}), "(self.root_dir, 'target_position.csv')\n", (837, 875), False, 'import os\n'), ((910, 958), 'os.path.join', 'os.path.join', (['self.root_dir', '"""target_orders.csv"""'], {}), "(self.root_dir, 'target_orders.csv')\n", (9... |
import requests
import json
from boto3.dynamodb.conditions import Key
"""
Integration tests against the bond registry api. These tests execute
against docker containers.
Fixtures to start containers, build the dynamodb table and populate it
with test data are in conftest.py.
"""
def test_health(api_url, table):
... | [
"boto3.dynamodb.conditions.Key",
"requests.delete",
"requests.get",
"json.dumps"
] | [((459, 505), 'requests.get', 'requests.get', (['f"""http://{api_url}/health_check"""'], {}), "(f'http://{api_url}/health_check')\n", (471, 505), False, 'import requests\n'), ((9879, 9942), 'requests.delete', 'requests.delete', (['f"""http://{api_url}/bonds/bar345/subscribers/a"""'], {}), "(f'http://{api_url}/bonds/bar... |
import plotly.express as px
def main():
jahr = [2015, 2016, 2017, 2018, 2019, 2021]
loc = [1500, 3500, 12000, 9000, 10000, 4000]
fig = px.bar(x=jahr, y=loc)
fig.show()
if __name__ == "__main__":
main() | [
"plotly.express.bar"
] | [((150, 171), 'plotly.express.bar', 'px.bar', ([], {'x': 'jahr', 'y': 'loc'}), '(x=jahr, y=loc)\n', (156, 171), True, 'import plotly.express as px\n')] |
# Copyright (c) OpenMMLab. All rights reserved.
from functools import partial
from itertools import chain
from typing import Sequence
import torch
import torch.nn as nn
import torch.nn.functional as F
from mmcv.cnn.bricks import (NORM_LAYERS, DropPath, build_activation_layer,
build_norm_la... | [
"functools.partial",
"mmcv.cnn.bricks.DropPath",
"mmcv.cnn.bricks.build_activation_layer",
"torch.ones",
"torch.nn.ModuleList",
"torch.nn.Conv2d",
"mmcv.runner.base_module.ModuleList",
"mmcv.cnn.bricks.NORM_LAYERS.register_module",
"torch.nn.Identity",
"mmcv.cnn.bricks.build_norm_layer"
] | [((495, 530), 'mmcv.cnn.bricks.NORM_LAYERS.register_module', 'NORM_LAYERS.register_module', (['"""LN2d"""'], {}), "('LN2d')\n", (522, 530), False, 'from mmcv.cnn.bricks import NORM_LAYERS, DropPath, build_activation_layer, build_norm_layer\n'), ((3113, 3199), 'torch.nn.Conv2d', 'nn.Conv2d', (['in_channels', 'in_channel... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
In this script we find outlier traces based on their distance from outhers.
Every trace isbecomivng a vector which contain information both from the
structure and times. Then based on the k and r we found the outlyiers.
"""
import datetime
from pm4py.algo.filtering.l... | [
"sklearn.preprocessing.StandardScaler",
"mtree.MTree",
"datetime.timedelta",
"numpy.array",
"pm4py.algo.filtering.log.attributes.attributes_filter.get_attribute_values",
"os.listdir",
"pm4py.objects.log.importer.xes.factory.apply"
] | [((699, 762), 'pm4py.algo.filtering.log.attributes.attributes_filter.get_attribute_values', 'log_attributes_filter.get_attribute_values', (['log', '"""concept:name"""'], {}), "(log, 'concept:name')\n", (741, 762), True, 'from pm4py.algo.filtering.log.attributes import attributes_filter as log_attributes_filter\n'), ((4... |
#!/usr/bin/env python
"""
* *******************************************************
* Copyright (c) VMware, Inc. 2019. All Rights Reserved.
* SPDX-License-Identifier: MIT
* *******************************************************
*
* DISCLAIMER. THIS PROGRAM IS PROVIDED TO YOU "AS IS" WITHOUT
* WARRANTIES OR CONDITIONS... | [
"samples.vmc.helpers.sample_cli.parser.parse_args",
"com.vmware.nsx_policy_client_for_vmc.create_nsx_policy_client_for_vmc",
"pprint.pprint"
] | [((1054, 1073), 'samples.vmc.helpers.sample_cli.parser.parse_args', 'parser.parse_args', ([], {}), '()\n', (1071, 1073), False, 'from samples.vmc.helpers.sample_cli import parser\n'), ((1171, 1250), 'com.vmware.nsx_policy_client_for_vmc.create_nsx_policy_client_for_vmc', 'create_nsx_policy_client_for_vmc', (['args.refr... |
from django.db import models
from django.contrib.auth.models import User
# Create your models here.
class Hotel(models.Model):
address = models.CharField(max_length=50)
name = models.CharField(max_length=50)
capacity = models.IntegerField()
comfort = models.CharField(max_length=50)
def __str__(self):
return "{... | [
"django.db.models.CharField",
"django.db.models.IntegerField",
"django.db.models.ForeignKey",
"django.db.models.DateField"
] | [((139, 170), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(50)'}), '(max_length=50)\n', (155, 170), False, 'from django.db import models\n'), ((179, 210), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(50)'}), '(max_length=50)\n', (195, 210), False, 'from django.db im... |
from streams_explorer.core.k8s_app import K8sApp, K8sAppDeployment, K8sAppStatefulSet
from streams_explorer.core.k8s_config_parser import StreamsBootstrapArgsParser
from tests.utils import (
ConfigType,
get_streaming_app_deployment,
get_streaming_app_stateful_set,
)
class TestK8sApp:
def test_parse_en... | [
"streams_explorer.core.k8s_app.K8sApp.factory",
"tests.utils.get_streaming_app_stateful_set",
"tests.utils.get_streaming_app_deployment"
] | [((365, 498), 'tests.utils.get_streaming_app_deployment', 'get_streaming_app_deployment', ([], {'name': '"""test-app"""', 'input_topics': '"""input-topic"""', 'output_topic': '"""output-topic"""', 'error_topic': '"""error-topic"""'}), "(name='test-app', input_topics='input-topic',\n output_topic='output-topic', erro... |
# -*- coding: future_fstrings -*-
#
# Copyright 2019 <NAME> <<EMAIL>>
#
# This file is part of Salus
# (see https://github.com/SymbioticLab/Salus).
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the Lice... | [
"benchmarks.exps.maybe_forced_preset",
"benchmarks.driver.workload.WTL.create",
"inspect.currentframe"
] | [((1333, 1371), 'benchmarks.exps.maybe_forced_preset', 'maybe_forced_preset', (['presets.AllocProf'], {}), '(presets.AllocProf)\n', (1352, 1371), False, 'from benchmarks.exps import run_seq, maybe_forced_preset, run_tfdist, case_switch_main\n'), ((1410, 1435), 'benchmarks.driver.workload.WTL.create', 'WTL.create', (['m... |
# 3 - simple plot
"""
Please note, this script is for python3+.
If you are using python2+, please modify it accordingly.
"""
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-1, 1, 100)
y = 2*x + 1
plt.plot(x, y)
plt.show()
| [
"matplotlib.pyplot.show",
"matplotlib.pyplot.plot",
"numpy.linspace"
] | [((182, 205), 'numpy.linspace', 'np.linspace', (['(-1)', '(1)', '(100)'], {}), '(-1, 1, 100)\n', (193, 205), True, 'import numpy as np\n'), ((218, 232), 'matplotlib.pyplot.plot', 'plt.plot', (['x', 'y'], {}), '(x, y)\n', (226, 232), True, 'import matplotlib.pyplot as plt\n'), ((233, 243), 'matplotlib.pyplot.show', 'plt... |
from Bio import SeqIO
def extract_genes(gb_filename, output_filename):
genes = []
with open(gb_filename) as gb:
for sequence in SeqIO.parse(gb, "genbank"):
for feature in sequence.features:
if feature.type == 'gene':
genes.append(feature)
# for feat... | [
"Bio.SeqIO.parse"
] | [((146, 172), 'Bio.SeqIO.parse', 'SeqIO.parse', (['gb', '"""genbank"""'], {}), "(gb, 'genbank')\n", (157, 172), False, 'from Bio import SeqIO\n')] |
# Copyright 2015 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or a... | [
"tensorflow.python.framework.ops.RegisterShape"
] | [((1121, 1158), 'tensorflow.python.framework.ops.RegisterShape', 'ops.RegisterShape', (['"""SymbolicGradient"""'], {}), "('SymbolicGradient')\n", (1138, 1158), False, 'from tensorflow.python.framework import ops\n')] |
#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
Two-dimensional simulation code for buoyancy driven convection below an
evaporating salt lake. Allows for input of different simulation parameters
(see main.py -h for all available options) as well as different boundary
conditions.
This source code is subject to the term... | [
"numpy.fft.ifftshift",
"numpy.abs",
"os.makedirs",
"argparse.ArgumentParser",
"os.getcwd",
"numpy.fft.fft",
"os.path.exists",
"numpy.zeros",
"numpy.transpose",
"time.time",
"numpy.array",
"numpy.matmul",
"os.path.join",
"sys.exit"
] | [((2103, 2243), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '(\'Simulation of two-dimensional \' + \'porous media flow\' +\n """ \nCopyright (C) 2017 <NAME> & <NAME>""")'}), '(description=\'Simulation of two-dimensional \' +\n \'porous media flow\' + """ \nCopyright (C) 2017 <NAME> ... |
# -*- coding: utf-8 -*-
"""
test_celllab_cts.py: Unit-test function for CellLabCTS.
Created on Thu Jul 9 08:20:06 2015
@author: gtucker
"""
from nose.tools import assert_equal
from numpy.testing import assert_array_equal
from landlab import RasterModelGrid, HexModelGrid
from landlab.ca.celllab_cts import Transition... | [
"landlab.ca.oriented_raster_cts.OrientedRasterCTS",
"landlab.HexModelGrid",
"landlab.RasterModelGrid",
"landlab.ca.celllab_cts.Transition",
"heapq.heappush",
"numpy.testing.assert_array_equal",
"landlab.ca.oriented_hex_cts.OrientedHexCTS",
"nose.tools.assert_equal",
"heapq.heappop",
"numpy.arange"... | [((1258, 1356), 'landlab.ca.celllab_cts.Transition', 'Transition', (['(0, 0, 0)', '(1, 1, 0)', '(1.0)'], {'name': '"""test"""', 'swap_properties': '(False)', 'prop_update_fn': 'None'}), "((0, 0, 0), (1, 1, 0), 1.0, name='test', swap_properties=False,\n prop_update_fn=None)\n", (1268, 1356), False, 'from landlab.ca.c... |
import bpy
from bpy.props import (StringProperty,
BoolProperty,
IntProperty,
FloatProperty,
FloatVectorProperty,
EnumProperty,
PointerProperty,
)
... | [
"bpy.props.IntProperty",
"bpy.props.BoolProperty",
"bpy.props.FloatVectorProperty",
"bpy.props.PointerProperty",
"bpy.props.FloatProperty",
"bpy.utils.unregister_class",
"bpy.props.StringProperty",
"bpy.props.EnumProperty",
"bpy.utils.register_class"
] | [((452, 493), 'bpy.props.IntProperty', 'IntProperty', ([], {'name': '"""Edge Index"""', 'default': '(0)'}), "(name='Edge Index', default=0)\n", (463, 493), False, 'from bpy.props import StringProperty, BoolProperty, IntProperty, FloatProperty, FloatVectorProperty, EnumProperty, PointerProperty\n'), ((536, 588), 'bpy.pr... |
import os
import time
import random
import hashlib
import datetime
def produceId():
filePath = os.getcwd()
src = filePath + str(time.time())
m = hashlib.md5()
m.update(src.encode('utf-8'))
return m.hexdigest()
def getFormatDate(date=None, _format="%Y-%m-%d %H:%M:%S"):
if date is None:
... | [
"hashlib.md5",
"random.randint",
"os.getcwd",
"time.time",
"datetime.datetime.now"
] | [((101, 112), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (110, 112), False, 'import os\n'), ((159, 172), 'hashlib.md5', 'hashlib.md5', ([], {}), '()\n', (170, 172), False, 'import hashlib\n'), ((329, 352), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (350, 352), False, 'import datetime\n'), ((13... |
"""
File: 561.py
Title: Array Partition I
Difficulty: Easy
URL: https://leetcode.com/problems/array-partition-i/
"""
import unittest
from typing import List
class Solution:
def arrayPairSum(self, nums: List[int]) -> int:
sorted_nums = list(sorted(nums))
ans = 0
for i in ... | [
"unittest.main"
] | [((893, 908), 'unittest.main', 'unittest.main', ([], {}), '()\n', (906, 908), False, 'import unittest\n')] |
# Copyright 2016 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agree... | [
"endpoints_management.control.check_request.Aggregator",
"future.standard_library.install_aliases",
"endpoints_management.control.sc_messages.Operation",
"endpoints_management.control.check_request.Info",
"builtins.object",
"endpoints_management.control.sc_messages.CheckResponse",
"endpoints_management.... | [((669, 703), 'future.standard_library.install_aliases', 'standard_library.install_aliases', ([], {}), '()\n', (701, 703), False, 'from future import standard_library\n'), ((17669, 17687), 'operator.attrgetter', 'attrgetter', (['u"""key"""'], {}), "(u'key')\n", (17679, 17687), False, 'from operator import attrgetter\n'... |
"""Data types for model updates."""
from dataclasses import dataclass, field
from typing import Generic, Hashable, Optional, TypeVar
from fl_simulation.utils.types import ModelDiff, ControlVarDiff
T_wid = TypeVar("T_wid", bound=Hashable)
@dataclass
class ModelUpdate(Generic[T_wid]):
"""The class containing the... | [
"dataclasses.field",
"typing.TypeVar"
] | [((208, 240), 'typing.TypeVar', 'TypeVar', (['"""T_wid"""'], {'bound': 'Hashable'}), "('T_wid', bound=Hashable)\n", (215, 240), False, 'from typing import Generic, Hashable, Optional, TypeVar\n'), ((573, 604), 'dataclasses.field', 'field', ([], {'default': 'None', 'init': '(False)'}), '(default=None, init=False)\n', (5... |
from django.contrib.auth.models import User
from django.db import models
from django.utils.translation import gettext_lazy as _
from django_countries.fields import CountryField
from django.db import models
from gmmp.models import Monitor
class CustomManager(models.Manager):
def get_queryset(self):
return... | [
"django.db.models.TextField",
"django.utils.translation.gettext_lazy",
"django.db.models.CharField",
"django.db.models.ForeignKey",
"django.db.models.PositiveIntegerField",
"django.db.models.BooleanField",
"django_countries.fields.CountryField"
] | [((12758, 12801), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(2)', 'unique': '(True)'}), '(max_length=2, unique=True)\n', (12774, 12801), False, 'from django.db import models\n'), ((12815, 12846), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(30)'}), '(max_length=30... |
# -*- coding: utf-8 -*-
# File: maputils.py
# Copyright 2021 Dr. <NAME>. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2... | [
"numpy.random.uniform",
"numpy.asarray",
"numpy.zeros",
"termcolor.colored",
"numpy.histogram",
"tabulate.tabulate",
"numpy.arange",
"functools.wraps"
] | [((4073, 4094), 'functools.wraps', 'functools.wraps', (['func'], {}), '(func)\n', (4088, 4094), False, 'import functools\n'), ((5213, 5242), 'numpy.arange', 'np.arange', (['(1)', '(cat_numbers + 2)'], {}), '(1, cat_numbers + 2)\n', (5222, 5242), True, 'import numpy as np\n'), ((5266, 5287), 'numpy.zeros', 'np.zeros', (... |
__author__ = '<NAME>'
import numpy as np
from matplotlib import pyplot as plt
def PlotData(Data, size=50, showGr = 1, newWin = 1, titleT = None):
if newWin:
plt.figure()
if titleT != None:
plt.title(titleT)
plt.scatter(Data[:,1][Data[:,0]==0], Data[:,2][Data[:,0]==0], color... | [
"matplotlib.pyplot.title",
"matplotlib.pyplot.show",
"numpy.sum",
"numpy.argmax",
"matplotlib.pyplot.scatter",
"numpy.argmin",
"numpy.argsort",
"matplotlib.pyplot.figure",
"numpy.max",
"numpy.unique"
] | [((253, 348), 'matplotlib.pyplot.scatter', 'plt.scatter', (['Data[:, 1][Data[:, 0] == 0]', 'Data[:, 2][Data[:, 0] == 0]'], {'color': '"""red"""', 's': 'size'}), "(Data[:, 1][Data[:, 0] == 0], Data[:, 2][Data[:, 0] == 0], color\n ='red', s=size)\n", (264, 348), True, 'from matplotlib import pyplot as plt\n'), ((343, ... |
from sys import platform
from pydantic.class_validators import validator
from modules.base.Configuration import *
from modules.base.Instances import *
@configuration
class SystemPlatformConfiguration(PlatformConfiguration):
'''Configuration settings for the System platform.'''
@validator('platform')
... | [
"pydantic.class_validators.validator"
] | [((295, 316), 'pydantic.class_validators.validator', 'validator', (['"""platform"""'], {}), "('platform')\n", (304, 316), False, 'from pydantic.class_validators import validator\n')] |
#! python
"""
===============
Pygraphviz Draw
===============
An example showing how to use the interface to the pygraphviz
AGraph class to draw a graph.
Also see the pygraphviz documentation and examples at
http://pygraphviz.github.io/
"""
# Author: <NAME> (<EMAIL>)
# Copyright (C) 2006-2018 by
# <NAME> <<EMA... | [
"networkx.nx_agraph.to_agraph",
"networkx.complete_graph"
] | [((456, 476), 'networkx.complete_graph', 'nx.complete_graph', (['(5)'], {}), '(5)\n', (473, 476), True, 'import networkx as nx\n'), ((511, 536), 'networkx.nx_agraph.to_agraph', 'nx.nx_agraph.to_agraph', (['G'], {}), '(G)\n', (533, 536), True, 'import networkx as nx\n')] |
# jsonParser.py
#
# Implementation of a simple JSON parser, returning a hierarchical
# ParseResults object support both list- and dict-style data access.
#
# Copyright 2006, by <NAME>
#
# Updated 8 Jan 2007 - fixed dict grouping bug, and made elements and
# members optional in array and object collections
#
... | [
"mo_parsing.helpers.dblQuotedString.add_parse_action",
"mo_parsing.helpers.delimited_list",
"mo_parsing.whitespaces.Whitespace"
] | [((966, 978), 'mo_parsing.whitespaces.Whitespace', 'Whitespace', ([], {}), '()\n', (976, 978), False, 'from mo_parsing.whitespaces import Whitespace\n'), ((1207, 1254), 'mo_parsing.helpers.dblQuotedString.add_parse_action', 'dblQuotedString.add_parse_action', (['remove_quotes'], {}), '(remove_quotes)\n', (1239, 1254), ... |
import os
import atexit
import shutil
import tempfile
from .._is_reload_process import is_reload_process
from ._certificate_generator import (
create_certificate,
SERVER_KEY_FILENAME,
SERVER_CRT_FILENAME,
)
class LocalhostCertificate:
"""Facilitates creating certificates only valid for localhost, on ... | [
"shutil.rmtree",
"tempfile.mkdtemp",
"os.path.join",
"atexit.register"
] | [((986, 1019), 'shutil.rmtree', 'shutil.rmtree', (['self._ssl_temp_dir'], {}), '(self._ssl_temp_dir)\n', (999, 1019), False, 'import shutil\n'), ((636, 654), 'tempfile.mkdtemp', 'tempfile.mkdtemp', ([], {}), '()\n', (652, 654), False, 'import tempfile\n'), ((718, 756), 'atexit.register', 'atexit.register', (['self._del... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#The MIT License (MIT)
#Copyright (c) 2015 <NAME>
#Permission is hereby granted, free of charge, to any person obtaining a copy
#of this software and associated documentation files (the "Software"), to deal
#in the Software without restriction, including without limitati... | [
"time.time"
] | [((1423, 1429), 'time.time', 'time', ([], {}), '()\n', (1427, 1429), False, 'from time import time\n'), ((1586, 1592), 'time.time', 'time', ([], {}), '()\n', (1590, 1592), False, 'from time import time\n')] |
import numpy as np
x=1.0
y=2.0
#exponents and logarithms
print(np.exp(x)) #e^x
print(np.log(x)) #ln x
print(np.log10(x)) #log_10 x
print(np.log2(x)) #log_2 x
#min/max/misc
print(np.fabs(x))
print(np.fmin(x,y))
print(np.fmax(x,y))
#populate arrays
n=100
z=np.arange(n,dtype=float)
z*=2.0*np.pi/float(n-1)
sin_z=np... | [
"numpy.fmin",
"numpy.fmax",
"numpy.log",
"numpy.log2",
"numpy.sin",
"numpy.arange",
"numpy.exp",
"numpy.fabs",
"numpy.interp",
"numpy.log10"
] | [((263, 288), 'numpy.arange', 'np.arange', (['n'], {'dtype': 'float'}), '(n, dtype=float)\n', (272, 288), True, 'import numpy as np\n'), ((318, 327), 'numpy.sin', 'np.sin', (['z'], {}), '(z)\n', (324, 327), True, 'import numpy as np\n'), ((65, 74), 'numpy.exp', 'np.exp', (['x'], {}), '(x)\n', (71, 74), True, 'import nu... |
from collections import OrderedDict
from .constants import GroupStatus, AsOfDateModifier, FundsType
from .exceptions import ParsingException, NotSupportedYetException, \
IntegrityException
from .models import \
Bai2File, Bai2FileHeader, Bai2FileTrailer, \
Group, GroupHeader, GroupTrailer, \
AccountIden... | [
"collections.OrderedDict"
] | [((5149, 5162), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (5160, 5162), False, 'from collections import OrderedDict\n'), ((5396, 5409), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (5407, 5409), False, 'from collections import OrderedDict\n'), ((5689, 5702), 'collections.OrderedDict', '... |
import pytest
from tests.factory.block_factory import ListItemFactory
class TestListItemFactory:
""" リストの子要素を生成できるか """
# 単一
@pytest.mark.parametrize(
('text', 'expected'),
[
('item1', '[ListItem: indent_depth=1 | Child of ListItem -> Plain: text=item1]'),
('要素1',... | [
"pytest.mark.parametrize",
"tests.factory.block_factory.ListItemFactory"
] | [((142, 394), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (["('text', 'expected')", "[('item1',\n '[ListItem: indent_depth=1 | Child of ListItem -> Plain: text=item1]'),\n ('要素1',\n '[ListItem: indent_depth=1 | Child of ListItem -> Plain: text=要素1]')]"], {'ids': "['ascii', 'full width']"}), "(('text'... |
# -*- coding: utf-8 -*-
from pprint import pprint
import yaml
import praw
import pymongo
import utils
HOT_LIMIT = 10
OLD_CONTENT = pymongo.MongoClient()['telegraph_digest']['content']
def normalization_coef(data):
return 1 / (sum(data) / len(data))
def was_before(url):
doc = {
... | [
"pymongo.MongoClient",
"praw.Reddit",
"argparse.ArgumentParser",
"utils.do_magic"
] | [((1243, 1392), 'praw.Reddit', 'praw.Reddit', ([], {'user_agent': "config['reddit']['user_agent']", 'client_id': "config['reddit']['client_id']", 'client_secret': "config['reddit']['client_secret']"}), "(user_agent=config['reddit']['user_agent'], client_id=config[\n 'reddit']['client_id'], client_secret=config['redd... |
try:
import nmap # import nmap.py module
# import xlwt
# import requests
from getmac import get_mac_address
# import sqlite3
# import geocoder
# import datetime
# import time
# import pandas as pd
print("All Modules loaded .. ")
except Exception as e:
print("Some Modules ... | [
"nmap.PortScanner",
"getmac.get_mac_address"
] | [((1599, 1621), 'getmac.get_mac_address', 'get_mac_address', ([], {'ip': 'IP'}), '(ip=IP)\n', (1614, 1621), False, 'from getmac import get_mac_address\n'), ((2915, 2933), 'nmap.PortScanner', 'nmap.PortScanner', ([], {}), '()\n', (2931, 2933), False, 'import nmap\n')] |
"""
Data preparation script for GNN tracking.
This script processes h5 files of the ntuple and produces graph data on disk.
Will also save a csv file of the time to build each graph
The differences between Savannah's code is:
- CMS geometry instead of TrackML geometry (main difference is just the layers that conn... | [
"yaml.load",
"numpy.arctan2",
"argparse.ArgumentParser",
"os.path.isfile",
"numpy.arange",
"os.path.join",
"csv.DictWriter",
"sys.path.append",
"pandas.read_hdf",
"IPython.embed",
"numpy.tan",
"pandas.concat",
"numpy.stack",
"functools.partial",
"os.path.expandvars",
"multiprocessing.P... | [((569, 591), 'sys.path.append', 'sys.path.append', (['"""../"""'], {}), "('../')\n", (584, 591), False, 'import sys\n'), ((737, 815), 'collections.namedtuple', 'namedtuple', (['"""Graph"""', "['x', 'edge_attr', 'edge_index', 'y', 'pid', 'pt', 'eta']"], {}), "('Graph', ['x', 'edge_attr', 'edge_index', 'y', 'pid', 'pt',... |
import datetime
import io
import logging
from decimal import Decimal
from z3c.rml import rml2pdf
from model.columns import Column
from model.family import get_parents, get_students
RML_BEGIN_TEMPLATE_PORTRAIT = """<!DOCTYPE document SYSTEM "rml_1_0.dtd">
<document filename="master.pdf" invariant="1">
<template pa... | [
"io.StringIO",
"decimal.Decimal",
"model.family.get_parents",
"model.family.get_students",
"datetime.datetime.now",
"logging.getLogger",
"z3c.rml.rml2pdf.go"
] | [((4875, 4921), 'logging.getLogger', 'logging.getLogger', (['f"""classinvoices.{__name__}"""'], {}), "(f'classinvoices.{__name__}')\n", (4892, 4921), False, 'import logging\n'), ((7013, 7026), 'io.StringIO', 'io.StringIO', ([], {}), '()\n', (7024, 7026), False, 'import io\n'), ((7441, 7484), 'z3c.rml.rml2pdf.go', 'rml2... |
"""
Automatically update the baseline of vcpkg-configuration.json
"""
import json
import os
import pybamm
def update_baseline():
"""
Opens vcpkg-configuration.json and updates the baseline with the latest commit id
"""
# Get latest commit id from pybamm-team/sundials-vcpkg-registry
cmd = "git ls... | [
"os.popen",
"json.loads",
"pybamm.root_dir"
] | [((461, 474), 'os.popen', 'os.popen', (['cmd'], {}), '(cmd)\n', (469, 474), False, 'import os\n'), ((548, 565), 'pybamm.root_dir', 'pybamm.root_dir', ([], {}), '()\n', (563, 565), False, 'import pybamm\n'), ((670, 688), 'json.loads', 'json.loads', (['output'], {}), '(output)\n', (680, 688), False, 'import json\n')] |
import re
import json
"""
A file for Player utilities, focused around parsing chat and making it human readable.
The DefaultParser should be able to handle most situations currently,
however, there are known weakness's in the approach but as it stands,
it is better then other examples I have seen.
DefaultParser - T... | [
"re.sub",
"json.loads"
] | [((905, 921), 'json.loads', 'json.loads', (['data'], {}), '(data)\n', (915, 921), False, 'import json\n'), ((1513, 1625), 're.sub', 're.sub', (['"""\\\\§c|\\\\§f|\\\\§b|\\\\§d|\\\\§a|\\\\§1|\\\\§2|\\\\§3|\\\\§4|\\\\§5|\\\\§6|\\\\§7|\\\\§8|\\\\§9|\\\\§0"""', '""""""', "item['text']"], {}), "(\n '\\\\§c|\\\\§f|\\\\§b|... |
import csv
import requests
from urllib.request import urlopen
from bs4 import BeautifulSoup
import pandas as pd
from google.cloud.storage.blob import Blob
from google.cloud import storage
import yfinance as yf
import datetime
from datetime import datetime, timedelta
import os
import shutil
import logging
import os.path... | [
"pandas.DataFrame",
"os.path.basename",
"pandas.read_csv",
"dateutil.relativedelta.relativedelta",
"json.dumps",
"urllib.request.urlopen",
"google.cloud.storage.Client",
"tempfile.mkdtemp",
"pytz.timezone",
"pandas.to_datetime",
"yfinance.Ticker",
"bs4.BeautifulSoup",
"requests.post",
"os.... | [((1094, 1111), 'json.dumps', 'json.dumps', (['param'], {}), '(param)\n', (1104, 1111), False, 'import json\n'), ((1182, 1221), 'requests.post', 'requests.post', (['function_url'], {'json': 'param'}), '(function_url, json=param)\n', (1195, 1221), False, 'import requests\n'), ((1425, 1441), 'google.cloud.storage.Client'... |
from src.models import UserLanguage
LANGUAGES = [
'C',
'C#',
'C++',
'CSS',
'HTML',
'Java',
'Javascript',
'Objective C',
'PHP',
'Python',
'Ruby',
'Swift',
'None'
]
for LANGUAGE in LANGUAGES:
UserLanguage.objects.create(language=LANGUAGE)
| [
"src.models.UserLanguage.objects.create"
] | [((206, 252), 'src.models.UserLanguage.objects.create', 'UserLanguage.objects.create', ([], {'language': 'LANGUAGE'}), '(language=LANGUAGE)\n', (233, 252), False, 'from src.models import UserLanguage\n')] |
# -*- coding: UTF-8 -*-
import tensorflow.compat.v1 as tf
import os, sys
import numpy as np
from PIL import Image
import cv2 as cv
def image_processing(image, height, width):
# 解码图像数据
image = tf.image.decode_jpeg(image, channels=3)
# 归一化，归一化区间是[-1, 1]
image = (tf.cast(image, dtype=tf.float32) - 127.0) ... | [
"tensorflow.compat.v1.train.batch_join",
"tensorflow.compat.v1.train.string_input_producer",
"os.path.join",
"tensorflow.compat.v1.image.resize_bilinear",
"tensorflow.compat.v1.name_scope",
"tensorflow.compat.v1.FIFOQueue",
"tensorflow.compat.v1.squeeze",
"tensorflow.compat.v1.expand_dims",
"numpy.r... | [((201, 240), 'tensorflow.compat.v1.image.decode_jpeg', 'tf.image.decode_jpeg', (['image'], {'channels': '(3)'}), '(image, channels=3)\n', (221, 240), True, 'import tensorflow.compat.v1 as tf\n'), ((376, 400), 'tensorflow.compat.v1.expand_dims', 'tf.expand_dims', (['image', '(0)'], {}), '(image, 0)\n', (390, 400), True... |
import math
def f(x):
return math.exp(6*x)+1.441*math.exp(2*x)-2.079*math.exp(4*x)-0.3330
def g(x):
return 6*math.exp(6*x)+2*1.441*math.exp(2*x)-4*2.079*math.exp(4*x)
def newton(initial, tol, maxiter):
i = 1
while i <= maxiter:
approx = initial - f(initial)/g(initial)
if abs(approx - ... | [
"math.exp"
] | [((163, 178), 'math.exp', 'math.exp', (['(4 * x)'], {}), '(4 * x)\n', (171, 178), False, 'import math\n'), ((34, 49), 'math.exp', 'math.exp', (['(6 * x)'], {}), '(6 * x)\n', (42, 49), False, 'import math\n'), ((74, 89), 'math.exp', 'math.exp', (['(4 * x)'], {}), '(4 * x)\n', (82, 89), False, 'import math\n'), ((119, 13... |
from __future__ import print_function
from freeway import Freeway
if __name__ == "__main__":
# Parse data from path
filepath = (
r"C:/example/assets/Characters/Roberto/MOD/Work/example_CH_Roberto_MOD.v001.abc"
)
myPath = Freeway(filepath)
# Show all parsed data
print(myPath)
# Use... | [
"freeway.Freeway"
] | [((247, 264), 'freeway.Freeway', 'Freeway', (['filepath'], {}), '(filepath)\n', (254, 264), False, 'from freeway import Freeway\n'), ((749, 764), 'freeway.Freeway', 'Freeway', ([], {}), '(**data)\n', (756, 764), False, 'from freeway import Freeway\n')] |
class Node(object):
def __init__(self, data, left=None, right=None):
self.data = data
self.left = left
self.right = right
class BST(object):
def __init__(self):
self.root = None
def add(self, data):
self.root = self._add_recur(self.root, data)
def _add_recur(s... | [
"random.randint"
] | [((1317, 1334), 'random.randint', 'randint', (['(0)', '(10000)'], {}), '(0, 10000)\n', (1324, 1334), False, 'from random import randint\n')] |
import cv2
import os
import sys
def add(img1, img2):
return cv2.add(img1, img2)
def sub(img1, img2):
return cv2.subtract(img1, img2)
def blur(img, intensity):
mask = intensity + (intensity % 2 + 1)
mask = 9 if mask < 10 else mask
return cv2.GaussianBlur(img, (mask, mask), intensity)
def mul(img,... | [
"cv2.GaussianBlur",
"os.mkdir",
"cv2.subtract",
"cv2.imwrite",
"os.path.exists",
"cv2.imread",
"cv2.add",
"cv2.resize"
] | [((65, 84), 'cv2.add', 'cv2.add', (['img1', 'img2'], {}), '(img1, img2)\n', (72, 84), False, 'import cv2\n'), ((118, 142), 'cv2.subtract', 'cv2.subtract', (['img1', 'img2'], {}), '(img1, img2)\n', (130, 142), False, 'import cv2\n'), ((260, 306), 'cv2.GaussianBlur', 'cv2.GaussianBlur', (['img', '(mask, mask)', 'intensit... |