code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
import autograd.numpy as np
from regression.nn.npy.nn_ag import NNRegressor as agNetwork
from regression.nn.npy.nn_npy import NNRegressor as npNetwork
if __name__ == '__main__':
from sklearn.datasets import load_breast_cancer
from sklearn.model_selection import train_test_split
from sklearn.preprocessi... | [
"autograd.numpy.rint",
"sklearn.model_selection.train_test_split",
"sklearn.preprocessing.OneHotEncoder",
"sklearn.datasets.load_breast_cancer",
"sklearn.preprocessing.StandardScaler",
"regression.nn.npy.nn_ag.NNRegressor",
"regression.nn.npy.nn_npy.NNRegressor",
"autograd.numpy.mean"
] | [((408, 428), 'sklearn.datasets.load_breast_cancer', 'load_breast_cancer', ([], {}), '()\n', (426, 428), False, 'from sklearn.datasets import load_breast_cancer\n'), ((479, 511), 'sklearn.preprocessing.OneHotEncoder', 'OneHotEncoder', ([], {'categories': '"""auto"""'}), "(categories='auto')\n", (492, 511), False, 'from... |
#!/usr/bin/python
import os
import matplotlib.pyplot as plt
import numpy as np
from post_process import load
# from scipy.stats import iqr
class InformationCapacity(object):
def __init__(self, foreign_directory="./", self_directory="./", estimator='fd', limiting='foreign'):
self.num_steps = 1
... | [
"os.path.exists",
"numpy.histogram",
"numpy.mean",
"matplotlib.pyplot.hist",
"numpy.trapz",
"numpy.log2",
"post_process.load",
"numpy.loadtxt",
"matplotlib.pyplot.legend"
] | [((9159, 9186), 'numpy.loadtxt', 'np.loadtxt', (['"""L_self/output"""'], {}), "('L_self/output')\n", (9169, 9186), True, 'import numpy as np\n'), ((9217, 9260), 'numpy.loadtxt', 'np.loadtxt', (['"""3_step_end_step/L_self/output"""'], {}), "('3_step_end_step/L_self/output')\n", (9227, 9260), True, 'import numpy as np\n'... |
#!/usr/bin/python3
from core.api import collectApi
@collectApi("LOAD5", "Cpu Avg Load 5", 5)
def cpu_load_5():
f = open("/proc/loadavg")
con = f.read().split()
f.close()
return float(con[1])
@collectApi("LOAD1", "Cpu Avg Load 1", 1)
def cpu_load_1():
f = open("/proc/loadavg")
con = f.read().s... | [
"core.api.collectApi"
] | [((54, 94), 'core.api.collectApi', 'collectApi', (['"""LOAD5"""', '"""Cpu Avg Load 5"""', '(5)'], {}), "('LOAD5', 'Cpu Avg Load 5', 5)\n", (64, 94), False, 'from core.api import collectApi\n'), ((211, 251), 'core.api.collectApi', 'collectApi', (['"""LOAD1"""', '"""Cpu Avg Load 1"""', '(1)'], {}), "('LOAD1', 'Cpu Avg Lo... |
from __future__ import print_function
import matplotlib as plt
import numpy as np
from skimage.io import imread
from skimage import exposure, color
from skimage.transform import resize
import keras
from keras import backend as K
from keras.datasets import cifar10
from keras.models import Sequential
from keras.layers i... | [
"keras.layers.Conv2D",
"matplotlib.pyplot.grid",
"matplotlib.pyplot.ylabel",
"keras.preprocessing.image.ImageDataGenerator",
"skimage.exposure.equalize_adapthist",
"numpy.array",
"keras.layers.Dense",
"keras.optimizers.Adadelta",
"matplotlib.pyplot.imshow",
"keras.backend.image_data_format",
"ma... | [((472, 493), 'matplotlib.use', 'matplotlib.use', (['"""Agg"""'], {}), "('Agg')\n", (486, 493), False, 'import matplotlib\n'), ((1701, 1722), 'skimage.io.imread', 'imread', (['"""img/cat.jpg"""'], {}), "('img/cat.jpg')\n", (1707, 1722), False, 'from skimage.io import imread\n'), ((1723, 1738), 'matplotlib.pyplot.imshow... |
from hiyapyco import dump as hdump
from mason.clients.airflow.airflow_client import AirflowClient
from mason.clients.airflow.scheduler import AirflowSchedulerClient
from mason.clients.athena.athena_client import AthenaClient
from mason.clients.athena.execution import AthenaExecutionClient
from mason.clients.athena.met... | [
"mason.test.support.testing_base.clean_string",
"mason.clients.local.execution.LocalExecutionClient",
"mason.clients.glue.glue_client.GlueClient",
"mason.test.support.testing_base.get_env",
"mason.clients.spark.execution.SparkExecutionClient",
"mason.clients.s3.s3_client.S3Client",
"mason.test.support.t... | [((1914, 2264), 'mason.clients.spark.spark_client.SparkConfig', 'SparkConfig', (["{'script_type': 'scala-test', 'spark_version': 'test.spark.version',\n 'main_class': 'test.main.Class', 'docker_image':\n 'docker/test-docker-image', 'application_file':\n 'test/jar/file/location/assembly.jar', 'driver_cores': 10... |
from django.contrib.auth.hashers import check_password
from django.forms.models import model_to_dict
from django.test import TestCase
from resources_portal.test.factories import UserFactory
from resources_portal.views.user import CreateUserSerializer
class TestCreateUserSerializer(TestCase):
def setUp(self):
... | [
"resources_portal.views.user.CreateUserSerializer",
"resources_portal.test.factories.UserFactory.build"
] | [((446, 475), 'resources_portal.views.user.CreateUserSerializer', 'CreateUserSerializer', ([], {'data': '{}'}), '(data={})\n', (466, 475), False, 'from resources_portal.views.user import CreateUserSerializer\n'), ((593, 634), 'resources_portal.views.user.CreateUserSerializer', 'CreateUserSerializer', ([], {'data': 'sel... |
"""
WSGI config for TeaRoom project.
It exposes the WSGI callable as a module-level variable named ``application``.
For more information on this file, see
https://docs.djangoproject.com/en/dev/howto/deployment/wsgi/
"""
import os
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "TeaRoom.settings.production")
from dj... | [
"os.environ.setdefault",
"django.core.wsgi.get_wsgi_application"
] | [((233, 311), 'os.environ.setdefault', 'os.environ.setdefault', (['"""DJANGO_SETTINGS_MODULE"""', '"""TeaRoom.settings.production"""'], {}), "('DJANGO_SETTINGS_MODULE', 'TeaRoom.settings.production')\n", (254, 311), False, 'import os\n'), ((377, 399), 'django.core.wsgi.get_wsgi_application', 'get_wsgi_application', ([]... |
from django import forms
from django.contrib.auth.decorators import login_required
from django.core.files.images import get_image_dimensions
from django.urls import reverse
from regex import regex
from .models import UserProfile
import json
from django.core.mail import send_mail, BadHeaderError
from django.http import ... | [
"django.shortcuts.render",
"django.contrib.auth.get_user_model",
"regex.regex.match",
"django.urls.reverse",
"re.sub"
] | [((1378, 1394), 'django.contrib.auth.get_user_model', 'get_user_model', ([], {}), '()\n', (1392, 1394), False, 'from django.contrib.auth import get_user_model\n'), ((7911, 7965), 'django.urls.reverse', 'reverse', (['"""home:profile"""'], {'kwargs': "{'slug': request.user}"}), "('home:profile', kwargs={'slug': request.u... |
import logging
import os
import random
import cocotb
import cocotb_test.simulator
import pytest
from cocotb.clock import Clock
from cocotb.regression import TestFactory
from cocotb.triggers import RisingEdge
from cocotbext.axi import AxiLiteMaster, AxiLiteBus
class TB(object):
def __init__(self, dut):
se... | [
"logging.getLogger",
"cocotb.regression.TestFactory",
"cocotb.triggers.RisingEdge",
"os.path.join",
"os.path.dirname",
"pytest.mark.parametrize",
"cocotbext.axi.AxiLiteBus.from_prefix",
"os.path.basename",
"cocotb.clock.Clock",
"random.randint"
] | [((6656, 6699), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""data_width"""', '[32]'], {}), "('data_width', [32])\n", (6679, 6699), False, 'import pytest\n'), ((6556, 6581), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (6571, 6581), False, 'import os\n'), ((6609, 6651), 'os.pa... |
import configparser
from pathlib import Path
def main() -> None:
MAIN_SCRIPT_BASENAME = "smart_key_box.service"
SETUP_DIR = Path(__file__).resolve().parent
PROJ_DIR = SETUP_DIR.parent
TEMPLATE_SERVICE_FILENAME = SETUP_DIR / "template.service"
DST_SERVICE_FILENAME = SETUP_DIR / MAIN_SCRIPT_BASENAM... | [
"configparser.ConfigParser",
"pathlib.Path"
] | [((552, 579), 'configparser.ConfigParser', 'configparser.ConfigParser', ([], {}), '()\n', (577, 579), False, 'import configparser\n'), ((135, 149), 'pathlib.Path', 'Path', (['__file__'], {}), '(__file__)\n', (139, 149), False, 'from pathlib import Path\n')] |
from proboscis.asserts import assert_true, assert_false, assert_equal
from proboscis import SkipTest
from proboscis import test
from alexa_request import RequestObjectBase, LaunchRequest, SessionEndedRequest,IntentRequest
from util import datetime_to_ISO8601
@test(groups=["intent.base"])
def test_getattribute():
... | [
"util.datetime_to_ISO8601",
"alexa_request.IntentRequest",
"proboscis.asserts.assert_true",
"proboscis.asserts.assert_equal",
"proboscis.TestProgram",
"proboscis.test",
"alexa_request.LaunchRequest",
"alexa_request.SessionEndedRequest",
"alexa_request.RequestObjectBase"
] | [((262, 290), 'proboscis.test', 'test', ([], {'groups': "['intent.base']"}), "(groups=['intent.base'])\n", (266, 290), False, 'from proboscis import test\n'), ((573, 605), 'proboscis.test', 'test', ([], {'groups': "['request.parsing']"}), "(groups=['request.parsing'])\n", (577, 605), False, 'from proboscis import test\... |
# env imports
from os import path
from marvinenv.lib.sitepackages import pyttsx3
def pyttsx_speak(tts): # function to speak with engine
engine = pyttsx3.init()
engine.say(tts) # que tts data
engine.runAndWait() # speak text
| [
"marvinenv.lib.sitepackages.pyttsx3.init"
] | [((150, 164), 'marvinenv.lib.sitepackages.pyttsx3.init', 'pyttsx3.init', ([], {}), '()\n', (162, 164), False, 'from marvinenv.lib.sitepackages import pyttsx3\n')] |
# -*- coding: utf-8 -*-
"""
DEMO: 利用Mysql UDF将Mysql数据变化存储到MongoDB
by <EMAIL> 2016.1.9
version 1.1
"""
import config # 加载配置文件
import bucketV3 as bucket # 加载全局变量
from flask import Flask, render_template, request, make_response, current_app
from flask_debugtoolbar import DebugToolbarExtension
from flask_uploads import co... | [
"flask_uploads.UploadSet",
"flask.Flask",
"flask_debugtoolbar.DebugToolbarExtension",
"flask_uploads.configure_uploads",
"os.remove",
"os.path.exists",
"setproctitle.getproctitle",
"os.getpid",
"bucketV3.debug.show",
"werkzeug.utils.import_string",
"bucketV3.worker.setJob",
"flask.request.url_... | [((1115, 1149), 'time.strftime', 'time.strftime', (['"""%Y-%m-%d %H:%M:%S"""'], {}), "('%Y-%m-%d %H:%M:%S')\n", (1128, 1149), False, 'import time\n'), ((1209, 1229), 'bucketV3.debug.start', 'bucket.debug.start', ([], {}), '()\n', (1227, 1229), True, 'import bucketV3 as bucket\n'), ((1667, 1725), 'flask_uploads.UploadSe... |
from datetime import date
import json
import re
def inventoryExport(d, format):
try:
cryptTotal = 0
libraryTotal = 0
crypt = {}
library = {}
maxCrypt = 0
maxLibrary = 0
with open("cardbase_crypt.json", "r") as crypt_file, open("cardbase_library.json", "r")... | [
"json.load",
"re.sub",
"datetime.date.today"
] | [((362, 383), 'json.load', 'json.load', (['crypt_file'], {}), '(crypt_file)\n', (371, 383), False, 'import json\n'), ((410, 433), 'json.load', 'json.load', (['library_file'], {}), '(library_file)\n', (419, 433), False, 'import json\n'), ((3619, 3652), 're.sub', 're.sub', (['"""."""', '"""="""', 'cryptTotalTitle'], {}),... |
import logging
import os
PGPORT = os.environ.get("PGPORT", 5432)
DATABASES = {
'jardin_test': 'postgres://postgres:@localhost:%s/jardin_test' % PGPORT,
'other_test_dict_config': {
'username': 'test',
'password': '<PASSWORD>',
'database': 'jardin_test',
'host': 'localhost',
... | [
"os.environ.get"
] | [((35, 65), 'os.environ.get', 'os.environ.get', (['"""PGPORT"""', '(5432)'], {}), "('PGPORT', 5432)\n", (49, 65), False, 'import os\n')] |
# Reference : https://bigdatatinos.com/2016/02/08/using-spark-hdinsight-to-analyze-us-air-traffic/
import pyspark
from pyspark import SparkConf
from pyspark import SparkContext
from pyspark.sql import SQLContext
import atexit
sc = SparkContext('local[*]')
sqlc = SQLContext(sc)
atexit.register(lambda: sc.stop())
imp... | [
"pyspark.SparkContext",
"pyspark.sql.SQLContext"
] | [((234, 258), 'pyspark.SparkContext', 'SparkContext', (['"""local[*]"""'], {}), "('local[*]')\n", (246, 258), False, 'from pyspark import SparkContext\n'), ((266, 280), 'pyspark.sql.SQLContext', 'SQLContext', (['sc'], {}), '(sc)\n', (276, 280), False, 'from pyspark.sql import SQLContext\n')] |
from flask_restx import Namespace, fields
class RoleDto:
"""The role dto"""
api = Namespace("role", description="role related operations")
role = api.model(
"role",
{
"role_name": fields.String(required=True, description="role name"),
},
)
| [
"flask_restx.Namespace",
"flask_restx.fields.String"
] | [((93, 149), 'flask_restx.Namespace', 'Namespace', (['"""role"""'], {'description': '"""role related operations"""'}), "('role', description='role related operations')\n", (102, 149), False, 'from flask_restx import Namespace, fields\n'), ((223, 276), 'flask_restx.fields.String', 'fields.String', ([], {'required': '(Tr... |
from wagtail.core.blocks import CharBlock, StreamBlock, StructBlock, TextBlock, URLBlock
from wagtail.embeds.blocks import EmbedBlock
from wagtail.images.blocks import ImageChooserBlock
from .base import SectionBlock
class HeroSectionBlock(SectionBlock):
heading = CharBlock(
required=False,
max_l... | [
"wagtail.core.blocks.CharBlock",
"wagtail.images.blocks.ImageChooserBlock",
"wagtail.core.blocks.URLBlock",
"wagtail.embeds.blocks.EmbedBlock",
"wagtail.core.blocks.TextBlock"
] | [((272, 417), 'wagtail.core.blocks.CharBlock', 'CharBlock', ([], {'required': '(False)', 'max_length': '(100)', 'label': '"""Hero Heading"""', 'help_text': '"""Add the big hero text. Keep it snappy."""', 'default': '"""We are heroes"""'}), "(required=False, max_length=100, label='Hero Heading', help_text=\n 'Add the... |
from datetime import date
import pytest
import responses
import re
from personio_py import PersonioError, Absence, Employee
from tests.test_mock_api import mock_personio, compare_labeled_attributes, mock_employees
from tests.mock_data import json_dict_absence_alan, json_dict_absence_types, json_dict_empty_response,\
... | [
"re.compile",
"responses.add",
"tests.test_mock_api.mock_employees",
"personio_py.Employee",
"personio_py.Absence",
"tests.test_mock_api.mock_personio",
"pytest.raises",
"datetime.date",
"tests.test_mock_api.compare_labeled_attributes"
] | [((509, 524), 'tests.test_mock_api.mock_personio', 'mock_personio', ([], {}), '()\n', (522, 524), False, 'from tests.test_mock_api import mock_personio, compare_labeled_attributes, mock_employees\n'), ((570, 590), 'personio_py.Absence', 'Absence', ([], {'id_': '(2628890)'}), '(id_=2628890)\n', (577, 590), False, 'from ... |
"""Method for sending notification into single chat."""
from typing import Optional
from uuid import UUID
from pydantic import Field
from botx.clients.methods.base import AuthorizedBotXMethod
from botx.clients.methods.extractors import extract_generated_sync_id
from botx.clients.types.message_payload import ResultPay... | [
"pydantic.Field",
"botx.clients.types.options.ResultOptions"
] | [((1129, 1161), 'pydantic.Field', 'Field', (['...'], {'alias': '"""notification"""'}), "(..., alias='notification')\n", (1134, 1161), False, 'from pydantic import Field\n'), ((1290, 1305), 'botx.clients.types.options.ResultOptions', 'ResultOptions', ([], {}), '()\n', (1303, 1305), False, 'from botx.clients.types.option... |
import asyncio
import sqlite3
import re
import os
from datetime import datetime
import secrets
import discord
from discord.ext import commands
# This used to be included in kyb3r/modmail-plugins but it has been broken so Wanted to fix it uwu
USER_CACHE = {}
class Thread:
statuses = {1: "open", 2: "closed", 3: ... | [
"secrets.token_hex",
"sqlite3.connect",
"re.compile",
"datetime.datetime.utcnow",
"discord.ext.commands.is_owner",
"datetime.datetime.fromisoformat",
"asyncio.gather",
"discord.ext.commands.command",
"os.remove"
] | [((7288, 7306), 'discord.ext.commands.command', 'commands.command', ([], {}), '()\n', (7304, 7306), False, 'from discord.ext import commands\n'), ((7312, 7331), 'discord.ext.commands.is_owner', 'commands.is_owner', ([], {}), '()\n', (7329, 7331), False, 'from discord.ext import commands\n'), ((1831, 1862), 'datetime.da... |
import pytest
def test_create_meshed_flow(api):
"""Demonstrates a fully meshed configuration
"""
config = api.config()
for i in range(1, 33):
config.ports.port(name='Port %s' % i, location='localhost/%s' % i)
device = config.devices.device(name='Device %s' % i)[-1]
device.ethe... | [
"pytest.main"
] | [((1224, 1260), 'pytest.main', 'pytest.main', (["['-vv', '-s', __file__]"], {}), "(['-vv', '-s', __file__])\n", (1235, 1260), False, 'import pytest\n')] |
import pace.data
from pace import Sample
from pkg_resources import resource_stream
def test_decoy_parsing():
decoys = pace.data.read_decoys_file(
resource_stream("pace", "data/decoys_9.txt"))
assert len(decoys) == 982791
assert decoys[:4] == [
"AAAAAAAAF",
"AAAAAAAAV",
... | [
"pkg_resources.resource_stream",
"pace.Sample"
] | [((161, 205), 'pkg_resources.resource_stream', 'resource_stream', (['"""pace"""', '"""data/decoys_9.txt"""'], {}), "('pace', 'data/decoys_9.txt')\n", (176, 205), False, 'from pkg_resources import resource_stream\n'), ((462, 507), 'pkg_resources.resource_stream', 'resource_stream', (['"""pace"""', '"""data/hits_16_9.txt... |
from dipper.models.Reference import Reference
from dipper.models.assoc.G2PAssoc import G2PAssoc
from dipper.sources.Source import Source
from dipper.sources.ZFIN import ZFIN
from dipper.models.Dataset import Dataset
from dipper.models.Model import Model
import csv
import logging
logger = logging.getLogger(__name__)
... | [
"logging.getLogger",
"dipper.models.Dataset.Dataset",
"dipper.models.Model.Model",
"dipper.models.assoc.G2PAssoc.G2PAssoc",
"dipper.models.Reference.Reference",
"dipper.sources.ZFIN.ZFIN",
"csv.reader"
] | [((290, 317), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (307, 317), False, 'import logging\n'), ((1032, 1084), 'dipper.models.Dataset.Dataset', 'Dataset', (['"""zfin_slim"""', '"""ZFINSlim"""', '"""http://zfin.org/"""'], {}), "('zfin_slim', 'ZFINSlim', 'http://zfin.org/')\n", (1039, ... |
#!/usr/bin/python
## """
## How do i parallelize a retriever function and a sender/saver function when they
## 1: require mpthreads
## 2: The dataammount is significant enough that I don't want the receiver to get to far ahead of the sender.
## """
## This code uses a semaphore to bound the amount of in-flight data.
#... | [
"random.randrange",
"tqdm.tqdm",
"time.sleep",
"multiprocessing.cpu_count",
"multiprocessing.Pool",
"multiprocessing.Manager",
"time.time"
] | [((1183, 1210), 'multiprocessing.cpu_count', 'multiprocessing.cpu_count', ([], {}), '()\n', (1208, 1210), False, 'import multiprocessing\n'), ((1216, 1241), 'multiprocessing.Manager', 'multiprocessing.Manager', ([], {}), '()\n', (1239, 1241), False, 'import multiprocessing\n'), ((1281, 1292), 'time.time', 'time.time', ... |
import numpy
def scale_array(arr, scale):
if (scale != int(scale)) or (scale < 1):
raise RuntimeError("scale={!r} must be a positive integer".format(scale))
elif scale == 1:
return arr
if len(arr.shape) == 2:
result = numpy.zeros(
(arr.shape[0] * scale, arr.shape[1] * sc... | [
"numpy.array",
"numpy.zeros"
] | [((255, 329), 'numpy.zeros', 'numpy.zeros', (['(arr.shape[0] * scale, arr.shape[1] * scale)'], {'dtype': 'arr.dtype'}), '((arr.shape[0] * scale, arr.shape[1] * scale), dtype=arr.dtype)\n', (266, 329), False, 'import numpy\n'), ((3926, 4189), 'numpy.array', 'numpy.array', (['((0, 0, 0, 0, 0), (0, 0, 0, 0, 0), (0, 0, 0, ... |
import collections
from typing import List
class Solution:
def possibleBipartition(self, N: int, dislikes: List[List[int]]) -> bool:
# 如果连线数特别多，可以知道不可能分为两个组
if len(dislikes) > (N // 2 + 1) ** 2:
return False
graph = collections.defaultdict(set)
for u, v in dislikes:
... | [
"collections.defaultdict"
] | [((258, 286), 'collections.defaultdict', 'collections.defaultdict', (['set'], {}), '(set)\n', (281, 286), False, 'import collections\n')] |
# -*- coding: utf-8 -*-
from flask import Flask, render_template, request
import os,shutil
import numpy as np
import json
import collections
import time
# import tensorflow as tf
import argparse
import sys
import face_model
from flask_cors import *
import cv2
from annoy import AnnoyIndex
import datetime
import random... | [
"json.JSONEncoder.default",
"flask.Flask",
"numpy.array",
"flaskext.mysql.MySQL",
"os.walk",
"argparse.ArgumentParser",
"json.dumps",
"flask.request.form.get",
"numpy.frombuffer",
"random.randint",
"annoy.AnnoyIndex",
"collections.OrderedDict",
"flask.request.get_json",
"cv2.cvtColor",
"... | [((470, 477), 'flaskext.mysql.MySQL', 'MySQL', ([], {}), '()\n', (475, 477), False, 'from flaskext.mysql import MySQL\n'), ((484, 499), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (489, 499), False, 'from flask import Flask, render_template, request\n'), ((18039, 18065), 'face_model.FaceModel', 'face_mo... |
import numpy as np
import os
import math
import dtdata as dt
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from keras.models import Model
from keras.layers import Dense, Activation, Dropout, Input
from keras.models import load_model
import matplotlib.pyplot as plt... | [
"keras.models.load_model",
"numpy.reshape",
"dtdata.centerAroundEntry",
"sklearn.model_selection.train_test_split",
"math.floor",
"matplotlib.pyplot.legend",
"os.path.join",
"sklearn.preprocessing.StandardScaler",
"os.path.isfile",
"keras.layers.Input",
"numpy.array",
"dtdata.loadData",
"num... | [((827, 843), 'sklearn.preprocessing.StandardScaler', 'StandardScaler', ([], {}), '()\n', (841, 843), False, 'from sklearn.preprocessing import StandardScaler\n'), ((1228, 1256), 'keras.models.load_model', 'load_model', (['autoencoder_path'], {}), '(autoencoder_path)\n', (1238, 1256), False, 'from keras.models import l... |
import numpy as np
import pandas as pd
import os
import shutil
unlabeled_path = '/home/elias/Escritorio/proyectos personales/BitsXlaMarató/Apolo-COVID-cough-predictor/Cough dataset/Unlabeled audio/'
# Check all directories of Unlabeled data
os.listdir(unlabeled_path)
# Let's create a TRAIN and TEST directory.
tra... | [
"os.path.exists",
"os.listdir",
"os.makedirs",
"shutil.move",
"os.rmdir"
] | [((245, 271), 'os.listdir', 'os.listdir', (['unlabeled_path'], {}), '(unlabeled_path)\n', (255, 271), False, 'import os\n'), ((1011, 1033), 'os.listdir', 'os.listdir', (['cough_path'], {}), '(cough_path)\n', (1021, 1033), False, 'import os\n'), ((1463, 1487), 'os.listdir', 'os.listdir', (['nocough_path'], {}), '(nocoug... |
import ast
from tater import Visitor, Node
class _AstConverter(Visitor):
def __init__(self):
self.root = Node()
def finalize(self):
return self.root
def generic_visit(self, node, iter_fields=ast.iter_fields, AST=ast.AST):
"""Called if no explicit visitor function exists for a n... | [
"tater.Node"
] | [((121, 127), 'tater.Node', 'Node', ([], {}), '()\n', (125, 127), False, 'from tater import Visitor, Node\n')] |
from flask import Flask, jsonify
import tweepy, configparser
config = configparser.ConfigParser()
config.read("config.ini")
consumer_key = config['twitter']['twitter_key']
consumer_secret = config['twitter']['twitter_secret']
access_token = config['twitter']['access_token']
access_token_secret = config['twitter']['ac... | [
"tweepy.OAuthHandler",
"tweepy.API",
"configparser.ConfigParser",
"flask.Flask"
] | [((71, 98), 'configparser.ConfigParser', 'configparser.ConfigParser', ([], {}), '()\n', (96, 98), False, 'import tweepy, configparser\n'), ((347, 362), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (352, 362), False, 'from flask import Flask, jsonify\n'), ((371, 421), 'tweepy.OAuthHandler', 'tweepy.OAuthH... |
import torch
from torch import nn
from torch.nn import functional as F
from torch.distributions.uniform import Uniform
from networks.layers.non_linear import NonLinear, NonLinearType
from networks.layers.conv_bn import ConvBN
class DropConnect(nn.Module):
def __init__(self, survival_prob):
"""
A m... | [
"torch.distributions.uniform.Uniform",
"torch.nn.Sequential",
"torch.floor",
"torch.nn.functional.avg_pool2d",
"networks.layers.non_linear.NonLinear",
"networks.layers.conv_bn.ConvBN"
] | [((543, 556), 'torch.distributions.uniform.Uniform', 'Uniform', (['(0)', '(1)'], {}), '(0, 1)\n', (550, 556), False, 'from torch.distributions.uniform import Uniform\n'), ((1416, 1457), 'torch.nn.functional.avg_pool2d', 'F.avg_pool2d', (['x', '(x.shape[2], x.shape[3])'], {}), '(x, (x.shape[2], x.shape[3]))\n', (1428, 1... |
# Copyright 2017 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import os
from core import path_util
from devil.android.sdk import intent # pylint: disable=import-error
path_util.AddAndroidPylibToPath()
from pylib.utils ... | [
"pylib.utils.shared_preference_utils.ExtractSettingsFromJson",
"os.path.exists",
"telemetry.core.util.GetBuildDirectories",
"devil.android.sdk.intent.Intent",
"pylib.utils.shared_preference_utils.ApplySharedPreferenceSetting",
"os.path.join",
"core.path_util.GetChromiumSrcDir",
"telemetry.internal.pla... | [((269, 302), 'core.path_util.AddAndroidPylibToPath', 'path_util.AddAndroidPylibToPath', ([], {}), '()\n', (300, 302), False, 'from core import path_util\n'), ((582, 697), 'os.path.join', 'os.path.join', (['"""chrome"""', '"""android"""', '"""shared_preference_files"""', '"""test"""', '"""vr_cardboard_skipdon_setupcomp... |
import os
import json
import numpy as np
import scipy.sparse as sp
from src.model.linear_svm import LinearSVM
from src.model.random_forest import RandomForest
from src.metric.uar import get_UAR, get_post_probability, get_late_fusion_UAR
from src.utils.io import load_proc_baseline_feature, save_UAR_results
from src.uti... | [
"src.metric.uar.get_UAR",
"numpy.hstack",
"src.utils.io.load_proc_baseline_feature",
"src.model.random_forest.RandomForest",
"src.utils.preprocess.upsample",
"numpy.array",
"numpy.vstack",
"numpy.ravel",
"src.utils.io.save_cv_results",
"scipy.sparse.csr_matrix",
"src.model.linear_svm.LinearSVM",... | [((2882, 2930), 'src.utils.io.load_proc_baseline_feature', 'load_proc_baseline_feature', (['"""MFCC"""'], {'verbose': '(True)'}), "('MFCC', verbose=True)\n", (2908, 2930), False, 'from src.utils.io import load_proc_baseline_feature, save_UAR_results\n'), ((4209, 4247), 'src.utils.preprocess.upsample', 'upsample', (['X_... |
from datetime import datetime
from urllib.parse import urljoin
import requests
from celery.exceptions import SoftTimeLimitExceeded
from django.conf import settings
from requests.exceptions import RequestException
from temba_client.exceptions import TembaException
from temba_client.utils import format_iso8601
from nur... | [
"datetime.datetime.utcfromtimestamp",
"datetime.datetime.fromtimestamp",
"requests.Session",
"nurseconnect_registration.celery.app.task",
"registrations.utils.tembaclient.update_contact",
"registrations.utils.tembaclient.create_contact",
"registrations.utils.tembaclient.create_flow_start",
"registrati... | [((490, 508), 'requests.Session', 'requests.Session', ([], {}), '()\n', (506, 508), False, 'import requests\n'), ((632, 792), 'nurseconnect_registration.celery.app.task', 'app.task', ([], {'autoretry_for': '(RequestException, SoftTimeLimitExceeded)', 'retry_backoff': '(True)', 'max_retries': '(15)', 'acks_late': '(True... |
from __future__ import absolute_import, division, print_function, unicode_literals
from keras import backend as K
import tensorflow as tf
from tensorflow.keras import layers
import os
import time
import matplotlib.pyplot as plt
from nc_loader import ERA5Dataset
def Unet():
concat_axis = 3
inputs = layers.In... | [
"tensorflow.keras.layers.Input",
"tensorflow.keras.layers.Conv2D",
"tensorflow.keras.layers.UpSampling2D",
"nc_loader.ERA5Dataset",
"tensorflow.keras.layers.MaxPooling2D",
"tensorflow.keras.metrics.Mean",
"tensorflow.keras.optimizers.SGD",
"tensorflow.keras.layers.concatenate",
"tensorflow.keras.lay... | [((4884, 4958), 'tensorflow.distribute.MirroredStrategy', 'tf.distribute.MirroredStrategy', ([], {'devices': "['/device:GPU:0', '/device:GPU:1']"}), "(devices=['/device:GPU:0', '/device:GPU:1'])\n", (4914, 4958), True, 'import tensorflow as tf\n'), ((5160, 5220), 'nc_loader.ERA5Dataset', 'ERA5Dataset', (['train_fnames'... |
import time
from TorchTSA.model import ARMAGARCHModel
from TorchTSA.model import ARMAIGARCHModel
from TorchTSA.simulate import ARMAGARCHSim
sim = ARMAGARCHSim(
_phi_arr=(0.8,), _theta_arr=(-0.5,),
_alpha_arr=(0.15,), _beta_arr=(0.8,),
_const=0.01
)
sim_data = sim.sample_n(2000)
arma_garch_model = ARMAGAR... | [
"TorchTSA.simulate.ARMAGARCHSim",
"TorchTSA.model.ARMAIGARCHModel",
"TorchTSA.model.ARMAGARCHModel",
"time.time"
] | [((148, 252), 'TorchTSA.simulate.ARMAGARCHSim', 'ARMAGARCHSim', ([], {'_phi_arr': '(0.8,)', '_theta_arr': '(-0.5,)', '_alpha_arr': '(0.15,)', '_beta_arr': '(0.8,)', '_const': '(0.01)'}), '(_phi_arr=(0.8,), _theta_arr=(-0.5,), _alpha_arr=(0.15,),\n _beta_arr=(0.8,), _const=0.01)\n', (160, 252), False, 'from TorchTSA.... |
#!/usr/bin/python
import glob
import json
from color_print import ColorPrint
#from enum import Enum
#class PluginAttribute(Enum):
# NAME = 'name'
# TYPE = 'type'
# FLAG = 'flag'
# ACTIVE = 'active'
# NOTIFY = 'notify'
# COMMANDS = 'commands'
# PLUGINS = 'plugins'
# DESC = 'description'###
... | [
"json.load",
"color_print.ColorPrint.info"
] | [((497, 535), 'color_print.ColorPrint.info', 'ColorPrint.info', (['"""Init: PluginsLoader"""'], {}), "('Init: PluginsLoader')\n", (512, 535), False, 'from color_print import ColorPrint\n'), ((744, 764), 'json.load', 'json.load', (['json_file'], {}), '(json_file)\n', (753, 764), False, 'import json\n')] |
import logging
from pathlib import Path
from typing import List, Optional
import jax
import numpy as np
import wandb
from pytorch_lightning.loggers import WandbLogger
from pytorch_lightning.loggers.base import DummyLogger
from tqdm import tqdm
from fourierflow.callbacks import Callback
from .jax_callback_hook impor... | [
"logging.getLogger",
"wandb.Table",
"numpy.isscalar",
"pathlib.Path",
"tqdm.tqdm",
"jax.jit",
"pytorch_lightning.loggers.base.DummyLogger"
] | [((357, 384), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (374, 384), False, 'import logging\n'), ((1643, 1664), 'jax.jit', 'jax.jit', (['routine.step'], {}), '(routine.step)\n', (1650, 1664), False, 'import jax\n'), ((1040, 1063), 'pathlib.Path', 'Path', (['weights_save_path'], {}), '... |
from django.db import models
from ..company_profile.models import CompanyProfile
from ...core.db.fields import PositiveTinyIntegerField
from ...core.db.models import TimeStampMixin
from ...share_resources.master_data.models import TypeAutoReplyMessage
from ...utils.storages import MediaRootS3Boto3Storage
class Messa... | [
"django.db.models.ForeignKey",
"django.db.models.FileField",
"django.db.models.TextField",
"django.db.models.CharField"
] | [((351, 407), 'django.db.models.TextField', 'models.TextField', ([], {'max_length': '(3000)', 'blank': '(True)', 'null': '(True)'}), '(max_length=3000, blank=True, null=True)\n', (367, 407), False, 'from django.db import models\n'), ((419, 491), 'django.db.models.FileField', 'models.FileField', ([], {'storage': 'MediaR... |
import sys
import os
import torch
import unittest
import numpy as np
from TorchProteinLibrary import FullAtomModel
class TestCoords2TypedCoordsBackward(unittest.TestCase):
def setUp(self):
self.a2c = FullAtomModel.Angles2Coords()
self.c2tc = FullAtomModel.Coords2TypedCoords()
self.c2cc = FullAtomModel.CoordsTra... | [
"torch.abs",
"TorchProteinLibrary.FullAtomModel.Angles2Coords",
"unittest.main",
"TorchProteinLibrary.FullAtomModel.Coords2TypedCoords",
"TorchProteinLibrary.FullAtomModel.CoordsTransform.Coords2CenteredCoords"
] | [((1914, 1929), 'unittest.main', 'unittest.main', ([], {}), '()\n', (1927, 1929), False, 'import unittest\n'), ((204, 233), 'TorchProteinLibrary.FullAtomModel.Angles2Coords', 'FullAtomModel.Angles2Coords', ([], {}), '()\n', (231, 233), False, 'from TorchProteinLibrary import FullAtomModel\n'), ((248, 282), 'TorchProtei... |
# -*- coding: utf-8 -*-
import unittest
import mock
from openregistry.concierge.mapping_types import (
LazyDBMapping,
RedisMapping,
VoidMapping,
MappingConfigurationException
)
class TestRedisDB(unittest.TestCase):
def setUp(self):
self.patch_strict_redis = mock.patch('openregistry.conci... | [
"unittest.TestSuite",
"openregistry.concierge.mapping_types.LazyDBMapping",
"mock.patch",
"openregistry.concierge.mapping_types.RedisMapping",
"unittest.makeSuite",
"openregistry.concierge.mapping_types.VoidMapping",
"mock.MagicMock"
] | [((875, 937), 'mock.patch', 'mock.patch', (['"""openregistry.concierge.mapping_types.StrictRedis"""'], {}), "('openregistry.concierge.mapping_types.StrictRedis')\n", (885, 937), False, 'import mock\n'), ((4020, 4077), 'mock.patch', 'mock.patch', (['"""openregistry.concierge.mapping_types.LazyDB"""'], {}), "('openregist... |
import random
import matplotlib.pyplot as plt
elem = 10000
x = []
y = []
colors = []
def iteration(x):
n = 0
result = 0
while n < 1000: # max iterations
result = pow(result, 2) + c
if abs(result) > 2:
return n
n += 1
return n
for i in range(elem):
c... | [
"random.uniform",
"matplotlib.pyplot.title",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.colorbar",
"matplotlib.pyplot.scatter",
"matplotlib.pyplot.axis",
"matplotlib.pyplot.show"
] | [((456, 528), 'matplotlib.pyplot.scatter', 'plt.scatter', (['x', 'y'], {'marker': '""","""', 'c': 'colors', 'cmap': '"""magma"""', 'vmin': '(0)', 'vmax': '(1000)'}), "(x, y, marker=',', c=colors, cmap='magma', vmin=0, vmax=1000)\n", (467, 528), True, 'import matplotlib.pyplot as plt\n'), ((536, 553), 'matplotlib.pyplot... |
import argparse
import click
from pathlib import Path
import requests
biomart_url = 'http://sep2015.archive.ensembl.org/biomart/martservice'
fields = ["ensembl_gene_id",
"chromosome_name",
"start_position",
"end_position",
"strand",
"entrezgene",
"hgnc_symb... | [
"requests.get",
"argparse.ArgumentParser",
"pathlib.Path"
] | [((761, 827), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Download ensemble reference"""'}), "(description='Download ensemble reference')\n", (784, 827), False, 'import argparse\n'), ((981, 995), 'pathlib.Path', 'Path', (['args.out'], {}), '(args.out)\n', (985, 995), False, 'from path... |
from telegram import ReplyKeyboardMarkup, KeyboardButton, Update, CallbackQuery
import logging
import threading
def handler(func):
"""
Every handler should have this decorator
"""
def wrapper(*args, **kwargs):
self = args[0]
bot = args[1]
update = args[2]
update_or_quer... | [
"telegram.KeyboardButton",
"threading.Thread",
"logging.info"
] | [((1164, 1235), 'logging.info', 'logging.info', (['log_msg', '*log_args'], {'extra': "{'update_id': update.update_id}"}), "(log_msg, *log_args, extra={'update_id': update.update_id})\n", (1176, 1235), False, 'import logging\n'), ((2085, 2148), 'threading.Thread', 'threading.Thread', ([], {'target': 'start_search', 'arg... |
"""
Simple tagging support using ``django-tagging``.
"""
from django.utils.translation import ugettext_lazy as _
import tagging
from tagging.fields import TagField
def register(cls, admin_cls):
cls.add_to_class('tags', TagField(_('tags')))
# use another name for the tag descriptor
# See http://code.goo... | [
"tagging.register",
"django.utils.translation.ugettext_lazy"
] | [((388, 438), 'tagging.register', 'tagging.register', (['cls'], {'tag_descriptor_attr': '"""etags"""'}), "(cls, tag_descriptor_attr='etags')\n", (404, 438), False, 'import tagging\n'), ((236, 245), 'django.utils.translation.ugettext_lazy', '_', (['"""tags"""'], {}), "('tags')\n", (237, 245), True, 'from django.utils.tr... |
# -*- coding: utf-8 -*-
from datetime import datetime
import unittest
import os
from neo4jrestclient import client
from neo4jrestclient.exceptions import NotFoundError, StatusException
from neo4jrestclient.utils import PY2
NEO4J_URL = os.environ.get('NEO4J_URL', "http://localhost:7474/db/data/")
NEO4J_VERSION = os.e... | [
"neo4jrestclient.client.GraphDatabase",
"datetime.datetime.now",
"unittest.skipIf",
"os.environ.get"
] | [((238, 299), 'os.environ.get', 'os.environ.get', (['"""NEO4J_URL"""', '"""http://localhost:7474/db/data/"""'], {}), "('NEO4J_URL', 'http://localhost:7474/db/data/')\n", (252, 299), False, 'import os\n'), ((316, 353), 'os.environ.get', 'os.environ.get', (['"""NEO4J_VERSION"""', 'None'], {}), "('NEO4J_VERSION', None)\n"... |
#!/usr/bin/env python3
from __future__ import division
from __future__ import print_function
from __future__ import absolute_import
import numpy as np
from conban_spanet.dataset_driver import DatasetDriver
from .utils import test_oracle
from bite_selection_package.config import spanet_config as config
N... | [
"numpy.random.choice",
"numpy.sum",
"numpy.ones",
"conban_spanet.dataset_driver.DatasetDriver"
] | [((504, 523), 'numpy.ones', 'np.ones', (['(N, d + 1)'], {}), '((N, d + 1))\n', (511, 523), True, 'import numpy as np\n'), ((545, 561), 'conban_spanet.dataset_driver.DatasetDriver', 'DatasetDriver', (['N'], {}), '(N)\n', (558, 561), False, 'from conban_spanet.dataset_driver import DatasetDriver\n'), ((1776, 1811), 'nump... |
import numpy as np
import pandas as pd
import os
def read_data():
# set path to raw data
raw_data_path = os.path.join(os.path.pardir,'data','raw')
train_file_path = os.path.join(raw_data_path,'train.csv')
test_file_path = os.path.join(raw_data_path,'test.csv')
# read data with default parameters
... | [
"pandas.read_csv",
"pandas.qcut",
"numpy.where",
"os.path.join",
"pandas.notnull",
"pandas.concat"
] | [((114, 157), 'os.path.join', 'os.path.join', (['os.path.pardir', '"""data"""', '"""raw"""'], {}), "(os.path.pardir, 'data', 'raw')\n", (126, 157), False, 'import os\n'), ((178, 218), 'os.path.join', 'os.path.join', (['raw_data_path', '"""train.csv"""'], {}), "(raw_data_path, 'train.csv')\n", (190, 218), False, 'import... |
#!/usr/bin/env python
#
# Copyright 2018 IBM
#
# This 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; either version 3, or (at your option)
# any later version.
#
# This software is distributed in the hope ... | [
"subprocess.check_output",
"getopt.getopt",
"time.sleep",
"subprocess.call",
"sys.exit"
] | [((1257, 1297), 'getopt.getopt', 'getopt.getopt', (['sys.argv[1:]', '"""t:c:o:p:h"""'], {}), "(sys.argv[1:], 't:c:o:p:h')\n", (1270, 1297), False, 'import getopt\n'), ((4653, 4694), 'subprocess.call', 'subprocess.call', (['perf_command'], {'shell': '(True)'}), '(perf_command, shell=True)\n', (4668, 4694), False, 'impor... |
import pytest
import pytma
from pytma import Utility
from pytma.Utility import LogError
def test_logger():
"""
Testing the logging helper.
"""
log = Utility.Logger('.', "test_pytma")
try:
log.info("information")
except LogError:
pytest.fail("Unexpected LogError ..")
try... | [
"pytest.fail",
"pytma.Utility.Logger"
] | [((169, 202), 'pytma.Utility.Logger', 'Utility.Logger', (['"""."""', '"""test_pytma"""'], {}), "('.', 'test_pytma')\n", (183, 202), False, 'from pytma import Utility\n'), ((274, 311), 'pytest.fail', 'pytest.fail', (['"""Unexpected LogError .."""'], {}), "('Unexpected LogError ..')\n", (285, 311), False, 'import pytest\... |
# -*- coding: utf-8 -*-
# Copyright (c) 2018-2021 <NAME>
# api.wwdt.me is released under the terms of the Apache License 2.0
"""Testing /v2.0/version route
"""
from fastapi.testclient import TestClient
from wwdtm import VERSION as WWDTM_VERSION
from app.main import app
from app.config import API_VERSION, APP_VERSION
... | [
"fastapi.testclient.TestClient"
] | [((329, 344), 'fastapi.testclient.TestClient', 'TestClient', (['app'], {}), '(app)\n', (339, 344), False, 'from fastapi.testclient import TestClient\n')] |
from functools import wraps
from typing import List, Callable
import numpy as np
LETTER_SIGNATURE = "fruits_letter"
LETTER_NAME = "fruits_name"
BOUND_LETTER_TYPE = Callable[[np.ndarray, int], np.ndarray]
FREE_LETTER_TYPE = Callable[[int], BOUND_LETTER_TYPE]
class ExtendedLetter:
"""Class for an extended letter... | [
"numpy.abs",
"functools.wraps"
] | [((7192, 7207), 'numpy.abs', 'np.abs', (['X[i, :]'], {}), '(X[i, :])\n', (7198, 7207), True, 'import numpy as np\n'), ((4922, 4936), 'functools.wraps', 'wraps', (['args[0]'], {}), '(args[0])\n', (4927, 4936), False, 'from functools import wraps\n'), ((5436, 5447), 'functools.wraps', 'wraps', (['func'], {}), '(func)\n',... |
#!/usr/bin/python3
import jk_flexdata
x = jk_flexdata.FlexObject({
"a": [
{
"b": "c"
}
]
})
print(x.a[0])
print(x.a[0].b)
| [
"jk_flexdata.FlexObject"
] | [((46, 89), 'jk_flexdata.FlexObject', 'jk_flexdata.FlexObject', (["{'a': [{'b': 'c'}]}"], {}), "({'a': [{'b': 'c'}]})\n", (68, 89), False, 'import jk_flexdata\n')] |
#!/usr/bin/env python
# coding: utf-8
# In[1]:
import os
import matplotlib.pyplot as plt
import numpy as np
import PIL
import tensorflow as tf
from keras import backend as K
from keras.layers import Input, Lambda, Conv2D
from keras.models import load_model, Model
from keras.callbacks import TensorBoard, ModelCheck... | [
"os.listdir",
"pandas.read_csv",
"numpy.array",
"pandas.DataFrame",
"pandas.concat"
] | [((823, 868), 'pandas.read_csv', 'pd.read_csv', (['"""../Data/LOC_train_solution.csv"""'], {}), "('../Data/LOC_train_solution.csv')\n", (834, 868), True, 'import pandas as pd\n'), ((976, 1013), 'pandas.DataFrame', 'pd.DataFrame', ([], {'columns': "['Id', 'names']"}), "(columns=['Id', 'names'])\n", (988, 1013), True, 'i... |
import os
import json
import argparse
from datetime import datetime
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow import keras
from tensorflow.keras.applications.efficientnet import EfficientNetB0
from tensorflow.keras.layers import Flatten, Dense
from tensorflow.keras.models impo... | [
"tensorflow.keras.preprocessing.image.ImageDataGenerator",
"paz.processors.CastImage",
"tensorflow.keras.callbacks.EarlyStopping",
"tensorflow.keras.layers.Dense",
"paz.processors.ImageDataProcessor",
"os.path.exists",
"argparse.ArgumentParser",
"tensorflow.keras.callbacks.ReduceLROnPlateau",
"paz.p... | [((1292, 1340), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': 'description'}), '(description=description)\n', (1315, 1340), False, 'import argparse\n'), ((3766, 3892), 'tensorflow.keras.preprocessing.image.ImageDataGenerator', 'ImageDataGenerator', ([], {'rotation_range': '(30)', 'width_shi... |
#! /usr/bin/env python3
# Notwendige Bibliothek installieren:
# pip3 install paho-mqtt
import paho.mqtt.publish as publish
# veröffentliche eine neue Nachricht unter dem angegebenen Thema
publish.single("test/topic", "nachricht", hostname="192.168.24.132")
| [
"paho.mqtt.publish.single"
] | [((197, 265), 'paho.mqtt.publish.single', 'publish.single', (['"""test/topic"""', '"""nachricht"""'], {'hostname': '"""192.168.24.132"""'}), "('test/topic', 'nachricht', hostname='192.168.24.132')\n", (211, 265), True, 'import paho.mqtt.publish as publish\n')] |
#!/usr/bin/python
# -*- coding: utf-8 -*-
import sys
sys.path.insert(0, './')
from features import features_functions
features_functions.createFeaturesFile('Bacterium_id_5190.csv', './features/CSV_files', 5190) | [
"features.features_functions.createFeaturesFile",
"sys.path.insert"
] | [((54, 78), 'sys.path.insert', 'sys.path.insert', (['(0)', '"""./"""'], {}), "(0, './')\n", (69, 78), False, 'import sys\n'), ((120, 216), 'features.features_functions.createFeaturesFile', 'features_functions.createFeaturesFile', (['"""Bacterium_id_5190.csv"""', '"""./features/CSV_files"""', '(5190)'], {}), "('Bacteriu... |
#!/usr/bin/python
# -*- coding: utf-8 -*-
"""
Authors: <NAME>, <NAME>, <NAME>, <NAME>
Date created: 12/8/2016 (original)
Date last modified: 05/25/2018
"""
__version__ = "1.3"
from time import sleep,time
from logging import debug,info,warn,error
import logging
from thread import start_new_thread
import traceback
im... | [
"logging.basicConfig",
"traceback.format_exc",
"platform.node",
"logging.debug",
"socket.socket",
"numpy.random.rand",
"cavro_centris_syringe_pump_LL.driver.valve_get",
"msgpack.packb",
"time.sleep",
"cavro_centris_syringe_pump_LL.driver.discover",
"msgpack.unpackb",
"platform.system",
"os.g... | [((2291, 2306), 'platform.node', 'platform.node', ([], {}), '()\n', (2304, 2306), False, 'import platform\n'), ((455, 466), 'os.getpid', 'os.getpid', ([], {}), '()\n', (464, 466), False, 'import psutil, os\n'), ((727, 744), 'platform.system', 'platform.system', ([], {}), '()\n', (742, 744), False, 'import platform\n'),... |
#https://www.wipo.int/classifications/ipc/en/ITsupport/Categorization/dataset/
import os, sys
from os.path import exists, join
from util.file import *
from zipfile import ZipFile
import xml.etree.ElementTree as ET
from tqdm import tqdm
import numpy as np
import pickle
from joblib import Parallel, delayed
WIPO_URL= 'ht... | [
"os.path.exists",
"zipfile.ZipFile",
"tqdm.tqdm",
"os.path.join",
"joblib.Parallel",
"joblib.delayed"
] | [((2809, 2821), 'zipfile.ZipFile', 'ZipFile', (['fin'], {}), '(fin)\n', (2816, 2821), False, 'from zipfile import ZipFile\n'), ((3941, 4000), 'tqdm.tqdm', 'tqdm', (["['train', 'test']"], {'desc': '"""loading classification file"""'}), "(['train', 'test'], desc='loading classification file')\n", (3945, 4000), False, 'fr... |
# -*- coding: utf-8 -*-
"""
@date: 2020/4/30 下午2:52
@file: compose.py
@author: zj
@description: 组合实现多种图像预处理
"""
import torchvision.transforms as transforms
from PIL import Image
import matplotlib.pyplot as plt
if __name__ == '__main__':
src = Image.open('../data/lena.jpg')
# 预处理顺序如下：
# 1. 按较短边缩放
# 2... | [
"PIL.Image.open",
"torchvision.transforms.ToPILImage",
"torchvision.transforms.RandomHorizontalFlip",
"torchvision.transforms.RandomCrop",
"torchvision.transforms.ColorJitter",
"torchvision.transforms.RandomErasing",
"torchvision.transforms.Resize",
"matplotlib.pyplot.axis",
"torchvision.transforms.... | [((250, 280), 'PIL.Image.open', 'Image.open', (['"""../data/lena.jpg"""'], {}), "('../data/lena.jpg')\n", (260, 280), False, 'from PIL import Image\n'), ((929, 939), 'matplotlib.pyplot.show', 'plt.show', ([], {}), '()\n', (937, 939), True, 'import matplotlib.pyplot as plt\n'), ((425, 447), 'torchvision.transforms.Resiz... |
from google.appengine.ext import ndb
from google.appengine.api import users
import webapp2
class User(ndb.Model):
firstname=ndb.StringProperty()
lastname=ndb.StringProperty()
username=ndb.StringProperty()
password=ndb.StringProperty()
email=ndb.StringProperty()
user_id=ndb.StringProperty()
cl... | [
"google.appengine.ext.ndb.TextProperty",
"google.appengine.ext.ndb.DateTimeProperty",
"google.appengine.ext.ndb.KeyProperty",
"google.appengine.ext.ndb.StringProperty"
] | [((129, 149), 'google.appengine.ext.ndb.StringProperty', 'ndb.StringProperty', ([], {}), '()\n', (147, 149), False, 'from google.appengine.ext import ndb\n'), ((163, 183), 'google.appengine.ext.ndb.StringProperty', 'ndb.StringProperty', ([], {}), '()\n', (181, 183), False, 'from google.appengine.ext import ndb\n'), ((1... |
import mock
import numpy as np
import pytest
import pypylon.pylon
import pypylon.genicam
import piescope.data
import piescope.lm.volume
from piescope.lm.detector import Basler
from piescope.lm.objective import StageController
pytest.importorskip('pypylon', reason="The pypylon library is not available.")
def test_... | [
"piescope.lm.objective.StageController",
"mock.patch",
"numpy.allclose",
"mock.patch.object",
"numpy.stack",
"piescope.lm.detector.Basler",
"pytest.importorskip"
] | [((230, 308), 'pytest.importorskip', 'pytest.importorskip', (['"""pypylon"""'], {'reason': '"""The pypylon library is not available."""'}), "('pypylon', reason='The pypylon library is not available.')\n", (249, 308), False, 'import pytest\n'), ((730, 775), 'mock.patch.object', 'mock.patch.object', (['StageController', ... |
"""Added Modifier Text field to RandomTable and Public RandomTable
Revision ID: 1058cde5df9f
Revises: <PASSWORD>
Create Date: 2020-07-05 14:49:25.030794
"""
# revision identifiers, used by Alembic.
revision = '1058cde5df9f'
down_revision = '<PASSWORD>'
from alembic import op
import sqlalchemy as sa
def upgrade():... | [
"sqlalchemy.Text",
"alembic.op.batch_alter_table"
] | [((396, 452), 'alembic.op.batch_alter_table', 'op.batch_alter_table', (['"""public_random_table"""'], {'schema': 'None'}), "('public_random_table', schema=None)\n", (416, 452), False, 'from alembic import op\n'), ((558, 607), 'alembic.op.batch_alter_table', 'op.batch_alter_table', (['"""random_table"""'], {'schema': 'N... |
import cv2
import face_recognition
img = cv2.imread("<NAME>.jpeg")
rgb_img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)
img_encoding = face_recognition.face_encodings(rgb_img)[0]
img2 = cv2.imread("images/<NAME>.jpeg")
rgb_img2 = cv2.cvtColor(img2, cv2.COLOR_BGR2RGB)
img_encoding2 = face_recognition.face_encodings(rgb_img2... | [
"cv2.imshow",
"cv2.destroyAllWindows",
"face_recognition.compare_faces",
"cv2.cvtColor",
"face_recognition.face_encodings",
"cv2.waitKey",
"cv2.imread"
] | [((42, 67), 'cv2.imread', 'cv2.imread', (['"""<NAME>.jpeg"""'], {}), "('<NAME>.jpeg')\n", (52, 67), False, 'import cv2\n'), ((78, 114), 'cv2.cvtColor', 'cv2.cvtColor', (['img', 'cv2.COLOR_BGR2RGB'], {}), '(img, cv2.COLOR_BGR2RGB)\n', (90, 114), False, 'import cv2\n'), ((182, 214), 'cv2.imread', 'cv2.imread', (['"""imag... |
# vim: tabstop=4 shiftwidth=4 softtabstop=4
# Copyright 2012 OpenStack LLC
#
# 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 requ... | [
"keystoneclient.contrib.ec2.utils.Ec2Signer"
] | [((924, 946), 'keystoneclient.contrib.ec2.utils.Ec2Signer', 'Ec2Signer', (['self.secret'], {}), '(self.secret)\n', (933, 946), False, 'from keystoneclient.contrib.ec2.utils import Ec2Signer\n')] |
from pathlib import Path
from typing import Dict, Any
import icontract
import pandas as pd
import pytest
from fuzzymatch_records.deduplicate import deduplicate_dataframe_columns
from pandas.testing import assert_frame_equal
CWD = Path(__file__).parent
DATA = CWD / "data"
@pytest.fixture
def duplicates() -> Dict[str... | [
"pathlib.Path",
"pytest.mark.parametrize",
"pytest.raises",
"pandas.read_excel",
"pandas.DataFrame",
"fuzzymatch_records.deduplicate.deduplicate_dataframe_columns"
] | [((422, 494), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""input_sheet"""', "['duplicates', 'not_duplicates']"], {}), "('input_sheet', ['duplicates', 'not_duplicates'])\n", (445, 494), False, 'import pytest\n'), ((922, 973), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""key"""', "['not_a_da... |
"""
test_predictor.py
Class created to run automated unit testings for the Pico & Placa predictor.
The tests are made for the following use-cases:
1. Users are allowed to go outside
2. Users are not allowed to go outside
3. License plate is not valid
4. Date format is incor... | [
"predictor.plate_validation",
"predictor.time_validation",
"predictor.predictor",
"predictor.date_validation"
] | [((614, 657), 'predictor.predictor', 'predictor', (['"""abc1231"""', '"""26/04/2021"""', '"""19:40"""'], {}), "('abc1231', '26/04/2021', '19:40')\n", (623, 657), False, 'from predictor import predictor, plate_validation, date_validation, time_validation\n'), ((683, 726), 'predictor.predictor', 'predictor', (['"""abc123... |
from attr import attrs, attrib
from aioalice.types import AliceObject, BaseSession, Response
from aioalice.utils import ensure_cls
@attrs
class AliceResponse(AliceObject):
"""AliceResponse is a response to Alice API"""
response = attrib(converter=ensure_cls(Response))
session = attrib(converter=ensure_c... | [
"attr.attrib",
"aioalice.utils.ensure_cls"
] | [((357, 374), 'attr.attrib', 'attrib', ([], {'type': 'dict'}), '(type=dict)\n', (363, 374), False, 'from attr import attrs, attrib\n'), ((399, 416), 'attr.attrib', 'attrib', ([], {'type': 'dict'}), '(type=dict)\n', (405, 416), False, 'from attr import attrs, attrib\n'), ((441, 458), 'attr.attrib', 'attrib', ([], {'type... |
import numpy as np
from os import chdir
#wd="/Users/moudiki/Documents/Python_Packages/teller"
#
#chdir(wd)
import teller as tr
import pandas as pd
from sklearn import datasets
import numpy as np
from sklearn import datasets
from sklearn.ensemble import RandomForestRegressor
from sklearn.model_selection import ... | [
"sklearn.ensemble.RandomForestRegressor",
"sklearn.model_selection.train_test_split",
"numpy.delete",
"sklearn.datasets.load_boston",
"teller.Explainer"
] | [((362, 384), 'sklearn.datasets.load_boston', 'datasets.load_boston', ([], {}), '()\n', (382, 384), False, 'from sklearn import datasets\n'), ((389, 418), 'numpy.delete', 'np.delete', (['boston.data', '(11)', '(1)'], {}), '(boston.data, 11, 1)\n', (398, 418), True, 'import numpy as np\n'), ((587, 642), 'sklearn.model_s... |
##############################################################################
#
# <NAME>
# <EMAIL>
#
# References:
# SuperDataScience,
# Official Documentation
#
#
##############################################################################
# Importing the libraries
import numpy as np
impo... | [
"numpy.unique",
"pandas.read_csv",
"matplotlib.pyplot.ylabel",
"sklearn.model_selection.train_test_split",
"sklearn.naive_bayes.GaussianNB",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.clf",
"sklearn.metrics.classification_report",
"matplotlib.colors.ListedColormap",
"matplotlib.pyplot.title",
... | [((2492, 2518), 'pandas.read_csv', 'pd.read_csv', (['"""Circles.csv"""'], {}), "('Circles.csv')\n", (2503, 2518), True, 'import pandas as pd\n'), ((2776, 2796), 'matplotlib.pyplot.title', 'plt.title', (['"""Dataset"""'], {}), "('Dataset')\n", (2785, 2796), True, 'import matplotlib.pyplot as plt\n'), ((2797, 2813), 'mat... |
#!/usr/bin/python3
import numpy as np
import PIL.Image
#infile = 'CHX_Eiger1M_blemish2-mask.npy'
infile = 'CHX_Eiger1M_flatfield.npy'
outfile = infile[:-4] + '.png'
pixmask = np.load(infile)
#pixmask = pixmask < 1
#img = np.where( pixmask<1, 255, 0)
#img = np.where( pixmask<1, 0, 255)
img = np.where( pixmask<0.1, ... | [
"numpy.where",
"numpy.uint8",
"numpy.load"
] | [((179, 194), 'numpy.load', 'np.load', (['infile'], {}), '(infile)\n', (186, 194), True, 'import numpy as np\n'), ((297, 328), 'numpy.where', 'np.where', (['(pixmask < 0.1)', '(0)', '(255)'], {}), '(pixmask < 0.1, 0, 255)\n', (305, 328), True, 'import numpy as np\n'), ((356, 369), 'numpy.uint8', 'np.uint8', (['img'], {... |
# File: G402 - 90% Project Completion
# Authors: <NAME>
# <NAME>
# <NAME>
import fileinput
def menu_display():
print('\n=============================================')
print(' Directory for Construction Tools and Data ')
... | [
"fileinput.input"
] | [((1843, 1889), 'fileinput.input', 'fileinput.input', (['"""Directory.txt"""'], {'inplace': '(True)'}), "('Directory.txt', inplace=True)\n", (1858, 1889), False, 'import fileinput\n')] |
#-*-coding:utf-8-*-
# date:2020-03-02
# Author: X.li
# function: inference & eval CenterNet only support resnet backbone
import os
import glob
import cv2
import numpy as np
import time
import shutil
import torch
import json
import matplotlib.pyplot as plt
from data_iterator import LoadImagesAndLabels
from models.decod... | [
"cv2.rectangle",
"matplotlib.pyplot.grid",
"pycocotools.cocoeval.COCOeval",
"matplotlib.pyplot.ylabel",
"torch.from_numpy",
"cv2.imshow",
"torch.cuda.synchronize",
"numpy.array",
"torch.cuda.is_available",
"numpy.arange",
"os.path.exists",
"os.listdir",
"pycocotools.coco.getImgIds",
"numpy... | [((1023, 1049), 'numpy.arange', 'np.arange', (['(0.0)', '(1.01)', '(0.01)'], {}), '(0.0, 1.01, 0.01)\n', (1032, 1049), True, 'import numpy as np\n'), ((1054, 1074), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""recall"""'], {}), "('recall')\n", (1064, 1074), True, 'import matplotlib.pyplot as plt\n'), ((1079, 1102), ... |
#!/bin/env python3
import gex
import time
# generating a pulse on gpio, test of the unit
with gex.Client(gex.TrxRawUSB()) as client:
out = gex.DOut(client, 'out')
out.pulse_us([0], 20)
out.pulse_us([3], 10) | [
"gex.TrxRawUSB",
"gex.DOut"
] | [((145, 168), 'gex.DOut', 'gex.DOut', (['client', '"""out"""'], {}), "(client, 'out')\n", (153, 168), False, 'import gex\n'), ((107, 122), 'gex.TrxRawUSB', 'gex.TrxRawUSB', ([], {}), '()\n', (120, 122), False, 'import gex\n')] |
import json
import requests
from . import BASE_URL
from .exceptions import generate_reference, handle_response
class ReceiveMoneyService:
def __init__(self, token):
self.token = token
self.headers = {
'Content-Type': 'application/json',
'Authorization': self.token
... | [
"json.dumps"
] | [((1327, 1346), 'json.dumps', 'json.dumps', (['payload'], {}), '(payload)\n', (1337, 1346), False, 'import json\n'), ((2897, 2916), 'json.dumps', 'json.dumps', (['payload'], {}), '(payload)\n', (2907, 2916), False, 'import json\n'), ((4045, 4064), 'json.dumps', 'json.dumps', (['payload'], {}), '(payload)\n', (4055, 406... |
import datetime
from thingsboard_gateway.tb_utility.tb_utility import TBUtility
try:
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization
from cryptography.hazmat.primitives.asymmetric import rsa
from cryptography import x509
from cryptog... | [
"cryptography.x509.NameAttribute",
"cryptography.x509.random_serial_number",
"datetime.datetime.utcnow",
"cryptography.x509.CertificateBuilder",
"cryptography.x509.DNSName",
"cryptography.hazmat.primitives.serialization.NoEncryption",
"cryptography.hazmat.primitives.hashes.SHA256",
"thingsboard_gatewa... | [((484, 525), 'thingsboard_gateway.tb_utility.tb_utility.TBUtility.install_package', 'TBUtility.install_package', (['"""cryptography"""'], {}), "('cryptography')\n", (509, 525), False, 'from thingsboard_gateway.tb_utility.tb_utility import TBUtility\n'), ((2458, 2473), 'cryptography.hazmat.primitives.hashes.SHA256', 'h... |
import pylab as pyl
import h5py as hdf
import corner
### Targeted ###
################
with hdf.File('./result_targetedPerfect.hdf5', 'r') as f:
dset = f[f.keys()[0]]
#data = dset['IDX', 'HALOID', 'ZSPEC', 'M200c', 'NGAL', 'LOSVD',
# 'LOSVD_err', 'MASS', 'LOSVD_dist']
data = dset['ZSPEC', 'M200c',... | [
"pylab.log10",
"corner.corner",
"h5py.File"
] | [((571, 682), 'corner.corner', 'corner.corner', (['X'], {'labels': "['z', 'Log $M_{200c}$', 'Log $\\\\sigma$']", 'bins': '(50)', 'smooth': '(True)', 'fill_contours': '(True)'}), "(X, labels=['z', 'Log $M_{200c}$', 'Log $\\\\sigma$'], bins=50,\n smooth=True, fill_contours=True)\n", (584, 682), False, 'import corner\n... |
import naturalize.crossover.core as c
import naturalize.crossover.strategies as st
from naturalize.solutionClass import Individual
import numpy as np
import pytest
# from naturalize.crossover.strategies import crossGene, basicCrossover
from naturalize.solutionClass import Individual
import numpy as np
np.random.s... | [
"naturalize.crossover.core.getCrossover",
"numpy.empty",
"numpy.random.seed",
"naturalize.solutionClass.Individual",
"numpy.all",
"naturalize.crossover.strategies.crossGeneSingleCut"
] | [((309, 327), 'numpy.random.seed', 'np.random.seed', (['(25)'], {}), '(25)\n', (323, 327), True, 'import numpy as np\n'), ((374, 385), 'numpy.empty', 'np.empty', (['(5)'], {}), '(5)\n', (382, 385), True, 'import numpy as np\n'), ((394, 405), 'numpy.empty', 'np.empty', (['(5)'], {}), '(5)\n', (402, 405), True, 'import n... |
import swmm_tools
import plot_tools
import os
import logging
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
def run_scenarios(scenarios, tmp_folder, tmp_name, out_folder):
for sc, data in scenarios:
out_inp = os.path.join(out_folder, '%s.inp' % sc)
swmm_tools.render_inpu... | [
"swmm_tools.render_input",
"os.path.join",
"seaborn.scatterplot",
"pandas.DataFrame",
"swmm_tools.run",
"matplotlib.pyplot.subplots"
] | [((1320, 1338), 'pandas.DataFrame', 'pd.DataFrame', (['rows'], {}), '(rows)\n', (1332, 1338), True, 'import pandas as pd\n'), ((1417, 1442), 'matplotlib.pyplot.subplots', 'plt.subplots', (['event_ct', '(1)'], {}), '(event_ct, 1)\n', (1429, 1442), True, 'import matplotlib.pyplot as plt\n'), ((3309, 3328), 'matplotlib.py... |
from __future__ import absolute_import
from __future__ import print_function
import argparse
import os
import sys
import string
import subprocess, logging
from threading import Thread
import time
import socket
import commands
def get_mpi_env(envs):
"""get the mpirun command for setting the envornment
support... | [
"commands.getoutput",
"argparse.ArgumentParser",
"subprocess.check_call",
"socket.socket",
"subprocess.Popen",
"string.split",
"os.environ.copy",
"time.sleep",
"os.path.isdir",
"sys.exit",
"threading.Thread"
] | [((4011, 4022), 'sys.exit', 'sys.exit', (['(0)'], {}), '(0)\n', (4019, 4022), False, 'import sys\n'), ((4882, 4897), 'socket.socket', 'socket.socket', ([], {}), '()\n', (4895, 4897), False, 'import socket\n'), ((5951, 6014), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Launch a distrib... |
import logging
__author__ = 'Adisor'
"""
This file is used to configure logging and to give the configured logging object to the rest of the application
"""
def clear_log_file(logfile):
with open(logfile, 'w'):
pass
logfile = 'log.log'
FORMAT = '%(asctime)-12s %(message)s'
logging.basicConfig(filename... | [
"logging.basicConfig",
"logging.getLogger"
] | [((292, 365), 'logging.basicConfig', 'logging.basicConfig', ([], {'filename': 'logfile', 'format': 'FORMAT', 'level': 'logging.DEBUG'}), '(filename=logfile, format=FORMAT, level=logging.DEBUG)\n', (311, 365), False, 'import logging\n'), ((399, 418), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (416, 418)... |
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
]
operations = [
migrations.CreateModel(
name='Area',
fields=[
('id', models.AutoField(verbose... | [
"django.db.models.IntegerField",
"django.db.models.AutoField",
"django.db.models.CharField",
"django.db.models.ForeignKey"
] | [((1362, 1401), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'to': '"""chipyapp.Module"""'}), "(to='chipyapp.Module')\n", (1379, 1401), False, 'from django.db import migrations, models\n'), ((296, 389), 'django.db.models.AutoField', 'models.AutoField', ([], {'verbose_name': '"""ID"""', 'serialize': '(False... |
from django.db import models
from datetime import date
# Create your models here.
class Script(models.Model):
"""
For the script designator, use the ISO 15924 standard, four letters with the first letter
uppercase and the last three lowercase.
"""
iso_15294 = models.CharField(max_length=4,unique=T... | [
"django.db.models.DateField",
"django.db.models.UniqueConstraint",
"django.db.models.CharField",
"django.db.models.ForeignKey"
] | [((282, 325), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(4)', 'unique': '(True)'}), '(max_length=4, unique=True)\n', (298, 325), False, 'from django.db import models\n'), ((343, 386), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(3)', 'unique': '(True)'}), '(max_le... |
# -*- coding:utf8 -*-
"""
Selenium wrapper for ss.lv website
"""
from __future__ import unicode_literals
import random
import string
from selenium import webdriver
from selenium.common import exceptions
from selenium.webdriver.common.desired_capabilities import DesiredCapabilities
# Phantom JS config
phantomjs_confi... | [
"selenium.webdriver.PhantomJS",
"random.choice"
] | [((743, 864), 'selenium.webdriver.PhantomJS', 'webdriver.PhantomJS', (['PHANTOMJS_EXECUTABLE_PATH'], {'desired_capabilities': 'phantomjs_config', 'service_args': 'phantomjs_params'}), '(PHANTOMJS_EXECUTABLE_PATH, desired_capabilities=\n phantomjs_config, service_args=phantomjs_params)\n', (762, 864), False, 'from se... |
import bpy
from bpy.types import Operator
class ConvertToBWOperator(Operator):
bl_idname = "object.convert_to_bw_operator"
bl_label = "Convert Colored Voxels to Black"
bl_options = {'REGISTER', 'UNDO'}
@classmethod
def poll(self, context):
return True
def execute(self, ... | [
"bpy.utils.unregister_class",
"bpy.utils.register_class"
] | [((859, 904), 'bpy.utils.register_class', 'bpy.utils.register_class', (['ConvertToBWOperator'], {}), '(ConvertToBWOperator)\n', (883, 904), False, 'import bpy\n'), ((928, 975), 'bpy.utils.unregister_class', 'bpy.utils.unregister_class', (['ConvertToBWOperator'], {}), '(ConvertToBWOperator)\n', (954, 975), False, 'impor... |
from django.core.management.base import BaseCommand
from main.views import get_csv
class Command(BaseCommand):
help = 'Gets data from CSV file'
def handle(self, *args, **options):
get_csv()
self.stdout.write(self.style.SUCCESS('Successfully imported data from CSV'))
| [
"main.views.get_csv"
] | [((207, 216), 'main.views.get_csv', 'get_csv', ([], {}), '()\n', (214, 216), False, 'from main.views import get_csv\n')] |
import datetime
import logging
import os.path
import unittest
import zipfile
from easy_atom import helpers
class TestUnzip(unittest.TestCase):
def setUp(self):
self.logger = logging.getLogger('utest')
self.zipfilename = "ExtractionMonoTable_CAT18_ToutePopulation_201802031143.zip"
def test_u... | [
"unittest.main",
"easy_atom.helpers.stdout_logger",
"datetime.datetime.now",
"logging.getLogger"
] | [((958, 1004), 'easy_atom.helpers.stdout_logger', 'helpers.stdout_logger', (["['utest']", 'logging.INFO'], {}), "(['utest'], logging.INFO)\n", (979, 1004), False, 'from easy_atom import helpers\n'), ((1010, 1025), 'unittest.main', 'unittest.main', ([], {}), '()\n', (1023, 1025), False, 'import unittest\n'), ((190, 216)... |
#! /usr/bin/env python3
import logging
import os
import time
import psycopg2
import psycopg2.extras
DB_TYPE = 'postgres'
log = logging.getLogger(__name__)
class Database:
def __init__(self, config: dict):
self.cfg = config
self.cfg_con = config.get('connection')
self.init_script = conf... | [
"logging.getLogger",
"os.path.exists",
"time.sleep"
] | [((130, 157), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (147, 157), False, 'import logging\n'), ((782, 795), 'time.sleep', 'time.sleep', (['(1)'], {}), '(1)\n', (792, 795), False, 'import time\n'), ((2984, 3011), 'os.path.exists', 'os.path.exists', (['script_path'], {}), '(script_pat... |
#
# Copyright (c) 2019 ISP RAS (http://www.ispras.ru)
# Ivannikov Institute for System Programming of the Russian Academy of Sciences
#
# 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
#
# h... | [
"marks.SafeUtils.RemoveSafeMark",
"marks.UnknownUtils.perform_unknown_mark_create",
"zipfile.ZipFile",
"marks.Download.MarksUploader",
"marks.UnsafeUtils.RemoveUnsafeMark",
"marks.UnknownUtils.RemoveUnknownMark",
"bridge.utils.logger.exception",
"marks.UnsafeUtils.perform_unsafe_mark_update",
"cache... | [((3026, 3048), 'marks.models.MarkSafe.objects.all', 'MarkSafe.objects.all', ([], {}), '()\n', (3046, 3048), False, 'from marks.models import MarkSafe, MarkUnsafe, MarkUnknown, Tag, MarkSafeReport, MarkUnsafeReport, MarkUnknownReport, SafeAssociationLike, UnsafeAssociationLike, UnknownAssociationLike, MarkSafeHistory, ... |
import os
import argparse
import json
from utils.vocab import Vocab
import modules.language_model as ppl_metric
import modules.classifier as acc_metric
argparser = argparse.ArgumentParser()
argparser.add_argument("--metric", type=str, default="ppl")
argparser.add_argument("--mode", type=str, default="train")
argparse... | [
"os.path.exists",
"modules.language_model.train_language_model",
"modules.classifier.train_sentence_classifier",
"os.makedirs",
"argparse.ArgumentParser",
"modules.language_model.evaluate",
"utils.vocab.Vocab",
"modules.classifier.evaluate"
] | [((166, 191), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (189, 191), False, 'import argparse\n'), ((1123, 1202), 'utils.vocab.Vocab', 'Vocab', (["params['vocab_path']", "params['max_vocab_size']", "params['min_token_freq']"], {}), "(params['vocab_path'], params['max_vocab_size'], params['mi... |
import requests
import logging
import pickle
import os
import json
pickle_dir = 'data/pickle_db/'
raw_data_dir = 'data/01_raw/'
def initialize_pickle(league_id):
logging.info(f'---------- initialize_pickle({league_id}) ----------')
if (os.path.isfile(f'{pickle_dir}league_{league_id}')):
logging.info(f... | [
"pickle.dump",
"pickle.load",
"os.path.isfile",
"json.load",
"logging.info"
] | [((168, 237), 'logging.info', 'logging.info', (['f"""---------- initialize_pickle({league_id}) ----------"""'], {}), "(f'---------- initialize_pickle({league_id}) ----------')\n", (180, 237), False, 'import logging\n'), ((246, 295), 'os.path.isfile', 'os.path.isfile', (['f"""{pickle_dir}league_{league_id}"""'], {}), "(... |
# -*- coding: utf-8 -*-
from django.conf import settings
from django.urls import reverse
from django.utils.six.moves.urllib.parse import urlparse
from django.utils.translation import ugettext as _
import pytest
from ..factories import AdminFactory, UserFactory
@pytest.mark.django_db
def test_login_required(django_... | [
"django.utils.translation.ugettext",
"django.utils.six.moves.urllib.parse.urlparse",
"django.urls.reverse"
] | [((336, 396), 'django.urls.reverse', 'reverse', (['"""mobetta:icu_file_list"""'], {'kwargs': "{'lang_code': 'nl'}"}), "('mobetta:icu_file_list', kwargs={'lang_code': 'nl'})\n", (343, 396), False, 'from django.urls import reverse\n'), ((459, 486), 'django.utils.six.moves.urllib.parse.urlparse', 'urlparse', (['response.l... |
from django.db import models
from users.models import User
class Event(models.Model):
title = models.CharField(verbose_name="事件名", max_length=64)
time = models.DateField(verbose_name="事件执行日期")
finished = models.BooleanField(verbose_name="是否完成", default=False)
creator = models.ForeignKey(User, on_dele... | [
"django.db.models.ForeignKey",
"django.db.models.DateField",
"django.db.models.CharField",
"django.db.models.BooleanField"
] | [((101, 152), 'django.db.models.CharField', 'models.CharField', ([], {'verbose_name': '"""事件名"""', 'max_length': '(64)'}), "(verbose_name='事件名', max_length=64)\n", (117, 152), False, 'from django.db import models\n'), ((164, 203), 'django.db.models.DateField', 'models.DateField', ([], {'verbose_name': '"""事件执行日期"""'}),... |
import requests
import json
from tokens.settings import BLOCKCYPHER_API_KEY
def register_new_token(email, new_token, first=None, last=None):
assert new_token and email
post_params = {
"first": "MichaelFlaxman",
"last": "TestingOkToToss",
"email": "<EMAIL>",
"token": new_token... | [
"json.loads",
"json.dumps"
] | [((573, 591), 'json.loads', 'json.loads', (['r.text'], {}), '(r.text)\n', (583, 591), False, 'import json\n'), ((465, 488), 'json.dumps', 'json.dumps', (['post_params'], {}), '(post_params)\n', (475, 488), False, 'import json\n')] |
"""
Copyright 2022 Objectiv B.V.
"""
import pytest
from bach.from_pandas import _assert_column_names_valid
from tests.unit.bach.test_utils import ColNameValid
from tests.unit.bach.util import get_pandas_df
def test__assert_column_names_valid_generic(dialect):
# check for duplicates and for non-named columns
... | [
"tests.unit.bach.test_utils.ColNameValid",
"tests.unit.bach.util.get_pandas_df",
"pytest.raises",
"bach.from_pandas._assert_column_names_valid"
] | [((395, 444), 'tests.unit.bach.util.get_pandas_df', 'get_pandas_df', ([], {'dataset': 'data', 'columns': 'column_names'}), '(dataset=data, columns=column_names)\n', (408, 444), False, 'from tests.unit.bach.util import get_pandas_df\n'), ((489, 540), 'bach.from_pandas._assert_column_names_valid', '_assert_column_names_v... |
import datetime
import io
from openpyxl import load_workbook
from ftc.management.commands._base_scraper import HTMLScraper
from ftc.models import Organisation, OrganisationLocation
class Command(HTMLScraper):
"""
Spider for scraping details of Registered Social Landlords in England
"""
name = "rsl"... | [
"datetime.datetime.now",
"io.BytesIO"
] | [((1726, 1747), 'io.BytesIO', 'io.BytesIO', (['r.content'], {}), '(r.content)\n', (1736, 1747), False, 'import io\n'), ((5790, 5813), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (5811, 5813), False, 'import datetime\n')] |
from pypresence import Presence
import time
import configparser
import os
import json
import psutil
import urllib.request
from pypresence.exceptions import InvalidPipe
firstrun = True
startup = True
start_time=time.time()
configpar = configparser.ConfigParser(allow_no_value=True)
while True:
tr... | [
"os.path.exists",
"configparser.ConfigParser",
"pypresence.Presence",
"psutil.process_iter",
"time.sleep",
"time.localtime",
"time.time",
"json.dump"
] | [((224, 235), 'time.time', 'time.time', ([], {}), '()\n', (233, 235), False, 'import time\n'), ((249, 295), 'configparser.ConfigParser', 'configparser.ConfigParser', ([], {'allow_no_value': '(True)'}), '(allow_no_value=True)\n', (274, 295), False, 'import configparser\n'), ((2821, 2835), 'time.sleep', 'time.sleep', (['... |
from setuptools import setup
setup(
name='Rocksmith-Servant',
version='0.1',
packages=[''],
url='https://github.com/kozaka-tv/Rocksmith-Servant',
license='',
author='kozaka',
author_email='<EMAIL>',
description='A Servant, a Bot for Rocksmith'
)
| [
"setuptools.setup"
] | [((30, 259), 'setuptools.setup', 'setup', ([], {'name': '"""Rocksmith-Servant"""', 'version': '"""0.1"""', 'packages': "['']", 'url': '"""https://github.com/kozaka-tv/Rocksmith-Servant"""', 'license': '""""""', 'author': '"""kozaka"""', 'author_email': '"""<EMAIL>"""', 'description': '"""A Servant, a Bot for Rocksmith"... |