code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
from typing import Callable, TypeVar, List
T = TypeVar('T')
class Registrable(object):
reg_list = dict()
@classmethod
def register(cls, class_name: str) -> Callable:
def register_inner(class_type: T) -> None:
cls.reg_list[class_name] = class_type
return register_inner
@c... | [
"typing.TypeVar"
] | [((48, 60), 'typing.TypeVar', 'TypeVar', (['"""T"""'], {}), "('T')\n", (55, 60), False, 'from typing import Callable, TypeVar, List\n')] |
#!/usr/bin/env python
# coding: utf-8
# # Self-Driving Car Engineer Nanodegree
#
#
# ## Project: **Finding Lane Lines on the Road**
# ***
# In this project, you will use the tools you learned about in the lesson to identify lane lines on the road. You can develop your pipeline on a series of individual images, and... | [
"matplotlib.image.imread",
"numpy.array",
"matplotlib.pyplot.imshow",
"os.path.exists",
"os.listdir",
"cv2.line",
"cv2.addWeighted",
"moviepy.editor.VideoFileClip",
"cv2.fillPoly",
"matplotlib.pyplot.subplot",
"cv2.cvtColor",
"matplotlib.pyplot.title",
"cv2.GaussianBlur",
"cv2.Canny",
"m... | [((3572, 3619), 'matplotlib.image.imread', 'mpimg.imread', (['"""test_images/solidWhiteRight.jpg"""'], {}), "('test_images/solidWhiteRight.jpg')\n", (3584, 3619), True, 'import matplotlib.image as mpimg\n'), ((3729, 3746), 'matplotlib.pyplot.imshow', 'plt.imshow', (['image'], {}), '(image)\n', (3739, 3746), True, 'impo... |
from django import forms
from zentral.core.probes.forms import BaseCreateProbeForm
from zentral.utils.forms import validate_sha256
from .probes import (OsqueryProbe, OsqueryComplianceProbe,
OsqueryDistributedQueryProbe, OsqueryFileCarveProbe,
OsqueryFIMProbe)
# OsqueryProbe
... | [
"django.forms.BooleanField",
"django.forms.CharField",
"django.forms.Select",
"django.forms.ValidationError",
"django.forms.ChoiceField",
"django.forms.IntegerField",
"django.forms.Textarea",
"django.forms.formset_factory"
] | [((8279, 8387), 'django.forms.formset_factory', 'forms.formset_factory', (['KeyForm'], {'formset': 'BaseKeyFormSet', 'min_num': '(1)', 'max_num': '(10)', 'extra': '(0)', 'can_delete': '(True)'}), '(KeyForm, formset=BaseKeyFormSet, min_num=1, max_num=\n 10, extra=0, can_delete=True)\n', (8300, 8387), False, 'from dja... |
import numpy
from scipy.spatial import distance
import matplotlib.pyplot as plt
import math
import matplotlib.ticker as mtick
freqs = [20, 25, 31.5, 40, 50, 63, 80, 100, 125, 160, 200, 250, 315, 400, 500, 630, 800, 1000, 1250, 1600, 2000, 2500, 3150, 4000, 5000, 6300, 8000, 10000, 12500]
def cosine_distance(a, b, we... | [
"scipy.spatial.distance.cosine",
"numpy.sqrt",
"matplotlib.pyplot.show",
"numpy.average",
"matplotlib.ticker.PercentFormatter",
"math.sqrt",
"numpy.asarray",
"numpy.any",
"numpy.square",
"numpy.rot90",
"matplotlib.pyplot.subplots",
"numpy.arange",
"numpy.atleast_1d"
] | [((3222, 3247), 'numpy.rot90', 'numpy.rot90', (['ref_spectrum'], {}), '(ref_spectrum)\n', (3233, 3247), False, 'import numpy\n'), ((3266, 3293), 'numpy.rot90', 'numpy.rot90', (['test1_spectrum'], {}), '(test1_spectrum)\n', (3277, 3293), False, 'import numpy\n'), ((3312, 3339), 'numpy.rot90', 'numpy.rot90', (['test2_spe... |
from django.test.utils import override_settings
from hc.api.models import Channel
from hc.test import BaseTestCase
@override_settings(PD_VENDOR_KEY="foo")
class AddPdConnectTestCase(BaseTestCase):
def setUp(self):
super().setUp()
self.url = "/projects/%s/add_pdc/" % self.project.code
def test... | [
"hc.api.models.Channel.objects.get",
"django.test.utils.override_settings"
] | [((118, 156), 'django.test.utils.override_settings', 'override_settings', ([], {'PD_VENDOR_KEY': '"""foo"""'}), "(PD_VENDOR_KEY='foo')\n", (135, 156), False, 'from django.test.utils import override_settings\n'), ((856, 893), 'django.test.utils.override_settings', 'override_settings', ([], {'PD_VENDOR_KEY': 'None'}), '(... |
import sys
sys.setrecursionlimit(3000)
def check(rs, cs):
table[rs][cs] = 2
if (rs, cs) == (rg, cg): return True
if rs > 0 and table[rs - 1][cs] == 1 and check(rs - 1, cs):
return True
if cs > 0 and table[rs][cs - 1] == 1 and check(rs, cs - 1):
return True
if rs < r - 1 and table[rs... | [
"sys.setrecursionlimit"
] | [((11, 38), 'sys.setrecursionlimit', 'sys.setrecursionlimit', (['(3000)'], {}), '(3000)\n', (32, 38), False, 'import sys\n')] |
import json
import logging
from unittest import mock, TestCase
from bullet_train import BulletTrain
import os
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
TEST_API_URL = 'https://test.bullet-train.io/api'
TEST_IDENTIFIER = 'test-identity'
TEST_FEATURE = 'test-feature'
class MockResponse:
... | [
"logging.getLogger",
"json.loads",
"bullet_train.BulletTrain",
"os.path.join",
"os.path.realpath",
"unittest.mock.patch"
] | [((121, 148), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (138, 148), False, 'import logging\n'), ((1878, 1989), 'unittest.mock.patch', 'mock.patch', (['"""bullet_train.bullet_train.requests.get"""'], {'side_effect': 'mocked_get_specific_feature_flag_enabled'}), "('bullet_train.bullet_... |
"""
This module contains entry points for command-line utilities provided by Plim package.
"""
import sys
import os
import argparse
import codecs
from pkg_resources import get_distribution
from pkg_resources import EntryPoint
from mako.template import Template
from mako.lookup import TemplateLookup
from .util import ... | [
"sys.path.insert",
"argparse.ArgumentParser",
"os.path.basename",
"mako.lookup.TemplateLookup",
"os.path.abspath",
"codecs.open",
"codecs.encode",
"pkg_resources.get_distribution"
] | [((832, 918), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Compile plim source files into mako files."""'}), "(description=\n 'Compile plim source files into mako files.')\n", (855, 918), False, 'import argparse\n'), ((1980, 2002), 'sys.path.insert', 'sys.path.insert', (['(0)', '"""... |
def load_model(model_path, device_type='cuda'):
import torch
from viclassifier.utils import dev_opt
device = dev_opt.usingDevice(device_type)
model = torch.load(model_path, map_location=device)
model.to(device)
# 测试时不启用 BatchNormalization 和 Dropout
model.eval()
return model
def predic... | [
"PIL.Image.open",
"viclassifier.utils.trans_gen.genTrans",
"torch.load",
"PIL.ImageFont.truetype",
"torch.exp",
"PIL.ImageDraw.Draw",
"os.path.abspath",
"torch.no_grad",
"sys.path.append",
"viclassifier.utils.dev_opt.usingDevice"
] | [((122, 154), 'viclassifier.utils.dev_opt.usingDevice', 'dev_opt.usingDevice', (['device_type'], {}), '(device_type)\n', (141, 154), False, 'from viclassifier.utils import dev_opt\n'), ((167, 210), 'torch.load', 'torch.load', (['model_path'], {'map_location': 'device'}), '(model_path, map_location=device)\n', (177, 210... |
# -*- coding: utf-8 -*-
"""
Created on Sat May 21 17:05:48 2022
@author: <NAME>
"""
import numpy as np
import pandas as pd
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import accuracy_score, balanced_accuracy_score, confusion_matrix
from ibllib.atlas import BrainRegions
from joblib import l... | [
"matplotlib.pyplot.hist",
"sklearn.metrics.balanced_accuracy_score",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.imshow",
"seaborn.despine",
"model_functions.load_channel_data",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.close",
"matplotlib.pyplot.yticks",
"sklearn.metrics.confusion_matrix"... | [((450, 464), 'ibllib.atlas.BrainRegions', 'BrainRegions', ([], {}), '()\n', (462, 464), False, 'from ibllib.atlas import BrainRegions\n'), ((658, 677), 'model_functions.load_channel_data', 'load_channel_data', ([], {}), '()\n', (675, 677), False, 'from model_functions import load_channel_data, load_trained_model\n'), ... |
#!/usr/bin/env python
import pytest
from pyxenon_snippets import directory_listing_recursive
def test_directory_listing_recursive():
directory_listing_recursive.run_example()
| [
"pyxenon_snippets.directory_listing_recursive.run_example"
] | [((141, 182), 'pyxenon_snippets.directory_listing_recursive.run_example', 'directory_listing_recursive.run_example', ([], {}), '()\n', (180, 182), False, 'from pyxenon_snippets import directory_listing_recursive\n')] |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.buffer.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
from itertools import product
n, m = map(int, readline().split())
inf = float('inf')
dp = [inf] * (2 ** n)
dp[0] = 0
for _ in range(m):
s, c = readline().rstrip().deco... | [
"sys.setrecursionlimit",
"itertools.product"
] | [((116, 146), 'sys.setrecursionlimit', 'sys.setrecursionlimit', (['(10 ** 7)'], {}), '(10 ** 7)\n', (137, 146), False, 'import sys\n'), ((468, 493), 'itertools.product', 'product', (['[0, 1]'], {'repeat': 'n'}), '([0, 1], repeat=n)\n', (475, 493), False, 'from itertools import product\n')] |
# -*- coding: utf-8 -*-
# Copyright 2020 Google 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 required by applicable law or... | [
"warnings.warn",
"google.api_core.grpc_helpers_async.create_channel",
"grpc.ssl_channel_credentials",
"google.auth.transport.grpc.SslCredentials"
] | [((3783, 4018), 'google.api_core.grpc_helpers_async.create_channel', 'grpc_helpers_async.create_channel', (['host'], {'credentials': 'credentials', 'credentials_file': 'credentials_file', 'quota_project_id': 'quota_project_id', 'default_scopes': 'cls.AUTH_SCOPES', 'scopes': 'scopes', 'default_host': 'cls.DEFAULT_HOST'}... |
import struct
import numpy as np
import pandas as pd
df_train = pd.read_csv('../data/train_data.csv')
df_valid = pd.read_csv('../data/valid_data.csv')
df_test = pd.read_csv('../data/test_data.csv')
with open('result.dat', 'rb') as f:
N, = struct.unpack('i', f.read(4))
no_dims, = struct.unpack('i', f.read(4))
... | [
"numpy.array",
"numpy.savez",
"pandas.read_csv"
] | [((65, 102), 'pandas.read_csv', 'pd.read_csv', (['"""../data/train_data.csv"""'], {}), "('../data/train_data.csv')\n", (76, 102), True, 'import pandas as pd\n'), ((114, 151), 'pandas.read_csv', 'pd.read_csv', (['"""../data/valid_data.csv"""'], {}), "('../data/valid_data.csv')\n", (125, 151), True, 'import pandas as pd\... |
from django.conf.urls.defaults import patterns, url, include
# Uncomment the next two lines to enable the admin:
from django.contrib import admin
admin.autodiscover()
urlpatterns = patterns(
'',
(r'^log/', include('requestlog.urls')),
(r'^admin/', include(admin.site.urls)),
# Pass anything that does... | [
"django.conf.urls.defaults.patterns",
"django.conf.urls.defaults.include",
"django.contrib.admin.autodiscover"
] | [((147, 167), 'django.contrib.admin.autodiscover', 'admin.autodiscover', ([], {}), '()\n', (165, 167), False, 'from django.contrib import admin\n'), ((472, 585), 'django.conf.urls.defaults.patterns', 'patterns', (['""""""', "('^static/(?P<path>.*)$', 'django.views.static.serve', {'document_root':\n settings.MEDIA_RO... |
"""
File contains handler for ReferenceDataRequest
"""
import asyncio
import uuid
from typing import Dict
from typing import List
from .base_handler import HandlerBase
from .base_request import RequestBase
from .requests import Subscription
from .utils.blp_name import RESPONSE_ERROR
from .utils.log import get_logger
... | [
"uuid.uuid4",
"asyncio.gather"
] | [((6291, 6313), 'asyncio.gather', 'asyncio.gather', (['*tasks'], {}), '(*tasks)\n', (6305, 6313), False, 'import asyncio\n'), ((1691, 1703), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (1701, 1703), False, 'import uuid\n'), ((5398, 5410), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (5408, 5410), False, 'import uuid... |
from math import floor
import pandas as pd
def filter_param_cd(df, code):
"""Return df filtered by approved data
"""
approved_df = df.copy()
params = [param.strip('_cd') for param in df.columns if param.endswith('_cd')]
for param in params:
#filter out records where param_cd doesn't cont... | [
"pandas.DataFrame",
"pandas.date_range",
"math.floor"
] | [((1141, 1167), 'math.floor', 'floor', (['(interp_limit / freq)'], {}), '(interp_limit / freq)\n', (1146, 1167), False, 'from math import floor\n'), ((1267, 1331), 'pandas.date_range', 'pd.date_range', ([], {'start': 'start', 'end': 'end', 'periods': 'None', 'freq': 'freq_str'}), '(start=start, end=end, periods=None, f... |
import json
import requests
import pandas as pd
import websocket
# Get Alpaca API Credential
endpoint = "https://data.alpaca.markets/v2"
headers = json.loads(open("key.txt", 'r').read())
def hist_data(symbols, start="2021-01-01", timeframe="1Hour", limit=50, end=""):
"""
returns historical b... | [
"pandas.DataFrame",
"requests.get",
"pandas.to_datetime"
] | [((1232, 1258), 'pandas.DataFrame', 'pd.DataFrame', (["data['bars']"], {}), "(data['bars'])\n", (1244, 1258), True, 'import pandas as pd\n'), ((1402, 1433), 'pandas.to_datetime', 'pd.to_datetime', (["df_data['time']"], {}), "(df_data['time'])\n", (1416, 1433), True, 'import pandas as pd\n'), ((3161, 3187), 'pandas.Data... |
import asyncio
from yaps.api import protocol
from yaps.utils.log import Log
SLEEP_SLOT_TIME = 1 # In seconds.
class State:
PING_PONG = 1
PING_PONG_1_MISS = 2
PING_PONG_2_MISS = 3
class Subscription:
"""
Abstraction for handling a subscription.
This class has utilites that ... | [
"yaps.api.protocol.async_cmd_ok",
"yaps.utils.log.Log.err",
"yaps.api.protocol.read_packet",
"yaps.api.protocol.send_packet",
"asyncio.sleep",
"yaps.utils.log.Log.debug"
] | [((1954, 1979), 'yaps.utils.log.Log.debug', 'Log.debug', (['f"""Ping {self}"""'], {}), "(f'Ping {self}')\n", (1963, 1979), False, 'from yaps.utils.log import Log\n'), ((3717, 3755), 'yaps.utils.log.Log.debug', 'Log.debug', (['f"""Subscription died {self}"""'], {}), "(f'Subscription died {self}')\n", (3726, 3755), False... |
#!/cygdrive/c/Python27/python.exe
# <NAME>, Ph.D.
# Swint-Kruse Laboratory
# Physician Scientist Training Program
# University of Kansas Medical Center
# This code is adapted from the example available at
# http://pandasplotting.blogspot.com/2012/04/added-kde-to-scatter-matrix-diagonals.html
# Creates a scatterplot ... | [
"pandas.tools.plotting.scatter_matrix",
"matplotlib.pyplot.subplots_adjust",
"pandas.read_csv",
"matplotlib.pyplot.savefig"
] | [((568, 601), 'pandas.read_csv', 'pandas.read_csv', (['infile'], {'sep': '"""\t"""'}), "(infile, sep='\\t')\n", (583, 601), False, 'import pandas\n'), ((679, 804), 'pandas.tools.plotting.scatter_matrix', 'pandas.tools.plotting.scatter_matrix', (['maindata'], {'alpha': '(0.1)', 'marker': '"""k."""', 'figsize': '(8, 8)',... |
import pygame;
import numpy as np;
from math import sin, cos;
pygame.init();
width, height, depth = 640, 480, 800;
camera = [width // 2, height // 2, depth];
units_x, units_y, units_z = 8, 8, 8;
scale_x, scale_y, scale_z = width / units_x, height / units_y, depth / units_z;
screen = pygame.display.set_mode((width, he... | [
"pygame.key.set_repeat",
"pygame.display.set_caption",
"pygame.draw.polygon",
"pygame.init",
"pygame.quit",
"pygame.event.get",
"pygame.display.set_mode",
"pygame.display.flip",
"math.cos",
"numpy.array",
"pygame.draw.rect",
"pygame.time.Clock",
"math.sin"
] | [((62, 75), 'pygame.init', 'pygame.init', ([], {}), '()\n', (73, 75), False, 'import pygame\n'), ((286, 326), 'pygame.display.set_mode', 'pygame.display.set_mode', (['(width, height)'], {}), '((width, height))\n', (309, 326), False, 'import pygame\n'), ((328, 388), 'pygame.display.set_caption', 'pygame.display.set_capt... |
from API.db import db
from datetime import datetime
from passlib.apps import custom_app_context as pwd_context
class User(db.Model):
__tablename__ = "users"
def __init__(self, username, password):
self.username = username
self.password = pwd_context.hash(password)
self.limit = 0
... | [
"passlib.apps.custom_app_context.hash",
"API.db.db.ForeignKey",
"datetime.datetime.strptime",
"API.db.db.session.commit",
"API.db.db.session.add",
"API.db.db.String",
"API.db.db.relationship",
"passlib.apps.custom_app_context.verify",
"API.db.db.session.delete",
"API.db.db.Column"
] | [((1579, 1638), 'API.db.db.Column', 'db.Column', (['db.Integer'], {'primary_key': '(True)', 'autoincrement': '(True)'}), '(db.Integer, primary_key=True, autoincrement=True)\n', (1588, 1638), False, 'from API.db import db\n'), ((1811, 1874), 'API.db.db.Column', 'db.Column', (['db.DateTime'], {'nullable': '(False)', 'def... |
import unittest
from Dice import Dice
class TestDice(unittest.TestCase):
def setUp(self):
self.sides = 8
self.dice = Dice(self.sides)
def test_roll(self):
for i in range(1000):
self.assertLessEqual(self.dice.roll(), self.sides)
def test_error(self):
self.asse... | [
"unittest.main",
"Dice.Dice"
] | [((402, 417), 'unittest.main', 'unittest.main', ([], {}), '()\n', (415, 417), False, 'import unittest\n'), ((140, 156), 'Dice.Dice', 'Dice', (['self.sides'], {}), '(self.sides)\n', (144, 156), False, 'from Dice import Dice\n')] |
"""Command line tool to extract meaningful health info from accelerometer data."""
import accelerometer.accUtils
import argparse
import collections
import datetime
import accelerometer.device
import json
import os
import accelerometer.summariseEpoch
import sys
import pandas as pd
import numpy as np
import matplotlib.p... | [
"argparse.ArgumentParser",
"os.access",
"os.path.split",
"os.path.isfile",
"datetime.datetime.now",
"pandas.datetime.strptime",
"sys.exit",
"import_npy.import_npy",
"os.remove"
] | [((520, 677), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""A tool to extract physical activity information from\n raw accelerometer files."""', 'add_help': '(True)'}), '(description=\n """A tool to extract physical activity information from\n raw accelerometer ... |
from django.shortcuts import render
from .models import VetsInfoTable
# Create your views here.
def home(request):
context = {
"name": "Home"
}
return render(request, 'index.html', context)
def view_vets(request):
obj = VetsInfoTable.objects.all()
context = {
"vets_data": obj... | [
"django.shortcuts.render"
] | [((176, 214), 'django.shortcuts.render', 'render', (['request', '"""index.html"""', 'context'], {}), "(request, 'index.html', context)\n", (182, 214), False, 'from django.shortcuts import render\n'), ((339, 381), 'django.shortcuts.render', 'render', (['request', '"""vets/vets.html"""', 'context'], {}), "(request, 'vets... |
import sys
import math
import random
# Figure out what we should name our output file, and how big it should be
if len(sys.argv) != 3: # Make sure we get a file argument, and only that
print("Incorrect number of arguments found, should be \"generate <file> 10^<x>\"")
for i in range(10):
with open("./gen/%s%d"... | [
"random.randint"
] | [((425, 449), 'random.randint', 'random.randint', (['(1)', '(10000)'], {}), '(1, 10000)\n', (439, 449), False, 'import random\n'), ((469, 493), 'random.randint', 'random.randint', (['(1)', '(10000)'], {}), '(1, 10000)\n', (483, 493), False, 'import random\n')] |
import pytest
from easydict import EasyDict
import numpy as np
import gym
from copy import deepcopy
from ding.envs.env import check_array_space, check_different_memory, check_all, demonstrate_correct_procedure
from ding.envs.env.tests import DemoEnv
@pytest.mark.unittest
def test_an_implemented_env():
demo_env =... | [
"ding.envs.env.tests.DemoEnv",
"ding.envs.env.demonstrate_correct_procedure",
"gym.spaces.Box",
"numpy.array",
"pytest.raises",
"ding.envs.env.check_array_space",
"ding.envs.env.check_different_memory",
"copy.deepcopy",
"ding.envs.env.check_all"
] | [((321, 332), 'ding.envs.env.tests.DemoEnv', 'DemoEnv', (['{}'], {}), '({})\n', (328, 332), False, 'from ding.envs.env.tests import DemoEnv\n'), ((337, 356), 'ding.envs.env.check_all', 'check_all', (['demo_env'], {}), '(demo_env)\n', (346, 356), False, 'from ding.envs.env import check_array_space, check_different_memor... |
import random
from floodsystem.utils import sorted_by_key # noqa
from floodsystem.geo import stations_by_distance, stations_within_radius, rivers_with_station, stations_by_river,rivers_by_station_number
from floodsystem.stationdata import build_station_list
'''def test_geo():
#Task 1A
#does the function ... | [
"floodsystem.geo.rivers_with_station",
"floodsystem.geo.stations_by_distance",
"floodsystem.geo.stations_within_radius",
"floodsystem.utils.sorted_by_key",
"floodsystem.geo.stations_by_river",
"floodsystem.geo.rivers_by_station_number",
"floodsystem.stationdata.build_station_list",
"random.randint"
] | [((579, 599), 'floodsystem.stationdata.build_station_list', 'build_station_list', ([], {}), '()\n', (597, 599), False, 'from floodsystem.stationdata import build_station_list\n'), ((673, 706), 'floodsystem.geo.stations_by_distance', 'stations_by_distance', (['stations', 'p'], {}), '(stations, p)\n', (693, 706), False, ... |
# -*- coding: utf-8 -*-
"""
Authors: <NAME>
UNESCO-IHE 2017
Contact: <EMAIL>
Repository: https://github.com/wateraccounting/wa
Module: Generator/Sheet3
"""
import os
def Create(Dir_Basin, Basin, Simulation, Dir_Basin_CSV_a, Dir_Basin_CSV_b):
"""
This functions create the monthly and yearly sheet 3 in ... | [
"os.path.exists",
"os.path.join",
"os.mkdir"
] | [((866, 941), 'os.path.join', 'os.path.join', (['Dir_Basin', '"""Simulations"""', "('Simulation_%d' % Simulation)", '"""PDF"""'], {}), "(Dir_Basin, 'Simulations', 'Simulation_%d' % Simulation, 'PDF')\n", (878, 941), False, 'import os\n'), ((1173, 1259), 'os.path.join', 'os.path.join', (['Dir_Basin_PDF', "('Sheet3a_Sim%... |
from flask import Blueprint
from apps.auth.business.wxlogin import WxLoginBusiness
from apps.auth.extentions import validation, parse_json_form
from library.api.render import json_detail_render
wxlogin = Blueprint("wxlogin", __name__)
@wxlogin.route('/', methods=['POST'])
@validation('POST:wx_user_code')
def wxuser... | [
"apps.auth.extentions.parse_json_form",
"apps.auth.business.wxlogin.WxLoginBusiness.get_user",
"apps.auth.extentions.validation",
"library.api.render.json_detail_render",
"flask.Blueprint"
] | [((206, 236), 'flask.Blueprint', 'Blueprint', (['"""wxlogin"""', '__name__'], {}), "('wxlogin', __name__)\n", (215, 236), False, 'from flask import Blueprint\n'), ((278, 309), 'apps.auth.extentions.validation', 'validation', (['"""POST:wx_user_code"""'], {}), "('POST:wx_user_code')\n", (288, 309), False, 'from apps.aut... |
from flask_socketio import SocketIO
NOTI = 'notification'
class MySocket():
def __init__(self, app, async_mode):
self.socketio = SocketIO(app, async_mode=async_mode)
def get_socketio(self):
return self.socketio
def noti_emit(self, msg, room=None):
if room:
self.soc... | [
"flask_socketio.SocketIO"
] | [((146, 182), 'flask_socketio.SocketIO', 'SocketIO', (['app'], {'async_mode': 'async_mode'}), '(app, async_mode=async_mode)\n', (154, 182), False, 'from flask_socketio import SocketIO\n')] |
import pytest
from weaverbird.backends.sql_translator.metadata import SqlQueryMetadataManager
from weaverbird.backends.sql_translator.steps import translate_filter
from weaverbird.backends.sql_translator.types import SQLQuery
from weaverbird.pipeline.conditions import ComparisonCondition
from weaverbird.pipeline.steps... | [
"weaverbird.backends.sql_translator.metadata.SqlQueryMetadataManager",
"weaverbird.pipeline.conditions.ComparisonCondition",
"pytest.raises",
"weaverbird.backends.sql_translator.steps.translate_filter"
] | [((1055, 1093), 'weaverbird.backends.sql_translator.steps.translate_filter', 'translate_filter', (['step', 'query'], {'index': '(1)'}), '(step, query, index=1)\n', (1071, 1093), False, 'from weaverbird.backends.sql_translator.steps import translate_filter\n'), ((2045, 2079), 'pytest.raises', 'pytest.raises', (['NotImpl... |
import json
import sqlite3
import typing
from typing import Optional, Dict
from copy import deepcopy
from contextlib import suppress
from bson.objectid import ObjectId
from pymongo import MongoClient
from pymongo.errors import ConfigurationError
class MongoStorageException(Exception):
pass
class Mongo:
def... | [
"json.loads",
"sqlite3.connect",
"json.dumps",
"contextlib.suppress",
"copy.deepcopy",
"pymongo.MongoClient"
] | [((512, 542), 'pymongo.MongoClient', 'MongoClient', (['connection_string'], {}), '(connection_string)\n', (523, 542), False, 'from pymongo import MongoClient\n'), ((959, 973), 'copy.deepcopy', 'deepcopy', (['data'], {}), '(data)\n', (967, 973), False, 'from copy import deepcopy\n'), ((3086, 3114), 'sqlite3.connect', 's... |
from testing_config import BaseTestConfig
from application.models import User
from application.models import Chatroom
import json
from application.utils import auth
class TestMatch(BaseTestConfig):
test_group = {
"name": "test_group",
"tag": "Poker",
}
test_group2 = {
"name": "test... | [
"json.dumps"
] | [((748, 770), 'json.dumps', 'json.dumps', (['self.tag_p'], {}), '(self.tag_p)\n', (758, 770), False, 'import json\n'), ((909, 931), 'json.dumps', 'json.dumps', (['self.tag_s'], {}), '(self.tag_s)\n', (919, 931), False, 'import json\n'), ((1071, 1093), 'json.dumps', 'json.dumps', (['self.tag_o'], {}), '(self.tag_o)\n', ... |
import sys
sys.path.insert(0, '/home/hena/caffe-ocr/buildcmake/install/python')
sys.path.insert(0, '/home/hena/tool/protobuf-3.1.0/python')
import caffe
import math
import numpy as np
def SoftMax(net_ans):
tmp_net = [math.exp(i) for i in net_ans]
sum_exp = sum(tmp_net)
return [i/sum_exp for i in tmp_net]
... | [
"numpy.sum",
"math.exp",
"sys.path.insert",
"numpy.zeros_like"
] | [((11, 79), 'sys.path.insert', 'sys.path.insert', (['(0)', '"""/home/hena/caffe-ocr/buildcmake/install/python"""'], {}), "(0, '/home/hena/caffe-ocr/buildcmake/install/python')\n", (26, 79), False, 'import sys\n'), ((80, 139), 'sys.path.insert', 'sys.path.insert', (['(0)', '"""/home/hena/tool/protobuf-3.1.0/python"""'],... |
"""
Tools for creating and working with Line (Station) Grids
"""
from typing import Union
import pyproj
import numpy as np
_atype = Union[type(None), np.ndarray]
_ptype = Union[type(None), pyproj.Proj]
class StaHGrid:
"""
Stations Grid
EXAMPLES:
--------
>>> x = arange(8)
>>> y = arange(8... | [
"numpy.isnan",
"numpy.any",
"numpy.ma.masked_where"
] | [((690, 702), 'numpy.any', 'np.any', (['mask'], {}), '(mask)\n', (696, 702), True, 'import numpy as np\n'), ((653, 664), 'numpy.isnan', 'np.isnan', (['x'], {}), '(x)\n', (661, 664), True, 'import numpy as np\n'), ((667, 678), 'numpy.isnan', 'np.isnan', (['y'], {}), '(y)\n', (675, 678), True, 'import numpy as np\n'), ((... |
import numpy as np
from ..reco.disp import disp_vector
import astropy.units as u
import matplotlib.pyplot as plt
from ctapipe.visualization import CameraDisplay
__all__ = [
'overlay_disp_vector',
'overlay_hillas_major_axis',
'overlay_source',
'display_dl1_event',
]
def display_dl1_event(event, camera_... | [
"matplotlib.pyplot.subplots",
"numpy.isfinite",
"ctapipe.visualization.CameraDisplay",
"numpy.arange"
] | [((1019, 1078), 'ctapipe.visualization.CameraDisplay', 'CameraDisplay', (['camera_geometry', 'image'], {'ax': 'axes[0]'}), '(camera_geometry, image, ax=axes[0], **kwargs)\n', (1032, 1078), False, 'from ctapipe.visualization import CameraDisplay\n'), ((1120, 1183), 'ctapipe.visualization.CameraDisplay', 'CameraDisplay',... |
import numpy as np
import random
from scipy.stats import skew as scipy_skew
from skimage.transform import resize as skimage_resize
from QFlow import config
## set of functions for loading and preparing a dataset for training.
def get_num_min_class(labels):
'''
Get the number of the minimum represented class i... | [
"numpy.copy",
"numpy.mean",
"numpy.random.default_rng",
"random.Random",
"numpy.argmax",
"numpy.array",
"numpy.zeros",
"numpy.sum",
"numpy.einsum",
"numpy.concatenate",
"numpy.std",
"numpy.expand_dims",
"numpy.gradient",
"numpy.ravel",
"skimage.transform.resize",
"numpy.load"
] | [((558, 584), 'numpy.argmax', 'np.argmax', (['labels'], {'axis': '(-1)'}), '(labels, axis=-1)\n', (567, 584), True, 'import numpy as np\n'), ((1729, 1756), 'numpy.random.default_rng', 'np.random.default_rng', (['seed'], {}), '(seed)\n', (1750, 1756), True, 'import numpy as np\n'), ((2684, 2723), 'numpy.concatenate', 'n... |
import pyglet
print('Loading resources')
def center_image(image):
"""Sets an image's anchor point to its center"""
image.anchor_x = image.width / 2
image.anchor_y = image.height / 2
# Tell pyglet where to find the resources
pyglet.resource.path = ['./resources', './resources/backgrounds']
pyglet.resource... | [
"pyglet.resource.image",
"pyglet.resource.reindex",
"pyglet.media.load"
] | [((305, 330), 'pyglet.resource.reindex', 'pyglet.resource.reindex', ([], {}), '()\n', (328, 330), False, 'import pyglet\n'), ((427, 465), 'pyglet.resource.image', 'pyglet.resource.image', (['"""tank_body.png"""'], {}), "('tank_body.png')\n", (448, 465), False, 'import pyglet\n'), ((512, 550), 'pyglet.resource.image', '... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
__author__ = 'ipetrash'
# SOURCE: https://github.com/gil9red/VideoStreamingWithEncryption/blob/37cf7f501460a286ec44a20db7b2403e8cb05d97/server_GUI_Qt/inner_libs/gui/SelectDirBox.py
import os
from PyQt5.QtWidgets import QWidget, QLineEdit, QLabel, QPushButton, QHBoxLa... | [
"PyQt5.QtCore.pyqtSignal",
"PyQt5.QtWidgets.QHBoxLayout",
"os.path.isdir",
"PyQt5.QtWidgets.QLabel",
"PyQt5.QtWidgets.QApplication",
"PyQt5.QtWidgets.QPushButton",
"os.startfile",
"PyQt5.QtWidgets.QLineEdit"
] | [((432, 447), 'PyQt5.QtCore.pyqtSignal', 'pyqtSignal', (['str'], {}), '(str)\n', (442, 447), False, 'from PyQt5.QtCore import pyqtSignal\n'), ((466, 481), 'PyQt5.QtCore.pyqtSignal', 'pyqtSignal', (['str'], {}), '(str)\n', (476, 481), False, 'from PyQt5.QtCore import pyqtSignal\n'), ((2350, 2366), 'PyQt5.QtWidgets.QAppl... |
'''
====================================================================
Copyright (c) 2016-2017 <NAME>. All rights reserved.
This software is licensed as described in the file LICENSE.txt,
which you should have received as part of this distribution.
=============================================================... | [
"pathlib.Path",
"wb_git_callback_server.WbGitCallbackServer",
"wb_annotate_node.AnnotateNode",
"pathlib.PurePosixPath",
"wb_platform_specific.getAppDir"
] | [((1105, 1152), 'wb_git_callback_server.WbGitCallbackServer', 'wb_git_callback_server.WbGitCallbackServer', (['app'], {}), '(app)\n', (1147, 1152), False, 'import wb_git_callback_server\n'), ((5252, 5274), 'pathlib.Path', 'pathlib.Path', (['str_path'], {}), '(str_path)\n', (5264, 5274), False, 'import pathlib\n'), ((56... |
import logging
import os
import random
import time
import datetime
import sys
import math
from screen import Screen
from scorer import Scorer
from trigger import Trigger
from psychopy import core, event, sound
from psychopy.hardware import keyboard
from pupil_labs import PupilCore
from datalog import Datalog
from conf... | [
"logging.basicConfig",
"psychopy.event.waitKeys",
"screen.Screen",
"os.path.join",
"pupil_labs.PupilCore",
"logging.info",
"datetime.datetime.now",
"psychopy.hardware.keyboard.Keyboard",
"sys.exit",
"psychopy.core.MonotonicClock",
"scorer.Scorer",
"trigger.Trigger",
"psychopy.core.wait"
] | [((503, 603), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': "CONF['loggingLevel']", 'format': '"""%(asctime)s-%(levelname)s-%(message)s"""'}), "(level=CONF['loggingLevel'], format=\n '%(asctime)s-%(levelname)s-%(message)s')\n", (522, 603), False, 'import logging\n'), ((784, 903), 'pupil_labs.PupilCore... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# This file is subject to the terms and conditions defined in
# file 'LICENSE.md', which is part of this source code package.
#
import time
import uuid
from kubernetes.K8sCronJob import K8sCronJob
from kubernetes.K8sPod import K8sPod
from kubernetes.models.v2alpha1.Cro... | [
"tests._utils.cleanup_cronjobs",
"kubernetes.K8sCronJob.K8sCronJob",
"tests._utils.cleanup_jobs",
"tests._utils.create_config",
"tests._utils.create_container",
"time.sleep",
"uuid.uuid4",
"tests._utils.create_cronjob",
"tests._utils.is_reachable",
"tests._constants.cronjob",
"tests._utils.clean... | [((563, 588), 'tests._utils.cleanup_cronjobs', '_utils.cleanup_cronjobs', ([], {}), '()\n', (586, 588), False, 'from tests import _utils\n'), ((597, 618), 'tests._utils.cleanup_jobs', '_utils.cleanup_jobs', ([], {}), '()\n', (616, 618), False, 'from tests import _utils\n'), ((627, 648), 'tests._utils.cleanup_pods', '_u... |
'''
This file implements various optimization methods, including
-- SGD with gradient norm clipping
-- AdaGrad
-- AdaDelta
-- Adam
Transparent to switch between CPU / GPU.
@author: <NAME> (<EMAIL>)
'''
import random
from collections import OrderedDict
import numpy as np
i... | [
"theano.tensor.Lop",
"collections.OrderedDict",
"theano.tensor.sqrt",
"theano.tensor.minimum",
"numpy.float64",
"theano.tensor.sqr",
"theano.tensor.set_subtensor",
"theano.tensor.inc_subtensor",
"theano.tensor.grad"
] | [((1566, 1580), 'theano.tensor.sqrt', 'T.sqrt', (['g_norm'], {}), '(g_norm)\n', (1572, 1580), True, 'import theano.tensor as T\n'), ((8330, 8361), 'theano.tensor.Lop', 'T.Lop', (['gparams', 'params', 'samples'], {}), '(gparams, params, samples)\n', (8335, 8361), True, 'import theano.tensor as T\n'), ((1419, 1439), 'the... |
import sys
from PyQt5.QtWidgets import QMainWindow
from PyQt5.QtGui import QPixmap, QIcon
from PyQt5 import uic
from internationalization import LANGUAGE
class Loose(QMainWindow):
def __init__(self, lang):
QMainWindow.__init__(self)
uic.loadUi("windows/Looser.ui", self)
self.lang = lang
... | [
"PyQt5.uic.loadUi",
"PyQt5.QtGui.QPixmap",
"PyQt5.QtWidgets.QMainWindow.__init__",
"internationalization.LANGUAGE.get"
] | [((219, 245), 'PyQt5.QtWidgets.QMainWindow.__init__', 'QMainWindow.__init__', (['self'], {}), '(self)\n', (239, 245), False, 'from PyQt5.QtWidgets import QMainWindow\n'), ((254, 291), 'PyQt5.uic.loadUi', 'uic.loadUi', (['"""windows/Looser.ui"""', 'self'], {}), "('windows/Looser.ui', self)\n", (264, 291), False, 'from P... |
import os
import subprocess
import time
class Asciicast(object):
def __init__(self, env=os.environ):
self.command = None
self.title = None
self.shell = env.get('SHELL', '/bin/sh')
self.term = env.get('TERM')
self.username = env.get('USER')
@property
def meta_data(... | [
"subprocess.Popen"
] | [((873, 919), 'subprocess.Popen', 'subprocess.Popen', (['args'], {'stdout': 'subprocess.PIPE'}), '(args, stdout=subprocess.PIPE)\n', (889, 919), False, 'import subprocess\n')] |
import sys
from pathlib import Path
import numpy as np
import pandas as pd
from bokeh.models import ColumnDataSource
from bokeh.io import export_png
from bokeh.plotting import figure
def plot_lifetime(df, type, path):
df = df.copy()
palette = ["#c9d9d3", "#718dbf", "#e84d60", "#648450"]
ylist = []
... | [
"numpy.abs",
"numpy.mean",
"bokeh.plotting.figure",
"pandas.merge",
"bokeh.models.ColumnDataSource",
"pandas.DataFrame",
"pandas.concat",
"numpy.arange"
] | [((1241, 1365), 'bokeh.plotting.figure', 'figure', ([], {'x_range': 'ylist', 'plot_height': '(250)', 'plot_width': '(1500)', 'title': "('Employment Status by age: West Germany / type: ' + type)"}), "(x_range=ylist, plot_height=250, plot_width=1500, title=\n 'Employment Status by age: West Germany / type: ' + type)\n... |
import unittest
import numpy as np
import openjij as oj
import cxxjij as cj
def calculate_ising_energy(h, J, spins):
energy = 0.0
for (i, j), Jij in J.items():
energy += Jij*spins[i]*spins[j]
for i, hi in h.items():
energy += hi * spins[i]
return energy
def calculate_qubo_energy(Q, ... | [
"openjij.cast_var_type",
"openjij.ChimeraModel",
"openjij.BinaryQuadraticModel",
"openjij.BinaryQuadraticModel.from_qubo",
"openjij.KingGraph",
"numpy.array",
"openjij.KingGraph.from_qubo",
"openjij.ChimeraModel.from_qubo",
"unittest.main",
"numpy.testing.assert_array_equal"
] | [((8441, 8456), 'unittest.main', 'unittest.main', ([], {}), '()\n', (8454, 8456), False, 'import unittest\n'), ((534, 558), 'openjij.cast_var_type', 'oj.cast_var_type', (['"""SPIN"""'], {}), "('SPIN')\n", (550, 558), True, 'import openjij as oj\n'), ((617, 643), 'openjij.cast_var_type', 'oj.cast_var_type', (['"""BINARY... |
from __future__ import absolute_import, division, print_function, unicode_literals
import os.path
import pytest
xr = pytest.importorskip('xarray') # noqa
from cfgrib import cfgrib_
SAMPLE_DATA_FOLDER = os.path.join(os.path.dirname(__file__), 'sample-data')
TEST_DATA = os.path.join(SAMPLE_DATA_FOLDER, 'era5-level... | [
"cfgrib.cfgrib_.SerializableLock",
"pytest.importorskip",
"cfgrib.cfgrib_.CfGribDataStore"
] | [((120, 149), 'pytest.importorskip', 'pytest.importorskip', (['"""xarray"""'], {}), "('xarray')\n", (139, 149), False, 'import pytest\n'), ((383, 431), 'cfgrib.cfgrib_.CfGribDataStore', 'cfgrib_.CfGribDataStore', (['TEST_DATA'], {'encode_cf': '()'}), '(TEST_DATA, encode_cf=())\n', (406, 431), False, 'from cfgrib import... |
#!/usr/bin/python2.5
#
# Copyright 2009 Google Inc.
#
# 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 ... | [
"django.utils.simplejson.loads",
"datetime.datetime",
"categories.all_test_sets.GetVisibleTestSets",
"categories.all_test_sets.AddTestSet",
"models.user_agent.UserAgent.factory",
"django.test.client.Client",
"models.result_stats.CategoryBrowserManager.UpdateSummaryBrowsers",
"models.result.ResultParen... | [((1634, 1642), 'django.test.client.Client', 'Client', ([], {}), '()\n', (1640, 1642), False, 'from django.test.client import Client\n'), ((1876, 1904), 'models.user_agent.UserAgent.factory', 'UserAgent.factory', (['ua_string'], {}), '(ua_string)\n', (1893, 1904), False, 'from models.user_agent import UserAgent\n'), ((... |
from __future__ import print_function
import os, sys
import pickle
import time
import glob
import numpy as np
import torch
from model import PVSE
from loss import cosine_sim, order_sim
from vocab import Vocabulary
from data import get_test_loader
from logger import AverageMeter
from option import parser, verify_input... | [
"model.PVSE",
"numpy.median",
"numpy.where",
"torch.load",
"numpy.tensordot",
"pickle.load",
"torch.cuda.device_count",
"torch.nn.DataParallel",
"torch.Tensor",
"os.path.isfile",
"numpy.argsort",
"data.get_test_loader",
"torch.cuda.is_available",
"numpy.zeros",
"numpy.dot",
"numpy.arra... | [((7270, 7298), 'data.get_test_loader', 'get_test_loader', (['args', 'vocab'], {}), '(args, vocab)\n', (7285, 7298), False, 'from data import get_test_loader\n'), ((10374, 10399), 'os.path.isfile', 'os.path.isfile', (['args.ckpt'], {}), '(args.ckpt)\n', (10388, 10399), False, 'import os, sys\n'), ((10410, 10436), 'mode... |
# Copyright (c) 2021 PaddlePaddle 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 appli... | [
"paddle.nn.LayerList",
"pycocotools.mask.merge",
"paddle.stack",
"paddle.nn.functional.interpolate",
"pycocotools.mask.frPyObjects",
"paddle.bmm",
"paddle.nn.functional.sigmoid",
"pycocotools.mask.decode",
"paddle.nn.initializer.XavierUniform",
"paddle.nn.Linear",
"paddle.nn.initializer.Constant... | [((2075, 2094), 'paddle.nn.Dropout', 'nn.Dropout', (['dropout'], {}), '(dropout)\n', (2085, 2094), True, 'import paddle.nn as nn\n'), ((2347, 2403), 'paddle.nn.Linear', 'nn.Linear', (['query_dim', 'hidden_dim', 'weight_attr', 'bias_attr'], {}), '(query_dim, hidden_dim, weight_attr, bias_attr)\n', (2356, 2403), True, 'i... |
import numpy as np
import pygame
import sys
import math
import random
from board import Board
from ai import Minimax_AI
# function to draw the board in pygame
def draw_board(board):
for c in range(COLUMN_COUNT):
for r in range(ROW_COUNT):
pygame.draw.rect(screen, colors["blue"], (c*SQUARESIZE,... | [
"random.choice",
"pygame.init",
"pygame.event.get",
"pygame.time.wait",
"pygame.display.set_mode",
"math.floor",
"board.Board",
"pygame.draw.rect",
"sys.exit",
"pygame.display.update",
"ai.Minimax_AI",
"pygame.font.SysFont"
] | [((1050, 1073), 'pygame.display.update', 'pygame.display.update', ([], {}), '()\n', (1071, 1073), False, 'import pygame\n'), ((1359, 1389), 'board.Board', 'Board', (['ROW_COUNT', 'COLUMN_COUNT'], {}), '(ROW_COUNT, COLUMN_COUNT)\n', (1364, 1389), False, 'from board import Board\n'), ((1480, 1502), 'random.choice', 'rand... |
#!/usr/bin/env python
#
# pyFlow - a lightweight parallel task engine
#
# Copyright (c) 2012-2017 Illumina, Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# 1. Redistributions of source ... | [
"sys.path.append",
"sys.exit"
] | [((1589, 1630), 'sys.path.append', 'sys.path.append', (["(scriptDir + '/../../src')"], {}), "(scriptDir + '/../../src')\n", (1604, 1630), False, 'import sys\n'), ((2561, 2577), 'sys.exit', 'sys.exit', (['retval'], {}), '(retval)\n', (2569, 2577), False, 'import sys\n')] |
import pandas as pd
from datetime import timedelta, date
import matplotlib.pyplot as plt
def daterange(start_date, end_date):
for n in range(int((end_date - start_date).days)):
yield start_date + timedelta(n)
def getFileByDate(date = 'latest'):
url = 'https://raw.githubusercontent.com/pcm-dpc/COVID-19/... | [
"pandas.read_csv",
"datetime.timedelta",
"matplotlib.pyplot.figure",
"datetime.date",
"datetime.date.today",
"matplotlib.pyplot.show"
] | [((1521, 1533), 'matplotlib.pyplot.figure', 'plt.figure', ([], {}), '()\n', (1531, 1533), True, 'import matplotlib.pyplot as plt\n'), ((1613, 1623), 'matplotlib.pyplot.show', 'plt.show', ([], {}), '()\n', (1621, 1623), True, 'import matplotlib.pyplot as plt\n'), ((403, 442), 'pandas.read_csv', 'pd.read_csv', (['url'], ... |
"""
Model select class1 single allele models.
"""
import argparse
import os
import signal
import sys
import time
import traceback
import random
from functools import partial
from pprint import pprint
import numpy
import pandas
from scipy.stats import kendalltau, percentileofscore, pearsonr
from sklearn.metrics import ... | [
"os.path.exists",
"scipy.stats.percentileofscore",
"random.shuffle",
"pandas.DataFrame",
"argparse.ArgumentParser",
"pandas.read_csv",
"traceback.print_stack",
"numpy.log",
"sklearn.metrics.roc_auc_score",
"pandas.concat",
"os.mkdir",
"os.getpid",
"functools.partial",
"os.path.abspath",
... | [((1157, 1195), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'usage': '__doc__'}), '(usage=__doc__)\n', (1180, 1195), False, 'import argparse\n'), ((5568, 5604), 'os.path.abspath', 'os.path.abspath', (['args.out_models_dir'], {}), '(args.out_models_dir)\n', (5583, 5604), False, 'import os\n'), ((12260, 1... |
import time
from adafruit_circuitplayground.express import cpx
import simpleio
cpx.pixels.auto_write = False
cpx.pixels.brightness = 0.3
# Set these based on your ambient temperature for best results!
minimum_temp = 24
maximum_temp = 30
while True:
# temperature value remapped to pixel position
peak = simple... | [
"adafruit_circuitplayground.express.cpx.pixels.show",
"simpleio.map_range",
"time.sleep"
] | [((314, 384), 'simpleio.map_range', 'simpleio.map_range', (['cpx.temperature', 'minimum_temp', 'maximum_temp', '(0)', '(10)'], {}), '(cpx.temperature, minimum_temp, maximum_temp, 0, 10)\n', (332, 384), False, 'import simpleio\n'), ((584, 601), 'adafruit_circuitplayground.express.cpx.pixels.show', 'cpx.pixels.show', ([]... |
############################################################
# Copyright 2019 <NAME>
# Licensed under the new BSD (3-clause) license:
#
# https://opensource.org/licenses/BSD-3-Clause
############################################################
############################################################
#
# Initial se... | [
"matplotlib.pyplot.gca",
"matplotlib.pyplot.plot",
"math.sqrt",
"scipy.stats.norm.rvs",
"math.log",
"numpy.random.seed",
"math.exp",
"scipy.stats.uniform.rvs",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.show"
] | [((2453, 2484), 'numpy.random.seed', 'numpy.random.seed', ([], {'seed': '(8675309)'}), '(seed=8675309)\n', (2470, 2484), False, 'import numpy\n'), ((3493, 3513), 'scipy.stats.norm.rvs', 'stats.norm.rvs', (['(0)', '(3)'], {}), '(0, 3)\n', (3507, 3513), True, 'import scipy.stats as stats\n'), ((3535, 3555), 'scipy.stats.... |
import vigorish.database as db
from vigorish.enums import DataSet, ScrapeCondition
from vigorish.scrape.brooks_pitchfx.parse_html import parse_pitchfx_log
from vigorish.scrape.scrape_task import ScrapeTaskABC
from vigorish.status.update_status_brooks_pitchfx import update_status_brooks_pitchfx_log
from vigorish.util.dt... | [
"vigorish.util.result.Result.Fail",
"vigorish.status.update_status_brooks_pitchfx.update_status_brooks_pitchfx_log",
"vigorish.database.DateScrapeStatus.verify_all_brooks_pitchfx_scraped_for_date",
"vigorish.scrape.brooks_pitchfx.parse_html.parse_pitchfx_log",
"vigorish.util.result.Result.Ok",
"vigorish.d... | [((690, 788), 'vigorish.database.DateScrapeStatus.verify_all_brooks_pitch_logs_scraped_for_date', 'db.DateScrapeStatus.verify_all_brooks_pitch_logs_scraped_for_date', (['self.db_session', 'game_date'], {}), '(self.\n db_session, game_date)\n', (755, 788), True, 'import vigorish.database as db\n'), ((1115, 1133), 'vi... |
import numpy as np
from torch import nn
def layer_init(layer, std=np.sqrt(2), bias_const=0.0):
"""
Simple function to init layers
"""
nn.init.orthogonal_(layer.weight, std)
nn.init.constant_(layer.bias, bias_const)
return layer
| [
"torch.nn.init.orthogonal_",
"numpy.sqrt",
"torch.nn.init.constant_"
] | [((68, 78), 'numpy.sqrt', 'np.sqrt', (['(2)'], {}), '(2)\n', (75, 78), True, 'import numpy as np\n'), ((152, 190), 'torch.nn.init.orthogonal_', 'nn.init.orthogonal_', (['layer.weight', 'std'], {}), '(layer.weight, std)\n', (171, 190), False, 'from torch import nn\n'), ((195, 236), 'torch.nn.init.constant_', 'nn.init.co... |
"""
Test script for src=9 provisioning
Below are some odd examples and notes:
Adding a class
{
'src': '9',
'uln': 'Githens',
'ufn': 'Steven',
'aid': '56021',
'utp': '2',
'said': '56021',
'fid': '2',
'username': 'swgithen',
'ctl': 'CourseTitleb018b622-b425-4af7-bb3d-d0d2b4deb35c',
'diagnost... | [
"unittest.TestSuite",
"java.net.InetAddress.getByName",
"java.util.HashMap",
"org.sakaiproject.component.cover.ComponentManager.get",
"unittest.TextTestRunner",
"unittest.TestLoader"
] | [((3507, 3595), 'org.sakaiproject.component.cover.ComponentManager.get', 'ComponentManager.get', (['"""org.sakaiproject.contentreview.service.ContentReviewService"""'], {}), "(\n 'org.sakaiproject.contentreview.service.ContentReviewService')\n", (3527, 3595), False, 'from org.sakaiproject.component.cover import Comp... |
import logging
from collections import Generator
from typing import Dict
from spanner import ems_spanner_client
from tenacity import retry, stop_after_attempt, wait_fixed
class SpannerChecker:
STOP_AFTER_ATTEMPT_SECS = 15
WAIT_FIXED = 3
def __init__(self, project_id: str, instance_id: str, db_name: str)... | [
"tenacity.wait_fixed",
"logging.info",
"spanner.ems_spanner_client.EmsSpannerClient",
"tenacity.stop_after_attempt"
] | [((353, 422), 'spanner.ems_spanner_client.EmsSpannerClient', 'ems_spanner_client.EmsSpannerClient', (['project_id', 'instance_id', 'db_name'], {}), '(project_id, instance_id, db_name)\n', (388, 422), False, 'from spanner import ems_spanner_client\n'), ((484, 525), 'logging.info', 'logging.info', (['f"""Executing query:... |
from typing import Any
from click import echo, style
def out(message: str, new_line: bool = True, **styles: Any) -> None:
if "bold" not in styles:
styles["bold"] = True
message = style(message, **styles)
echo(message, nl=new_line)
def err(message: str, new_line: bool = True, **styles: Any) -... | [
"click.echo",
"click.style"
] | [((230, 256), 'click.echo', 'echo', (['message'], {'nl': 'new_line'}), '(message, nl=new_line)\n', (234, 256), False, 'from click import echo, style\n'), ((431, 457), 'click.echo', 'echo', (['message'], {'nl': 'new_line'}), '(message, nl=new_line)\n', (435, 457), False, 'from click import echo, style\n'), ((201, 225), ... |
from django.db.models.signals import m2m_changed
from django.dispatch import receiver
from .models import Image
@receiver(m2m_changed, sender=Image.users_likes.through)
def users_like_changed(sender, instance, **kwargs):
instance.total_likes = instance.users_likes.count()
instance.save()
| [
"django.dispatch.receiver"
] | [((114, 169), 'django.dispatch.receiver', 'receiver', (['m2m_changed'], {'sender': 'Image.users_likes.through'}), '(m2m_changed, sender=Image.users_likes.through)\n', (122, 169), False, 'from django.dispatch import receiver\n')] |
import random
from typing import List, Union
import torch
import torchvision.transforms as T
import torchvision.transforms.functional as F
from PIL import Image
class RandomDiscreteRotation():
def __init__(self, angles, resample=0, expand=False):
self.angles = angles
self.resample = resample
... | [
"torchvision.transforms.functional.adjust_gamma",
"torchvision.transforms.functional.to_tensor",
"random.choice",
"torchvision.transforms.functional.hflip",
"torchvision.transforms.ColorJitter",
"torchvision.transforms.functional.rotate",
"torch.tensor",
"torchvision.transforms.functional.vflip",
"t... | [((518, 544), 'random.choice', 'random.choice', (['self.angles'], {}), '(self.angles)\n', (531, 544), False, 'import random\n'), ((561, 611), 'torchvision.transforms.functional.rotate', 'F.rotate', (['image', 'angle', 'self.resample', 'self.expand'], {}), '(image, angle, self.resample, self.expand)\n', (569, 611), True... |
import pandas as pd
# Wczytaj do DataFrame arkusz z narodzinami dzieci
# w Polsce dostępny pod adresem
df = pd.read_csv('Imiona_dzieci_2000-2019.csv')
| [
"pandas.read_csv"
] | [((111, 153), 'pandas.read_csv', 'pd.read_csv', (['"""Imiona_dzieci_2000-2019.csv"""'], {}), "('Imiona_dzieci_2000-2019.csv')\n", (122, 153), True, 'import pandas as pd\n')] |
# emacs: -*- mode: python; py-indent-offset: 4; indent-tabs-mode: nil -*-
# vi: set ft=python sts=4 ts=4 sw=4 et:
### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
#
# See COPYING file distributed along with the PyMVPA package for the
# copyright and license terms.
#
### ### ### ### ###... | [
"numpy.abs",
"numpy.eye",
"numpy.random.random",
"mvpa2.base.externals.exists",
"unittest.makeSuite",
"itertools.product",
"mvpa2.datasets.base.dataset_wizard",
"numpy.linalg.det",
"numpy.dot",
"numpy.linalg.norm",
"mvpa2.testing.datasets.get_random_rotation",
"mvpa2.mappers.procrustean.Procru... | [((733, 765), 'mvpa2.base.externals.exists', 'externals.exists', (['"""liblapack.so"""'], {}), "('liblapack.so')\n", (749, 765), False, 'from mvpa2.base import externals\n'), ((793, 818), 'mvpa2.base.externals.exists', 'externals.exists', (['"""scipy"""'], {}), "('scipy')\n", (809, 818), False, 'from mvpa2.base import ... |
# Generated by Django 2.2.7 on 2019-12-15 12:15
from django.db import migrations, models
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
migrations.CreateModel(
name='Warframe',
fields=[
('id', models.AutoField... | [
"django.db.models.FloatField",
"django.db.models.IntegerField",
"django.db.models.AutoField",
"django.db.models.URLField",
"django.db.models.CharField"
] | [((304, 355), 'django.db.models.AutoField', 'models.AutoField', ([], {'primary_key': '(True)', 'serialize': '(False)'}), '(primary_key=True, serialize=False)\n', (320, 355), False, 'from django.db import migrations, models\n'), ((383, 428), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(100)', ... |
#!/pxrpythonsubst
#
# Copyright 2016 Pixar
#
# Licensed under the Apache License, Version 2.0 (the "Apache License")
# with the following modification; you may not use this file except in
# compliance with the Apache License and the following modification to it:
# Section 6. Trademarks. is deleted and replaced with:
#
... | [
"logging.getLogger",
"pxr.Tf.MakeValidIdentifier",
"pxr.Tf.IsValidIdentifier",
"pxr.Tf.DictionaryStrcmp",
"pxr.Tf.StringSplit",
"pxr.Tf._GetLongMax",
"pxr.Tf._GetULongMax",
"pxr.Tf._GetLongMin",
"unittest.main"
] | [((5274, 5289), 'unittest.main', 'unittest.main', ([], {}), '()\n', (5287, 5289), False, 'import unittest\n'), ((1307, 1326), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (1324, 1326), False, 'import logging\n'), ((1581, 1603), 'pxr.Tf.StringSplit', 'Tf.StringSplit', (['""""""', '""""""'], {}), "('', '')... |
# coding: utf-8
# Copyright (c) 2016, 2020, Oracle and/or its affiliates. All rights reserved.
# This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may c... | [
"oci.util.formatted_flat_dict"
] | [((2974, 2999), 'oci.util.formatted_flat_dict', 'formatted_flat_dict', (['self'], {}), '(self)\n', (2993, 2999), False, 'from oci.util import formatted_flat_dict, NONE_SENTINEL, value_allowed_none_or_none_sentinel\n')] |
import bpy
import numpy as np
import math
import mathutils
import time
import os
class Prism:
""" ^"""
""" / \\"""
""" / ^ \\"""
""" / | \\"""
""" /'alpha'\\ <-- lenght of this side is calculated based on 'width' and 'alpha'"""
"""/ \\"""
"""-------... | [
"bpy.ops.object.delete",
"mathutils.Vector",
"numpy.tan",
"bpy.ops.object.select_all",
"bpy.data.objects.new",
"bpy.data.meshes.new",
"math.radians",
"bpy.context.collection.objects.link"
] | [((732, 751), 'math.radians', 'math.radians', (['alpha'], {}), '(alpha)\n', (744, 751), False, 'import math\n'), ((877, 919), 'bpy.ops.object.select_all', 'bpy.ops.object.select_all', ([], {'action': '"""SELECT"""'}), "(action='SELECT')\n", (902, 919), False, 'import bpy\n'), ((929, 968), 'bpy.ops.object.delete', 'bpy.... |
# -*- coding: utf-8 -*-
from setuptools import setup, find_packages
with open('requirements.txt') as f:
install_requires = f.read().strip().split('\n')
# get version from __version__ variable in proceso/__init__.py
from proceso import __version__ as version
setup(
name='proceso',
version=version,
description='A ... | [
"setuptools.find_packages"
] | [((405, 420), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (418, 420), False, 'from setuptools import setup, find_packages\n')] |
# -*- coding: utf-8 -*-
# Copyright (c) 2013 <NAME> <<EMAIL>>
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, mo... | [
"email.mime.base.MIMEBase",
"re.compile",
"email.encoders.encode_base64",
"email.mime.multipart.MIMEMultipart",
"mimetypes.guess_type",
"email.header.Header",
"email.mime.text.MIMEText"
] | [((3070, 3106), 're.compile', 're.compile', (['"""^(.*) <([^@]+@[^@]+)>$"""'], {}), "('^(.*) <([^@]+@[^@]+)>$')\n", (3080, 3106), False, 'import re\n'), ((8321, 8349), 'email.mime.multipart.MIMEMultipart', 'MIMEMultipart', (['"""alternative"""'], {}), "('alternative')\n", (8334, 8349), False, 'from email.mime.multipart... |
import types
import tkinter
import Pmw
import sys
import collections
class OptionMenu(Pmw.MegaWidget):
def __init__(self, parent = None, **kw):
# Define the megawidget options.
INITOPT = Pmw.INITOPT
optiondefs = (
('command', None, None),
('items', ... | [
"Pmw.MegaWidget.__init__"
] | [((688, 725), 'Pmw.MegaWidget.__init__', 'Pmw.MegaWidget.__init__', (['self', 'parent'], {}), '(self, parent)\n', (711, 725), False, 'import Pmw\n')] |
import os
from pypdflite.pdflite import PDFLite
from pypdflite.pdfobjects.pdfcolor import PDFColor
def TableTest(test_dir):
""" Functional test for text, paragraph, and page
splitting.
"""
data = [["Heading1", "Heading2", "Heading3"],
["Cell a2", "Cell b2", "Cell c2"],
... | [
"pypdflite.pdfobjects.pdfcolor.PDFColor",
"os.path.join"
] | [((1161, 1183), 'pypdflite.pdfobjects.pdfcolor.PDFColor', 'PDFColor', ([], {'name': '"""green"""'}), "(name='green')\n", (1169, 1183), False, 'from pypdflite.pdfobjects.pdfcolor import PDFColor\n'), ((450, 495), 'os.path.join', 'os.path.join', (['test_dir', '"""tests/TableTest.pdf"""'], {}), "(test_dir, 'tests/TableTes... |
from typing import List, Optional
from pydantic import BaseModel
from pydantic import validator
class CrossReferenceSchemaRelated(BaseModel):
curie: str
pages: Optional[List[str]] = None
is_obsolete: Optional[bool] = None
@validator('curie')
def name_must_contain_space(cls, v):
if v.coun... | [
"pydantic.validator"
] | [((243, 261), 'pydantic.validator', 'validator', (['"""curie"""'], {}), "('curie')\n", (252, 261), False, 'from pydantic import validator\n')] |
# -*- coding: utf-8 -*-
# Generated by the protocol buffer compiler. DO NOT EDIT!
# source: syft_proto/frameworks/crypten/onnx_model.proto
from google.protobuf import descriptor as _descriptor
from google.protobuf import message as _message
from google.protobuf import reflection as _reflection
from google.protobuf im... | [
"google.protobuf.reflection.GeneratedProtocolMessageType",
"google.protobuf.symbol_database.Default",
"google.protobuf.descriptor.FieldDescriptor",
"google.protobuf.descriptor.FileDescriptor"
] | [((408, 434), 'google.protobuf.symbol_database.Default', '_symbol_database.Default', ([], {}), '()\n', (432, 434), True, 'from google.protobuf import symbol_database as _symbol_database\n'), ((549, 1461), 'google.protobuf.descriptor.FileDescriptor', '_descriptor.FileDescriptor', ([], {'name': '"""syft_proto/frameworks/... |
# -*-coding:Utf-8 -*
# Copyright (c) 2010-2017 <NAME>
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright notice, this
# list ... | [
"primaires.communication.contextes.invitation.Invitation",
"primaires.interpreteur.contexte.Contexte.__init__",
"primaires.interpreteur.contexte.Contexte.__getstate__",
"primaires.interpreteur.contexte.Contexte.__setstate__"
] | [((1995, 2024), 'primaires.interpreteur.contexte.Contexte.__init__', 'Contexte.__init__', (['self', 'pere'], {}), '(self, pere)\n', (2012, 2024), False, 'from primaires.interpreteur.contexte import Contexte\n'), ((2714, 2741), 'primaires.interpreteur.contexte.Contexte.__getstate__', 'Contexte.__getstate__', (['self'], ... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Jan 13 12:07:22 2020
@author: medrclaa
Stand alone script for testing arc in ARC. simply run
pytest arc_test.py
To ensure the working environment is suitable for running experiments.
If you only wish to run a single experiment then you an easily ha... | [
"modules.ukf_fx.HiddenPrints",
"os.getcwd",
"os.chdir",
"arc.arc.main",
"unittest.main"
] | [((623, 637), 'os.chdir', 'os.chdir', (['""".."""'], {}), "('..')\n", (631, 637), False, 'import os\n'), ((2089, 2104), 'unittest.main', 'unittest.main', ([], {}), '()\n', (2102, 2104), False, 'import unittest\n'), ((581, 592), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (590, 592), False, 'import os\n'), ((1286, 1300)... |
import os
from pathlib import Path
from typing import List
from challenges.day3 import frequency_character
def _read_input() -> List[str]:
"""Read the input file."""
travel_map = []
current_path = Path(os.path.dirname(os.path.realpath(__file__)))
image_path = current_path / "resources" / "day3_puzzle_... | [
"os.path.realpath",
"challenges.day3.frequency_character"
] | [((798, 858), 'challenges.day3.frequency_character', 'frequency_character', (['sample_input'], {'right': '(3)', 'down': '(1)', 'char': '"""#"""'}), "(sample_input, right=3, down=1, char='#')\n", (817, 858), False, 'from challenges.day3 import frequency_character\n'), ((987, 1044), 'challenges.day3.frequency_character',... |
# -*- coding: utf-8 -*-
import pytest
from raiden.messages import Ping, Ack, decode, Lock, MediatedTransfer
from raiden.utils import make_privkey_address, sha3
PRIVKEY, ADDRESS = make_privkey_address()
def test_signature():
ping = Ping(nonce=0)
ping.sign(PRIVKEY, ADDRESS)
assert ping.sender == ADDRESS
... | [
"raiden.messages.MediatedTransfer",
"raiden.messages.Ping",
"raiden.messages.Ack",
"raiden.utils.sha3",
"raiden.utils.make_privkey_address",
"pytest.mark.parametrize",
"raiden.messages.Lock",
"raiden.messages.decode",
"pytest.raises"
] | [((180, 202), 'raiden.utils.make_privkey_address', 'make_privkey_address', ([], {}), '()\n', (200, 202), False, 'from raiden.utils import make_privkey_address, sha3\n'), ((2841, 2890), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""amount"""', '[-1, 2 ** 256]'], {}), "('amount', [-1, 2 ** 256])\n", (2864, ... |
import pytest
from billy.utils.search import google_book_search
class TestGoogleBookSearch(object):
def test_search_returns_200(self, mock):
"""Ensure a basic search returns a 200 request"""
assert google_book_search("<NAME>")["status"] == 200
def test_search_body_returns_dict(self, mock):
... | [
"billy.utils.search.google_book_search"
] | [((220, 248), 'billy.utils.search.google_book_search', 'google_book_search', (['"""<NAME>"""'], {}), "('<NAME>')\n", (238, 248), False, 'from billy.utils.search import google_book_search\n'), ((416, 444), 'billy.utils.search.google_book_search', 'google_book_search', (['"""<NAME>"""'], {}), "('<NAME>')\n", (434, 444), ... |
import math
class Config_1:
DATASET_ROOT_DIR = '../data/test1/Data' # The data set root directory
DATASET_SCALE = 0 # How many users' trajectory data are choosed
TRAJACTORY_SCALE = 20 # How many trajectories are choosed per user
RANGE = { # To... | [
"math.log"
] | [((746, 775), 'math.log', 'math.log', (['COHERENCE_THRESHOLD'], {}), '(COHERENCE_THRESHOLD)\n', (754, 775), False, 'import math\n'), ((1698, 1727), 'math.log', 'math.log', (['COHERENCE_THRESHOLD'], {}), '(COHERENCE_THRESHOLD)\n', (1706, 1727), False, 'import math\n'), ((2486, 2515), 'math.log', 'math.log', (['COHERENCE... |
import os
import psutil
import time
def process_time():
p = psutil.Process(os.getpid())
return time.time() - p.create_time()
| [
"time.time",
"os.getpid"
] | [((81, 92), 'os.getpid', 'os.getpid', ([], {}), '()\n', (90, 92), False, 'import os\n'), ((105, 116), 'time.time', 'time.time', ([], {}), '()\n', (114, 116), False, 'import time\n')] |
import discord
from discord.ext import commands
from discord.utils import get
class c269(commands.Cog, name="c269"):
def __init__(self, bot: commands.Bot):
self.bot = bot
@commands.command(name='Vir_the_True_Elementalist', aliases=['c269', 'Elementalist_1', 'Distasta_Master_1'])
async def exam... | [
"discord.Embed",
"discord.ext.commands.command"
] | [((190, 301), 'discord.ext.commands.command', 'commands.command', ([], {'name': '"""Vir_the_True_Elementalist"""', 'aliases': "['c269', 'Elementalist_1', 'Distasta_Master_1']"}), "(name='Vir_the_True_Elementalist', aliases=['c269',\n 'Elementalist_1', 'Distasta_Master_1'])\n", (206, 301), False, 'from discord.ext im... |
"""
This example shows some more complex querying
Key points are filtering by related names and using Q objects
"""
import asyncio
from tortoise import Tortoise, fields
from tortoise.models import Model
from tortoise.query_utils import Q
class Tournament(Model):
id = fields.IntField(pk=True)
name = fields.T... | [
"tortoise.Tortoise.generate_schemas",
"tortoise.fields.ManyToManyField",
"tortoise.fields.IntField",
"tortoise.query_utils.Q",
"tortoise.fields.ForeignKeyField",
"asyncio.get_event_loop",
"tortoise.fields.TextField",
"tortoise.Tortoise.init"
] | [((276, 300), 'tortoise.fields.IntField', 'fields.IntField', ([], {'pk': '(True)'}), '(pk=True)\n', (291, 300), False, 'from tortoise import Tortoise, fields\n'), ((312, 330), 'tortoise.fields.TextField', 'fields.TextField', ([], {}), '()\n', (328, 330), False, 'from tortoise import Tortoise, fields\n'), ((411, 435), '... |
import os
from remotepixel import cbers_ndvi
CBERS_SCENE = "CBERS_4_MUX_20171121_057_094_L2"
CBERS_BUCKET = os.path.join(os.path.dirname(__file__), "fixtures", "cbers-pds")
CBERS_PATH = os.path.join(
CBERS_BUCKET, "CBERS4/MUX/057/094/CBERS_4_MUX_20171121_057_094_L2/"
)
def test_point_valid(monkeypatch):
""... | [
"remotepixel.cbers_ndvi.point",
"os.path.dirname",
"os.path.join",
"remotepixel.cbers_ndvi.area"
] | [((189, 274), 'os.path.join', 'os.path.join', (['CBERS_BUCKET', '"""CBERS4/MUX/057/094/CBERS_4_MUX_20171121_057_094_L2/"""'], {}), "(CBERS_BUCKET,\n 'CBERS4/MUX/057/094/CBERS_4_MUX_20171121_057_094_L2/')\n", (201, 274), False, 'import os\n'), ((124, 149), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(_... |
#!/usr/bin/env python
#
# __COPYRIGHT__
#
# Permission is hereby granted, free of charge, to any person obtaining
# a copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merge, publish,
... | [
"TestSCons_time.TestSCons_time"
] | [((1367, 1398), 'TestSCons_time.TestSCons_time', 'TestSCons_time.TestSCons_time', ([], {}), '()\n', (1396, 1398), False, 'import TestSCons_time\n')] |
"""
The container to store indexes in active learning.
Serve as the basic type of 'set' operation.
"""
# Authors: <NAME>
# License: BSD 3 clause
from __future__ import division
import collections
import copy
import numpy as np
from .multi_label_tools import check_index_multilabel, infer_label_size_multilabel, flatt... | [
"numpy.unique",
"numpy.asarray",
"numpy.zeros",
"numpy.argwhere",
"numpy.unravel_index",
"numpy.nonzero",
"copy.deepcopy"
] | [((3255, 3290), 'copy.deepcopy', 'copy.deepcopy', (['self._innercontainer'], {}), '(self._innercontainer)\n', (3268, 3290), False, 'import copy\n'), ((16509, 16558), 'numpy.unique', 'np.unique', (['[tp[0] for tp in self._innercontainer]'], {}), '([tp[0] for tp in self._innercontainer])\n', (16518, 16558), True, 'import... |
import platform as p
import uuid
import hashlib
def basic():
sb = []
sb.append(p.node())
sb.append( ''.join([ x for x in p.architecture() ]) )
sb.append(p.machine())
sb.append(p.processor())
sb.append(p.system())
sb.append(str(uuid.getnode())) # MAC address
text = '.'.join(sb)
retu... | [
"platform.node",
"uuid.getnode",
"platform.system",
"platform.architecture",
"platform.processor",
"platform.machine"
] | [((89, 97), 'platform.node', 'p.node', ([], {}), '()\n', (95, 97), True, 'import platform as p\n'), ((171, 182), 'platform.machine', 'p.machine', ([], {}), '()\n', (180, 182), True, 'import platform as p\n'), ((198, 211), 'platform.processor', 'p.processor', ([], {}), '()\n', (209, 211), True, 'import platform as p\n')... |
url = "https://www.delish.com/cooking/recipe-ideas/recipes/a53823/easy-pad-thai-recipe/"
url2 = "https://www.allrecipes.com/recipe/92462/slow-cooker-texas-pulled-pork/"
# opener = urllib.URLopener()
# opener.addheader(('User-Agent', 'Mozilla/5.0'))
# f = urllib.urlopen(url)
import requests
import html2text
h = html2... | [
"html2text.HTML2Text",
"requests.get"
] | [((315, 336), 'html2text.HTML2Text', 'html2text.HTML2Text', ([], {}), '()\n', (334, 336), False, 'import html2text\n'), ((363, 381), 'requests.get', 'requests.get', (['url2'], {}), '(url2)\n', (375, 381), False, 'import requests\n')] |
#!/usr/bin/env python
from __future__ import print_function
import inspect
import logging
import os
import platform
import sys
from time import sleep
from flaky import flaky
import pytest
import requests
from jira_test_manager import JiraTestManager
# _non_parallel is used to prevent some tests from failing due to ... | [
"logging.getLogger",
"sys.path.insert",
"unittest2.main",
"jira_test_manager.JiraTestManager",
"inspect.currentframe",
"os.path.join",
"time.sleep",
"requests.get",
"os.path.dirname",
"pytest.mark.skipif",
"logging.info",
"platform.python_version",
"pip.main"
] | [((1265, 1290), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (1280, 1290), False, 'import os\n'), ((1308, 1343), 'os.path.join', 'os.path.join', (['TEST_ROOT', '"""icon.png"""'], {}), "(TEST_ROOT, 'icon.png')\n", (1320, 1343), False, 'import os\n'), ((1363, 1398), 'os.path.join', 'os.path.j... |
# -*- coding: utf-8 -*-
from __future__ import absolute_import, print_function, unicode_literals
import datetime
import decimal
import platform
import sys
import types
from itertools import chain
#stripped version of SIX
PY2 = sys.version_info[0] == 2
PY3 = sys.version_info[0] == 3
PY_35 = sys.version_info >= (3, 5... | [
"itertools.chain",
"platform.system",
"sys.platform.startswith"
] | [((519, 550), 'sys.platform.startswith', 'sys.platform.startswith', (['"""java"""'], {}), "('java')\n", (542, 550), False, 'import sys\n'), ((403, 420), 'platform.system', 'platform.system', ([], {}), '()\n', (418, 420), False, 'import platform\n'), ((442, 459), 'platform.system', 'platform.system', ([], {}), '()\n', (... |
import argparse
from sklearn.decomposition import LatentDirichletAllocation as LDA
import pickle
from biom import load_table
def main(args):
model = LDA(n_components=args.n_latent, max_iter=args.iterations,
verbose=1, learning_method='online')
table = load_table(args.train_biom)
X = table.... | [
"biom.load_table",
"sklearn.decomposition.LatentDirichletAllocation",
"pickle.dump",
"argparse.ArgumentParser"
] | [((155, 253), 'sklearn.decomposition.LatentDirichletAllocation', 'LDA', ([], {'n_components': 'args.n_latent', 'max_iter': 'args.iterations', 'verbose': '(1)', 'learning_method': '"""online"""'}), "(n_components=args.n_latent, max_iter=args.iterations, verbose=1,\n learning_method='online')\n", (158, 253), True, 'fr... |
import argparse
from datetime import datetime
import os
from catalyst import dl, utils
from catalyst.contrib.data import AllTripletsSampler
from catalyst.contrib.losses import TripletMarginLossWithSampler
from catalyst.data import BatchBalanceClassSampler
from torch import nn, optim
from torch.utils.data import DataLo... | [
"torch.nn.CrossEntropyLoss",
"catalyst.dl.MetricAggregationCallback",
"catalyst.contrib.data.AllTripletsSampler",
"catalyst.dl.SchedulerCallback",
"argparse.ArgumentParser",
"catalyst.dl.OptimizerCallback",
"torchvision.transforms.ToTensor",
"catalyst.dl.ConsoleLogger",
"src.modules.resnet9",
"tor... | [((1729, 1800), 'catalyst.data.BatchBalanceClassSampler', 'BatchBalanceClassSampler', ([], {'labels': 'labels', 'num_classes': '(10)', 'num_samples': '(10)'}), '(labels=labels, num_classes=10, num_samples=10)\n', (1753, 1800), False, 'from catalyst.data import BatchBalanceClassSampler\n'), ((2047, 2085), 'src.modules.r... |
import pandas as pd
import rapidfuzz
import math
import numpy as np
# ------------------------- #
# --------- DATA ---------- #
# ------------------------- #
# Read in mock census and PES data
CEN = pd.read_csv('Data/Mock_Rwanda_Data_Census.csv')
PES = pd.read_csv('Data/Mock_Rwanda_Data_Pes.csv')
# select ne... | [
"rapidfuzz.string_metric.normalized_levenshtein",
"pandas.read_csv",
"numpy.where",
"math.log2",
"numpy.maximum"
] | [((209, 256), 'pandas.read_csv', 'pd.read_csv', (['"""Data/Mock_Rwanda_Data_Census.csv"""'], {}), "('Data/Mock_Rwanda_Data_Census.csv')\n", (220, 256), True, 'import pandas as pd\n'), ((263, 307), 'pandas.read_csv', 'pd.read_csv', (['"""Data/Mock_Rwanda_Data_Pes.csv"""'], {}), "('Data/Mock_Rwanda_Data_Pes.csv')\n", (27... |
import os
import pandas as pd
import spacy
from sklearn.feature_extraction.text import CountVectorizer
import datetime
import numpy as np
from processing import get_annee_scolaire
if __name__ == "__main__":
#print("files", os.listdir("data_processed"))
##########################
# Chargement des donné... | [
"pandas.read_pickle",
"sklearn.feature_extraction.text.CountVectorizer",
"spacy.load",
"datetime.datetime.strptime",
"os.path.join",
"pandas.DataFrame"
] | [((368, 411), 'os.path.join', 'os.path.join', (['"""data_processed"""', '"""greves.pk"""'], {}), "('data_processed', 'greves.pk')\n", (380, 411), False, 'import os\n'), ((420, 442), 'pandas.read_pickle', 'pd.read_pickle', (['path_g'], {}), '(path_g)\n', (434, 442), True, 'import pandas as pd\n'), ((583, 625), 'os.path.... |
from torch import nn
from torchvision.models.detection.backbone_utils import resnet_fpn_backbone
from torchvision.models.utils import load_state_dict_from_url
from .utils import pooling
from .utils.class_head import ClassificationHead
class FasterRCNN_FPN(nn.Module):
"""
A Faster R-CNN FPN inspired parking l... | [
"torchvision.models.utils.load_state_dict_from_url",
"torchvision.models.detection.backbone_utils.resnet_fpn_backbone"
] | [((698, 746), 'torchvision.models.detection.backbone_utils.resnet_fpn_backbone', 'resnet_fpn_backbone', (['"""resnet50"""'], {'pretrained': '(True)'}), "('resnet50', pretrained=True)\n", (717, 746), False, 'from torchvision.models.detection.backbone_utils import resnet_fpn_backbone\n'), ((1295, 1348), 'torchvision.mode... |
from resources import Resources
import configparser
def getConfigEntry(group, item):
entry = None
if group != None and item != None:
config = configparser.ConfigParser()
try:
config.read(Resources.getConfigFile())
except(FileNotFoundError):
print("ERROR: File '"... | [
"resources.Resources.getConfigFile",
"configparser.ConfigParser"
] | [((160, 187), 'configparser.ConfigParser', 'configparser.ConfigParser', ([], {}), '()\n', (185, 187), False, 'import configparser\n'), ((225, 250), 'resources.Resources.getConfigFile', 'Resources.getConfigFile', ([], {}), '()\n', (248, 250), False, 'from resources import Resources\n'), ((323, 348), 'resources.Resources... |
# -*- coding: utf-8 -*-
import os
import configparser
import glob
import sqlite3
import traceback
import json
from bottle import route, run, auth_basic, abort, response
from sqlite3 import OperationalError
config = configparser.ConfigParser()
config.read('config/config.ini')
def VERIFY(username, password):
retur... | [
"json.loads",
"configparser.ConfigParser",
"bottle.route",
"traceback.print_exc",
"os.path.isdir",
"bottle.abort",
"bottle.auth_basic",
"bottle.run",
"glob.glob"
] | [((217, 244), 'configparser.ConfigParser', 'configparser.ConfigParser', ([], {}), '()\n', (242, 244), False, 'import configparser\n'), ((396, 406), 'bottle.route', 'route', (['"""/"""'], {}), "('/')\n", (401, 406), False, 'from bottle import route, run, auth_basic, abort, response\n'), ((408, 426), 'bottle.auth_basic',... |