code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
"""
比requests更强大python库，让你的爬虫效率提高一倍
https://mp.weixin.qq.com/s/jqGx-4t4ytDDnXxDkzbPqw
HTTPX 基础教程
https://zhuanlan.zhihu.com/p/103824900
"""
def interface(url, data):
import httpx
head = {"Content-Type": "application/json; charset=UTF-8"}
return httpx.request('POST', url, json=data, headers=head)
if __... | [
"httpx.request"
] | [((261, 312), 'httpx.request', 'httpx.request', (['"""POST"""', 'url'], {'json': 'data', 'headers': 'head'}), "('POST', url, json=data, headers=head)\n", (274, 312), False, 'import httpx\n')] |
from http import HTTPStatus
from typing import Tuple
from uuid import UUID
from fastapi import status, APIRouter, Response, Depends, HTTPException
from command.command_handler import Status
from domain.classroom.classroom_creation_command_handler import ClassroomCreated
from domain.classroom.classroom_type import Cla... | [
"fastapi.HTTPException",
"web.presentation.service.classroom_service.get_detailed_classroom",
"web.schema.classroom_response.ClassroomReadResponse.to_duration",
"fastapi.APIRouter",
"fastapi.Depends"
] | [((877, 888), 'fastapi.APIRouter', 'APIRouter', ([], {}), '()\n', (886, 888), False, 'from fastapi import status, APIRouter, Response, Depends, HTTPException\n'), ((1825, 1852), 'fastapi.Depends', 'Depends', (['CommandBusProvider'], {}), '(CommandBusProvider)\n', (1832, 1852), False, 'from fastapi import status, APIRou... |
import logging
l = logging.getLogger("angr.codenode")
class CodeNode(object):
__slots__ = ['addr', 'size', '_graph', 'thumb']
def __init__(self, addr, size, graph=None, thumb=False):
self.addr = addr
self.size = size
self.thumb = thumb
self._graph = graph
def __len__(sel... | [
"logging.getLogger"
] | [((19, 53), 'logging.getLogger', 'logging.getLogger', (['"""angr.codenode"""'], {}), "('angr.codenode')\n", (36, 53), False, 'import logging\n')] |
import os
scrapy_project_path = '/Users/kingname/book/chapter_12/DeploySpider'
os.chdir(scrapy_project_path) #切换工作区，进入爬虫工程根目录执行命令
os.system('scrapyd-deploy')
import json
import time
import requests
start_url = 'http://45.76.110.210:6800/schedule.json'
start_data = {'project': 'DeploySpider',
'spider':... | [
"os.chdir",
"os.system",
"requests.post"
] | [((81, 110), 'os.chdir', 'os.chdir', (['scrapy_project_path'], {}), '(scrapy_project_path)\n', (89, 110), False, 'import os\n'), ((132, 159), 'os.system', 'os.system', (['"""scrapyd-deploy"""'], {}), "('scrapyd-deploy')\n", (141, 159), False, 'import os\n'), ((431, 501), 'requests.post', 'requests.post', (['start_url']... |
from __future__ import print_function, division, absolute_import
import itertools
import sys
# unittest only added in 3.4 self.subTest()
if sys.version_info[0] < 3 or sys.version_info[1] < 4:
import unittest2 as unittest
else:
import unittest
# unittest.mock is not available in 2.7 (though unittest2 might cont... | [
"numpy.clip",
"numpy.prod",
"imgaug.random.RNG",
"imgaug.parameters.Choice",
"mock.Mock",
"imgaug.parameters.Uniform",
"imgaug.parameters.draw_distributions_grid",
"imgaug.parameters.handle_discrete_param",
"numpy.array",
"six.moves.xrange",
"imgaug.parameters.handle_continuous_param",
"imgaug... | [((422, 443), 'matplotlib.use', 'matplotlib.use', (['"""Agg"""'], {}), "('Agg')\n", (436, 443), False, 'import matplotlib\n'), ((789, 808), 'imgaug.is_np_array', 'ia.is_np_array', (['arr'], {}), '(arr)\n', (803, 808), True, 'import imgaug as ia\n'), ((1005, 1112), 'imgaug.parameters.handle_continuous_param', 'iap.handl... |
import os
import databases
import sqlalchemy
DB_CONNECTOR = os.getenv('APP_DB_CONNECTOR')
DB_USERNAME = os.getenv('APP_DB_USERNAME')
DB_PASSWORD = os.getenv('APP_DB_PASSWORD')
DB_HOST = os.getenv('APP_DB_HOST')
DB_PORT = os.getenv('APP_DB_PORT')
DB_DATABASE = os.getenv('APP_DB_DATABASE')
DB_URL = f'{DB_CONNECTOR}://... | [
"sqlalchemy.MetaData",
"databases.Database",
"os.getenv"
] | [((62, 91), 'os.getenv', 'os.getenv', (['"""APP_DB_CONNECTOR"""'], {}), "('APP_DB_CONNECTOR')\n", (71, 91), False, 'import os\n'), ((106, 134), 'os.getenv', 'os.getenv', (['"""APP_DB_USERNAME"""'], {}), "('APP_DB_USERNAME')\n", (115, 134), False, 'import os\n'), ((149, 177), 'os.getenv', 'os.getenv', (['"""APP_DB_PASSW... |
import os
import time
import argparse
import torchvision
import torch
import torch.nn as nn
from util import AverageMeter, TwoAugUnsupervisedDataset
from encoder import SmallAlexNet
from align_uniform import align_loss, uniform_loss
import json
def parse_option():
parser = argparse.ArgumentParser('STL-10 Repres... | [
"torch.optim.lr_scheduler.MultiStepLR",
"torchvision.transforms.ColorJitter",
"argparse.ArgumentParser",
"torchvision.datasets.STL10",
"align_uniform.uniform_loss",
"util.RandomResizedCropWithBox",
"torchvision.transforms.ToTensor",
"torchvision.transforms.RandomHorizontalFlip",
"torchvision.transfo... | [((282, 381), 'argparse.ArgumentParser', 'argparse.ArgumentParser', (['"""STL-10 Representation Learning with Alignment and Uniformity Losses"""'], {}), "(\n 'STL-10 Representation Learning with Alignment and Uniformity Losses')\n", (305, 381), False, 'import argparse\n'), ((2851, 2892), 'os.path.join', 'os.path.joi... |
# SPDX-License-Identifier: Apache-2.0
# Copyright(c) 2021 Open Networking Foundation
import time
from ipaddress import IPv4Address
from pprint import pprint
from trex_test import TrexTest
from grpc_test import *
from trex_stl_lib.api import (
STLVM,
STLPktBuilder,
STLStream,
STLTXCont,
)
import ptf.t... | [
"ptf.testutils.simple_udp_packet",
"ipaddress.IPv4Address",
"trex_stl_lib.api.STLTXCont",
"time.sleep",
"trex_stl_lib.api.STLVM",
"time.time",
"trex_stl_lib.api.STLPktBuilder"
] | [((901, 928), 'ipaddress.IPv4Address', 'IPv4Address', (['"""172.16.17.32"""'], {}), "('172.16.17.32')\n", (912, 928), False, 'from ipaddress import IPv4Address\n'), ((988, 1015), 'ipaddress.IPv4Address', 'IPv4Address', (['"""10.128.13.29"""'], {}), "('10.128.13.29')\n", (999, 1015), False, 'from ipaddress import IPv4Ad... |
# -*- coding: utf-8 -*-
##############################################################################
# Copyright (c) 2017 Science and Technology Facilities Council
#
# All rights reserved.
#
# Modifications made as part of the fparser project are distributed
# under the following license:
#
# Redistribution and use i... | [
"pytest.raises",
"fparser.api.parse",
"re.compile"
] | [((6763, 6813), 'fparser.api.parse', 'api.parse', (['source_str'], {'isfree': '(True)', 'isstrict': '(False)'}), '(source_str, isfree=True, isstrict=False)\n', (6772, 6813), False, 'from fparser import api\n'), ((7035, 7085), 'fparser.api.parse', 'api.parse', (['source_str'], {'isfree': '(True)', 'isstrict': '(False)'}... |
import curtsies.events as ev
import sys
DELIMITERS = ' .'
WHITESPACE = ' '
def print_console(txt, npadding=0, newline=False, flush=True):
"""
Prints txt without newline, cursor positioned at the end.
:param txt: The text to print
:param length: The txt will be padded with spaces to fit this length
... | [
"sys.stdout.flush",
"sys.stdout.write"
] | [((589, 611), 'sys.stdout.write', 'sys.stdout.write', (['"""\n"""'], {}), "('\\n')\n", (605, 611), False, 'import sys\n'), ((616, 634), 'sys.stdout.flush', 'sys.stdout.flush', ([], {}), '()\n', (632, 634), False, 'import sys\n'), ((497, 519), 'sys.stdout.write', 'sys.stdout.write', (['"""\n"""'], {}), "('\\n')\n", (513... |
# -*- coding: utf-8 -*-
'''
:synopsis: Unit Tests for Windows Registry Module 'module.reg'
:platform: Windows
:maturity: develop
:codeauthor: <NAME> <https://github.com/damon-atkins>
versionadded:: 2016.11.0
'''
# Import Python future libs
from __future__ import absolute_import
from __future__ impor... | [
"salt.ext.six.moves.winreg.QueryValueEx",
"salt.modules.reg.read_value",
"salt.ext.six.moves.winreg.CreateKeyEx",
"salt.modules.reg.delete_value",
"salt.modules.reg.set_value",
"salt.ext.six.moves.winreg.CloseKey",
"time.strftime",
"salt.ext.six.moves.winreg.OpenKey",
"salt.modules.reg.list_keys",
... | [((1607, 1681), 'tests.support.unit.skipIf', 'skipIf', (['NO_WINDOWS_MODULES', '"""requires Windows OS to test Windows registry"""'], {}), "(NO_WINDOWS_MODULES, 'requires Windows OS to test Windows registry')\n", (1613, 1681), False, 'from tests.support.unit import TestCase, skipIf\n'), ((965, 976), 'time.time', 'time.... |
from blaze import compute, resource, symbol, discover
from blaze.utils import example
flag = [False]
def mymap(func, *args):
flag[0] = True
return map(func, *args)
def test_map_called_on_resource_star():
r = resource(example('accounts_*.csv'))
s = symbol('s', discover(r))
flag[0] = False
a ... | [
"blaze.utils.example",
"blaze.discover"
] | [((234, 259), 'blaze.utils.example', 'example', (['"""accounts_*.csv"""'], {}), "('accounts_*.csv')\n", (241, 259), False, 'from blaze.utils import example\n'), ((281, 292), 'blaze.discover', 'discover', (['r'], {}), '(r)\n', (289, 292), False, 'from blaze import compute, resource, symbol, discover\n')] |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
mwtab.mwschema
~~~~~~~~~~~~~~
This module provides schema definitions for different sections of the
``mwTab`` Metabolomics Workbench format.
"""
import sys
from schema import Schema, Optional, Or
if sys.version_info.major == 2:
str = unicode
metabolomics_wor... | [
"schema.Optional",
"schema.Schema",
"schema.Or"
] | [((14489, 14532), 'schema.Schema', 'Schema', (["{'Units': str, 'Data': data_schema}"], {}), "({'Units': str, 'Data': data_schema})\n", (14495, 14532), False, 'from schema import Schema, Optional, Or\n'), ((409, 429), 'schema.Optional', 'Optional', (['"""STUDY_ID"""'], {}), "('STUDY_ID')\n", (417, 429), False, 'from sch... |
"""
flux related class and functions
"""
from scipy.integrate import quad
import pandas as pd
from .helper import LinearInterp, polar_to_cartesian, lorentz_boost, lorentz_matrix
from .oscillation import survival_solar
from .parameters import *
def _invs(ev):
return 1/ev**2
class FluxBaseContinuous:
def ... | [
"pandas.DataFrame",
"scipy.integrate.quad"
] | [((61687, 61743), 'pandas.DataFrame', 'pd.DataFrame', (["{'time': self.time, 'energy': self.energy}"], {}), "({'time': self.time, 'energy': self.energy})\n", (61699, 61743), True, 'import pandas as pd\n'), ((10282, 10308), 'scipy.integrate.quad', 'quad', (['fx', 'emin', 'self.evMax'], {}), '(fx, emin, self.evMax)\n', (... |
# Author : <NAME> "blackdaemon"
# Email : <EMAIL>
#
# Copyright (c) 2010, <NAME> <<EMAIL>>
# 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 code must retain the... | [
"random.randint",
"enso.messages.MessageManager.get",
"enso.commands.CommandManager.get",
"enso.messages.TimedMiniMessage",
"enso.contrib.scriptotron.ensoapi.EnsoApi",
"xml.sax.saxutils.escape"
] | [((2409, 2418), 'enso.contrib.scriptotron.ensoapi.EnsoApi', 'EnsoApi', ([], {}), '()\n', (2416, 2418), False, 'from enso.contrib.scriptotron.ensoapi import EnsoApi\n'), ((6830, 6850), 'enso.commands.CommandManager.get', 'CommandManager.get', ([], {}), '()\n', (6848, 6850), False, 'from enso.commands import CommandManag... |
import unittest
class PerlinTestCase(unittest.TestCase):
def test_perlin_1d_range(self):
from noise import pnoise1
for i in range(-10000, 10000):
x = i * 0.49
n = pnoise1(x)
self.assertTrue(-1.0 <= n <= 1.0, (x, n))
def test_perlin_1d_octaves_range(self):
... | [
"noise.snoise3",
"noise.snoise4",
"noise.pnoise1",
"noise.snoise2",
"noise.pnoise3",
"unittest.main",
"noise.pnoise2",
"noise.randomize"
] | [((4699, 4714), 'unittest.main', 'unittest.main', ([], {}), '()\n', (4712, 4714), False, 'import unittest\n'), ((210, 220), 'noise.pnoise1', 'pnoise1', (['x'], {}), '(x)\n', (217, 220), False, 'from noise import pnoise1\n'), ((651, 663), 'noise.pnoise1', 'pnoise1', (['(0.5)'], {}), '(0.5)\n', (658, 663), False, 'from n... |
#!/usr/bin/env python3
import os
import shutil
import sys
import pathlib
import logging
# I will NEVER EVER use subproccess again
# At least not for something like Popen
try:
from sh import wget
except Exception:
print('[!] Just install sh right now!(pip install --user sh)')
sys.exit(0)
# Dumb Python2 sup... | [
"os.path.abspath",
"sh.wget",
"sys.exit"
] | [((2357, 2460), 'sh.wget', 'wget', (['"""-m"""', 'url', '"""-P"""', 'dir_name'], {'_iter': '(True)', '_err_to_out': '(True)', '_out_bufsize': '(1)', '_ok_code': 'exit_codes'}), "('-m', url, '-P', dir_name, _iter=True, _err_to_out=True, _out_bufsize=\n 1, _ok_code=exit_codes)\n", (2361, 2460), False, 'from sh import ... |
import ase
from ase import Atoms
from ase.atom import Atom
import sys
from ase.visualize import view
import pickle
f = open(sys.argv[1],'r') #The .amc file
p = pickle.load(f)
positions = p['atomspositions']
atms = Atoms()
for p0 in positions:
a = Atom('Au',position=p0)
atms.append(a)
atms.center(vacuum=2)
view(atm... | [
"ase.Atoms",
"pickle.load",
"ase.visualize.view",
"ase.atom.Atom"
] | [((160, 174), 'pickle.load', 'pickle.load', (['f'], {}), '(f)\n', (171, 174), False, 'import pickle\n'), ((215, 222), 'ase.Atoms', 'Atoms', ([], {}), '()\n', (220, 222), False, 'from ase import Atoms\n'), ((312, 322), 'ase.visualize.view', 'view', (['atms'], {}), '(atms)\n', (316, 322), False, 'from ase.visualize impor... |
import json
def Config(config_path):
with open(config_path) as config_file:
return json.load(config_file)
| [
"json.load"
] | [((96, 118), 'json.load', 'json.load', (['config_file'], {}), '(config_file)\n', (105, 118), False, 'import json\n')] |
"""编译go语言模块."""
import warnings
from typing import List, Optional
from pathlib import Path
from pmfp.utils.run_command_utils import run
def _build_grpc(includes: str, flag: str, to: str, target: str, cwd: Path) -> None:
command = f"protoc {includes} {flag} --go_out={to} --go-grpc_out={to} {target}"
try:
... | [
"pmfp.utils.run_command_utils.run"
] | [((323, 358), 'pmfp.utils.run_command_utils.run', 'run', (['command'], {'cwd': 'cwd', 'visible': '(True)'}), '(command, cwd=cwd, visible=True)\n', (326, 358), False, 'from pmfp.utils.run_command_utils import run\n')] |
import json
import logging
from flask import jsonify, make_response, request
from flask_jwt_extended import jwt_required
from flask_restful import Resource
from http import HTTPStatus
from marshmallow import ValidationError, Schema
from werkzeug.security import generate_password_hash
from app.models import db
from ap... | [
"logging.getLogger",
"app.models.user.User",
"app.models.user.User.query.filter_by",
"marshmallow.ValidationError",
"app.api.utils.get_url",
"flask.request.get_json",
"werkzeug.security.generate_password_hash",
"app.models.db.session.rollback",
"app.models.db.session.commit",
"app.models.db.sessio... | [((449, 476), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (466, 476), False, 'import logging\n'), ((1646, 1664), 'flask.request.get_json', 'request.get_json', ([], {}), '()\n', (1662, 1664), False, 'from flask import jsonify, make_response, request\n'), ((2302, 2342), 'werkzeug.securit... |
import numpy as np
from mpi4py import MPI
from src.imagine.goal_generator.simple_sentence_generator import SentenceGeneratorHeuristic
from src import logger
class GoalSampler:
def __init__(self,
policy_language_model,
reward_language_model,
goal_dim,
... | [
"numpy.random.normal",
"numpy.tile",
"src.logger.info",
"numpy.repeat",
"mpi4py.MPI.COMM_WORLD.bcast",
"numpy.random.choice",
"numpy.random.random",
"numpy.where",
"src.imagine.goal_generator.simple_sentence_generator.SentenceGeneratorHeuristic",
"numpy.array",
"mpi4py.MPI.COMM_WORLD.scatter",
... | [((1608, 1770), 'src.imagine.goal_generator.simple_sentence_generator.SentenceGeneratorHeuristic', 'SentenceGeneratorHeuristic', (["params['train_descriptions']", "params['test_descriptions']"], {'sentences': 'None', 'method': "params['conditions']['imagination_method']"}), "(params['train_descriptions'], params[\n ... |
from Qt import QtWidgets, QtGui
from .categories import (
CategoryState,
SystemWidget,
ProjectWidget
)
from .widgets import ShadowWidget
from .. import style
class MainWidget(QtWidgets.QWidget):
widget_width = 1000
widget_height = 600
def __init__(self, user_role, parent=None):
super(... | [
"Qt.QtWidgets.QTabWidget",
"Qt.QtWidgets.QApplication.instance",
"Qt.QtWidgets.QVBoxLayout"
] | [((682, 715), 'Qt.QtWidgets.QTabWidget', 'QtWidgets.QTabWidget', ([], {'parent': 'self'}), '(parent=self)\n', (702, 715), False, 'from Qt import QtWidgets, QtGui\n'), ((1079, 1106), 'Qt.QtWidgets.QVBoxLayout', 'QtWidgets.QVBoxLayout', (['self'], {}), '(self)\n', (1100, 1106), False, 'from Qt import QtWidgets, QtGui\n')... |
import uuid
from mongoengine import Document, StringField, ListField, UUIDField
from django.conf import settings
from cripts.core.cripts_mongoengine import CriptsBaseAttributes, CriptsSourceDocument
from cripts.core.cripts_mongoengine import CriptsActionsDocument
class UserName(CriptsBaseAttributes, CriptsSourceDoc... | [
"mongoengine.ListField",
"mongoengine.UUIDField",
"mongoengine.StringField"
] | [((1994, 2020), 'mongoengine.StringField', 'StringField', ([], {'required': '(True)'}), '(required=True)\n', (2005, 2020), False, 'from mongoengine import Document, StringField, ListField, UUIDField\n'), ((2039, 2065), 'mongoengine.StringField', 'StringField', ([], {'required': '(True)'}), '(required=True)\n', (2050, 2... |
import pytest
import operator as op
from sweetpea import fully_cross_block
from sweetpea.primitives import Factor, DerivedLevel, WithinTrial, Transition, Window
from sweetpea.encoding_diagram import __generate_encoding_diagram
color = Factor("color", ["red", "blue"])
text = Factor("text", ["red", "blue"])
con_lev... | [
"sweetpea.primitives.Window",
"sweetpea.primitives.Factor",
"sweetpea.primitives.WithinTrial",
"sweetpea.primitives.Transition",
"sweetpea.encoding_diagram.__generate_encoding_diagram",
"sweetpea.fully_cross_block"
] | [((238, 270), 'sweetpea.primitives.Factor', 'Factor', (['"""color"""', "['red', 'blue']"], {}), "('color', ['red', 'blue'])\n", (244, 270), False, 'from sweetpea.primitives import Factor, DerivedLevel, WithinTrial, Transition, Window\n'), ((279, 310), 'sweetpea.primitives.Factor', 'Factor', (['"""text"""', "['red', 'bl... |
import yaml
import os
import time
import datetime
from pycti.utils.constants import StixCyberObservableTypes
from weasyprint import HTML
from pycti import OpenCTIConnectorHelper, get_config_variable
from jinja2 import Environment, FileSystemLoader
class ExportReportPdf:
def __init__(self):
# Instantiate t... | [
"pycti.get_config_variable",
"pycti.utils.constants.StixCyberObservableTypes.has_value",
"os.path.join",
"time.sleep",
"pycti.OpenCTIConnectorHelper",
"os.path.dirname",
"os.path.isfile",
"datetime.datetime.now",
"weasyprint.HTML",
"os.path.abspath",
"jinja2.FileSystemLoader"
] | [((627, 657), 'pycti.OpenCTIConnectorHelper', 'OpenCTIConnectorHelper', (['config'], {}), '(config)\n', (649, 657), False, 'from pycti import OpenCTIConnectorHelper, get_config_variable\n'), ((739, 845), 'pycti.get_config_variable', 'get_config_variable', (['"""EXPORT_REPORT_PDF_PRIMARY_COLOR"""', "['export_report_pdf'... |
from django.urls import path
from .views import initiate_payment, callback
urlpatterns = [
path('', initiate_payment, name='pay'),
path('callback/', callback, name='callback'),
]
| [
"django.urls.path"
] | [((96, 134), 'django.urls.path', 'path', (['""""""', 'initiate_payment'], {'name': '"""pay"""'}), "('', initiate_payment, name='pay')\n", (100, 134), False, 'from django.urls import path\n'), ((140, 184), 'django.urls.path', 'path', (['"""callback/"""', 'callback'], {'name': '"""callback"""'}), "('callback/', callback,... |
# -*- coding: utf-8 -*-
__author__ = "<NAME> <<EMAIL>>"
"""
config.py
- settings for the flask application object
"""
import os
import redis
from sweetrpg_library_api.application import constants
class BaseConfig(object):
DEBUG = bool(os.environ.get(constants.DEBUG) or True)
PORT = os.environ.get(constant... | [
"os.environ.get"
] | [((681, 714), 'os.environ.get', 'os.environ.get', (['constants.DB_OPTS'], {}), '(constants.DB_OPTS)\n', (695, 714), False, 'import os\n'), ((1686, 1723), 'os.environ.get', 'os.environ.get', (['constants.SERVER_NAME'], {}), '(constants.SERVER_NAME)\n', (1700, 1723), False, 'import os\n'), ((297, 327), 'os.environ.get', ... |
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
import bisect
import numpy as np
from torch.utils.data.dataset import ConcatDataset as _ConcatDataset
class ConcatDataset(_ConcatDataset):
"""
Same as torch.utils.data.dataset.ConcatDataset, but exposes an extra
method for querying t... | [
"torch.utils.data.dataset.ConcatDataset.__init__",
"numpy.random.randint",
"bisect.bisect_right"
] | [((411, 450), 'torch.utils.data.dataset.ConcatDataset.__init__', '_ConcatDataset.__init__', (['self', 'datasets'], {}), '(self, datasets)\n', (434, 450), True, 'from torch.utils.data.dataset import ConcatDataset as _ConcatDataset\n'), ((798, 860), 'numpy.random.randint', 'np.random.randint', (['(0)', '(self.cumulative_... |
import os
class Config:
# Statement for enabling the development environment
DEBUG = True
# Define the application directory
BASE_DIR = os.path.abspath(os.path.dirname(__file__))
# Logging config.
LOG_DIR = "logs"
LOG_TYPE = ["LOG_TYPE", "watched"]
LOG_LEVEL = "DEBUG"
APP_LOG_NAM... | [
"os.path.dirname"
] | [((171, 196), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (186, 196), False, 'import os\n')] |
from db_connection import db
class Agenda(db.Model):
__tablename__ = "agendas"
id = db.Column(db.Integer, primary_key=True)
date = db.Column(db.Date)
work_start = db.Column(db.Time)
work_end = db.Column(db.Time)
rest_start = db.Column(db.Time)
rest_end = db.Column(db.Time)
user_id = db... | [
"db_connection.db.Column",
"db_connection.db.relationship",
"db_connection.db.ForeignKey"
] | [((94, 133), 'db_connection.db.Column', 'db.Column', (['db.Integer'], {'primary_key': '(True)'}), '(db.Integer, primary_key=True)\n', (103, 133), False, 'from db_connection import db\n'), ((145, 163), 'db_connection.db.Column', 'db.Column', (['db.Date'], {}), '(db.Date)\n', (154, 163), False, 'from db_connection import... |
# Copyright (C) 2021 Intel Corporation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in wri... | [
"numpy.zeros",
"numpy.ones",
"mmdet.datasets.builder.PIPELINES.register_module",
"copy.deepcopy"
] | [((715, 742), 'mmdet.datasets.builder.PIPELINES.register_module', 'PIPELINES.register_module', ([], {}), '()\n', (740, 742), False, 'from mmdet.datasets.builder import PIPELINES\n'), ((2438, 2465), 'mmdet.datasets.builder.PIPELINES.register_module', 'PIPELINES.register_module', ([], {}), '()\n', (2463, 2465), False, 'f... |
# -*- coding: utf-8 -*-
# Generated by Django 1.11.3 on 2017-07-27 16:14
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('basic', '0002_auto_20170727_1741'),
]
operations = [
migrations.AddField(
... | [
"django.db.models.CharField"
] | [((409, 526), 'django.db.models.CharField', 'models.CharField', ([], {'default': '""""""', 'help_text': '"""Django function, with syntax: "app_name.function_name\\""""', 'max_length': '(100)'}), '(default=\'\', help_text=\n \'Django function, with syntax: "app_name.function_name"\', max_length=100)\n', (425, 526), F... |
from simple_network.tcp_app_server import *
import httptools
"""
Module Docstring
Docstrings: http://www.python.org/dev/peps/pep-0257/
"""
__author__ = 'ButenkoMS <<EMAIL>>'
# ======================================================================
# ===================GLOBAL SETTINGS FOR ALL TESTS===================... | [
"httptools.parse_url",
"httptools.HttpRequestParser"
] | [((4859, 4892), 'httptools.HttpRequestParser', 'httptools.HttpRequestParser', (['self'], {}), '(self)\n', (4886, 4892), False, 'import httptools\n'), ((7194, 7232), 'httptools.parse_url', 'httptools.parse_url', (['self._current_url'], {}), '(self._current_url)\n', (7213, 7232), False, 'import httptools\n')] |
"""
Link extractor based on lxml.html
"""
import lxml.html
from scrapy.link import Link
from scrapy.utils.python import unique as unique_list
class LxmlParserLinkExtractor(object):
def __init__(self, tag="a", attr="href", process=None, unique=False):
self.scan_tag = tag if callable(tag) else lambda t: t ... | [
"scrapy.utils.python.unique"
] | [((933, 983), 'scrapy.utils.python.unique', 'unique_list', (['self.links'], {'key': '(lambda link: link.url)'}), '(self.links, key=lambda link: link.url)\n', (944, 983), True, 'from scrapy.utils.python import unique as unique_list\n')] |
import numpy as np
import argparse
from sklearn.svm import LinearSVR
from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_regression
parser = argparse.ArgumentParser()
parser.add_argument('-x', '--datapath', type=str, required=True)
parser.add_a... | [
"argparse.ArgumentParser",
"sklearn.svm.LinearSVR",
"sklearn.preprocessing.StandardScaler",
"numpy.savetxt",
"numpy.load"
] | [((217, 242), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (240, 242), False, 'import argparse\n'), ((538, 579), 'numpy.load', 'np.load', (['args.datapath'], {'allow_pickle': '(True)'}), '(args.datapath, allow_pickle=True)\n', (545, 579), True, 'import numpy as np\n'), ((584, 623), 'numpy.loa... |
from guardian.shortcuts import get_objects_for_user
from django.http import Http404, HttpResponseRedirect
from django.db.models import Count
from django.core.urlresolvers import reverse
from django.shortcuts import render, get_object_or_404
from vdw.samples.models import Sample, Project, Batch, Cohort
from .forms impor... | [
"django.shortcuts.render",
"django.db.models.Count",
"vdw.samples.models.Sample.objects.filter",
"vdw.samples.models.Sample.objects.all",
"django.shortcuts.get_object_or_404",
"guardian.shortcuts.get_objects_for_user",
"vdw.samples.models.Cohort.objects.all",
"django.core.urlresolvers.reverse",
"vdw... | [((373, 431), 'guardian.shortcuts.get_objects_for_user', 'get_objects_for_user', (['request.user', '"""samples.view_project"""'], {}), "(request.user, 'samples.view_project')\n", (393, 431), False, 'from guardian.shortcuts import get_objects_for_user\n'), ((451, 482), 'django.db.models.Count', 'Count', (['"""batches"""... |
#!/usr/bin/env python3
# coding: utf-8
# Adapted from: https://github.com/zpincus/celltool/blob/master/celltool/numerics/image_warp.py
from scipy import ndimage
import numpy as np
from probreg import bcpd
import tifffile
import matplotlib.pyplot as plt
import napari
from magicgui import magic_factory, widgets
from nap... | [
"numpy.sqrt",
"numpy.subtract.outer",
"numpy.ones",
"napari.qt.thread_worker",
"numpy.linalg.pinv",
"numpy.log",
"numpy.asarray",
"numpy.zeros",
"magicgui.widgets.ProgressBar",
"numpy.seterr"
] | [((2818, 2863), 'numpy.subtract.outer', 'np.subtract.outer', (['points[:, 0]', 'points[:, 0]'], {}), '(points[:, 0], points[:, 0])\n', (2835, 2863), True, 'import numpy as np\n'), ((2871, 2916), 'numpy.subtract.outer', 'np.subtract.outer', (['points[:, 1]', 'points[:, 1]'], {}), '(points[:, 1], points[:, 1])\n', (2888,... |
from django.test import TestCase, RequestFactory
import vcr
from django.conf import settings
from django.core.management import call_command
from open_humans.models import OpenHumansMember
from main.celery import read_reference, clean_raw_23andme
from main.celery_helper import vcf_header
import os
import tempfile
impor... | [
"django.test.RequestFactory",
"open_humans.models.OpenHumansMember.create",
"main.celery.read_reference",
"vcr.use_cassette",
"django.core.management.call_command",
"main.celery_helper.vcf_header",
"requests_mock.Mocker",
"main.celery.clean_raw_23andme",
"requests.get",
"os.path.dirname",
"tempf... | [((3225, 3302), 'vcr.use_cassette', 'vcr.use_cassette', (['"""main/tests/fixtures/process_file.yaml"""'], {'record_mode': '"""none"""'}), "('main/tests/fixtures/process_file.yaml', record_mode='none')\n", (3241, 3302), False, 'import vcr\n'), ((3974, 4060), 'vcr.use_cassette', 'vcr.use_cassette', (['"""main/tests/fixtu... |
# -*- coding: UTF-8 -*-
#!/usr/bin/python3
"""
Embedding Layer
"""
#************************************************************
# Imported Libraries
#************************************************************
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from gensim.models i... | [
"gensim.models.KeyedVectors.load_word2vec_format",
"torch.from_numpy",
"torch.nn.Dropout",
"torch.nn.Embedding"
] | [((622, 692), 'torch.nn.Embedding', 'nn.Embedding', (['vocab.vocab_size', 'self.emb_dim'], {'padding_idx': 'vocab.PAD_ID'}), '(vocab.vocab_size, self.emb_dim, padding_idx=vocab.PAD_ID)\n', (634, 692), True, 'import torch.nn as nn\n'), ((805, 832), 'torch.nn.Dropout', 'nn.Dropout', ([], {'p': 'params.emb_do'}), '(p=para... |
import abc
import socket
import logging
import asyncio
import warnings
import h2.config
import h2.exceptions
from .utils import DeadlineWrapper
from .const import Status
from .stream import send_message, recv_message
from .stream import StreamIterator
from .metadata import Metadata, Deadline
from .protocol import H2P... | [
"logging.getLogger",
"warnings.warn",
"asyncio.wait"
] | [((486, 513), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (503, 513), False, 'import logging\n'), ((3945, 4062), 'warnings.warn', 'warnings.warn', (['""""end" argument is deprecated, use "stream.send_trailing_metadata" explicitly"""'], {'stacklevel': '(2)'}), '(\n \'"end" argument i... |
#!/usr/bin/env python
import argparse
from eva import EvaProgram, Input, Output
from eva.ckks import CKKSCompiler
from eva.seal import generate_keys
import numpy as np
import time
from eva.std.numeric import horizontal_sum
def dot(x, y):
return np.dot(x, y)
def generate_inputs_naive(size, label="x"):
inputs... | [
"eva.EvaProgram",
"eva.Output",
"argparse.ArgumentParser",
"numpy.testing.assert_allclose",
"numpy.array",
"numpy.dot",
"eva.ckks.CKKSCompiler",
"numpy.zeros",
"eva.std.numeric.horizontal_sum",
"eva.Input",
"time.time",
"eva.seal.generate_keys"
] | [((251, 263), 'numpy.dot', 'np.dot', (['x', 'y'], {}), '(x, y)\n', (257, 263), True, 'import numpy as np\n'), ((346, 360), 'numpy.zeros', 'np.zeros', (['size'], {}), '(size)\n', (354, 360), True, 'import numpy as np\n'), ((668, 701), 'eva.EvaProgram', 'EvaProgram', (['"""fhe_dot"""'], {'vec_size': '(1)'}), "('fhe_dot',... |
from __future__ import division
from __future__ import print_function
# -*- coding: utf-8 -*-
# Copyright 2020 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.a... | [
"google.appengine.ext.db.Key.from_path",
"logging.info",
"google.appengine.ext.db.DateTimeProperty",
"time.time"
] | [((3303, 3345), 'logging.info', 'logging.info', (['"""cache %s for %r"""', 'verb', 'key'], {}), "('cache %s for %r', verb, key)\n", (3315, 3345), False, 'import logging\n'), ((4462, 4522), 'google.appengine.ext.db.Key.from_path', 'db.Key.from_path', (['"""SharedInvalidateParent"""', 'PARENT_ENTITY_ID'], {}), "('SharedI... |
import intrepyd
from intrepyd.iec611312py.plcopen import parse_plc_open_file
from intrepyd.iec611312py.stmtprinter import StmtPrinter
import unittest
from . import from_fixture_path
class TestOpenPLC(unittest.TestCase):
def test_simple_1(self):
pous = parse_plc_open_file(from_fixture_path('openplc/simple1.... | [
"unittest.main",
"intrepyd.iec611312py.stmtprinter.StmtPrinter"
] | [((1715, 1730), 'unittest.main', 'unittest.main', ([], {}), '()\n', (1728, 1730), False, 'import unittest\n'), ((384, 397), 'intrepyd.iec611312py.stmtprinter.StmtPrinter', 'StmtPrinter', ([], {}), '()\n', (395, 397), False, 'from intrepyd.iec611312py.stmtprinter import StmtPrinter\n'), ((1246, 1259), 'intrepyd.iec61131... |
from unittest import TestCase
import json
from helpers import *
from pytezos import ContractInterface, pytezos, MichelsonRuntimeError
from pytezos.context.mixin import ExecutionContext
token_a = "<KEY>"
token_b = "<KEY>"
token_c = "<KEY>"
token_d = "<KEY>"
pair_ab = {
"token_a_type" : {
"fa2": {
... | [
"pytezos.ContractInterface.from_michelson"
] | [((1489, 1531), 'pytezos.ContractInterface.from_michelson', 'ContractInterface.from_michelson', (['dex_code'], {}), '(dex_code)\n', (1521, 1531), False, 'from pytezos import ContractInterface, pytezos, MichelsonRuntimeError\n')] |
import os
from collections import defaultdict
from rbc.omnisci_backend import Array
from rbc.errors import OmnisciServerError
from numba import types as nb_types
import pytest
rbc_omnisci = pytest.importorskip('rbc.omniscidb')
available_version, reason = rbc_omnisci.is_available()
pytestmark = pytest.mark.skipif(not a... | [
"rbc.externals.stdio.printf",
"rbc.omnisci_backend.zeros_like",
"pytest.mark.parametrize",
"numba.types.double",
"pytest.importorskip",
"collections.defaultdict",
"os.path.basename",
"pytest.raises",
"pytest.mark.skipif",
"pytest.fixture",
"pytest.skip",
"rbc.external.external",
"rbc.omnisci... | [((191, 227), 'pytest.importorskip', 'pytest.importorskip', (['"""rbc.omniscidb"""'], {}), "('rbc.omniscidb')\n", (210, 227), False, 'import pytest\n'), ((296, 352), 'pytest.mark.skipif', 'pytest.mark.skipif', (['(not available_version)'], {'reason': 'reason'}), '(not available_version, reason=reason)\n', (314, 352), F... |
from dataclasses import dataclass
import re
from tokenize import group
from core.constructs.resource import ResourceModel
from core.constructs.workspace import Workspace
RUUID = "cdev::simple::bucket"
def get_cloud_output_from_cdev_name(component_name: str, cdev_name: str) -> str:
try:
ws = Workspace.in... | [
"core.constructs.workspace.Workspace.instance",
"re.compile"
] | [((1177, 1206), 're.compile', 're.compile', (['remote_name_regex'], {}), '(remote_name_regex)\n', (1187, 1206), False, 'import re\n'), ((308, 328), 'core.constructs.workspace.Workspace.instance', 'Workspace.instance', ([], {}), '()\n', (326, 328), False, 'from core.constructs.workspace import Workspace\n'), ((764, 784)... |
# -*- coding: utf-8 -*-
# Demo: MACD strategy
# src: ./test_backtest/MACD_JCSC.py
# jupyter: ./test_backtest/QUANTAXIS回测分析全过程讲解.ipynb
# paper: ./test_backtest/QUANTAXIS回测分析全过程讲解.md
import QUANTAXIS as QA
import numpy as np
import pandas as pd
import datetime
st1=datetime.datetime.now()
# define the MACD strategy
def M... | [
"QUANTAXIS.QA_BacktestBroker",
"QUANTAXIS.EMA",
"QUANTAXIS.CROSS",
"QUANTAXIS.QA_SU_save_strategy",
"QUANTAXIS.QA_Account",
"QUANTAXIS.QA_Risk",
"datetime.datetime.now",
"QUANTAXIS.QA_Event",
"QUANTAXIS.QA_fetch_stock_day_adv",
"pandas.DataFrame"
] | [((264, 287), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (285, 287), False, 'import datetime\n'), ((800, 815), 'QUANTAXIS.QA_Account', 'QA.QA_Account', ([], {}), '()\n', (813, 815), True, 'import QUANTAXIS as QA\n'), ((825, 847), 'QUANTAXIS.QA_BacktestBroker', 'QA.QA_BacktestBroker', ([], {}), ... |
"""Wrapper for pygame, which exports the PSP Python API on non-PSP systems."""
__author__ = "<NAME>, <<EMAIL>>"
import pygame
pygame.init()
_vol_music = 255
_vol_sound = 255
def setMusicVolume(vol):
global _vol_music
if vol >= 0 and vol <= 255:
_vol_music = vol
pygame.mixer.music.set_vol... | [
"pygame.init",
"pygame.mixer.Sound",
"pygame.mixer.music.set_volume",
"pygame.mixer.music.play",
"pygame.mixer.music.stop",
"pygame.mixer.music.load"
] | [((131, 144), 'pygame.init', 'pygame.init', ([], {}), '()\n', (142, 144), False, 'import pygame\n'), ((294, 343), 'pygame.mixer.music.set_volume', 'pygame.mixer.music.set_volume', (['(_vol_music / 255.0)'], {}), '(_vol_music / 255.0)\n', (323, 343), False, 'import pygame\n'), ((557, 590), 'pygame.mixer.music.load', 'py... |
import torch
import torch.nn as nn
import torchvision.models as models
import numpy as np
class EncoderCNN(nn.Module):
def __init__(self, embed_size):
super(EncoderCNN, self).__init__()
resnet = models.resnet50(pretrained=True)
for param in resnet.parameters():
param.requires_gr... | [
"torch.nn.Sequential",
"torch.nn.LSTM",
"torch.nn.Linear",
"torchvision.models.resnet50",
"torch.nn.Embedding"
] | [((216, 248), 'torchvision.models.resnet50', 'models.resnet50', ([], {'pretrained': '(True)'}), '(pretrained=True)\n', (231, 248), True, 'import torchvision.models as models\n'), ((409, 432), 'torch.nn.Sequential', 'nn.Sequential', (['*modules'], {}), '(*modules)\n', (422, 432), True, 'import torch.nn as nn\n'), ((454,... |
"""Items model. """
# Django
from django.db import models
# Utilities
from App.utils.models import BlackMarketModel
# Models
from .category import Category
from .unit import Unit
from .owner import Owner
class Item(BlackMarketModel):
"""Items model.
Is a model to items we goin to sell """
name = mode... | [
"django.db.models.TextField",
"django.db.models.ForeignKey",
"django.db.models.BooleanField",
"django.db.models.DecimalField",
"django.db.models.CharField"
] | [((316, 386), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(100)', 'unique': '(True)', 'blank': '(False)', 'null': '(False)'}), '(max_length=100, unique=True, blank=False, null=False)\n', (332, 386), False, 'from django.db import models\n'), ((402, 479), 'django.db.models.ForeignKey', 'models.... |
import random
import cv2
import numpy as np
from augraphy.base.augmentation import Augmentation
class NoiseTexturize(Augmentation):
"""Creates a random noise based texture pattern to emulate paper textures.
Consequently applies noise patterns to the original image from big to small.
:param sigma_range:... | [
"numpy.clip",
"numpy.array",
"numpy.stack",
"cv2.resize",
"random.randint",
"random.gauss"
] | [((3150, 3223), 'cv2.resize', 'cv2.resize', (['result'], {'dsize': '(width, height)', 'interpolation': 'cv2.INTER_LINEAR'}), '(result, dsize=(width, height), interpolation=cv2.INTER_LINEAR)\n', (3160, 3223), False, 'import cv2\n'), ((1413, 1469), 'random.randint', 'random.randint', (['self.sigma_range[0]', 'self.sigma_... |
# Copyright (c) 2019, CRS4
#
# 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, distribu... | [
"PIL.Image.open",
"io.BytesIO",
"ome_seadragon_cache.CacheDriverFactory",
"openslide.OpenSlide"
] | [((1741, 1760), 'openslide.OpenSlide', 'OpenSlide', (['img_path'], {}), '(img_path)\n', (1750, 1760), False, 'from openslide import OpenSlide\n'), ((7796, 7805), 'io.BytesIO', 'BytesIO', ([], {}), '()\n', (7803, 7805), False, 'from io import BytesIO\n'), ((8120, 8143), 'PIL.Image.open', 'Image.open', (['tile_buffer'], ... |
from PyQt5 import QtWidgets, QtCore
from podcastista.ShowEpisodeWidget import ShowEpisodeWidget
from podcastista.FlowLayout import FlowLayout
class FillThread(QtCore.QThread):
""" Worker thread for loading up episodes """
def __init__(self, spotify, shows):
super().__init__()
self._spotify = ... | [
"PyQt5.QtWidgets.QWidget",
"podcastista.FlowLayout.FlowLayout",
"PyQt5.QtWidgets.QLabel",
"podcastista.ShowEpisodeWidget.ShowEpisodeWidget",
"PyQt5.QtWidgets.QVBoxLayout",
"PyQt5.QtWidgets.QStackedLayout",
"PyQt5.QtWidgets.QScrollArea"
] | [((1196, 1215), 'PyQt5.QtWidgets.QWidget', 'QtWidgets.QWidget', ([], {}), '()\n', (1213, 1215), False, 'from PyQt5 import QtWidgets, QtCore\n'), ((1239, 1262), 'PyQt5.QtWidgets.QVBoxLayout', 'QtWidgets.QVBoxLayout', ([], {}), '()\n', (1260, 1262), False, 'from PyQt5 import QtWidgets, QtCore\n'), ((1282, 1310), 'PyQt5.Q... |
import pyparsing as pp
#relationship will refer to 'track' in all of your examples
relationship = pp.Word(pp.alphas).setResultsName('relationship')
number = pp.Word(pp.nums + '.')
variable = pp.Word(pp.alphas)
# an argument to a relationship can be either a number or a variable
argument = number | variable
# argument... | [
"pyparsing.OneOrMore",
"pyparsing.Suppress",
"pyparsing.Word",
"pyparsing.delimitedList"
] | [((158, 180), 'pyparsing.Word', 'pp.Word', (["(pp.nums + '.')"], {}), "(pp.nums + '.')\n", (165, 180), True, 'import pyparsing as pp\n'), ((192, 210), 'pyparsing.Word', 'pp.Word', (['pp.alphas'], {}), '(pp.alphas)\n', (199, 210), True, 'import pyparsing as pp\n'), ((844, 866), 'pyparsing.OneOrMore', 'pp.OneOrMore', (['... |
#!/usr/bin/env python
import vtk
from vtk.util.misc import vtkGetDataRoot
VTK_DATA_ROOT = vtkGetDataRoot()
# this script tests vtkImageReslice with various axes permutations,
# in order to cover a nasty set of "if" statements that check
# the intersections of the raster lines with the input bounding box.
# Image pipel... | [
"vtk.util.misc.vtkGetDataRoot",
"vtk.vtkImageReader",
"vtk.vtkRenderWindow",
"vtk.vtkTransform",
"vtk.vtkActor2D",
"vtk.vtkImageMapper",
"vtk.vtkImageReslice",
"vtk.vtkRenderer"
] | [((90, 106), 'vtk.util.misc.vtkGetDataRoot', 'vtkGetDataRoot', ([], {}), '()\n', (104, 106), False, 'from vtk.util.misc import vtkGetDataRoot\n'), ((333, 353), 'vtk.vtkImageReader', 'vtk.vtkImageReader', ([], {}), '()\n', (351, 353), False, 'import vtk\n'), ((604, 622), 'vtk.vtkTransform', 'vtk.vtkTransform', ([], {}),... |
import collections
from itertools import repeat
import torch
import torch.nn as nn
import torch.nn.utils.rnn as rnn_utils
def _ntuple(n):
def parse(x):
if isinstance(x, collections.Iterable):
return x
return tuple(repeat(x, n))
return parse
_single = _ntuple(1)
_pair = _ntuple(2)
... | [
"torch.sort",
"torch.ne",
"torch.nn.utils.rnn.pack_padded_sequence",
"torch.nn.utils.rnn.pad_packed_sequence",
"itertools.repeat"
] | [((1898, 1970), 'torch.nn.utils.rnn.pack_padded_sequence', 'rnn_utils.pack_padded_sequence', (['rnn_input', 'lens'], {'batch_first': 'batch_first'}), '(rnn_input, lens, batch_first=batch_first)\n', (1928, 1970), True, 'import torch.nn.utils.rnn as rnn_utils\n'), ((2230, 2289), 'torch.nn.utils.rnn.pad_packed_sequence', ... |
import pandas as pandas_Pandas_Module
class Script:
@staticmethod
def main():
food_info = pandas_Pandas_Module.read_csv("../food_info.csv")
print(str(food_info.dtypes))
Script.main() | [
"pandas.read_csv"
] | [((97, 146), 'pandas.read_csv', 'pandas_Pandas_Module.read_csv', (['"""../food_info.csv"""'], {}), "('../food_info.csv')\n", (126, 146), True, 'import pandas as pandas_Pandas_Module\n')] |
# coding=utf-8
"""
Command Line Interface
======================
"""
import argparse
import logging
import os
from os import path
import sys
from landspout import core, __version__
LOGGER = logging.getLogger('landspout')
LOGGING_FORMAT = '[%(asctime)-15s] %(levelname)-8s %(name)-15s: %(message)s'
def exit_applicat... | [
"logging.getLogger",
"logging.basicConfig",
"os.path.exists",
"argparse.FileType",
"argparse.ArgumentParser",
"os.path.normpath",
"landspout.core.Landspout",
"sys.exit"
] | [((193, 223), 'logging.getLogger', 'logging.getLogger', (['"""landspout"""'], {}), "('landspout')\n", (210, 223), False, 'import logging\n'), ((634, 648), 'sys.exit', 'sys.exit', (['code'], {}), '(code)\n', (642, 648), False, 'import sys\n'), ((810, 972), 'argparse.ArgumentParser', 'argparse.ArgumentParser', (['"""land... |
import tornado.httpserver
import tornado.ioloop
import tornado.options
import tornado.web
import tornado.auth
import tornado.escape
import os.path
import logging
import sys
import urllib
import json
from uuid import uuid4
from tornado.options import define, options
define("port", default=8000, help="run on the given... | [
"json.load",
"tornado.options.define",
"uuid.uuid4"
] | [((269, 337), 'tornado.options.define', 'define', (['"""port"""'], {'default': '(8000)', 'help': '"""run on the given port"""', 'type': 'int'}), "('port', default=8000, help='run on the given port', type=int)\n", (275, 337), False, 'from tornado.options import define, options\n'), ((19434, 19441), 'uuid.uuid4', 'uuid4'... |
import matplotlib
import matplotlib.pyplot as plt
import numpy as np
import math
from matplotlib.ticker import FormatStrFormatter
from matplotlib import scale as mscale
from matplotlib import transforms as mtransforms
# z = [0,0.1,0.3,0.9,1,2,5]
z = [7.8, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 200, 300, 400, 500, 6... | [
"matplotlib.pyplot.grid",
"matplotlib.pyplot.savefig",
"matplotlib.rcParams.update",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.minorticks_off",
"matplotlib.pyplot.show"
] | [((805, 831), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': '(8, 5)'}), '(figsize=(8, 5))\n', (815, 831), True, 'import matplotlib.pyplot as plt\n'), ((858, 903), 'matplotlib.rcParams.update', 'matplotlib.rcParams.update', (["{'font.size': 20}"], {}), "({'font.size': 20})\n", (884, 903), False, 'import mat... |
import discord
from discord.ext.commands import Bot
TOKEN = "<discordtoken>"
client = discord.Client()
bot = Bot(command_prefix="!")
@bot.event
async def on_ready():
print("Bot Hazır " + str(bot.user))
@bot.event
async def on_message(message):
if message.author == client.user:
ret... | [
"discord.Client",
"discord.ext.commands.Bot"
] | [((93, 109), 'discord.Client', 'discord.Client', ([], {}), '()\n', (107, 109), False, 'import discord\n'), ((117, 140), 'discord.ext.commands.Bot', 'Bot', ([], {'command_prefix': '"""!"""'}), "(command_prefix='!')\n", (120, 140), False, 'from discord.ext.commands import Bot\n')] |
# -*- coding: utf-8 -*-
""" test """
from __future__ import unicode_literals
from django.template.loader import get_template
from django.contrib import messages
# Create your views here.
from django.http import HttpResponse
def index(request):
""" index """
template = get_template('cornwall/index.html')
m... | [
"django.contrib.messages.set_level",
"django.http.HttpResponse",
"django.contrib.messages.add_message",
"django.contrib.messages.get_messages",
"django.template.loader.get_template"
] | [((279, 314), 'django.template.loader.get_template', 'get_template', (['"""cornwall/index.html"""'], {}), "('cornwall/index.html')\n", (291, 314), False, 'from django.template.loader import get_template\n'), ((319, 362), 'django.contrib.messages.set_level', 'messages.set_level', (['request', 'messages.DEBUG'], {}), '(r... |
from tdw.controller import Controller
from tdw.tdw_utils import TDWUtils
from tdw.add_ons.image_capture import ImageCapture
from tdw.backend.paths import EXAMPLE_CONTROLLER_OUTPUT_PATH
"""
Get the _flow pass.
"""
c = Controller()
object_id_0 = c.get_unique_id()
object_id_1 = c.get_unique_id()
object_id_2 = c.get_uniq... | [
"tdw.tdw_utils.TDWUtils.create_avatar",
"tdw.add_ons.image_capture.ImageCapture",
"tdw.backend.paths.EXAMPLE_CONTROLLER_OUTPUT_PATH.joinpath",
"tdw.tdw_utils.TDWUtils.create_empty_room",
"tdw.controller.Controller"
] | [((219, 231), 'tdw.controller.Controller', 'Controller', ([], {}), '()\n', (229, 231), False, 'from tdw.controller import Controller\n'), ((550, 597), 'tdw.backend.paths.EXAMPLE_CONTROLLER_OUTPUT_PATH.joinpath', 'EXAMPLE_CONTROLLER_OUTPUT_PATH.joinpath', (['"""flow"""'], {}), "('flow')\n", (589, 597), False, 'from tdw.... |
"""
Expression Dataset for analysis of matrix (RNASeq/microarray) data with annotations
"""
import pandas as PD
import numpy as N
from matplotlib import pylab as P
from collections import OrderedDict
from ast import literal_eval
# from ..plot.matrix import matshow_clustered
class ExpressionSet(object):
def... | [
"collections.OrderedDict",
"numpy.isnan",
"pandas.read_table",
"pandas.MultiIndex.from_tuples",
"numpy.arange"
] | [((1227, 1240), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (1238, 1240), False, 'from collections import OrderedDict\n'), ((1862, 1900), 'pandas.read_table', 'PD.read_table', (['fname'], {'skiprows': '(cnt - 1)'}), '(fname, skiprows=cnt - 1)\n', (1875, 1900), True, 'import pandas as PD\n'), ((2481, 251... |
import sys
import rospy
import types
#from std_msgs.msg import String
from sensor_msgs.msg import Image
from cibr_img_processing.msg import Ints
from cv_bridge import CvBridge, CvBridgeError
#make int msgs
#TODO: get the img size from camera_indo topics
class CVUtilNode: # abstarct this, it can easily work with other ... | [
"rospy.Subscriber",
"rospy.is_shutdown",
"rospy.init_node",
"cv_bridge.CvBridge",
"rospy.Rate",
"types.MethodType",
"rospy.Publisher"
] | [((506, 516), 'cv_bridge.CvBridge', 'CvBridge', ([], {}), '()\n', (514, 516), False, 'from cv_bridge import CvBridge, CvBridgeError\n'), ((572, 614), 'rospy.init_node', 'rospy.init_node', (['self.name'], {'anonymous': '(True)'}), '(self.name, anonymous=True)\n', (587, 614), False, 'import rospy\n'), ((633, 647), 'rospy... |
from abc import abstractproperty
from ..backend_config.bucket_config import S3BucketConfig
from ..storage.helper import StorageHelper
class SetupUploadMixin(object):
log = abstractproperty()
storage_uri = abstractproperty()
def setup_upload(
self, bucket_name, host=None, access_key=None, sec... | [
"abc.abstractproperty"
] | [((179, 197), 'abc.abstractproperty', 'abstractproperty', ([], {}), '()\n', (195, 197), False, 'from abc import abstractproperty\n'), ((216, 234), 'abc.abstractproperty', 'abstractproperty', ([], {}), '()\n', (232, 234), False, 'from abc import abstractproperty\n')] |
import os
import unittest
import pandas as pd
from application.ParcelsParser import ParcelsParser
class TestPracelsParser(unittest.TestCase):
def setUp(self):
self.parser = ParcelsParser("./test_cadastral_parcels.tsv", "cadastral_parcel_identifier")
def test_if_file_exist(self):
file_path = ... | [
"application.ParcelsParser.ParcelsParser",
"pandas.read_csv",
"os.path.isfile",
"unittest.main",
"os.path.abspath"
] | [((2856, 2871), 'unittest.main', 'unittest.main', ([], {}), '()\n', (2869, 2871), False, 'import unittest\n'), ((188, 264), 'application.ParcelsParser.ParcelsParser', 'ParcelsParser', (['"""./test_cadastral_parcels.tsv"""', '"""cadastral_parcel_identifier"""'], {}), "('./test_cadastral_parcels.tsv', 'cadastral_parcel_i... |
# -*- encoding: utf-8
"""
Copyright (c) 2014, <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
noti... | [
"numpy.mean",
"numpy.sum",
"numpy.zeros",
"numpy.isnan",
"numpy.vstack"
] | [((1876, 1908), 'numpy.zeros', 'np.zeros', (['(0, 4)'], {'dtype': 'np.int32'}), '((0, 4), dtype=np.int32)\n', (1884, 1908), True, 'import numpy as np\n'), ((1829, 1841), 'numpy.vstack', 'np.vstack', (['b'], {}), '(b)\n', (1838, 1841), True, 'import numpy as np\n'), ((2666, 2683), 'numpy.mean', 'np.mean', (['bo[:, 0]'],... |
import pickle
import pandas as pd
# cat aa ab ac > dataset.pkl from https://github.com/zhougr1993/DeepInterestNetwork
with open('dataset.pkl', 'rb') as f:
train_set = pickle.load(f, encoding='bytes')
test_set = pickle.load(f, encoding='bytes')
cate_list = pickle.load(f, encoding='bytes')
user_count, i... | [
"pandas.DataFrame",
"pickle.load"
] | [((744, 856), 'pandas.DataFrame', 'pd.DataFrame', (['train_data'], {'columns': "['label', 'user_id', 'item_id', 'cate_id', 'item_history', 'cate_history']"}), "(train_data, columns=['label', 'user_id', 'item_id', 'cate_id',\n 'item_history', 'cate_history'])\n", (756, 856), True, 'import pandas as pd\n'), ((1324, 14... |
from email_extras.settings import USE_GNUPG
if USE_GNUPG:
from django.contrib import admin
from email_extras.models import Key, Address
from email_extras.forms import KeyForm
class KeyAdmin(admin.ModelAdmin):
form = KeyForm
list_display = ('__str__', 'email_addresses')
... | [
"django.contrib.admin.site.register"
] | [((572, 606), 'django.contrib.admin.site.register', 'admin.site.register', (['Key', 'KeyAdmin'], {}), '(Key, KeyAdmin)\n', (591, 606), False, 'from django.contrib import admin\n'), ((612, 654), 'django.contrib.admin.site.register', 'admin.site.register', (['Address', 'AddressAdmin'], {}), '(Address, AddressAdmin)\n', (... |
import boto3
import argparse
import os,sys
def main(argv=None):
argv = (argv or sys.argv)[1:]
parser = argparse.ArgumentParser(description='dump all aws log streams into files')
parser.add_argument("--profile",
dest="aws_profile",
type=str,
... | [
"os.path.join",
"boto3.client",
"os.environ.get",
"argparse.ArgumentParser"
] | [((114, 188), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""dump all aws log streams into files"""'}), "(description='dump all aws log streams into files')\n", (137, 188), False, 'import argparse\n'), ((824, 844), 'boto3.client', 'boto3.client', (['"""logs"""'], {}), "('logs')\n", (836,... |
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import make_blobs
from sklearn.mixture import GaussianMixture
from sklearn.cluster import KMeans
from matplotlib.patches import Ellipse
# For reproducibility
np.random.seed(1000)
nb_samples = 300
nb_centers = 2
if __na... | [
"sklearn.cluster.KMeans",
"seaborn.set",
"sklearn.mixture.GaussianMixture",
"sklearn.datasets.make_blobs",
"numpy.dot",
"numpy.random.seed",
"numpy.linalg.norm",
"numpy.linalg.eigh",
"matplotlib.patches.Ellipse",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.show"
] | [((256, 276), 'numpy.random.seed', 'np.random.seed', (['(1000)'], {}), '(1000)\n', (270, 276), True, 'import numpy as np\n'), ((376, 510), 'sklearn.datasets.make_blobs', 'make_blobs', ([], {'n_samples': 'nb_samples', 'n_features': '(2)', 'center_box': '[-1, 1]', 'centers': 'nb_centers', 'cluster_std': '[1.0, 0.6]', 'ra... |
import logging
import threading
from concurrent.futures import ThreadPoolExecutor
from multiprocessing import Queue
from foreverbull.worker.worker import WorkerHandler
from foreverbull_core.models.finance import EndOfDay
from foreverbull_core.models.socket import Request
from foreverbull_core.models.worker import Inst... | [
"logging.getLogger",
"threading.Thread.__init__",
"concurrent.futures.ThreadPoolExecutor",
"foreverbull_core.socket.router.MessageRouter",
"foreverbull.worker.worker.WorkerHandler",
"multiprocessing.Queue"
] | [((745, 772), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (762, 772), False, 'import logging\n'), ((805, 812), 'multiprocessing.Queue', 'Queue', ([], {}), '()\n', (810, 812), False, 'from multiprocessing import Queue\n'), ((846, 853), 'multiprocessing.Queue', 'Queue', ([], {}), '()\n',... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Tests for `AffiliationSearch` module."""
from collections import namedtuple
from nose.tools import assert_equal, assert_true
import scopus
s = scopus.AffiliationSearch('af-id(60021784)', refresh=True)
def test_affiliations():
received = s.affiliations
asser... | [
"nose.tools.assert_equal",
"scopus.AffiliationSearch",
"collections.namedtuple"
] | [((196, 253), 'scopus.AffiliationSearch', 'scopus.AffiliationSearch', (['"""af-id(60021784)"""'], {'refresh': '(True)'}), "('af-id(60021784)', refresh=True)\n", (220, 253), False, 'import scopus\n'), ((435, 467), 'collections.namedtuple', 'namedtuple', (['"""Affiliation"""', 'order'], {}), "('Affiliation', order)\n", (... |
# Copyright 2013 <NAME>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, soft... | [
"osbuild.config.get_dist_dir",
"osbuild.config.load_modules",
"os.path.join",
"os.chdir",
"osbuild.command.run"
] | [((767, 788), 'osbuild.config.load_modules', 'config.load_modules', ([], {}), '()\n', (786, 788), False, 'from osbuild import config\n'), ((977, 998), 'osbuild.config.load_modules', 'config.load_modules', ([], {}), '()\n', (996, 998), False, 'from osbuild import config\n'), ((1372, 1392), 'os.chdir', 'os.chdir', (['sou... |
from django import template
from week.models import SidebarContentPage,SidebarImagePage
register = template.Library()
@register.inclusion_tag('week/announcement.html')
def sidebar():
sidebar_data = SidebarContentPage.objects.get()
return {'sidebar_data':sidebar_data}
@register.inclusion_tag('week/advertise... | [
"week.models.SidebarContentPage.objects.get",
"week.models.SidebarImagePage.objects.get",
"django.template.Library"
] | [((100, 118), 'django.template.Library', 'template.Library', ([], {}), '()\n', (116, 118), False, 'from django import template\n'), ((205, 237), 'week.models.SidebarContentPage.objects.get', 'SidebarContentPage.objects.get', ([], {}), '()\n', (235, 237), False, 'from week.models import SidebarContentPage, SidebarImageP... |
import os
import requests
import time
import uuid
import configparser
import datetime
import fbchat
import re
from fbchat import Client, ImageAttachment
from fbchat import FBchatException
from pathlib import Path
politeness_index = 0.5 # ;)
epoch = datetime.datetime(1970, 1, 1)
# Hack to get the login to work, see:... | [
"datetime.datetime",
"os.path.exists",
"datetime.datetime.fromtimestamp",
"fbchat.Client",
"configparser.ConfigParser",
"re.compile",
"datetime.datetime.strptime",
"pathlib.Path",
"requests.get",
"time.sleep",
"uuid.uuid4"
] | [((252, 281), 'datetime.datetime', 'datetime.datetime', (['(1970)', '(1)', '(1)'], {}), '(1970, 1, 1)\n', (269, 281), False, 'import datetime\n'), ((422, 468), 're.compile', 're.compile', (['""""name":"fb_dtsg","value":"(.*?)\\""""'], {}), '(\'"name":"fb_dtsg","value":"(.*?)"\')\n', (432, 468), False, 'import re\n'), (... |
from django.contrib.auth.models import AbstractUser
from django.db.models import (BooleanField, CASCADE, CharField, FloatField,
IntegerField, ManyToManyField, Model,
OneToOneField, PositiveSmallIntegerField)
from django.contrib.postgres.fields import ArrayFiel... | [
"django.utils.translation.ugettext_lazy",
"django.db.models.FloatField",
"django.db.models.IntegerField",
"django.db.models.BooleanField",
"django.urls.reverse",
"django.db.models.CharField"
] | [((1176, 1203), 'django.db.models.BooleanField', 'BooleanField', ([], {'default': '(False)'}), '(default=False)\n', (1188, 1203), False, 'from django.db.models import BooleanField, CASCADE, CharField, FloatField, IntegerField, ManyToManyField, Model, OneToOneField, PositiveSmallIntegerField\n'), ((1217, 1252), 'django.... |
#!/usr/bin/env python3
from sys import argv
from pathlib import Path
from re import compile as re_compile
PACKAGE_RE = re_compile("symbiflow-arch-defs-([a-zA-Z0-9_-]+)-([a-z0-9])")
with (Path(__file__).parent.parent.parent / 'packages.list').open('r') as rptr:
for artifact in rptr.read().splitlines():
m ... | [
"pathlib.Path",
"re.compile"
] | [((121, 182), 're.compile', 're_compile', (['"""symbiflow-arch-defs-([a-zA-Z0-9_-]+)-([a-z0-9])"""'], {}), "('symbiflow-arch-defs-([a-zA-Z0-9_-]+)-([a-z0-9])')\n", (131, 182), True, 'from re import compile as re_compile\n'), ((538, 553), 'pathlib.Path', 'Path', (['"""install"""'], {}), "('install')\n", (542, 553), Fals... |
from django.conf.urls import url, include
urlpatterns = [
url(r'^api-auth/', include('rest_framework.urls', namespace='rest_framework')),
url(r'^api/viet_ocr/', include('viet_ocr.api.urls', namespace="viet_ocr-api")),
url(r'^api/post_process/', include('post_process.api.urls', namespace="post_process-api"... | [
"django.conf.urls.include"
] | [((83, 141), 'django.conf.urls.include', 'include', (['"""rest_framework.urls"""'], {'namespace': '"""rest_framework"""'}), "('rest_framework.urls', namespace='rest_framework')\n", (90, 141), False, 'from django.conf.urls import url, include\n'), ((171, 225), 'django.conf.urls.include', 'include', (['"""viet_ocr.api.ur... |
from django.contrib import admin
from .models import Asset
# Register your models here.
admin.site.register(Asset) | [
"django.contrib.admin.site.register"
] | [((90, 116), 'django.contrib.admin.site.register', 'admin.site.register', (['Asset'], {}), '(Asset)\n', (109, 116), False, 'from django.contrib import admin\n')] |
#!/usr/bin/env python3*
import unicodedata
class Word:
"""
Object representation for a word
Parameters
----------
text : str
word text
formatedText : str
word text without accent, punctuation, etc (UTF-8)
color : List of integers
pixel color values in rgb for th... | [
"unicodedata.category",
"unicodedata.normalize"
] | [((1472, 1509), 'unicodedata.normalize', 'unicodedata.normalize', (['"""NFD"""', 'uniText'], {}), "('NFD', uniText)\n", (1493, 1509), False, 'import unicodedata\n'), ((1531, 1554), 'unicodedata.category', 'unicodedata.category', (['c'], {}), '(c)\n', (1551, 1554), False, 'import unicodedata\n')] |
"""
fit1d package is designed to provide an organized toolbox for different types of
1D fits that can be performed.
It is easy to add new fits and other functionalities
"""
from abc import ABC, abstractmethod
import numpy as np
from typing import List,Tuple
from fit1d.common.model import Model, ModelMock
from fit1d.co... | [
"numpy.delete",
"numpy.array",
"fit1d.common.fit_data.FitData",
"fit1d.common.model.ModelMock"
] | [((2867, 2899), 'numpy.delete', 'np.delete', (['self._fit_data.x', 'ind'], {}), '(self._fit_data.x, ind)\n', (2876, 2899), True, 'import numpy as np\n'), ((2927, 2959), 'numpy.delete', 'np.delete', (['self._fit_data.y', 'ind'], {}), '(self._fit_data.y, ind)\n', (2936, 2959), True, 'import numpy as np\n'), ((3223, 3232)... |
from django.db.models import CharField
from django.utils.translation import ugettext_lazy as _
import validators
class CURPField(CharField):
default_validators = [validators.CURPValidator()]
description = _("CURP")
def __init__(self, *args, **kwargs):
kwargs['max_length'] = 18
super(CURPField, self).__init__(... | [
"django.utils.translation.ugettext_lazy",
"validators.CURPValidator"
] | [((209, 218), 'django.utils.translation.ugettext_lazy', '_', (['"""CURP"""'], {}), "('CURP')\n", (210, 218), True, 'from django.utils.translation import ugettext_lazy as _\n'), ((166, 192), 'validators.CURPValidator', 'validators.CURPValidator', ([], {}), '()\n', (190, 192), False, 'import validators\n')] |
#!/usr/bin/env python3
from html.parser import HTMLParser
import inquirer
import requests
# Parser for HTML input
class InputParser(HTMLParser):
def __init__(self, input_name):
super().__init__()
self._input_name = input_name
self._value = None
@property
def value(self):
... | [
"inquirer.List",
"requests.post",
"inquirer.prompt",
"inquirer.Text"
] | [((2443, 2469), 'inquirer.prompt', 'inquirer.prompt', (['questions'], {}), '(questions)\n', (2458, 2469), False, 'import inquirer\n'), ((2579, 2693), 'requests.post', 'requests.post', (['"""https://www.stadtreinigung.hamburg/privatkunden/abfuhrkalender/index.html"""'], {'data': 'answers'}), "(\n 'https://www.stadtre... |
import chardet
import sys
import codecs
import os
def findEncoding(s):
file = open(s, mode='rb')
buf = file.read()
result = chardet.detect(buf)
file.close()
return result['encoding']
def convertEncoding(s):
if os.access(s,os.W_OK):
encoding = findEncoding(s)
... | [
"os.access",
"os.path.join",
"os.getcwd",
"chardet.detect",
"codecs.open",
"os.walk"
] | [((147, 166), 'chardet.detect', 'chardet.detect', (['buf'], {}), '(buf)\n', (161, 166), False, 'import chardet\n'), ((254, 275), 'os.access', 'os.access', (['s', 'os.W_OK'], {}), '(s, os.W_OK)\n', (263, 275), False, 'import os\n'), ((895, 908), 'os.walk', 'os.walk', (['path'], {}), '(path)\n', (902, 908), False, 'impor... |
import unittest
from asyncio import sleep
from async_unittest import TestCase
from aio_counter import AioCounter
from aio_counter.exceptions import AioCounterException
class TestAioCounter(TestCase):
TIK = float(0.3)
TAK = float(0.6)
TTL = int(1)
@classmethod
def setUpClass(cls) -> None:
... | [
"unittest.main",
"aio_counter.AioCounter",
"asyncio.sleep"
] | [((4531, 4546), 'unittest.main', 'unittest.main', ([], {}), '()\n', (4544, 4546), False, 'import unittest\n'), ((365, 390), 'aio_counter.AioCounter', 'AioCounter', ([], {'loop': 'cls.loop'}), '(loop=cls.loop)\n', (375, 390), False, 'from aio_counter import AioCounter\n'), ((2684, 2715), 'asyncio.sleep', 'sleep', (['sel... |
import math
# Modify the parameters here
UNROLL_FACTOR = 32
DATA_T = 'unsigned short'
# Generate the code
data_type = DATA_T
level = int(math.log2(UNROLL_FACTOR))
for layer in range(level - 1, -1, -1):
pair = int(math.pow(2, layer))
for i in range(pair):
# data_t tmp_[layer]_[pair] = tmp_[layer+1]_[pa... | [
"math.pow",
"math.log2"
] | [((139, 163), 'math.log2', 'math.log2', (['UNROLL_FACTOR'], {}), '(UNROLL_FACTOR)\n', (148, 163), False, 'import math\n'), ((219, 237), 'math.pow', 'math.pow', (['(2)', 'layer'], {}), '(2, layer)\n', (227, 237), False, 'import math\n')] |
from django.shortcuts import render
from django.contrib.auth.models import User, Group
from rest_framework import viewsets
from django.shortcuts import get_object_or_404
from rest_framework.response import Response
from rest_framework import viewsets, status
from .models import Post,Comment,Category,Tag
from .serialize... | [
"rest_framework.response.Response",
"django.shortcuts.get_object_or_404"
] | [((675, 700), 'rest_framework.response.Response', 'Response', (['serializer.data'], {}), '(serializer.data)\n', (683, 700), False, 'from rest_framework.response import Response\n'), ((1063, 1090), 'rest_framework.response.Response', 'Response', (['serializer.errors'], {}), '(serializer.errors)\n', (1071, 1090), False, ... |
from collections import namedtuple
import datetime
import pprint
import sys
import copy
import json
def expandStatusValue(v):
"""
v : string | (string, datetime.date | None)
が string だった場合 (string, None) に展開する.
"""
if isinstance(v, str):
v = (v, None)
return v
def formatDate(d):
if not d:
return "????-??-?... | [
"sys.exit",
"json.dumps",
"datetime.timedelta",
"datetime.date.fromordinal",
"datetime.date",
"copy.deepcopy",
"datetime.date.today"
] | [((11197, 11218), 'datetime.date.today', 'datetime.date.today', ([], {}), '()\n', (11216, 11218), False, 'import datetime\n'), ((15604, 15622), 'json.dumps', 'json.dumps', (['labels'], {}), '(labels)\n', (15614, 15622), False, 'import json\n'), ((15669, 15719), 'json.dumps', 'json.dumps', (['[name for name, label in la... |
# min (1/2) x'Q'x - q'x
from __future__ import print_function
import numpy as np
import aa
dim = 1000
mems = [5, 10, 20, 50, 100]
N = int(1e4)
np.random.seed(1234)
Q = np.random.randn(dim,dim)
Q = Q.T.dot(Q)
q = np.random.randn(dim)
x_0 = np.random.randn(dim)
x_star = np.linalg.solve(Q, q)
step = 0.0005
def f(x):... | [
"numpy.copy",
"numpy.linalg.solve",
"aa.AndersonAccelerator",
"numpy.random.seed",
"numpy.random.randn"
] | [((146, 166), 'numpy.random.seed', 'np.random.seed', (['(1234)'], {}), '(1234)\n', (160, 166), True, 'import numpy as np\n'), ((172, 197), 'numpy.random.randn', 'np.random.randn', (['dim', 'dim'], {}), '(dim, dim)\n', (187, 197), True, 'import numpy as np\n'), ((216, 236), 'numpy.random.randn', 'np.random.randn', (['di... |
from paper_1.data.data_loader import load_val_data, load_train_data, sequential_data_loader, random_data_loader
from paper_1.utils import read_parameter_file, create_experiment_directory
from paper_1.evaluation.eval_utils import init_metrics_object
from paper_1.baseline.main import train as baseline_train
from paper_1.... | [
"paper_1.data.data_loader.sequential_data_loader",
"torch.cuda.is_available",
"paper_1.data.data_loader.load_val_data",
"torch.utils.tensorboard.SummaryWriter",
"os.path.exists",
"os.listdir",
"paper_1.baseline.main.train",
"paper_1.utils.read_parameter_file",
"os.path.isdir",
"pandas.concat",
"... | [((787, 811), 'torch.cuda.empty_cache', 'torch.cuda.empty_cache', ([], {}), '()\n', (809, 811), False, 'import torch\n'), ((1407, 1465), 'paper_1.data.data_loader.load_train_data', 'load_train_data', (['data_params', 'source_domain', 'target_domain'], {}), '(data_params, source_domain, target_domain)\n', (1422, 1465), ... |
#!/usr/bin/env python
#
# Copyright (c) 2017 Ericsson AB and others. All rights reserved
#
# This program and the accompanying materials
# are made available under the terms of the Apache License, Version 2.0
# which accompanies this distribution, and is available at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
imp... | [
"logging.getLogger",
"sfc.lib.openstack_utils.create_vnffg_with_param_file",
"sfc.lib.openstack_utils.get_vnf_ip",
"sfc.lib.odl_utils.wait_for_classification_rules",
"os.path.join",
"sfc.lib.config.CommonConfig",
"urllib3.disable_warnings",
"sfc.lib.openstack_utils.OpenStackSFC",
"sys.exit",
"thre... | [((598, 625), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (615, 625), False, 'import logging\n'), ((642, 667), 'sfc.lib.config.CommonConfig', 'sfc_config.CommonConfig', ([], {}), '()\n', (665, 667), True, 'import sfc.lib.config as sfc_config\n'), ((720, 747), 'sfc.lib.openstack_utils.O... |
"""A collection of utility function, shared across modules."""
import collections
import datetime
import gzip as gz
import logging
import os
import re
import shutil
import subprocess
from argparse import ArgumentTypeError
from copy import deepcopy
from logging import Logger
from typing import (Any, Callable, Dict, Gene... | [
"logging.getLogger",
"os.listdir",
"shutil.copyfileobj",
"re.compile",
"gzip.open",
"subprocess.Popen",
"datetime.datetime.strptime",
"argparse.ArgumentTypeError",
"os.unlink",
"os.path.basename",
"copy.deepcopy",
"datetime.date.today",
"typing.cast",
"typing.TypeVar"
] | [((12006, 12043), 're.compile', 're.compile', (['"""^(\\\\d+\\\\.\\\\d*|\\\\.\\\\d+)$"""'], {}), "('^(\\\\d+\\\\.\\\\d*|\\\\.\\\\d+)$')\n", (12016, 12043), False, 'import re\n'), ((12048, 12070), 're.compile', 're.compile', (['"""^(\\\\d+)$"""'], {}), "('^(\\\\d+)$')\n", (12058, 12070), False, 'import re\n'), ((12449, ... |
import csv
from typing import List
from CombinedPopulation import CombinedPopulation
from PopulationGroup import PopulationGroup, Democrats, Republicans, Independents
class DistrictVotingRecord:
def __init__(self,
district: str,
incumbent: str,
expected_lean: flo... | [
"CombinedPopulation.CombinedPopulation",
"PopulationGroup.PopulationGroup",
"csv.reader"
] | [((1225, 1296), 'PopulationGroup.PopulationGroup', 'PopulationGroup', (['Republicans', '(partisanship + skew)', 'stddev', 'r_weight', '(12)'], {}), '(Republicans, partisanship + skew, stddev, r_weight, 12)\n', (1240, 1296), False, 'from PopulationGroup import PopulationGroup, Democrats, Republicans, Independents\n'), (... |
# coding=utf-8
from actrie.tests.test_matcher import test
if __name__ == "__main__":
test()
| [
"actrie.tests.test_matcher.test"
] | [((91, 97), 'actrie.tests.test_matcher.test', 'test', ([], {}), '()\n', (95, 97), False, 'from actrie.tests.test_matcher import test\n')] |
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Li... | [
"pyramid.renderers.render",
"pyramid_mailer.message.Message",
"email.utils.parseaddr",
"premailer.Premailer",
"zope.interface.implementer",
"email.headerregistry.Address",
"warehouse.email.ses.models.EmailMessage.created.desc",
"pyramid_mailer.get_mailer",
"email.message.EmailMessage"
] | [((2123, 2148), 'zope.interface.implementer', 'implementer', (['IEmailSender'], {}), '(IEmailSender)\n', (2134, 2148), False, 'from zope.interface import implementer\n'), ((3003, 3028), 'zope.interface.implementer', 'implementer', (['IEmailSender'], {}), '(IEmailSender)\n', (3014, 3028), False, 'from zope.interface imp... |
from typing import Optional, List
from pathlib import Path
from dataclasses import astuple
import re
from pydantic import BaseModel, Field, Extra, validator
from pydantic.dataclasses import dataclass
from woke.core.enums import EvmVersionEnum
from woke.c_regex_parsing.solidity_version import SolidityVersion
class W... | [
"re.compile",
"pathlib.Path",
"pydantic.Field",
"pydantic.validator",
"dataclasses.astuple"
] | [((1212, 1262), 'pydantic.validator', 'validator', (['"""allow_paths"""'], {'pre': '(True)', 'each_item': '(True)'}), "('allow_paths', pre=True, each_item=True)\n", (1221, 1262), False, 'from pydantic import BaseModel, Field, Extra, validator\n'), ((1334, 1386), 'pydantic.validator', 'validator', (['"""include_paths"""... |
import tensorflow as tf
import tensorflow.contrib.layers as tfl
"""Copied from the almighty <NAME>;
CECAM/CSM/IRTG School 2018: Machine Learning in Scientific Computing
https://github.com/CECAML/school_nierstein_2018/blob/master/Convnet%20TF.ipynb
"""
def prelu(net):
alpha = tf.Variable(0.0, dtype=net.dtype)
... | [
"tensorflow.contrib.layers.batch_norm",
"tensorflow.contrib.layers.conv2d",
"tensorflow.Variable",
"tensorflow.contrib.layers.fully_connected",
"tensorflow.concat",
"tensorflow.reduce_mean",
"tensorflow.maximum",
"tensorflow.identity",
"tensorflow.contrib.layers.avg_pool2d"
] | [((284, 317), 'tensorflow.Variable', 'tf.Variable', (['(0.0)'], {'dtype': 'net.dtype'}), '(0.0, dtype=net.dtype)\n', (295, 317), True, 'import tensorflow as tf\n'), ((329, 357), 'tensorflow.maximum', 'tf.maximum', (['(alpha * net)', 'net'], {}), '(alpha * net, net)\n', (339, 357), True, 'import tensorflow as tf\n'), ((... |