code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
#!/usr/bin/env python3
import argparse
import os
import re
import glog as log
import numpy as np
import pandas as pd
import ray
from factorized_sampler_lib import data_utils
from factorized_sampler_lib import rustlib
import join_utils
NULL = -1
@ray.remote
def get_first_jct(join_name, table, base_count_table):
... | [
"os.path.exists",
"ray.get",
"pandas.Int64Dtype",
"join_utils.get_bottom_up_table_ordering",
"numpy.nanprod",
"os.path.join",
"numpy.isin",
"glog.info",
"factorized_sampler_lib.rustlib.prepare_indices",
"factorized_sampler_lib.data_utils.save_result",
"ray.init"
] | [((324, 411), 'factorized_sampler_lib.data_utils.save_result', 'data_utils.save_result', (['f"""{table}.jct"""', 'join_name', 'f"""join count table of `{table}`"""'], {}), "(f'{table}.jct', join_name,\n f'join count table of `{table}`')\n", (346, 411), False, 'from factorized_sampler_lib import data_utils\n'), ((789... |
from rest_framework import serializers
from users_api import models
class UserSerializer(serializers.ModelSerializer):
class Meta:
model = models.User
fields = ('id', 'email', 'username', 'password')
# Passwd field only availble for creating object
extra_kwargs = {
'pa... | [
"users_api.models.User.objects.user_creation"
] | [((593, 736), 'users_api.models.User.objects.user_creation', 'models.User.objects.user_creation', ([], {'email': "validated_data['email']", 'username': "validated_data['username']", 'password': "validated_data['password']"}), "(email=validated_data['email'], username=\n validated_data['username'], password=validated... |
import pandas as pd
import seaborn as sns
import numpy as np
from skforecast.ForecasterAutoreg import ForecasterAutoreg
from skforecast.ForecasterAutoregCustom import ForecasterAutoregCustom
from skforecast.ForecasterAutoregMultiOutput import ForecasterAutoregMultiOutput
from skforecast.model_selection import gri... | [
"pandas.read_csv",
"pandas.DatetimeIndex",
"pandas.Timedelta",
"pandas.DataFrame",
"datetime.timedelta",
"pandas.to_datetime"
] | [((3830, 3860), 'pandas.read_csv', 'pd.read_csv', (['"""cities_prom.csv"""'], {}), "('cities_prom.csv')\n", (3841, 3860), True, 'import pandas as pd\n'), ((1517, 1561), 'pandas.to_datetime', 'pd.to_datetime', (["df2['Date']"], {'errors': '"""coerce"""'}), "(df2['Date'], errors='coerce')\n", (1531, 1561), True, 'import ... |
from CukooHashSet import CukooSet
def test_set_add_1_element():
"""Add 1 element to CukooSet"""
mySet = CukooSet()
assert mySet.insert("1")
def test_set_search_1_element():
"""Searching for element in cukoo set"""
mySet = CukooSet()
assert mySet.insert("1")
assert mySet._contains("1")
... | [
"CukooHashSet.CukooSet"
] | [((114, 124), 'CukooHashSet.CukooSet', 'CukooSet', ([], {}), '()\n', (122, 124), False, 'from CukooHashSet import CukooSet\n'), ((246, 256), 'CukooHashSet.CukooSet', 'CukooSet', ([], {}), '()\n', (254, 256), False, 'from CukooHashSet import CukooSet\n'), ((440, 450), 'CukooHashSet.CukooSet', 'CukooSet', ([], {}), '()\n... |
from datetime import datetime as dt
class Account():
def __init__(self, account_nr, client_name, opening_date, interest_rate, opening_amount):
self.account_nr = account_nr
self.client_name = client_name
self.opening_date = dt.strptime(opening_date, "%Y-%m-%d")
self.interest_rate = ... | [
"datetime.datetime.strptime"
] | [((253, 290), 'datetime.datetime.strptime', 'dt.strptime', (['opening_date', '"""%Y-%m-%d"""'], {}), "(opening_date, '%Y-%m-%d')\n", (264, 290), True, 'from datetime import datetime as dt\n')] |
import time
import application2 as ap
import matplotlib.pyplot as plt
if __name__ == '__main__':
x_nodes = range(10, 1000, 10)
y_slow = []
y_fast = []
for num_nodes in x_nodes:
ugraph = ap.upa_graph(num_nodes, 5)
start = time.time()
ap.targeted_order(ugraph)
end = time... | [
"application2.upa_graph",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"application2.fast_targeted_order",
"application2.targeted_order",
"matplotlib.pyplot.title",
"time.time",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.show"
] | [((517, 577), 'matplotlib.pyplot.plot', 'plt.plot', (['x_nodes', 'y_slow', '"""-b"""'], {'label': '"""slow targeted order"""'}), "(x_nodes, y_slow, '-b', label='slow targeted order')\n", (525, 577), True, 'import matplotlib.pyplot as plt\n'), ((582, 642), 'matplotlib.pyplot.plot', 'plt.plot', (['x_nodes', 'y_fast', '""... |
"""ClusterMsgs module: Message types for Cluster rendering"""
# This module is intended to supply routines and dataformats common to
# both ClusterClient and ClusterServer.
from panda3d.core import *
from direct.distributed.PyDatagram import PyDatagram
from direct.distributed.PyDatagramIterator import PyDatagramItera... | [
"time.sleep",
"direct.distributed.PyDatagramIterator.PyDatagramIterator",
"direct.distributed.PyDatagram.PyDatagram"
] | [((3683, 3711), 'direct.distributed.PyDatagramIterator.PyDatagramIterator', 'PyDatagramIterator', (['datagram'], {}), '(datagram)\n', (3701, 3711), False, 'from direct.distributed.PyDatagramIterator import PyDatagramIterator\n'), ((3942, 3954), 'direct.distributed.PyDatagram.PyDatagram', 'PyDatagram', ([], {}), '()\n',... |
import itertools
import random
class Minesweeper():
"""
Minesweeper game representation
"""
def __init__(self, height=8, width=8, mines=8):
# Set initial width, height, and number of mines
self.height = height
self.width = width
self.mines = set()
# Initialize... | [
"random.choice",
"random.randrange"
] | [((9909, 9942), 'random.choice', 'random.choice', (['possibleMovesTuple'], {}), '(possibleMovesTuple)\n', (9922, 9942), False, 'import random\n'), ((627, 651), 'random.randrange', 'random.randrange', (['height'], {}), '(height)\n', (643, 651), False, 'import random\n'), ((668, 691), 'random.randrange', 'random.randrang... |
import unittest
from tests import testlib
from skeletor.db import table
class DBTableTestCase(unittest.TestCase):
def setUp(self):
self.name = 'test'
self.email = '<EMAIL>'
self.context = testlib.create_database(self)
self.table = table.Table('users')
def test_new_user(self... | [
"unittest.main",
"skeletor.db.table.Table",
"tests.testlib.create_database"
] | [((3666, 3681), 'unittest.main', 'unittest.main', ([], {}), '()\n', (3679, 3681), False, 'import unittest\n'), ((221, 250), 'tests.testlib.create_database', 'testlib.create_database', (['self'], {}), '(self)\n', (244, 250), False, 'from tests import testlib\n'), ((272, 292), 'skeletor.db.table.Table', 'table.Table', ([... |
# @crzypatchwork
from flask import Blueprint, request, session
from pytezos import Contract
from pytezos import pytezos
from pytezos.operation.result import OperationResult
from flask import Flask
from flask_restx import fields, Resource, Api, Namespace
from decimal import *
from controllers.validate import Validate
... | [
"json.loads",
"flask_restx.Namespace",
"controllers.validate.Validate",
"pytezos.operation.result.OperationResult.originated_contracts",
"pytezos.Contract.from_file"
] | [((420, 430), 'controllers.validate.Validate', 'Validate', ([], {}), '()\n', (428, 430), False, 'from controllers.validate import Validate\n'), ((437, 506), 'flask_restx.Namespace', 'Namespace', (['"""atomic_swap"""'], {'description': '"""publish and other entrypoints"""'}), "('atomic_swap', description='publish and ot... |
# Copyright 2018 The Oppia Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable ... | [
"core.domain.classroom_services.get_classroom_by_url_fragment",
"core.domain.topic_fetchers.get_multi_topic_rights",
"core.domain.topic_fetchers.get_multi_topic_summaries"
] | [((1642, 1714), 'core.domain.classroom_services.get_classroom_by_url_fragment', 'classroom_services.get_classroom_by_url_fragment', (['classroom_url_fragment'], {}), '(classroom_url_fragment)\n', (1690, 1714), False, 'from core.domain import classroom_services\n'), ((1795, 1846), 'core.domain.topic_fetchers.get_multi_t... |
import numpy as np
from matplotlib import pyplot as plt
import pickle
file = open('Data/Alpha0Bw7', 'rb')
Data = np.array(pickle.load(file))
Alpha0 = [0.01, 0.02, 0.05, 0.1, 0.2, 0.4, 0.6, 0.9]
Bw = np.linspace(0.4, 3.2, 15)
Names = ['alpha0', 'bw',
'IS est', 'IS a-var', 'n0/ESS', 'n0/RSS', 'kernel number',
... | [
"numpy.ones",
"numpy.log",
"pickle.load",
"numpy.linspace",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.show"
] | [((201, 226), 'numpy.linspace', 'np.linspace', (['(0.4)', '(3.2)', '(15)'], {}), '(0.4, 3.2, 15)\n', (212, 226), True, 'import numpy as np\n'), ((124, 141), 'pickle.load', 'pickle.load', (['file'], {}), '(file)\n', (135, 141), False, 'import pickle\n'), ((1121, 1157), 'matplotlib.pyplot.subplots', 'plt.subplots', (['(3... |
import subprocess
from jetee.common.utils import render_env_variables
class SSHClient(object):
def __init__(self, hostname, port, username, env_variables=None):
self.hostname = hostname
self.port = port
self.username = username
self.env_variables = env_variables or {}
def run... | [
"jetee.common.utils.render_env_variables"
] | [((373, 429), 'jetee.common.utils.render_env_variables', 'render_env_variables', (['self.env_variables'], {'delimiter': 'u""" """'}), "(self.env_variables, delimiter=u' ')\n", (393, 429), False, 'from jetee.common.utils import render_env_variables\n')] |
"""
This file is part of the accompanying code to our manuscript:
<NAME>., <NAME>., <NAME>., and <NAME>.: A note on leveraging synergy in multiple meteorological
datasets with deep learning for rainfall-runoff modeling, Hydrol. Earth Syst. Sci. Discuss.,
https://doi.org/10.5194/hess-2020-221, in review, 2020.
You sho... | [
"torch.nn.LSTM",
"codebase.modelzoo.head.get_head",
"torch.nn.Dropout",
"torch.cat"
] | [((1099, 1166), 'torch.nn.LSTM', 'nn.LSTM', ([], {'input_size': 'self.input_size', 'hidden_size': "cfg['hidden_size']"}), "(input_size=self.input_size, hidden_size=cfg['hidden_size'])\n", (1106, 1166), True, 'import torch.nn as nn\n'), ((1191, 1226), 'torch.nn.Dropout', 'nn.Dropout', ([], {'p': "cfg['output_dropout']"}... |
from flask import (current_app, render_template, url_for, request, Blueprint,
flash, redirect,abort)
from calla.utils import iterdir
import sys, os
from calla.article import article_factory
from calla.forms import ArticleForm, SettingForm, ServerSettingForm
import copy
from .config import Config
ad... | [
"flask.render_template",
"flask.request.args.get",
"flask.flash",
"calla.forms.ServerSettingForm",
"flask.Blueprint",
"flask.url_for",
"copy.deepcopy",
"flask.abort",
"copy.copy",
"calla.forms.ArticleForm",
"calla.forms.SettingForm",
"calla.article.article_factory"
] | [((329, 357), 'flask.Blueprint', 'Blueprint', (['"""admin"""', '__name__'], {}), "('admin', __name__)\n", (338, 357), False, 'from flask import current_app, render_template, url_for, request, Blueprint, flash, redirect, abort\n'), ((371, 424), 'flask.Blueprint', 'Blueprint', (['"""article"""', '__name__'], {'url_prefix... |
import pytest
from reversion.models import Version
from reversion.revisions import create_revision
from djmoney.money import Money
from .testapp.models import RevisionedModel
@pytest.mark.django_db
def test_that_can_safely_restore_deleted_object():
amount = Money(100, "GHS")
with create_revision():
... | [
"reversion.models.Version.objects.get_deleted",
"reversion.revisions.create_revision",
"djmoney.money.Money"
] | [((266, 283), 'djmoney.money.Money', 'Money', (['(100)', '"""GHS"""'], {}), "(100, 'GHS')\n", (271, 283), False, 'from djmoney.money import Money\n'), ((293, 310), 'reversion.revisions.create_revision', 'create_revision', ([], {}), '()\n', (308, 310), False, 'from reversion.revisions import create_revision\n'), ((413, ... |
# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | [
"itertools.chain",
"numpy.prod",
"numpy.sqrt",
"tensorflow.python.ops.variables.global_variables_initializer",
"tensorflow.python.framework.random_seed.set_random_seed",
"tensorflow.python.ops.gradient_checker_v2.compute_gradient",
"six.moves.xrange",
"tensorflow.python.ops.variables.Variable",
"ten... | [((9072, 9145), 'tensorflow.python.framework.test_util.run_v1_only', 'test_util.run_v1_only', (['"""b/126596827 needs graph mode in multiple threads"""'], {}), "('b/126596827 needs graph mode in multiple threads')\n", (9093, 9145), False, 'from tensorflow.python.framework import test_util\n'), ((9779, 9790), 'tensorflo... |
import time
import random
import os
import os.path as osp
from mmseg.datasets.builder import DATASETS
from mmseg.datasets.ainno import AinnoDataset
CLASSES = ['background', 'huahen', 'zangwu', 'laji']
LABELS = [0, 1, 2, 3]
PALETTE = [[0, 0, 0], [0, 0, 255], [255, 0, 0], [0, 255, 0]]
@DATASETS.register_module()
clas... | [
"random.sample",
"os.listdir",
"random.shuffle",
"os.path.join",
"time.sleep",
"os.path.isfile",
"os.path.isdir",
"mmseg.datasets.builder.DATASETS.register_module"
] | [((289, 315), 'mmseg.datasets.builder.DATASETS.register_module', 'DATASETS.register_module', ([], {}), '()\n', (313, 315), False, 'from mmseg.datasets.builder import DATASETS\n'), ((2057, 2104), 'random.sample', 'random.sample', (['self.ok_ori_samples', 'self.ok_len'], {}), '(self.ok_ori_samples, self.ok_len)\n', (2070... |
from logging import getLogger
from pathlib import Path
from random import choice, choices
from .models import ParrotData
logger = getLogger(__name__)
class Parrot:
def read_data(self) -> ParrotData:
raise NotImplementedError
def write_data(self, data: ParrotData) -> None:
raise NotImplement... | [
"logging.getLogger",
"random.choices",
"pathlib.Path"
] | [((132, 151), 'logging.getLogger', 'getLogger', (['__name__'], {}), '(__name__)\n', (141, 151), False, 'from logging import getLogger\n'), ((1030, 1058), 'random.choices', 'choices', (['population', 'weights'], {}), '(population, weights)\n', (1037, 1058), False, 'from random import choice, choices\n'), ((1602, 1627), ... |
# 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, software
# distribu... | [
"openfermion.utils.count_qubits",
"openfermion.ops.QubitOperator"
] | [((4857, 4884), 'openfermion.ops.QubitOperator', 'QubitOperator', (['pauli_string'], {}), '(pauli_string)\n', (4870, 4884), False, 'from openfermion.ops import QubitOperator\n'), ((11095, 11110), 'openfermion.ops.QubitOperator', 'QubitOperator', ([], {}), '()\n', (11108, 11110), False, 'from openfermion.ops import Qubi... |
import os
import pickle
def load_model(input_dir):
"""
Modify this method to deserialize you model if this environment's standard model
loader cannot. For example, if your custom model archive contains multiple pickle
files, you must explicitly load which ever one corresponds to your serialized model
... | [
"pickle.load",
"os.path.join"
] | [((492, 534), 'os.path.join', 'os.path.join', (['input_dir', '"""sklearn_reg.pkl"""'], {}), "(input_dir, 'sklearn_reg.pkl')\n", (504, 534), False, 'import os\n'), ((590, 632), 'pickle.load', 'pickle.load', (['picklefile'], {'encoding': '"""latin1"""'}), "(picklefile, encoding='latin1')\n", (601, 632), False, 'import pi... |
#!/usr/bin/env python
from __future__ import print_function
from setuptools import setup, find_packages, Extension
from setuptools.command.build_ext import build_ext
from distutils.errors import DistutilsSetupError
from distutils import log
from distutils.dep_util import newer_group
from distutils.dir_util import mkpat... | [
"distutils.dir_util.mkpath",
"struct.calcsize",
"re.compile",
"pkg_resources.require",
"io.open",
"distutils.log.debug",
"sys.exit",
"setuptools.command.build_ext.build_ext.get_libraries",
"distutils.errors.DistutilsSetupError",
"os.path.exists",
"subprocess.run",
"setuptools.find_packages",
... | [((739, 773), 'os.environ.get', 'os.environ.get', (['"""SKIA_LIBRARY_DIR"""'], {}), "('SKIA_LIBRARY_DIR')\n", (753, 773), False, 'import os\n'), ((965, 1005), 'os.environ.get', 'os.environ.get', (['"""PYTHON2_EXE"""', '"""python2"""'], {}), "('PYTHON2_EXE', 'python2')\n", (979, 1005), False, 'import os\n'), ((1075, 113... |
import logging
import urllib.request
import xml.etree.ElementTree as ET
def xml_parse_url(url):
"""This function return all values in
the url, with the library xml.etree. ElementTree
we recover the data on the xlm url adding the
result in list
:return: dict with values total, free , stat... | [
"xml.etree.ElementTree.fromstring",
"logging.debug"
] | [((430, 502), 'logging.debug', 'logging.debug', (['"""initializing the variable %s for read the url"""', 'open_url'], {}), "('initializing the variable %s for read the url', open_url)\n", (443, 502), False, 'import logging\n'), ((519, 542), 'xml.etree.ElementTree.fromstring', 'ET.fromstring', (['open_url'], {}), '(open... |
import concurrent.futures
import os
import os.path as osp
import pathlib
import shutil
import urllib.parse
from .connection import download_image
from .data import PageContent
from .utils import escape_path
OUTPUT_PATH = pathlib.Path('data/')
OUTPUT_TEXT_FILENAME = 'article.txt'
def save_text(post_text: str, output... | [
"shutil.copyfileobj",
"os.path.basename",
"os.makedirs",
"pathlib.Path"
] | [((223, 244), 'pathlib.Path', 'pathlib.Path', (['"""data/"""'], {}), "('data/')\n", (235, 244), False, 'import pathlib\n'), ((914, 956), 'os.makedirs', 'os.makedirs', (['content_folder'], {'exist_ok': '(True)'}), '(content_folder, exist_ok=True)\n', (925, 956), False, 'import os\n'), ((596, 618), 'os.path.basename', 'o... |
import sqlite3 as sql
DB_PATH = "dispositivo.db"
def createDB():
conn = sql.connect(DB_PATH)
conn.commit()
conn.close()
if __name__ == "__main__":
createDB() | [
"sqlite3.connect"
] | [((76, 96), 'sqlite3.connect', 'sql.connect', (['DB_PATH'], {}), '(DB_PATH)\n', (87, 96), True, 'import sqlite3 as sql\n')] |
import arrow
import timeblocks
def get_all_busy(service,calendars,begin_date,end_date,begin_time,end_time):
"""
@brief creates a list of busy times using events from a set of given calendars
@param service: Google 'service' object
@param calendars (dict): a list of calendars
@param ... | [
"timeblocks.TimeBlock",
"arrow.get"
] | [((1066, 1087), 'arrow.get', 'arrow.get', (['begin_date'], {}), '(begin_date)\n', (1075, 1087), False, 'import arrow\n'), ((1173, 1192), 'arrow.get', 'arrow.get', (['end_date'], {}), '(end_date)\n', (1182, 1192), False, 'import arrow\n'), ((4222, 4238), 'arrow.get', 'arrow.get', (['start'], {}), '(start)\n', (4231, 423... |
# Copyright 2021 DAI Foundation
#
# 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,... | [
"ethtx_ce.factory.create_app"
] | [((994, 1154), 'ethtx_ce.factory.create_app', 'factory.create_app', (['__name__', '__path__', 'settings_override'], {'extensions': "[mongo_db, (semantics_db, {'db'}), (eth_tx_processor, {'semantics_repository'})\n ]"}), "(__name__, __path__, settings_override, extensions=[\n mongo_db, (semantics_db, {'db'}), (eth... |
from datetime import date, timedelta
import os.path
FILE_PREFIX = 'data/bitstampUSD-'
FILE_SUFFIX = '.json'
def get_avalible_json_files(start_date=date(2010, 1, 1), end_date=date(2050, 12, 31)):
delta = end_date - start_date
filenames = []
for i in range(delta.days + 1):
_date = start_date + time... | [
"datetime.timedelta",
"datetime.date"
] | [((149, 165), 'datetime.date', 'date', (['(2010)', '(1)', '(1)'], {}), '(2010, 1, 1)\n', (153, 165), False, 'from datetime import date, timedelta\n'), ((176, 194), 'datetime.date', 'date', (['(2050)', '(12)', '(31)'], {}), '(2050, 12, 31)\n', (180, 194), False, 'from datetime import date, timedelta\n'), ((1946, 1962), ... |
"""
Module that combines the computation graph functionality of module
lazyflow
with the neural network capabilities of
pylearn2
"""
import logging
logging.basicConfig(level=logging.INFO)
| [
"logging.basicConfig"
] | [((158, 197), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (177, 197), False, 'import logging\n')] |
# -*- coding: utf-8 -*-
"""
Created on Sat Jul 6 15:00:21 2019
@author: agarwal.270a
"""
# Import Libraries
import numpy as np
import matplotlib.pyplot as plt
from scipy import signal as sig
from scipy.signal import windows as win
import pandas as pd
from scipy import io
import pickle
from scipy.stats i... | [
"numpy.random.standard_normal",
"scipy.signal.detrend",
"matplotlib.pyplot.grid",
"scipy.io.savemat",
"numpy.nanpercentile",
"numpy.random.rand",
"scipy.signal.filtfilt",
"scipy.io.loadmat",
"numpy.array",
"numpy.linalg.norm",
"numpy.sin",
"numpy.arange",
"numpy.mean",
"matplotlib.pyplot.p... | [((776, 805), 'numpy.arange', 'np.arange', (['(250)', '(900)', 'len_in_s'], {}), '(250, 900, len_in_s)\n', (785, 805), True, 'import numpy as np\n'), ((1279, 1298), 'numpy.sum', 'np.sum', (['arr'], {'axis': '(0)'}), '(arr, axis=0)\n', (1285, 1298), True, 'import numpy as np\n'), ((1350, 1369), 'numpy.sum', 'np.sum', ([... |
from dataclasses import dataclass
@dataclass(init=True, repr=True, eq=True, frozen=True)
class SearchResult:
details: dict
@classmethod
def parse(cls, title, link):
if not isinstance(title, str) or not isinstance(link, str):
raise TypeError('Link and title should be str type')
... | [
"dataclasses.dataclass"
] | [((37, 90), 'dataclasses.dataclass', 'dataclass', ([], {'init': '(True)', 'repr': '(True)', 'eq': '(True)', 'frozen': '(True)'}), '(init=True, repr=True, eq=True, frozen=True)\n', (46, 90), False, 'from dataclasses import dataclass\n')] |
import numpy as np
import pytest
from sklego.neighbors import BayesianKernelDensityClassifier
from sklego.common import flatten
from sklego.testing import check_shape_remains_same_classifier
from tests.conftest import nonmeta_checks, general_checks, estimator_checks
@pytest.fixture()
def simple_dataset():
# Two... | [
"numpy.random.normal",
"numpy.ones",
"sklego.common.flatten",
"numpy.zeros",
"pytest.fixture",
"sklego.neighbors.BayesianKernelDensityClassifier"
] | [((272, 288), 'pytest.fixture', 'pytest.fixture', ([], {}), '()\n', (286, 288), False, 'import pytest\n'), ((610, 1028), 'sklego.common.flatten', 'flatten', (['[nonmeta_checks, general_checks, estimator_checks.\n check_classifier_data_not_an_array, estimator_checks.\n check_classifiers_one_label, estimator_checks... |
import pathlib
import shutil
import tokenize
import sys
import sysconfig
from typing import Optional, Tuple
from pegen.c_generator import CParserGenerator
from pegen.grammar import Grammar
from pegen.grammar_parser import GeneratedParser as GrammarParser
from pegen.parser import Parser
from pegen.parser_generator imp... | [
"distutils.tests.support.fixup_build_ext",
"distutils.command.clean.clean",
"pegen.grammar_parser.GeneratedParser",
"pathlib.Path",
"distutils.core.Distribution",
"sysconfig.get_config_var",
"pegen.python_generator.PythonParserGenerator",
"tokenize.generate_tokens",
"pegen.c_generator.CParserGenerat... | [((446, 468), 'pathlib.Path', 'pathlib.Path', (['__file__'], {}), '(__file__)\n', (458, 468), False, 'import pathlib\n'), ((553, 593), 'sysconfig.get_config_var', 'sysconfig.get_config_var', (['compiler_flags'], {}), '(compiler_flags)\n', (577, 593), False, 'import sysconfig\n'), ((616, 666), 'sysconfig.get_config_var'... |
from anyway.request_params import RequestParams
from anyway.widgets.widget_utils import get_accidents_stats
from anyway.models import AccidentMarkerView
from anyway.widgets.widget import register
from anyway.widgets.suburban_widgets.sub_urban_widget import SubUrbanWidget
from typing import Dict
from flask_babel i... | [
"flask_babel._",
"anyway.widgets.widget_utils.get_accidents_stats"
] | [((650, 895), 'anyway.widgets.widget_utils.get_accidents_stats', 'get_accidents_stats', ([], {'table_obj': 'AccidentMarkerView', 'filters': 'self.request_params.location_info', 'group_by': '"""road_light_hebrew"""', 'count': '"""road_light_hebrew"""', 'start_time': 'self.request_params.start_time', 'end_time': 'self.re... |
import os
import sys
from pathlib import Path
import pytest
import mxnet as mx
from mxnet.gluon.utils import download
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys.path.insert(1, os.path.dirname(os.path.abspath(__file__)))
EXAMPLE_DIR = Path(__file__).parent.parent / 'docs/example... | [
"cnocr.utils.check_context",
"pathlib.Path",
"mxnet.cpu",
"pytest.mark.skip",
"mxnet.gpu",
"os.path.abspath",
"cnocr.utils.read_img",
"mxnet.gluon.utils.download"
] | [((375, 393), 'pytest.mark.skip', 'pytest.mark.skip', ([], {}), '()\n', (391, 393), False, 'import pytest\n'), ((502, 553), 'mxnet.gluon.utils.download', 'download', (['url', '"""./cnocr-models.zip"""'], {'overwrite': '(True)'}), "(url, './cnocr-models.zip', overwrite=True)\n", (510, 553), False, 'from mxnet.gluon.util... |
from setuptools import setup
import versioneer
with open('requirements.txt', 'rt') as f:
requirements = f.read().splitlines()
setup(
name="psdm_qs_cli",
version=versioneer.get_version(),
cmdclass=versioneer.get_cmdclass(),
description="Python client for interacting with the PCDS questionnaire.",
... | [
"versioneer.get_cmdclass",
"versioneer.get_version"
] | [((176, 200), 'versioneer.get_version', 'versioneer.get_version', ([], {}), '()\n', (198, 200), False, 'import versioneer\n'), ((215, 240), 'versioneer.get_cmdclass', 'versioneer.get_cmdclass', ([], {}), '()\n', (238, 240), False, 'import versioneer\n')] |
import ujson
from pymilvus.grpc_gen import milvus_pb2 as milvus_types
from pymilvus import connections
sys_info_req = ujson.dumps({"metric_type": "system_info"})
sys_statistics_req = ujson.dumps({"metric_type": "system_statistics"})
sys_logs_req = ujson.dumps({"metric_type": "system_logs"})
class MilvusSys:
def ... | [
"ujson.dumps",
"pymilvus.connections.get_connection",
"pymilvus.grpc_gen.milvus_pb2.GetMetricsRequest"
] | [((119, 162), 'ujson.dumps', 'ujson.dumps', (["{'metric_type': 'system_info'}"], {}), "({'metric_type': 'system_info'})\n", (130, 162), False, 'import ujson\n'), ((184, 233), 'ujson.dumps', 'ujson.dumps', (["{'metric_type': 'system_statistics'}"], {}), "({'metric_type': 'system_statistics'})\n", (195, 233), False, 'imp... |
# Licensed to Modin Development Team under one or more contributor license agreements.
# See the NOTICE file distributed with this work for additional information regarding
# copyright ownership. The Modin Development Team licenses this file to you under the
# Apache License, Version 2.0 (the "License"); you may not u... | [
"pyarrow.Table.from_pandas"
] | [((2289, 2319), 'pyarrow.Table.from_pandas', 'pyarrow.Table.from_pandas', (['obj'], {}), '(obj)\n', (2314, 2319), False, 'import pyarrow\n')] |
# -*- coding: utf-8 -*-
# ---
# jupyter:
# jupytext:
# formats: ipynb,py:light
# text_representation:
# extension: .py
# format_name: light
# format_version: '1.3'
# jupytext_version: 1.0.5
# kernelspec:
# display_name: altmetrics
# language: python
# name: altmetrics
# -... | [
"pandas.DataFrame",
"pandas.read_csv"
] | [((1186, 1265), 'pandas.read_csv', 'pd.read_csv', (['in_articles_csv'], {'index_col': '"""doi"""', 'parse_dates': "['publication_date']"}), "(in_articles_csv, index_col='doi', parse_dates=['publication_date'])\n", (1197, 1265), True, 'import pandas as pd\n'), ((1549, 1673), 'pandas.read_csv', 'pd.read_csv', (['details_... |
import d20, re, json
import pickle
import os.path
from api.open5e import get5e_direct, get5e, get_creatures, get_section
from api.api_utils import *
from api.character_models import *
from api.pycritter import *
from api.images import *
from _runtime import server, CONFIG
import logging
logger = logging.getLogger("uvic... | [
"logging.getLogger",
"d20.roll"
] | [((297, 331), 'logging.getLogger', 'logging.getLogger', (['"""uvicorn.error"""'], {}), "('uvicorn.error')\n", (314, 331), False, 'import logging\n'), ((2198, 2217), 'd20.roll', 'd20.roll', (['roll_args'], {}), '(roll_args)\n', (2206, 2217), False, 'import d20, re, json\n')] |
from flask import request
import json
from Aula55.controller.base_controller import BaseController
from Aula55.dao.pessoa_dao import PessoaDao
from Aula55.model.pessoa import Pessoa
class PessoaController(BaseController):
def __init__(self):
super().__init__(PessoaDao())
def post(self):
return... | [
"Aula55.dao.pessoa_dao.PessoaDao",
"Aula55.model.pessoa.Pessoa"
] | [((534, 542), 'Aula55.model.pessoa.Pessoa', 'Pessoa', ([], {}), '()\n', (540, 542), False, 'from Aula55.model.pessoa import Pessoa\n'), ((272, 283), 'Aula55.dao.pessoa_dao.PessoaDao', 'PessoaDao', ([], {}), '()\n', (281, 283), False, 'from Aula55.dao.pessoa_dao import PessoaDao\n')] |
# Generated by Django 2.1.2 on 2018-10-25 14:06
import django.db.models.deletion
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('sunless_web', '0059_auto_20181025_2303'),
]
operations = [
migrations.AlterField(
model_name='di... | [
"django.db.models.ForeignKey"
] | [((379, 510), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'null': '(True)', 'on_delete': 'django.db.models.deletion.CASCADE', 'related_name': '"""discuss"""', 'to': '"""sunless_web.Translation"""'}), "(null=True, on_delete=django.db.models.deletion.CASCADE,\n related_name='discuss', to='sunless_web.Tra... |
#!/usr/bin/env python
# Authors: <NAME>,
# Since: 02/10/2020
# Project: RIT MSD P20250 Finger Lakes ROV Exploration
# filename: flask_node.py
# import required libraries
import rospy
import time
import threading
from std_msgs.msg import Float32MultiArray
from std_msgs.msg import Int8
from flask import Flask
from flas... | [
"flask_cors.CORS",
"flask.Flask",
"rospy.init_node",
"rospy.get_time",
"rospy.Subscriber"
] | [((346, 361), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (351, 361), False, 'from flask import Flask\n'), ((362, 371), 'flask_cors.CORS', 'CORS', (['app'], {}), '(app)\n', (366, 371), False, 'from flask_cors import CORS\n'), ((1364, 1380), 'rospy.get_time', 'rospy.get_time', ([], {}), '()\n', (1378, 13... |
from itertools import cycle
from toolz.itertoolz import concatv, take
import numpy as np
import pytest
from tensorforce.environments import Environment
from bad_seeds.simple.bad_seeds_01 import BadSeeds01, count_measurements
def test_initialization():
bad_seeds_01_env = Environment.create(
environment=B... | [
"bad_seeds.simple.bad_seeds_01.count_measurements",
"tensorforce.environments.Environment.create",
"itertools.cycle",
"numpy.array",
"pytest.raises",
"bad_seeds.simple.bad_seeds_01.BadSeeds01"
] | [((279, 382), 'tensorforce.environments.Environment.create', 'Environment.create', ([], {'environment': 'BadSeeds01', 'seed_count': '(10)', 'bad_seed_count': '(3)', 'max_episode_length': '(100)'}), '(environment=BadSeeds01, seed_count=10, bad_seed_count=3,\n max_episode_length=100)\n', (297, 382), False, 'from tenso... |
# -*- coding: utf-8 -*-
# Generated by Django 1.11.7 on 2017-12-02 19:57
from __future__ import unicode_literals
from django.db import migrations, models
import geoposition.fields
class Migration(migrations.Migration):
dependencies = [
('driver', '0001_initial'),
]
operations = [
migrat... | [
"django.db.models.AutoField",
"django.db.models.CharField"
] | [((408, 501), '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", (424, 501), False, 'from django.db import migrations, models\... |
from pathlib import Path
import numpy as np
import torch
import subprocess
import argparse
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument("source_file", help="Absolute path to the Pytorch weights file to convert")
args = parser.parse_args()
source_file = Path(args.so... | [
"numpy.savez",
"subprocess.run",
"argparse.ArgumentParser",
"pathlib.Path"
] | [((132, 157), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (155, 157), False, 'import argparse\n'), ((308, 330), 'pathlib.Path', 'Path', (['args.source_file'], {}), '(args.source_file)\n', (312, 330), False, 'from pathlib import Path\n'), ((606, 650), 'numpy.savez', 'np.savez', (["(target_fol... |
import datetime
from ..dojo_test_case import DojoTestCase
from dojo.models import Test
from dojo.tools.acunetix.parser import AcunetixParser
class TestAcunetixParser(DojoTestCase):
def test_parse_file_with_one_finding(self):
testfile = open("unittests/scans/acunetix/one_finding.xml")
parser = Ac... | [
"dojo.tools.acunetix.parser.AcunetixParser",
"dojo.models.Test",
"datetime.date"
] | [((318, 334), 'dojo.tools.acunetix.parser.AcunetixParser', 'AcunetixParser', ([], {}), '()\n', (332, 334), False, 'from dojo.tools.acunetix.parser import AcunetixParser\n'), ((1711, 1727), 'dojo.tools.acunetix.parser.AcunetixParser', 'AcunetixParser', ([], {}), '()\n', (1725, 1727), False, 'from dojo.tools.acunetix.par... |
# -*- coding: utf-8 -*-
# *****************************************************************************
# Copyright (c) 2016-2020, Intel Corporation
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:... | [
"pathlib.Path",
"dpctl.get_include",
"os.path.join",
"os.environ.get",
"multiprocessing.cpu_count",
"distutils.log.info",
"os.path.dirname",
"os.path.abspath"
] | [((2654, 2703), 'os.environ.get', 'os.environ.get', (['"""DPNP_BACKEND_TESTS_ENABLE"""', 'None'], {}), "('DPNP_BACKEND_TESTS_ENABLE', None)\n", (2668, 2703), False, 'import os\n'), ((2911, 2956), 'distutils.log.info', 'log.info', (['f"""Project directory is: {root_dir}"""'], {}), "(f'Project directory is: {root_dir}')\... |
import struct
from pws.hash.abstracthash import Hash
class SHA1(Hash):
@staticmethod
def pad(data: bytes) -> bytes:
# Padding routine as follows
# Start by appending a `1` bit to the message
# Proceed by appending `0` bits to the message until the length in bits is congruent... | [
"struct.unpack",
"struct.pack"
] | [((914, 943), 'struct.pack', 'struct.pack', (['""">Q"""', 'bit_length'], {}), "('>Q', bit_length)\n", (925, 943), False, 'import struct\n'), ((1802, 1851), 'struct.unpack', 'struct.unpack', (['""">I"""', 'block[4 * idx:4 * (idx + 1)]'], {}), "('>I', block[4 * idx:4 * (idx + 1)])\n", (1815, 1851), False, 'import struct\... |
from __future__ import print_function
from awsglue.context import GlueContext
from glue_migrator.utils.helpers import get_options
from glue_migrator.services.spark_service import SparkService
from glue_migrator.migrators.jdbc_exporter import JdbcExporter
from glue_migrator.schemas.datacatalog import DataCatalogSchemas... | [
"argparse.ArgumentParser",
"glue_migrator.utils.logger.Logger",
"glue_migrator.migrators.jdbc_exporter.JdbcExporter",
"glue_migrator.utils.helpers.get_options",
"glue_migrator.services.spark_service.SparkService",
"awsglue.context.GlueContext"
] | [((404, 412), 'glue_migrator.utils.logger.Logger', 'Logger', ([], {}), '()\n', (410, 412), False, 'from glue_migrator.utils.logger import Logger\n'), ((1417, 1458), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'prog': 'sys.argv[0]'}), '(prog=sys.argv[0])\n', (1440, 1458), False, 'import argparse\n'), ((2... |
from django.core.management.base import BaseCommand
from googleapiclient.discovery import build
from dotenv import load_dotenv
import os
import pandas as pd
import json
from songs.models import NewVideo, NewVideoStats
load_dotenv()
def html_reverse_escape(string):
'''Reverse escapes HTML code in string into AS... | [
"os.getenv",
"dotenv.load_dotenv",
"songs.models.NewVideoStats",
"googleapiclient.discovery.build",
"songs.models.NewVideo.objects.all"
] | [((222, 235), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (233, 235), False, 'from dotenv import load_dotenv\n'), ((788, 814), 'os.getenv', 'os.getenv', (['"""DEVELOPER_KEY"""'], {}), "('DEVELOPER_KEY')\n", (797, 814), False, 'import os\n'), ((830, 894), 'googleapiclient.discovery.build', 'build', (['api_ser... |
#! /usr/bin/python
import serial, time
import subprocess
from subprocess import call, Popen
from argparse import ArgumentParser
import re
import unittest
import os
def do_test(port, baudrate, test_name):
databits = serial.EIGHTBITS
stopbits = serial.STOPBITS_ONE
parity = serial.PARITY_NONE
ser = seria... | [
"argparse.ArgumentParser",
"time.sleep",
"serial.Serial",
"unittest.main",
"time.time"
] | [((315, 384), 'serial.Serial', 'serial.Serial', (['port', 'baudrate', 'databits', 'parity', 'stopbits'], {'timeout': '(10)'}), '(port, baudrate, databits, parity, stopbits, timeout=10)\n', (328, 384), False, 'import serial, time\n'), ((479, 490), 'time.time', 'time.time', ([], {}), '()\n', (488, 490), False, 'import se... |
# -*- coding: utf-8 -*-
"""
Created on Sun Apr 2 17:03:04 2017
@author: Villanueva
"""
import warnings
import pytest
from simetuc.util import IonType, Transition, DecayTransition, Excitation, EneryTransferProcess
from simetuc.util import log_exceptions_warnings
def test_transition():
'''Test generic transitio... | [
"simetuc.util.EneryTransferProcess",
"warnings.catch_warnings",
"simetuc.util.Excitation",
"pytest.raises",
"simetuc.util.DecayTransition",
"simetuc.util.Transition",
"warnings.filterwarnings"
] | [((388, 415), 'simetuc.util.Transition', 'Transition', (['IonType.S', '(1)', '(0)'], {}), '(IonType.S, 1, 0)\n', (398, 415), False, 'from simetuc.util import IonType, Transition, DecayTransition, Excitation, EneryTransferProcess\n'), ((425, 496), 'simetuc.util.Transition', 'Transition', (['IonType.S', '(1)', '(0)'], {'... |
from backend.communications import send_email
from backend.communications import send_sms
from unittest import TestCase
from unittest.mock import MagicMock
class TestSendEmail(TestCase):
def _call(self, *args, **kw):
return send_email(*args, **kw)
def test_no_api_key(self):
request = MagicMo... | [
"backend.communications.send_email",
"unittest.mock.MagicMock",
"backend.communications.send_sms"
] | [((239, 262), 'backend.communications.send_email', 'send_email', (['*args'], {}), '(*args, **kw)\n', (249, 262), False, 'from backend.communications import send_email\n'), ((313, 324), 'unittest.mock.MagicMock', 'MagicMock', ([], {}), '()\n', (322, 324), False, 'from unittest.mock import MagicMock\n'), ((582, 603), 'ba... |
# Generated by Django 3.2 on 2021-07-24 03:08
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('trunk', '0002_eyekey_trunk'),
]
operations = [
migrations.AlterOrderWithRespectTo(
name='eyekey',
order_with_respect_to='trunk... | [
"django.db.migrations.AlterOrderWithRespectTo"
] | [((217, 302), 'django.db.migrations.AlterOrderWithRespectTo', 'migrations.AlterOrderWithRespectTo', ([], {'name': '"""eyekey"""', 'order_with_respect_to': '"""trunk"""'}), "(name='eyekey', order_with_respect_to='trunk'\n )\n", (251, 302), False, 'from django.db import migrations\n')] |
import pymysql
import sys
import zlib
import json
from time import sleep
from kafka import KafkaConsumer, KafkaProducer, TopicPartition
import ast
from threading import Thread
import threading
import wget
import subprocess
import csv
import os
import shutil
import pandas as pd
import time
from bson import json_util
... | [
"wget.download",
"os.listdir",
"pandas.read_csv",
"csv.writer",
"pymysql.connect",
"shutil.rmtree",
"os.path.isfile",
"sys.exc_info",
"os.path.isdir",
"subprocess.call",
"os.mkdir",
"zlib.crc32",
"threading.Thread",
"time.time"
] | [((1649, 1693), 'subprocess.call', 'subprocess.call', (['command_extract'], {'shell': '(True)'}), '(command_extract, shell=True)\n', (1664, 1693), False, 'import subprocess\n'), ((1992, 2038), 'subprocess.call', 'subprocess.call', (['command_inference'], {'shell': '(True)'}), '(command_inference, shell=True)\n', (2007,... |
import pygame
from pygame.draw import *
import math
width = 400
height = 400
r = 180
factor = 2
n = 100
i = 0
pygame.init()
screen = pygame.display.set_mode((width, height))
clock = pygame.time.Clock()
black = (0, 0, 0)
pink = (255, 0, 208)
white = (255,255,255)
screen.fill(black)
FPS = 15
def draw():
global i
... | [
"pygame.init",
"pygame.quit",
"pygame.event.get",
"pygame.display.set_mode",
"pygame.display.flip",
"math.cos",
"pygame.time.Clock",
"math.sin"
] | [((112, 125), 'pygame.init', 'pygame.init', ([], {}), '()\n', (123, 125), False, 'import pygame\n'), ((135, 175), 'pygame.display.set_mode', 'pygame.display.set_mode', (['(width, height)'], {}), '((width, height))\n', (158, 175), False, 'import pygame\n'), ((184, 203), 'pygame.time.Clock', 'pygame.time.Clock', ([], {})... |
from rh_nexttask.query import Query
from rh_nexttask.querycollector import QueryCollector
def test_creation():
queries = QueryCollector()
assert isinstance(queries, QueryCollector)
def test_from_file():
queries = QueryCollector.from_file('/home/user/Src/sathlan/python-rh-nexttask/tests/fixtures/filter.ini... | [
"rh_nexttask.querycollector.QueryCollector.from_file",
"rh_nexttask.querycollector.QueryCollector"
] | [((126, 142), 'rh_nexttask.querycollector.QueryCollector', 'QueryCollector', ([], {}), '()\n', (140, 142), False, 'from rh_nexttask.querycollector import QueryCollector\n'), ((227, 327), 'rh_nexttask.querycollector.QueryCollector.from_file', 'QueryCollector.from_file', (['"""/home/user/Src/sathlan/python-rh-nexttask/te... |
#!/usr/bin/env python3
"""
New cartopy projection classes.
"""
import warnings
from .internals import ic # noqa: F401
from .internals import docstring
try:
from cartopy.crs import _WarpedRectangularProjection
from cartopy.crs import AzimuthalEquidistant, Gnomonic, LambertAzimuthalEqualArea
from cartopy.c... | [
"warnings.warn",
"cartopy._crs.Globe"
] | [((1929, 1985), 'cartopy._crs.Globe', 'Globe', ([], {'semimajor_axis': 'WGS84_SEMIMAJOR_AXIS', 'ellipse': 'None'}), '(semimajor_axis=WGS84_SEMIMAJOR_AXIS, ellipse=None)\n', (1934, 1985), False, 'from cartopy._crs import Globe\n'), ((2142, 2228), 'warnings.warn', 'warnings.warn', (['f"""The {self.name!r} projection does... |
from typing import Any
from ray import workflow
from ray.experimental.dag import DAGNode, FunctionNode, InputNode
from ray.experimental.dag.input_node import InputAtrributeNode, DAGInputData
def transform_ray_dag_to_workflow(dag_node: DAGNode, input_context: DAGInputData):
"""
Transform a Ray DAG to a workf... | [
"ray.workflow.step"
] | [((803, 828), 'ray.workflow.step', 'workflow.step', (['node._body'], {}), '(node._body)\n', (816, 828), False, 'from ray import workflow\n')] |
import os
class RenderHTML:
def __init__(self, file):
self._file = file
if not os.path.exists(self._file):
raise FileNotFoundError(f"No such HTML file: {self._file}")
with open(file, 'r') as f:
self._html = f.read()
def __repr__(self):
return "<%s... | [
"os.path.exists"
] | [((102, 128), 'os.path.exists', 'os.path.exists', (['self._file'], {}), '(self._file)\n', (116, 128), False, 'import os\n')] |
import unittest
from user import User
import pyperclip
class testUser(unittest.TestCase):
'''
Test class that defines test cases for the user class behaviours.
Args:
unittest.TestCase: TestCase class that helps in creating test cases
'''
def setUp(self):
"""
Method to ru... | [
"unittest.main",
"user.User.find_by_username",
"user.User.display_userInfo",
"user.User",
"user.User.find_by_userpassword"
] | [((3096, 3111), 'unittest.main', 'unittest.main', ([], {}), '()\n', (3109, 3111), False, 'import unittest\n'), ((389, 450), 'user.User', 'User', (['"""Maranatha"""', '"""uwase"""', '"""Marah-uwase"""', '"""marahuwase@31998"""'], {}), "('Maranatha', 'uwase', 'Marah-uwase', 'marahuwase@31998')\n", (393, 450), False, 'fro... |
# Despy: A discrete event simulation framework for Python
# Version 0.1
# Released under the MIT License (MIT)
# Copyright (c) 2015, <NAME>
"""Despy model for the Abel-Baker problem, example 2.2.
From 'Discrete Event System Simulation, 4th ed.; Banks, Carson, Nelson,
and Nicole
"""
import despy as dp
class ... | [
"despy.model.Entity.set_counter",
"despy.model.ResourceQueue",
"despy.model.Resource",
"despy.model.Entity",
"despy.stats_random.get_empirical_pmf"
] | [((556, 664), 'despy.stats_random.get_empirical_pmf', 'dp.stats_random.get_empirical_pmf', (['[1, 2, 3, 4]', '[0.25, 0.4, 0.2, 0.15]', '"""Customer Arrival Distribution"""'], {}), "([1, 2, 3, 4], [0.25, 0.4, 0.2, 0.15],\n 'Customer Arrival Distribution')\n", (589, 664), True, 'import despy as dp\n'), ((1062, 1167), ... |
import rclpy
from rclpy.node import Node
from std_msgs.msg import String
class MinimalPublisher(Node):
def __init__(self):
super().__init__('minimal_publisher')
self.publisher_ = self.create_publisher(String, 'topic', 10)
timer_period = 0.5 # seconds
self.timer = self.create_tim... | [
"std_msgs.msg.String",
"rclpy.init",
"rclpy.shutdown",
"rclpy.spin"
] | [((623, 644), 'rclpy.init', 'rclpy.init', ([], {'args': 'args'}), '(args=args)\n', (633, 644), False, 'import rclpy\n'), ((694, 723), 'rclpy.spin', 'rclpy.spin', (['minimal_publisher'], {}), '(minimal_publisher)\n', (704, 723), False, 'import rclpy\n'), ((917, 933), 'rclpy.shutdown', 'rclpy.shutdown', ([], {}), '()\n',... |
from pypy.interpreter import baseobjspace
from pypy.interpreter.error import OperationError
from rpython.tool.error import offset2lineno
class PyTraceback(baseobjspace.W_Root):
"""Traceback object
Public app-level fields:
* 'tb_frame'
* 'tb_lasti'
* 'tb_lineno'
* 'tb_next'
"""
d... | [
"rpython.tool.error.offset2lineno"
] | [((514, 558), 'rpython.tool.error.offset2lineno', 'offset2lineno', (['self.frame.pycode', 'self.lasti'], {}), '(self.frame.pycode, self.lasti)\n', (527, 558), False, 'from rpython.tool.error import offset2lineno\n')] |
# Generated by Django 2.0.5 on 2018-05-22 14:36
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('home', '0009_auto_20180522_1409'),
]
operations = [
migrations.AlterModelOptions(
name='contactnumbers',
options={'verbose_n... | [
"django.db.migrations.AlterModelOptions"
] | [((224, 331), 'django.db.migrations.AlterModelOptions', 'migrations.AlterModelOptions', ([], {'name': '"""contactnumbers"""', 'options': "{'verbose_name_plural': 'Contact Points'}"}), "(name='contactnumbers', options={\n 'verbose_name_plural': 'Contact Points'})\n", (252, 331), False, 'from django.db import migratio... |
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not u... | [
"tvm.autotvm.ConfigEntity",
"tvm.target.override_native_generic_func",
"tvm.relay.tile",
"tvm.relay.backend.te_compiler.get",
"tvm.relay.Tuple",
"tvm.autotvm.apply_history_best",
"tvm.relay.subtract",
"tvm.autotvm.MeasureInput",
"tvm.relay.analysis.free_vars",
"tvm.testing.device_enabled",
"tvm.... | [((1064, 1110), 'tvm.autotvm.register_topi_compute', 'autotvm.register_topi_compute', (['"""test/conv2d_1"""'], {}), "('test/conv2d_1')\n", (1093, 1110), False, 'from tvm import autotvm\n'), ((1281, 1328), 'tvm.autotvm.register_topi_schedule', 'autotvm.register_topi_schedule', (['"""test/conv2d_1"""'], {}), "('test/con... |
from types import SimpleNamespace
from src.data import DATA_DIR
from src.utils.io import read_file
from src.utils.keyboard import create_keyboard
keys = SimpleNamespace(
settings=':gear: Settings',
cancel=':cross_mark: Cancel',
back=':BACK_arrow: Back',
next=':arrow_right: Next',
add=':heavy_plus_... | [
"src.utils.io.read_file",
"src.utils.keyboard.create_keyboard",
"types.SimpleNamespace"
] | [((155, 884), 'types.SimpleNamespace', 'SimpleNamespace', ([], {'settings': '""":gear: Settings"""', 'cancel': '""":cross_mark: Cancel"""', 'back': '""":BACK_arrow: Back"""', 'next': '""":arrow_right: Next"""', 'add': '""":heavy_plus_sign: Add"""', 'save': '""":check_mark_button: Save"""', 'yes': '""":white_check_mark:... |
from __future__ import print_function
import os
import cv2
import string
import random
import numpy as np
class dataLoader(object):
def __init__(self, directory, dataset_dir, dataset_name, max_steps,
image_width, image_height, image_patch_width, image_patch_height,
grd_attn=False,... | [
"numpy.ceil",
"random.shuffle",
"numpy.random.rand",
"os.path.join",
"numpy.floor",
"numpy.array",
"numpy.zeros",
"cv2.resize",
"cv2.imread"
] | [((874, 921), 'os.path.join', 'os.path.join', (['self.directory', 'self.dataset_name'], {}), '(self.directory, self.dataset_name)\n', (886, 921), False, 'import os\n'), ((2289, 2305), 'numpy.random.rand', 'np.random.rand', ([], {}), '()\n', (2303, 2305), True, 'import numpy as np\n'), ((2561, 2584), 'random.shuffle', '... |
import string
import random
import numpy as np
import os
import pdb
class PsudoSeqdb:
''' we create a psudo seq detabase. '''
def __init__( self, dbSize, actionCount, maxSeqSize, equalSize = False ):
self.dbSize = dbSize ;
self.actionCount = actionCount
self.maxSeqSize = maxSeqSize
self.seqs = list()
... | [
"os.path.abspath",
"os.path.join",
"random.randint"
] | [((4709, 4772), 'os.path.join', 'os.path.join', (['parentdir', '"""data/test_action_20_maxSeq15_10K.txt"""'], {}), "(parentdir, 'data/test_action_20_maxSeq15_10K.txt')\n", (4721, 4772), False, 'import os\n'), ((4664, 4689), 'os.path.abspath', 'os.path.abspath', (['__file__'], {}), '(__file__)\n', (4679, 4689), False, '... |
from compas_fab.backends import RosClient
from helpers import show_trajectory
from compas.geometry import Frame
with RosClient("localhost") as client:
robot = client.load_robot()
group = robot.main_group_name
frames = []
frames.append(Frame((0.3, 0.1, 0.05), (-1, 0, 0), (0, 1, 0)))
frames.append(... | [
"helpers.show_trajectory",
"compas.geometry.Frame",
"compas_fab.backends.RosClient"
] | [((119, 141), 'compas_fab.backends.RosClient', 'RosClient', (['"""localhost"""'], {}), "('localhost')\n", (128, 141), False, 'from compas_fab.backends import RosClient\n'), ((1212, 1239), 'helpers.show_trajectory', 'show_trajectory', (['trajectory'], {}), '(trajectory)\n', (1227, 1239), False, 'from helpers import show... |
# -*- coding: utf-8 -*-
import codecs
from collections import Counter, defaultdict
from itertools import chain, count
import torch
import torchtext.data
import torchtext.vocab
PAD_WORD = '<blank>'
UNK = 0
BOS_WORD = '<s>'
EOS_WORD = '</s>'
def __getstate__(self):
return dict(self.__dict__, stoi=dict(self.stoi)... | [
"itertools.chain",
"torch.LongTensor",
"collections.Counter",
"itertools.count",
"collections.defaultdict",
"codecs.open"
] | [((403, 437), 'collections.defaultdict', 'defaultdict', (['(lambda : 0)', 'self.stoi'], {}), '(lambda : 0, self.stoi)\n', (414, 437), False, 'from collections import Counter, defaultdict\n'), ((1532, 1573), 'itertools.chain', 'chain', (['*[vocab.freqs for vocab in vocabs]'], {}), '(*[vocab.freqs for vocab in vocabs])\n... |
# Creation of a Sentinel-2 Canadian Dataset
"""
# Note: before running this code, create a new conda env named : gee
conda install -c anaconda pandas
conda install -c anaconda pillow
conda install -c conda-forge matplotlib
# Then, authenticate yourself to Google Eeath Engine
earthengine authenticate
... | [
"matplotlib.pyplot.tight_layout",
"pandas.read_csv",
"matplotlib.pyplot.show"
] | [((655, 704), 'pandas.read_csv', 'pd.read_csv', (['"""points_ALL_categories_2018_ACI.csv"""'], {}), "('points_ALL_categories_2018_ACI.csv')\n", (666, 704), True, 'import pandas as pd\n'), ((2317, 2335), 'matplotlib.pyplot.tight_layout', 'plt.tight_layout', ([], {}), '()\n', (2333, 2335), True, 'from matplotlib import p... |
from django.urls import path, include
from rest_framework.urlpatterns import format_suffix_patterns
from internal_api import views
urlpatterns = [
path('calculateTMC/', views.CalculateTMCForCredit.as_view()),
]
urlpatterns = format_suffix_patterns(urlpatterns)
| [
"internal_api.views.CalculateTMCForCredit.as_view",
"rest_framework.urlpatterns.format_suffix_patterns"
] | [((231, 266), 'rest_framework.urlpatterns.format_suffix_patterns', 'format_suffix_patterns', (['urlpatterns'], {}), '(urlpatterns)\n', (253, 266), False, 'from rest_framework.urlpatterns import format_suffix_patterns\n'), ((174, 211), 'internal_api.views.CalculateTMCForCredit.as_view', 'views.CalculateTMCForCredit.as_v... |
import datetime
from subprocess import CalledProcessError # nosec
from threading import Thread
from typing import Dict, List, Optional, Set
import boto3
import click
import pytz
import semver
from botocore.config import Config
from botocore.exceptions import ClientError
from colored import attr, fg
from opta.amplitu... | [
"opta.core.plan_displayer.PlanDisplayer.display",
"opta.constants.VERSION.strip",
"opta.commands.local_flag._handle_local_flag",
"opta.utils.logger.info",
"opta.core.terraform.Terraform.create_state_storage",
"opta.core.terraform.Terraform.tf_lock_details",
"opta.core.azure.Azure",
"opta.exceptions.Us... | [((1424, 1439), 'click.command', 'click.command', ([], {}), '()\n', (1437, 1439), False, 'import click\n'), ((1441, 1540), 'click.option', 'click.option', (['"""-c"""', '"""--config"""'], {'default': '"""opta.yaml"""', 'help': '"""Opta config file"""', 'show_default': '(True)'}), "('-c', '--config', default='opta.yaml'... |
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from kneed import KneeLocator
from jupyter_utils import AllDataset
data_dir = '../drp-data/'
GDSC_GENE_EXPRESSION = 'preprocessed/gdsc_tcga/gdsc_rma_gene_expr.csv'
TCGA_GENE_EXPRESSION = 'preprocessed/gdsc_tcga/tcga_log2_gene_expr.csv'
TCGA_CANCER... | [
"pandas.DataFrame",
"pandas.ExcelWriter",
"pandas.read_csv"
] | [((573, 621), 'pandas.read_csv', 'pd.read_csv', (['(data_dir + GDSC_lnIC50)'], {'index_col': '(0)'}), '(data_dir + GDSC_lnIC50, index_col=0)\n', (584, 621), True, 'import pandas as pd\n'), ((632, 676), 'pandas.read_csv', 'pd.read_csv', (['(data_dir + TCGA_DR)'], {'index_col': '(0)'}), '(data_dir + TCGA_DR, index_col=0)... |
import cv2
import numpy as np
import random
#########################################################
# FUNCTION TO FIND THE CONNECTED COMPONENTS
#########################################################
def drawComponents(image, adj, block_size):
#ret, labels = cv2.connectedComponents(image)
#pri... | [
"numpy.ones_like",
"cv2.merge",
"cv2.threshold",
"cv2.imshow",
"numpy.max",
"numpy.zeros",
"cv2.waitKey",
"cv2.destroyAllWindows",
"cv2.connectedComponents",
"cv2.cvtColor",
"cv2.imread",
"random.randint"
] | [((3501, 3533), 'cv2.imread', 'cv2.imread', (['"""../../Images/2.jpg"""'], {}), "('../../Images/2.jpg')\n", (3511, 3533), False, 'import cv2\n'), ((3535, 3567), 'cv2.imshow', 'cv2.imshow', (['"""Original"""', 'img_orig'], {}), "('Original', img_orig)\n", (3545, 3567), False, 'import cv2\n'), ((3657, 3699), 'cv2.cvtColo... |
import csv
import string
from nltk.corpus import stopwords
import gensim
MIN_COUNT = 10
BIGRAM = False
TRIGRAM = False
DATA_PATH = 'data/all_text_clean.csv'
DICT_PATH = 'data/dict_{}mn'.format(MIN_COUNT)
import logging
logging.basicConfig(filename='data/logs/dict_{}mn.log'.format(MIN_COUNT), format='%(asctime)s : %... | [
"csv.reader",
"gensim.corpora.Dictionary"
] | [((1203, 1238), 'gensim.corpora.Dictionary', 'gensim.corpora.Dictionary', (['comments'], {}), '(comments)\n', (1228, 1238), False, 'import gensim\n'), ((584, 613), 'csv.reader', 'csv.reader', (['f'], {'delimiter': '"""\t"""'}), "(f, delimiter='\\t')\n", (594, 613), False, 'import csv\n')] |
import string
from dagster import (
InputDefinition,
Int,
OutputDefinition,
PartitionSetDefinition,
ScheduleDefinition,
lambda_solid,
pipeline,
repository,
solid,
usable_as_dagster_type,
)
@lambda_solid
def do_something():
return 1
@lambda_solid
def do_input(x):
retu... | [
"dagster.ScheduleDefinition",
"dagster.usable_as_dagster_type",
"dagster.InputDefinition",
"dagster.OutputDefinition",
"dagster.pipeline",
"dagster.PartitionSetDefinition"
] | [((328, 348), 'dagster.pipeline', 'pipeline', ([], {'name': '"""foo"""'}), "(name='foo')\n", (336, 348), False, 'from dagster import InputDefinition, Int, OutputDefinition, PartitionSetDefinition, ScheduleDefinition, lambda_solid, pipeline, repository, solid, usable_as_dagster_type\n'), ((401, 449), 'dagster.pipeline',... |
#!/usr/bin/python3
"""
module for use with getting captcha data.
customize learner for use with different captchas.
"""
import pytesseract
import cv2
from captcha_test import CaptchaTest
from test_alias import TestAlias
class CaptchaLearner():
"""CaptchaLearner class. create one and use over course of ->
... | [
"test_alias.TestAlias",
"cv2.threshold",
"cv2.medianBlur",
"captcha_test.CaptchaTest",
"pytesseract.image_to_string",
"cv2.imread"
] | [((1913, 1944), 'cv2.imread', 'cv2.imread', (['self.temp_file_name'], {}), '(self.temp_file_name)\n', (1923, 1944), False, 'import cv2\n'), ((1959, 1996), 'cv2.medianBlur', 'cv2.medianBlur', (['img', 'test.blur_factor'], {}), '(img, test.blur_factor)\n', (1973, 1996), False, 'import cv2\n'), ((2005, 2065), 'cv2.thresho... |
import pandas as pd
import matplotlib as mpl
import matplotlib.pyplot as plt
import datetime
import seaborn as sns
from matplotlib.colors import ListedColormap
import numpy as np
df = pd.read_excel('data/R1_5_results_only.xlsx')
rc = {'figure.figsize': (10, 5),
'axes.facecolor': 'white',
'axes.grid': True... | [
"matplotlib.pyplot.savefig",
"seaborn.despine",
"seaborn.color_palette",
"seaborn.stripplot",
"matplotlib.pyplot.rcParams.update",
"pandas.read_excel",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.subplots_adjust",
"matplotlib.pyplot.show"
] | [((185, 229), 'pandas.read_excel', 'pd.read_excel', (['"""data/R1_5_results_only.xlsx"""'], {}), "('data/R1_5_results_only.xlsx')\n", (198, 229), True, 'import pandas as pd\n'), ((409, 432), 'matplotlib.pyplot.rcParams.update', 'plt.rcParams.update', (['rc'], {}), '(rc)\n', (428, 432), True, 'import matplotlib.pyplot a... |
import json
from typing import Dict, Sequence, List, Tuple, Union
from django import forms
from django.conf import settings
from django.contrib.postgres.forms import SimpleArrayField
from utilities.choices import ColorChoices
from .utils import add_blank_choice, parse_numeric_range
__all__ = (
'APISelect',
'... | [
"json.dumps"
] | [((7830, 7884), 'json.dumps', 'json.dumps', (['[*current, *params]'], {'separators': "(',', ':')"}), "([*current, *params], separators=(',', ':'))\n", (7840, 7884), False, 'import json\n')] |
# Generated by Django 2.0.3 on 2018-04-09 20:51
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('entrance', '0071_auto_20180409_2042'),
]
operations = [
migrations.AddField(
model_name='selectenrollmenttypeentrancestep',
... | [
"django.db.models.TextField"
] | [((366, 491), 'django.db.models.TextField', 'models.TextField', ([], {'blank': '(True)', 'default': '""""""', 'help_text': '"""Поддерживается Markdown"""', 'verbose_name': '"""информация для модераторов"""'}), "(blank=True, default='', help_text=\n 'Поддерживается Markdown', verbose_name='информация для модераторов'... |
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not u... | [
"ocw.data_source.esgf.load_dataset",
"getpass.getpass"
] | [((1756, 1801), 'getpass.getpass', 'getpass', ([], {'prompt': '"""Enter your ESGF Password:\n"""'}), "(prompt='Enter your ESGF Password:\\n')\n", (1763, 1801), False, 'from getpass import getpass\n'), ((1923, 1982), 'ocw.data_source.esgf.load_dataset', 'esgf.load_dataset', (['dataset_id', 'variable', 'username', 'passw... |
# Copyright 2021 JD.com, Inc., JD AI
"""
@author: <NAME>
@contact: <EMAIL>
"""
from xmodaler.utils.registry import Registry
ENGINE_REGISTRY = Registry("ENGINE")
ENGINE_REGISTRY.__doc__ = """
Registry for engine
"""
def build_engine(cfg):
engine = ENGINE_REGISTRY.get(cfg.ENGINE.NAME)(cfg)
return engine | [
"xmodaler.utils.registry.Registry"
] | [((143, 161), 'xmodaler.utils.registry.Registry', 'Registry', (['"""ENGINE"""'], {}), "('ENGINE')\n", (151, 161), False, 'from xmodaler.utils.registry import Registry\n')] |
#-*- coding:utf-8 -*-
"""
" ip2region python seacher client module
"
" Author: koma<<EMAIL>>
" Date : 2015-11-06
"""
import struct, io, socket, sys
class Ip2Region(object):
__headerSip = []
__headerPtr = []
__f = None
__sPtr = 0
__indexLen = 0
__dbBinStr = ''
def __init__(se... | [
"struct.unpack",
"socket.inet_aton",
"io.open",
"sys.exit"
] | [((5850, 5870), 'socket.inet_aton', 'socket.inet_aton', (['ip'], {}), '(ip)\n', (5866, 5870), False, 'import struct, io, socket, sys\n'), ((5305, 5326), 'io.open', 'io.open', (['dbfile', '"""rb"""'], {}), "(dbfile, 'rb')\n", (5312, 5326), False, 'import struct, io, socket, sys\n'), ((5887, 5911), 'struct.unpack', 'stru... |
# -*- coding: utf-8 -*-
from os import popen
class UpdtPyLibs(object):
"""
升级所有第三方有更新的python库到最新版本
"""
@staticmethod
def exec_cmd(cmmd):
"""
执行命令
:param cmmd: str/命令内容
:return: tuple/(boolean, result)
"""
return popen(cmmd).read()
@staticmetho... | [
"os.popen"
] | [((284, 295), 'os.popen', 'popen', (['cmmd'], {}), '(cmmd)\n', (289, 295), False, 'from os import popen\n')] |
import time
import keyboard
import random
import tkinter
# Checking to see if RED is active
def redCheck():
return keyboard.is_pressed('r')
# Checking to see if BLACK is active
def blackCheck():
return keyboard.is_pressed('b')
print("Welcome to the reaction time tester")
def main():
update.set(" ... | [
"keyboard.is_pressed",
"tkinter.Button",
"time.sleep",
"tkinter.StringVar",
"tkinter.Tk",
"tkinter.Label",
"time.time",
"random.randint"
] | [((1158, 1170), 'tkinter.Tk', 'tkinter.Tk', ([], {}), '()\n', (1168, 1170), False, 'import tkinter\n'), ((1245, 1264), 'tkinter.StringVar', 'tkinter.StringVar', ([], {}), '()\n', (1262, 1264), False, 'import tkinter\n'), ((1303, 1322), 'tkinter.StringVar', 'tkinter.StringVar', ([], {}), '()\n', (1320, 1322), False, 'im... |
#!/usr/bin/env python
# coding: utf-8
'''
* Author : <NAME>
* Date : 09.05.2019
* Description : Hector agent monitoring
* Help :
- https://psutil.readthedocs.io/en/latest/#psutil.swap_memory
'''
import psutil
import sys
sys.path.insert(0, '..') # to import helpers from parent folder
import helpers
class swap... | [
"sys.path.insert",
"helpers.bytes_to_mb",
"psutil.swap_memory"
] | [((230, 254), 'sys.path.insert', 'sys.path.insert', (['(0)', '""".."""'], {}), "(0, '..')\n", (245, 254), False, 'import sys\n'), ((369, 389), 'psutil.swap_memory', 'psutil.swap_memory', ([], {}), '()\n', (387, 389), False, 'import psutil\n'), ((527, 557), 'helpers.bytes_to_mb', 'helpers.bytes_to_mb', (['data[key]'], {... |
"""
# Authors:
* <NAME> 2021
* <NAME> 2020
* <NAME> 2020
* <NAME> 2020
* <NAME> 2020
* <NAME> 2020
"""
import torch
import numpy as np
smallVal = np.finfo("float").eps # To avoid divide by zero
def si_snr_loss(y_pred_batch, y_true_batch, lens, reduction="mean"):
"""Compute the si_snr sco... | [
"torch.log10",
"torch.sum",
"torch.squeeze",
"numpy.finfo",
"torch.zeros"
] | [((167, 184), 'numpy.finfo', 'np.finfo', (['"""float"""'], {}), "('float')\n", (175, 184), True, 'import numpy as np\n'), ((858, 893), 'torch.squeeze', 'torch.squeeze', (['y_pred_batch'], {'dim': '(-1)'}), '(y_pred_batch, dim=-1)\n', (871, 893), False, 'import torch\n'), ((914, 949), 'torch.squeeze', 'torch.squeeze', (... |
#!/usr/bin/env python3
# Author: <NAME>
# Date: 2021/1/29
# Functions to generate csv summaries of data statistics and merge result statistics
import os
import argparse
import re
from typing import Tuple
import pandas as pd
import numpy as np
import consts as C
from processing.marsdataloader import MARSDataLoader
... | [
"os.listdir",
"argparse.ArgumentParser",
"pandas.read_csv",
"re.compile",
"os.path.join",
"numpy.sum",
"pandas.DataFrame"
] | [((523, 608), 'pandas.read_csv', 'pd.read_csv', (['C.ALL_RES_CSV_PATH'], {'dtype': '{exp_ID_name: int}', 'index_col': 'exp_ID_name'}), '(C.ALL_RES_CSV_PATH, dtype={exp_ID_name: int}, index_col=exp_ID_name\n )\n', (534, 608), True, 'import pandas as pd\n'), ((620, 694), 'pandas.read_csv', 'pd.read_csv', (['C.EXP_ID_L... |
import clr
clr.AddReference('RevitAPI')
from Autodesk.Revit.DB import *
clr.AddReference("RevitNodes")
import Revit
clr.ImportExtensions(Revit.Elements)
refgroup = UnwrapElement(IN[0])
groups = UnwrapElement(IN[1])
# Get Mirrored state of first family instance in reference group instance
refGroupMembers = refgroup.G... | [
"clr.AddReference",
"clr.ImportExtensions"
] | [((11, 39), 'clr.AddReference', 'clr.AddReference', (['"""RevitAPI"""'], {}), "('RevitAPI')\n", (27, 39), False, 'import clr\n'), ((73, 103), 'clr.AddReference', 'clr.AddReference', (['"""RevitNodes"""'], {}), "('RevitNodes')\n", (89, 103), False, 'import clr\n'), ((117, 153), 'clr.ImportExtensions', 'clr.ImportExtensi... |
"""7 compounds containing only carbon and hydrogen,
and having only two topological symmetry classes each
ethane
benzene
cyclopentane
ethylene
methane
cyclopropane
cyclohexane
"""
import numpy as np
from openeye.oechem import OEPerceiveSymmetry
from simtk import unit
from bayes_implicit_solvent.freesolv import cid_t... | [
"openeye.oechem.OEPerceiveSymmetry",
"pkg_resources.resource_filename",
"bayes_implicit_solvent.molecule.Molecule",
"numpy.load",
"glob.glob"
] | [((679, 765), 'pkg_resources.resource_filename', 'resource_filename', (['"""bayes_implicit_solvent"""', '"""vacuum_samples/vacuum_samples_*.npy"""'], {}), "('bayes_implicit_solvent',\n 'vacuum_samples/vacuum_samples_*.npy')\n", (696, 765), False, 'from pkg_resources import resource_filename\n'), ((824, 852), 'glob.g... |
from pyspark.sql import SparkSession
spark = SparkSession.builder.appName("SparkSQL").getOrCreate()
# header means we are using a header in the CSV File
# inferSchema means to tell spark to try to figure it out the table Schema
people = spark.read.option("header", "true").option("inferSchema", "true")\
.csv("file... | [
"pyspark.sql.SparkSession.builder.appName"
] | [((46, 86), 'pyspark.sql.SparkSession.builder.appName', 'SparkSession.builder.appName', (['"""SparkSQL"""'], {}), "('SparkSQL')\n", (74, 86), False, 'from pyspark.sql import SparkSession\n')] |
from typing import List, Tuple, Union
import numpy as np
import torch
from allrank.click_models.base import ClickModel
from allrank.data.dataset_loading import PADDED_Y_VALUE
def click_on_slates(slates: Union[Tuple[np.ndarray, np.ndarray], Tuple[torch.Tensor, torch.Tensor]],
click_model: ClickMo... | [
"numpy.sum",
"numpy.zeros_like"
] | [((2179, 2195), 'numpy.zeros_like', 'np.zeros_like', (['y'], {}), '(y)\n', (2192, 2195), True, 'import numpy as np\n'), ((1200, 1224), 'numpy.sum', 'np.sum', (['(slate_clicks > 0)'], {}), '(slate_clicks > 0)\n', (1206, 1224), True, 'import numpy as np\n')] |
import pathlib
import re
from setuptools import find_packages, setup
# YOU SHOULDN'T CALL THIS FILE USING "python setup.py ..."
# INSTEAD SEE THE Makefile FOR TARGET "pip"
# E.g. run: `make pip`
this = pathlib.Path(__file__).parent
def find_version(version_file):
version_match = re.search(r"^__version__ = ['\"](... | [
"re.search",
"setuptools.find_packages",
"pathlib.Path"
] | [((204, 226), 'pathlib.Path', 'pathlib.Path', (['__file__'], {}), '(__file__)\n', (216, 226), False, 'import pathlib\n'), ((287, 360), 're.search', 're.search', (['"""^__version__ = [\'\\\\"]([^\'\\\\"]*)[\'\\\\"]"""', 'version_file', 're.M'], {}), '(\'^__version__ = [\\\'\\\\"]([^\\\'\\\\"]*)[\\\'\\\\"]\', version_fil... |
import robocode_vscode
robocode_vscode.import_robocode_ls_core()
| [
"robocode_vscode.import_robocode_ls_core"
] | [((24, 65), 'robocode_vscode.import_robocode_ls_core', 'robocode_vscode.import_robocode_ls_core', ([], {}), '()\n', (63, 65), False, 'import robocode_vscode\n')] |
from AssetCategory import AssetCategory
from AssetDesc import AssetDesc
from SceneAccessor import SceneAccessor
from ProjectExportDesc import ProjectExportDesc
from FSSceneAccessor import FSSceneAccessor
from FSTextureAssetAccessor import FSTextureAssetAccessor
from FSSequenceAssetAccessor import FSSequenceAsse... | [
"os.path.join",
"os.makedirs"
] | [((1143, 1192), 'os.path.join', 'os.path.join', (['self.rootDir', '"""projects"""', 'self.name'], {}), "(self.rootDir, 'projects', self.name)\n", (1155, 1192), False, 'import os\n'), ((1206, 1227), 'os.makedirs', 'os.makedirs', (['projPath'], {}), '(projPath)\n', (1217, 1227), False, 'import os\n'), ((1067, 1116), 'os.... |
from distutils.core import setup, Extension
from glob import glob
setup(
name = "tap",
packages = [
"tap",
],
ext_modules = [
Extension(
"tap/core",
extra_compile_args = [
"-Iboost/core/include",
"-Iboost/endian/include",
"-Wextra",
"-Wno-missing-field-initializers",
"-Wno-unused-para... | [
"glob.glob"
] | [((392, 414), 'glob.glob', 'glob', (['"""tap/core/*.cpp"""'], {}), "('tap/core/*.cpp')\n", (396, 414), False, 'from glob import glob\n')] |
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License.
import atexit
from datetime import datetime
import json
from threading import Thread
from urllib.request import Request, urlopen
_format = '%Y-%m-%d %H:%M:%S.%f'
_file = None
_run_name = None
_slack_url = None
def init(f... | [
"urllib.request.Request",
"json.dumps",
"datetime.datetime.now",
"threading.Thread",
"atexit.register"
] | [((1288, 1319), 'atexit.register', 'atexit.register', (['_close_logfile'], {}), '(_close_logfile)\n', (1303, 1319), False, 'import atexit\n'), ((1072, 1091), 'urllib.request.Request', 'Request', (['_slack_url'], {}), '(_slack_url)\n', (1079, 1091), False, 'from urllib.request import Request, urlopen\n'), ((894, 933), '... |