code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
from os import path
import numpy as np
from vision.domain.iCameraCalibration import ICameraCalibration
from vision.domain.iCameraCalibrationFactory import ICameraCalibrationFactory
from vision.infrastructure.fallbackCameraCalibration import FallBackCameraCalibration
from vision.infrastructure.openCvCameraCalibration ... | [
"vision.infrastructure.fallbackCameraCalibration.FallBackCameraCalibration",
"vision.infrastructure.openCvCameraCalibration.OpenCvCameraCalibration",
"numpy.load"
] | [((690, 720), 'numpy.load', 'np.load', (['calibration_file_path'], {}), '(calibration_file_path)\n', (697, 720), True, 'import numpy as np\n'), ((853, 947), 'vision.infrastructure.openCvCameraCalibration.OpenCvCameraCalibration', 'OpenCvCameraCalibration', (['camera_matrix', 'distortion_coefficients', 'image_width', 'i... |
from rest_framework.response import Response
from rest_framework.views import APIView
from NotebookIndex.notebook_index.serializer import ManyCatalog
from NotebookManage.notebook.models import Book, Catalog
class CatalogView(APIView):
def get(self, request, id=None):
catalog = Catalog.objects.filter(book=... | [
"rest_framework.response.Response",
"NotebookIndex.notebook_index.serializer.ManyCatalog",
"NotebookManage.notebook.models.Book.objects.filter"
] | [((432, 501), 'rest_framework.response.Response', 'Response', (["{'code': 200, 'msg': 'Query was successful!', 'data': data}"], {}), "({'code': 200, 'msg': 'Query was successful!', 'data': data})\n", (440, 501), False, 'from rest_framework.response import Response\n'), ((371, 411), 'NotebookIndex.notebook_index.seriali... |
import json
import string
from correction_to_answer_key import BASE_DIR, CONFIG
IGNORE_LINES_STARTSWITH = tuple([letter for letter in string.ascii_letters + "!@#$%^&*(" + " "])
LANG = {
"Urdu": "UDU",
"Assamese": "ASM",
"Bengali": "BEN",
"English": "ENG",
"Gujarati": "GUJ",
"Hindi": "HIN",
... | [
"json.dumps"
] | [((2711, 2730), 'json.dumps', 'json.dumps', (['ANSWERS'], {}), '(ANSWERS)\n', (2721, 2730), False, 'import json\n')] |
from sklearn.tree import DecisionTreeClassifier
from sklearn import EstimatorObject
dtree = DecisionTreeClassifier()
dtree.fit(df(['Age', 'Distance']), df['Attended'])
model = EstimatorObject()
cart_plot(dtree) | [
"sklearn.EstimatorObject",
"sklearn.tree.DecisionTreeClassifier"
] | [((96, 120), 'sklearn.tree.DecisionTreeClassifier', 'DecisionTreeClassifier', ([], {}), '()\n', (118, 120), False, 'from sklearn.tree import DecisionTreeClassifier\n'), ((184, 201), 'sklearn.EstimatorObject', 'EstimatorObject', ([], {}), '()\n', (199, 201), False, 'from sklearn import EstimatorObject\n')] |
"""
Test script for the ReplayMemory
"""
import unittest
from models.utils.replay_memory import ReplayMemory
import numpy as np
class DummyTupleGenerator:
def __init__(self, input_shape, action_space):
self.state_number = 0
self.last_action = 0
self.input_shape = input_shape
self... | [
"numpy.ones",
"numpy.all",
"models.utils.replay_memory.ReplayMemory"
] | [((1534, 1588), 'models.utils.replay_memory.ReplayMemory', 'ReplayMemory', (['memory_length', 'input_shape', 'action_space'], {}), '(memory_length, input_shape, action_space)\n', (1546, 1588), False, 'from models.utils.replay_memory import ReplayMemory\n'), ((973, 998), 'numpy.ones', 'np.ones', (['self.input_shape'], {... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import json
import pickle
if __name__ == '__main__':
customer=dict(name='walter',age=100)
bstr=pickle.dumps(customer)
print(bstr)
# 写入文件
f=open('dump.txt', 'wb')
pickle.dump(customer,f)
f.close()
# 读出文件
f=open('dump.txt','rb')
cust... | [
"json.loads",
"pickle.dump",
"pickle.dumps",
"json.dumps",
"pickle.load"
] | [((151, 173), 'pickle.dumps', 'pickle.dumps', (['customer'], {}), '(customer)\n', (163, 173), False, 'import pickle\n'), ((235, 259), 'pickle.dump', 'pickle.dump', (['customer', 'f'], {}), '(customer, f)\n', (246, 259), False, 'import pickle\n'), ((325, 339), 'pickle.load', 'pickle.load', (['f'], {}), '(f)\n', (336, 33... |
import pandas as pd
import sys
import argparse
import random
random.seed(0)
def split(m, out_f, parts, randomize = True, phenotypes = None, ids = None):
"""split matrix into <parts> parts"""
#read in phenotypes
#split data table into phenotypes and features
if not phenotypes is None:
pts = pd.r... | [
"pandas.concat",
"random.shuffle",
"random.seed",
"pandas.read_csv"
] | [((61, 75), 'random.seed', 'random.seed', (['(0)'], {}), '(0)\n', (72, 75), False, 'import random\n'), ((316, 362), 'pandas.read_csv', 'pd.read_csv', (['phenotypes'], {'sep': '"""\t"""', 'index_col': '(0)'}), "(phenotypes, sep='\\t', index_col=0)\n", (327, 362), True, 'import pandas as pd\n'), ((683, 706), 'random.shuf... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
PLOTTREE - Plot a phylogenetic tree with just a single line of code.
Usage: plottree TREE [options]
positional arguments:
TREE A tree in NEWCIK format file or string (surrounded by
double quotes).
optional arguments:
-h, ... | [
"matplotlib.rcParams.get",
"matplotlib.pylab.subplots",
"matplotlib.rcParams.update",
"argparse.ArgumentParser",
"os.path.isfile",
"matplotlib.pylab.show",
"Bio.Phylo.draw",
"io.StringIO",
"Bio.Phylo.read",
"matplotlib.pylab.subplots_adjust"
] | [((1429, 1449), 'os.path.isfile', 'os.path.isfile', (['tree'], {}), '(tree)\n', (1443, 1449), False, 'import os\n'), ((1804, 1844), 'matplotlib.rcParams.update', 'mpl.rcParams.update', (["{'font.size': size}"], {}), "({'font.size': size})\n", (1823, 1844), True, 'import matplotlib as mpl\n'), ((1914, 1928), 'matplotlib... |
from django.core import mail
from django.urls import reverse
from website.apps.datamaps.models import Country
from website.apps.packages.tests.factories import PackageFactory
from website.apps.tests.base import ViewTestMixin, WebsiteTestBase
from website.apps.users.factories import UserFactory
from ..models import Pr... | [
"website.apps.packages.tests.factories.PackageFactory.create",
"website.apps.datamaps.models.Country.objects.all",
"website.apps.users.factories.UserFactory.create",
"website.apps.datamaps.models.Country.objects.get",
"django.urls.reverse"
] | [((2779, 2810), 'website.apps.datamaps.models.Country.objects.get', 'Country.objects.get', ([], {'code': '"""USA"""'}), "(code='USA')\n", (2798, 2810), False, 'from website.apps.datamaps.models import Country\n'), ((2825, 2848), 'website.apps.packages.tests.factories.PackageFactory.create', 'PackageFactory.create', ([]... |
"""
This is the requires side of the interface layer, for use in charms that
wish to request integration with GCP native features. The integration will
be provided by the GCP integration charm, which allows the requiring charm
to not require cloud credentials itself and not have a lot of GCP specific
API code.
The fl... | [
"random.choice",
"charms.reactive.when_not",
"urllib.request.Request",
"charmhelpers.core.hookenv.charm_name",
"urllib.parse.urljoin",
"charmhelpers.core.unitdata.kv",
"charms.reactive.when",
"urllib.request.urlopen"
] | [((2572, 2611), 'urllib.parse.urljoin', 'urljoin', (['_metadata_url', '"""instance/name"""'], {}), "(_metadata_url, 'instance/name')\n", (2579, 2611), False, 'from urllib.parse import urljoin\n'), ((2628, 2667), 'urllib.parse.urljoin', 'urljoin', (['_metadata_url', '"""instance/zone"""'], {}), "(_metadata_url, 'instanc... |
from typing import List
import datasets
# Citation, taken from https://github.com/microsoft/CodeXGLUE
_DEFAULT_CITATION = """@article{CodeXGLUE,
title={CodeXGLUE: A Benchmark Dataset and Open Challenge for Code Intelligence},
year={2020},}"""
class Child:
_DESCRIPTION = None
_FEATURES = N... | [
"datasets.SplitGenerator",
"datasets.Features"
] | [((1656, 1764), 'datasets.SplitGenerator', 'datasets.SplitGenerator', ([], {'name': 'SPLITS[k]', 'gen_kwargs': "{'split_name': k, 'file_paths': downloaded_files[k]}"}), "(name=SPLITS[k], gen_kwargs={'split_name': k,\n 'file_paths': downloaded_files[k]})\n", (1679, 1764), False, 'import datasets\n'), ((771, 804), 'da... |
#!/usr/bin/python3
import requests
import subprocess
import sys
import os
import random
import binascii
class Username:
def __init__(self):
first = random.choice(['John',
'Jane',
'Alice',
'Bob',
... | [
"requests.session",
"random.choice",
"subprocess.Popen",
"os.urandom",
"os.path.dirname"
] | [((1903, 1921), 'requests.session', 'requests.session', ([], {}), '()\n', (1919, 1921), False, 'import requests\n'), ((2261, 2354), 'subprocess.Popen', 'subprocess.Popen', (["['pdftotext', '-', '-']"], {'stdin': 'subprocess.PIPE', 'stdout': 'subprocess.PIPE'}), "(['pdftotext', '-', '-'], stdin=subprocess.PIPE, stdout=\... |
from django.contrib import admin
from .models import Image,UserProfile
admin.site.register(Image)
admin.site.register(UserProfile)
# Register your models here.
| [
"django.contrib.admin.site.register"
] | [((73, 99), 'django.contrib.admin.site.register', 'admin.site.register', (['Image'], {}), '(Image)\n', (92, 99), False, 'from django.contrib import admin\n'), ((100, 132), 'django.contrib.admin.site.register', 'admin.site.register', (['UserProfile'], {}), '(UserProfile)\n', (119, 132), False, 'from django.contrib impor... |
from tkinter import Tk
from pyDEA.core.gui_modules.custom_canvas_gui import StyledCanvas
from pyDEA.core.utils.dea_utils import bg_color
def test_bg_color():
parent = Tk()
canvas = StyledCanvas(parent)
assert canvas.cget('background') == bg_color
parent.destroy()
| [
"tkinter.Tk",
"pyDEA.core.gui_modules.custom_canvas_gui.StyledCanvas"
] | [((174, 178), 'tkinter.Tk', 'Tk', ([], {}), '()\n', (176, 178), False, 'from tkinter import Tk\n'), ((192, 212), 'pyDEA.core.gui_modules.custom_canvas_gui.StyledCanvas', 'StyledCanvas', (['parent'], {}), '(parent)\n', (204, 212), False, 'from pyDEA.core.gui_modules.custom_canvas_gui import StyledCanvas\n')] |
import os
import base64
import logging
import pickle
from datetime import timedelta
from distutils.version import StrictVersion
from django.conf import settings as django_settings
from django.core.management import call_command, get_commands, load_command_class
from django.core.management.base import OutputWrapper
f... | [
"logging.getLogger",
"django.core.management.base.OutputWrapper",
"django.utils.timezone.now",
"datetime.timedelta",
"django.core.exceptions.ImproperlyConfigured"
] | [((1112, 1156), 'logging.getLogger', 'logging.getLogger', (['settings.TASK_LOGGER_NAME'], {}), '(settings.TASK_LOGGER_NAME)\n', (1129, 1156), False, 'import logging\n'), ((769, 834), 'django.core.exceptions.ImproperlyConfigured', 'ImproperlyConfigured', (['"""Missing celery library, please install it"""'], {}), "('Miss... |
from collections.abc import Sequence
import mundi
import sidekick.api as sk
from .epidemiology import Epidemiology
from .utils import delegate_map, delegate_mapping, concat_frame, agg_frame
info_method = lambda attr: delegate_mapping(attr, concat_frame)
sum_method = lambda attr: delegate_mapping(attr, agg_frame("sum"... | [
"sidekick.api.delegate_to",
"mundi.regions"
] | [((701, 724), 'sidekick.api.delegate_to', 'sk.delegate_to', (['"""_data"""'], {}), "('_data')\n", (715, 724), True, 'import sidekick.api as sk\n'), ((740, 763), 'sidekick.api.delegate_to', 'sk.delegate_to', (['"""_data"""'], {}), "('_data')\n", (754, 763), True, 'import sidekick.api as sk\n'), ((782, 805), 'sidekick.ap... |
from assets import *
import datetime
import pytz
def utc():
return datetime.datetime.now(datetime.timezone.utc)
# noinspection PyBroadException
def convert_time(_time) -> str:
"""
Convert time into a years, hours, minute, seconds thing.
"""
# much better than the original one lol
# man I su... | [
"datetime.datetime.now",
"pytz.timezone"
] | [((73, 117), 'datetime.datetime.now', 'datetime.datetime.now', (['datetime.timezone.utc'], {}), '(datetime.timezone.utc)\n', (94, 117), False, 'import datetime\n'), ((1982, 2015), 'pytz.timezone', 'pytz.timezone', (['"""America/New_York"""'], {}), "('America/New_York')\n", (1995, 2015), False, 'import pytz\n')] |
import os
import subprocess
from typing import Dict
import yaml
def read_yaml(file_name: str) -> Dict:
assert os.path.exists(file_name), f"file {file_name} does not exist"
with open(file_name, "r") as stream:
try:
yaml_file = yaml.safe_load(stream)
return yaml_file
exc... | [
"os.path.exists",
"subprocess.run",
"yaml.safe_load"
] | [((117, 142), 'os.path.exists', 'os.path.exists', (['file_name'], {}), '(file_name)\n', (131, 142), False, 'import os\n'), ((421, 440), 'subprocess.run', 'subprocess.run', (['cmd'], {}), '(cmd)\n', (435, 440), False, 'import subprocess\n'), ((257, 279), 'yaml.safe_load', 'yaml.safe_load', (['stream'], {}), '(stream)\n'... |
import rdflib
from utilities.utility_functions import prefix, add_equivalence_relation, check_nodes_synonymy, check_nodes_equivalence, \
add_synonymy_relation
from utilities.wordnet_utility_functions import check_synonymy
import utilities.constants as constants
def negative_verbs(g1, g2, n, result_graph, indexes... | [
"utilities.utility_functions.check_nodes_equivalence",
"utilities.utility_functions.check_nodes_synonymy",
"rdflib.term.URIRef",
"utilities.utility_functions.prefix",
"utilities.utility_functions.add_synonymy_relation",
"utilities.utility_functions.add_equivalence_relation"
] | [((803, 817), 'utilities.utility_functions.prefix', 'prefix', (['s1', 'g1'], {}), '(s1, g1)\n', (809, 817), False, 'from utilities.utility_functions import prefix, add_equivalence_relation, check_nodes_synonymy, check_nodes_equivalence, add_synonymy_relation\n'), ((822, 836), 'utilities.utility_functions.prefix', 'pref... |
from nose.tools import assert_equal, assert_raises
class TestProdThree(object):
def test_prod_three(self):
solution = Solution()
assert_raises(TypeError, solution.max_prod_three, None)
assert_raises(ValueError, solution.max_prod_three, [1, 2])
assert_equal(solution.max_prod_three(... | [
"nose.tools.assert_raises"
] | [((152, 207), 'nose.tools.assert_raises', 'assert_raises', (['TypeError', 'solution.max_prod_three', 'None'], {}), '(TypeError, solution.max_prod_three, None)\n', (165, 207), False, 'from nose.tools import assert_equal, assert_raises\n'), ((216, 274), 'nose.tools.assert_raises', 'assert_raises', (['ValueError', 'soluti... |
"""
my_module - word操作.
Main members:
# read_docx_tables - 读取docx中的表格数据.
参考资料:
# https://python-docx.readthedocs.io/en/latest/user/install.html
# https://www.cnblogs.com/program-in-chinese/p/10500103.html
"""
from qytPython import logger
from qytPython.utils.requirem... | [
"qytPython.utils.requirement.check_requirement",
"docx.Document"
] | [((468, 499), 'qytPython.utils.requirement.check_requirement', 'check_requirement', (['docx', '"""docx"""'], {}), "(docx, 'docx')\n", (485, 499), False, 'from qytPython.utils.requirement import check_requirement\n'), ((837, 861), 'docx.Document', 'docx.Document', (['file_name'], {}), '(file_name)\n', (850, 861), False,... |
# -*- coding: utf-8 -*-
#
# Helper functions for frontend test design
#
# The runner signatures take a callable,
# the `method_call`, as 1st argument
#
# 3rd party imports
import itertools
import numpy as np
from syncopy.shared.errors import SPYValueError, SPYTypeError
# fix random generators
np.random.seed(40203)
... | [
"numpy.random.rand",
"numpy.random.choice",
"itertools.product",
"numpy.diff",
"numpy.max",
"numpy.array",
"numpy.random.randint",
"numpy.isfinite",
"numpy.random.seed",
"numpy.min",
"numpy.all",
"numpy.arange"
] | [((297, 318), 'numpy.random.seed', 'np.random.seed', (['(40203)'], {}), '(40203)\n', (311, 318), True, 'import numpy as np\n'), ((2122, 2153), 'numpy.arange', 'np.arange', (['foilim[0]', 'foilim[1]'], {}), '(foilim[0], foilim[1])\n', (2131, 2153), True, 'import numpy as np\n'), ((2178, 2215), 'numpy.arange', 'np.arange... |
import asyncio
# user can define a consumer and
# a producer. But the producer can
# be overriden with another job class where it pass
# the queue to the consumer
#
# A job can be either a producer or a consumer
# and can also be both with at most two queues
#
# I think I can get away with one method worker?
# Worker... | [
"random.randint",
"asyncio.sleep"
] | [((660, 681), 'random.randint', 'random.randint', (['(0)', '(10)'], {}), '(0, 10)\n', (674, 681), False, 'import random\n'), ((760, 776), 'asyncio.sleep', 'asyncio.sleep', (['i'], {}), '(i)\n', (773, 776), False, 'import asyncio\n')] |
import xlsxwriter
import os
import re
from bs4 import BeautifulSoup
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from time import sleep
import logging
import logging.handlers
from datetime import datetime
# logging
LOG_FILENAME = "scrap_merit_info_acpdc.out"
my_logger = logging.getL... | [
"logging.getLogger",
"re.compile",
"selenium.webdriver.Chrome",
"logging.handlers.RotatingFileHandler",
"time.sleep",
"bs4.BeautifulSoup",
"datetime.datetime.now",
"xlsxwriter.Workbook"
] | [((308, 349), 'logging.getLogger', 'logging.getLogger', (['"""ScrapMeritInfoLogger"""'], {}), "('ScrapMeritInfoLogger')\n", (325, 349), False, 'import logging\n'), ((439, 536), 'logging.handlers.RotatingFileHandler', 'logging.handlers.RotatingFileHandler', (['LOG_FILENAME'], {'maxBytes': '(10 * 1024 * 1024)', 'backupCo... |
# Copyright 2009-2017 <NAME>.
# This program is distributed under the MIT license.
from python_toolbox import cute_testing
from python_toolbox.cute_iter_tools import PushbackIterator
def test_pushback_iterator():
pushback_iterator = PushbackIterator(iter([1, 2, 3]))
assert next(pushback_iterator) == 1
... | [
"python_toolbox.cute_testing.RaiseAssertor"
] | [((553, 594), 'python_toolbox.cute_testing.RaiseAssertor', 'cute_testing.RaiseAssertor', (['StopIteration'], {}), '(StopIteration)\n', (579, 594), False, 'from python_toolbox import cute_testing\n'), ((712, 753), 'python_toolbox.cute_testing.RaiseAssertor', 'cute_testing.RaiseAssertor', (['StopIteration'], {}), '(StopI... |
from fastapi import HTTPException
from sqlalchemy.orm import Session
from sqlalchemy.exc import IntegrityError
from models import model
from schemas import schema
def get_pessoa(db: Session, numero_cadastro: int):
return db.query(model.Pessoa).filter(model.Pessoa.NUMERO_CADASTRO == numero_cadastro).first()
def... | [
"fastapi.HTTPException",
"models.model.Pessoa"
] | [((546, 732), 'models.model.Pessoa', 'model.Pessoa', ([], {'NOME': 'pessoa.NOME', 'CIDADE': 'pessoa.CIDADE', 'ENDERECO': 'pessoa.ENDERECO', 'BAIRRO': 'pessoa.BAIRRO', 'CONTATO': 'pessoa.CONTATO', 'CPFCNPJ': 'pessoa.CPFCNPJ', 'CATEGORIA': 'pessoa.CATEGORIA'}), '(NOME=pessoa.NOME, CIDADE=pessoa.CIDADE, ENDERECO=pessoa.\n... |
import sys
sys.path.append('./PyScr/')
import numpy as np
import matplotlib.pyplot as plt
import cmath
import math
import copy
import pfprint
import primefac
from scipy.special import comb as choose
_ = None
def ppprint(arg):
global _
pfprint.pfprint(arg)
_ = arg
def frac():
pfprint.frac = not pfprint.frac
retu... | [
"math.factorial",
"matplotlib.pyplot.clf",
"numpy.exp",
"matplotlib.pyplot.close",
"primefac.primes",
"sys.path.append",
"matplotlib.pyplot.cla",
"pfprint.pfprint"
] | [((11, 38), 'sys.path.append', 'sys.path.append', (['"""./PyScr/"""'], {}), "('./PyScr/')\n", (26, 38), False, 'import sys\n'), ((652, 661), 'numpy.exp', 'np.exp', (['(1)'], {}), '(1)\n', (658, 661), True, 'import numpy as np\n'), ((239, 259), 'pfprint.pfprint', 'pfprint.pfprint', (['arg'], {}), '(arg)\n', (254, 259), ... |
# Copyright (c) 2013 python-gerrit Developers.
#
# 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... | [
"gerrit.filters.Items",
"json.loads"
] | [((804, 819), 'gerrit.filters.Items', 'filters.Items', ([], {}), '()\n', (817, 819), False, 'from gerrit import filters\n'), ((2875, 2890), 'gerrit.filters.Items', 'filters.Items', ([], {}), '()\n', (2888, 2890), False, 'from gerrit import filters\n'), ((1259, 1275), 'json.loads', 'json.loads', (['line'], {}), '(line)\... |
import sys
from mmdet.apis import inference_detector, init_detector
import json
import os
import numpy as np
import argparse
from tqdm import tqdm
import json
class MyEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, np.integer):
return int(obj)
elif isinstance(obj, np.floating):
... | [
"os.listdir",
"argparse.ArgumentParser",
"mmdet.apis.init_detector",
"tqdm.tqdm",
"os.path.join",
"mmdet.apis.inference_detector",
"json.dump"
] | [((569, 634), 'mmdet.apis.init_detector', 'init_detector', (['config2make_json', 'model2make_json'], {'device': '"""cuda:0"""'}), "(config2make_json, model2make_json, device='cuda:0')\n", (582, 634), False, 'from mmdet.apis import inference_detector, init_detector\n'), ((643, 663), 'os.listdir', 'os.listdir', (['pic_pa... |
from django.db import models
# from django.contrib.postgres import fields
import django.utils.timezone as timezone
from sites.constant import SignType, SignUse, TemplateType
class AliyunAccount(models.Model):
""" 阿里云配置 """
name = models.CharField(max_length=100, verbose_name="阿里云用户名")
app_id = models.Char... | [
"django.db.models.FloatField",
"django.db.models.TextField",
"django.db.models.ForeignKey",
"sites.constant.SignUse.all",
"django.db.models.BooleanField",
"sites.constant.TemplateType.all",
"sites.constant.SignType.all",
"django.db.models.DateTimeField",
"django.db.models.CharField"
] | [((240, 295), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(100)', 'verbose_name': '"""阿里云用户名"""'}), "(max_length=100, verbose_name='阿里云用户名')\n", (256, 295), False, 'from django.db import models\n'), ((309, 382), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(64)', 'ed... |
from src.srp6a_py.client import SRP as SRPClient
from src.srp6a_py.server import SRP as SRPServer
from src.srp6a_py.modulus import get_params
from base64 import b64encode
USERNAME="TOTOLAFRITE"
class Test_generate_secret_and_verifier:
def test_e2e(self):
N, g = get_params()
srp_group = {
"N": N,
... | [
"base64.b64encode",
"src.srp6a_py.server.SRP",
"src.srp6a_py.modulus.get_params",
"src.srp6a_py.client.SRP.generate_secret",
"src.srp6a_py.client.SRP.generate_verifier",
"src.srp6a_py.client.SRP"
] | [((272, 284), 'src.srp6a_py.modulus.get_params', 'get_params', ([], {}), '()\n', (282, 284), False, 'from src.srp6a_py.modulus import get_params\n'), ((356, 389), 'src.srp6a_py.client.SRP.generate_secret', 'SRPClient.generate_secret', (['"""toto"""'], {}), "('toto')\n", (381, 389), True, 'from src.srp6a_py.client impor... |
import ChromaPy32 as Chroma # Import the Chroma Module
from time import sleep # Import the sleep-function
Headset = Chroma.Headset() # Initialize a new Headset Instance
RED = (255, 0, 0) # Initialize a new color by RGB (RED,GREEN,BLUE)
for x in range(0, Headset.MaxLED): # for-loop with Headset.MaxLED as iterati... | [
"ChromaPy32.Headset",
"time.sleep"
] | [((119, 135), 'ChromaPy32.Headset', 'Chroma.Headset', ([], {}), '()\n', (133, 135), True, 'import ChromaPy32 as Chroma\n'), ((466, 476), 'time.sleep', 'sleep', (['(0.1)'], {}), '(0.1)\n', (471, 476), False, 'from time import sleep\n')] |
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.12
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
def swig_im... | [
"_SPP.VecFloat_front",
"_SPP.VecFloat_capacity",
"_SPP.VecVecFloat_append",
"_SPP.VecFloat_rend",
"_SPP.SwigPyIterator___next__",
"_SPP.VecFloat_swap",
"_SPP.VecFloat___setslice__",
"_SPP.VecFloat_reserve",
"_SPP.SwigPyIterator___ne__",
"_SPP.VecVecFloat_pop_back",
"_SPP.VecFloat_rbegin",
"_SP... | [((10732, 10755), '_SPP.normalize', '_SPP.normalize', (['x', 'y', 'z'], {}), '(x, y, z)\n', (10746, 10755), False, 'import _SPP\n'), ((10853, 10910), '_SPP.point_plane_distance', '_SPP.point_plane_distance', (['point', 'plane_norm', 'plane_point'], {}), '(point, plane_norm, plane_point)\n', (10878, 10910), False, 'impo... |
"""Unit tests for `FileHandler` from `ScriptRunner.filehandler`."""
from ScriptRunner.filehandler import FileHandler
class TestFIleNames:
"""Wraps tests for `FileHandler.file_names`."""
@staticmethod
def test_empty(test_dir):
"""
Passes test if `FIleNames.file_names` is empty.
""... | [
"ScriptRunner.filehandler.FileHandler"
] | [((1208, 1229), 'ScriptRunner.filehandler.FileHandler', 'FileHandler', (['test_dir'], {}), '(test_dir)\n', (1219, 1229), False, 'from ScriptRunner.filehandler import FileHandler\n'), ((1485, 1506), 'ScriptRunner.filehandler.FileHandler', 'FileHandler', (['test_dir'], {}), '(test_dir)\n', (1496, 1506), False, 'from Scri... |
# -*- encoding: utf-8 -*-
'''
@Time : 2021-08-15
@Author : EvilRecluse
@Contact : https://github.com/RecluseXU
@Desc : 辅助装饰器
'''
# here put the import lib
# from uuid import uuid1
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.chrome.webdriver import WebDriver
def te... | [
"selenium.webdriver.support.wait.WebDriverWait"
] | [((1193, 1223), 'selenium.webdriver.support.wait.WebDriverWait', 'WebDriverWait', (['driver', '(10)', '(0.1)'], {}), '(driver, 10, 0.1)\n', (1206, 1223), False, 'from selenium.webdriver.support.wait import WebDriverWait\n')] |
import tensorflow as tf
import tensorflow.compat.v2 as v2
import tensorflow.neuron as tfn
import shutil
import numpy as np
import unittest
from tensorflow.neuron.python.unittest_base import TestV1Only
class TestEarlyExit(TestV1Only):
def test_sequential(self):
with self.assertRaises(NotImplementedError):
... | [
"tensorflow.compat.v2.keras.Input",
"tensorflow.compat.v2.keras.layers.Dense",
"numpy.random.rand",
"tensorflow.compat.v2.keras.layers.concatenate",
"tensorflow.saved_model.save",
"tensorflow.compat.v2.keras.Model",
"numpy.random.randint",
"tensorflow.compat.v2.keras.layers.Embedding",
"tensorflow.c... | [((699, 736), 'tensorflow.saved_model.save', 'tf.saved_model.save', (['model', 'model_dir'], {}), '(model, model_dir)\n', (718, 736), True, 'import tensorflow as tf\n'), ((805, 858), 'shutil.rmtree', 'shutil.rmtree', (['compiled_model_dir'], {'ignore_errors': '(True)'}), '(compiled_model_dir, ignore_errors=True)\n', (8... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
################################################################################
#
# qooxdoo - the new era of web development
#
# http://qooxdoo.org
#
# Copyright:
# 2006-2012 1&1 Internet AG, Germany, http://www.1und1.de
#
# License:
# MIT: https://opensource.org... | [
"os.path.abspath",
"sys.path.insert"
] | [((684, 713), 'sys.path.insert', 'sys.path.insert', (['(0)', 'scriptDir'], {}), '(0, scriptDir)\n', (699, 713), False, 'import sys, os\n'), ((632, 657), 'os.path.abspath', 'os.path.abspath', (['__file__'], {}), '(__file__)\n', (647, 657), False, 'import sys, os\n')] |
# Copyright (c) 2017, MD2K Center of Excellence
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright notice, this
# list of conditio... | [
"datetime.datetime",
"pytz.timezone",
"os.path.exists",
"json.loads",
"argparse.ArgumentParser",
"datetime.datetime.strptime",
"os.path.join",
"cerebralcortex.core.datatypes.datastream.DataPoint",
"cerebralcortex.core.datatypes.datastream.DataStream",
"cerebralcortex.cerebralcortex.CerebralCortex"... | [((1896, 1973), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""CerebralCortex Qualtrics data importer"""'}), "(description='CerebralCortex Qualtrics data importer')\n", (1919, 1973), False, 'import argparse\n'), ((6447, 6474), 'pytz.timezone', 'pytz.timezone', (['"""US/Central"""'], {}),... |
"""
Copyright 2019 <NAME>
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 in writing... | [
"logging.getLogger",
"logging.StreamHandler",
"random.choice",
"random.seed",
"rps3env.tests.utils.captured_output",
"gym.make"
] | [((843, 870), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (860, 870), False, 'import logging\n'), ((935, 968), 'logging.StreamHandler', 'logging.StreamHandler', (['sys.stdout'], {}), '(sys.stdout)\n', (956, 968), False, 'import logging\n'), ((7915, 7938), 'gym.make', 'gym.make', (['"""... |
from transitions.extensions import GraphMachine
import pymongo
from pymongo import MongoClient
from pprint import pprint
client = MongoClient()
db = client.chatbot
schedule = db.schedule
class TocMachine(GraphMachine):
def __init__(self, **machine_configs):
self.machine = GraphMachine(
model =... | [
"pymongo.MongoClient",
"transitions.extensions.GraphMachine"
] | [((131, 144), 'pymongo.MongoClient', 'MongoClient', ([], {}), '()\n', (142, 144), False, 'from pymongo import MongoClient\n'), ((287, 330), 'transitions.extensions.GraphMachine', 'GraphMachine', ([], {'model': 'self'}), '(model=self, **machine_configs)\n', (299, 330), False, 'from transitions.extensions import GraphMac... |
import itertools
import random
import numpy as np
class Sudoku:
"""Class for creating and solving Sudoku puzzles"""
def _get_square(self, row, col):
"""
Returns coordinates for the square where the row,col coordinate is
"""
top = int(row / 3) * 3 # (0 or 1 or 2) * 3
... | [
"numpy.copy",
"numpy.where",
"numpy.random.choice",
"numpy.ndindex",
"numpy.logical_xor",
"numpy.invert",
"numpy.count_nonzero",
"numpy.sum",
"numpy.zeros",
"numpy.full",
"numpy.all",
"numpy.transpose"
] | [((939, 962), 'numpy.copy', 'np.copy', (['self.positions'], {}), '(self.positions)\n', (946, 962), True, 'import numpy as np\n'), ((983, 999), 'numpy.ndindex', 'np.ndindex', (['(3)', '(9)'], {}), '(3, 9)\n', (993, 999), True, 'import numpy as np\n'), ((4305, 4348), 'numpy.sum', 'np.sum', (['self.positions[:, row, col]'... |
"""
Modulo dedicado a classes/funções sem nenhuma outra dependência ou
que não sejam parte do core do Bot.
"""
import json
import requests
def photo_meetup(repo_data, matches):
"""
Recebe como entrada uma Dataclass com dados do nosso
repositório no Github e retorna a url de uma imagem
do meetup.
... | [
"json.loads",
"requests.get"
] | [((408, 461), 'requests.get', 'requests.get', (['contents_url'], {'headers': 'repo_data.headers'}), '(contents_url, headers=repo_data.headers)\n', (420, 461), False, 'import requests\n'), ((476, 504), 'json.loads', 'json.loads', (['response.content'], {}), '(response.content)\n', (486, 504), False, 'import json\n')] |
'''
Author : <NAME>
API Project for Olympics Database
Takes requests using the flask app route in browser and returns list of dictionaries containing results.
'''
import sys
import argparse
import flask
import json
import psycopg2
from config import user
from config import password
from config import datab... | [
"psycopg2.connect",
"flask.request.args.get",
"argparse.ArgumentParser",
"flask.Flask",
"json.dumps"
] | [((345, 366), 'flask.Flask', 'flask.Flask', (['__name__'], {}), '(__name__)\n', (356, 366), False, 'import flask\n'), ((389, 454), 'psycopg2.connect', 'psycopg2.connect', ([], {'database': 'database', 'user': 'user', 'password': 'password'}), '(database=database, user=user, password=password)\n', (405, 454), False, 'im... |
import random
import struct
# from numba import jit
from constants import *
# @jit
def serialize_list(list):
return_list = []
for i in list:
if i!=None:
return_list.append(i.to_JSON())
else:
return_list.append(None)
return return_list
def serialize_char_list(list, m... | [
"random.randint",
"struct.pack"
] | [((5052, 5073), 'random.randint', 'random.randint', (['(0)', '(10)'], {}), '(0, 10)\n', (5066, 5073), False, 'import random\n'), ((6306, 6329), 'struct.pack', 'struct.pack', (['"""!H"""', 'item'], {}), "('!H', item)\n", (6317, 6329), False, 'import struct\n'), ((6475, 6498), 'struct.pack', 'struct.pack', (['"""!I"""', ... |
# -*- coding: utf-8 -*-
import datetime
from south.db import db
from south.v2 import SchemaMigration
from django.db import models
class Migration(SchemaMigration):
def forwards(self, orm):
# Adding model 'SponsorListPlugin'
db.create_table('cmsplugin_sponsorlistplugin', (
('cmsplugin_... | [
"south.db.db.send_create_signal",
"django.db.models.ForeignKey",
"south.db.db.create_unique",
"django.db.models.AutoField",
"south.db.db.delete_table"
] | [((875, 934), 'south.db.db.send_create_signal', 'db.send_create_signal', (['"""sponsorship"""', "['SponsorListPlugin']"], {}), "('sponsorship', ['SponsorListPlugin'])\n", (896, 934), False, 'from south.db import db\n'), ((1379, 1485), 'south.db.db.create_unique', 'db.create_unique', (['"""sponsorship_sponsorlistplugin_... |
import asyncio
import base64
import binascii
import json
import logging
import os
import sys
from urllib.parse import urlparse
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from runners.agent_container import ( # noqa:E402
arg_parser,
create_agent_with_args,
AriesAgent,
)
f... | [
"logging.getLogger",
"runners.support.utils.prompt",
"runners.support.utils.log_timer",
"runners.support.utils.log_status",
"asyncio.sleep",
"asyncio.get_event_loop",
"asyncio.Future",
"json.loads",
"ptvsd.enable_attach",
"pydevd_pycharm.settrace",
"ptvsd.wait_for_attach",
"logging.basicConfig... | [((464, 506), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.WARNING'}), '(level=logging.WARNING)\n', (483, 506), False, 'import logging\n'), ((516, 543), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (533, 543), False, 'import logging\n'), ((1502, 1518), 'asyncio.... |
# Generated by Django 3.0.5 on 2020-04-29 18:19
import django.db.models.deletion
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('projects', '0004_remove_facet_count'),
]
operations = [
migrations.CreateModel(
name='FacetVari... | [
"django.db.models.ForeignKey",
"django.db.models.AutoField",
"django.db.models.CharField",
"django.db.models.IntegerField"
] | [((371, 464), 'django.db.models.AutoField', 'models.AutoField', ([], {'auto_created': '(True)', 'primary_key': '(True)', 'serialize': '(False)', 'verbose_name': '"""ID"""'}), "(auto_created=True, primary_key=True, serialize=False,\n verbose_name='ID')\n", (387, 464), False, 'from django.db import migrations, models\... |
import sys
import collections
def read_syscalls():
out = collections.OrderedDict()
for line in sys.stdin:
if not line or line[0] == '#' or line[0] == '\n':
continue
if line[-1] == '\n':
line = line[0:-1]
sline = line.split(' ')
if len(sline) != 2:
... | [
"collections.OrderedDict",
"sys.exit"
] | [((62, 87), 'collections.OrderedDict', 'collections.OrderedDict', ([], {}), '()\n', (85, 87), False, 'import collections\n'), ((1092, 1103), 'sys.exit', 'sys.exit', (['(1)'], {}), '(1)\n', (1100, 1103), False, 'import sys\n'), ((1296, 1307), 'sys.exit', 'sys.exit', (['(1)'], {}), '(1)\n', (1304, 1307), False, 'import s... |
import re
def soundex(name):
return ' '.join(process_word(word).upper()
for word in
name.split(' ')
)
def process_word(word):
fl = word[0]
word = word.lower()
word = word[0] + re.sub('[hw]', '', word[1:])
word = word.tr... | [
"re.sub",
"re.findall"
] | [((273, 301), 're.sub', 're.sub', (['"""[hw]"""', '""""""', 'word[1:]'], {}), "('[hw]', '', word[1:])\n", (279, 301), False, 'import re\n'), ((469, 501), 're.sub', 're.sub', (['"""[aeiouy]"""', '""""""', 'word[1:]'], {}), "('[aeiouy]', '', word[1:])\n", (475, 501), False, 'import re\n'), ((586, 609), 're.findall', 're.... |
"""
Low level transformations and actions.
Those methods and classes are described in detailed in
appendix T of the book.
@author rambabu.posa
"""
import os
import logging
from pyspark.sql import (SparkSession, functions as F)
def get_absolute_file_path(path, filename):
current_dir = os.path.dirname(__file__... | [
"logging.warning",
"os.path.join",
"os.path.dirname",
"pyspark.sql.functions.col",
"pyspark.sql.SparkSession.builder.appName",
"pyspark.sql.functions.count"
] | [((296, 321), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (311, 321), False, 'import os\n'), ((397, 437), 'os.path.join', 'os.path.join', (['current_dir', 'relative_path'], {}), '(current_dir, relative_path)\n', (409, 437), False, 'import os\n'), ((546, 632), 'logging.warning', 'logging.wa... |
#!/usr/bin/env python
# pylint: disable=C0116,W0613
# This program is dedicated to the public domain under the CC0 license.
"""
First, a few callback functions are defined. Then, those functions are passed to
the Dispatcher and registered at their respective places.
Then, the bot is started and runs until we press Ctr... | [
"telegram.Bot",
"telegram.ext.Updater"
] | [((742, 769), 'telegram.Bot', 'telegram.Bot', ([], {'token': 'API_KEY'}), '(token=API_KEY)\n', (754, 769), False, 'import telegram\n'), ((967, 983), 'telegram.ext.Updater', 'Updater', (['API_KEY'], {}), '(API_KEY)\n', (974, 983), False, 'from telegram.ext import Updater\n')] |
from src.core.python.DocumentConverter import DocumentConverter
from src.core.python.SupremeCourtOpinionMetadata import SupremeCourtOpinionMetadata
from src.core.python.SupremeCourtOpinion import SupremeCourtOpinion
import re
import os, os.path
class SupremeCourtOpinionFileConverter(DocumentConverter):
'''
<NA... | [
"os.path.exists",
"src.core.python.SupremeCourtOpinion.SupremeCourtOpinion",
"re.compile",
"src.core.python.SupremeCourtOpinionMetadata.SupremeCourtOpinionMetadata",
"re.search"
] | [((1281, 1302), 're.compile', 're.compile', (['"""\\\\.txt$"""'], {}), "('\\\\.txt$')\n", (1291, 1302), False, 'import re\n'), ((1831, 1876), 're.compile', 're.compile', (['"""\\\\* \\\\* \\\\* \\\\* \\\\* \\\\* \\\\* \\\\*"""'], {}), "('\\\\* \\\\* \\\\* \\\\* \\\\* \\\\* \\\\* \\\\*')\n", (1841, 1876), False, 'import... |
from unittest import TestCase, skipIf
from ...examples import get_path
from ..alpha_shapes import alpha_shape, alpha_shape_auto
import numpy as np
import os
try:
import geopandas
from shapely import geometry
GEOPANDAS_EXTINCT = False
except ImportError:
GEOPANDAS_EXTINCT = True
this_directory = os.pa... | [
"numpy.hstack",
"numpy.testing.assert_allclose",
"unittest.skipIf",
"os.path.join",
"numpy.column_stack",
"os.path.dirname",
"numpy.vstack"
] | [((315, 340), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (330, 340), False, 'import os\n'), ((344, 416), 'unittest.skipIf', 'skipIf', (['GEOPANDAS_EXTINCT', '"""Geopandas is missing, so test will not run."""'], {}), "(GEOPANDAS_EXTINCT, 'Geopandas is missing, so test will not run.')\n", (... |
import os
def is_root() -> bool:
return os.geteuid() == 0 | [
"os.geteuid"
] | [((45, 57), 'os.geteuid', 'os.geteuid', ([], {}), '()\n', (55, 57), False, 'import os\n')] |
import datetime
DESCRIBE_DBINSTANCES_RESPONSE = {
"DBInstances": [
{
"AllocatedStorage": 1,
"AutoMinorVersionUpgrade": True,
"AvailabilityZone": "us-east-1e",
"BackupRetentionPeriod": 35,
"CACertificateIdentifier": "abc-ca-2013",
"Cop... | [
"datetime.datetime"
] | [((2870, 2919), 'datetime.datetime', 'datetime.datetime', (['(2018)', '(8)', '(15)', '(1)', '(58)', '(59)', '(852000)'], {}), '(2018, 8, 15, 1, 58, 59, 852000)\n', (2887, 2919), False, 'import datetime\n')] |
import logging
import sys
# Multiple calls to logging.getLogger('someLogger') return a
# reference to the same logger object. This is true not only
# within the same module, but also across modules as long as
# it is in the same Python interpreter process.
FORMATTER = logging.Formatter(
"%(asctime)s — %(name)s ... | [
"logging.getLogger",
"logging.Formatter",
"logging.StreamHandler"
] | [((273, 381), 'logging.Formatter', 'logging.Formatter', (['"""%(asctime)s — %(name)s — %(levelname)s —%(funcName)s:%(lineno)d — %(message)s"""'], {}), "(\n '%(asctime)s — %(name)s — %(levelname)s —%(funcName)s:%(lineno)d — %(message)s'\n )\n", (290, 381), False, 'import logging\n'), ((432, 465), 'logging.StreamHa... |
import os
from pprint import pprint
from typing import List, Tuple
from logger import log_settings
from local_db import LocalDb, local_db_name
from dir_tree import CreateTree
app_log = log_settings()
local_path = "k:\\data\\paper_dtdt\\some_other\\"
class ParseFiles:
def __init__(self, tb_item):
self._ro... | [
"logger.log_settings",
"os.path.join",
"dir_tree.CreateTree",
"local_db.LocalDb",
"os.walk"
] | [((186, 200), 'logger.log_settings', 'log_settings', ([], {}), '()\n', (198, 200), False, 'from logger import log_settings\n'), ((1473, 1503), 'local_db.LocalDb', 'LocalDb', ([], {'db_name': 'local_db_name'}), '(db_name=local_db_name)\n', (1480, 1503), False, 'from local_db import LocalDb, local_db_name\n'), ((1540, 15... |
from django.db import models
# Create your models here.
class Article(models.Model):
title = models.CharField(max_length=100)
image = models.ImageField(default='null')
content = models.TextField()
public = models.BooleanField()
created_at = models.DateTimeField(auto_now_add=True)
updated_at = ... | [
"django.db.models.TextField",
"django.db.models.DateTimeField",
"django.db.models.BooleanField",
"django.db.models.ImageField",
"django.db.models.CharField"
] | [((99, 131), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(100)'}), '(max_length=100)\n', (115, 131), False, 'from django.db import models\n'), ((144, 177), 'django.db.models.ImageField', 'models.ImageField', ([], {'default': '"""null"""'}), "(default='null')\n", (161, 177), False, 'from djang... |
'''
XlPy/matched/remove
___________________
Helper class to remove base IDs from parsed modification lists.
:copyright: (c) 2015 The Regents of the University of California.
:license: GNU GPL, see licenses/GNU GPLv3.txt for more details.
'''
# load modules
from collections import namedtuple
from... | [
"collections.namedtuple",
"xldlib.utils.logger.init",
"xldlib.definitions.ZIP"
] | [((503, 538), 'collections.namedtuple', 'namedtuple', (['"""Threshold"""', '"""score ev"""'], {}), "('Threshold', 'score ev')\n", (513, 538), False, 'from collections import namedtuple\n'), ((1299, 1330), 'xldlib.utils.logger.init', 'logger.init', (['"""matched"""', '"""DEBUG"""'], {}), "('matched', 'DEBUG')\n", (1310,... |
# -*- coding: utf-8 -*-
import os
import os.path
import difflib
from io import StringIO
import pandas as pd
def main():
original_dir = 'separate_jornaldata/'
append_dir = 'sepv2/'
original_filelist = os.listdir(original_dir)
append_filelist = [item for item in os.listdir(append_dir) if os.path.splitext... | [
"os.listdir",
"pandas.concat",
"os.path.splitext"
] | [((213, 237), 'os.listdir', 'os.listdir', (['original_dir'], {}), '(original_dir)\n', (223, 237), False, 'import os\n'), ((278, 300), 'os.listdir', 'os.listdir', (['append_dir'], {}), '(append_dir)\n', (288, 300), False, 'import os\n'), ((1381, 1428), 'pandas.concat', 'pd.concat', (['[originaldataframe, appenddataframe... |
from PySide2 import QtWidgets
import shiboken2
import maya.OpenMayaUI as apiUI
def getMayaWindow():
"""
Get the main Maya window as a QtGui.QMainWindow instance
@return: QtGui.QMainWindow instance of the top level Maya windows
"""
ptr = apiUI.MQtUtil.mainWindow()
if ptr is not None:
re... | [
"maya.OpenMayaUI.MQtUtil.mainWindow",
"PySide2.QtWidgets.QVBoxLayout",
"PySide2.QtWidgets.QLabel"
] | [((259, 285), 'maya.OpenMayaUI.MQtUtil.mainWindow', 'apiUI.MQtUtil.mainWindow', ([], {}), '()\n', (283, 285), True, 'import maya.OpenMayaUI as apiUI\n'), ((533, 560), 'PySide2.QtWidgets.QVBoxLayout', 'QtWidgets.QVBoxLayout', (['self'], {}), '(self)\n', (554, 560), False, 'from PySide2 import QtWidgets\n'), ((595, 621),... |
"""
https://github.com/Fredkiss3/kge
Copyright (C) 2020-2021 <NAME>
THIS GAME ENGINE USE A COMBINATION OF GAME ENGINES :
- PYGLET : FOR RENDERING AND SOUND SYSTEM
- PYGAME : FOR JOYSTICK CONTROL
inspired by PPB ENGINE:
Checkout the repository : https://github.com/ppb/pursuedpybear/
"""
#: The re... | [
"logging.basicConfig",
"kge.utils.vector.Vector.Zero"
] | [((5042, 5078), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'log_level'}), '(level=log_level)\n', (5061, 5078), False, 'import logging\n'), ((3880, 3893), 'kge.utils.vector.Vector.Zero', 'Vector.Zero', ([], {}), '()\n', (3891, 3893), False, 'from kge.utils.vector import Vector\n')] |
'''
Test Runbooks.py render_runbooks()
'''
import mock
import unittest
from runbooks import render_runbooks
class RenderRunbooksIntegrationTest(unittest.TestCase):
''' Run unit tests against the cache_runbooks method '''
def setUp(self):
''' Setup mocked data '''
self.runbooks = """
... | [
"runbooks.render_runbooks"
] | [((683, 725), 'runbooks.render_runbooks', 'render_runbooks', (['self.runbooks', 'self.facts'], {}), '(self.runbooks, self.facts)\n', (698, 725), False, 'from runbooks import render_runbooks\n'), ((961, 1003), 'runbooks.render_runbooks', 'render_runbooks', (['self.runbooks', 'self.facts'], {}), '(self.runbooks, self.fac... |
#!/usr/bin/env python3
"""Trains an action predictor on estimated IkeaDB poses."""
import numpy as np
import addpaths # noqa
from load import loadDataset
from common_pp.act_class_model import train_act_class_model
if __name__ == '__main__':
dataset = loadDataset()
merge_map = {
'attach leg 1': '*ta... | [
"load.loadDataset",
"common_pp.act_class_model.train_act_class_model"
] | [((260, 273), 'load.loadDataset', 'loadDataset', ([], {}), '()\n', (271, 273), False, 'from load import loadDataset\n'), ((641, 706), 'common_pp.act_class_model.train_act_class_model', 'train_act_class_model', (['dataset', 'merge_map'], {'balance_func': 'np.median'}), '(dataset, merge_map, balance_func=np.median)\n', (... |
# -*- coding: utf-8 -*-
"""
* TencentBlueKing is pleased to support the open source community by making 蓝鲸智云-蓝鲸 PaaS 平台(BlueKing-PaaS) available.
* Copyright (C) 2017-2021 TH<NAME>, a Tencent company. All rights reserved.
* Licensed under the MIT License (the "License"); you may not use this file except in complianc... | [
"unittest.main",
"blue_krill.encrypt.legacy.legacy_encrypt",
"cryptography.fernet.Fernet.generate_key",
"blue_krill.encrypt.legacy.legacy_decrypt"
] | [((1618, 1633), 'unittest.main', 'unittest.main', ([], {}), '()\n', (1631, 1633), False, 'import unittest\n'), ((1448, 1485), 'blue_krill.encrypt.legacy.legacy_decrypt', 'legacy_decrypt', (['encrypted_s', "('a' * 24)"], {}), "(encrypted_s, 'a' * 24)\n", (1462, 1485), False, 'from blue_krill.encrypt.legacy import legacy... |
# Copyright (c) <NAME>
# This source code is licensed under the BSD-style license found in the
# LICENSE file in the root directory of this source tree.
"""
Manning's counter-ion condensation theory for thermodynamics of ions
in charged membranes.
"""
import warnings
import math
from membrane_toolkit.core.unitized im... | [
"warnings.warn",
"math.exp",
"scipy.optimize.brentq",
"membrane_toolkit.core.unitized.ureg"
] | [((1712, 1730), 'membrane_toolkit.core.unitized.ureg', 'ureg', (['fixed_charge'], {}), '(fixed_charge)\n', (1716, 1730), False, 'from membrane_toolkit.core.unitized import ureg\n'), ((4761, 4824), 'scipy.optimize.brentq', 'brentq', (['manning_solve', '(1e-10)', '(2 * conc_co.magnitude)'], {'xtol': '(1e-06)'}), '(mannin... |
from datetime import datetime
class Vote:
def __init__(self, user_id: str, poll_id: str, chosen_option: int):
self.user_id = user_id
self.poll_id = poll_id
self.chosen_option = chosen_option
self.timestamp = datetime.now().timestamp() # o alex to ekane
def __eq__(self, other):... | [
"datetime.datetime.now"
] | [((246, 260), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (258, 260), False, 'from datetime import datetime\n')] |
import time
import tests.config as config
test_value = "db_connections.0.host"
start = time.time()
for i in range(1000):
config.get_config(test_value)
print(time.time() - start, 'seconds')
| [
"time.time",
"tests.config.get_config"
] | [((90, 101), 'time.time', 'time.time', ([], {}), '()\n', (99, 101), False, 'import time\n'), ((129, 158), 'tests.config.get_config', 'config.get_config', (['test_value'], {}), '(test_value)\n', (146, 158), True, 'import tests.config as config\n'), ((166, 177), 'time.time', 'time.time', ([], {}), '()\n', (175, 177), Fal... |
import cv2
import math
import torch
import torchvision
import numpy as np
from copy import deepcopy
class AffineTransform(object):
def __init__(self, input_res=256, output_res=64, rotation_prob=0.6):
self.input_res = input_res
self.output_res = output_res
self.rotation_prob = rotation_pro... | [
"cv2.warpAffine",
"numpy.random.random",
"numpy.dot",
"numpy.cos",
"numpy.random.uniform",
"numpy.sin",
"numpy.float32",
"numpy.round"
] | [((430, 483), 'numpy.float32', 'np.float32', (['[[1, 0, pt[0]], [0, 1, pt[1]], [0, 0, 1]]'], {}), '([[1, 0, pt[0]], [0, 1, pt[1]], [0, 0, 1]])\n', (440, 483), True, 'import numpy as np\n'), ((761, 811), 'numpy.float32', 'np.float32', (['[[cs, -sn, 0], [sn, cs, 0], [0, 0, 1]]'], {}), '([[cs, -sn, 0], [sn, cs, 0], [0, 0,... |
"""
Unit tests for the ska_tmc_cdm.messages.subarray_node.configure.csp module.
"""
import functools
import itertools
import copy
import pytest
from ska_tmc_cdm.messages.subarray_node.configure.core import ReceiverBand
from ska_tmc_cdm.messages.subarray_node.configure.csp import (
CBFConfiguration,
CommonConf... | [
"ska_tmc_cdm.messages.subarray_node.configure.csp.CommonConfiguration",
"ska_tmc_cdm.messages.subarray_node.configure.csp.CBFConfiguration",
"ska_tmc_cdm.messages.subarray_node.configure.csp.SubarrayConfiguration",
"ska_tmc_cdm.messages.subarray_node.configure.csp.PSSConfiguration",
"itertools.count",
"fu... | [((1289, 1363), 'ska_tmc_cdm.messages.subarray_node.configure.csp.CommonConfiguration', 'CommonConfiguration', (['config_id', 'frequency_band', 'subarray_id', 'band_5_tuning'], {}), '(config_id, frequency_band, subarray_id, band_5_tuning)\n', (1308, 1363), False, 'from ska_tmc_cdm.messages.subarray_node.configure.csp i... |
import time
from selenium import webdriver
# chromedriver.exe放到python.exe所在目录就不需要在下面Chrome()里写上路径了
driver =webdriver.Chrome()
driver.get('https://www.baidu.com/')
input_div=driver.find_element_by_id("kw").send_keys('python')
driver.find_element_by_xpath('//*[@id="su"]').click()
time.sleep(5) # delays for 5 seconds
d... | [
"selenium.webdriver.Chrome",
"time.sleep"
] | [((109, 127), 'selenium.webdriver.Chrome', 'webdriver.Chrome', ([], {}), '()\n', (125, 127), False, 'from selenium import webdriver\n'), ((282, 295), 'time.sleep', 'time.sleep', (['(5)'], {}), '(5)\n', (292, 295), False, 'import time\n')] |
from random import randint
from typing import List
def is_sorted(target: list) -> bool:
'''
Checks if the target list is sorted in ascending order.
'''
for i in range(len(target) - 1):
if target[i] > target[i + 1]:
return False
return True
def random_int_list(
length: int... | [
"random.randint"
] | [((450, 479), 'random.randint', 'randint', (['min_value', 'max_value'], {}), '(min_value, max_value)\n', (457, 479), False, 'from random import randint\n')] |
import matplotlib.pyplot as plt
from data import MEASUREMENTS_STABLE_WAN, MEASUREMENTS_BARE_LATENCY_LAN_ABFT, MEASUREMENTS_BARE_LATENCY_LAN_BEAT_BEAT, MEASUREMENTS_BARE_LATENCY_LAN_BEAT_HB, MEASUREMENTS_BARE_LATENCY_WAN_ABFT, MEASUREMENTS_BARE_LATENCY_WAN_DUMBO_HB, MEASUREMENTS_BARE_LATENCY_WAN_DUMBO_DUMBO1, MEASUREMEN... | [
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.xticks",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.gca",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.clf",
"IPython.embed",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.tight_layout",
"matplotlib.pyplot.ylim",
"matplotlib.pyplot.xlim",
... | [((879, 908), 'matplotlib.pyplot.figure', 'plt.figure', (['(1)'], {'figsize': '(7, 5)'}), '(1, figsize=(7, 5))\n', (889, 908), True, 'import matplotlib.pyplot as plt\n'), ((913, 922), 'matplotlib.pyplot.clf', 'plt.clf', ([], {}), '()\n', (920, 922), True, 'import matplotlib.pyplot as plt\n'), ((2019, 2051), 'matplotlib... |
"""[summary]
Returns:
[type]: [description]
"""
import pickle
import sys
import numpy as np
def gen_label(x):
"""[summary]
Args:
x ([type]): [description]
Returns:
[type]: [description]
"""
if 1 <= x <= 10:
return 2
if 11 <= x <= 100:
return 1
return ... | [
"numpy.array"
] | [((1723, 1755), 'numpy.array', 'np.array', (['real_label_id_features'], {}), '(real_label_id_features)\n', (1731, 1755), True, 'import numpy as np\n'), ((1757, 1788), 'numpy.array', 'np.array', (['ext_label_id_features'], {}), '(ext_label_id_features)\n', (1765, 1788), True, 'import numpy as np\n')] |
# coding=utf-8
import os
import json
ROOT_PATH = './new_json_v2_other_in(copy 2)'
path_list = [os.path.join(ROOT_PATH, p) for p in os.listdir(ROOT_PATH)]
record = 0
record_error = 0
children_err_list = []
top_layer_err_list = []
count_dict = {}
for p in path_list:
count = 0
count_1 = 0
try:
data ... | [
"os.listdir",
"os.path.join"
] | [((98, 124), 'os.path.join', 'os.path.join', (['ROOT_PATH', 'p'], {}), '(ROOT_PATH, p)\n', (110, 124), False, 'import os\n'), ((134, 155), 'os.listdir', 'os.listdir', (['ROOT_PATH'], {}), '(ROOT_PATH)\n', (144, 155), False, 'import os\n')] |
"""Actions to be run after a successful Cookie bake."""
import glob
from pathlib import Path
from urllib.request import Request, urlopen
def run():
"""Actions to be run."""
req = Request(
url="https://www.gitignore.io/api/node,composer",
headers={"User-Agent": "Python"},
)
Path("../.gi... | [
"urllib.request.Request",
"urllib.request.urlopen",
"glob.glob",
"pathlib.Path"
] | [((189, 285), 'urllib.request.Request', 'Request', ([], {'url': '"""https://www.gitignore.io/api/node,composer"""', 'headers': "{'User-Agent': 'Python'}"}), "(url='https://www.gitignore.io/api/node,composer', headers={\n 'User-Agent': 'Python'})\n", (196, 285), False, 'from urllib.request import Request, urlopen\n')... |
from django.shortcuts import render, redirect
from core.models import ContactModel
# Create your views here.
def index(request):
if request.method == "POST":
name = request.POST.get("name")
email = request.POST.get("email")
concerntype = request.POST.get("concerntype")
phone_no = ... | [
"django.shortcuts.render",
"core.models.ContactModel",
"django.shortcuts.redirect"
] | [((586, 614), 'django.shortcuts.render', 'render', (['request', '"""main.html"""'], {}), "(request, 'main.html')\n", (592, 614), False, 'from django.shortcuts import render, redirect\n'), ((419, 521), 'core.models.ContactModel', 'ContactModel', ([], {'name': 'name', 'email': 'email', 'concerntype': 'concerntype', 'phon... |
from datetime import datetime
from sqlobject import SQLObject, SQLObjectNotFound, RelatedJoin, \
DateTimeCol, IntCol, StringCol, UnicodeCol
from sqlobject.inheritance import InheritableSQLObject
import warnings
import logging
log = logging.getLogger("turbogears.identity.soprovider")
import turbogears
from turbog... | [
"logging.getLogger",
"turbogears.identity._encrypt_password",
"sqlobject.DateTimeCol",
"turbogears.identity.get_failure_url",
"sqlobject.UnicodeCol",
"sqlobject.IntCol",
"sqlobject.StringCol",
"turbogears.identity.current_provider.encrypt_password",
"sqlobject.RelatedJoin",
"turbojson.jsonify.json... | [((238, 289), 'logging.getLogger', 'logging.getLogger', (['"""turbogears.identity.soprovider"""'], {}), "('turbogears.identity.soprovider')\n", (255, 289), False, 'import logging\n'), ((487, 520), 'turbogears.database.PackageHub', 'PackageHub', (['"""turbogears.identity"""'], {}), "('turbogears.identity')\n", (497, 520... |
# -*- coding: utf-8 -*-
# Copyright (c) 2020 <NAME>
# Copyright (c) 2020 Instituto Nacional de Tecnologïa Industrial
# License: Apache 2.0
# Project: KiAuto (formerly kicad-automation-scripts)
import os
import re
from sys import exit, path
# Default W,H for recording
REC_W = 1366
REC_H = 960
# Return error codes
# Po... | [
"sys.path.insert",
"os.path.join",
"os.environ.get",
"os.path.splitext",
"os.path.isfile",
"sys.exit",
"os.stat",
"pcbnew.GetBuildVersion"
] | [((2902, 2937), 'os.environ.get', 'os.environ.get', (['"""KIAUS_USE_NIGHTLY"""'], {}), "('KIAUS_USE_NIGHTLY')\n", (2916, 2937), False, 'import os\n'), ((4401, 4467), 'os.path.join', 'os.path.join', (["os.environ['HOME']", "('.config/' + self.kicad_conf_dir)"], {}), "(os.environ['HOME'], '.config/' + self.kicad_conf_dir... |
import os
import argparse
from sentivi import Pipeline
from sentivi.data import DataLoader, TextEncoder
from sentivi.classifier import *
from sentivi.text_processor import TextProcessor
CLASSIFIER = SVMClassifier
ENCODING_TYPE = ['one-hot', 'bow', 'tf-idf', 'word2vec']
if __name__ == '__main__':
argument_parser... | [
"sentivi.data.DataLoader",
"argparse.ArgumentParser",
"os.path.join",
"sentivi.data.TextEncoder",
"sentivi.text_processor.TextProcessor"
] | [((323, 392), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Sentiment Analysis Experiments"""'}), "(description='Sentiment Analysis Experiments')\n", (346, 392), False, 'import argparse\n'), ((853, 919), 'sentivi.text_processor.TextProcessor', 'TextProcessor', ([], {'methods': "['word_s... |
import logging
import os
import torch
import torch.nn as nn
import torch.nn.functional as F
from transformers.modeling_bert import BertLayerNorm, BertPreTrainedModel, BertModel
from transformers.activations import get_activation
class MLPWithLayerNorm(nn.Module):
''' MLP layer with layer regularization
'''
... | [
"transformers.modeling_bert.BertModel.from_pretrained",
"transformers.modeling_bert.BertLayerNorm",
"transformers.activations.get_activation",
"torch.nn.functional.cross_entropy",
"torch.nn.Linear"
] | [((465, 506), 'torch.nn.Linear', 'nn.Linear', (['input_size', 'config.hidden_size'], {}), '(input_size, config.hidden_size)\n', (474, 506), True, 'import torch.nn as nn\n'), ((531, 569), 'transformers.activations.get_activation', 'get_activation', (['self.config.hidden_act'], {}), '(self.config.hidden_act)\n', (545, 56... |
# MIT License
#
# Copyright (c) 2018 <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 limitation the rights
# to use, copy, modify, merge, pub... | [
"numpy.abs",
"numpy.log",
"tqdm.tqdm",
"numpy.argmax",
"utility.extract_spectrum",
"os.path.join",
"os.path.normpath",
"traceback.print_exc",
"utility.create_audio_sample",
"torch.zeros"
] | [((2225, 2246), 'tqdm.tqdm', 'tqdm', (['_h5_video_names'], {}), '(_h5_video_names)\n', (2229, 2246), False, 'from tqdm import tqdm\n'), ((2805, 2829), 'numpy.argmax', 'np.argmax', (['(array > value)'], {}), '(array > value)\n', (2814, 2829), True, 'import numpy as np\n'), ((4295, 4324), 'utility.extract_spectrum', 'ut.... |
# Generated by Django 2.2.2 on 2019-07-07 16:09
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('campus_app', '0009_noticia_dia_publicacao'),
]
operations = [
migrations.AlterField(
model_name='noticia',
name='dia... | [
"django.db.models.DateField"
] | [((352, 387), 'django.db.models.DateField', 'models.DateField', ([], {'auto_now_add': '(True)'}), '(auto_now_add=True)\n', (368, 387), False, 'from django.db import migrations, models\n')] |
# -*- coding: utf-8 -*-
#================================================================
# God Bless You.
#
# author: klaus
# email: <EMAIL>
# created date: 2019/12/17
# description:
#
#================================================================
import os
import time
from easydict import EasyDict
impor... | [
"tensorflow.train.Checkpoint",
"tensorflow.summary.experimental.set_step",
"os.makedirs",
"tensorflow.Variable",
"tensorflow.keras.metrics.Mean",
"os.path.join",
"easydict.EasyDict",
"tensorflow.summary.experimental.get_step",
"time.time"
] | [((1946, 1956), 'easydict.EasyDict', 'EasyDict', ([], {}), '()\n', (1954, 1956), False, 'from easydict import EasyDict\n'), ((1987, 1997), 'easydict.EasyDict', 'EasyDict', ([], {}), '()\n', (1995, 1997), False, 'from easydict import EasyDict\n'), ((2026, 2036), 'easydict.EasyDict', 'EasyDict', ([], {}), '()\n', (2034, ... |
# Copyright 2013 - <NAME>
#
# 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 in writing, so... | [
"six.moves.urllib.parse.urlencode",
"solumclient.openstack.common.apiclient.exceptions.NotFound",
"solumclient.openstack.common.apiclient.exceptions.NoUniqueMatch"
] | [((3942, 3966), 'solumclient.openstack.common.apiclient.exceptions.NotFound', 'exceptions.NotFound', (['msg'], {}), '(msg)\n', (3961, 3966), False, 'from solumclient.openstack.common.apiclient import exceptions\n'), ((4015, 4041), 'solumclient.openstack.common.apiclient.exceptions.NoUniqueMatch', 'exceptions.NoUniqueMa... |
import sqlite3
import json
import datetime
import time
import logging
import logging.config
from flask import Flask
from flask import g
from flask import Response
from flask import request
application = Flask(__name__)
logging.config.fileConfig("logging.conf")
logger = logging.getLogger()
DATABASE = "/opt/hotpiweb/t... | [
"logging.getLogger",
"datetime.datetime",
"flask.request.args.get",
"sqlite3.connect",
"flask.Flask",
"datetime.datetime.utcnow",
"json.dumps",
"logging.config.fileConfig",
"datetime.timedelta",
"time.time",
"flask.request.args.has_key"
] | [((204, 219), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (209, 219), False, 'from flask import Flask\n'), ((221, 262), 'logging.config.fileConfig', 'logging.config.fileConfig', (['"""logging.conf"""'], {}), "('logging.conf')\n", (246, 262), False, 'import logging\n'), ((272, 291), 'logging.getLogger', ... |
import re
import numpy
import math
from gensim.models import Word2Vec
from .. import resources
import logging
log = logging.getLogger(__name__)
class Embedder:
""" Embeds words and sentences into a vector of real values.
Params:
word_embedding_model (Word2Vec) - A word to vector model already made a... | [
"logging.getLogger",
"re.sub"
] | [((118, 145), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (135, 145), False, 'import logging\n'), ((2778, 2812), 're.sub', 're.sub', (['"""[^A-Za-z ]"""', '""""""', 'sentence'], {}), "('[^A-Za-z ]', '', sentence)\n", (2784, 2812), False, 'import re\n')] |
import os
import pytest
@pytest.fixture
def test_data():
import numpy as np
test_data_file = os.path.join(os.path.dirname(os.path.realpath(__file__)),
'data', 'laserembeddings-test-data.npz')
return np.load(test_data_file) if os.path.isfile(test_data_file) else None
| [
"os.path.isfile",
"numpy.load",
"os.path.realpath"
] | [((276, 306), 'os.path.isfile', 'os.path.isfile', (['test_data_file'], {}), '(test_data_file)\n', (290, 306), False, 'import os\n'), ((249, 272), 'numpy.load', 'np.load', (['test_data_file'], {}), '(test_data_file)\n', (256, 272), True, 'import numpy as np\n'), ((133, 159), 'os.path.realpath', 'os.path.realpath', (['__... |
import requests
from . import scrape_leafly as sl
from bs4 import BeautifulSoup as bs
from selenium import webdriver
from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
import re
from fake_useragent import UserAgent
import multiprocessing as mp
import os
import time
import pickle as pk
ua = ... | [
"os.path.exists",
"requests.get",
"multiprocessing.cpu_count",
"bs4.BeautifulSoup",
"time.sleep",
"multiprocessing.Pool",
"os.mkdir",
"re.sub",
"fake_useragent.UserAgent",
"re.search"
] | [((320, 331), 'fake_useragent.UserAgent', 'UserAgent', ([], {}), '()\n', (329, 331), False, 'from fake_useragent import UserAgent\n'), ((874, 928), 'requests.get', 'requests.get', (['TEST_URL'], {'headers': 'headers', 'cookies': 'cooks'}), '(TEST_URL, headers=headers, cookies=cooks)\n', (886, 928), False, 'import reque... |
#!/usr/bin/env python
from setuptools import setup
setup(name='pyvctrl',
version='1.0',
description='A simple Python wrapper for the vcontrold/vclient programs',
author='<NAME>',
author_email='<EMAIL>',
url='https://github.com/dirkbaechle/pyvctrl',
packages=['pyvctrl'],
scrip... | [
"setuptools.setup"
] | [((53, 321), 'setuptools.setup', 'setup', ([], {'name': '"""pyvctrl"""', 'version': '"""1.0"""', 'description': '"""A simple Python wrapper for the vcontrold/vclient programs"""', 'author': '"""<NAME>"""', 'author_email': '"""<EMAIL>"""', 'url': '"""https://github.com/dirkbaechle/pyvctrl"""', 'packages': "['pyvctrl']",... |
#!/usr/bin/python3
# -*- coding: utf-8 -*-
import re
import subprocess
import sys
from pathlib import Path
from dateutil.parser import parse
DIRNAME = Path(__file__).parent.absolute()
PATTERN = "::error file={},line={}::{}"
rc = 0
def log_error(file, line, message):
global rc
print(PATTERN.format(file.rel... | [
"dateutil.parser.parse",
"pathlib.Path",
"pathlib.Path.cwd",
"re.compile",
"subprocess.run",
"sys.exit"
] | [((419, 429), 'pathlib.Path.cwd', 'Path.cwd', ([], {}), '()\n', (427, 429), False, 'from pathlib import Path\n'), ((520, 569), 'subprocess.run', 'subprocess.run', (['cmd'], {'capture_output': '(True)', 'cwd': 'cwd'}), '(cmd, capture_output=True, cwd=cwd)\n', (534, 569), False, 'import subprocess\n'), ((1081, 1128), 're... |
# U-Net Model Construction
import unittest
import numpy as np
import keras
from keras.models import *
from keras.layers import *
from keras.optimizers import *
from keras.regularizers import l1, l2
from keras import backend as K
def sagittal_spine_unet(input_size, num_classes, filter_multiplier=10, regularization... | [
"keras.backend.sum",
"keras.layers.UpSampling2D",
"keras.backend.square",
"numpy.zeros",
"keras.backend.log",
"keras.regularizers.l1",
"unittest.main",
"keras.backend.variable",
"numpy.log2",
"keras.backend.abs",
"keras.backend.epsilon"
] | [((496, 529), 'numpy.zeros', 'np.zeros', (['[num_layers]'], {'dtype': 'int'}), '([num_layers], dtype=int)\n', (504, 529), True, 'import numpy as np\n'), ((556, 589), 'numpy.zeros', 'np.zeros', (['[num_layers]'], {'dtype': 'int'}), '([num_layers], dtype=int)\n', (564, 589), True, 'import numpy as np\n'), ((617, 650), 'n... |
from datetime import datetime
import json
import os
import shutil
import sys
from django.contrib.auth.models import User
from django.core.management import call_command
from django.core.management.base import BaseCommand
from django.utils.dateparse import parse_datetime
from django.utils.timezone import utc
from djang... | [
"django.utils.dateparse.parse_datetime",
"django.contrib.auth.models.User.objects.first",
"os.remove",
"datetime.datetime",
"os.path.exists",
"os.listdir",
"container.models.ContainerFamily.objects.create",
"os.path.split",
"os.path.isdir",
"django.core.management.call_command",
"os.rename",
"... | [((1016, 1037), 'django.core.management.call_command', 'call_command', (['"""reset"""'], {}), "('reset')\n", (1028, 1037), False, 'from django.core.management import call_command\n'), ((2271, 2297), 'os.remove', 'os.remove', (['before_filename'], {}), '(before_filename)\n', (2280, 2297), False, 'import os\n'), ((2306, ... |
# TODO 阿里云短信验证码服务类，构建类时请传入字符串类型的手机号和验证码
import sys
from typing import List
from alibabacloud_dysmsapi20170525 import models as dysmsapi_20170525_models
from alibabacloud_dysmsapi20170525.client import Client as Dysmsapi20170525Client
from alibabacloud_tea_openapi import models as open_api_models
class Sample(object)... | [
"alibabacloud_dysmsapi20170525.client.Client",
"alibabacloud_tea_openapi.models.Config"
] | [((683, 745), 'alibabacloud_tea_openapi.models.Config', 'open_api_models.Config', ([], {'access_key_id': '""""""', 'access_key_secret': '""""""'}), "(access_key_id='', access_key_secret='')\n", (705, 745), True, 'from alibabacloud_tea_openapi import models as open_api_models\n'), ((942, 972), 'alibabacloud_dysmsapi2017... |
# Generated by Django 3.1.5 on 2021-03-06 17:29
from django.db import migrations, models
def forward(apps, schema_editor):
Entitat = apps.get_model("cole", "Entitat")
try:
entitat_instance = Entitat.objects.all()[0]
if entitat_instance:
return
except:
pass
entitat_i... | [
"django.db.migrations.RunPython"
] | [((512, 541), 'django.db.migrations.RunPython', 'migrations.RunPython', (['forward'], {}), '(forward)\n', (532, 541), False, 'from django.db import migrations, models\n')] |
import argparse
from typing import Optional, Dict, Type
from cpk.cli import AbstractCLICommand
from cpk.cli.commands.endpoint.info import CLIEndpointInfoCommand
from cpk.types import Machine, Arguments
_supported_subcommands: Dict[str, Type[AbstractCLICommand]] = {
"info": CLIEndpointInfoCommand,
}
class CLIEnd... | [
"argparse.ArgumentParser"
] | [((620, 682), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'parents': '[parent]', 'prog': '"""cpk endpoint"""'}), "(parents=[parent], prog='cpk endpoint')\n", (643, 682), False, 'import argparse\n')] |
import re as regex
from enum import Enum
import bs4
class AuditAction(Enum):
DeletePost = 1
RemoveMember = 2
AcceptJoinRequest = 3
DeclineJoinRequest = 4
PostStatus = 5
ChangeRank = 6
BuyAd = 7
SendAllyRequest = 8
CreateEnemy = 9
AcceptAllyRequest = 10
DeclineAllyRequest = 11
DeleteAlly =... | [
"re.search"
] | [((2120, 2177), 're.search', 'regex.search', (['"""/User\\\\.aspx\\\\?ID=(\\\\d+)"""', "element['href']"], {}), "('/User\\\\.aspx\\\\?ID=(\\\\d+)', element['href'])\n", (2132, 2177), True, 'import re as regex\n'), ((2390, 2456), 're.search', 'regex.search', (['"""/Groups/group\\\\.aspx\\\\?gid=(\\\\d+)"""', "element['h... |
# Generated by Django 3.1.8 on 2021-06-21 13:53
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('speechdb', '0018_auto_20210621_0958'),
]
operations = [
migrations.AddField(
model_name='work',
name='lang',
... | [
"django.db.models.CharField"
] | [((331, 433), 'django.db.models.CharField', 'models.CharField', ([], {'choices': "[('greek', 'Greek'), ('latin', 'Latin')]", 'default': '"""latin"""', 'max_length': '(8)'}), "(choices=[('greek', 'Greek'), ('latin', 'Latin')], default=\n 'latin', max_length=8)\n", (347, 433), False, 'from django.db import migrations,... |
# -*- coding: utf-8 -*-
"""
Tencent is pleased to support the open source community by making BK-BASE 蓝鲸基础平台 available.
Copyright (C) 2021 THL A29 Limited, a Tencent company. All rights reserved.
BK-BASE 蓝鲸基础平台 is licensed under the MIT License.
License for BK-BASE 蓝鲸基础平台:
------------------------------------------... | [
"common.local.get_request_username",
"datahub.databus.exceptions.SchemaDiffError",
"datahub.databus.api.MetaApi.data_processings.update",
"common.log.logger.warning",
"datahub.databus.exceptions.TransfromProcessingNotFoundError",
"datahub.databus.rt.get_rt_fields_storages",
"datahub.databus.exceptions.D... | [((5766, 5798), 'datahub.databus.rt.get_rt_fields_storages', 'rt.get_rt_fields_storages', (['rt_id'], {}), '(rt_id)\n', (5791, 5798), False, 'from datahub.databus import channel, model_manager, rt, settings\n'), ((6929, 7008), 'datahub.databus.channel.get_inner_channel_to_use', 'channel.get_inner_channel_to_use', (["no... |
import sys
import os
current = os.path.dirname(os.path.realpath(__file__))
sieve_root = os.path.dirname(os.path.dirname(os.path.dirname(current)))
sys.path.append(sieve_root)
from sieve_test_driver.test_framework import new_built_in_workload
from sieve_common.common import RUNNING, TERMINATED
test_cases = {
"w1"... | [
"os.path.realpath",
"os.path.dirname",
"sieve_test_driver.test_framework.new_built_in_workload",
"sys.path.append"
] | [((148, 175), 'sys.path.append', 'sys.path.append', (['sieve_root'], {}), '(sieve_root)\n', (163, 175), False, 'import sys\n'), ((48, 74), 'os.path.realpath', 'os.path.realpath', (['__file__'], {}), '(__file__)\n', (64, 74), False, 'import os\n'), ((121, 145), 'os.path.dirname', 'os.path.dirname', (['current'], {}), '(... |