code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import matplotlib.gridspec as gridspec
import matplotlib.patches as mpatches
from scipy.optimize import minimize
import time
def sim_run(options, MPC):
start = time.clock()
# Simulator Options
FIG_SIZE = options['F... | [
"matplotlib.patches.Rectangle",
"time.clock",
"numpy.delete",
"scipy.optimize.minimize",
"numpy.append",
"numpy.array",
"numpy.zeros",
"matplotlib.pyplot.figure",
"matplotlib.gridspec.GridSpec",
"numpy.cos",
"numpy.sin",
"matplotlib.pyplot.title",
"matplotlib.pyplot.xlim",
"numpy.rad2deg",... | [((258, 270), 'time.clock', 'time.clock', ([], {}), '()\n', (268, 270), False, 'import time\n'), ((490, 524), 'numpy.zeros', 'np.zeros', (['(mpc.horizon * num_inputs)'], {}), '(mpc.horizon * num_inputs)\n', (498, 524), True, 'import numpy as np\n'), ((872, 896), 'numpy.array', 'np.array', (['[[0, 0, 0, 0]]'], {}), '([[... |
import xml.dom.minidom as MD
# import csv
# import pandas
import torch
import torch.nn as nn
from torch.autograd import Variable
import torch.nn.functional as F
import numpy as np
Batch_Size = 32
LR = 0.01
GAMMA = 0.9
EPSILON = 0.9
TARGET_REPLACE_ITER = 100
MEMORY_SIZE = 700
STATES_DIMENTION = 4
ACTIONS_DIMENTI... | [
"numpy.hstack",
"numpy.random.choice",
"torch.max",
"torch.nn.MSELoss",
"numpy.zeros",
"numpy.random.uniform",
"numpy.random.randint",
"torch.nn.functional.relu",
"torch.nn.Linear",
"torch.FloatTensor"
] | [((445, 482), 'torch.nn.Linear', 'torch.nn.Linear', (['STATES_DIMENTION', '(50)'], {}), '(STATES_DIMENTION, 50)\n', (460, 482), False, 'import torch\n'), ((552, 590), 'torch.nn.Linear', 'torch.nn.Linear', (['(50)', 'ACTIONS_DIMENTION'], {}), '(50, ACTIONS_DIMENTION)\n', (567, 590), False, 'import torch\n'), ((702, 711)... |
import pymysql.cursors
from model import contact
from model.group import Group
from model.contact import Contact
import re
class DbFixture:
def __init__(self, host, name, user, password):
self.host = host
self.name = name
self.user = user
self.password = password
self.con... | [
"re.sub"
] | [((897, 920), 're.sub', 're.sub', (['"""[() -]"""', '""""""', 's'], {}), "('[() -]', '', s)\n", (903, 920), False, 'import re\n')] |
from unittest import TestCase
from unittest.mock import Mock
from seleniumwire.proxy.modifier import RequestModifier
class RequestModifierTest(TestCase):
def setUp(self):
self.modifier = RequestModifier()
def test_override_header(self):
self.modifier.headers = {
'User-Agent': 'T... | [
"seleniumwire.proxy.modifier.RequestModifier",
"unittest.mock.Mock"
] | [((203, 220), 'seleniumwire.proxy.modifier.RequestModifier', 'RequestModifier', ([], {}), '()\n', (218, 220), False, 'from seleniumwire.proxy.modifier import RequestModifier\n'), ((7278, 7284), 'unittest.mock.Mock', 'Mock', ([], {}), '()\n', (7282, 7284), False, 'from unittest.mock import Mock\n')] |
#!/usr/bin/env python3
from __future__ import division
import sys
import time
import curses
import curses.textpad
import Adafruit_PCA9685
pwm = Adafruit_PCA9685.PCA9685()
servo_min = 150 # Min pulse length out of 4096
servo_max = 600 # Max pulse length out of 4096
pwm.set_pwm_freq(60)
servo_delay = .15
loop_delay =... | [
"curses.endwin",
"time.sleep",
"curses.noecho",
"Adafruit_PCA9685.PCA9685",
"curses.initscr"
] | [((146, 172), 'Adafruit_PCA9685.PCA9685', 'Adafruit_PCA9685.PCA9685', ([], {}), '()\n', (170, 172), False, 'import Adafruit_PCA9685\n'), ((2790, 2813), 'time.sleep', 'time.sleep', (['servo_delay'], {}), '(servo_delay)\n', (2800, 2813), False, 'import time\n'), ((2849, 2872), 'time.sleep', 'time.sleep', (['servo_delay']... |
# encoding: utf-8
import pytest
from flourish import Flourish
from flourish.helpers import publication_range
class TestFlourish:
@classmethod
def setup_class(cls):
with pytest.warns(None) as warnings:
cls.flourish = Flourish('tests/source')
def test_publication_range(self):
... | [
"flourish.Flourish",
"flourish.helpers.publication_range",
"pytest.warns"
] | [((189, 207), 'pytest.warns', 'pytest.warns', (['None'], {}), '(None)\n', (201, 207), False, 'import pytest\n'), ((248, 272), 'flourish.Flourish', 'Flourish', (['"""tests/source"""'], {}), "('tests/source')\n", (256, 272), False, 'from flourish import Flourish\n'), ((345, 377), 'flourish.helpers.publication_range', 'pu... |
from spyd.registry_manager import register
@register('client_message_handler')
class TauntHandler(object):
message_type = 'N_TAUNT'
@staticmethod
def handle(client, room, message):
player = client.get_player()
room.handle_player_event('taunt', player)
| [
"spyd.registry_manager.register"
] | [((46, 80), 'spyd.registry_manager.register', 'register', (['"""client_message_handler"""'], {}), "('client_message_handler')\n", (54, 80), False, 'from spyd.registry_manager import register\n')] |
import logging
import re
from dataclasses import dataclass
from pprint import pformat
logger = logging.getLogger(__name__)
pp = lambda x: logger.info(pformat(x))
@dataclass
class BagNode:
name: str
capacity: map
parents: set
def clean_bag_name(bag_name: str) -> tuple:
"""
Parses a string with a... | [
"logging.getLogger",
"pprint.pformat"
] | [((96, 123), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (113, 123), False, 'import logging\n'), ((151, 161), 'pprint.pformat', 'pformat', (['x'], {}), '(x)\n', (158, 161), False, 'from pprint import pformat\n')] |
# Copyright (c) 2016 Cisco Systems
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless require... | [
"traceback.format_exc",
"aim.tree_manager.AimHashTreeMaker",
"aim.tree_manager.HashTreeManager",
"aim.common.utils.spawn_thread",
"aim.common.utils.ThreadExit",
"aim.common.utils.perform_harakiri",
"aim.common.utils.rlock",
"aim.aim_manager.AimManager",
"aim.common.utils.get_rlock",
"aim.common.ha... | [((1125, 1152), 'oslo_log.log.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1142, 1152), True, 'from oslo_log import log as logging\n'), ((1189, 1221), 'aim.common.utils.camel_to_snake', 'utils.camel_to_snake', (['x.__name__'], {}), '(x.__name__)\n', (1209, 1221), False, 'from aim.common import ... |
#!/usr/bin/env python
import sys
sys.path.append(
'dist/carla-0.9.0-py%d.%d-linux-x86_64.egg' % (sys.version_info.major,
sys.version_info.minor))
import carla
import os
import random
import time
# This function is here because this functionality haven't been p... | [
"random.choice",
"carla.VehicleControl",
"os.makedirs",
"carla.Location",
"time.sleep",
"os.path.dirname",
"carla.Client",
"os.path.isdir",
"PIL.Image.frombytes",
"sys.path.append",
"carla.Rotation",
"PIL.Image.merge"
] | [((35, 151), 'sys.path.append', 'sys.path.append', (["('dist/carla-0.9.0-py%d.%d-linux-x86_64.egg' % (sys.version_info.major, sys\n .version_info.minor))"], {}), "('dist/carla-0.9.0-py%d.%d-linux-x86_64.egg' % (sys.\n version_info.major, sys.version_info.minor))\n", (50, 151), False, 'import sys\n'), ((713, 822),... |
#!/usr/bin/env python3
# Author: <NAME>
# Copyright: 2017-2018 NVWA
#
# NVWA: Nederlandse Voedsel- en Warenautoriteit
# Netherlands Food and Consumer Product Safety Authority
# https://english.nvwa.nl/
#
# Licence: GPLv3
import os
import sys
import subprocess
import shutil
import tempfile
import unittest
import itert... | [
"os.path.exists",
"Bio.Blast.NCBIXML.parse",
"pickle.dumps",
"Bio.Seq.Seq",
"subprocess.run",
"os.path.join",
"os.path.isfile",
"itertools.combinations",
"tempfile.mkdtemp",
"Bio.Blast.Applications.NcbiblastnCommandline",
"os.path.basename",
"shutil.rmtree",
"Bio.SeqIO.write"
] | [((14043, 14160), 'Bio.Blast.Applications.NcbiblastnCommandline', 'NcbiblastnCommandline', ([], {'query': '"""test/sul2_1_AF542061.fasta"""', 'db': '"""test/102637-001-018_k64-contigs.fa"""', 'evalue': '(0.001)'}), "(query='test/sul2_1_AF542061.fasta', db=\n 'test/102637-001-018_k64-contigs.fa', evalue=0.001)\n", (1... |
from tests.common import *
import numpy as np
import pandas as pd
import warnings
warnings.filterwarnings('ignore')
def test_silhouette(adata_batch):
#adata = adata_factory(pca=True, n_top_genes=2000)
score = scIB.me.silhouette(adata_batch, group_key='celltype', embed='X_pca', scale=True)
LOGGER.info(f"s... | [
"warnings.filterwarnings"
] | [((83, 116), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (106, 116), False, 'import warnings\n')] |
import os
import logging
import subprocess
from theano.configparser import (
AddConfigVar, BoolParam, ConfigParam, EnumStr, IntParam,
TheanoConfigParser)
from theano.misc.cpucount import cpuCount
from theano.misc.windows import call_subprocess_Popen
_logger = logging.getLogger('theano.configdefaults')... | [
"logging.getLogger",
"theano.misc.windows.call_subprocess_Popen",
"os.getenv",
"theano.configparser.BoolParam",
"theano.configparser.IntParam",
"os.path.join",
"theano.configparser.TheanoConfigParser",
"theano.configparser.ConfigParam",
"theano.configparser.AddConfigVar",
"theano.configparser.Enum... | [((278, 320), 'logging.getLogger', 'logging.getLogger', (['"""theano.configdefaults"""'], {}), "('theano.configdefaults')\n", (295, 320), False, 'import logging\n'), ((331, 351), 'theano.configparser.TheanoConfigParser', 'TheanoConfigParser', ([], {}), '()\n', (349, 351), False, 'from theano.configparser import AddConf... |
import os
import numpy as np
from PIL import Image
import torch
import torch.nn as nn
from dataset import TestDataset
from models import ModelBuilder, SegmentationModule
from utils import colorEncode
from lib.nn import user_scattered_collate, async_copy_to
from lib.utils import as_numpy
from constants import REQ_FILE... | [
"flask_cors.CORS",
"flask.Flask",
"numpy.int32",
"io.BytesIO",
"flask_cors.cross_origin",
"torch.max",
"numpy.array",
"dataset.TestDataset",
"models.SegmentationModule",
"utils.colorEncode",
"torch.nn.NLLLoss",
"time.time",
"torch.cuda.set_device",
"PIL.Image.fromarray",
"PIL.Image.open"... | [((481, 492), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (490, 492), False, 'import os\n'), ((621, 635), 'numpy.int32', 'np.int32', (['pred'], {}), '(pred)\n', (629, 635), True, 'import numpy as np\n'), ((2279, 2306), 'torch.nn.NLLLoss', 'nn.NLLLoss', ([], {'ignore_index': '(-1)'}), '(ignore_index=-1)\n', (2289, 2306)... |
from multiprocessing.pool import Pool
from .fetcher import Oplog
from .input import Input
from .output import Output
class WorkFlow(object):
def __init__(self, config):
self.config = config
def start(self, config):
data = Oplog(config['fetcher'])()
#data=[{'_id':'5c8342ca06160bf1e5d401... | [
"multiprocessing.pool.Pool"
] | [((842, 874), 'multiprocessing.pool.Pool', 'Pool', ([], {'processes': 'self.config.pLen'}), '(processes=self.config.pLen)\n', (846, 874), False, 'from multiprocessing.pool import Pool\n')] |
"""
multipath_conf parses multipath.conf configuration files into nested
dictionaries.
"""
import string
from insights.parsr import (EOF, Forward, LeftCurly, Lift, Literal, LineEnd,
RightCurly, Many, Number, OneLineComment, PosMarker, skip_none, String,
QuotedString, WS, WSChar)
from insights.parsr.quer... | [
"insights.parsr.Many",
"insights.parsr.Literal",
"insights.parsr.query.Entry",
"insights.parsr.Forward",
"insights.parsr.Lift",
"insights.parsr.OneLineComment",
"insights.parsr.String"
] | [((645, 654), 'insights.parsr.Forward', 'Forward', ([], {}), '()\n', (652, 654), False, 'from insights.parsr import EOF, Forward, LeftCurly, Lift, Literal, LineEnd, RightCurly, Many, Number, OneLineComment, PosMarker, skip_none, String, QuotedString, WS, WSChar\n'), ((696, 723), 'insights.parsr.Literal', 'Literal', (['... |
import json
from django.template import Library
from saleor.product.utils import product_json_ld
register = Library()
@register.simple_tag
def product_availability_schema(product):
return json.dumps(product_json_ld(product))
| [
"saleor.product.utils.product_json_ld",
"django.template.Library"
] | [((111, 120), 'django.template.Library', 'Library', ([], {}), '()\n', (118, 120), False, 'from django.template import Library\n'), ((208, 232), 'saleor.product.utils.product_json_ld', 'product_json_ld', (['product'], {}), '(product)\n', (223, 232), False, 'from saleor.product.utils import product_json_ld\n')] |
from pymongo import MongoClient
from pymongo.collection import Collection
from arend.settings import base
class MongoTasksConnector:
def __init__(self):
self.db: MongoClient = MongoClient(base.mongodb_string)
self.task_collection: Collection = self.db[base.mongodb_arend_task_results]
def __e... | [
"pymongo.MongoClient"
] | [((191, 223), 'pymongo.MongoClient', 'MongoClient', (['base.mongodb_string'], {}), '(base.mongodb_string)\n', (202, 223), False, 'from pymongo import MongoClient\n')] |
# Copyright (c) 2021 Cisco Systems, Inc. and its affiliates
# All rights reserved
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless... | [
"sklearn.metrics.classification_report",
"time.sleep",
"numpy.arange",
"monai.transforms.LoadImage",
"monai.utils.set_determinism",
"os.path.exists",
"monai.transforms.ScaleIntensity",
"os.listdir",
"argparse.ArgumentParser",
"monai.transforms.AddChannel",
"monai.transforms.ToTensor",
"monai.a... | [((7769, 7808), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '""""""'}), "(description='')\n", (7792, 7808), False, 'import argparse\n'), ((2013, 2053), 'os.path.join', 'os.path.join', (['root_dir', '"""MedNIST.tar.gz"""'], {}), "(root_dir, 'MedNIST.tar.gz')\n", (2025, 2053), False, 'impor... |
import datetime
import os
import re
import shutil
import tempfile
import zipfile
from typing import Optional
import discord
import py7zr
from discord import HTTPException
from discord.ext import commands
import util
from bot import COOL_CRAB, PENDING_FIXES_CHANNEL, FLASH_GAMES_CHANNEL, OTHER_GAMES_CHANNEL, ANIMATIONS... | [
"discord.ext.commands.has_role",
"shutil.make_archive",
"re.compile",
"bot.is_bot_guy",
"logger.getLogger",
"datetime.date.today",
"curation_validator.get_launch_commands_bluebot",
"tempfile.mkdtemp",
"shutil.rmtree",
"discord.ext.commands.max_concurrency",
"util.get_archive_filenames",
"disco... | [((440, 457), 'logger.getLogger', 'getLogger', (['"""main"""'], {}), "('main')\n", (449, 457), False, 'from logger import getLogger\n'), ((602, 807), 'discord.ext.commands.command', 'commands.command', ([], {'name': '"""check-lc"""', 'brief': '"""Check if a given launch command is already in the master database."""', '... |
import os
import matplotlib.pyplot as plt
import pandas as pd
import torch
import torchvision
from matplotlib import rc
from piq import psnr, ssim
from data_management import (
CropOrPadAndResimulate,
Flatten,
Normalize,
RandomMaskDataset,
filter_acquisition_no_fs,
)
from find_adversarial import ... | [
"pandas.read_pickle",
"data_management.Normalize",
"os.makedirs",
"data_management.CropOrPadAndResimulate",
"config_robustness.OpA",
"operators.rotate_real",
"os.path.join",
"find_adversarial.grid_attack",
"os.path.isfile",
"torch.tensor",
"matplotlib.rc",
"pandas.DataFrame",
"data_managemen... | [((632, 676), 'os.path.join', 'os.path.join', (['config.RESULTS_PATH', '"""attacks"""'], {}), "(config.RESULTS_PATH, 'attacks')\n", (644, 676), False, 'import os\n'), ((692, 750), 'os.path.join', 'os.path.join', (['save_path', '"""challenge_example_V0S15_adv.pkl"""'], {}), "(save_path, 'challenge_example_V0S15_adv.pkl'... |
# Copyright 2018 Google LLC. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or a... | [
"tensorflow_compression.python.ops.spectral_ops.irdft_matrix",
"tensorflow.compat.v1.reshape",
"tensorflow_compression.python.ops.math_ops.lower_bound",
"tensorflow.compat.v1.math.maximum",
"tensorflow.compat.v1.linalg.matmul",
"tensorflow.compat.v1.constant",
"tensorflow.compat.v1.math.square"
] | [((6417, 6467), 'tensorflow.compat.v1.constant', 'tf.constant', (['(self.reparam_offset ** 2)'], {'dtype': 'dtype'}), '(self.reparam_offset ** 2, dtype=dtype)\n', (6428, 6467), True, 'import tensorflow.compat.v1 as tf\n'), ((6480, 6554), 'tensorflow.compat.v1.constant', 'tf.constant', (['((self.minimum + self.reparam_o... |
import sublime, sublime_plugin
import os, re, sys, subprocess
class phpSyntaxCheckerCommand(sublime_plugin.EventListener):
# Command refers to $PATH environment variable
EXECUTE_COMMAND = "/Applications/AMPPS/php-5.6/bin/php -l"
def on_post_save(self, view):
file_path = view.file_name()
command_line = s... | [
"sys.getfilesystemencoding",
"re.compile",
"subprocess.Popen",
"sublime.Region",
"sublime.error_message"
] | [((673, 700), 'sys.getfilesystemencoding', 'sys.getfilesystemencoding', ([], {}), '()\n', (698, 700), False, 'import os, re, sys, subprocess\n'), ((821, 850), 'sublime.error_message', 'sublime.error_message', (['stderr'], {}), '(stderr)\n', (842, 850), False, 'import sublime, sublime_plugin\n'), ((877, 919), 're.compil... |
from django.urls import path
from .views import index
app_name = "app"
urlpatterns = [
path("", index, name="index"),
]
| [
"django.urls.path"
] | [((96, 125), 'django.urls.path', 'path', (['""""""', 'index'], {'name': '"""index"""'}), "('', index, name='index')\n", (100, 125), False, 'from django.urls import path\n')] |
# This is a generated file! Please edit source .ksy file and use kaitai-struct-compiler to rebuild
from pkg_resources import parse_version
import kaitaistruct
from kaitaistruct import KaitaiStruct, KaitaiStream, BytesIO
import collections
if parse_version(kaitaistruct.__version__) < parse_version('0.9'):
raise E... | [
"pkg_resources.parse_version",
"collections.defaultdict"
] | [((245, 284), 'pkg_resources.parse_version', 'parse_version', (['kaitaistruct.__version__'], {}), '(kaitaistruct.__version__)\n', (258, 284), False, 'from pkg_resources import parse_version\n'), ((287, 307), 'pkg_resources.parse_version', 'parse_version', (['"""0.9"""'], {}), "('0.9')\n", (300, 307), False, 'from pkg_r... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""Console script for daskerator."""
from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
import datetime as dt
from functools import partial
from hashlib import md5
import inspect
from operator import methodcaller
import os
from pathlib import Path
from... | [
"bripy.bllb.logging.setup_logging",
"click.File",
"time.sleep",
"pprint.pprint",
"inspect.getmembers",
"distributed.LocalCluster",
"pathlib.Path",
"click.option",
"time.perf_counter",
"os.getpid",
"pandas.DataFrame",
"distributed.Client",
"click.command",
"click.argument",
"hashlib.md5",... | [((6252, 6267), 'click.command', 'click.command', ([], {}), '()\n', (6265, 6267), False, 'import click\n'), ((6946, 6990), 'click.option', 'click.option', (['"""--md5/--no-md5"""'], {'default': '(True)'}), "('--md5/--no-md5', default=True)\n", (6958, 6990), False, 'import click\n'), ((6992, 7035), 'click.option', 'clic... |
from threading import Thread
from time import sleep
from src.airmar.airmar_receiver import AirmarReceiver
from src.airmar.config_reader import read_pin_config, read_interval, read_port_config, read_ids
from src.broadcaster.broadcaster import make_broadcaster, BroadcasterType
class AirmarInputThread(Thread):
"""A... | [
"src.airmar.airmar_receiver.AirmarReceiver",
"src.airmar.config_reader.read_ids",
"src.airmar.config_reader.read_interval",
"time.sleep",
"src.airmar.config_reader.read_pin_config",
"src.broadcaster.broadcaster.make_broadcaster",
"src.airmar.config_reader.read_port_config"
] | [((669, 739), 'src.broadcaster.broadcaster.make_broadcaster', 'make_broadcaster', ([], {'broadcaster_type': 'broadcaster_type', 'filename': 'filename'}), '(broadcaster_type=broadcaster_type, filename=filename)\n', (685, 739), False, 'from src.broadcaster.broadcaster import make_broadcaster, BroadcasterType\n'), ((755, ... |
import utils
from elements import BoolElement
from lib.sysfont import sysfont
from lib.ST7735 import TFT
from machine import Pin
import utime
from displaylib import MenuSwitcher
from utils import tft, buzz
button1 = Pin(2, Pin.IN, Pin.PULL_UP)
button2 = Pin(3, Pin.IN, Pin.PULL_UP)
button3 = Pin(22, Pin.IN, Pin.PULL_UP... | [
"utils.tft.size",
"utils.buzz",
"utime.sleep_ms",
"utils.tft.rgb",
"utils.tft.rotation",
"displaylib.MenuSwitcher.back",
"machine.Pin",
"displaylib.MenuSwitcher.root.next",
"displaylib.MenuSwitcher.current.next",
"utils.tft.initr",
"displaylib.MenuSwitcher.root.draw",
"displaylib.MenuSwitcher.... | [((217, 244), 'machine.Pin', 'Pin', (['(2)', 'Pin.IN', 'Pin.PULL_UP'], {}), '(2, Pin.IN, Pin.PULL_UP)\n', (220, 244), False, 'from machine import Pin\n'), ((255, 282), 'machine.Pin', 'Pin', (['(3)', 'Pin.IN', 'Pin.PULL_UP'], {}), '(3, Pin.IN, Pin.PULL_UP)\n', (258, 282), False, 'from machine import Pin\n'), ((293, 321)... |
import bs4
import flask
import flask_cors
import json
import pyrebase
import requests
import traceback
from lib import TranscriptParser
app = flask.Flask(__name__)
firebase = pyrebase.initialize_app({
'apiKey': '<KEY>',
'authDomain': 'canigraduate-43286.firebaseapp.com',
'databaseURL': 'https://canigraduat... | [
"flask.Flask",
"flask_cors.cross_origin",
"flask.request.form.get",
"pyrebase.initialize_app",
"flask.jsonify"
] | [((143, 164), 'flask.Flask', 'flask.Flask', (['__name__'], {}), '(__name__)\n', (154, 164), False, 'import flask\n'), ((176, 445), 'pyrebase.initialize_app', 'pyrebase.initialize_app', (["{'apiKey': '<KEY>', 'authDomain': 'canigraduate-43286.firebaseapp.com',\n 'databaseURL': 'https://canigraduate-43286.firebaseio.c... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# -----------------------------------------------------------------------------
# :author: <NAME>
# :email: <EMAIL>
# :copyright: (c) 2014-2022, <NAME>
#
# Distributed under the terms of the Creative Commons Attribution 4.0 International Public License.
#
# The full... | [
"logging.getLogger",
"os.path.exists",
"os.path.join"
] | [((645, 672), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (662, 672), False, 'import logging\n'), ((1183, 1208), 'os.path.exists', 'os.path.exists', (['nxdl_file'], {}), '(nxdl_file)\n', (1197, 1208), False, 'import os\n'), ((1615, 1680), 'os.path.join', 'os.path.join', (['file_set.pat... |
#!/usr/bin/env python
# coding: utf-8
from __future__ import absolute_import, division, print_function, unicode_literals
__metaclass__ = type
import argparse
import textwrap
import gc
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
from os import path
from scipy.io import loadmat
from radpy.int... | [
"textwrap.dedent",
"argparse.ArgumentParser",
"matplotlib.use",
"radpy.interpolate.batch_process",
"scipy.io.loadmat",
"matplotlib.pyplot.ioff",
"os.path.split",
"matplotlib.pyplot.close",
"gc.collect"
] | [((203, 224), 'matplotlib.use', 'matplotlib.use', (['"""Agg"""'], {}), "('Agg')\n", (217, 224), False, 'import matplotlib\n'), ((385, 490), 'textwrap.dedent', 'textwrap.dedent', (['""" Example:\n {} -ipmv -o composite brancomp/*.mat\n """'], {}), '(\n """ Example:\n {} -ipmv -o... |
#from __future__ import annotations
from typing import Callable, Dict
from pypresence import Presence, exceptions
import time, sys
# import info about system
from .args import parse_args
from .config import ConfigError, load_config
from .computer.Computer import Computer
args = parse_args()
class Run_rpc:
rpc... | [
"pypresence.Presence",
"time.sleep",
"sys.exit"
] | [((2317, 2328), 'sys.exit', 'sys.exit', (['(0)'], {}), '(0)\n', (2325, 2328), False, 'import time, sys\n'), ((2775, 2789), 'time.sleep', 'time.sleep', (['(30)'], {}), '(30)\n', (2785, 2789), False, 'import time, sys\n'), ((1930, 1949), 'pypresence.Presence', 'Presence', (['client_id'], {}), '(client_id)\n', (1938, 1949... |
from typing import Any, Callable, Generator
from google.cloud.firestore_v1.base_document import DocumentSnapshot
from google.cloud.firestore_v1.collection import CollectionReference
from src.service.firebase.models.documentAPIModel import DocumentFirebaseAPIModel
from src.service.firebase.models.documentEntity import D... | [
"google.cloud.firestore.Client",
"src.service.firebase.models.documentAPIModel.DocumentFirebaseAPIModel"
] | [((670, 703), 'google.cloud.firestore.Client', 'Client', ([], {'project': 'self.project_name'}), '(project=self.project_name)\n', (676, 703), False, 'from google.cloud.firestore import Client\n'), ((1404, 1465), 'src.service.firebase.models.documentAPIModel.DocumentFirebaseAPIModel', 'DocumentFirebaseAPIModel', ([], {'... |
"""
D-SCRIPT: Structure Aware PPI Prediction
"""
import argparse, os, sys
class CitationAction(argparse.Action):
def __init__(self, option_strings, dest, **kwargs):
super(CitationAction, self).__init__(option_strings, dest, **kwargs)
def __call__(self, parser, namespace, values, option_string=None):
... | [
"argparse.ArgumentParser",
"sys.exit"
] | [((493, 537), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '__doc__'}), '(description=__doc__)\n', (516, 537), False, 'import argparse, os, sys\n'), ((434, 445), 'sys.exit', 'sys.exit', (['(0)'], {}), '(0)\n', (442, 445), False, 'import argparse, os, sys\n')] |
#!/usr/bin/env pyturbubox
import ulz
import sys
import cubicle
import argparse
import numpy as np
from pathlib import Path
import matplotlib
matplotlib.use('Agg')
matplotlib.rcParams.update({'font.size': 9})
import matplotlib.pyplot as plt
pp = argparse.ArgumentParser()
pp.add_argument('srcfile', help='path to cou... | [
"argparse.ArgumentParser",
"matplotlib.rcParams.update",
"matplotlib.use",
"cubicle.File",
"matplotlib.pyplot.colorbar",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.ylim",
"matplotlib.pyplot.xlim",
"matplotlib.pyplot.get_cmap"
] | [((144, 165), 'matplotlib.use', 'matplotlib.use', (['"""Agg"""'], {}), "('Agg')\n", (158, 165), False, 'import matplotlib\n'), ((166, 210), 'matplotlib.rcParams.update', 'matplotlib.rcParams.update', (["{'font.size': 9}"], {}), "({'font.size': 9})\n", (192, 210), False, 'import matplotlib\n'), ((249, 274), 'argparse.Ar... |
# -*- coding: utf-8 -*-
import unittest
from bitbucket.bitbucket import Bitbucket
from bitbucket.tests.private import USERNAME, PASSWORD
TEST_REPO_SLUG = 'test_bitbucket_api'
class AuthenticatedBitbucketTest(unittest.TestCase):
""" Bitbucket test base class for authenticated methods."""
def setUp(self):
... | [
"bitbucket.bitbucket.Bitbucket"
] | [((391, 420), 'bitbucket.bitbucket.Bitbucket', 'Bitbucket', (['USERNAME', 'PASSWORD'], {}), '(USERNAME, PASSWORD)\n', (400, 420), False, 'from bitbucket.bitbucket import Bitbucket\n')] |
from lenstronomy.GalKin.numeric_kinematics import NumericKinematics
from lenstronomy.GalKin.analytic_kinematics import AnalyticKinematics
__all__ = ['GalkinModel']
class GalkinModel(object):
"""
this class handles all the kinematic modeling aspects of Galkin
Excluded are observational conditions (seeing,... | [
"lenstronomy.GalKin.numeric_kinematics.NumericKinematics",
"lenstronomy.GalKin.analytic_kinematics.AnalyticKinematics"
] | [((3733, 3797), 'lenstronomy.GalKin.analytic_kinematics.AnalyticKinematics', 'AnalyticKinematics', ([], {'kwargs_cosmo': 'kwargs_cosmo'}), '(kwargs_cosmo=kwargs_cosmo, **kwargs_numerics)\n', (3751, 3797), False, 'from lenstronomy.GalKin.analytic_kinematics import AnalyticKinematics\n'), ((3840, 3935), 'lenstronomy.GalK... |
'''
CIS 419/519 project: Using decision tree ensembles to infer the pathological
cause of age-related neurodegenerative changes based on clinical assessment
nadfahors: <NAME>, <NAME>, & <NAME>
This file contains code for preparing NACC data for analysis, including:
* synthesis of pathology data to create pat... | [
"pandas.Series",
"numpy.ceil",
"numpy.unique",
"pandas.read_csv",
"sklearn.model_selection.train_test_split",
"sklearn.preprocessing.OneHotEncoder",
"pandas.crosstab",
"pickle.load",
"numpy.array",
"sklearn.impute.SimpleImputer",
"pandas.DataFrame",
"pandas.concat",
"sklearn.metrics.confusio... | [((1110, 1148), 'pandas.read_csv', 'pd.read_csv', (['"""investigator_nacc48.csv"""'], {}), "('investigator_nacc48.csv')\n", (1121, 1148), True, 'import pandas as pd\n'), ((1349, 1372), 'pandas.read_csv', 'pd.read_csv', (['"""xvar.csv"""'], {}), "('xvar.csv')\n", (1360, 1372), True, 'import pandas as pd\n'), ((13754, 13... |
"""
Command line utility for converting from pdf to text
- Part of the basic business (decode parameters, open file and main function) are in fucntion, not classes.
"""
import time
import threading
import json
import sys
import getopt
import os
import signal
from common.logmanager import LogManager
from pdfut... | [
"getopt.getopt",
"sys.exit",
"os.path.isfile",
"os._exit",
"pdfutils.pdfmanager.PdfManager",
"common.logmanager.LogManager"
] | [((427, 439), 'common.logmanager.LogManager', 'LogManager', ([], {}), '()\n', (437, 439), False, 'from common.logmanager import LogManager\n'), ((865, 891), 'os.path.isfile', 'os.path.isfile', (['input_file'], {}), '(input_file)\n', (879, 891), False, 'import os\n'), ((1183, 1244), 'getopt.getopt', 'getopt.getopt', (['... |
import sqlalchemy as sa
from .exc import ClassNotVersioned, ImproperlyConfigured
from .manager import VersioningManager
from .operation import Operation
from .transaction import TransactionFactory
from .unit_of_work import UnitOfWork
from .utils import (
changeset,
count_versions,
get_versioning_manager,
... | [
"sqlalchemy.event.remove",
"sqlalchemy.event.listen"
] | [((1832, 1933), 'sqlalchemy.event.listen', 'sa.event.listen', (['sa.engine.Engine', '"""before_cursor_execute"""', 'manager.track_association_operations'], {}), "(sa.engine.Engine, 'before_cursor_execute', manager.\n track_association_operations)\n", (1847, 1933), True, 'import sqlalchemy as sa\n'), ((1964, 2035), '... |
import unittest
import numpy as np
from PCAfold import preprocess
class TestClustering(unittest.TestCase):
################################################################################
#
# Clustering functions
#
################################################################################
def test_variabl... | [
"numpy.random.rand",
"PCAfold.preprocess.get_centroids",
"PCAfold.preprocess.variable_bins",
"PCAfold.preprocess.get_populations",
"numpy.min",
"PCAfold.preprocess.flip_clusters",
"numpy.array",
"numpy.zeros",
"numpy.linspace",
"PCAfold.preprocess.get_partition",
"PCAfold.preprocess.degrade_clus... | [((6999, 7038), 'numpy.array', 'np.array', (['[0, 0, 0, 1.1, 1, 1, 2, 2, 2]'], {}), '([0, 0, 0, 1.1, 1, 1, 2, 2, 2])\n', (7007, 7038), True, 'import numpy as np\n'), ((7171, 7214), 'numpy.array', 'np.array', (['[-1.2, 0, 0, 0, 1, 1, 1, 2, 2, 2]'], {}), '([-1.2, 0, 0, 0, 1, 1, 1, 2, 2, 2])\n', (7179, 7214), True, 'impor... |
# Copyright 2020 Max Planck Institute for Software Systems
# 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 ... | [
"os.path.exists",
"datetime.datetime.now",
"os.mkdir"
] | [((879, 890), 'os.mkdir', 'mkdir', (['path'], {}), '(path)\n', (884, 890), False, 'from os import mkdir\n'), ((805, 820), 'os.path.exists', 'exists', (['"""SimBA"""'], {}), "('SimBA')\n", (811, 820), False, 'from os.path import exists\n'), ((826, 840), 'os.mkdir', 'mkdir', (['"""SimBA"""'], {}), "('SimBA')\n", (831, 84... |
#!/usr/bin/env python
# -*- coding:utf-8 -*-
"""
随机产生验证码
"""
from functools import wraps
import random
code = ""
for i in range(4):
num = random.randrange(0, 2)
# 当前位显示字母或者数字各有50%几率
if num == 0:
# 随机显示数字
r1 = random.randrange(0, 10)
code += str(r1)
else:
# 随机显示字母
... | [
"functools.wraps",
"random.randrange"
] | [((145, 167), 'random.randrange', 'random.randrange', (['(0)', '(2)'], {}), '(0, 2)\n', (161, 167), False, 'import random\n'), ((792, 803), 'functools.wraps', 'wraps', (['func'], {}), '(func)\n', (797, 803), False, 'from functools import wraps\n'), ((241, 264), 'random.randrange', 'random.randrange', (['(0)', '(10)'], ... |
from __future__ import absolute_import, division, unicode_literals
import json
import os
from six import iteritems
from six.moves import zip
from tqdm import tqdm
import zipfile
# these may be used by pick_group_fn/postprocess_fn
from six.moves import range # NOQA
from ..utils import download_utils, file_formats, f... | [
"os.path.exists",
"zipfile.ZipFile",
"os.path.join",
"json.load",
"six.iteritems",
"six.moves.zip",
"json.dump"
] | [((1228, 1245), 'six.iteritems', 'iteritems', (['groups'], {}), '(groups)\n', (1237, 1245), False, 'from six import iteritems\n'), ((1570, 1659), 'os.path.join', 'os.path.join', (["options['metadata_dir']", "(group_options['dataset']['metadata'] + '.json')"], {}), "(options['metadata_dir'], group_options['dataset']['me... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Copyright (C) 2007-2009 <NAME> ( <EMAIL> )
# All rights reserved.
#
# This software is licensed as described in the file COPYING, which
# you should have received as part of this distribution.
"""
Function for simple sequence analysis (reduced part of Trseeker).
- get_... | [
"re.split",
"re.compile",
"collections.defaultdict",
"re.sub",
"random.randint"
] | [((848, 864), 'collections.defaultdict', 'defaultdict', (['int'], {}), '(int)\n', (859, 864), False, 'from collections import defaultdict\n'), ((3063, 3080), 're.compile', 're.compile', (['"""n|N"""'], {}), "('n|N')\n", (3073, 3080), False, 'import re\n'), ((3558, 3586), 're.sub', 're.sub', (['"""\\\\s+"""', '""""""', ... |
# --------------------------------------------------------
# (c) Copyright 2020 by <NAME>.
# Licensed under BSD 3-clause licence.
# --------------------------------------------------------
""" The tools module contains useful functions that don't really belong anywhere else. """
from typing import Any, Callable, List,... | [
"typing.TypeVar"
] | [((365, 377), 'typing.TypeVar', 'TypeVar', (['"""R"""'], {}), "('R')\n", (372, 377), False, 'from typing import Any, Callable, List, TypeVar\n'), ((413, 425), 'typing.TypeVar', 'TypeVar', (['"""S"""'], {}), "('S')\n", (420, 425), False, 'from typing import Any, Callable, List, TypeVar\n'), ((461, 473), 'typing.TypeVar'... |
# Owner(s): ["oncall: jit"]
import sys
import os
import contextlib
import subprocess
from torch.testing._internal.common_utils import TestCase, run_tests, TemporaryFileName
@contextlib.contextmanager
def _jit_disabled():
cur_env = os.environ.get("PYTORCH_JIT", "1")
os.environ["PYTORCH_JIT"] = "0"
try:
... | [
"torch.testing._internal.common_utils.TemporaryFileName",
"subprocess.check_output",
"torch.testing._internal.common_utils.run_tests",
"os.environ.get"
] | [((238, 272), 'os.environ.get', 'os.environ.get', (['"""PYTORCH_JIT"""', '"""1"""'], {}), "('PYTORCH_JIT', '1')\n", (252, 272), False, 'import os\n'), ((2482, 2493), 'torch.testing._internal.common_utils.run_tests', 'run_tests', ([], {}), '()\n', (2491, 2493), False, 'from torch.testing._internal.common_utils import Te... |
##########################################################################
#
# Copyright (c) 2007-2010, Image Engine Design 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:
#
# * Redis... | [
"IECore.curry",
"UIElement.UIElement.__init__"
] | [((4592, 4622), 'UIElement.UIElement.__init__', 'UIElement.__init__', (['self', 'menu'], {}), '(self, menu)\n', (4610, 4622), False, 'from UIElement import UIElement\n'), ((4521, 4582), 'IECore.curry', 'IECore.curry', (['self.__postMenu', 'menu', 'definition', 'useInterToUI'], {}), '(self.__postMenu, menu, definition, ... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import json
import csv
import texttable
from core.alert import messages
from core.alert import info
from core.compatible import version_info
from core.time import now
from core.die import die_failure
from database.db import get_logs_by_scan_unique_id
from database.db impo... | [
"csv.DictWriter",
"texttable.Texttable",
"core.alert.messages",
"json.dumps",
"lib.html_log.log_data.table_title.format",
"core.compatible.version_info",
"lib.html_log.log_data.table_items.format",
"database.db.get_logs_by_scan_unique_id",
"core.time.now"
] | [((1398, 1419), 'texttable.Texttable', 'texttable.Texttable', ([], {}), '()\n', (1417, 1419), False, 'import texttable\n'), ((2514, 2556), 'database.db.get_logs_by_scan_unique_id', 'get_logs_by_scan_unique_id', (['scan_unique_id'], {}), '(scan_unique_id)\n', (2540, 2556), False, 'from database.db import get_logs_by_sca... |
from django import test as django_test
from django.contrib.auth import get_user_model
from django.urls import reverse
from my_project.common.models import Notification
from my_project.common.views import DetailsNotificationView
from my_project.offer.models import Offer
UserModel = get_user_model()
class DetailsNoti... | [
"django.contrib.auth.get_user_model",
"my_project.offer.models.Offer.objects.first",
"my_project.common.models.Notification.objects.first",
"my_project.common.models.Notification.objects.get",
"my_project.offer.models.Offer",
"django.urls.reverse",
"my_project.common.models.Notification"
] | [((284, 300), 'django.contrib.auth.get_user_model', 'get_user_model', ([], {}), '()\n', (298, 300), False, 'from django.contrib.auth import get_user_model\n'), ((989, 1017), 'my_project.common.models.Notification.objects.first', 'Notification.objects.first', ([], {}), '()\n', (1015, 1017), False, 'from my_project.commo... |
'''
Created on 2009-08-18
@author: malem303
'''
import collections
import struct
from imugrabber.algorithms import statistics
def trainingDataSet(longitudeRange = (-5.0, 5.0, 10), latitudeRange = (-5.0, 5.0, 10)):
trainingDataSet = collections.defaultdict(list)
for longitude in statistics.frange(*l... | [
"imugrabber.algorithms.statistics.frange",
"collections.defaultdict"
] | [((244, 273), 'collections.defaultdict', 'collections.defaultdict', (['list'], {}), '(list)\n', (267, 273), False, 'import collections\n'), ((300, 334), 'imugrabber.algorithms.statistics.frange', 'statistics.frange', (['*longitudeRange'], {}), '(*longitudeRange)\n', (317, 334), False, 'from imugrabber.algorithms import... |
#!/usr/local/bin/env python
import json
import os
import numpy as np
from PIL import Image
# Read input data from JSON
fn = "../../../versign-core/src/app/register_request.json"
fo = open(fn, "r")
payload = json.loads(fo.read())
fo.close()
os.remove(fn)
# Get customer ID
user = payload['customerId']
print('Customer:... | [
"numpy.array",
"PIL.Image.fromarray",
"numpy.reshape",
"os.remove"
] | [((242, 255), 'os.remove', 'os.remove', (['fn'], {}), '(fn)\n', (251, 255), False, 'import os\n'), ((649, 687), 'numpy.reshape', 'np.reshape', (['pixelData', '(height, width)'], {}), '(pixelData, (height, width))\n', (659, 687), True, 'import numpy as np\n'), ((533, 563), 'numpy.array', 'np.array', (["refSign['pixelDat... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Define some basic robot costs used in reinforcement learning and optimization.
Dependencies:
- `pyrobolearn.states`
- `pyrobolearn.actions`
"""
from abc import ABCMeta
import numpy as np
import pyrobolearn as prl
from pyrobolearn.robots.robot import Robot
from pyrobol... | [
"numpy.copy",
"numpy.abs",
"numpy.allclose",
"numpy.array",
"numpy.linalg.norm"
] | [((3318, 3335), 'numpy.allclose', 'np.allclose', (['x', '(0)'], {}), '(x, 0)\n', (3329, 3335), True, 'import numpy as np\n'), ((4811, 4838), 'numpy.copy', 'np.copy', (['self.state.data[0]'], {}), '(self.state.data[0])\n', (4818, 4838), True, 'import numpy as np\n'), ((5293, 5310), 'numpy.copy', 'np.copy', (['curr_pos']... |
import matplotlib.pyplot as plt
def produce_plot(train_list, validation_list, plot_name, experiment_name, learning_rate, epochs):
"""
:param train_list:
:param validation_list:
:param plot_name:
:type plot_name: str
:param experiment_name:
:param learning_rate:
:param epochs:
:return:
"""
epoch_range = ra... | [
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.close",
"matplotlib.pyplot.legend"
] | [((379, 427), 'matplotlib.pyplot.plot', 'plt.plot', (['epoch_range', 'train_list'], {'label': '"""Train"""'}), "(epoch_range, train_list, label='Train')\n", (387, 427), True, 'import matplotlib.pyplot as plt\n'), ((459, 517), 'matplotlib.pyplot.plot', 'plt.plot', (['epoch_range', 'validation_list'], {'label': '"""Valid... |
import logging
import os
import shutil
import tempfile
from pythonrouge.pythonrouge import Pythonrouge
from dotenv import load_dotenv
from sacred.observers import MongoObserver
import torch
import numpy as np
load_dotenv()
SAVE_FILES = os.getenv("SACRED_SAVE_FILES", "false").lower() == "true"
def setup_mongo_observ... | [
"logging.getLogger",
"pythonrouge.pythonrouge.Pythonrouge",
"os.getenv",
"numpy.in1d",
"os.path.join",
"dotenv.load_dotenv",
"tempfile.mkdtemp",
"shutil.rmtree",
"sacred.observers.MongoObserver.create"
] | [((210, 223), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (221, 223), False, 'from dotenv import load_dotenv\n'), ((344, 373), 'os.getenv', 'os.getenv', (['"""SACRED_MONGO_URL"""'], {}), "('SACRED_MONGO_URL')\n", (353, 373), False, 'import os\n'), ((388, 415), 'os.getenv', 'os.getenv', (['"""SACRED_DB_NAME""... |
"""Model of Evergreen TestMapping that needs to be analyzed."""
from __future__ import annotations
from datetime import datetime, timedelta
from typing import Optional
import structlog
from pymongo.collection import Collection, ReturnDocument
from pymongo.errors import DuplicateKeyError
LOGGER = structlog.get_logge... | [
"structlog.get_logger",
"datetime.timedelta",
"datetime.datetime.utcnow"
] | [((301, 323), 'structlog.get_logger', 'structlog.get_logger', ([], {}), '()\n', (321, 323), False, 'import structlog\n'), ((340, 358), 'datetime.timedelta', 'timedelta', ([], {'weeks': '(2)'}), '(weeks=2)\n', (349, 358), False, 'from datetime import datetime, timedelta\n'), ((2901, 2918), 'datetime.datetime.utcnow', 'd... |
import pytest
import json
from app import create_app
@pytest.fixture
def testapp():
app = create_app()
app.config['TESTING'] = True
return app.test_client()
def test_docs_endpoint(testapp):
resp = testapp.get('/docs', follow_redirects=True)
assert "Documentation" in resp.data.decode("utf-8")
d... | [
"pytest.mark.parametrize",
"app.create_app"
] | [((716, 888), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (["['amount', 'curr_from', 'curr_to']", "[(100, 'EUR', 'CZK'), (100, 'EUR', 'USD'), (100, 'CZK', 'USD'), (1, 'EUR',\n 'PLN'), (10, 'PLN', 'CZK')]"], {}), "(['amount', 'curr_from', 'curr_to'], [(100, 'EUR',\n 'CZK'), (100, 'EUR', 'USD'), (100, 'CZ... |
#!/usr/bin/env python
from os.path import exists
from setuptools import setup, find_packages
setup(
name='CoinbaseProWebsocketClient',
version=open('VERSION').read().strip(),
# Your name & email here
author='<NAME>',
author_email='<EMAIL>',
# If you had CoinbaseProWebsocketClient.tests, you wo... | [
"os.path.exists",
"setuptools.find_packages"
] | [((368, 383), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (381, 383), False, 'from setuptools import setup, find_packages\n'), ((939, 958), 'os.path.exists', 'exists', (['"""README.md"""'], {}), "('README.md')\n", (945, 958), False, 'from os.path import exists\n')] |
from collections import Counter
class Hashing(object):
def findTheDifference(self, s, t):
"""
:type s: str
:type t: str
:rtype: str
"""
# Prepare a counter for string s.
# This holds the characters as keys and respective frequency as value.
counter_s =... | [
"collections.Counter"
] | [((321, 331), 'collections.Counter', 'Counter', (['s'], {}), '(s)\n', (328, 331), False, 'from collections import Counter\n')] |
import torch
import torch.utils.data
import torch.nn as nn
import torch.optim as optim
from torch.autograd import Variable
from torchvision import datasets, transforms
import torch.nn.functional as F
import numpy as np
from dataset.data_loader_kitti_reimpl import KITTIReader_traj
from models.vgg_warper_weak_short... | [
"torch.mul",
"numpy.log",
"torch.nn.functional.sigmoid",
"torch.nn.MSELoss",
"utils.visual.VisdomShow",
"ops.flow_warper_pad_2x.FlowWarp",
"numpy.mean",
"numpy.concatenate",
"torch.autograd.Variable",
"dataset.data_loader_kitti_reimpl.KITTIReader_traj",
"models.vgg_warper_weak_shortcut_nobn.VGG_... | [((807, 900), 'dataset.data_loader_kitti_reimpl.KITTIReader_traj', 'KITTIReader_traj', ([], {'is_test': '(True)', 'max_interval': '(10)', 'min_ntraj': '(10)', 'max_ntraj': '(10)', 'is_eval': '(True)'}), '(is_test=True, max_interval=10, min_ntraj=10, max_ntraj=10,\n is_eval=True)\n', (823, 900), False, 'from dataset.... |
from __future__ import print_function
from pycontracts import Contract
def remove_fst(dictionary):
del dictionary["arg__0"]
return dictionary
class TestClassBase(object):
@Contract.pre_conditions({
"Both arguments should be positive": lambda args: args.arg__1 > 0 and args.arg__2 > 0
})
d... | [
"pycontracts.Contract.post_conditions",
"pycontracts.Contract.pre_conditions"
] | [((188, 305), 'pycontracts.Contract.pre_conditions', 'Contract.pre_conditions', (["{'Both arguments should be positive': lambda args: args.arg__1 > 0 and args\n .arg__2 > 0}"], {}), "({'Both arguments should be positive': lambda args: \n args.arg__1 > 0 and args.arg__2 > 0})\n", (211, 305), False, 'from pycontrac... |
import matplotlib.pyplot as plt
from matplotlib.patches import Polygon
from matplotlib.collections import PatchCollection
from matplotlib import cm
from matplotlib.colors import ListedColormap, LinearSegmentedColormap, Normalize
import matplotlib.pylab as pylab
import numpy as np
import sys
np.random.seed(0)
class Pl... | [
"numpy.ones_like",
"numpy.abs",
"matplotlib.pyplot.savefig",
"numpy.average",
"matplotlib.collections.PatchCollection",
"numpy.array",
"matplotlib.pyplot.figure",
"numpy.zeros",
"numpy.linspace",
"numpy.random.seed",
"matplotlib.pylab.rcParams.update",
"matplotlib.colors.Normalize",
"numpy.a... | [((293, 310), 'numpy.random.seed', 'np.random.seed', (['(0)'], {}), '(0)\n', (307, 310), True, 'import numpy as np\n'), ((801, 830), 'matplotlib.pylab.rcParams.update', 'pylab.rcParams.update', (['params'], {}), '(params)\n', (822, 830), True, 'import matplotlib.pylab as pylab\n'), ((850, 862), 'matplotlib.pyplot.figur... |
"""``runway gen-sample`` command group."""
# docs: file://./../../../../docs/source/commands.rst
import click
from ... import options
from ._cdk_csharp import cdk_csharp
from ._cdk_py import cdk_py
from ._cdk_tsc import cdk_tsc
from ._cfn import cfn
from ._cfngin import cfngin
from ._k8s_cfn_repo import k8s_cfn_repo
f... | [
"click.group"
] | [((1053, 1123), 'click.group', 'click.group', (['"""gen-sample"""'], {'short_help': '"""generate sample module/project"""'}), "('gen-sample', short_help='generate sample module/project')\n", (1064, 1123), False, 'import click\n')] |
import os
import argparse
import tensorflow as tf
from tensorflow.python.framework import graph_util
dir = os.path.dirname(os.path.realpath(__file__))
from model import Model
# issue 15410
import tempfile
import subprocess
tf.contrib.lite.tempfile = tempfile
tf.contrib.lite.subprocess = subprocess
def freeze_graph... | [
"model.Model",
"argparse.ArgumentParser",
"tensorflow.placeholder",
"tensorflow.train.Saver",
"tensorflow.Session",
"os.path.realpath",
"tensorflow.train.get_checkpoint_state",
"tensorflow.contrib.lite.toco_convert",
"tensorflow.python.framework.graph_util.convert_variables_to_constants",
"tensorf... | [((125, 151), 'os.path.realpath', 'os.path.realpath', (['__file__'], {}), '(__file__)\n', (141, 151), False, 'import os\n'), ((488, 531), 'tensorflow.train.get_checkpoint_state', 'tf.train.get_checkpoint_state', (['model_folder'], {}), '(model_folder)\n', (517, 531), True, 'import tensorflow as tf\n'), ((905, 965), 'te... |
from pymongo import MongoClient
from bson import ObjectId
from settings import Common
# import datetime
# import sys
from twisted.python import log
class MongoModel(dict):
collection_name = None
def __init__(self, *args, **kwargs):
dict.__init__(self, *args, **kwargs)
self.db = self.connect()... | [
"pymongo.MongoClient",
"bson.ObjectId",
"twisted.python.log.msg"
] | [((865, 924), 'pymongo.MongoClient', 'MongoClient', ([], {'host': 'Common.MONGO_HOST', 'port': 'Common.MONGO_PORT'}), '(host=Common.MONGO_HOST, port=Common.MONGO_PORT)\n', (876, 924), False, 'from pymongo import MongoClient\n'), ((416, 429), 'twisted.python.log.msg', 'log.msg', (['self'], {}), '(self)\n', (423, 429), F... |
'''
Author: <NAME> <<EMAIL>>
This package is distributed under Apache 2 license.
'''
from setuptools import setup
from os import path
this_directory = path.abspath(path.dirname(__file__))
with open(path.join(this_directory, 'README.md'), encoding='utf-8') as f:
long_description = f.read()
CLASSIFIERS = """
Deve... | [
"os.path.join",
"os.path.dirname",
"setuptools.setup"
] | [((1310, 1327), 'setuptools.setup', 'setup', ([], {}), '(**metadata)\n', (1315, 1327), False, 'from setuptools import setup\n'), ((167, 189), 'os.path.dirname', 'path.dirname', (['__file__'], {}), '(__file__)\n', (179, 189), False, 'from os import path\n'), ((201, 239), 'os.path.join', 'path.join', (['this_directory', ... |
from dataclasses import dataclass
from typing import List, Optional, OrderedDict
from pylpc.parsers import Char, Longest, Map, Satisfy, Terminal
from pylpc.pylpc import ParseError, ParseResult, Parser, Location, Regex, StringStream
def EOS_PATTERN_ID():
return "<EOS>"
def UNKNOWN_PATTERN_ID():
return "<UNKNOW... | [
"pylpc.parsers.Terminal",
"dataclasses.dataclass",
"pylpc.parsers.Satisfy",
"pylpc.parsers.Char",
"pylpc.pylpc.Parser",
"pylpc.pylpc.ParseError.expectation"
] | [((326, 348), 'dataclasses.dataclass', 'dataclass', ([], {'frozen': '(True)'}), '(frozen=True)\n', (335, 348), False, 'from dataclasses import dataclass\n'), ((397, 419), 'dataclasses.dataclass', 'dataclass', ([], {'frozen': '(True)'}), '(frozen=True)\n', (406, 419), False, 'from dataclasses import dataclass\n'), ((865... |
import io
import re
from contextlib import redirect_stdout
import pytest
from numpy.distutils import log
def setup_module():
f = io.StringIO() # changing verbosity also logs here, capture that
with redirect_stdout(f):
log.set_verbosity(2, force=True) # i.e. DEBUG
def teardown_module():
log.s... | [
"contextlib.redirect_stdout",
"numpy.distutils.log.set_verbosity",
"re.compile",
"pytest.mark.parametrize",
"io.StringIO"
] | [((374, 429), 're.compile', 're.compile', (['"""\\\\x1B(?:[@-Z\\\\\\\\-_]|\\\\[[0-?]*[ -/]*[@-~])"""'], {}), "('\\\\x1B(?:[@-Z\\\\\\\\-_]|\\\\[[0-?]*[ -/]*[@-~])')\n", (384, 429), False, 'import re\n'), ((430, 502), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""func_name"""', "['error', 'warn', 'info', 'd... |
import komand
from .schema import SearchInput, SearchOutput
# Custom imports below
import json
import requests
class Search(komand.Action):
API_URL = 'https://www.threatminer.org/reports.php?api=True'
FLAGS = {
"Full Text": 1,
"By Year": 2
}
def __init__(self):
super(self.__... | [
"requests.get"
] | [((1148, 1189), 'requests.get', 'requests.get', (['self.API_URL'], {'params': 'params'}), '(self.API_URL, params=params)\n', (1160, 1189), False, 'import requests\n'), ((704, 763), 'requests.get', 'requests.get', (['self.API_URL'], {'params': "{'q': query, 'rt': flag}"}), "(self.API_URL, params={'q': query, 'rt': flag}... |
import boto3
import sure # noqa # pylint: disable=unused-import
from moto import mock_guardduty
@mock_guardduty
def test_create_detector():
client = boto3.client("guardduty", region_name="us-east-1")
response = client.create_detector(
Enable=True,
ClientToken="745645734574758463758",
... | [
"boto3.client"
] | [((157, 207), 'boto3.client', 'boto3.client', (['"""guardduty"""'], {'region_name': '"""us-east-1"""'}), "('guardduty', region_name='us-east-1')\n", (169, 207), False, 'import boto3\n'), ((603, 653), 'boto3.client', 'boto3.client', (['"""guardduty"""'], {'region_name': '"""us-east-1"""'}), "('guardduty', region_name='u... |
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.model_zoo as model_zoo
from common.backbone.resnet.resnet import *
from common.backbone.resnet.resnet import Bottleneck, BasicBlock
from common.backbone.resnet.resnet import model_urls
from common.lib.roi_pooling.roi_pool import ROI... | [
"torch.nn.ReLU",
"torch.nn.Dropout",
"torch.nn.Embedding",
"common.utils.flatten.Flattener",
"torch.load",
"torch.nn.Linear",
"pdb.set_trace",
"torch.nn.AvgPool2d",
"common.lib.roi_pooling.roi_align.ROIAlign",
"torch.nn.functional.cross_entropy",
"torch.cat"
] | [((3273, 3330), 'common.lib.roi_pooling.roi_align.ROIAlign', 'ROIAlign', ([], {'output_size': 'output_size', 'spatial_scale': '(1.0 / 16)'}), '(output_size=output_size, spatial_scale=1.0 / 16)\n', (3281, 3330), False, 'from common.lib.roi_pooling.roi_align import ROIAlign\n'), ((5285, 5308), 'torch.nn.Dropout', 'torch.... |
from functools import partial
from aio_pika import Message
import json
from lib.ipc.util import poll_for_async_connection
# from lib.config import logger
async def on_message(entry_point, exchange, message):
with message.process():
msg = json.loads(message.body.decode())
# logger.debug(f"remote c... | [
"functools.partial",
"aio_pika.Message",
"lib.ipc.util.poll_for_async_connection"
] | [((910, 941), 'lib.ipc.util.poll_for_async_connection', 'poll_for_async_connection', (['loop'], {}), '(loop)\n', (935, 941), False, 'from lib.ipc.util import poll_for_async_connection\n'), ((1081, 1139), 'functools.partial', 'partial', (['on_message', 'entry_point', 'channel.default_exchange'], {}), '(on_message, entry... |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'mzlnmsl.ui'
#
# Created by: PyQt5 UI code generator 5.15.4
#
# WARNING: Any manual changes made to this file will be lost when pyuic5 is
# run again. Do not edit this file unless you know what you are doing.
from PyQt5 import QtCore, QtGu... | [
"PyQt5.QtWidgets.QWidget",
"PyQt5.QtWebEngineWidgets.QWebEngineView",
"PyQt5.QtGui.QFont",
"PyQt5.QtCore.QMetaObject.connectSlotsByName",
"PyQt5.QtWidgets.QRadioButton",
"PyQt5.QtCore.QRect",
"PyQt5.QtWidgets.QGroupBox",
"PyQt5.QtWidgets.QLabel",
"PyQt5.QtWidgets.QPushButton",
"PyQt5.QtWidgets.QCh... | [((630, 659), 'PyQt5.QtWidgets.QWidget', 'QtWidgets.QWidget', (['MainWindow'], {}), '(MainWindow)\n', (647, 659), False, 'from PyQt5 import QtCore, QtGui, QtWidgets\n'), ((739, 775), 'PyQt5.QtWidgets.QLabel', 'QtWidgets.QLabel', (['self.centralwidget'], {}), '(self.centralwidget)\n', (755, 775), False, 'from PyQt5 impo... |
# https://colab.research.google.com/github/akeshavan/IntroDL/blob/master/IntroToKeras.ipynb#scrollTo=ZCR5NALKsm1o
# *********************************************************************************************************
# 0. Required libraries
# ************************************************************************... | [
"keras.layers.Conv2D",
"keras.utils.to_categorical",
"keras.optimizers.SGD",
"keras.layers.Dense",
"numpy.arange",
"matplotlib.pyplot.imshow",
"numpy.random.seed",
"numpy.vstack",
"keras.backend.clear_session",
"matplotlib.pyplot.axis",
"glob.glob",
"keras.optimizers.Adam",
"matplotlib.pyplo... | [((391, 412), 'matplotlib.use', 'matplotlib.use', (['"""Agg"""'], {}), "('Agg')\n", (405, 412), False, 'import matplotlib\n'), ((2278, 2299), 'glob.glob', 'glob', (['"""dataset/*.jpg"""'], {}), "('dataset/*.jpg')\n", (2282, 2299), False, 'from glob import glob\n'), ((2394, 2420), 'numpy.zeros', 'np.zeros', (['(N, 256, ... |
#!/usr/bin/python3
import wiringpi2
import time
import datetime
import data_adc as dataDevice
AF_BASE=100
AF_E=AF_BASE+13; AF_RW=AF_BASE+14; AF_RS=AF_BASE+15
AF_DB4=AF_BASE+12; AF_DB5=AF_BASE+11; AF_DB6=AF_BASE+10; AF_DB7=AF_BASE+9
AF_SELECT=AF_BASE+0; AF_RIGHT=AF_BASE+1; AF_DOWN=AF_BASE+2
AF_UP=AF_BASE+3; AF_LEFT=A... | [
"wiringpi2.digitalWrite",
"wiringpi2.lcdInit",
"wiringpi2.lcdPrintf",
"wiringpi2.wiringPiSetup",
"wiringpi2.lcdPosition",
"wiringpi2.digitalRead",
"time.sleep",
"wiringpi2.mcp23017Setup",
"wiringpi2.pinMode",
"data_adc.device"
] | [((459, 484), 'wiringpi2.wiringPiSetup', 'wiringpi2.wiringPiSetup', ([], {}), '()\n', (482, 484), False, 'import wiringpi2\n'), ((487, 523), 'wiringpi2.mcp23017Setup', 'wiringpi2.mcp23017Setup', (['AF_BASE', '(32)'], {}), '(AF_BASE, 32)\n', (510, 523), False, 'import wiringpi2\n'), ((527, 557), 'wiringpi2.pinMode', 'wi... |
# encoding: utf-8
from test_haystack.discovery.models import Bar, Foo
from haystack import indexes
class FooIndex(indexes.SearchIndex, indexes.Indexable):
text = indexes.CharField(document=True, model_attr="body")
def get_model(self):
return Foo
class BarIndex(indexes.SearchIndex, indexes.Indexabl... | [
"haystack.indexes.CharField"
] | [((169, 220), 'haystack.indexes.CharField', 'indexes.CharField', ([], {'document': '(True)', 'model_attr': '"""body"""'}), "(document=True, model_attr='body')\n", (186, 220), False, 'from haystack import indexes\n'), ((335, 367), 'haystack.indexes.CharField', 'indexes.CharField', ([], {'document': '(True)'}), '(documen... |
# Copyright 2022 OpenMined.
#
# 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, ... | [
"utility_analysis.data_peeker.SampleParams",
"absl.testing.absltest.main",
"pipeline_dp.LocalBackend",
"pipeline_dp.DataExtractors",
"utility_analysis.data_peeker.DataPeeker",
"collections.defaultdict"
] | [((4025, 4040), 'absl.testing.absltest.main', 'absltest.main', ([], {}), '()\n', (4038, 4040), False, 'from absl.testing import absltest\n'), ((880, 906), 'pipeline_dp.LocalBackend', 'pipeline_dp.LocalBackend', ([], {}), '()\n', (904, 906), False, 'import pipeline_dp\n'), ((930, 970), 'utility_analysis.data_peeker.Data... |
import re
from bs4 import Tag
from ._abstract import AbstractScraper
from ._utils import normalize_string
"""
NOTE: This website has at least 2 prominent layouts styles, so there are two logic blocks and 2 test cases to
support in ingredients and instructions processing sections.
"""
class FarmhouseDeliver... | [
"re.compile"
] | [((649, 675), 're.compile', 're.compile', (['"""Ingredients:"""'], {}), "('Ingredients:')\n", (659, 675), False, 'import re\n'), ((1356, 1381), 're.compile', 're.compile', (['"""Ingredients"""'], {}), "('Ingredients')\n", (1366, 1381), False, 'import re\n'), ((2223, 2250), 're.compile', 're.compile', (['"""Instructions... |
#!/usr/bin/python
#
# Copyright 2002-2021 Barcelona Supercomputing Center (www.bsc.es)
#
# 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
... | [
"distutils.core.Extension",
"re.sub",
"os.walk"
] | [((1588, 1900), 'distutils.core.Extension', 'Extension', (['"""compss"""'], {'include_dirs': "['../bindings-common/src', '../bindings-common/include', os.environ[\n 'JAVA_HOME'] + '/include', include_jdk]", 'library_dirs': "['../bindings-common/lib']", 'libraries': "['bindings_common']", 'extra_compile_args': 'os_ex... |
import pytest
import random
import collections
import pickle
from uuid import uuid4
import os
import unicodedata
import tempfile
from pkg_resources import parse_version
import gluonnlp
from gluonnlp.data.tokenizers import WhitespaceTokenizer, MosesTokenizer, JiebaTokenizer,\
SpacyTokenizer, SubwordNMTTokenizer, YTT... | [
"gluonnlp.data.tokenizers.SentencepieceTokenizer",
"pickle.dumps",
"gluonnlp.base.get_repo_url",
"gluonnlp.utils.lazy_imports.try_import_huggingface_tokenizers",
"gluonnlp.data.tokenizers.HuggingFaceWordPieceTokenizer",
"pytest.mark.seed",
"gluonnlp.data.tokenizers.SubwordNMTTokenizer",
"gluonnlp.data... | [((21306, 21327), 'pytest.mark.seed', 'pytest.mark.seed', (['(123)'], {}), '(123)\n', (21322, 21327), False, 'import pytest\n'), ((9250, 9271), 'gluonnlp.data.tokenizers.WhitespaceTokenizer', 'WhitespaceTokenizer', ([], {}), '()\n', (9269, 9271), False, 'from gluonnlp.data.tokenizers import WhitespaceTokenizer, MosesTo... |
#!/usr/bin/env python
# coding: utf-8
# In[1]:
import sys
import pathlib
import sqlite3
import pandas as pd
from sklearn.preprocessing import StandardScaler
from sklearn.model_selection import train_test_split
from pycytominer import feature_select
from pycytominer.cyto_utils import infer_cp_features
from utils.si... | [
"pandas.read_sql_query",
"pycytominer.cyto_utils.infer_cp_features",
"scripts.profile_util.load_config",
"sqlite3.connect",
"pandas.read_csv",
"pathlib.Path",
"utils.single_cell_utils.normalize_sc",
"sklearn.model_selection.train_test_split",
"utils.single_cell_utils.process_sites",
"pandas.crosst... | [((371, 412), 'sys.path.append', 'sys.path.append', (['"""../0.generate-profiles"""'], {}), "('../0.generate-profiles')\n", (386, 412), False, 'import sys\n'), ((471, 494), 'pandas.np.random.seed', 'pd.np.random.seed', (['(1234)'], {}), '(1234)\n', (488, 494), True, 'import pandas as pd\n'), ((993, 1051), 'pathlib.Path... |
from django import test
from django_extras.forms import fields
from django_extras.core import validators
class ColorFieldTestCase(test.TestCase):
def test_check_validator_no_alpha(self):
target = fields.ColorField()
self.assertIn(validators.validate_color, target.validators)
def test_check_val... | [
"django_extras.forms.fields.ColorField"
] | [((209, 228), 'django_extras.forms.fields.ColorField', 'fields.ColorField', ([], {}), '()\n', (226, 228), False, 'from django_extras.forms import fields\n'), ((362, 397), 'django_extras.forms.fields.ColorField', 'fields.ColorField', ([], {'allow_alpha': '(True)'}), '(allow_alpha=True)\n', (379, 397), False, 'from djang... |
# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | [
"tensorflow.python.autograph.utils.ag_logging.has_verbosity",
"collections.namedtuple",
"tensorflow.python.autograph.pyct.ast_util.parallel_walk",
"tensorflow.python.autograph.pyct.parser.parse_str",
"tensorflow.python.autograph.utils.ag_logging.log",
"tensorflow.python.autograph.pyct.pretty_printer.fmt",... | [((1321, 1383), 'collections.namedtuple', 'collections.namedtuple', (['"""LineLocation"""', "('filename', 'lineno')"], {}), "('LineLocation', ('filename', 'lineno'))\n", (1343, 1383), False, 'import collections\n'), ((1538, 1610), 'collections.namedtuple', 'collections.namedtuple', (['"""Location"""', "('filename', 'li... |
# Generated by Django 3.0.5 on 2020-05-21 19:25
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
ope... | [
"django.db.models.DateField",
"django.db.models.TextField",
"django.db.models.ForeignKey",
"django.db.models.AutoField",
"django.db.migrations.swappable_dependency",
"django.db.models.CharField"
] | [((247, 304), 'django.db.migrations.swappable_dependency', 'migrations.swappable_dependency', (['settings.AUTH_USER_MODEL'], {}), '(settings.AUTH_USER_MODEL)\n', (278, 304), False, 'from django.db import migrations, models\n'), ((432, 525), 'django.db.models.AutoField', 'models.AutoField', ([], {'auto_created': '(True)... |
#
# Copyright (c) 2018-2020 by <NAME> <<EMAIL>>.
#
# This software is available under the terms of the MIT license. Parts are licensed under
# different terms if stated. The legal terms are attached to the LICENSE file and are
# made available on:
#
# https://opensource.org/licenses/MIT
#
# SPDX-License-Identifier:... | [
"angelos.portfolio.node.create.CreateNode",
"test.fixture.generate.Generate.person_data",
"angelos.portfolio.node.validate.ValidateNode",
"angelos.common.policy.evaluate",
"angelos.portfolio.domain.create.CreateDomain",
"angelos.portfolio.entity.create.CreatePersonEntity"
] | [((1169, 1194), 'angelos.common.policy.evaluate', 'evaluate', (['"""Node:Validate"""'], {}), "('Node:Validate')\n", (1177, 1194), False, 'from angelos.common.policy import evaluate\n'), ((973, 993), 'angelos.portfolio.entity.create.CreatePersonEntity', 'CreatePersonEntity', ([], {}), '()\n', (991, 993), False, 'from an... |
# -*- coding: utf-8 -*-
"""
Various small and named graphs, together with some compact generators.
"""
__author__ ="""<NAME> (<EMAIL>)\<NAME> (<EMAIL>)"""
# Copyright (C) 2004-2008 by
# <NAME> <<EMAIL>>
# <NAME> <<EMAIL>>
# <NAME> <<EMAIL>>
# All rights reserved.
# BSD license.
__all__ = ['make_sma... | [
"networkx.generators.classic.empty_graph",
"networkx.generators.classic.path_graph",
"networkx.generators.classic.complete_graph",
"networkx.generators.classic.cycle_graph",
"networkx.exception.NetworkXError"
] | [((3008, 3036), 'networkx.generators.classic.empty_graph', 'empty_graph', (['n', 'create_using'], {}), '(n, create_using)\n', (3019, 3036), False, 'from networkx.generators.classic import empty_graph, cycle_graph, path_graph, complete_graph\n'), ((5034, 5062), 'networkx.generators.classic.cycle_graph', 'cycle_graph', (... |
from sqlalchemy import create_engine
from constants import SQLALCHEMY_URL
engine = create_engine(SQLALCHEMY_URL)
| [
"sqlalchemy.create_engine"
] | [((85, 114), 'sqlalchemy.create_engine', 'create_engine', (['SQLALCHEMY_URL'], {}), '(SQLALCHEMY_URL)\n', (98, 114), False, 'from sqlalchemy import create_engine\n')] |
from dataclasses import dataclass
from enum import IntEnum, IntFlag, auto
from functools import reduce
from struct import Struct
from typing import Any, Dict, List, Optional, Type
from .datatypes import (
AerospikeDataType,
AerospikeKeyType,
AerospikeValueType,
data_to_aerospike_type,
parse_raw,
)
... | [
"struct.Struct",
"enum.auto"
] | [((428, 434), 'enum.auto', 'auto', ([], {}), '()\n', (432, 434), False, 'from enum import IntEnum, IntFlag, auto\n'), ((449, 455), 'enum.auto', 'auto', ([], {}), '()\n', (453, 455), False, 'from enum import IntEnum, IntFlag, auto\n'), ((469, 475), 'enum.auto', 'auto', ([], {}), '()\n', (473, 475), False, 'from enum imp... |
import logging, os
logging.disable(logging.WARNING)
os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
import tensorflow as tf
from tensorflow.keras import models
from tensorflow.keras import layers
from tensorflow.keras.layers import BatchNormalization, Conv2D, UpSampling2D, MaxPooling2D, Dropout
from tensorflow.keras.optimiz... | [
"numpy.clip",
"tensorflow.math.logical_not",
"tensorflow.keras.backend.epsilon",
"tensorflow.keras.layers.BatchNormalization",
"tensorflow.cast",
"tensorflow.keras.layers.Input",
"tensorflow.keras.layers.Conv2D",
"argparse.ArgumentParser",
"tensorflow.keras.optimizers.Adagrad",
"numpy.stack",
"n... | [((20, 52), 'logging.disable', 'logging.disable', (['logging.WARNING'], {}), '(logging.WARNING)\n', (35, 52), False, 'import logging, os\n'), ((4737, 4770), 'tensorflow.keras.layers.Input', 'layers.Input', ([], {'shape': '(512, 512, 3)'}), '(shape=(512, 512, 3))\n', (4749, 4770), False, 'from tensorflow.keras import la... |
"""Unit tests for netbox_onboarding.onboard module and its classes.
(c) 2020 Network To Code
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 requi... | [
"django.utils.text.slugify",
"dcim.models.Platform.objects.create",
"dcim.models.DeviceRole.objects.create",
"dcim.models.Platform.objects.get",
"dcim.models.Interface.objects.create",
"netbox_onboarding.netbox_keeper.NetboxKeeper",
"dcim.models.Device.objects.create",
"dcim.models.Interface.objects.g... | [((1271, 1320), 'dcim.models.Site.objects.create', 'Site.objects.create', ([], {'name': '"""USWEST"""', 'slug': '"""uswest"""'}), "(name='USWEST', slug='uswest')\n", (1290, 1320), False, 'from dcim.models import Site, Manufacturer, DeviceType, DeviceRole, Device, Interface, Platform\n'), ((1844, 1877), 'netbox_onboardi... |
import torch
from torch import nn, einsum
from functools import partial
from einops import rearrange
# helpers
def exists(val):
return val is not None
def cast_tuple(val, depth):
if isinstance(val, tuple):
return val
return (val,) * depth
# classes
class PreNorm(nn.Module):
def __init__(se... | [
"torch.nn.Dropout",
"deepspeed.ops.sparse_attention.SparseSelfAttention",
"torch.nn.GELU",
"torch.nn.ModuleList",
"einops.rearrange",
"deepspeed.ops.sparse_attention.VariableSparsityConfig",
"torch.einsum",
"functools.partial",
"torch.nn.Linear",
"torch.arange",
"torch.finfo",
"torch.zeros",
... | [((1243, 1289), 'torch.einsum', 'einsum', (['"""b h i j, b h j d -> b h i d"""', 'attn', 'v'], {}), "('b h i j, b h j d -> b h i d', attn, v)\n", (1249, 1289), False, 'from torch import nn, einsum\n'), ((1013, 1056), 'torch.einsum', 'einsum', (['"""b h i d, b h j d -> b h i j"""', 'q', 'k'], {}), "('b h i d, b h j d ->... |
#!/usr/bin/python
# Copyright: Ansible Project
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
from __future__ import absolute_import, division, print_function
__metaclass__ = type
ANSIBLE_METADATA = {'metadata_version': '1.1',
'status': ['preview'],
... | [
"textwrap.dedent",
"collections.namedtuple",
"ansible.module_utils.six.moves.urllib.parse.quote",
"ansible.module_utils.ec2.AWSRetry.jittered_backoff",
"re.match",
"ansible.module_utils.ec2.ansible_dict_to_boto3_filter_list",
"time.sleep",
"uuid.uuid4",
"ansible.module_utils.ec2.camel_dict_to_snake_... | [((31613, 31640), 'ansible.module_utils.ec2.AWSRetry.jittered_backoff', 'AWSRetry.jittered_backoff', ([], {}), '()\n', (31638, 31640), False, 'from ansible.module_utils.ec2 import boto3_conn, ec2_argument_spec, get_aws_connection_info, AWSRetry, ansible_dict_to_boto3_filter_list, compare_aws_tags, boto3_tag_list_to_ans... |
from MazeBase import MazeBase
import MazeData
class Maze(MazeBase):
def __init__(self, mapName, mazeData = MazeData.mazeData, cellWidth = MazeData.CELL_WIDTH):
model = loader.loadModel(mapName)
mData = mazeData[mapName]
self.treasurePosList = mData['treasurePosList']
self.numTreasu... | [
"MazeBase.MazeBase.__init__"
] | [((360, 408), 'MazeBase.MazeBase.__init__', 'MazeBase.__init__', (['self', 'model', 'mData', 'cellWidth'], {}), '(self, model, mData, cellWidth)\n', (377, 408), False, 'from MazeBase import MazeBase\n')] |
# --------------------------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for license information.
# --------------------------------------------------------------------... | [
"azure.mgmt.containerregistry.v2018_02_01_preview.models.DockerBuildStep",
"azure.cli.core.commands.LongRunningOperation",
"knack.log.get_logger",
"azure.mgmt.containerregistry.v2018_02_01_preview.models.SourceControlAuthInfo",
"azure.mgmt.containerregistry.v2018_02_01_preview.models.PlatformProperties",
... | [((1048, 1068), 'knack.log.get_logger', 'get_logger', (['__name__'], {}), '(__name__)\n', (1058, 1068), False, 'from knack.log import get_logger\n'), ((3693, 3981), 'azure.mgmt.containerregistry.v2018_02_01_preview.models.DockerBuildStep', 'DockerBuildStep', ([], {'branch': 'branch', 'image_names': 'image_names', 'is_p... |
"""
Trains a model, acording to the experiment file input
The arguments are loaded from a .yaml file, which is the input argument of this script
(Instructions to run: `python train_model.py <path to .yaml file>`)
"""
import os
import sys
import time
import logging
import yaml
from bff_positioning.data import Preproc... | [
"logging.basicConfig",
"bff_positioning.data.Preprocessor",
"bff_positioning.data.undersample_bf",
"bff_positioning.data.undersample_space",
"bff_positioning.data.create_noisy_features",
"yaml.load",
"logging.info",
"bff_positioning.models.CNN",
"os.path.basename",
"bff_positioning.data.get_95th_p... | [((568, 579), 'time.time', 'time.time', ([], {}), '()\n', (577, 579), False, 'import time\n'), ((584, 617), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': '"""INFO"""'}), "(level='INFO')\n", (603, 617), False, 'import logging\n'), ((1402, 1440), 'logging.info', 'logging.info', (['"""Loading the dataset...... |
import json
import os
from socket import AF_UNIX, SOCK_DGRAM, socket
from core.exceptions import AlreadyRunningError, NotRunningError
from django.conf import settings
from django.contrib.auth.models import User
from django.db import models
from PIL import Image
from .functions import image_upload_to
from .MinecraftIn... | [
"os.path.exists",
"json.loads",
"PIL.Image.open",
"django.db.models.TextField",
"socket.socket",
"django.db.models.ForeignKey",
"django.db.models.IntegerField",
"os.path.join",
"django.db.models.BooleanField",
"django.db.models.ImageField",
"django.db.models.CharField"
] | [((480, 531), 'django.db.models.CharField', 'models.CharField', ([], {'verbose_name': '"""Nom"""', 'max_length': '(64)'}), "(verbose_name='Nom', max_length=64)\n", (496, 531), False, 'from django.db import models\n'), ((568, 633), 'django.db.models.BooleanField', 'models.BooleanField', ([], {'verbose_name': '"""Serveur... |
# -*- coding: utf-8 -*-
import os
import sys
root = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys.path.append(root + '/python')
import ccxt # noqa: E402
exchange = ccxt.binance({
'apiKey': '<KEY>',
'secret': '<KEY>',
'enableRateLimit': True,
})
symbol = 'BTC/USDT'
t... | [
"os.path.abspath",
"ccxt.binance",
"sys.path.append"
] | [((131, 164), 'sys.path.append', 'sys.path.append', (["(root + '/python')"], {}), "(root + '/python')\n", (146, 164), False, 'import sys\n'), ((205, 282), 'ccxt.binance', 'ccxt.binance', (["{'apiKey': '<KEY>', 'secret': '<KEY>', 'enableRateLimit': True}"], {}), "({'apiKey': '<KEY>', 'secret': '<KEY>', 'enableRateLimit'... |
from sympy import (diff, expand, Eq, Integral, integrate, Interval, lambdify,
log, oo, Piecewise, piecewise_fold, symbols, pi, solve,
Rational, Basic)
from sympy.utilities.pytest import XFAIL, raises
x,y = symbols('x,y')
def test_piecewise():
# Test canonization
assert P... | [
"sympy.sin",
"sympy.cos",
"sympy.Eq",
"sympy.utilities.pytest.raises",
"sympy.lambdify",
"sympy.Integral",
"sympy.expand",
"sympy.Rational",
"sympy.symbols",
"sympy.piecewise_fold",
"sympy.Piecewise",
"sympy.solve",
"sympy.Interval",
"sympy.log",
"sympy.O",
"sympy.diff",
"sympy.integ... | [((245, 259), 'sympy.symbols', 'symbols', (['"""x,y"""'], {}), "('x,y')\n", (252, 259), False, 'from sympy import diff, expand, Eq, Integral, integrate, Interval, lambdify, log, oo, Piecewise, piecewise_fold, symbols, pi, solve, Rational, Basic\n'), ((510, 543), 'sympy.utilities.pytest.raises', 'raises', (['TypeError',... |
# Copyright (c) OpenMMLab. All rights reserved.
from mmdet.datasets import DATASETS
from pycocotools.coco import COCO
from .coco_video_dataset import CocoVideoDataset
from .parsers import CocoVID
@DATASETS.register_module()
class ImagenetVIDDataset(CocoVideoDataset):
"""ImageNet VID dataset for video object dete... | [
"pycocotools.coco.COCO",
"mmdet.datasets.DATASETS.register_module"
] | [((200, 226), 'mmdet.datasets.DATASETS.register_module', 'DATASETS.register_module', ([], {}), '()\n', (224, 226), False, 'from mmdet.datasets import DATASETS\n'), ((1558, 1572), 'pycocotools.coco.COCO', 'COCO', (['ann_file'], {}), '(ann_file)\n', (1562, 1572), False, 'from pycocotools.coco import COCO\n')] |
from tkinter import *
import math
import pickle
from game import Board, Game
from mcts_alphaZero import MCTSPlayer
from policy_value_net_tensorflow import PolicyValueNet # Tensorflow
from policy_value_net_res_tensorflow import PolicyValueNetRes30 # Tensorflow
from human_play import Human
#定义棋盘类
class chessBoard() :
... | [
"human_play.Human",
"policy_value_net_res_tensorflow.PolicyValueNetRes30",
"mcts_alphaZero.MCTSPlayer",
"game.Game",
"game.Board",
"policy_value_net_tensorflow.PolicyValueNet"
] | [((2844, 2919), 'game.Board', 'Board', ([], {'width': 'width', 'height': 'height', 'n_in_row': 'n_in_row', 'forbidden_hands': '(False)'}), '(width=width, height=height, n_in_row=n_in_row, forbidden_hands=False)\n', (2849, 2919), False, 'from game import Board, Game\n'), ((2940, 2951), 'game.Game', 'Game', (['board'], {... |