code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
from collections import namedtuple
import json, logging, socket, re, struct, time
from typing import Tuple, Iterator
from urllib.parse import urlparse, parse_qs
from backend import Backend, Change
from protocol import PacketType, recvall, PKT_CHANGE_TYPES, change_from_packet, packet_from_change, send_packet, recv_pack... | [
"socks.socksocket",
"collections.namedtuple",
"urllib.parse.urlparse",
"socket.socket",
"protocol.change_from_packet",
"protocol.recv_packet",
"protocol.send_packet",
"re.match",
"struct.pack",
"time.sleep",
"urllib.parse.parse_qs",
"struct.unpack",
"logging.info",
"protocol.packet_from_ch... | [((534, 590), 'collections.namedtuple', 'namedtuple', (['"""HostPortInfo"""', "['host', 'port', 'addrtype']"], {}), "('HostPortInfo', ['host', 'port', 'addrtype'])\n", (544, 590), False, 'from collections import namedtuple\n'), ((607, 674), 'collections.namedtuple', 'namedtuple', (['"""SocketURLInfo"""', "['target', 'p... |
from typing import List, Tuple
from pathlib import Path
def get_ot_defs() -> List[Tuple[str, int]]:
def_files = (
Path(__file__).parent / ".." / ".." / ".." / "labware" / "definitions" / "2"
).glob("**/*.json")
# example filename
# shared-data/labware/definitions/2/opentrons_96_tiprack_300ul... | [
"pathlib.Path"
] | [((129, 143), 'pathlib.Path', 'Path', (['__file__'], {}), '(__file__)\n', (133, 143), False, 'from pathlib import Path\n')] |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed Jul 7 23:19:58 2021
@author: qiang
"""
import tensorflow.keras.backend as K
import tensorflow as tf
import time
from rl_symbol_env_continous import symbol_env_continous
from DDPG_keras import ActorCritic
from env_base import UR5_env
obs_dim = (10,)
... | [
"rl_symbol_env_continous.symbol_env_continous",
"env_base.UR5_env",
"tensorflow.Session",
"time.sleep",
"DDPG_keras.ActorCritic",
"tensorflow.keras.backend.set_session"
] | [((377, 389), 'tensorflow.Session', 'tf.Session', ([], {}), '()\n', (387, 389), True, 'import tensorflow as tf\n'), ((390, 409), 'tensorflow.keras.backend.set_session', 'K.set_session', (['sess'], {}), '(sess)\n', (403, 409), True, 'import tensorflow.keras.backend as K\n'), ((416, 438), 'rl_symbol_env_continous.symbol_... |
#!/usr/bin/env python
# encoding: utf-8
from flask import Flask, request, jsonify
import base64
import numpy as np
from util.args_help import fill_from_args
import os
import logging
from dpr.simple_mmap_dataset import Corpus
from dpr.faiss_index import ANNIndex
logger = logging.getLogger(__name__)
class Options():
... | [
"logging.getLogger",
"logging.basicConfig",
"util.args_help.fill_from_args",
"flask.Flask",
"base64.b64encode",
"os.path.join",
"flask.request.get_json",
"numpy.zeros",
"logging.root.removeHandler",
"flask.jsonify"
] | [((272, 299), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (289, 299), False, 'import logging\n'), ((865, 1029), 'logging.basicConfig', 'logging.basicConfig', ([], {'format': '"""%(filename)s:%(lineno)d - %(message)s"""', 'datefmt': '"""%m/%d/%Y %H:%M:%S"""', 'level': '(logging.INFO if ... |
import os
import shutil
import pandas as pd
from pathlib import Path
from b2btool.blob.storage import *
try:
conversion = pd.read_excel(
r"J:\PTCR\Users\RECS\.b2btool\drawings_to_jde.xlsx",
dtype={"ID": str, "JDE": str},
)
except FileNotFoundError as ex:
print(ex.args)
def find_jde(draw... | [
"os.path.exists",
"os.makedirs",
"shutil.move",
"pathlib.Path",
"shutil.copyfile",
"pandas.read_excel",
"os.remove"
] | [((128, 233), 'pandas.read_excel', 'pd.read_excel', (['"""J:\\\\PTCR\\\\Users\\\\RECS\\\\.b2btool\\\\drawings_to_jde.xlsx"""'], {'dtype': "{'ID': str, 'JDE': str}"}), "('J:\\\\PTCR\\\\Users\\\\RECS\\\\.b2btool\\\\drawings_to_jde.xlsx',\n dtype={'ID': str, 'JDE': str})\n", (141, 233), True, 'import pandas as pd\n'), ... |
import spacy
import pandas as pd
import numpy as np
# Given tokens, find sentences containing a keyword from texts
def find_sents(tokens,keyword):
useful_sents=[]
for sent in tokens.sents:
bows=[token.text for token in sent]
for word in bows:
if ((keyword in word.lower()) & (sent n... | [
"spacy.load"
] | [((1197, 1225), 'spacy.load', 'spacy.load', (['"""en_core_web_sm"""'], {}), "('en_core_web_sm')\n", (1207, 1225), False, 'import spacy\n')] |
# Noysim -- Noise simulation tools for Aimsun.
# Copyright (c) 2010-2011 by <NAME>, Ghent University & Griffith University.
#
# Basic geometry functions and classes
import numpy
import pylab
EPSILON = 10e-12 # smallest difference for points/directions
#--------------------------------------------------... | [
"numpy.radians",
"numpy.sqrt",
"pylab.plot",
"numpy.arcsin",
"pylab.figure",
"numpy.arctan2",
"pylab.show"
] | [((6690, 6704), 'pylab.figure', 'pylab.figure', ([], {}), '()\n', (6702, 6704), False, 'import pylab\n'), ((3341, 3402), 'numpy.sqrt', 'numpy.sqrt', (['((self.x - other.x) ** 2 + (self.y - other.y) ** 2)'], {}), '((self.x - other.x) ** 2 + (self.y - other.y) ** 2)\n', (3351, 3402), False, 'import numpy\n'), ((4364, 445... |
import unittest
from helpers import auditchecker, xroad
from main.maincontroller import MainController
from tests.xroad_global_groups_tests import global_groups_tests
class XroadMemberRemoveFromGlobalGroup(unittest.TestCase):
"""
SERVICE_38 Remove an X-Road Member from a Global Group
RIA URL: https://jir... | [
"tests.xroad_global_groups_tests.global_groups_tests.test_member_remove_from_global_group",
"main.maincontroller.MainController",
"helpers.auditchecker.AuditChecker",
"unittest.TestCase.__init__"
] | [((561, 605), 'unittest.TestCase.__init__', 'unittest.TestCase.__init__', (['self', 'methodName'], {}), '(self, methodName)\n', (587, 605), False, 'import unittest\n'), ((674, 694), 'main.maincontroller.MainController', 'MainController', (['self'], {}), '(self)\n', (688, 694), False, 'from main.maincontroller import Ma... |
##########################################################################
#
# Copyright (c) 2019, <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 ... | [
"Gaffer.Box",
"unittest.main",
"Gaffer.PlugAlgo.promote",
"Gaffer.StandardSet",
"TestExtension.AddOne",
"Gaffer.V3iPlug",
"Gaffer.Metadata.value",
"Gaffer.Plug.Range",
"Gaffer.Color4fPlug",
"Gaffer.IntPlug",
"Gaffer.FloatPlug",
"Gaffer.StringPlug",
"Gaffer.Metadata.registerValue",
"Gaffer.... | [((6556, 6571), 'unittest.main', 'unittest.main', ([], {}), '()\n', (6569, 6571), False, 'import unittest\n'), ((1943, 1974), 'GafferTest.TestCase.setUp', 'GafferTest.TestCase.setUp', (['self'], {}), '(self)\n', (1968, 1974), False, 'import GafferTest\n'), ((2107, 2127), 'Gaffer.Box', 'Gaffer.Box', (['"""AddOne"""'], {... |
from numpy import average, number
from textblob import TextBlob
class ScaleUtilities:
average = 0
number = 0
def __init__(self, string, number):
self.string = string
def get_subjectivity_of(string):
polarity = TextBlob(string).sentiment.polarity * 5
number += 1
average... | [
"textblob.TextBlob"
] | [((245, 261), 'textblob.TextBlob', 'TextBlob', (['string'], {}), '(string)\n', (253, 261), False, 'from textblob import TextBlob\n')] |
from chibi.atlas import Chibi_atlas
from chibi_command import Command, Command_result
from chibi_hybrid.chibi_hybrid import Chibi_hybrid
__all__ = [ 'Create', 'Start', 'Stop', 'Attach', 'Info', 'Destroy' ]
class Info_result( Command_result ):
def parse_result( self ):
if not self:
return
... | [
"chibi.atlas.Chibi_atlas"
] | [((334, 347), 'chibi.atlas.Chibi_atlas', 'Chibi_atlas', ([], {}), '()\n', (345, 347), False, 'from chibi.atlas import Chibi_atlas\n')] |
import time
from time import sleep
def print_elapsed_time(exit_event):
start_time = time.time()
while True:
if exit_event.is_set():
break
print(f'Running for {round(time.time() - start_time)} s', end='\r')
sleep(1)
| [
"time.time",
"time.sleep"
] | [((90, 101), 'time.time', 'time.time', ([], {}), '()\n', (99, 101), False, 'import time\n'), ((254, 262), 'time.sleep', 'sleep', (['(1)'], {}), '(1)\n', (259, 262), False, 'from time import sleep\n'), ((205, 216), 'time.time', 'time.time', ([], {}), '()\n', (214, 216), False, 'import time\n')] |
""" Adapt Server
This module contains all the functionality necessary to
setup an Adapt Server node (not really).
Example
-------
python3 adapt_server.py -v ingest -s testfile.txt
"""
import filesystem
from filesystem import FSOperationError
import sys
import os
import argparse
import logging
from general import... | [
"logging.basicConfig",
"logging.getLogger",
"os.path.exists",
"user.Keystore",
"user.Keystore.load",
"argparse.ArgumentParser",
"filesystem.UpssFs",
"asset.Asset.from_id",
"asset.Asset",
"general.hash_entity",
"os.path.basename",
"sys.exit",
"os.path.abspath",
"filesystem.LOG.setLevel",
... | [((440, 501), 'logging.basicConfig', 'logging.basicConfig', ([], {'format': '"""%(message)s"""', 'level': 'logging.INFO'}), "(format='%(message)s', level=logging.INFO)\n", (459, 501), False, 'import logging\n'), ((508, 535), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (525, 535), False... |
import gym
import pixelate_arena
import time
import pybullet as p
import os
if __name__ == "__main__":
parent_path = os.path.dirname(os.getcwd())
os.chdir(parent_path)
env = gym.make("pixelate_arena-v0")
x=0
while True:
p.stepSimulation()
if x==10000:
env.unlock_antidote... | [
"time.sleep",
"os.getcwd",
"os.chdir",
"pybullet.stepSimulation",
"gym.make"
] | [((155, 176), 'os.chdir', 'os.chdir', (['parent_path'], {}), '(parent_path)\n', (163, 176), False, 'import os\n'), ((187, 216), 'gym.make', 'gym.make', (['"""pixelate_arena-v0"""'], {}), "('pixelate_arena-v0')\n", (195, 216), False, 'import gym\n'), ((341, 354), 'time.sleep', 'time.sleep', (['(1)'], {}), '(1)\n', (351,... |
from flask import Flask
def create_app():
app = Flask(__name__)
app.config["SECRET_KEY"] = "secret-key-goes-here"
# blueprint for auth routes in our app
from .blue_prints.auth import auth as auth_blueprint
app.register_blueprint(auth_blueprint)
# blueprint for non-auth parts of app
from... | [
"flask.Flask"
] | [((54, 69), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (59, 69), False, 'from flask import Flask\n')] |
import os
import tensorflow as tf
from BertLibrary.bert_predictor import BertPredictor
from BertLibrary.bert_trainer import BertTrainer
from BertLibrary.bert_evaluator import BertEvaluator
from tensorflow.estimator import Estimator
from tensorflow.estimator import RunConfig
from BertLibrary.bert.run_classifier import... | [
"BertLibrary.bert.tokenization.FullTokenizer",
"tensorflow.estimator.RunConfig",
"BertLibrary.bert.modeling.BertConfig.from_json_file",
"tensorflow.estimator.Estimator",
"os.path.join",
"BertLibrary.bert_evaluator.BertEvaluator",
"BertLibrary.bert_predictor.BertPredictor",
"BertLibrary.bert_trainer.Be... | [((1426, 1514), 'tensorflow.estimator.Estimator', 'Estimator', ([], {'model_fn': 'model_fn', 'config': 'config', 'params': "{'batch_size': self.batch_size}"}), "(model_fn=model_fn, config=config, params={'batch_size': self.\n batch_size})\n", (1435, 1514), False, 'from tensorflow.estimator import Estimator\n'), ((15... |
#!/usr/bin/env python3
import unittest
import torch
from torch.distributions import HalfCauchy
from gpytorch.priors import HalfCauchyPrior
from gpytorch.test.utils import least_used_cuda_device
class TestHalfCauchyPrior(unittest.TestCase):
def test_half_cauchy_prior_to_gpu(self):
if torch.cuda.is_avail... | [
"torch.device",
"torch.distributions.HalfCauchy",
"gpytorch.priors.HalfCauchyPrior",
"torch.tensor",
"torch.cuda.is_available",
"unittest.main",
"gpytorch.test.utils.least_used_cuda_device",
"torch.ones"
] | [((3657, 3672), 'unittest.main', 'unittest.main', ([], {}), '()\n', (3670, 3672), False, 'import unittest\n'), ((301, 326), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {}), '()\n', (324, 326), False, 'import torch\n'), ((894, 914), 'gpytorch.priors.HalfCauchyPrior', 'HalfCauchyPrior', (['(0.1)'], {}), '(... |
#!/usr/bin/env python3
from Crypto.PublicKey import RSA
from Crypto.Cipher import PKCS1_OAEP
from Crypto.Cipher import ChaCha20
from Crypto.Hash import SHA256
import binascii
import argparse
#from pathlib import Path
import sys
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="""CLI tool t... | [
"Crypto.Cipher.PKCS1_OAEP.new",
"sys.exit",
"argparse.ArgumentParser",
"Crypto.Cipher.ChaCha20.new"
] | [((271, 344), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""CLI tool to decrypt an ulog file\n"""'}), "(description='CLI tool to decrypt an ulog file\\n')\n", (294, 344), False, 'import argparse\n'), ((1936, 1961), 'Crypto.Cipher.PKCS1_OAEP.new', 'PKCS1_OAEP.new', (['r', 'SHA256'], {}),... |
from django.contrib import admin
from .models import Message, Reply, Reader
# Register your models here.
admin.site.register(Message)
admin.site.register(Reply)
admin.site.register(Reader)
| [
"django.contrib.admin.site.register"
] | [((106, 134), 'django.contrib.admin.site.register', 'admin.site.register', (['Message'], {}), '(Message)\n', (125, 134), False, 'from django.contrib import admin\n'), ((135, 161), 'django.contrib.admin.site.register', 'admin.site.register', (['Reply'], {}), '(Reply)\n', (154, 161), False, 'from django.contrib import ad... |
from models.lenet import *
from models.wresnet import *
import os
def select_model(dataset,
model_name,
pretrained=False,
pretrained_models_path=None):
if dataset in ['SVHN', 'CIFAR10', 'CINIC10', 'CIFAR100']:
n_classes = 100 if dataset == 'CIFAR100' else... | [
"torch.manual_seed",
"torch.load",
"os.path.join",
"random.seed",
"torch.cuda.manual_seed",
"torchsummary.summary",
"time.time",
"torch.FloatTensor"
] | [((2094, 2111), 'random.seed', 'random.seed', (['(1234)'], {}), '(1234)\n', (2105, 2111), False, 'import random\n'), ((2150, 2173), 'torch.manual_seed', 'torch.manual_seed', (['(1234)'], {}), '(1234)\n', (2167, 2173), False, 'import torch\n'), ((2178, 2206), 'torch.cuda.manual_seed', 'torch.cuda.manual_seed', (['(1234)... |
# -*- coding: utf-8 -*-
#!/usr/bin/env python3
import asyncio
import base64
import json
import os
import sys
from aiohttp import web
from navigator.conf import (
DEBUG,
SESSION_PREFIX,
SESSION_URL,
SESSION_KEY,
config
)
from navigator.handlers import nav_exception_handler
from navigator.exception... | [
"aiohttp.web.HTTPFound",
"json.dumps",
"aiohttp.web.Response",
"navigator.auth.sessions.get_session",
"navigator.auth.models.User.get"
] | [((4799, 4817), 'aiohttp.web.HTTPFound', 'web.HTTPFound', (['"""/"""'], {}), "('/')\n", (4812, 4817), False, 'from aiohttp import web\n'), ((727, 752), 'navigator.auth.sessions.get_session', 'get_session', (['self.request'], {}), '(self.request)\n', (738, 752), False, 'from navigator.auth.sessions import get_session, n... |
from bs4 import BeautifulSoup
from PIL import Image
from io import BytesIO
import requests
import os
def start_search():
search = input("Enter Search Item: ")
params = {"q": search}
dir_name = search.replace(" ", "_").lower()
if not os.path.isdir(dir_name):
os.makedirs(dir_name)
r = req... | [
"os.makedirs",
"io.BytesIO",
"requests.get",
"bs4.BeautifulSoup",
"os.path.isdir"
] | [((317, 381), 'requests.get', 'requests.get', (['"""http://www.bing.com/images/search"""'], {'params': 'params'}), "('http://www.bing.com/images/search', params=params)\n", (329, 381), False, 'import requests\n'), ((394, 430), 'bs4.BeautifulSoup', 'BeautifulSoup', (['r.text', '"""html.parser"""'], {}), "(r.text, 'html.... |
from office31 import office31
from office31 import download_and_extract_office31
from pathlib import Path
import os
#Hacky script to count how many images are in each folder/cluster in both sources
out_name = "./data/office31/office31_count.txt"
def count_items(src="amazon"):
file_open=open(out_name, "a")
labe... | [
"os.listdir",
"os.path.join"
] | [((399, 412), 'os.listdir', 'os.listdir', (['d'], {}), '(d)\n', (409, 412), False, 'import os\n'), ((434, 455), 'os.path.join', 'os.path.join', (['d', 'path'], {}), '(d, path)\n', (446, 455), False, 'import os\n'), ((473, 494), 'os.listdir', 'os.listdir', (['full_path'], {}), '(full_path)\n', (483, 494), False, 'import... |
# -*- coding: utf-8 -*-
"""Webscraper for Swedish data.
Reference: https://www.scb.se/hitta-statistik/statistik-efter-amne/befolkning/befolkningens-sammansattning/befolkningsstatistik/pong/tabell-och-diagram/preliminar-statistik-over-doda/
Todo:
* caching
"""
import pkg_resources
from .main import *
from . impo... | [
"pkg_resources.get_distribution"
] | [((394, 441), 'pkg_resources.get_distribution', 'pkg_resources.get_distribution', (['"""covid19sweden"""'], {}), "('covid19sweden')\n", (424, 441), False, 'import pkg_resources\n')] |
# -*- coding: utf-8 -*-
# ----------------------------------------------------------------------
# Copyright (c) 2021
#
# See the LICENSE file for details
# see the AUTHORS file for authors
# ----------------------------------------------------------------------
#--------------------
# System wide imports
# ----------... | [
"airflow_actionproject.hooks.action.ActionDatabaseHook"
] | [((846, 873), 'airflow_actionproject.hooks.action.ActionDatabaseHook', 'ActionDatabaseHook', (['conn_id'], {}), '(conn_id)\n', (864, 873), False, 'from airflow_actionproject.hooks.action import ActionDatabaseHook\n')] |
from ioflo.base.consoling import getConsole
from stp_core.crypto.nacl_wrappers import Signer as NaclSigner, Privateer
from raet.raeting import AutoMode, Acceptance
from raet.road.estating import RemoteEstate
from raet.road.stacking import RoadStack
from stp_raet.test.helper import handshake, sendMsgs, cleanup, getRemo... | [
"ioflo.base.consoling.getConsole",
"stp_raet.test.helper.sendMsgs",
"stp_core.crypto.nacl_wrappers.Privateer",
"stp_raet.test.helper.getRemote",
"stp_core.network.port_dispenser.genHa",
"stp_raet.test.helper.handshake",
"stp_core.crypto.nacl_wrappers.Signer",
"raet.road.stacking.RoadStack",
"raet.ro... | [((425, 436), 'stp_core.common.log.getlogger', 'getlogger', ([], {}), '()\n', (434, 436), False, 'from stp_core.common.log import getlogger\n'), ((1151, 1163), 'stp_core.crypto.nacl_wrappers.Signer', 'NaclSigner', ([], {}), '()\n', (1161, 1163), True, 'from stp_core.crypto.nacl_wrappers import Signer as NaclSigner, Pri... |
import threading
import sqlite3
from enum import Enum
import time
import datetime
from ..CTGP7Defines import CTGP7Defines
current_time_min = lambda: int(round(time.time() / 60))
class ConsoleMessageType(Enum):
SINGLE_MESSAGE = 0
TIMED_MESSAGE = 1
SINGLE_KICKMESSAGE = 2
TIMED_KICKMESSAGE = 3
class CT... | [
"threading.Lock",
"time.time",
"sqlite3.connect",
"datetime.datetime.utcnow"
] | [((436, 452), 'threading.Lock', 'threading.Lock', ([], {}), '()\n', (450, 452), False, 'import threading\n'), ((644, 723), 'sqlite3.connect', 'sqlite3.connect', (['"""RedYoshiBot/server/data/data.sqlite"""'], {'check_same_thread': '(False)'}), "('RedYoshiBot/server/data/data.sqlite', check_same_thread=False)\n", (659, ... |
import taichi as ti
from FD_wave.wave_module_2d4d import wave
from FD_wave.receiver_module import receiver
import Visualization.SFE_visual as vis
ti.init(arch=ti.gpu)
frame = 1
c = ti.field(dtype=ti.f32, shape=(600,600))
c_s = ti.field(dtype=ti.f32, shape=(1000, 1000))
wave_cs = wave(300, 400, 600, 600, 10.0, 10.0, 1... | [
"FD_wave.receiver_module.receiver",
"taichi.init",
"FD_wave.wave_module_2d4d.wave",
"Visualization.SFE_visual.SFE_2mix_show",
"taichi.field",
"taichi.GUI",
"Visualization.SFE_visual.SFE_gray_show"
] | [((147, 167), 'taichi.init', 'ti.init', ([], {'arch': 'ti.gpu'}), '(arch=ti.gpu)\n', (154, 167), True, 'import taichi as ti\n'), ((183, 223), 'taichi.field', 'ti.field', ([], {'dtype': 'ti.f32', 'shape': '(600, 600)'}), '(dtype=ti.f32, shape=(600, 600))\n', (191, 223), True, 'import taichi as ti\n'), ((229, 271), 'taic... |
critics={'<NAME>': {'Lady in the Water': 2.5, 'Snakes on a Plane': 3.5, 'Just My Luck': 3.0, 'Superman Returns': 3.5, 'You, Me and Dupree': 2.5, 'The Night Listener': 3.0},
'<NAME>': {'Lady in the Water': 3.0, 'Snakes on a Plane': 3.5, 'Just My Luck': 1.5, 'Superman Returns': 5.0, 'The Night Listener': 3.0, 'Y... | [
"math.sqrt"
] | [((2218, 2234), 'math.sqrt', 'sqrt', (['inital_dis'], {}), '(inital_dis)\n', (2222, 2234), False, 'from math import sqrt\n')] |
from django.contrib import admin
from applications.core.models import Clients
admin.site.register(Clients)
| [
"django.contrib.admin.site.register"
] | [((81, 109), 'django.contrib.admin.site.register', 'admin.site.register', (['Clients'], {}), '(Clients)\n', (100, 109), False, 'from django.contrib import admin\n')] |
import itertools
import logging
import netCDF4
import numpy
from .. import core
from ..constants import masked as cfdm_masked
from ..decorators import (
_inplace_enabled,
_inplace_enabled_define_and_cleanup,
_manage_log_level_via_verbosity,
)
from ..functions import abspath
from ..mixin.container import C... | [
"logging.getLogger",
"numpy.prod",
"numpy.ma.getmaskarray",
"numpy.asanyarray",
"numpy.array",
"numpy.ma.is_masked",
"numpy.where",
"numpy.ma.masked_all",
"itertools.product",
"numpy.ndim",
"numpy.ma.masked_where",
"numpy.empty",
"numpy.ma.where",
"numpy.amin",
"numpy.ma.array",
"numpy... | [((412, 439), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (429, 439), False, 'import logging\n'), ((24164, 24184), 'numpy.ma.isMA', 'numpy.ma.isMA', (['array'], {}), '(array)\n', (24177, 24184), False, 'import numpy\n'), ((40415, 40435), 'numpy.ma.isMA', 'numpy.ma.isMA', (['array'], {}... |
# -*- coding: utf-8 -*-
from __future__ import print_function
from __future__ import unicode_literals
from __future__ import division
from __future__ import absolute_import
from builtins import open
from builtins import str
import json
import os
import sys
from dateutil.parser import parse
from html2text import HTML2Te... | [
"dateutil.parser.parse",
"os.path.exists",
"os.makedirs",
"lxml.etree.parse",
"html2text.HTML2Text",
"json.dumps",
"builtins.str",
"os.path.join",
"bs4.BeautifulSoup",
"lxml.etree.XMLParser",
"os.path.isdir",
"sys.exit",
"builtins.open",
"os.path.expanduser"
] | [((702, 735), 'os.path.expanduser', 'os.path.expanduser', (['enex_filename'], {}), '(enex_filename)\n', (720, 735), False, 'import os\n'), ((3037, 3061), 'builtins.open', 'open', (['self.enex_filename'], {}), '(self.enex_filename)\n', (3041, 3061), False, 'from builtins import open\n'), ((911, 941), 'os.path.expanduser... |
from django.conf.urls import patterns, url
# App specific URL patterns
urlpatterns = patterns("djkatta.cabshare.views",
# post new req
url(r'new_post/$', 'new_post', name='new_post'),
# view posts by the user
url(r'my_posts/$', 'my_posts', name='my_posts'),
# modify old req
url(r'(?P<post_id... | [
"django.conf.urls.url"
] | [((145, 191), 'django.conf.urls.url', 'url', (['"""new_post/$"""', '"""new_post"""'], {'name': '"""new_post"""'}), "('new_post/$', 'new_post', name='new_post')\n", (148, 191), False, 'from django.conf.urls import patterns, url\n'), ((228, 274), 'django.conf.urls.url', 'url', (['"""my_posts/$"""', '"""my_posts"""'], {'n... |
#!/usr/bin/env python
# coding:utf8
# -*- coding: utf-8 -*-
"""
Main Program: Run MODIS AGGREGATION IN MPI WITH FLEXIBLE STATISTICS
Created on 2020
@author: <NAME> (Email: <EMAIL>)
"""
import os
import sys
import h5py
import timeit
import random
import calendar
import numpy as np
import pandas as pd
from mpi4py impo... | [
"numpy.where",
"timeit.default_timer",
"random.seed",
"h5py.File",
"numpy.split",
"numpy.arange"
] | [((1212, 1234), 'timeit.default_timer', 'timeit.default_timer', ([], {}), '()\n', (1232, 1234), False, 'import timeit\n'), ((1372, 1389), 'random.seed', 'random.seed', (['rank'], {}), '(rank)\n', (1383, 1389), False, 'import random\n'), ((1484, 1518), 'numpy.arange', 'np.arange', (['(total_file_num + remain)'], {}), '(... |
import typing
from lxml import html
import requests
from dataclasses import dataclass
from waffle.logger import LOG
from waffle.law_url import LawUrl
@dataclass
class _FollowResults:
path: LawUrl
links: typing.List[LawUrl]
@dataclass
class DownloadResults:
path: LawUrl
content: str
class Downloade... | [
"waffle.logger.LOG.debug",
"waffle.law_url.LawUrl",
"lxml.html.fromstring"
] | [((503, 530), 'waffle.law_url.LawUrl', 'LawUrl', (['self.LAWS[language]'], {}), '(self.LAWS[language])\n', (509, 530), False, 'from waffle.law_url import LawUrl\n'), ((1059, 1103), 'waffle.logger.LOG.debug', 'LOG.debug', (['"""Processing page at %s"""', 'location'], {}), "('Processing page at %s', location)\n", (1068, ... |
from django.urls import path
from rest_framework import routers
from .administration.views import AdministrationOfUserAPIView
from .views import PersonDetailView, PersonDashboardsWidgetsView, PersonWidgetDefinitionViewSet, PersonStackViewset
router = routers.SimpleRouter()
router.register(r'admin/users', Administrati... | [
"rest_framework.routers.SimpleRouter"
] | [((253, 275), 'rest_framework.routers.SimpleRouter', 'routers.SimpleRouter', ([], {}), '()\n', (273, 275), False, 'from rest_framework import routers\n')] |
# -*- coding: utf-8 -*-
'''This code pulls all coins from Conmarketcap.com
It stores it in a pandas dataframe'''
from bs4 import BeautifulSoup
import requests
import pandas as pd
import json
import collections
def coinmarketcap_coins(n):
'''This function pulls all the cryptocurrencies and its relat... | [
"json.loads",
"pandas.DataFrame.from_dict",
"bs4.BeautifulSoup",
"collections.defaultdict",
"pandas.DataFrame",
"pandas.concat"
] | [((534, 548), 'pandas.DataFrame', 'pd.DataFrame', ([], {}), '()\n', (546, 548), True, 'import pandas as pd\n'), ((937, 978), 'bs4.BeautifulSoup', 'BeautifulSoup', (['cmc.content', '"""html.parser"""'], {}), "(cmc.content, 'html.parser')\n", (950, 978), False, 'from bs4 import BeautifulSoup\n'), ((1252, 1280), 'json.loa... |
import json
import re
import traceback
from flask import request, make_response, abort
from flask.views import MethodView
from api import app
from api.extensions.api import Blueprint
from api.commands import log_parser
blp = Blueprint(
'Log',
__name__,
url_prefix='/logs',
description="Operations on ... | [
"flask.make_response",
"api.extensions.api.Blueprint",
"json.dumps",
"flask.request.args.get"
] | [((229, 318), 'api.extensions.api.Blueprint', 'Blueprint', (['"""Log"""', '__name__'], {'url_prefix': '"""/logs"""', 'description': '"""Operations on all logs"""'}), "('Log', __name__, url_prefix='/logs', description=\n 'Operations on all logs')\n", (238, 318), False, 'from api.extensions.api import Blueprint\n'), (... |
import os
import re
import string
from collections import namedtuple, defaultdict
from tests import utils
from tests.parser import ParserTestCase
from sglove.parser.exception import *
from sglove.parser import _OptionManager
class TestOptionManager(ParserTestCase):
__TEST_COUNT = 50
def __test_invalid_nami... | [
"sglove.parser._OptionManager",
"collections.namedtuple",
"tests.utils.get_temp_file",
"collections.defaultdict",
"tests.utils.config_file",
"re.sub"
] | [((368, 398), 'sglove.parser._OptionManager', '_OptionManager', (['self._APP_NAME'], {}), '(self._APP_NAME)\n', (382, 398), False, 'from sglove.parser import _OptionManager\n'), ((416, 453), 'collections.namedtuple', 'namedtuple', (['"""name_t"""', "('name', 'sub')"], {}), "('name_t', ('name', 'sub'))\n", (426, 453), F... |
# coding: utf-8
"""
Gitea API.
This documentation describes the Gitea API. # noqa: E501
OpenAPI spec version: 1.15.3
Generated by: https://github.com/swagger-api/swagger-codegen.git
"""
import pprint
import re # noqa: F401
import six
from gitea_api.configuration import Configuration
clas... | [
"six.iteritems",
"gitea_api.configuration.Configuration"
] | [((4858, 4891), 'six.iteritems', 'six.iteritems', (['self.swagger_types'], {}), '(self.swagger_types)\n', (4871, 4891), False, 'import six\n'), ((1449, 1464), 'gitea_api.configuration.Configuration', 'Configuration', ([], {}), '()\n', (1462, 1464), False, 'from gitea_api.configuration import Configuration\n')] |
import unittest
from jina.executors.crafters import BaseCrafter
from jina.flow import Flow
from jina.proto import jina_pb2
from tests import JinaTestCase
class DummyCrafter(BaseCrafter):
def craft(self, *args, **kwargs):
return 1 / 0
class FlowExceptTestCase(JinaTestCase):
def test_bad_flow(self):... | [
"unittest.main",
"jina.flow.Flow"
] | [((2485, 2500), 'unittest.main', 'unittest.main', ([], {}), '()\n', (2498, 2500), False, 'import unittest\n'), ((475, 481), 'jina.flow.Flow', 'Flow', ([], {}), '()\n', (479, 481), False, 'from jina.flow import Flow\n'), ((1158, 1164), 'jina.flow.Flow', 'Flow', ([], {}), '()\n', (1162, 1164), False, 'from jina.flow impo... |
from enum import Enum
from dlchord2.const import ACCIDENTALS_SHARP, ACCIDENTALS_FLAT
from dlchord2.exceptions.accidentals_exceptions import AccidentalsParseError
class AccidentalsType(Enum):
"""
調号の種類を表す列挙体
"""
NONE = 0
SHARP = 1
FLAT = 2
class AccidentalsParseData(object):
"""
調号を解... | [
"dlchord2.exceptions.accidentals_exceptions.AccidentalsParseError"
] | [((1551, 1599), 'dlchord2.exceptions.accidentals_exceptions.AccidentalsParseError', 'AccidentalsParseError', (['"""異なる調号は重複して存在することはできません。"""'], {}), "('異なる調号は重複して存在することはできません。')\n", (1572, 1599), False, 'from dlchord2.exceptions.accidentals_exceptions import AccidentalsParseError\n')] |
import pytest
import yaml
from nequip.utils import instantiate
simple_default = {"b": 1, "d": 31}
class SimpleExample:
def __init__(self, a, b=simple_default["b"], d=simple_default["d"]):
self.a = a
self.b = b
self.d = d
nested_default = {"d": 37}
class NestedExample:
def __init... | [
"pytest.mark.parametrize",
"nequip.utils.instantiate",
"pytest.raises",
"yaml.dump"
] | [((865, 913), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""prefix"""', '[True, False]'], {}), "('prefix', [True, False])\n", (888, 913), False, 'import pytest\n'), ((3012, 3060), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""prefix"""', '[True, False]'], {}), "('prefix', [True, False])\n", ... |
import torch
import torch.nn as nn
import os
import torch.optim as optim
import torch.optim.lr_scheduler as lr_scheduler
from .modules import WavePool, WaveUnpool, ImagePool, NLayerDiscriminator
from utils.metrics import compute_dice_metric
from utils.losses import DiceLoss
import numpy as np
class WaveEncoder(nn.Mod... | [
"torch.nn.ReLU",
"os.makedirs",
"numpy.random.random",
"torch.nn.ReflectionPad2d",
"os.path.join",
"torch.nn.Conv2d",
"torch.tensor",
"torch.nn.BCELoss",
"os.path.isdir",
"torch.round",
"utils.losses.DiceLoss"
] | [((479, 500), 'torch.nn.ReflectionPad2d', 'nn.ReflectionPad2d', (['(1)'], {}), '(1)\n', (497, 500), True, 'import torch.nn as nn\n'), ((521, 542), 'torch.nn.ReLU', 'nn.ReLU', ([], {'inplace': '(True)'}), '(inplace=True)\n', (528, 542), True, 'import torch.nn as nn\n'), ((565, 589), 'torch.nn.Conv2d', 'nn.Conv2d', (['(3... |
#
# copyright © 2020 - all rights reserved
# Created at: 03/11/20
# By: mauromarini
# License: MIT
# Repository: https://github.com/marinimau/wayne_django_rest
# Credits: @marinimau (https://github.com/marinimau)
#
from django.urls import path
from api.user import views as user_views
from api.social impor... | [
"api.social.views.UsernameSocialAccountRetrieve.as_view",
"api.user.views.UserDetailPublic.as_view",
"api.social.views.UsernameSocialAccountPublic.as_view",
"api.social.views.EmailSocialAccountRetrieve.as_view",
"api.user.views.ProfileDetailPublic.as_view",
"api.social.views.EmailSocialAccountPublic.as_vi... | [((651, 688), 'api.user.views.UserDetailPublic.as_view', 'user_views.UserDetailPublic.as_view', ([], {}), '()\n', (686, 688), True, 'from api.user import views as user_views\n'), ((726, 766), 'api.user.views.ProfileDetailPublic.as_view', 'user_views.ProfileDetailPublic.as_view', ([], {}), '()\n', (764, 766), True, 'fro... |
# -*- coding: utf-8 -*-
# This file is part of CSDaily.
# Copyright (C) 2018-present qytz <<EMAIL>>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LIC... | [
"logging.getLogger",
"aiohttp.ClientSession",
"os.makedirs",
"sqlalchemy.create_engine",
"os.path.join",
"datetime.datetime.now",
"pandas.DataFrame",
"datetime.date.today",
"asyncio.get_event_loop",
"time.time"
] | [((853, 880), 'logging.getLogger', 'logging.getLogger', (['__file__'], {}), '(__file__)\n', (870, 880), False, 'import logging\n'), ((4685, 4705), 'pandas.DataFrame', 'pd.DataFrame', (['quotes'], {}), '(quotes)\n', (4697, 4705), True, 'import pandas as pd\n'), ((5124, 5168), 'os.path.join', 'os.path.join', (['self._dat... |
import kfserving
from typing import List, Union
import numpy as np
class Predictor(): # pylint:disable=too-few-public-methods
def __init__(self, clf: kfserving.KFModel):
self.clf = clf
def predict_fn(self, arr: Union[np.ndarray, List]) -> np.ndarray:
instances = []
for req_data in arr... | [
"numpy.array"
] | [((557, 586), 'numpy.array', 'np.array', (["resp['predictions']"], {}), "(resp['predictions'])\n", (565, 586), True, 'import numpy as np\n')] |
# Configuration file for the Sphinx documentation builder.
#
# This file only contains a selection of the most common options. For a full
# list see the documentation:
# https://www.sphinx-doc.org/en/master/usage/configuration.html
# -- Path setup --------------------------------------------------------------
# If ex... | [
"os.path.abspath"
] | [((593, 617), 'os.path.abspath', 'os.path.abspath', (['"""../.."""'], {}), "('../..')\n", (608, 617), False, 'import os\n'), ((638, 667), 'os.path.abspath', 'os.path.abspath', (['"""../../tnpy"""'], {}), "('../../tnpy')\n", (653, 667), False, 'import os\n')] |
import docker, json
VALID_PROFILE = ['volume', 'mariadb']
def backup_list():
client = docker.DockerClient(base_url='unix://var/run/docker.sock')
bck = {}
for ct in client.containers.list(all=True):
is_backup = False
error = []
if 'one.h42.backup.enable' in ct.labels:
if... | [
"docker.DockerClient"
] | [((92, 150), 'docker.DockerClient', 'docker.DockerClient', ([], {'base_url': '"""unix://var/run/docker.sock"""'}), "(base_url='unix://var/run/docker.sock')\n", (111, 150), False, 'import docker, json\n'), ((2966, 3024), 'docker.DockerClient', 'docker.DockerClient', ([], {'base_url': '"""unix://var/run/docker.sock"""'})... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
'''
Based on storm.py module from https://github.com/nathanmarz/storm/blob/master/storm-core/src/multilang/py/storm.py, and the examples from https://github.com/apache/incubator-storm/blob/master/examples/storm-starter/multilang/resources/splitsentence.py and http://storm.... | [
"get_tweets.get_tweets_for_trends",
"storm.emit",
"time.sleep",
"get_tweets.authenticate",
"tweepy.API",
"get_tweets.get_trending_topics_text",
"get_tweets.available_places"
] | [((1462, 1484), 'time.sleep', 'time.sleep', (['sleep_time'], {}), '(sleep_time)\n', (1472, 1484), False, 'import json, time\n'), ((1964, 1993), 'get_tweets.available_places', 'get_tweets.available_places', ([], {}), '()\n', (1991, 1993), False, 'import get_tweets\n'), ((2459, 2491), 'time.sleep', 'time.sleep', (['self.... |
#!/usr/bin/env python
from __future__ import division
__author__ = "<NAME>"
__copyright__ = "Copyright 2013, The Emperor Project"
__credits__ = ["<NAME>"]
__license__ = "BSD"
__version__ = "0.9.3-dev"
__maintainer__ = "<NAME>"
__email__ = "<EMAIL>"
__status__ = "Development"
from unittest import TestCase, main
from ... | [
"os.close",
"numpy.testing.assert_almost_equal",
"numpy.array",
"unittest.main",
"emperor.parse.parse_coords",
"tempfile.mkstemp"
] | [((2964, 2970), 'unittest.main', 'main', ([], {}), '()\n', (2968, 2970), False, 'from unittest import TestCase, main\n'), ((677, 697), 'emperor.parse.parse_coords', 'parse_coords', (['coords'], {}), '(coords)\n', (689, 697), False, 'from emperor.parse import parse_coords\n'), ((1010, 1049), 'numpy.testing.assert_almost... |
from alembic import op
import sqlalchemy as sa
import sqlalchemy_utils
"""empty message
Revision ID: <KEY>
Revises: <PASSWORD>
Create Date: 2018-08-06 16:03:36.820890
"""
# revision identifiers, used by Alembic.
revision = '<KEY>'
down_revision = '8efa45d83a3b'
def upgrade():
# ### commands auto generated by ... | [
"sqlalchemy.DateTime",
"alembic.op.drop_constraint",
"alembic.op.drop_column",
"sqlalchemy_utils.types.json.JSONType",
"alembic.op.create_unique_constraint"
] | [((705, 813), 'alembic.op.create_unique_constraint', 'op.create_unique_constraint', (['"""auth_providers_by_provider"""', '"""auth_providers"""', "['provider', 'provider_id']"], {}), "('auth_providers_by_provider', 'auth_providers',\n ['provider', 'provider_id'])\n", (732, 813), False, 'from alembic import op\n'), (... |
from pathlib import Path
from tkinter import Frame, Canvas, Entry, Text, Button, PhotoImage, messagebox
import controller as db_controller
OUTPUT_PATH = Path(__file__).parent
ASSETS_PATH = OUTPUT_PATH / Path("./assets")
def relative_to_assets(path: str) -> Path:
return ASSETS_PATH / Path(path)
def add_reserva... | [
"tkinter.messagebox.showerror",
"tkinter.Frame.__init__",
"tkinter.Entry",
"pathlib.Path",
"tkinter.Button",
"tkinter.Canvas",
"tkinter.messagebox.showinfo"
] | [((155, 169), 'pathlib.Path', 'Path', (['__file__'], {}), '(__file__)\n', (159, 169), False, 'from pathlib import Path\n'), ((205, 221), 'pathlib.Path', 'Path', (['"""./assets"""'], {}), "('./assets')\n", (209, 221), False, 'from pathlib import Path\n'), ((292, 302), 'pathlib.Path', 'Path', (['path'], {}), '(path)\n', ... |
import cv2
import numpy as np
import imutils
from collections import defaultdict
# mouse callback function
def define_points(target_img):
corners = []
refPt = []
def draw_circle(event,x,y,flags,param):
global refPt
if event == cv2.EVENT_LBUTTONDBLCLK:
cv2.circle(param,(x,y),5,(... | [
"numpy.sqrt",
"cv2.imshow",
"numpy.array",
"cv2.warpPerspective",
"cv2.HoughLines",
"cv2.destroyAllWindows",
"numpy.sin",
"cv2.setMouseCallback",
"cv2.line",
"numpy.diff",
"numpy.argmin",
"cv2.waitKey",
"numpy.round",
"numpy.ones",
"cv2.getPerspectiveTransform",
"cv2.kmeans",
"numpy.... | [((429, 453), 'cv2.namedWindow', 'cv2.namedWindow', (['"""image"""'], {}), "('image')\n", (444, 453), False, 'import cv2\n'), ((458, 512), 'cv2.setMouseCallback', 'cv2.setMouseCallback', (['"""image"""', 'draw_circle', 'target_img'], {}), "('image', draw_circle, target_img)\n", (478, 512), False, 'import cv2\n'), ((674... |
import argparse
import configparser
import os
import pathlib
import platform
import random
import subprocess as sp
import sys
import typing
import warnings
if platform.system() == 'Windows':
import winsound
try:
from IPython.core import magic
IPYTHON_INSTALLED = True
except ImportError:
IPYTHON_INSTAL... | [
"configparser.ConfigParser",
"argparse.ArgumentParser",
"pathlib.Path",
"subprocess.Popen",
"pathlib.Path.home",
"subprocess.run",
"platform.system",
"warnings.warn",
"sys.__excepthook__"
] | [((160, 177), 'platform.system', 'platform.system', ([], {}), '()\n', (175, 177), False, 'import platform\n'), ((503, 522), 'pathlib.Path.home', 'pathlib.Path.home', ([], {}), '()\n', (520, 522), False, 'import pathlib\n'), ((1595, 1612), 'platform.system', 'platform.system', ([], {}), '()\n', (1610, 1612), False, 'imp... |
from pymongo.read_concern import ReadConcern
from pymongo.read_preferences import ReadPreference
from pymongo.write_concern import WriteConcern
from pymongo.errors import InvalidOperation
from iu_mongo.errors import TransactionError
__all__ = ['Session', 'TransactionContext']
DEFAULT_READ_CONCERN = ReadConcern('major... | [
"pymongo.read_concern.ReadConcern",
"pymongo.write_concern.WriteConcern"
] | [((302, 325), 'pymongo.read_concern.ReadConcern', 'ReadConcern', (['"""majority"""'], {}), "('majority')\n", (313, 325), False, 'from pymongo.read_concern import ReadConcern\n'), ((350, 391), 'pymongo.write_concern.WriteConcern', 'WriteConcern', ([], {'w': '"""majority"""', 'wtimeout': '(5000)'}), "(w='majority', wtime... |
# -*- coding: utf-8 -*-
from flask import Flask, jsonify, request, Markup, abort, make_response
# import peewee
# import json
api = Flask(__name__)
@api.route('/')
def index():
html = '''
<form action="/iperf3test">
<p><label>iperf3 test: </label></p>
Test Name: <input type="text" name="TestNa... | [
"flask.Markup",
"flask.request.args.get",
"flask.jsonify",
"flask.Flask"
] | [((133, 148), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (138, 148), False, 'from flask import Flask, jsonify, request, Markup, abort, make_response\n'), ((1115, 1127), 'flask.Markup', 'Markup', (['html'], {}), '(html)\n', (1121, 1127), False, 'from flask import Flask, jsonify, request, Markup, abort, ... |
import math
import numpy as np
from scipy.spatial.distance import cdist
from torch.utils.data import Dataset
import torch
import os
import pickle
from problems.tsptw.state_tsptw import StateTSPTWInt
from utils.functions import accurate_cdist
class TSPTW(object):
NAME = 'tsptw' # TSP with Time Windows
@stati... | [
"utils.functions.accurate_cdist",
"scipy.spatial.distance.cdist",
"torch.max",
"pickle.load",
"os.path.splitext",
"torch.unbind",
"torch.tensor",
"torch.arange",
"problems.tsptw.state_tsptw.StateTSPTWInt.initialize",
"torch.cat"
] | [((1578, 1612), 'torch.unbind', 'torch.unbind', (["dataset['timew']", '(-1)'], {}), "(dataset['timew'], -1)\n", (1590, 1612), False, 'import torch\n'), ((2256, 2297), 'problems.tsptw.state_tsptw.StateTSPTWInt.initialize', 'StateTSPTWInt.initialize', (['*args'], {}), '(*args, **kwargs)\n', (2280, 2297), False, 'from pro... |
"""Defines various classes and definitions that provide assistance for
unit testing Actors in an ActorSystem."""
import unittest
import pytest
import logging
import time
from thespian.actors import ActorSystem
def simpleActorTestLogging():
"""This function returns a logging dictionary that can be passed as
... | [
"thespian.system.timing.timePeriodSeconds",
"socket.socket",
"thespian.actors.ActorSystem",
"time.sleep",
"pytest.fixture",
"pytest.skip",
"random.randint"
] | [((5370, 5555), 'pytest.fixture', 'pytest.fixture', ([], {'params': "['simpleSystemBase', 'multiprocQueueBase', 'multiprocUDPBase',\n 'multiprocTCPBase', 'multiprocTCPBase-AdminRouting',\n 'multiprocTCPBase-AdminRoutingTXOnly']"}), "(params=['simpleSystemBase', 'multiprocQueueBase',\n 'multiprocUDPBase', 'mult... |
import logging as log
import numpy as np
import h5py
import humblerl as hrl
from humblerl import Callback, Interpreter
import torch
import torch.nn as nn
import torch.optim as optim
from torch.distributions import Normal
from torch.utils.data import Dataset
from common_utils import get_model_path_if_exists
from third... | [
"numpy.random.rand",
"torch.from_numpy",
"torch.exp",
"torch.softmax",
"numpy.array",
"torch.cuda.is_available",
"torch.sum",
"numpy.take_along_axis",
"logging.info",
"torch.nn.LSTM",
"torch.mean",
"torch.eye",
"torch.distributions.Normal",
"logging.warning",
"h5py.File",
"numpy.squeez... | [((11699, 11724), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {}), '()\n', (11722, 11724), False, 'import torch\n'), ((12676, 12782), 'common_utils.get_model_path_if_exists', 'get_model_path_if_exists', ([], {'path': 'model_path', 'default_path': "rnn_params['ckpt_path']", 'model_name': '"""MDN-RNN"""'})... |
# coding: utf-8
__author__ = "<NAME>"
from django.test import TestCase
from model_mommy import mommy
from core.models import Programs
class ProgramsModelTestCase(TestCase):
"""Class Testing Model Pogramas """
def setUp(self):
"""
Initial Test Settings
"""
self.program = ... | [
"core.models.Programs.objects.all",
"model_mommy.mommy.make",
"core.models.Programs.objects.count"
] | [((320, 340), 'model_mommy.mommy.make', 'mommy.make', (['Programs'], {}), '(Programs)\n', (330, 340), False, 'from model_mommy import mommy\n'), ((935, 959), 'core.models.Programs.objects.count', 'Programs.objects.count', ([], {}), '()\n', (957, 959), False, 'from core.models import Programs\n'), ((990, 1012), 'core.mo... |
import os
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
from matplotlib.lines import Line2D
from matplotlib import rcParams
params = {
# 'text.latex.preamble': ['\\usepackage{gensymb}'],
# 'text.usetex': True,
'font.family': 'Helvetica',
'lines.solid_capstyle'... | [
"seaborn.set_palette",
"matplotlib.rcParams.update",
"pandas.read_csv",
"matplotlib.pyplot.gcf",
"seaborn.set_context",
"numpy.argmax",
"numpy.max",
"seaborn.set_style",
"os.path.realpath",
"seaborn.boxplot",
"seaborn.scatterplot",
"numpy.min",
"pandas.DataFrame",
"matplotlib.pyplot.subplo... | [((365, 388), 'matplotlib.rcParams.update', 'rcParams.update', (['params'], {}), '(params)\n', (380, 388), False, 'from matplotlib import rcParams\n'), ((390, 457), 'seaborn.set_context', 'sns.set_context', (['"""paper"""'], {'font_scale': '(1.6)', 'rc': "{'lines.linewidth': 2}"}), "('paper', font_scale=1.6, rc={'lines... |
import numpy as np
def split_ids(args, ids, folds=10):
if args.dataset == 'COLORS-3':
assert folds == 1, 'this dataset has train, val and test splits'
train_ids = [np.arange(500)]
val_ids = [np.arange(500, 3000)]
test_ids = [np.arange(3000, 10500)]
elif args.dataset == 'TRIANGL... | [
"numpy.concatenate",
"numpy.array",
"numpy.arange"
] | [((186, 200), 'numpy.arange', 'np.arange', (['(500)'], {}), '(500)\n', (195, 200), True, 'import numpy as np\n'), ((221, 241), 'numpy.arange', 'np.arange', (['(500)', '(3000)'], {}), '(500, 3000)\n', (230, 241), True, 'import numpy as np\n'), ((263, 285), 'numpy.arange', 'np.arange', (['(3000)', '(10500)'], {}), '(3000... |
#!/usr/bin/env python3
import os
from aws_cdk import core
from awscdk.app_stack import ApplicationStack
# naming conventions, also used for ACM certs, DNS Records, resource naming
# Dynamically generated resource names created in CDK are used in GitLab CI
# such as cluster name, task definitions, etc.
environment_na... | [
"awscdk.app_stack.ApplicationStack",
"aws_cdk.core.Tag",
"os.environ.get",
"aws_cdk.core.App"
] | [((386, 429), 'os.environ.get', 'os.environ.get', (['"""DOMAIN_NAME"""', '"""mysite.com"""'], {}), "('DOMAIN_NAME', 'mysite.com')\n", (400, 429), False, 'import os\n'), ((747, 787), 'os.environ.get', 'os.environ.get', (['"""APP_NAME"""', '"""mysite-com"""'], {}), "('APP_NAME', 'mysite-com')\n", (761, 787), False, 'impo... |
import json
import logging
import stripe
from django.http import HttpResponse
from django.views.decorators.csrf import csrf_exempt
from django.views.decorators.http import require_POST
from pretix.base.models import Event, Order
from pretix.plugins.stripe.payment import Stripe
logger = logging.getLogger('pretix.plug... | [
"logging.getLogger",
"pretix.base.models.Order.objects.current.get",
"django.http.HttpResponse",
"stripe.Charge.retrieve",
"pretix.base.models.Event.objects.current.get",
"pretix.plugins.stripe.payment.Stripe"
] | [((290, 332), 'logging.getLogger', 'logging.getLogger', (['"""pretix.plugins.stripe"""'], {}), "('pretix.plugins.stripe')\n", (307, 332), False, 'import logging\n'), ((1232, 1245), 'pretix.plugins.stripe.payment.Stripe', 'Stripe', (['event'], {}), '(event)\n', (1238, 1245), False, 'from pretix.plugins.stripe.payment im... |
import re
from sloth.grammar import LexicalGrammar
from sloth.token import Token
class LexerError(Exception):
def __init__(self, pos):
self.pos = pos
self.description = 'LexerError at Line {}, Column {}'.format(
self.pos[0], self.pos[1]
)
def __str__(self):
return... | [
"sloth.token.Token"
] | [((2137, 2172), 'sloth.token.Token', 'Token', (['token_name', 'lexeme', 'position'], {}), '(token_name, lexeme, position)\n', (2142, 2172), False, 'from sloth.token import Token\n')] |
from com.huawei.iotplatform.client.dto.DeviceCommandCancelTaskRespV4 import DeviceCommandCancelTaskRespV4
from com.huawei.iotplatform.client.dto.Pagination import Pagination
class QueryDeviceCmdCancelTaskOutDTO(object):
pagination = Pagination()
data = DeviceCommandCancelTaskRespV4()
def __init__(self):
... | [
"com.huawei.iotplatform.client.dto.DeviceCommandCancelTaskRespV4.DeviceCommandCancelTaskRespV4",
"com.huawei.iotplatform.client.dto.Pagination.Pagination"
] | [((239, 251), 'com.huawei.iotplatform.client.dto.Pagination.Pagination', 'Pagination', ([], {}), '()\n', (249, 251), False, 'from com.huawei.iotplatform.client.dto.Pagination import Pagination\n'), ((263, 294), 'com.huawei.iotplatform.client.dto.DeviceCommandCancelTaskRespV4.DeviceCommandCancelTaskRespV4', 'DeviceComma... |
import os
import subprocess
class TestTasks:
""" Test that the tasks work with invoke. """
CMD_KWARGS = dict(
capture_output=True,
encoding="utf-8",
shell=True,
env=os.environ.copy(),
)
def test_unapproved_licenses(self):
""" Should emit table of unapproved lic... | [
"subprocess.run",
"os.environ.copy"
] | [((347, 434), 'subprocess.run', 'subprocess.run', (['"""poetry run invoke license.unapproved-licenses"""'], {}), "('poetry run invoke license.unapproved-licenses', **self.\n CMD_KWARGS)\n", (361, 434), False, 'import subprocess\n'), ((739, 832), 'subprocess.run', 'subprocess.run', (['"""poetry run invoke license.wri... |
# Space: O(n)
# Time: O(n)
import collections
class Solution():
def findWords(self, board, words):
column = len(board)
if column == 0: return []
row = len(board[0])
if row == 0: return []
target_word = set()
res = set()
# build a trie, this will be used... | [
"collections.defaultdict"
] | [((350, 378), 'collections.defaultdict', 'collections.defaultdict', (['set'], {}), '(set)\n', (373, 378), False, 'import collections\n')] |
# coding: utf-8
# - We are creating a very simple machine learning model.<br>
# - Using dataset: tic-tac-toe.data.txt with user-defined columns.<br>
# - We are treating this problem as a supervised learning problem.<br>
# In[74]:
# This the rough sketch of the processing that happened in my brain while creating the... | [
"sklearn.metrics.confusion_matrix",
"pandas.read_csv",
"sklearn.model_selection.train_test_split",
"numpy.where",
"sklearn.metrics.classification_report",
"sklearn.tree.DecisionTreeClassifier",
"sklearn.neighbors.KNeighborsClassifier",
"sklearn.ensemble.RandomForestClassifier",
"sklearn.preprocessin... | [((662, 709), 'pandas.read_csv', 'pd.read_csv', (['"""../tic-tac-toe.data.txt"""'], {'sep': '""","""'}), "('../tic-tac-toe.data.txt', sep=',')\n", (673, 709), True, 'import pandas as pd\n'), ((724, 771), 'pandas.read_csv', 'pd.read_csv', (['"""../tic-tac-toe.data.txt"""'], {'sep': '""","""'}), "('../tic-tac-toe.data.tx... |
import aiohttp
from matrix_traversal.utils import (
traverse_matrix_counterclockwise,
get_formatted_matrix,
check_url)
from typing import List
from aiohttp import ClientError
from asyncio.exceptions import TimeoutError
async def send_request(url: str) -> List[List[int]]:
"""
This function sends a ... | [
"matrix_traversal.utils.check_url",
"aiohttp.ClientSession",
"matrix_traversal.utils.get_formatted_matrix",
"matrix_traversal.utils.traverse_matrix_counterclockwise"
] | [((1339, 1353), 'matrix_traversal.utils.check_url', 'check_url', (['url'], {}), '(url)\n', (1348, 1353), False, 'from matrix_traversal.utils import traverse_matrix_counterclockwise, get_formatted_matrix, check_url\n'), ((475, 498), 'aiohttp.ClientSession', 'aiohttp.ClientSession', ([], {}), '()\n', (496, 498), False, '... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import os
import sys
import PyPDF2
length = len(sys.argv)
if length >= 2:
PASSWORD = sys.argv[1]
else:
print('usage: cmd password [path]')
sys.exit(1)
if length == 3:
PATH = sys.argv[2]
else:
PATH = os.curdir
for folder_name, _, filenames in os.walk... | [
"os.rename",
"sys.exit",
"PyPDF2.PdfFileWriter",
"PyPDF2.PdfFileReader",
"os.walk"
] | [((313, 326), 'os.walk', 'os.walk', (['PATH'], {}), '(PATH)\n', (320, 326), False, 'import os\n'), ((200, 211), 'sys.exit', 'sys.exit', (['(1)'], {}), '(1)\n', (208, 211), False, 'import sys\n'), ((557, 587), 'PyPDF2.PdfFileReader', 'PyPDF2.PdfFileReader', (['pdf_file'], {}), '(pdf_file)\n', (577, 587), False, 'import ... |
import turtle as t
zel = float(input("What is your Zel: "))
for i in range(4):
t.fd(zel)
t.lt(90)
t.done()
| [
"turtle.done",
"turtle.lt",
"turtle.fd"
] | [((103, 111), 'turtle.done', 't.done', ([], {}), '()\n', (109, 111), True, 'import turtle as t\n'), ((82, 91), 'turtle.fd', 't.fd', (['zel'], {}), '(zel)\n', (86, 91), True, 'import turtle as t\n'), ((94, 102), 'turtle.lt', 't.lt', (['(90)'], {}), '(90)\n', (98, 102), True, 'import turtle as t\n')] |
"""
Ashley URLs (that includes django machina urls)
"""
from django.urls import include, path, re_path
from machina import urls as machina_urls
from ashley.api import urls as api_urls
from ashley.views import ChangeUsernameView, ForumLTIView, ManageModeratorsView
API_PREFIX = "v1.0"
urlpatterns = [
path("lti/fo... | [
"ashley.views.ManageModeratorsView.as_view",
"django.urls.include",
"ashley.views.ForumLTIView.as_view",
"ashley.views.ChangeUsernameView.as_view"
] | [((338, 360), 'ashley.views.ForumLTIView.as_view', 'ForumLTIView.as_view', ([], {}), '()\n', (358, 360), False, 'from ashley.views import ChangeUsernameView, ForumLTIView, ManageModeratorsView\n'), ((432, 460), 'ashley.views.ChangeUsernameView.as_view', 'ChangeUsernameView.as_view', ([], {}), '()\n', (458, 460), False,... |
#!/usr/bin/env python
import certifire
import certifire.plugins.acme
import certifire.plugins.dns_providers
from codecs import open
from setuptools import setup, find_packages
import sys
try:
# for pip >= 10
from pip._internal.req import parse_requirements
except ImportError:
# for pip <= 9.0.3
print(... | [
"certifire.get_author",
"certifire.get_version",
"certifire.get_author_email",
"setuptools.find_packages",
"pip._internal.req.parse_requirements",
"sys.exit",
"codecs.open"
] | [((440, 462), 'codecs.open', 'open', (['"""README.md"""', '"""r"""'], {}), "('README.md', 'r')\n", (444, 462), False, 'from codecs import open\n'), ((422, 433), 'sys.exit', 'sys.exit', (['(1)'], {}), '(1)\n', (430, 433), False, 'import sys\n'), ((616, 677), 'pip._internal.req.parse_requirements', 'parse_requirements', ... |
"""
:mod: `kanka.utils` - Helper functions
"""
from datetime import datetime
from requests_toolbelt.sessions import BaseUrlSession
from dacite import from_dict, Config
from .exceptions import KankaAPIError
API_BASE_ENDPOINT = 'https://kanka.io/api/1.0/'
class KankaSession(BaseUrlSession):
""" Store session data.... | [
"datetime.datetime.strptime",
"dacite.Config"
] | [((2126, 2167), 'datetime.datetime.strptime', 'datetime.strptime', (['t', '"""%Y-%m-%dT%H:%M:%S"""'], {}), "(t, '%Y-%m-%dT%H:%M:%S')\n", (2143, 2167), False, 'from datetime import datetime\n'), ((2625, 2667), 'dacite.Config', 'Config', ([], {'type_hooks': '{datetime: to_datetime}'}), '(type_hooks={datetime: to_datetime... |
import json
import os
from pymatgen.io.vasp import Poscar
def from_path(path):
# TODO: should maybe support .tar.gz or .tar.xz
return StructureDir.from_dir(path)
class StructureDir:
def __init__(self, *, layers, masses, layer_sc_matrices, structure):
self.layers = layers
self.masses = mass... | [
"json.load",
"os.path.join"
] | [((609, 621), 'json.load', 'json.load', (['f'], {}), '(f)\n', (618, 621), False, 'import json\n'), ((493, 521), 'os.path.join', 'os.path.join', (['path', '"""POSCAR"""'], {}), "(path, 'POSCAR')\n", (505, 521), False, 'import os\n'), ((551, 582), 'os.path.join', 'os.path.join', (['path', '"""meta.json"""'], {}), "(path,... |
#!/usr/bin/env python
# coding: utf-8
import pandas as pd
import os
from functools import reduce
import sys
directory_with_mapping_reports = sys.argv[1]
mapping_summary = sys.argv[2]
############################################################
# Reads each file. Add sample name in the column with values
###########... | [
"pandas.merge",
"os.listdir"
] | [((431, 473), 'os.listdir', 'os.listdir', (['directory_with_mapping_reports'], {}), '(directory_with_mapping_reports)\n', (441, 473), False, 'import os\n'), ((776, 828), 'pandas.merge', 'pd.merge', (['left', 'right'], {'on': "['attribute']", 'how': '"""outer"""'}), "(left, right, on=['attribute'], how='outer')\n", (784... |
# Copyright 2019-2021 ETH Zurich and the DaCe authors. All rights reserved.
import dace
import dace.library
from dace.transformation import transformation as xf
import pytest
@dace.library.node
class MyLibNode(dace.nodes.LibraryNode):
implementations = {}
default_implementation = 'pure'
def __init__(self... | [
"dace.library.register_expansion",
"dace.SDFG",
"dace.nodes.Tasklet",
"pytest.raises"
] | [((441, 461), 'dace.SDFG', 'dace.SDFG', (['"""libtest"""'], {}), "('libtest')\n", (450, 461), False, 'import dace\n'), ((633, 683), 'dace.library.register_expansion', 'dace.library.register_expansion', (['MyLibNode', '"""pure"""'], {}), "(MyLibNode, 'pure')\n", (664, 683), False, 'import dace\n'), ((587, 610), 'pytest.... |
"""
Functions to manipulate data from PostgreSQL database includes a
parallelise dataframe that runs a function on a pandas data frame
in parallel, as well as a loop_chunks function. This reads a chunk
from the database performs an operation and uploads to a new
table in the database.
"""
import numpy as np
import pa... | [
"pandas.read_sql_query",
"utils.db_connect.alchemy_input_output_close",
"utils.db_connect.alchemy_input_output_open",
"multiprocessing.cpu_count",
"numpy.array_split",
"multiprocessing.Pool",
"time.time"
] | [((901, 930), 'numpy.array_split', 'np.array_split', (['df', 'num_cores'], {}), '(df, num_cores)\n', (915, 930), True, 'import numpy as np\n'), ((942, 957), 'multiprocessing.Pool', 'Pool', (['num_cores'], {}), '(num_cores)\n', (946, 957), False, 'from multiprocessing import Pool, cpu_count\n'), ((1764, 1802), 'utils.db... |
import pygame
import pygame.camera
#from pygame.locals import *
pygame.init()
pygame.camera.init()
screen = pygame.display.set_mode((640, 480), 0)
def main():
camlist = pygame.camera.list_cameras()
if camlist:
print('camera {} is detected'.format(camlist[0]))
cam = pygame.camera.Camera(camlis... | [
"pygame.camera.init",
"pygame.init",
"pygame.display.set_mode",
"pygame.camera.Camera",
"pygame.display.update",
"pygame.camera.list_cameras"
] | [((65, 78), 'pygame.init', 'pygame.init', ([], {}), '()\n', (76, 78), False, 'import pygame\n'), ((79, 99), 'pygame.camera.init', 'pygame.camera.init', ([], {}), '()\n', (97, 99), False, 'import pygame\n'), ((109, 147), 'pygame.display.set_mode', 'pygame.display.set_mode', (['(640, 480)', '(0)'], {}), '((640, 480), 0)\... |
import csv
import codecs
import StringIO
import cStringIO
import sys
import time
import argparse
from pyspark import SparkContext
parser = argparse.ArgumentParser(description='Count columns and lines existing in file')
parser.add_argument('-df','--DATAFILE', dest="DATAFILE", type=str,
help='the pat... | [
"csv.field_size_limit",
"StringIO.StringIO",
"cStringIO.StringIO",
"argparse.ArgumentParser",
"csv.writer",
"codecs.getincrementalencoder",
"pyspark.SparkContext"
] | [((141, 220), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Count columns and lines existing in file"""'}), "(description='Count columns and lines existing in file')\n", (164, 220), False, 'import argparse\n'), ((2717, 2731), 'pyspark.SparkContext', 'SparkContext', ([], {}), '()\n', (27... |
from extras.plugins import PluginConfig
from django.utils.translation import gettext_lazy as _
class NetBoxSecretStore(PluginConfig):
name = 'netbox_secretstore'
verbose_name = _('Netbox Secret Store')
description = _('A Secret Storage for NetBox')
version = '1.0.8'
author = 'NetBox Maintainers'
... | [
"django.utils.translation.gettext_lazy"
] | [((186, 210), 'django.utils.translation.gettext_lazy', '_', (['"""Netbox Secret Store"""'], {}), "('Netbox Secret Store')\n", (187, 210), True, 'from django.utils.translation import gettext_lazy as _\n'), ((229, 261), 'django.utils.translation.gettext_lazy', '_', (['"""A Secret Storage for NetBox"""'], {}), "('A Secret... |
import os
import numpy as np
import urllib
from absl import flags
import tensorflow as tf
import tensorflow_probability as tfp
tfb = tfp.bijectors
tfd = tfp.distributions
flags.DEFINE_float(
"learning_rate", default=0.001, help="Initial learning rate.")
flags.DEFINE_integer(
"epochs", default=100, help="Numb... | [
"tensorflow.shape",
"tensorflow.get_variable",
"tensorflow.contrib.learn.datasets.load_dataset",
"tensorflow.estimator.inputs.numpy_input_fn",
"tensorflow.metrics.mean",
"tensorflow.nn.softplus",
"tensorflow.gfile.MakeDirs",
"tensorflow.reduce_mean",
"absl.flags.DEFINE_float",
"tensorflow.app.run"... | [((174, 260), 'absl.flags.DEFINE_float', 'flags.DEFINE_float', (['"""learning_rate"""'], {'default': '(0.001)', 'help': '"""Initial learning rate."""'}), "('learning_rate', default=0.001, help=\n 'Initial learning rate.')\n", (192, 260), False, 'from absl import flags\n'), ((261, 350), 'absl.flags.DEFINE_integer', '... |
from sqlalchemy import Column, Integer, String, Float, ForeignKey
from sqlalchemy.engine.create import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
CONNECTION_STRING = "sqlite+pysqlite:///data/db.sqlite"
engine = create_engine(CONNECTION_STRING)
Sess... | [
"sqlalchemy.orm.sessionmaker",
"sqlalchemy.ForeignKey",
"sqlalchemy.ext.declarative.declarative_base",
"sqlalchemy.Column",
"sqlalchemy.engine.create.create_engine"
] | [((282, 314), 'sqlalchemy.engine.create.create_engine', 'create_engine', (['CONNECTION_STRING'], {}), '(CONNECTION_STRING)\n', (295, 314), False, 'from sqlalchemy.engine.create import create_engine\n'), ((326, 346), 'sqlalchemy.orm.sessionmaker', 'sessionmaker', (['engine'], {}), '(engine)\n', (338, 346), False, 'from ... |
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: MIT-0
from aws_xray_sdk.core import xray_recorder
from aws_xray_sdk.ext.flask.middleware import XRayMiddleware
from aws_xray_sdk.core import patch_all
patch_all()
from flask import Flask
from flask import request
from fla... | [
"flask.request.args.get",
"aws_xray_sdk.ext.flask.middleware.XRayMiddleware",
"flask_cors.CORS",
"aws_xray_sdk.core.patch_all",
"flask.Flask",
"elasticsearch.Elasticsearch",
"json.dumps",
"os.environ.get",
"aws_xray_sdk.core.xray_recorder.configure",
"pprint.pprint"
] | [((249, 260), 'aws_xray_sdk.core.patch_all', 'patch_all', ([], {}), '()\n', (258, 260), False, 'from aws_xray_sdk.core import patch_all\n'), ((528, 578), 'os.environ.get', 'os.environ.get', (['"""ES_SEARCH_DOMAIN_SCHEME"""', '"""https"""'], {}), "('ES_SEARCH_DOMAIN_SCHEME', 'https')\n", (542, 578), False, 'import os, s... |
from django.conf.urls import url
from django.conf.urls import patterns
from django.views.generic import TemplateView
view = TemplateView.as_view(template_name='dummy.html')
urlpatterns = patterns('',
url(r'^nl/foo/', view, name='not-translated'),
)
| [
"django.views.generic.TemplateView.as_view",
"django.conf.urls.url"
] | [((126, 174), 'django.views.generic.TemplateView.as_view', 'TemplateView.as_view', ([], {'template_name': '"""dummy.html"""'}), "(template_name='dummy.html')\n", (146, 174), False, 'from django.views.generic import TemplateView\n'), ((207, 251), 'django.conf.urls.url', 'url', (['"""^nl/foo/"""', 'view'], {'name': '"""n... |
import collections
try:
stringtype = basestring # python 2
except:
stringtype = str # python 3
def coerce_to_list(x):
if isinstance(x, stringtype):
return x.replace(',', ' ').split()
return x or []
def namedtuple(name, args=None, optional=None):
args = coerce_to_list(args)
optiona... | [
"collections.namedtuple"
] | [((357, 402), 'collections.namedtuple', 'collections.namedtuple', (['name', '(args + optional)'], {}), '(name, args + optional)\n', (379, 402), False, 'import collections\n')] |
import fudge
from armstrong.apps.embeds.mixins import TemplatesByEmbedTypeMixin
from .support.models import Parent, Child, TypeModel
from ._utils import TestCase
class TemplateCompareTestMixin(object):
def path_opts(self, obj, use_fallback=False, use_type=False):
return dict(
base=obj.base_la... | [
"fudge.Fake",
"armstrong.apps.embeds.mixins.TemplatesByEmbedTypeMixin"
] | [((1375, 1402), 'armstrong.apps.embeds.mixins.TemplatesByEmbedTypeMixin', 'TemplatesByEmbedTypeMixin', ([], {}), '()\n', (1400, 1402), False, 'from armstrong.apps.embeds.mixins import TemplatesByEmbedTypeMixin\n'), ((1587, 1614), 'armstrong.apps.embeds.mixins.TemplatesByEmbedTypeMixin', 'TemplatesByEmbedTypeMixin', ([]... |
from twitchchatbot.lib.commands.parsing import commands
import json
def addcom(user, args):
# Concatenate a list of strings down to a single, space delimited string.
queueEvent = {}
if len(args) < 2:
queueEvent['msg'] = "Proper usage: !addcom <cmd> <Text to send>"
else:
commandHead = ... | [
"json.dump"
] | [((629, 661), 'json.dump', 'json.dump', (['commands', 'f'], {'indent': '(1)'}), '(commands, f, indent=1)\n', (638, 661), False, 'import json\n')] |
from distutils.core import setup
import py2exe
# if py2exe complains "can't find P", try one of the following workarounds:
#
# a. py2exe doesn't support zipped eggs - http://www.py2exe.org/index.cgi/ExeWithEggs
# You should give the --always-unzip option to easy_install, or you can use setup.py directly
# $ python s... | [
"distutils.core.setup"
] | [((610, 801), 'distutils.core.setup', 'setup', ([], {'console': "['fog-client']", 'zipfile': '"""py2exe-fog-client.zip"""', 'options': "{'py2exe': {'includes': ['pyptlib', 'twisted', 'txsocksx'], 'packages': [\n 'ometa', 'terml', 'zope.interface']}}"}), "(console=['fog-client'], zipfile='py2exe-fog-client.zip', opti... |
import os
import shutil
import argparse
import torch
from torch import nn
from torchvision.utils import save_image, make_grid
import matplotlib.pyplot as plt
import numpy as np
import cv2 as cv
import utils.utils as utils
from utils.constants import *
class GenerationMode(enum.Enum):
SINGLE_IMAGE = 0,
INT... | [
"numpy.sqrt",
"utils.utils.save_and_maybe_display_image",
"numpy.array",
"torch.cuda.is_available",
"numpy.linalg.norm",
"numpy.sin",
"numpy.moveaxis",
"utils.utils.get_available_file_name",
"matplotlib.pyplot.imshow",
"os.path.exists",
"numpy.repeat",
"argparse.ArgumentParser",
"numpy.max",... | [((1093, 1114), 'numpy.min', 'np.min', (['generated_img'], {}), '(generated_img)\n', (1099, 1114), True, 'import numpy as np\n'), ((1136, 1157), 'numpy.max', 'np.max', (['generated_img'], {}), '(generated_img)\n', (1142, 1157), True, 'import numpy as np\n'), ((3254, 3267), 'numpy.sin', 'np.sin', (['omega'], {}), '(omeg... |
from direct.gui.DirectGui import OnscreenText, DirectButton
from panda3d.core import *
from direct.interval.IntervalGlobal import *
from direct.showbase.DirectObject import DirectObject
from toontown.toonbase import ToontownGlobals
class DMenuDisclaimer(DirectObject):
notify = directNotify.newCategory('DisclaimerS... | [
"toontown.toonbase.ToontownGlobals.getMinnieFont",
"direct.gui.DirectGui.DirectButton",
"direct.showbase.DirectObject.DirectObject.__init__"
] | [((365, 392), 'direct.showbase.DirectObject.DirectObject.__init__', 'DirectObject.__init__', (['self'], {}), '(self)\n', (386, 392), False, 'from direct.showbase.DirectObject import DirectObject\n'), ((1220, 1522), 'direct.gui.DirectGui.DirectButton', 'DirectButton', ([], {'parent': 'aspect2d', 'relief': 'None', 'image... |
"""a module solely for finding how add_a_list and add_tuple_list compare.
it's effectively the empirical proof for how LongIntTable.add() chooses
the fastest method with it's get_fastest_method() function."""
from __future__ import print_function
from math import log10
import time
import random
from os import getcwd
... | [
"itertools.cycle",
"time.clock",
"matplotlib.pyplot.ylabel",
"numpy.polyfit",
"random.randrange",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"os.getcwd",
"numpy.array",
"matplotlib.pyplot.figure",
"dicetables.additiveevents.AdditiveEvents",
"numpy.save",
"matplotlib.pyplot.ion",
... | [((5825, 5851), 'math.log10', 'log10', (['events_tuples[0][1]'], {}), '(events_tuples[0][1])\n', (5830, 5851), False, 'from math import log10\n'), ((6730, 6756), 'dicetables.additiveevents.AdditiveEvents', 'AdditiveEvents', (['input_dict'], {}), '(input_dict)\n', (6744, 6756), False, 'from dicetables.additiveevents imp... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# #########################################################################
# Copyright (c) 2020, UChicago Argonne, LLC. All rights reserved. #
# #
# Copyright 2020. UChicago Argonne, LLC. This ... | [
"orangecontrib.wonder.fit.parameters.instrument.polarization_parameters.PolarizationParameters.get_parameters_prefix",
"orangewidget.gui.comboBox",
"orangecontrib.wonder.fit.parameters.instrument.polarization_parameters.PolarizationParameters",
"orangecontrib.wonder.util.gui_utility.gui.lineEdit",
"orangeco... | [((4131, 4143), 'orangewidget.settings.Setting', 'Setting', (['[1]'], {}), '([1])\n', (4138, 4143), False, 'from orangewidget.settings import Setting\n'), ((4174, 4209), 'orangewidget.settings.Setting', 'Setting', (['[LorentzFormula.Shkl_Shkl]'], {}), '([LorentzFormula.Shkl_Shkl])\n', (4181, 4209), False, 'from orangew... |
from appshell.base import View
from appshell.templates import confirmation, message
from flask import request, flash, redirect
from flask_babelex import Babel, Domain
mydomain = Domain('appshell')
_ = mydomain.gettext
lazy_gettext = mydomain.lazy_gettext
class ConfirmationEndpoint(View):
methods = ("GET", "POST"... | [
"flask.redirect",
"flask_babelex.Domain",
"appshell.templates.confirmation",
"flask.flash"
] | [((179, 197), 'flask_babelex.Domain', 'Domain', (['"""appshell"""'], {}), "('appshell')\n", (185, 197), False, 'from flask_babelex import Babel, Domain\n'), ((605, 644), 'appshell.templates.confirmation', 'confirmation', (['self.confirmation_message'], {}), '(self.confirmation_message)\n', (617, 644), False, 'from apps... |
from flask import g, request
from flask_restful import reqparse
from werkzeug import datastructures
from ..exceptions.system_error import SystemError
from ..exceptions.system_exception import SystemException
from ..exceptions.service_error import ServiceError
from ..exceptions.service_exception import ServiceException... | [
"flask_restful.reqparse.RequestParser"
] | [((382, 406), 'flask_restful.reqparse.RequestParser', 'reqparse.RequestParser', ([], {}), '()\n', (404, 406), False, 'from flask_restful import reqparse\n')] |
import bpy
import mathutils
from src.main.Module import Module
from src.utility.BlenderUtility import check_intersection, check_bb_intersection, get_all_mesh_objects
class ObjectPoseSampler(Module):
"""
Samples positions and rotations of selected object inside the sampling volume while performing mesh and
... | [
"bpy.context.view_layer.update",
"src.main.Module.Module.__init__",
"src.utility.BlenderUtility.check_intersection",
"src.utility.BlenderUtility.get_all_mesh_objects",
"src.utility.BlenderUtility.check_bb_intersection"
] | [((1971, 2000), 'src.main.Module.Module.__init__', 'Module.__init__', (['self', 'config'], {}), '(self, config)\n', (1986, 2000), False, 'from src.main.Module import Module\n'), ((6509, 6540), 'bpy.context.view_layer.update', 'bpy.context.view_layer.update', ([], {}), '()\n', (6538, 6540), False, 'import bpy\n'), ((273... |
#!python
"""This module is for messing with input characters."""
import os
import sys
unicurses_path = os.path.dirname(os.path.abspath(__file__)) + '/../libs/unicurses'
sys.path.insert(0, unicurses_path)
import unicurses as curses
def key_info(key):
try:
_ord = ord(key)
except:
_ord = -1
t... | [
"sys.path.insert",
"unicurses.keyname",
"unicurses.unctrl",
"unicurses.raw",
"unicurses.wrapper",
"os.path.abspath"
] | [((169, 203), 'sys.path.insert', 'sys.path.insert', (['(0)', 'unicurses_path'], {}), '(0, unicurses_path)\n', (184, 203), False, 'import sys\n'), ((2287, 2307), 'unicurses.wrapper', 'curses.wrapper', (['main'], {}), '(main)\n', (2301, 2307), True, 'import unicurses as curses\n'), ((1964, 1976), 'unicurses.raw', 'curses... |
from selenium import webdriver
def _options_factory():
"""Produces a selenium.webdriver.ChromeOptions object. Used to force "headless" on invocation. You shouldn't call this function."""
ret = webdriver.ChromeOptions()
ret.add_argument("headless")
return ret
def get_driver(*varargs,args=[]):
"""Creates headless ... | [
"bs4.BeautifulSoup",
"selenium.webdriver.Chrome",
"selenium.webdriver.ChromeOptions"
] | [((196, 221), 'selenium.webdriver.ChromeOptions', 'webdriver.ChromeOptions', ([], {}), '()\n', (219, 221), False, 'from selenium import webdriver\n'), ((577, 613), 'selenium.webdriver.Chrome', 'webdriver.Chrome', ([], {'chrome_options': 'opt'}), '(chrome_options=opt)\n', (593, 613), False, 'from selenium import webdriv... |