code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
import pandas
import os
from subprocess import check_output
worldclim_dir = "/Users/mperry/data/worldclim"
OUTDIR = os.path.join(worldclim_dir, "stacked")
def make_stack(variable, period, month, rcp, paths):
outpath = os.path.join(OUTDIR,
"{}_{}_{}_{}_stack.tif".format(variable, period,... | [
"pandas.read_csv",
"subprocess.check_output",
"os.path.join",
"os.path.exists"
] | [((117, 155), 'os.path.join', 'os.path.join', (['worldclim_dir', '"""stacked"""'], {}), "(worldclim_dir, 'stacked')\n", (129, 155), False, 'import os\n'), ((760, 798), 'pandas.read_csv', 'pandas.read_csv', (['"""../climate_data.csv"""'], {}), "('../climate_data.csv')\n", (775, 798), False, 'import pandas\n'), ((345, 36... |
#! /usr/bin/python
# See README.txt for information and build instructions.
import run_params_pb2
import sys
from google.protobuf.text_format import MessageToString, Merge
import argparse
arg_parser = argparse.ArgumentParser("Create a definitions file for run_params")
arg_parser.add_argument('output_file', help='Pat... | [
"run_params_pb2.params",
"google.protobuf.text_format.MessageToString",
"argparse.ArgumentParser"
] | [((204, 271), 'argparse.ArgumentParser', 'argparse.ArgumentParser', (['"""Create a definitions file for run_params"""'], {}), "('Create a definitions file for run_params')\n", (227, 271), False, 'import argparse\n'), ((386, 409), 'run_params_pb2.params', 'run_params_pb2.params', ([], {}), '()\n', (407, 409), False, 'im... |
import pytest
from django.test import Client
from pollaris.app.models import SearchLog
def post_to_search_log(payload):
return Client().post("/api/v1/search/log", payload, content_type="application/json")
@pytest.mark.django_db
def test_search_log_request_search_string():
payload = {
"address_enter... | [
"pollaris.app.models.SearchLog.objects.all",
"django.test.Client"
] | [((574, 597), 'pollaris.app.models.SearchLog.objects.all', 'SearchLog.objects.all', ([], {}), '()\n', (595, 597), False, 'from pollaris.app.models import SearchLog\n'), ((1450, 1473), 'pollaris.app.models.SearchLog.objects.all', 'SearchLog.objects.all', ([], {}), '()\n', (1471, 1473), False, 'from pollaris.app.models i... |
"""Main plotting module."""
import math
import locale
import matplotlib as mpl
import matplotlib.pyplot as plt
from matplotlib.backends.backend_pdf import PdfPages
def init_params(german_labels=True, font_size=20, font_family='Carlito',
pdf_padding=0.1, pdf_bbox='tight', pdf_fonttype=42,
... | [
"matplotlib.backends.backend_pdf.PdfPages",
"matplotlib.pyplot.close",
"matplotlib.rcParams.update",
"math.floor",
"matplotlib.pyplot.figure",
"locale.setlocale",
"matplotlib.pyplot.get_fignums",
"matplotlib.pyplot.subplots"
] | [((4561, 4590), 'matplotlib.pyplot.subplots', 'plt.subplots', ([], {'figsize': 'figsize'}), '(figsize=figsize)\n', (4573, 4590), True, 'import matplotlib.pyplot as plt\n'), ((6819, 6848), 'matplotlib.pyplot.subplots', 'plt.subplots', ([], {'figsize': 'figsize'}), '(figsize=figsize)\n', (6831, 6848), True, 'import matpl... |
#!/usr/bin/env python
# coding: utf-8
# ### Module Import
# In[4]:
from for_CL7_use import NbaPlayer
nba = NbaPlayer()
nba.add_player('<NAME>', 'Los Angeles Lakers', 36)
nba.add_player('<NAME>', '<NAME>', 31)
nba.add_player('<NAME>', 'Phoenix Suns', 36)
nba.add_player('<NAME>', '<NAME>', 32)
nba.add_player('<NAME... | [
"for_CL7_use.NbaPlayer"
] | [((112, 123), 'for_CL7_use.NbaPlayer', 'NbaPlayer', ([], {}), '()\n', (121, 123), False, 'from for_CL7_use import NbaPlayer\n')] |
import pandas as pd
import os
import numpy as np
def read_file(path):
f = open(path,'r')
txt = f.read()
lines = txt.split('\n')
lines = lines[2:10]
data = [x.split(':') for x in lines]
out = dict()
out['shortname'] = path.split('/')[-2]
for d in data:
out[d[0]] = [d[1]]
return out
roots = ['1/1A0','1/1B0'... | [
"pandas.DataFrame",
"os.path.join"
] | [((523, 589), 'os.path.join', 'os.path.join', (['"""RAW_Data"""', '"""Synthetic"""', 'roots[0]', '"""Description.txt"""'], {}), "('RAW_Data', 'Synthetic', roots[0], 'Description.txt')\n", (535, 589), False, 'import os\n'), ((615, 633), 'pandas.DataFrame', 'pd.DataFrame', (['data'], {}), '(data)\n', (627, 633), True, 'i... |
"""extend entity key length
Revision ID: 84683329b0a5
Revises: <KEY>
Create Date: 2019-02-20 07:00:21.047707
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision = '84683329b0a5'
down_revision = '<KEY>'
def upgrade():
op.drop_column('document_record', 'sheet')
... | [
"sqlalchemy.String",
"alembic.op.drop_column",
"sqlalchemy.VARCHAR"
] | [((275, 317), 'alembic.op.drop_column', 'op.drop_column', (['"""document_record"""', '"""sheet"""'], {}), "('document_record', 'sheet')\n", (289, 317), False, 'from alembic import op\n'), ((322, 360), 'alembic.op.drop_column', 'op.drop_column', (['"""match"""', '"""document_id"""'], {}), "('match', 'document_id')\n", (... |
# practice_challenge/study_part1.py
## Starting From Scratch
import os
import sqlite3
DB_FILEPATH = os.path.join(os.path.dirname(__file__),
"..",
"practice_challenge",
"study_part1.sqlite3... | [
"os.path.dirname",
"sqlite3.connect"
] | [((332, 360), 'sqlite3.connect', 'sqlite3.connect', (['DB_FILEPATH'], {}), '(DB_FILEPATH)\n', (347, 360), False, 'import sqlite3\n'), ((116, 141), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (131, 141), False, 'import os\n')] |
import numpy as np
import bokeh.plotting as bp
bp.output_file("bokeh1.html")
x = np.linspace(0, 2 * np.pi, 1024)
y = np.cos(x)
fig = bp.figure( )
fig.line(x, y)
bp.show(fig)
| [
"bokeh.plotting.figure",
"bokeh.plotting.output_file",
"bokeh.plotting.show",
"numpy.cos",
"numpy.linspace"
] | [((47, 76), 'bokeh.plotting.output_file', 'bp.output_file', (['"""bokeh1.html"""'], {}), "('bokeh1.html')\n", (61, 76), True, 'import bokeh.plotting as bp\n'), ((81, 112), 'numpy.linspace', 'np.linspace', (['(0)', '(2 * np.pi)', '(1024)'], {}), '(0, 2 * np.pi, 1024)\n', (92, 112), True, 'import numpy as np\n'), ((117, ... |
# =============================================================================
# Copyright (c) 2016, Cisco Systems, 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:
#
# Redistributions of sour... | [
"common.get_custom_command_profile_list",
"database.DBSession",
"utils.get_acceptable_string",
"api_utils.convert_value_to_list",
"utils.is_empty",
"common.delete_custom_command_profile",
"api_utils.validate_url_parameters",
"common.create_or_update_custom_command_profile",
"api_utils.convert_json_r... | [((2822, 2833), 'database.DBSession', 'DBSession', ([], {}), '()\n', (2831, 2833), False, 'from database import DBSession\n'), ((2875, 2912), 'api_utils.convert_json_request_to_list', 'convert_json_request_to_list', (['request'], {}), '(request)\n', (2903, 2912), False, 'from api_utils import convert_json_request_to_li... |
import copy
from typing import Iterator
import torch
from scores import ContentScore, StyleScore
class StyleTransfer:
@staticmethod
def inject_scoring(base, content, style, content_layers, style_layers):
model = torch.nn.Sequential()
c_i = 0
for name, layer in copy.deepcopy(base).n... | [
"copy.deepcopy",
"torch.stack",
"torch.nn.Sequential",
"scores.ContentScore",
"torch.no_grad",
"scores.StyleScore"
] | [((233, 254), 'torch.nn.Sequential', 'torch.nn.Sequential', ([], {}), '()\n', (252, 254), False, 'import torch\n'), ((299, 318), 'copy.deepcopy', 'copy.deepcopy', (['base'], {}), '(base)\n', (312, 318), False, 'import copy\n'), ((2149, 2164), 'torch.no_grad', 'torch.no_grad', ([], {}), '()\n', (2162, 2164), False, 'imp... |
# This technical data was produced for the U. S. Government under Contract No. W15P7T-13-C-F600, and
# is subject to the Rights in Technical Data-Noncommercial Items clause at DFARS 252.227-7013 (FEB 2012)
from django.contrib.auth.models import User
from django.contrib.contenttypes.models import ContentType
from djang... | [
"django.core.urlresolvers.reverse",
"django.contrib.contenttypes.models.ContentType.objects.get",
"geoevents.notes.models.Note.objects.create",
"django.test.client.Client",
"django.test.utils.override_settings",
"geoevents.notes.models.Note.objects.get"
] | [((566, 660), 'django.test.utils.override_settings', 'override_settings', ([], {'AUTHENTICATION_BACKENDS': "('django.contrib.auth.backends.ModelBackend',)"}), "(AUTHENTICATION_BACKENDS=(\n 'django.contrib.auth.backends.ModelBackend',))\n", (583, 660), False, 'from django.test.utils import override_settings\n'), ((81... |
"""The library of functions used by py-subscribers."""
from requests import get
def get_repos(api, user):
"""Get list of all repos for a given user.
Parameters
----------
api : str
The API's fully-qualified domain name.
user : str
The user of interest.
The parameters help ... | [
"requests.get"
] | [((525, 538), 'requests.get', 'get', (['endpoint'], {}), '(endpoint)\n', (528, 538), False, 'from requests import get\n'), ((1240, 1253), 'requests.get', 'get', (['endpoint'], {}), '(endpoint)\n', (1243, 1253), False, 'from requests import get\n'), ((1951, 1964), 'requests.get', 'get', (['endpoint'], {}), '(endpoint)\n... |
import solver
print(solver.solve(10001))
| [
"solver.solve"
] | [((21, 40), 'solver.solve', 'solver.solve', (['(10001)'], {}), '(10001)\n', (33, 40), False, 'import solver\n')] |
import pdb
import torch
import numpy as np
import time
from tools.utils import Progbar,AverageMeter
from matplotlib import pyplot as plt
from scipy.integrate import simps
def predict_set(nets, dataloader, runtime_params):
run_type = runtime_params['run_type']
#net = net.eval()
progbar = Progbar(len(datalo... | [
"matplotlib.pyplot.savefig",
"numpy.sum",
"numpy.concatenate",
"matplotlib.pyplot.plot",
"numpy.count_nonzero",
"time.time",
"numpy.argsort",
"numpy.max",
"numpy.mean",
"numpy.array",
"numpy.arange",
"numpy.linalg.norm",
"numpy.min",
"torch.no_grad",
"scipy.integrate.simps",
"tools.uti... | [((383, 397), 'tools.utils.AverageMeter', 'AverageMeter', ([], {}), '()\n', (395, 397), False, 'from tools.utils import Progbar, AverageMeter\n'), ((434, 446), 'numpy.array', 'np.array', (['[]'], {}), '([])\n', (442, 446), True, 'import numpy as np\n'), ((466, 478), 'numpy.array', 'np.array', (['[]'], {}), '([])\n', (4... |
from celery import shared_task
from celery_progress.backend import ProgressRecorder
from time import sleep
@shared_task(bind=True)
def go_to_sleep(self, duration):
progress_recorder = ProgressRecorder(self)
for i in range(100):
sleep(duration)
progress_recorder.set_progress(i + 1, 100, f'On it... | [
"celery_progress.backend.ProgressRecorder",
"celery.shared_task",
"time.sleep"
] | [((110, 132), 'celery.shared_task', 'shared_task', ([], {'bind': '(True)'}), '(bind=True)\n', (121, 132), False, 'from celery import shared_task\n'), ((190, 212), 'celery_progress.backend.ProgressRecorder', 'ProgressRecorder', (['self'], {}), '(self)\n', (206, 212), False, 'from celery_progress.backend import ProgressR... |
# -- encoding: UTF-8 --
from datetime import time
import babel.dates as dates
import pytest
@pytest.mark.parametrize("locale, time, expected_period_id", [
("de", time(7, 42), "morning1"), # (from, before)
("de", time(3, 11), "night1"), # (after, before)
("fi", time(0), "midnight"), # (at)
("en_US"... | [
"datetime.time",
"babel.dates.get_period_id"
] | [((581, 621), 'babel.dates.get_period_id', 'dates.get_period_id', (['time'], {'locale': 'locale'}), '(time, locale=locale)\n', (600, 621), True, 'import babel.dates as dates\n'), ((169, 180), 'datetime.time', 'time', (['(7)', '(42)'], {}), '(7, 42)\n', (173, 180), False, 'from datetime import time\n'), ((224, 235), 'da... |
from django.urls import path
from reserva.core.views.name_application import check, done, pay, send, success
app_name = "name_application"
urlpatterns = [
path("check", check, name="check"),
path("send", send, name="send"),
path("pay", pay, name="pay"),
path("done", done, name="done"),
path("succ... | [
"django.urls.path"
] | [((162, 196), 'django.urls.path', 'path', (['"""check"""', 'check'], {'name': '"""check"""'}), "('check', check, name='check')\n", (166, 196), False, 'from django.urls import path\n'), ((202, 233), 'django.urls.path', 'path', (['"""send"""', 'send'], {'name': '"""send"""'}), "('send', send, name='send')\n", (206, 233),... |
import time
import cv2
import sys
from rasp import camera_detect
from rasp import client_socket
if __name__ == "__main__":
image_detect = camera_detect.run(sys.argv[1])
index = 1
try:
while True:
img = next(image_detect)
print('{}> image detected'.format(index), flush=True... | [
"rasp.client_socket.run",
"cv2.waitKey",
"time.sleep",
"rasp.camera_detect.run",
"cv2.destroyAllWindows"
] | [((144, 174), 'rasp.camera_detect.run', 'camera_detect.run', (['sys.argv[1]'], {}), '(sys.argv[1])\n', (161, 174), False, 'from rasp import camera_detect\n'), ((399, 413), 'cv2.waitKey', 'cv2.waitKey', (['(0)'], {}), '(0)\n', (410, 413), False, 'import cv2\n'), ((426, 449), 'cv2.destroyAllWindows', 'cv2.destroyAllWindo... |
# Copyright 2016-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: MIT-0
from __future__ import print_function
from awsglue.context import GlueContext
from hive_metastore_migration import *
CONNECTION_TYPE_NAME = 'com.amazonaws.services.glue.connections.DataCatalogConnectio... | [
"awsglue.context.GlueContext"
] | [((4386, 4401), 'awsglue.context.GlueContext', 'GlueContext', (['sc'], {}), '(sc)\n', (4397, 4401), False, 'from awsglue.context import GlueContext\n')] |
import csv
from players.models import Joueur
def run():
file = open('new_data.csv')
reader = csv.reader(file)
Joueur.objects.all().delete()
for row in reader:
print(row)
player, is_created = Joueur.objects.get_or_create(nom=row[1], prenom=row[2], adresse=row[3], code_postal=row[4],
... | [
"players.models.Joueur.objects.all",
"csv.reader",
"players.models.Joueur.objects.get_or_create"
] | [((102, 118), 'csv.reader', 'csv.reader', (['file'], {}), '(file)\n', (112, 118), False, 'import csv\n'), ((227, 460), 'players.models.Joueur.objects.get_or_create', 'Joueur.objects.get_or_create', ([], {'nom': 'row[1]', 'prenom': 'row[2]', 'adresse': 'row[3]', 'code_postal': 'row[4]', 'intra_extra': 'row[5]', 'age': '... |
from django.urls import path
from django.views.generic import TemplateView
from . import views
app_name = 'todo'
urlpatterns = [
path('', views.getHome, name='home'),
path('about/', views.AboutView.as_view(), name='about'),
path('task/', views.PriorityTaskView.as_view(), name='task'),
path('add/', view... | [
"django.views.generic.TemplateView.as_view",
"django.urls.path"
] | [((134, 170), 'django.urls.path', 'path', (['""""""', 'views.getHome'], {'name': '"""home"""'}), "('', views.getHome, name='home')\n", (138, 170), False, 'from django.urls import path\n'), ((510, 573), 'django.urls.path', 'path', (['"""complete/<int:pk>/"""', 'views.completeTask'], {'name': '"""complete"""'}), "('compl... |
import pytest
import crystalball
@pytest.mark.parametrize('json_text', [
'{"foo": "bar"}', # Normal JSON
'[{"foo": "bar"}]', # Object within a list
'{"baz": {"foo": "bar"},}', # Object within another
])
def test_finds_json_keys(json_text):
"""
Values can be extracted from JSON-like documents
... | [
"pytest.mark.parametrize",
"crystalball.parse"
] | [((37, 145), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""json_text"""', '[\'{"foo": "bar"}\', \'[{"foo": "bar"}]\', \'{"baz": {"foo": "bar"},}\']'], {}), '(\'json_text\', [\'{"foo": "bar"}\', \'[{"foo": "bar"}]\',\n \'{"baz": {"foo": "bar"},}\'])\n', (60, 145), False, 'import pytest\n'), ((336, 364),... |
########################################
# MIT License
#
# Copyright (c) 2020 <NAME>
########################################
'''
Define the data_types.for the variables to use in the package.
'''
import ctypes
import numpy as np
__all__ = []
# Types for numpy.ndarray objects
cpu_float = np.float64 # double
cpu_comp... | [
"numpy.full",
"numpy.empty",
"numpy.array",
"numpy.fromiter",
"ctypes.POINTER"
] | [((1258, 1282), 'ctypes.POINTER', 'ctypes.POINTER', (['c_double'], {}), '(c_double)\n', (1272, 1282), False, 'import ctypes\n'), ((1314, 1335), 'ctypes.POINTER', 'ctypes.POINTER', (['c_int'], {}), '(c_int)\n', (1328, 1335), False, 'import ctypes\n'), ((627, 669), 'numpy.array', 'np.array', (['*args'], {'dtype': 'cpu_fl... |
import pickle
from bs4 import BeautifulSoup
soup = BeautifulSoup(open('data/html/四角号码检字表（勘误版）.htm', encoding='gb18030'))
section = soup.body.div
print(section['class'])
# get printable text, instead of using element for more quickly
raw_data = section.text
data_list = raw_data.split()
print(len(data_list))
clea... | [
"pickle.dump"
] | [((1044, 1070), 'pickle.dump', 'pickle.dump', (['dict_data', 'fd'], {}), '(dict_data, fd)\n', (1055, 1070), False, 'import pickle\n')] |
from setuptools import setup, find_packages
requires = ['requests==2.18.1']
setup(name='pywordlist',
version='0.0.2',
description='Random phrase generator. https://xkcd.com/936/',
url='http://github.com/f0rkz/pywordlist',
author='f0rkz',
author_email='<EMAIL>',
license='MIT',
... | [
"setuptools.setup"
] | [((78, 367), 'setuptools.setup', 'setup', ([], {'name': '"""pywordlist"""', 'version': '"""0.0.2"""', 'description': '"""Random phrase generator. https://xkcd.com/936/"""', 'url': '"""http://github.com/f0rkz/pywordlist"""', 'author': '"""f0rkz"""', 'author_email': '"""<EMAIL>"""', 'license': '"""MIT"""', 'packages': "[... |
# Copyright (C) 2020 <NAME>.
# All rights reserved.
import asyncio
import glob
import os
import subprocess
import time
import requests
from bs4 import BeautifulSoup
from hachoir.metadata import extractMetadata
from hachoir.parser import createParser
from telethon import events
from telethon.errors import (
Messag... | [
"glob.glob",
"userbot.utils.progress",
"telethon.events.NewMessage",
"telethon.tl.types.DocumentAttributeVideo",
"hachoir.parser.createParser",
"userbot.bot.send_read_acknowledge",
"requests.get",
"userbot.bot.conversation",
"asyncio.get_event_loop",
"asyncio.sleep",
"userbot.events.register",
... | [((2748, 2796), 'userbot.events.register', 'register', ([], {'outgoing': '(True)', 'pattern': '"""^\\\\.song (.*)"""'}), "(outgoing=True, pattern='^\\\\.song (.*)')\n", (2756, 2796), False, 'from userbot.events import register\n'), ((3915, 3970), 'userbot.events.register', 'register', ([], {'outgoing': '(True)', 'patte... |
#
# Copyright (c) 2020 by <NAME>, Ryazan State Radio Engineering University.
#
# 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
# t... | [
"ryu.lib.packet.packet.Packet",
"ryu.controller.handler.set_ev_cls",
"ryu.lib.packet.ethernet.ethernet",
"ryu.lib.packet.arp.arp"
] | [((1918, 1981), 'ryu.controller.handler.set_ev_cls', 'set_ev_cls', (['ofp_event.EventOFPSwitchFeatures', 'CONFIG_DISPATCHER'], {}), '(ofp_event.EventOFPSwitchFeatures, CONFIG_DISPATCHER)\n', (1928, 1981), False, 'from ryu.controller.handler import set_ev_cls\n'), ((2493, 2548), 'ryu.controller.handler.set_ev_cls', 'set... |
# bezier_curve()生成贝塞尔曲线坐标。
import numpy as np
from skimage.draw import bezier_curve
img = np.zeros((10, 10), dtype=np.uint8)
print(img[1, 5])
rr, cc = bezier_curve(1, 5, 5, -2, 8, 8, 2)
img[rr, cc] = 1
print(img)
print(img[1, 5])
print(img[5, -2])
print(img[8, 8])
| [
"numpy.zeros",
"skimage.draw.bezier_curve"
] | [((90, 124), 'numpy.zeros', 'np.zeros', (['(10, 10)'], {'dtype': 'np.uint8'}), '((10, 10), dtype=np.uint8)\n', (98, 124), True, 'import numpy as np\n'), ((151, 185), 'skimage.draw.bezier_curve', 'bezier_curve', (['(1)', '(5)', '(5)', '(-2)', '(8)', '(8)', '(2)'], {}), '(1, 5, 5, -2, 8, 8, 2)\n', (163, 185), False, 'fro... |
# coding:utf-8
import getpass
import os
import re
import tempfile
import time
from datetime import datetime as dt
import requests_cache
from errors import EtherscanIoException
def _bool(text: str):
"""Convert str to bool"""
if text.lower() in ["0", "false", "none", "null", "n/a", ""]:
return False
... | [
"requests_cache.core.CachedSession",
"getpass.getpass",
"errors.EtherscanIoException",
"tempfile.gettempdir",
"time.time",
"datetime.datetime.strptime",
"datetime.datetime.fromtimestamp",
"re.sub",
"os.getenv"
] | [((497, 540), 're.sub', 're.sub', (['"""(.)([A-Z][a-z]+)"""', '"""\\\\1_\\\\2"""', 'name'], {}), "('(.)([A-Z][a-z]+)', '\\\\1_\\\\2', name)\n", (503, 540), False, 'import re\n'), ((551, 584), 're.sub', 're.sub', (['"""__([A-Z])"""', '"""_\\\\1"""', 'name'], {}), "('__([A-Z])', '_\\\\1', name)\n", (557, 584), False, 'im... |
import boto.provider
from boto.compat import urllib
qsa_of_interest = ['acl', 'cors', 'defaultObjectAcl', 'location', 'logging',
'partNumber', 'policy', 'requestPayment', 'torrent',
'versioning', 'versionId', 'versions', 'website',
'uploads', 'uploadId', 'respo... | [
"boto.compat.urllib.parse.unquote"
] | [((1275, 1302), 'boto.compat.urllib.parse.unquote', 'urllib.parse.unquote', (['nv[1]'], {}), '(nv[1])\n', (1295, 1302), False, 'from boto.compat import urllib\n'), ((3990, 4025), 'boto.compat.urllib.parse.unquote', 'urllib.parse.unquote', (['headers[hkey]'], {}), '(headers[hkey])\n', (4010, 4025), False, 'from boto.com... |
#! /usr/bin/env python
# -*- coding: utf-8 -*-
# Pocket PiAP
# ......................................................................
# Copyright (c) 2017-2020, <NAME>
# ......................................................................
# Licensed under MIT (the "License");
# you may not use this file except in co... | [
"piaplib.keyring.clarify.getAlgoForOS",
"piaplib.pku.utils._handleVersionArgs",
"argparse.ArgumentParser",
"os.path.dirname",
"sys.path.insert",
"piaplib.keyring.clarify.hasBackendCommand",
"piaplib.keyring.clarify.getBackendCommand",
"piaplib.pku.utils._handleVerbosityArgs"
] | [((7011, 7060), 'piaplib.pku.utils._handleVerbosityArgs', 'utils._handleVerbosityArgs', (['parser'], {'default': '(False)'}), '(parser, default=False)\n', (7037, 7060), True, 'import piaplib.pku.utils as utils\n'), ((7071, 7103), 'piaplib.pku.utils._handleVersionArgs', 'utils._handleVersionArgs', (['parser'], {}), '(pa... |
# passed
from wrapper.client import Client
api_server='testnet'
private_keys=['<KEY>',
'<KEY>']
addresses=['GDJJB2QA7XZSBHCGIRUAIUC5RJ6MJGV2DG5THNNJOTUQWXEDKXLVFZMI',
'GCKEZY2FW2MLANNJTQZIKFISGP2MZ57MZWMGECG3WD2FJHEQAGAA7ZUA']
# key_pairs=[]
# for key in private_keys:
# key_pair=Keypa... | [
"wrapper.client.Client"
] | [((833, 891), 'wrapper.client.Client', 'Client', ([], {'private_key': 'private_keys[0]', 'api_server': 'api_server'}), '(private_key=private_keys[0], api_server=api_server)\n', (839, 891), False, 'from wrapper.client import Client\n')] |
import numpy as np
import cv2
import imutils
import os
import time
# This function calculates the distance between the center of two individuals in a
# single frame of the video
def Check(a, b):
dist = (((a[0] - b[0]) ** 2) + (a[1] - b[1]) ** 2) ** 0.5
calibration = (a[1] + b[1]) / 2
if 0 < dist < 0.25 * ... | [
"cv2.dnn.NMSBoxes",
"cv2.VideoWriter_fourcc",
"numpy.argmax",
"cv2.waitKey",
"cv2.dnn.blobFromImage",
"cv2.dnn.readNetFromDarknet",
"time.time",
"cv2.VideoCapture",
"cv2.rectangle",
"numpy.array",
"cv2.VideoWriter",
"imutils.resize",
"cv2.destroyAllWindows",
"os.path.sep.join"
] | [((3685, 3711), 'cv2.VideoCapture', 'cv2.VideoCapture', (['filename'], {}), '(filename)\n', (3701, 3711), False, 'import cv2\n'), ((3888, 3899), 'time.time', 'time.time', ([], {}), '()\n', (3897, 3899), False, 'import time\n'), ((4501, 4512), 'time.time', 'time.time', ([], {}), '()\n', (4510, 4512), False, 'import time... |
import os
from enum import Enum
from ricecooker.classes import nodes, questions, files
from ricecooker.classes.licenses import get_license
from ricecooker.exceptions import UnknownContentKindError, UnknownFileTypeError, UnknownQuestionTypeError, raise_for_invalid_channel
from le_utils.constants import content_kinds,fil... | [
"le_utils.constants.content_kinds.MAPPING.items",
"ricecooker.exceptions.raise_for_invalid_channel",
"ricecooker.classes.files.ThumbnailFile",
"ricecooker.classes.files.SubtitleFile",
"os.path.splitext",
"ricecooker.classes.files.Base64ImageFile",
"ricecooker.classes.questions.PerseusQuestion"
] | [((4046, 4080), 'ricecooker.exceptions.raise_for_invalid_channel', 'raise_for_invalid_channel', (['channel'], {}), '(channel)\n', (4071, 4080), False, 'from ricecooker.exceptions import UnknownContentKindError, UnknownFileTypeError, UnknownQuestionTypeError, raise_for_invalid_channel\n'), ((11199, 11326), 'ricecooker.c... |
from discord import Role, TextChannel, Permissions, Embed, Color
from discord.ext import commands
from discord.utils import get
from datetime import datetime
from sqlite3 import connect
class Setup(commands.Cog, name='Setup'):
"""
Module rassemblant les commandes pour configurer le bot.
"""
def __ini... | [
"discord.utils.get",
"discord.ext.commands.command",
"discord.Embed",
"discord.ext.commands.has_permissions",
"datetime.datetime.now",
"discord.ext.commands.Cog.listener",
"sqlite3.connect",
"discord.ext.commands.is_owner"
] | [((367, 497), 'discord.ext.commands.command', 'commands.command', ([], {'brief': '"""!setup [verif/mute/logs/temp] [@role/#channel]"""', 'description': '"""Définir un role pour "verif" ou "mute\\""""'}), '(brief=\'!setup [verif/mute/logs/temp] [@role/#channel]\',\n description=\'Définir un role pour "verif" ou "mute... |
from django.test import TestCase
from django.urls import reverse
from freezegun import freeze_time
from rest_framework.test import APIClient
from rest_framework import status
from .utils import (
create_user,
create_friend_request,
create_friend,
create_message,
)
from core.models import Message, Fri... | [
"core.models.Friend.objects.filter",
"django.urls.reverse",
"core.models.User.objects.filter",
"core.models.Message.objects.filter",
"freezegun.freeze_time",
"rest_framework.test.APIClient"
] | [((352, 381), 'django.urls.reverse', 'reverse', (['"""api:message_create"""'], {}), "('api:message_create')\n", (359, 381), False, 'from django.urls import reverse\n'), ((401, 428), 'django.urls.reverse', 'reverse', (['"""api:message_list"""'], {}), "('api:message_list')\n", (408, 428), False, 'from django.urls import ... |
"""
Transformer 实现
Author: <NAME>
Date: 2021/3/7
REF: http://nlp.seas.harvard.edu/2018/04/03/attention.html
"""
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
import copy
import math
from torch.autograd import Variable
from torch.nn.modules.container import Sequential
from torch.... | [
"torch.nn.Dropout",
"torch.sqrt",
"torch.nn.Embedding",
"numpy.ones",
"torch.cos",
"matplotlib.pyplot.figure",
"numpy.arange",
"torch.arange",
"torch.ones",
"torch.nn.Linear",
"torch.zeros",
"math.log",
"torch.matmul",
"torch.nn.modules.normalization.LayerNorm",
"copy.deepcopy",
"matpl... | [((7195, 7222), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': '(15, 5)'}), '(figsize=(15, 5))\n', (7205, 7222), True, 'import matplotlib.pyplot as plt\n'), ((7354, 7364), 'matplotlib.pyplot.show', 'plt.show', ([], {}), '()\n', (7362, 7364), True, 'import matplotlib.pyplot as plt\n'), ((4623, 4648), 'torch.... |
# Generated by Django 3.1.6 on 2021-03-05 03:48
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('infra', '0006_networkinterfacemodel_subnetid'),
]
operations = [
migrations.AddField(
model_name='instancemodel',
... | [
"django.db.models.CharField"
] | [((366, 421), 'django.db.models.CharField', 'models.CharField', ([], {'blank': '(True)', 'max_length': '(100)', 'null': '(True)'}), '(blank=True, max_length=100, null=True)\n', (382, 421), False, 'from django.db import migrations, models\n')] |
from setuptools import setup, find_packages
setup(
name='django-inlineobjects',
packages=find_packages(),
version='2.0.3',
description='A reusable Django application used to insert content objects into other pieces of content.',
author='<NAME>',
author_email='<EMAIL>',
url='https://github.c... | [
"setuptools.find_packages"
] | [((98, 113), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (111, 113), False, 'from setuptools import setup, find_packages\n')] |
from django import forms
from django.contrib.auth import authenticate, get_user_model
from django.contrib.auth.forms import AuthenticationForm
from authtools import forms as authforms
User = get_user_model()
class LoginForm(AuthenticationForm):
username = forms.CharField(
required=True,
widget=... | [
"django.forms.EmailInput",
"django.contrib.auth.get_user_model",
"django.forms.PasswordInput"
] | [((194, 210), 'django.contrib.auth.get_user_model', 'get_user_model', ([], {}), '()\n', (208, 210), False, 'from django.contrib.auth import authenticate, get_user_model\n'), ((320, 369), 'django.forms.EmailInput', 'forms.EmailInput', ([], {'attrs': "{'placeholder': 'E-mail'}"}), "(attrs={'placeholder': 'E-mail'})\n", (... |
import plotly.express as px
import pandas as pd
data = dict(
concept = ["root concept","name","forename","surname","initials","contact details","address","address line","postcoce","telephone","email","identification num","passport ","driving license","nat insurance","healthcare identifier","nhs num","hosp num","em... | [
"plotly.express.sunburst"
] | [((968, 1036), 'plotly.express.sunburst', 'px.sunburst', (['data'], {'names': '"""concept"""', 'parents': '"""parent"""', 'values': '"""value"""'}), "(data, names='concept', parents='parent', values='value')\n", (979, 1036), True, 'import plotly.express as px\n')] |
# -*- coding: utf-8 -*-
"""
@author: <NAME>, <NAME>, <NAME>, <NAME>
"""
# This is our main program file that displays the menu for the user to use
import helpers as h
import search_colleges as sc
import average_stats as avg_stat
import recommender_helper as r_helper
import bestcolleges_helper as bs_helper
import fet... | [
"recommender_helper.view_recommendations",
"bestcolleges_helper.view_all_careers",
"bestcolleges_helper.view_career_info_by_name",
"helpers.get_input",
"average_stats.compute_loan_and_draw_map",
"fetch_all_data.refresh_all_data",
"helpers.get_states",
"average_stats.compute_cost_and_draw_map",
"aver... | [((740, 754), 'helpers.get_input', 'h.get_input', (['(7)'], {}), '(7)\n', (751, 754), True, 'import helpers as h\n'), ((1406, 1420), 'helpers.get_states', 'h.get_states', ([], {}), '()\n', (1418, 1420), True, 'import helpers as h\n'), ((1467, 1484), 'helpers.get_input', 'h.get_input', (['(1600)'], {}), '(1600)\n', (147... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Test various building blocks
"""
import pytest
import mframework._mframework as mf
import mframework._utils as mfu
from mframework import log as log
log.on
def test_log():
log.off
log.on
def test_version():
from mframework.__version__ import __versio... | [
"mframework._mframework.SpecDict",
"mframework._mframework.ItemDict",
"mframework._utils.DictLike",
"mframework._mframework.is_primitve_type",
"mframework._mframework.check_type",
"pytest.raises",
"mframework._mframework.SpecEntry"
] | [((390, 415), 'mframework._mframework.is_primitve_type', 'mf.is_primitve_type', (['bool'], {}), '(bool)\n', (409, 415), True, 'import mframework._mframework as mf\n'), ((427, 451), 'mframework._mframework.is_primitve_type', 'mf.is_primitve_type', (['int'], {}), '(int)\n', (446, 451), True, 'import mframework._mframewor... |
#!/usr/bin/env python
#
# Copyright (C) 2015 <NAME> <<EMAIL>>
#
# 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 applic... | [
"managesf.services.gerrit.utils.GerritRepo",
"yaml.load",
"yaml.safe_dump",
"os.path.join",
"logging.getLogger"
] | [((800, 827), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (817, 827), False, 'import logging\n'), ((1081, 1131), 'managesf.services.gerrit.utils.GerritRepo', 'utils.GerritRepo', (['"""config"""', 'self.plugin._full_conf'], {}), "('config', self.plugin._full_conf)\n", (1097, 1131), Fals... |
from django import forms
from Online_Library.web_app.models import Profile, Book
class CreateBookForm(forms.ModelForm):
class Meta:
model=Book
fields=('title','description','image','type')
widgets={
'description':forms.Textarea(
attrs={
'ro... | [
"Online_Library.web_app.models.Book.objects.all",
"django.forms.Textarea"
] | [((257, 290), 'django.forms.Textarea', 'forms.Textarea', ([], {'attrs': "{'rows': 3}"}), "(attrs={'rows': 3})\n", (271, 290), False, 'from django import forms\n'), ((539, 572), 'django.forms.Textarea', 'forms.Textarea', ([], {'attrs': "{'rows': 3}"}), "(attrs={'rows': 3})\n", (553, 572), False, 'from django import form... |
import json
from .column import Column
class JSON(Column):
def from_backend(self, value):
if type(value) == list or type(value) == dict:
return value
if not value:
return None
try:
return json.loads(value)
except json.JSONDecodeError:
... | [
"json.loads",
"json.dumps"
] | [((254, 271), 'json.loads', 'json.loads', (['value'], {}), '(value)\n', (264, 271), False, 'import json\n'), ((426, 453), 'json.dumps', 'json.dumps', (['data[self.name]'], {}), '(data[self.name])\n', (436, 453), False, 'import json\n')] |
import matplotlib.pyplot as plt
import numpy as np
import sys
from environment import MountainCar
def get_state(mode, state):
if mode == 'raw':
s = np.zeros((2, 1))
else:
s = np.zeros((2048, 1))
for k in state:
s[k] = state[k]
return s
def get_q(s, w, b):
... | [
"matplotlib.pyplot.title",
"numpy.random.uniform",
"matplotlib.pyplot.show",
"environment.MountainCar",
"matplotlib.pyplot.legend",
"numpy.zeros",
"numpy.cumsum",
"numpy.random.randint",
"numpy.array"
] | [((618, 638), 'numpy.zeros', 'np.zeros', (['(n_S, n_A)'], {}), '((n_S, n_A))\n', (626, 638), True, 'import numpy as np\n'), ((683, 700), 'environment.MountainCar', 'MountainCar', (['mode'], {}), '(mode)\n', (694, 700), False, 'from environment import MountainCar\n'), ((2142, 2167), 'numpy.cumsum', 'np.cumsum', (['a'], ... |
# Generated by Django 3.2.7 on 2021-09-14 03:41
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('core', '0032_unit_reveal_at_level'),
]
operations = [
migrations.RemoveField(
model_name='unit',
name='reveal_at_level',
... | [
"django.db.migrations.RemoveField"
] | [((226, 291), 'django.db.migrations.RemoveField', 'migrations.RemoveField', ([], {'model_name': '"""unit"""', 'name': '"""reveal_at_level"""'}), "(model_name='unit', name='reveal_at_level')\n", (248, 291), False, 'from django.db import migrations\n')] |
import argparse
import json
import os
import tensorflow as tf
from trainer import model
if __name__ == '__main__':
parser = argparse.ArgumentParser()
# Required arguments
parser.add_argument('--data_bucket_name',
help='GCS location of the training images',
required=... | [
"argparse.ArgumentParser",
"trainer.model.train"
] | [((129, 154), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (152, 154), False, 'import argparse\n'), ((5231, 5255), 'trainer.model.train', 'model.train', ([], {}), '(**arguments)\n', (5242, 5255), False, 'from trainer import model\n')] |
'''Autogenerated by xml_generate script, do not edit!'''
from OpenGL import platform as _p, arrays
# Code generation uses this
from OpenGL.raw.GL import _types as _cs
# End users want this...
from OpenGL.raw.GL._types import *
from OpenGL.raw.GL import _errors
from OpenGL.constant import Constant as _C
import... | [
"OpenGL.constant.Constant",
"OpenGL.platform.createFunction"
] | [((544, 588), 'OpenGL.constant.Constant', '_C', (['"""GL_PROXY_TEXTURE_1D_STACK_MESAX"""', '(34651)'], {}), "('GL_PROXY_TEXTURE_1D_STACK_MESAX', 34651)\n", (546, 588), True, 'from OpenGL.constant import Constant as _C\n'), ((622, 666), 'OpenGL.constant.Constant', '_C', (['"""GL_PROXY_TEXTURE_2D_STACK_MESAX"""', '(34652... |
# - * - coding: utf - 8 - * -
"""
This module tests the functions in dam_tol.py.
"""
__version__ = '1.0'
__author__ = '<NAME>'
import sys
import pytest
import numpy as np
sys.path.append(r'C:\LAYLA')
from src.LAYLA_V02.constraints import Constraints
from src.guidelines.dam_tol import is_dam_tol
@pytest.mark.param... | [
"sys.path.append",
"src.LAYLA_V02.constraints.Constraints",
"numpy.array",
"src.guidelines.dam_tol.is_dam_tol"
] | [((176, 204), 'sys.path.append', 'sys.path.append', (['"""C:\\\\LAYLA"""'], {}), "('C:\\\\LAYLA')\n", (191, 204), False, 'import sys\n'), ((788, 818), 'src.guidelines.dam_tol.is_dam_tol', 'is_dam_tol', (['stack', 'constraints'], {}), '(stack, constraints)\n', (798, 818), False, 'from src.guidelines.dam_tol import is_da... |
from unittest import TestCase
from deferrable.backend.base import BackendFactory
class TestBackendFactory(TestCase):
def test_queue_name_with_None(self):
self.assertEqual('deferrable', BackendFactory._queue_name(None))
def test_queue_name_with_group(self):
self.assertEqual('deferrable_test', ... | [
"deferrable.backend.base.BackendFactory._queue_name"
] | [((199, 231), 'deferrable.backend.base.BackendFactory._queue_name', 'BackendFactory._queue_name', (['None'], {}), '(None)\n', (225, 231), False, 'from deferrable.backend.base import BackendFactory\n'), ((320, 354), 'deferrable.backend.base.BackendFactory._queue_name', 'BackendFactory._queue_name', (['"""test"""'], {}),... |
import numpy as np
import torch
import logging
logger = logging.getLogger(__name__)
class Learner(object):
def __init__(self, config):
self.config = config
self.npr = np.random.RandomState(config.seed)
self.calibrate = config.learner.calibrate
self.semi_supervised = config.learner... | [
"torch.cuda.is_available",
"numpy.random.RandomState",
"logging.getLogger"
] | [((57, 84), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (74, 84), False, 'import logging\n'), ((190, 224), 'numpy.random.RandomState', 'np.random.RandomState', (['config.seed'], {}), '(config.seed)\n', (211, 224), True, 'import numpy as np\n'), ((413, 438), 'torch.cuda.is_available', '... |
'''
Beginning with just a plot
Let's get started on the Gapminder app. Your job is to make the ColumnDataSource object, prepare the plot, and add circles for Life expectancy vs Fertility. You'll also set x and y ranges for the axes.
As in the previous chapter, the DataCamp environment executes the bokeh serve command... | [
"bokeh.models.ColumnDataSource",
"bokeh.io.curdoc",
"bokeh.plotting.figure"
] | [((1390, 1597), 'bokeh.models.ColumnDataSource', 'ColumnDataSource', ([], {'data': "{'x': data.loc[1970].fertility, 'y': data.loc[1970].life, 'country': data.\n loc[1970].Country, 'pop': data.loc[1970].population / 20000000 + 2,\n 'region': data.loc[1970].region}"}), "(data={'x': data.loc[1970].fertility, 'y': da... |
"""Queries, the Q in CQRS."""
from typing import Any, AsyncGenerator, Dict, Generic, Tuple, TypeVar
from abc import ABCMeta, abstractmethod
from . import schema
from .context import Context
# pylint: disable=invalid-name
_T_Context = TypeVar("_T_Context", bound=Context)
_T_Result = TypeVar("_T_Result", bound=schema.... | [
"typing.TypeVar"
] | [((237, 273), 'typing.TypeVar', 'TypeVar', (['"""_T_Context"""'], {'bound': 'Context'}), "('_T_Context', bound=Context)\n", (244, 273), False, 'from typing import Any, AsyncGenerator, Dict, Generic, Tuple, TypeVar\n'), ((286, 331), 'typing.TypeVar', 'TypeVar', (['"""_T_Result"""'], {'bound': 'schema.SchemaBase'}), "('_... |
import json
from nltk.stem import SnowballStemmer
MIN_WORD_LEN = 4
WORDS_IN_KEY = 3
stemmer = SnowballStemmer('russian')
raw = open('nalkod.json', 'rt')
vocab = {}
corpus = json.load(raw)
def phrases(sentence, n=2):
words = sentence.split(' ')
phrases = []
first = 0
la... | [
"nltk.stem.SnowballStemmer",
"json.load"
] | [((101, 127), 'nltk.stem.SnowballStemmer', 'SnowballStemmer', (['"""russian"""'], {}), "('russian')\n", (116, 127), False, 'from nltk.stem import SnowballStemmer\n'), ((202, 216), 'json.load', 'json.load', (['raw'], {}), '(raw)\n', (211, 216), False, 'import json\n')] |
from sendgrid import SendGridAPIClient
from sendgrid.helpers.mail import Mail
class EmailClient:
def send_email(self, api_key, from_email, to_email, subject, body):
message = Mail(
from_email=from_email,
to_emails=to_email,
subject=subject,
html_content=bod... | [
"sendgrid.SendGridAPIClient",
"sendgrid.helpers.mail.Mail"
] | [((190, 277), 'sendgrid.helpers.mail.Mail', 'Mail', ([], {'from_email': 'from_email', 'to_emails': 'to_email', 'subject': 'subject', 'html_content': 'body'}), '(from_email=from_email, to_emails=to_email, subject=subject,\n html_content=body)\n', (194, 277), False, 'from sendgrid.helpers.mail import Mail\n'), ((349, ... |
import nltk
from nltk import FreqDist
from nltk import word_tokenize
from nltk.corpus import stopwords
import re
import json
class Tweet_Print():
""" This file should take in Twitter stream data from python.json, then
manipulate it using NLTK. Current version tokenizes tweets, prints
frequency distribution... | [
"json.loads",
"nltk.corpus.stopwords.words",
"nltk.Text",
"nltk.FreqDist",
"nltk.word_tokenize"
] | [((1469, 1496), 'nltk.Text', 'nltk.Text', (['tokenized_tweets'], {}), '(tokenized_tweets)\n', (1478, 1496), False, 'import nltk\n'), ((1578, 1599), 'nltk.FreqDist', 'FreqDist', (['tweets_nltk'], {}), '(tweets_nltk)\n', (1586, 1599), False, 'from nltk import FreqDist\n'), ((1705, 1743), 'nltk.corpus.stopwords.words', 'n... |
from typing import Optional, Callable
import os
import torch
from torch import nn
from torch.nn import functional as F
from torch.utils.data import Dataset, DataLoader
from torch.optim.lr_scheduler import ReduceLROnPlateau
from torch.serialization import save
import numpy as np
import pandas as pd
from glog import log... | [
"torch.nn.Dropout",
"sklearn.preprocessing.StandardScaler",
"pandas.read_csv",
"joblib.dump",
"numpy.isnan",
"numpy.mean",
"torch.no_grad",
"sklearn.impute.SimpleImputer",
"torch.utils.data.DataLoader",
"os.path.exists",
"torch.optim.lr_scheduler.ReduceLROnPlateau",
"torch.nn.Linear",
"sklea... | [((1547, 1583), 'glog.logger.info', 'logger.info', (['f"""Mapping is {mapping}"""'], {}), "(f'Mapping is {mapping}')\n", (1558, 1583), False, 'from glog import logger\n'), ((1595, 1633), 'numpy.array', 'np.array', (['[mapping[y] for y in y_full]'], {}), '([mapping[y] for y in y_full])\n', (1603, 1633), True, 'import nu... |
import torch
import torch.nn as nn
class Model(object):
def __init__(self, model_config, data_config, is_train=True):
super(Model, self).__init__()
trj_model = None
if model_config['CAMERA_EMBDDING']:
extrinsic_dim = model_config['EXTRINSIC_DIM']
embedd_dim = mode... | [
"lib.model.rie.RIETrajectoryModel",
"torch.nn.DataParallel",
"torch.cuda.is_available",
"lib.model.rie.RIEModel"
] | [((2625, 2650), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {}), '()\n', (2648, 2650), False, 'import torch\n'), ((770, 1228), 'lib.model.rie.RIEModel', 'RIEModel', (['num_joints_in', "model_config['INPUT_DIM']", 'num_joints_out'], {'filter_widths': 'filter_widths', 'causal': "model_config['CAUSAL']", 'd... |
#!/usr/bin/python
import argparse
import os
import re
import sys
import cv2
from lib.diagManager import DiagManager
from lib.roadManager import RoadManager
from lib.cameraCal import CameraCal
from matplotlib import pyplot as plt
# process_road_image handles rendering a single image through the pipeline
def process_r... | [
"os.mkdir",
"argparse.ArgumentParser",
"cv2.cvtColor",
"os.path.exists",
"cv2.VideoCapture",
"cv2.imread",
"lib.diagManager.DiagManager",
"lib.cameraCal.CameraCal",
"lib.roadManager.RoadManager",
"cv2.destroyAllWindows",
"sys.exit",
"re.compile"
] | [((2636, 2706), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'prog': '"""main.py"""', 'usage': 'usage', 'description': 'desc'}), "(prog='main.py', usage=usage, description=desc)\n", (2659, 2706), False, 'import argparse\n'), ((3417, 3441), 're.compile', 're.compile', (['"""^.+\\\\.mp4$"""'], {}), "('^.+\... |
#!/usr/bin/env python
import datetime
import getopt
import inspect
import json
import os
import platform
import sys
import time
import threading
from Global import __MULTIPROCESSING__
__version__ = "0.1"
if __MULTIPROCESSING__:
import multiprocessing
from multiprocessing import Queue
from multiprocessi... | [
"Logger.logging.getLogger",
"platform.processor",
"platform.python_implementation",
"platform.python_version",
"platform.node",
"getopt.getopt",
"platform.platform",
"platform.system",
"Two.Two",
"time.sleep",
"multiprocessing.Queue",
"Three.Three",
"platform.version",
"platform.machine",
... | [((476, 499), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (497, 499), False, 'import datetime\n'), ((759, 793), 'Logger.logging.getLogger', 'Logger.logging.getLogger', (['__name__'], {}), '(__name__)\n', (783, 793), False, 'import Logger\n'), ((968, 1002), 'getopt.getopt', 'getopt.getopt', (['ar... |
import os
import uuid
from datetime import datetime, timedelta
import mock
import pytz
from django.conf import settings
from django.contrib.auth.models import User
from django.test import TestCase
from django.urls import reverse
from utils.widget import quill
from wiki import modelgetters
from wiki.models import wikip... | [
"wiki.modelgetters.get_one_wiki_page_data",
"uuid.uuid4",
"wiki.modelgetters.form_all_wiki_pages_data",
"django.contrib.auth.models.User",
"mock.patch",
"datetime.timedelta",
"datetime.datetime.now"
] | [((527, 660), 'django.contrib.auth.models.User', 'User', ([], {'is_superuser': '(True)', 'username': '"""test1"""', 'password': '"""<PASSWORD>"""', 'email': '"""<EMAIL>"""', 'first_name': '"""testname1"""', 'last_name': '"""testlast2"""'}), "(is_superuser=True, username='test1', password='<PASSWORD>', email=\n '<EMA... |
import HSCIC as hs
import tensorflow as tf
from tensorflow import keras
from keras import layers
import requests
requests.packages.urllib3.disable_warnings()
import ssl
try:
_create_unverified_https_context = ssl._create_unverified_context
except AttributeError:
pass
else:
ssl._create_default_https_context... | [
"requests.packages.urllib3.disable_warnings",
"tensorflow.reduce_sum",
"tensorflow.keras.metrics.Mean",
"tensorflow.keras.Input",
"tensorflow.keras.backend.random_normal",
"tensorflow.keras.Model",
"tensorflow.shape",
"keras.layers.Dense",
"tensorflow.exp",
"HSCIC.HSCIC",
"tensorflow.math.exp",
... | [((114, 158), 'requests.packages.urllib3.disable_warnings', 'requests.packages.urllib3.disable_warnings', ([], {}), '()\n', (156, 158), False, 'import requests\n'), ((630, 653), 'tensorflow.keras.Input', 'keras.Input', ([], {'shape': '(2,)'}), '(shape=(2,))\n', (641, 653), False, 'from tensorflow import keras\n'), ((11... |
import argparse
import os
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import PIL
import scipy.io
import scipy.misc
import tensorflow as tf
from keras import backend as K
from keras.layers import Conv2D, Input, Lambda
from keras.models import Model, load_model
from matplotlib.pyplot import im... | [
"keras.models.load_model",
"yolo_utils.scale_boxes",
"tensorflow.variables_initializer",
"yolo_utils.generate_colors",
"os.path.join",
"keras.backend.argmax",
"matplotlib.pyplot.imshow",
"tensorflow.placeholder",
"yad2k.models.keras_yolo.yolo_boxes_to_corners",
"yolo_utils.read_classes",
"tensor... | [((3564, 3579), 'keras.backend.get_session', 'K.get_session', ([], {}), '()\n', (3577, 3579), True, 'from keras import backend as K\n'), ((4038, 4071), 'yolo_utils.generate_colors', 'generate_colors', (['yolo.class_names'], {}), '(yolo.class_names)\n', (4053, 4071), False, 'from yolo_utils import draw_boxes, generate_c... |
# -*- coding: utf-8 -*-
#@+leo-ver=5-thin
#@+node:ekr.20210926044012.1: * @file ../unittests/test_doctests.py
#@@first
"""Run all doctests."""
import doctest
import glob
import os
import unittest
from leo.core import leoGlobals as g
unittest_dir = os.path.dirname(__file__)
leo_dir = os.path.abspath(os.path.join(unitte... | [
"leo.core.leoGlobals.printObj",
"os.path.dirname",
"math.floor",
"os.path.exists",
"doctest.testfile",
"leo.core.leoGlobals.shortFileName",
"glob.glob",
"os.path.join"
] | [((249, 274), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (264, 274), False, 'import os\n'), ((301, 333), 'os.path.join', 'os.path.join', (['unittest_dir', '""".."""'], {}), "(unittest_dir, '..')\n", (313, 333), False, 'import os\n'), ((1489, 1502), 'math.floor', 'math.floor', (['n'], {}),... |
import logging
from abc import abstractmethod, ABCMeta
class AbstractJob(metaclass=ABCMeta):
'''AbstractJob provides common functionality for jobs that executes various set of tasks on spark.'''
def __init__(self, sc, spark, gc, config):
logging.basicConfig(level=logging.INFO)
self.logger = l... | [
"logging.getLogger",
"logging.basicConfig"
] | [((257, 296), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (276, 296), False, 'import logging\n'), ((319, 361), 'logging.getLogger', 'logging.getLogger', (['self.__class__.__name__'], {}), '(self.__class__.__name__)\n', (336, 361), False, 'import logging\n')] |
# -*- coding: utf-8 -*-
# Generated by Django 1.9 on 2016-02-14 20:46
from __future__ import unicode_literals
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('core', '0010_class_remarks'),
]
operations = [
migrations.RenameField(
mod... | [
"django.db.migrations.RenameField"
] | [((281, 371), 'django.db.migrations.RenameField', 'migrations.RenameField', ([], {'model_name': '"""class"""', 'old_name': '"""lastPaid"""', 'new_name': '"""last_paid"""'}), "(model_name='class', old_name='lastPaid', new_name=\n 'last_paid')\n", (303, 371), False, 'from django.db import migrations\n'), ((423, 531), ... |
import logging
from textnn.utils import json
from pathlib import Path
from typing import Iterable, Tuple, Union, Generator
from textnn.dataset import KerasModelTrainingProgram
from textnn.utils import read_text_file_lines as read_lines, skip, FixedLengthIterable
def yelp_star_rating_generator(data_file: Path, trim_t... | [
"textnn.utils.FixedLengthIterable",
"textnn.utils.read_text_file_lines",
"textnn.utils.json.loads",
"logging.info",
"pathlib.Path"
] | [((737, 753), 'textnn.utils.json.loads', 'json.loads', (['line'], {}), '(line)\n', (747, 753), False, 'from textnn.utils import json\n'), ((5662, 5704), 'textnn.utils.FixedLengthIterable', 'FixedLengthIterable', ([], {'gen_source': 'gen_source'}), '(gen_source=gen_source)\n', (5681, 5704), False, 'from textnn.utils imp... |
import numpy as np
import sympy
from enum import Enum
from detmodel.hit import Hit
from detmodel.signal import Signal, Segment
from detmodel.muon import Muon
from detmodel import util
class DetType(Enum):
MM = 'mm'
MDT = 'mdt'
STGC = 'stgc'
def asint(self):
return {
DetType.MM: ... | [
"detmodel.util.distpoint2line",
"numpy.random.uniform",
"numpy.abs",
"detmodel.hit.Hit",
"sympy.Line3D",
"sympy.Point",
"numpy.zeros",
"sympy.Plane",
"sympy.Line",
"numpy.tan",
"detmodel.signal.Signal",
"numpy.random.poisson",
"numpy.linspace",
"numpy.random.normal",
"sympy.Point3D"
] | [((1130, 1168), 'sympy.Point3D', 'sympy.Point3D', (['(0)', '(0)', 'z'], {'evaluate': '(False)'}), '(0, 0, z, evaluate=False)\n', (1143, 1168), False, 'import sympy\n'), ((1187, 1235), 'sympy.Plane', 'sympy.Plane', (['self.point'], {'normal_vector': '(0, 0, 1)'}), '(self.point, normal_vector=(0, 0, 1))\n', (1198, 1235),... |
# **********************************************************************************************************************
#
# brief: simple script to plot runtimes
#
# author: <NAME>
# date: 14.08.2020
#
# **********************************************************************************************************... | [
"sys.path.append",
"os.path.abspath",
"samples.sun.sund3.SunD3Config",
"samples.sun.sunrgb.SunRGBDataset",
"samples.sun.sunrgbd.SunRGBDDataset",
"samples.sun.sunrgbd.SunRGBDConfig",
"random.choices",
"samples.sun.sund3.SunD3Dataset",
"mrcnn.utils.extract_bboxes",
"samples.sun.sunrgbd_fusenet.SunRG... | [((414, 439), 'os.path.abspath', 'os.path.abspath', (['"""../../"""'], {}), "('../../')\n", (429, 439), False, 'import os\n'), ((475, 500), 'sys.path.append', 'sys.path.append', (['ROOT_DIR'], {}), '(ROOT_DIR)\n', (490, 500), False, 'import sys\n'), ((740, 771), 'os.path.join', 'os.path.join', (['ROOT_DIR', '"""logs/""... |
# coding:utf-8
from LxBasic import bscMtdCore
from LxCore.config import appConfig
#
class MaConfig(object):
DEF_mya_node_pathsep = '|'
DEF_mya_set_separator = '>'
DEF_mya_node_namespace_pathsep = ':'
DEF_mya_node_port_pathsep = '.'
# Nde_Node Type
DEF_mya_type_transform = 'transform'
DEF_... | [
"LxBasic.bscMtdCore.orderedDict"
] | [((6088, 6344), 'LxBasic.bscMtdCore.orderedDict', 'bscMtdCore.orderedDict', (["[('light', 'Light(s)'), ('object', 'Object(s)'), ('defaultLightSet',\n 'Default Set(s)'), ('link', 'Light Link(s)'), ('shadowLink',\n 'Shadow Link(s)'), ('ignore', 'Light Ignore(s)'), ('shadowIgnore',\n 'Shadow Ignore(s)')]"], {}), ... |
import os
import sys
import pickle # see if useful
import numpy as np
import cv2
import constants
import video_interpreter as vi
import to_nodes
def generate_ctm_dataset(activity):
# func to extract frames correctly here, should return either frames by frames
# or multiple frames in a convenient data f... | [
"constants.initialize_directories"
] | [((598, 632), 'constants.initialize_directories', 'constants.initialize_directories', ([], {}), '()\n', (630, 632), False, 'import constants\n')] |
from os import environ
environ['PYGAME_HIDE_SUPPORT_PROMPT'] = '1'
# For `debug` support on Mac, we need to preload tkinter
from designer.system import setup_debug_mode
setup_debug_mode()
# Actually import all dependencies
import pygame
from designer.core.director import *
from designer.core.event import *
from desi... | [
"designer.system.setup_debug_mode"
] | [((171, 189), 'designer.system.setup_debug_mode', 'setup_debug_mode', ([], {}), '()\n', (187, 189), False, 'from designer.system import setup_debug_mode\n')] |
# Generated by Django 2.0.7 on 2018-08-06 08:25
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('tft', '0013_auto_20180806_1606'),
]
operations = [
migrations.AlterModelOptions(
name='shortcut',
options={'verbose_... | [
"django.db.models.CharField",
"django.db.migrations.AlterModelOptions"
] | [((231, 345), 'django.db.migrations.AlterModelOptions', 'migrations.AlterModelOptions', ([], {'name': '"""shortcut"""', 'options': "{'verbose_name': '快捷标题', 'verbose_name_plural': '快捷标题'}"}), "(name='shortcut', options={'verbose_name':\n '快捷标题', 'verbose_name_plural': '快捷标题'})\n", (259, 345), False, 'from django.db ... |
from rest_framework import serializers
from django.db import transaction
from delivery.services import create_delivery_config, create_pick_period_line
from product.services import create_default_group_by_shop
from shop.constant import ShopStatus
from shop.services import (
create_shop,
create_pay_channel,
... | [
"django.db.transaction.savepoint_rollback",
"shop.services.create_shop_mini_program_qcode",
"config.services.create_share_setup",
"shop.services.create_shop_creator_history_realname",
"rest_framework.serializers.IntegerField",
"shop.services.create_shop",
"django.db.transaction.atomic",
"user.serializ... | [((1002, 1056), 'rest_framework.serializers.IntegerField', 'serializers.IntegerField', ([], {'read_only': '(True)', 'label': '"""商铺id"""'}), "(read_only=True, label='商铺id')\n", (1026, 1056), False, 'from rest_framework import serializers\n'), ((1073, 1126), 'rest_framework.serializers.CharField', 'serializers.CharField... |
"""An agent that makes random decisions using a TensorFlow policy."
This agent creates and uses a new randomly initialized
TensorFlow NN policy for each step but doesn't do any
learning.
"""
import agentos
from tensorflow import keras
import numpy as np
class Policy:
def __init__(self):
self.nn = keras.S... | [
"tensorflow.keras.layers.Dense",
"numpy.median",
"numpy.mean",
"numpy.array",
"agentos.run_agent"
] | [((1280, 1338), 'agentos.run_agent', 'agentos.run_agent', (['RandomTFAgent', 'CartPoleEnv'], {'max_iters': '(5)'}), '(RandomTFAgent, CartPoleEnv, max_iters=5)\n', (1297, 1338), False, 'import agentos\n'), ((361, 436), 'tensorflow.keras.layers.Dense', 'keras.layers.Dense', (['(4)'], {'activation': '"""relu"""', 'input_s... |
# Generated by Django 2.2.4 on 2019-11-07 16:46
import apps.documents.models
import apps.simple_history
import apps.utils
from django.db import migrations, models
import django.db.models.deletion
import enumfields.fields
import shipchain_common.utils
import simple_history.models
import uuid
class Migration(migration... | [
"django.db.models.UUIDField",
"django.db.models.CharField",
"django.db.models.ForeignKey",
"django.db.migrations.AlterModelOptions",
"django.db.models.DateTimeField"
] | [((501, 591), 'django.db.migrations.AlterModelOptions', 'migrations.AlterModelOptions', ([], {'name': '"""document"""', 'options': "{'ordering': ('-created_at',)}"}), "(name='document', options={'ordering': (\n '-created_at',)})\n", (529, 591), False, 'from django.db import migrations, models\n'), ((738, 830), 'djan... |
# --*-- coding=utf-8 --*--
import io
from conf.config import SAVEFILE
def savefile(res):
with io.open(SAVEFILE, mode='a+', encoding='utf-8') as savefile:
if isinstance(res, basestring):
savefile.write(res.encode('utf-8') + u"\n")
savefile.flush()
elif isinstance(res, list... | [
"io.open"
] | [((102, 148), 'io.open', 'io.open', (['SAVEFILE'], {'mode': '"""a+"""', 'encoding': '"""utf-8"""'}), "(SAVEFILE, mode='a+', encoding='utf-8')\n", (109, 148), False, 'import io\n')] |
import hashlib
import uuid
from datetime import datetime
from skygear.container import SkygearContainer
from skygear.models import Record, RecordID, Reference
from skygear.options import options as skyoptions
from skygear.transmitter.encoding import serialize_record
from skygear.utils.context import current_user_id
... | [
"datetime.datetime.utcnow",
"skygear.utils.context.current_user_id",
"skygear.transmitter.encoding.serialize_record",
"skygear.models.RecordID"
] | [((1213, 1230), 'datetime.datetime.utcnow', 'datetime.utcnow', ([], {}), '()\n', (1228, 1230), False, 'from datetime import datetime\n'), ((1301, 1318), 'datetime.datetime.utcnow', 'datetime.utcnow', ([], {}), '()\n', (1316, 1318), False, 'from datetime import datetime\n'), ((1730, 1762), 'skygear.transmitter.encoding.... |
#!/usr/bin/env python
"""
Downloads Google's AudioSet dataset locally
"""
import argparse
import atexit
import collections
import csv
import logging.handlers
import multiprocessing as mp
import os
import random
import shutil
import sys
import traceback as tb
import urllib.request
from functools import partial
import m... | [
"os.remove",
"csv.reader",
"argparse.ArgumentParser",
"log.init_console_logger",
"random.shuffle",
"utils.get_filename",
"os.path.join",
"sys.stdin.isatty",
"utils.HTTP_ERR_PATTERN.match",
"utils.get_subset_name",
"pafy.new",
"os.path.exists",
"multiprocessing_logging.install_mp_handler",
... | [((1252, 1321), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Download AudioSet data locally"""'}), "(description='Download AudioSet data locally')\n", (1275, 1321), False, 'import argparse\n'), ((14755, 14797), 'utils.get_media_filename', 'get_media_filename', (['ytid', 'ts_start', 'ts... |
#!/usr/bin/env python2.7
# -*- coding: utf-8 -*-
import time
import Image
import ImageDraw
import ImageFont
from Adafruit_LED_Backpack import Matrix8x8
def print_8x8(image):
display.clear()
display.set_image(image)
display.write_display()
a = u'동해물과 백두산이 마르고 닳도록 하느님이 보우하사 '
display = Matrix8x8.Matr... | [
"ImageDraw.Draw",
"Image.new",
"ImageFont.truetype",
"time.sleep",
"Adafruit_LED_Backpack.Matrix8x8.Matrix8x8"
] | [((306, 327), 'Adafruit_LED_Backpack.Matrix8x8.Matrix8x8', 'Matrix8x8.Matrix8x8', ([], {}), '()\n', (325, 327), False, 'from Adafruit_LED_Backpack import Matrix8x8\n'), ((352, 377), 'Image.new', 'Image.new', (['"""1"""', '(1250, 8)'], {}), "('1', (1250, 8))\n", (361, 377), False, 'import Image\n'), ((384, 405), 'ImageD... |
import pyrealsense as pyrs
pyrs.start()
import datetime
import scipy.misc
class CameraCalibration(Sensor):
def __init__(self, dataStore, pattern, length=100):
## this is a trick to disable the recording later on
self.calibDone = False
self.cnt = -1
self.dataStore = dataStore
... | [
"pyrealsense.start",
"datetime.datetime.now"
] | [((28, 40), 'pyrealsense.start', 'pyrs.start', ([], {}), '()\n', (38, 40), True, 'import pyrealsense as pyrs\n'), ((479, 502), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (500, 502), False, 'import datetime\n'), ((2085, 2108), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (... |
# -*- coding: utf-8 -*-
# Generated by Django 1.10.2 on 2016-10-07 15:55
from __future__ import unicode_literals
import re
from django.core.validators import RegexValidator
from django.db import migrations, models
from django.conf import settings
import django.utils.timezone
script_regex = re.compile(r'(<script[\sa-... | [
"django.db.migrations.RunPython",
"django.db.models.TextField",
"django.db.migrations.RemoveField",
"django.db.models.CharField",
"django.db.models.ForeignKey",
"django.db.models.BooleanField",
"django.db.models.SlugField",
"django.db.models.DateTimeField",
"re.compile"
] | [((294, 364), 're.compile', 're.compile', (['"""(<script[\\\\sa-zA-Z0-9"\\\\\';-_=/]*>([\\\\s\\\\S]+?)</script>)"""'], {}), '(\'(<script[\\\\sa-zA-Z0-9"\\\\\\\';-_=/]*>([\\\\s\\\\S]+?)</script>)\')\n', (304, 364), False, 'import re\n'), ((6352, 6407), 'django.db.migrations.RunPython', 'migrations.RunPython', (['migrate... |
from aiogram import types
from aiogram.dispatcher.filters import Command
from aiogram.dispatcher.filters.builtin import CommandHelp
from loader import dp, db
from utils.misc import rate_limit
@rate_limit(5, 'help')
@dp.message_handler(CommandHelp())
async def bot_help(message: types.Message):
text = [
'Сп... | [
"utils.misc.rate_limit",
"aiogram.dispatcher.filters.Command",
"aiogram.dispatcher.filters.builtin.CommandHelp",
"loader.db.get_parcels_received",
"loader.db.get_parcels_created",
"loader.db.get_parcels_sent",
"loader.db.get_door_not_opened"
] | [((195, 216), 'utils.misc.rate_limit', 'rate_limit', (['(5)', '"""help"""'], {}), "(5, 'help')\n", (205, 216), False, 'from utils.misc import rate_limit\n'), ((237, 250), 'aiogram.dispatcher.filters.builtin.CommandHelp', 'CommandHelp', ([], {}), '()\n', (248, 250), False, 'from aiogram.dispatcher.filters.builtin import... |
from typing import OrderedDict
import ruamel
from ruamel.yaml import YAML
from ruamel.yaml.representer import RoundTripRepresenter
import sys
import os
yaml=YAML(pure=True) # default, if not specfied, is 'rt' (round-trip)
class MyRepresenter(RoundTripRepresenter):
pass
ruamel.yaml.add_representer(OrderedDict, ... | [
"ruamel.yaml.add_representer",
"os.scandir",
"ruamel.yaml.YAML"
] | [((158, 173), 'ruamel.yaml.YAML', 'YAML', ([], {'pure': '(True)'}), '(pure=True)\n', (162, 173), False, 'from ruamel.yaml import YAML\n'), ((279, 380), 'ruamel.yaml.add_representer', 'ruamel.yaml.add_representer', (['OrderedDict', 'MyRepresenter.represent_dict'], {'representer': 'MyRepresenter'}), '(OrderedDict, MyRepr... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
## For Testing Matrix2vec on dataset MNIST
## PCA, Kernel PCA, ISOMAP, NMDS, LLE, LE
# import tensorflow as ts
import logging
import os.path
import sys
import multiprocessing
import numpy as np
import argparse
import scipy.io
import datetime
import matrix2vec
from skle... | [
"sklearn.model_selection.GridSearchCV",
"gzip.open",
"sklearn.preprocessing.scale",
"sklearn.model_selection.cross_val_score",
"numpy.zeros",
"sklearn.neighbors.KNeighborsClassifier",
"pickle.load",
"numpy.array",
"sklearn.datasets.load_svmlight_file",
"sklearn.decomposition.PCA",
"matrix2vec.ma... | [((1143, 1170), 'sklearn.datasets.load_svmlight_file', 'ds.load_svmlight_file', (['path'], {}), '(path)\n', (1164, 1170), True, 'from sklearn import datasets as ds\n'), ((1273, 1299), 'gzip.open', 'gzip.open', (['data_file', '"""rb"""'], {}), "(data_file, 'rb')\n", (1282, 1299), False, 'import gzip\n'), ((1363, 1395), ... |
# first motor test
import pin
import time
# load the configuration from config1.json
pin.load("config1.json")
print("foreward")
pin.Out("in1",1)
pin.Out("in2",0)
pin.Out("ena",1)
time.sleep(3)
print("backward")
pin.Out("in1",0)
pin.Out("in2",1)
pin.Out("ena",1)
time.sleep(3)
pin.Out("ena",0)
print("stop")
# reset... | [
"pin.load",
"pin.Out",
"pin.cleanup",
"time.sleep"
] | [((86, 110), 'pin.load', 'pin.load', (['"""config1.json"""'], {}), "('config1.json')\n", (94, 110), False, 'import pin\n'), ((130, 147), 'pin.Out', 'pin.Out', (['"""in1"""', '(1)'], {}), "('in1', 1)\n", (137, 147), False, 'import pin\n'), ((147, 164), 'pin.Out', 'pin.Out', (['"""in2"""', '(0)'], {}), "('in2', 0)\n", (1... |
import collections
import datetime
import importlib
import math
import os.path
import pprint
import random
import subprocess
import sys
import git
import numpy as np
import sacred
import tensorboardX
import torch
import tqdm
def git_revision():
return subprocess.check_output("git rev-parse --short HEAD".split())... | [
"pprint.pformat",
"torch.nn.ReLU",
"importlib.import_module",
"torch.nn.Sequential",
"math.ceil",
"torch.manual_seed",
"torch.load",
"torch.nn.init.uniform_",
"git.Repo",
"torch.set_default_tensor_type",
"torch.cat",
"torch.cuda.manual_seed_all",
"random.seed",
"pprint.pprint",
"torch.cu... | [((2682, 2699), 'git.Repo', 'git.Repo', (['"""../.."""'], {}), "('../..')\n", (2690, 2699), False, 'import git\n'), ((3086, 3183), 'torch.set_default_tensor_type', 'torch.set_default_tensor_type', (["('torch.cuda.FloatTensor' if args.cuda else 'torch.FloatTensor')"], {}), "('torch.cuda.FloatTensor' if args.cuda else\n ... |
from django.shortcuts import render , redirect
from django.contrib.auth import authenticate,login, get_user_model
from django.http import HttpResponse
from django.contrib.auth.views import LogoutView
from django.utils.http import is_safe_url
from .forms import LoginForm,RegisterForm,GuestForm
from .models import GuestE... | [
"django.shortcuts.redirect",
"django.contrib.auth.get_user_model",
"django.contrib.auth.authenticate",
"django.shortcuts.render",
"django.contrib.auth.login"
] | [((1659, 1675), 'django.contrib.auth.get_user_model', 'get_user_model', ([], {}), '()\n', (1673, 1675), False, 'from django.contrib.auth import authenticate, login, get_user_model\n'), ((872, 894), 'django.shortcuts.redirect', 'redirect', (['"""/register/"""'], {}), "('/register/')\n", (880, 894), False, 'from django.s... |
# ##### BEGIN GPL LICENSE BLOCK #####
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is ... | [
"bpy.utils.unregister_module",
"bpy.utils.register_module",
"bpy.props.StringProperty"
] | [((2815, 2841), 'bpy.props.StringProperty', 'bpy.props.StringProperty', ([], {}), '()\n', (2839, 2841), False, 'import bpy, os, mathutils\n'), ((4775, 4810), 'bpy.utils.register_module', 'bpy.utils.register_module', (['__name__'], {}), '(__name__)\n', (4800, 4810), False, 'import bpy, os, mathutils\n'), ((4847, 4884), ... |
#!/usr/bin/env python
import logging
import time
import redis
import uwatch2lib
from acme_notifications.instance import settings
log = logging.getLogger(__name__)
def main():
logging.basicConfig(level=logging.DEBUG, format="%(levelname)-8s %(message)s")
log.info("Starting forwarding from Redis to BLE")
... | [
"redis.Redis",
"uwatch2lib.Uwatch2",
"logging.basicConfig",
"time.sleep",
"logging.getLogger"
] | [((139, 166), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (156, 166), False, 'import logging\n'), ((185, 263), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.DEBUG', 'format': '"""%(levelname)-8s %(message)s"""'}), "(level=logging.DEBUG, format='%(levelname)-8s %... |
import os, sys
import pandas as pd
import numpy as np
import integer_polyomino.scripts.graph_topo as gt
def genome_metric_preprocess(df):
iso_groups(df)
df['Iso_index'] = df['Iso_index'].astype(np.uint8)
df['original'] = df['original'].astype('category')
df['pIDs'] = df['pIDs'].apply(lambda x: str(eva... | [
"os.path.join"
] | [((2024, 2058), 'os.path.join', 'os.path.join', (['file_path', 'file_name'], {}), '(file_path, file_name)\n', (2036, 2058), False, 'import os, sys\n')] |
import os
import numpy as np
import logging
log = logging.getLogger('data_utils')
def resample_ants(nii_file, nii_file_newres, new_res=(1.37, 1.37, 10, 1)):
'''
Call ANTs to resample an image to a given resolution and save a new resampled file.
:param nii_file: the path of the input file
:param... | [
"numpy.pad",
"numpy.random.seed",
"numpy.random.shuffle",
"numpy.ceil",
"numpy.concatenate",
"numpy.empty",
"numpy.min",
"numpy.array",
"logging.getLogger"
] | [((50, 81), 'logging.getLogger', 'logging.getLogger', (['"""data_utils"""'], {}), "('data_utils')\n", (67, 81), False, 'import logging\n'), ((4156, 4188), 'numpy.array', 'np.array', (['[data[i] for i in idx]'], {}), '([data[i] for i in idx])\n', (4164, 4188), True, 'import numpy as np\n'), ((1692, 1731), 'numpy.min', '... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# @Time : 2021/10/12 6:00 下午
# @Author : <NAME>
# @File : setup.py.py
# @Software: PyCharm
import setuptools
with open('README.md', 'r', encoding='utf-8') as fh:
long_description = fh.read()
setuptools.setup(
name='whrtest',
version='0.0.1',
author='<N... | [
"setuptools.find_packages"
] | [((479, 505), 'setuptools.find_packages', 'setuptools.find_packages', ([], {}), '()\n', (503, 505), False, 'import setuptools\n')] |
from mmdet.apis import init_detector, inference_detector, show_result_pyplot
import mmcv
import cv2
import numpy as np
import time
import sys
import glob
import os
from datetime import datetime
def process_video_crcnn(frame_offset, frame_count, config_file, checkpoint_file, video_path):
"""
frame_offset: skipp... | [
"numpy.full",
"numpy.concatenate",
"os.path.join",
"cv2.imwrite",
"mmdet.apis.init_detector",
"mmdet.apis.inference_detector",
"mmcv.VideoReader",
"time.time",
"cv2.imread",
"cv2.rectangle",
"datetime.datetime.now",
"numpy.vstack"
] | [((504, 532), 'mmcv.VideoReader', 'mmcv.VideoReader', (['video_path'], {}), '(video_path)\n', (520, 532), False, 'import mmcv\n'), ((545, 605), 'mmdet.apis.init_detector', 'init_detector', (['config_file', 'checkpoint_file'], {'device': '"""cuda:0"""'}), "(config_file, checkpoint_file, device='cuda:0')\n", (558, 605), ... |
import logging
import io, os
import sys
import threading
import time
from collections import deque
from os.path import expanduser
import PIL
from PIL import Image, ImageFile
from cobiv.modules.core.entity import Entity
ImageFile.LOAD_TRUNCATED_IMAGES = True
class ThumbLoader(Entity):
logger = logging.getLogger... | [
"threading.Thread",
"io.BytesIO",
"os.path.join",
"os.path.basename",
"os.path.dirname",
"os.path.exists",
"logging.getLogger",
"time.sleep",
"os.path.expanduser",
"collections.deque"
] | [((303, 330), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (320, 330), False, 'import logging\n'), ((424, 431), 'collections.deque', 'deque', ([], {}), '()\n', (429, 431), False, 'from collections import deque\n'), ((1488, 1521), 'threading.Thread', 'threading.Thread', ([], {'target': '... |
#!/usr/bin/env python
import argparse
parser = argparse.ArgumentParser(description="Use the last runs to set the nuisance Chebyshev and covariance parameters.")
parser.add_argument("rundir", help="The relative path to the output directory containing the samples.")
args = parser.parse_args()
import Starfish
from Star... | [
"Starfish.utils.h5read",
"Starfish.model.PhiParam.load",
"Starfish.specfmt.format",
"argparse.ArgumentParser"
] | [((49, 172), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Use the last runs to set the nuisance Chebyshev and covariance parameters."""'}), "(description=\n 'Use the last runs to set the nuisance Chebyshev and covariance parameters.'\n )\n", (72, 172), False, 'import argparse\n')... |
import numpy as np
def add_noise(a):
if len(a.shape) == 2:
b = np.random.rand(a.shape[0], a.shape[1])
return a + b
else:
return a
def dot_product(a, b):
if len(a.shape) == 2 and len(b.shape) == 1 and a.shape[1] == b.shape[0]:
return a.dot(b)
else:
return "Inco... | [
"numpy.random.rand",
"numpy.eye",
"numpy.ones"
] | [((391, 402), 'numpy.eye', 'np.eye', (['dim'], {}), '(dim)\n', (397, 402), True, 'import numpy as np\n'), ((411, 426), 'numpy.ones', 'np.ones', (['(dim,)'], {}), '((dim,))\n', (418, 426), True, 'import numpy as np\n'), ((76, 114), 'numpy.random.rand', 'np.random.rand', (['a.shape[0]', 'a.shape[1]'], {}), '(a.shape[0], ... |