code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
from project_utils import dict_to_file, get_word_count
if __name__ == "__main__":
inp_filename = 'sample.txt'
out_filename = 'count.csv'
print("Reading file ", inp_filename)
word_dict = get_word_count(inp_filename)
print("Output from get_word_count is")
print(word_dict)
print("W... | [
"project_utils.dict_to_file",
"project_utils.get_word_count"
] | [((213, 241), 'project_utils.get_word_count', 'get_word_count', (['inp_filename'], {}), '(inp_filename)\n', (227, 241), False, 'from project_utils import dict_to_file, get_word_count\n'), ((362, 399), 'project_utils.dict_to_file', 'dict_to_file', (['word_dict', 'out_filename'], {}), '(word_dict, out_filename)\n', (374,... |
import os
import json
import yaml
import argparse
from pyxform import xls2json
from pyxform.builder import create_survey_element_from_dict
from pprint import pprint
from ..content_variations import build_content
from ..utils.form_to_yaml_string import form_to_yaml_string
YAML_FORMAT = 'yml'
JSON_FORMAT = 'json'
XL... | [
"pyxform.xls2json.workbook_to_json",
"os.path.exists",
"argparse.ArgumentParser",
"json.dumps",
"os.path.splitext",
"pyxform.xls2json.xls_to_dict",
"os.path.abspath",
"pyxform.builder.create_survey_element_from_dict"
] | [((1461, 1485), 'os.path.abspath', 'os.path.abspath', (['path_in'], {}), '(path_in)\n', (1476, 1485), False, 'import os\n'), ((1958, 1994), 'pyxform.xls2json.workbook_to_json', 'xls2json.workbook_to_json', (['flat_json'], {}), '(flat_json)\n', (1983, 1994), False, 'from pyxform import xls2json\n'), ((2008, 2047), 'pyxf... |
import builtins
import datetime
import inspect
import threading
import time
import ws
global _c,_pq,_l_ws,_sc
_c={}
_pq=None
_l_ws={}
_sc=None
_tl=threading.Lock()
def _print_q():
global _pq,_l_ws
lt=time.time()
fs=__import__("storage")
fs.set_silent("log.log")
dt=fs.read("log.log")
lc=dt.count(b"\n")
whil... | [
"threading.current_thread",
"threading.Lock",
"inspect.currentframe",
"time.sleep",
"ws.send",
"datetime.datetime.now",
"time.time",
"threading.Thread",
"builtins.print"
] | [((150, 166), 'threading.Lock', 'threading.Lock', ([], {}), '()\n', (164, 166), False, 'import threading\n'), ((208, 219), 'time.time', 'time.time', ([], {}), '()\n', (217, 219), False, 'import time\n'), ((1542, 1604), 'threading.Thread', 'threading.Thread', ([], {'target': '_ws_keep_alive', 'args': '(a, _l_ws[a][0])'}... |
import utils
from utils import format
import os
import tempfile
import urllib.request
import shutil
import zipfile
spire_dir = r"D:\Games\Slay the Spire Modded"
mod_dir = os.path.join("cache", "mod")
def build():
# STEP: clone FruityMod
if not os.path.exists(mod_dir):
print("Downloading {}".format("Fr... | [
"zipfile.ZipFile",
"utils.cd",
"spire.name_id",
"os.remove",
"os.path.exists",
"numpy.repeat",
"utils.format",
"tempfile.NamedTemporaryFile",
"utils.open_data",
"io.StringIO",
"numpy.round",
"numpy.ceil",
"shutil.copyfileobj",
"skimage.transform.resize",
"engi_mod.keywords.items",
"os.... | [((172, 200), 'os.path.join', 'os.path.join', (['"""cache"""', '"""mod"""'], {}), "('cache', 'mod')\n", (184, 200), False, 'import os\n'), ((800, 842), 'os.path.join', 'os.path.join', (['spire_dir', '"""ModTheSpire.jar"""'], {}), "(spire_dir, 'ModTheSpire.jar')\n", (812, 842), False, 'import os\n'), ((1375, 1421), 'os.... |
import errno
import os
import subprocess
import sys
from distutils import log
from distutils.command.build_ext import build_ext
from distutils.errors import DistutilsError
def exec_process(cmdline, silent=True, catch_enoent=True, input=None, **kwargs):
"""Execute a subprocess and returns the returncode, stdout ... | [
"os.path.exists",
"sys.getdefaultencoding",
"subprocess.Popen",
"os.path.join",
"sys.platform.startswith",
"os.environ.copy",
"distutils.command.build_ext.build_ext.initialize_options",
"sys.stderr.write",
"distutils.errors.DistutilsError",
"distutils.log.info",
"distutils.command.build_ext.buil... | [((1996, 2050), 'distutils.errors.DistutilsError', 'DistutilsError', (['""""make" is not present on this system"""'], {}), '(\'"make" is not present on this system\')\n', (2010, 2050), False, 'from distutils.errors import DistutilsError\n'), ((2103, 2133), 'os.path.join', 'os.path.join', (['"""deps"""', '"""c-ares"""']... |
#!/usr/bin/env python3
import jwt
import requests
import base64
import json
import boto3
import time
import functools
import os
from mod_python import apache
region = json.loads(requests.get('http://169.254.169.254/latest/dynamic/instance-identity/document').text)['region']
ssm_parameter_name_env_var = 'SYNAPSE_TOKE... | [
"jwt.decode",
"json.loads",
"boto3.client",
"os.environ.get",
"base64.b64decode",
"requests.get",
"boto3.resource",
"functools.lru_cache",
"time.time"
] | [((1535, 1565), 'functools.lru_cache', 'functools.lru_cache', ([], {'maxsize': '(1)'}), '(maxsize=1)\n', (1554, 1565), False, 'import functools\n'), ((2916, 2937), 'functools.lru_cache', 'functools.lru_cache', ([], {}), '()\n', (2935, 2937), False, 'import functools\n'), ((1015, 1044), 'boto3.resource', 'boto3.resource... |
from flask import Flask, request, jsonify
from flask_restful import Resource, Api
from TeiParser import Family
from dataManager import parentManager
import os
# path to "_data/N" folder
path_N = os.path.join("_data", "N")
# create the parent manager
pm_N = parentManager(path_N)
# create the Flask application
app = Fl... | [
"flask_restful.Api",
"dataManager.parentManager",
"os.path.join",
"flask.Flask"
] | [((196, 222), 'os.path.join', 'os.path.join', (['"""_data"""', '"""N"""'], {}), "('_data', 'N')\n", (208, 222), False, 'import os\n'), ((258, 279), 'dataManager.parentManager', 'parentManager', (['path_N'], {}), '(path_N)\n', (271, 279), False, 'from dataManager import parentManager\n'), ((318, 333), 'flask.Flask', 'Fl... |
# this resizes __1.jpt to x it's original size & it turns it grayscale
import cv
import numpy
import bSpline
if __name__ == "__main__": # this is not a module
scale = 10
# load image
#cv_img = cv.LoadImage("__1.jpg", cv.CV_LOAD_IMAGE_GRAYSCALE) # CV_LOAD_IMAGE_GRAYSCALE
cv_img = cv.LoadImage("__1.jpg", cv.C... | [
"cv.GetSize",
"bSpline.cubic_setBeta",
"cv.SaveImage",
"numpy.zeros",
"bSpline.cubic_getBeta",
"cv.LoadImage"
] | [((292, 343), 'cv.LoadImage', 'cv.LoadImage', (['"""__1.jpg"""', 'cv.CV_LOAD_IMAGE_UNCHANGED'], {}), "('__1.jpg', cv.CV_LOAD_IMAGE_UNCHANGED)\n", (304, 343), False, 'import cv\n'), ((480, 541), 'numpy.zeros', 'numpy.zeros', (['(cv_img_height * scale, cv_img_width * scale, 2)'], {}), '((cv_img_height * scale, cv_img_wid... |
# -*- coding: utf-8 -*-
# Define here the models for your scraped items
from scrapy import Item, Field
class RawResponseItem(Item):
appid = Field()
crawlid = Field()
url = Field()
response_url = Field()
status_code = Field()
status_msg = Field()
headers = Field()
body = Field()
li... | [
"scrapy.Field"
] | [((147, 154), 'scrapy.Field', 'Field', ([], {}), '()\n', (152, 154), False, 'from scrapy import Item, Field\n'), ((169, 176), 'scrapy.Field', 'Field', ([], {}), '()\n', (174, 176), False, 'from scrapy import Item, Field\n'), ((187, 194), 'scrapy.Field', 'Field', ([], {}), '()\n', (192, 194), False, 'from scrapy import ... |
""" Implement alike logic as is done on www.cdecl.org
Try for example:
$ cdelc.py 'char **a;'
"""
import argparse
import io
from ppci.api import get_current_arch
from ppci.lang.c import CLexer, CParser, COptions, CContext, CSemantics
from ppci.lang.c.nodes import types, declarations
from ppci.lang.c.preprocessor im... | [
"ppci.api.get_current_arch",
"argparse.ArgumentParser",
"ppci.lang.c.CSemantics",
"ppci.lang.c.CContext",
"ppci.lang.c.COptions",
"ppci.lang.c.preprocessor.prepare_for_parsing",
"ppci.lang.c.CParser",
"io.StringIO"
] | [((355, 458), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '__doc__', 'formatter_class': 'argparse.RawDescriptionHelpFormatter'}), '(description=__doc__, formatter_class=argparse.\n RawDescriptionHelpFormatter)\n', (378, 458), False, 'import argparse\n'), ((584, 602), 'ppci.api.get_curr... |
# -*- coding: utf-8 -*-
import logging
import threading
import storj.exception as sjexc
from PyQt4 import QtCore, QtGui
from .qt_interfaces.dashboard_ui import Ui_MainMenu
from .bucket_edition import BucketEditingUI
from .client_config import ClientConfigurationUI
from .engine import StorjEngine
from .file_download... | [
"logging.getLogger",
"PyQt4.QtGui.QMovie",
"PyQt4.QtGui.QLabel.__init__",
"PyQt4.QtGui.QPixmap",
"PyQt4.QtCore.SIGNAL",
"PyQt4.QtGui.QWidget.__init__",
"threading.Thread",
"PyQt4.QtGui.QMessageBox.about"
] | [((1007, 1048), 'logging.getLogger', 'logging.getLogger', (["('%s.MainUI' % __name__)"], {}), "('%s.MainUI' % __name__)\n", (1024, 1048), False, 'import logging\n'), ((809, 844), 'PyQt4.QtGui.QLabel.__init__', 'QtGui.QLabel.__init__', (['self', 'parent'], {}), '(self, parent)\n', (830, 844), False, 'from PyQt4 import Q... |
from desaf109 import moeda
p = float(input('Digite um preço: R$'))
print('A metade de {} é {}'.format(moeda.moeda(p), moeda.metade(p, True)))
print('O dobro de {} é {}'.format(moeda.moeda(p), moeda.dobro(p, True)))
print('Se adcionarmos 10% fica {}'.format(moeda.aumentar(p, 10, True)))
print('Se tirarmos 13% fica {}'.... | [
"desaf109.moeda.metade",
"desaf109.moeda.dobro",
"desaf109.moeda.moeda",
"desaf109.moeda.aumentar",
"desaf109.moeda.diminuir"
] | [((103, 117), 'desaf109.moeda.moeda', 'moeda.moeda', (['p'], {}), '(p)\n', (114, 117), False, 'from desaf109 import moeda\n'), ((119, 140), 'desaf109.moeda.metade', 'moeda.metade', (['p', '(True)'], {}), '(p, True)\n', (131, 140), False, 'from desaf109 import moeda\n'), ((177, 191), 'desaf109.moeda.moeda', 'moeda.moeda... |
"""
Copyright (C) Cortic Technology Corp. - All Rights Reserved
Written by <NAME> <<EMAIL>>, 2021
"""
# need to advertise different processor type, eg CPU, GPU, TPU
import traceback
import logging
from curt.base_service import BaseService
class VisionProcessorService(BaseService):
def __init__(self):
... | [
"traceback.format_exc"
] | [((1113, 1135), 'traceback.format_exc', 'traceback.format_exc', ([], {}), '()\n', (1133, 1135), False, 'import traceback\n')] |
import lamp.modules
import torch
import numpy as np
from lamp.utils import get_activation_function
class FeedforwardNeuralNetwork(lamp.modules.BaseModule):
def __init__(self, dim_in, dim_out, architecture, dropout, outf=None, dtype = None, device = None):
super(FeedforwardNeuralNetwork, self).__init__()... | [
"torch.nn.ReLU",
"torch.nn.Dropout",
"torch.nn.Sequential",
"lamp.utils.get_activation_function",
"numpy.linspace",
"torch.nn.Linear"
] | [((404, 425), 'torch.nn.Sequential', 'torch.nn.Sequential', ([], {}), '()\n', (423, 425), False, 'import torch\n'), ((528, 581), 'torch.nn.Linear', 'torch.nn.Linear', (['architecture[n]', 'architecture[n + 1]'], {}), '(architecture[n], architecture[n + 1])\n', (543, 581), False, 'import torch\n'), ((682, 705), 'torch.n... |
import numpy as np
import math
from scipy.sparse import csr_matrix, diags
from scipy import linalg
import time
try:
from numba import jit, njit
numbaOn = True
except ModuleNotFoundError:
numbaOn = False
if numbaOn:
@njit(["void(float64[:], f8, float64[:], float64[:], f8, f8)"])
def velocityImplNumba(u, t, ... | [
"math.pow",
"numba.njit",
"numpy.square",
"numpy.exp",
"numpy.array",
"numpy.zeros",
"scipy.sparse.diags",
"numpy.zeros_like"
] | [((227, 289), 'numba.njit', 'njit', (["['void(float64[:], f8, float64[:], float64[:], f8, f8)']"], {}), "(['void(float64[:], f8, float64[:], float64[:], f8, f8)'])\n", (231, 289), False, 'from numba import jit, njit\n'), ((798, 852), 'numba.njit', 'njit', (["['void(float64[:], float64[:], float64[:], f8)']"], {}), "(['... |
import math
import pathlib
import sys
import torch
import torch.nn as nn
PROJECT_DIR = pathlib.Path(__file__).absolute().parent.parent.parent # main directory, the parent of src
if str(PROJECT_DIR) not in sys.path:
sys.path.append(str(PROJECT_DIR))
from src.model.ConvLayer import ConvLayer
from src.m... | [
"src.model.PrimaryCaps.PrimaryCaps",
"math.floor",
"pathlib.Path",
"src.model.Decoder.Decoder",
"src.model.DigitCaps.DigitCaps",
"src.model.ConvLayer.ConvLayer",
"torch.device"
] | [((2509, 2573), 'math.floor', 'math.floor', (['((input_wh - conv_kernel + conv_stride) / conv_stride)'], {}), '((input_wh - conv_kernel + conv_stride) / conv_stride)\n', (2519, 2573), False, 'import math\n'), ((2611, 2690), 'math.floor', 'math.floor', (['((conv_dimension - primary_kernel + primary_stride) / primary_str... |
from flask import current_app, request, Response, make_response
from rdflib import ConjunctiveGraph
from werkzeug.exceptions import abort
from depot.middleware import FileServeApp
from .entity_blueprint import entity_blueprint
from whyis.data_extensions import DATA_EXTENSIONS
from whyis.data_formats import DATA_FORMAT... | [
"flask.current_app.get_resource",
"flask.current_app.get_entity_uri",
"flask.current_app.file_depot.exists",
"flask.current_app.nanopub_depot.exists",
"whyis.data_formats.DATA_FORMATS.keys",
"flask.current_app.file_depot.get",
"flask.current_app.nanopub_depot.get",
"rdflib.ConjunctiveGraph",
"flask.... | [((923, 963), 'flask.current_app.get_entity_uri', 'current_app.get_entity_uri', (['name', 'format'], {}), '(name, format)\n', (949, 963), False, 'from flask import current_app, request, Response, make_response\n'), ((980, 1012), 'flask.current_app.get_resource', 'current_app.get_resource', (['entity'], {}), '(entity)\n... |
# Copyright 2016 The Cebes Authors. All Rights Reserved.
#
# Licensed under the Apache License, version 2.0 (the "License").
# You may not use this work except in compliance with the License,
# which is available at www.apache.org/licenses/LICENSE-2.0
#
# This software is distributed on an "AS IS" basis, WITHOUT WARRAN... | [
"pycebes.core.pipeline_api.placeholder",
"pycebes.core.pipeline_api.drop",
"pycebes.core.pipeline.Pipeline",
"pycebes.core.pipeline_api.linear_regression",
"pycebes.core.pipeline_api.vector_assembler",
"unittest.main"
] | [((9800, 9815), 'unittest.main', 'unittest.main', ([], {}), '()\n', (9813, 9815), False, 'import unittest\n'), ((1009, 1019), 'pycebes.core.pipeline.Pipeline', 'Pipeline', ([], {}), '()\n', (1017, 1019), False, 'from pycebes.core.pipeline import Pipeline, Model\n'), ((1044, 1081), 'pycebes.core.pipeline_api.drop', 'pl.... |
"""
Import wikidata nodes into KGTK file
"""
def parser():
return {
'help': 'Import wikidata nodes into KGTK file'
}
def add_arguments(parser):
"""
Parse arguments
Args:
parser (argparse.ArgumentParser)
"""
parser.add_argument("-i", action="store", type=str, dest="wikidat... | [
"json.loads",
"csv.writer",
"bz2.open"
] | [((2540, 2633), 'csv.writer', 'csv.writer', (['myfile'], {'quoting': 'csv.QUOTE_NONE', 'delimiter': '"""\t"""', 'escapechar': '"""\n"""', 'quotechar': '""""""'}), "(myfile, quoting=csv.QUOTE_NONE, delimiter='\\t', escapechar='\\n',\n quotechar='')\n", (2550, 2633), False, 'import csv\n'), ((2744, 2778), 'bz2.open', ... |
import time
import argparse
from datetime import datetime
import logging
import numpy as np
import os
import torch
import torch.nn.functional as F
import torch.multiprocessing as mp
from models import NavCnnModel, NavCnnRnnModel, NavCnnRnnMultModel, NavPlannerControllerModel
from data import EqaDataLoader
from metrics ... | [
"metrics.NavMetric",
"models.NavCnnModel",
"torch.nn.CrossEntropyLoss",
"torch.LongTensor",
"models.get_state",
"numpy.array",
"models.MaskedNLLCriterion",
"logging.info",
"torch.nn.functional.softmax",
"os.path.exists",
"argparse.ArgumentParser",
"models.NavPlannerControllerModel",
"data.Eq... | [((3106, 3141), 'data.EqaDataLoader', 'EqaDataLoader', ([], {}), '(**eval_loader_kwargs)\n', (3119, 3141), False, 'from data import EqaDataLoader\n'), ((34031, 34067), 'data.EqaDataLoader', 'EqaDataLoader', ([], {}), '(**train_loader_kwargs)\n', (34044, 34067), False, 'from data import EqaDataLoader\n'), ((47924, 47949... |
from BinaryModel import *
from numpy.random import rand
class MajorityModel(BinaryModel):
def __init__(self, filename=None):
self.mdlPrm = {
'addNoise' : False,
}
self.wkrIds = {}
self.imgIds = {}
if filename:
self.load_data(filename)
else:
... | [
"numpy.random.rand"
] | [((2670, 2676), 'numpy.random.rand', 'rand', ([], {}), '()\n', (2674, 2676), False, 'from numpy.random import rand\n')] |
from django.db import models
from dynamic_scraper.models import Scraper, SchedulerRuntime
from scrapy.contrib.djangoitem import DjangoItem
class EventWebsite(models.Model):
name = models.CharField(max_length=200)
scraper = models.ForeignKey(Scraper, blank=True, null=True, on_delete=models.SET_NULL)
url = ... | [
"django.db.models.URLField",
"django.db.models.TextField",
"django.db.models.CharField",
"django.db.models.ForeignKey"
] | [((186, 218), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(200)'}), '(max_length=200)\n', (202, 218), False, 'from django.db import models\n'), ((233, 309), 'django.db.models.ForeignKey', 'models.ForeignKey', (['Scraper'], {'blank': '(True)', 'null': '(True)', 'on_delete': 'models.SET_NULL'})... |
"""
PatientFinders are used to find OpenMRS patients that correspond to
CommCare cases if none of the patient identifiers listed in
OpenmrsCaseConfig.match_on_ids have successfully matched a patient.
See `README.md`__ for more context.
"""
import logging
from collections import namedtuple
from functools import partial... | [
"logging.getLogger",
"collections.namedtuple",
"corehq.motech.openmrs.repeater_helpers.search_patients",
"dimagi.ext.couchdbkit.ListProperty",
"pprint.pformat",
"dimagi.ext.couchdbkit.DecimalProperty",
"functools.partial",
"dimagi.ext.couchdbkit.StringProperty",
"dimagi.ext.couchdbkit.DictProperty",... | [((1192, 1219), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1209, 1219), False, 'import logging\n'), ((4250, 4298), 'collections.namedtuple', 'namedtuple', (['"""PatientScore"""', "['patient', 'score']"], {}), "('PatientScore', ['patient', 'score'])\n", (4260, 4298), False, 'from coll... |
from main import status, tps, server_commands, scoreboard
def setup(bot):
bot.add_cog(status.Status(bot), True)
bot.add_cog(tps.Tps(bot), True)
bot.add_cog(server_commands.ServerCommands(bot), True)
bot.add_cog(scoreboard.ScoreBoard(bot), True)
| [
"main.status.Status",
"main.scoreboard.ScoreBoard",
"main.server_commands.ServerCommands",
"main.tps.Tps"
] | [((92, 110), 'main.status.Status', 'status.Status', (['bot'], {}), '(bot)\n', (105, 110), False, 'from main import status, tps, server_commands, scoreboard\n'), ((134, 146), 'main.tps.Tps', 'tps.Tps', (['bot'], {}), '(bot)\n', (141, 146), False, 'from main import status, tps, server_commands, scoreboard\n'), ((170, 205... |
from mongoengine import connect
from config import Config
from db.models.subscriptions import Subscriptions
class Db:
Subscriptions = None
def __init__(self, createClient=True):
config = Config()
self.db = {}
self.Subscriptions = Subscriptions
self.createClient = createClient
... | [
"config.Config",
"mongoengine.connect"
] | [((204, 212), 'config.Config', 'Config', ([], {}), '()\n', (210, 212), False, 'from config import Config\n'), ((401, 717), 'mongoengine.connect', 'connect', ([], {'db': "config.data['database']['dbName']", 'host': "config.data['database']['host']", 'port': "config.data['database']['port']", 'username': "config.data['da... |
import os
import re
import gzip
import argparse
import pandas as pd
import numpy as np
from collections import defaultdict
def get_args():
"""
Parse command line arguments
"""
parser = argparse.ArgumentParser(description="Method to create track for escape mutations")
parser.add_argument("-xlsx",... | [
"os.system",
"collections.defaultdict",
"argparse.ArgumentParser",
"pandas.read_excel"
] | [((205, 292), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Method to create track for escape mutations"""'}), "(description=\n 'Method to create track for escape mutations')\n", (228, 292), False, 'import argparse\n'), ((1206, 1268), 'pandas.read_excel', 'pd.read_excel', (['args.xls... |
#!/usr/bin/env python
from app import app
app.run(host = '0.0.0.0', port = 8089, debug = True, threaded = False, processes = 1)
| [
"app.app.run"
] | [((44, 119), 'app.app.run', 'app.run', ([], {'host': '"""0.0.0.0"""', 'port': '(8089)', 'debug': '(True)', 'threaded': '(False)', 'processes': '(1)'}), "(host='0.0.0.0', port=8089, debug=True, threaded=False, processes=1)\n", (51, 119), False, 'from app import app\n')] |
import unittest
from zeppos_microsoft_sql_server.ms_sql_server import MsSqlServer
import pandas as pd
import pyodbc
import os
class TestTheProjectMethods(unittest.TestCase):
def test_constructor_methods(self):
self.assertEqual("<class 'zeppos_microsoft_sql_server.ms_sql_server.MsSqlServer'>", str(type(MsSq... | [
"os.path.exists",
"pyodbc.connect",
"zeppos_microsoft_sql_server.ms_sql_server.MsSqlServer",
"pandas.DataFrame",
"pandas.read_csv",
"unittest.main",
"os.remove"
] | [((4822, 4837), 'unittest.main', 'unittest.main', ([], {}), '()\n', (4835, 4837), False, 'import unittest\n'), ((392, 527), 'zeppos_microsoft_sql_server.ms_sql_server.MsSqlServer', 'MsSqlServer', (['"""DRIVER={ODBC Driver 13 for SQL Server}; SERVER=localhost\\\\sqlexpress; DATABASE=master; Trusted_Connection=yes;"""'],... |
import unittest
import io
import sys
from main import Gedcom
class TestProject(unittest.TestCase):
def test_us22_unique_id(self):
# Redirect stdout for unit test
capturedOutput = io.StringIO()
sys.stdout = capturedOutput
FILENAME="My-Family-27-Jan-2019-275.ged"
... | [
"unittest.main",
"io.StringIO",
"main.Gedcom"
] | [((812, 827), 'unittest.main', 'unittest.main', ([], {}), '()\n', (825, 827), False, 'import unittest\n'), ((200, 213), 'io.StringIO', 'io.StringIO', ([], {}), '()\n', (211, 213), False, 'import io\n'), ((332, 348), 'main.Gedcom', 'Gedcom', (['FILENAME'], {}), '(FILENAME)\n', (338, 348), False, 'from main import Gedcom... |
from twisted.plugin import IPlugin
from twisted.words.protocols import irc
from txircd.config import ConfigValidationError
from txircd.module_interface import Command, ICommand, IModuleData, ModuleData
from txircd.modules.xlinebase import XLineBase
from txircd.utils import durationToSeconds, ircLower, now
from zope.int... | [
"fnmatch.fnmatchcase",
"txircd.utils.now",
"zope.interface.implements",
"txircd.config.ConfigValidationError",
"txircd.utils.durationToSeconds"
] | [((415, 447), 'zope.interface.implements', 'implements', (['IPlugin', 'IModuleData'], {}), '(IPlugin, IModuleData)\n', (425, 447), False, 'from zope.interface import implements\n'), ((2766, 2786), 'zope.interface.implements', 'implements', (['ICommand'], {}), '(ICommand)\n', (2776, 2786), False, 'from zope.interface im... |
import matplotlib.pyplot as plt
import numpy
import errandpy
"""
logファイルのFitting Parameter: a,b,c,dを返します
normalized_paramの時正規化したパラメーターを返します
"""
def real_a(a, delta, min):
return (a + 1) * delta + min
def real_b(b, delta):
return b * delta
def get_z0FromLogFile(path, isLega... | [
"numpy.mean",
"matplotlib.pyplot.clf",
"matplotlib.pyplot.axhline",
"numpy.dot",
"matplotlib.pyplot.scatter",
"matplotlib.pyplot.axvline"
] | [((2581, 2594), 'numpy.mean', 'numpy.mean', (['y'], {}), '(y)\n', (2591, 2594), False, 'import numpy\n'), ((2609, 2640), 'numpy.dot', 'numpy.dot', (['(y - ymean)', '(y - ymean)'], {}), '(y - ymean, y - ymean)\n', (2618, 2640), False, 'import numpy\n'), ((3009, 3018), 'matplotlib.pyplot.clf', 'plt.clf', ([], {}), '()\n'... |
from brownie import Lottery, accounts, config, network
from web3 import Web3
def printStuff():
account = accounts[0]
lottery = Lottery.deploy(
config["networks"][network.show_active()]["eth_usd_price_feed"],
config["networks"][network.show_active()]["gbp_usd_price_feed"],
{"from": acco... | [
"brownie.network.show_active"
] | [((180, 201), 'brownie.network.show_active', 'network.show_active', ([], {}), '()\n', (199, 201), False, 'from brownie import Lottery, accounts, config, network\n'), ((253, 274), 'brownie.network.show_active', 'network.show_active', ([], {}), '()\n', (272, 274), False, 'from brownie import Lottery, accounts, config, ne... |
from netmiko import ConnectHandler
import os
template = """logging host 192.168.20.5 transport tcp port 514
logging trap 6
interface loopback 30
description "{rtr} loopback interface\""""
username = 'test'
password = "<PASSWORD>"
# step 1
# fetch the hostname of the router for the template
for n in range(1, 5):
... | [
"os.listdir"
] | [((1005, 1021), 'os.listdir', 'os.listdir', (['"""./"""'], {}), "('./')\n", (1015, 1021), False, 'import os\n')] |
from datetime import date
import pytest
import netsgiro
import netsgiro.records
def test_transmission_start():
record = netsgiro.records.TransmissionStart.from_string(
'NY00001055555555100008100008080000000000'
'0000000000000000000000000000000000000000'
)
assert record.service_code == n... | [
"netsgiro.records.TransmissionEnd.from_string",
"netsgiro.records.TransmissionStart.from_string",
"netsgiro.records.TransactionAmountItem3.from_string",
"netsgiro.records.AvtaleGiroAgreement.from_string",
"netsgiro.records.TransactionAmountItem2.from_string",
"netsgiro.records.TransactionAmountItem1.from_... | [((128, 268), 'netsgiro.records.TransmissionStart.from_string', 'netsgiro.records.TransmissionStart.from_string', (['"""NY000010555555551000081000080800000000000000000000000000000000000000000000000000"""'], {}), "(\n 'NY000010555555551000081000080800000000000000000000000000000000000000000000000000'\n )\n", (174, ... |
from django.contrib import admin
from .models import TimePeriod
class TimePeriodAdminBase(object):
list_display = ('name', 'period_start', 'period_end',)
class TimePeriodAdmin(TimePeriodAdminBase, admin.ModelAdmin):
pass
admin.site.register(TimePeriod, TimePeriodAdmin)
| [
"django.contrib.admin.site.register"
] | [((236, 284), 'django.contrib.admin.site.register', 'admin.site.register', (['TimePeriod', 'TimePeriodAdmin'], {}), '(TimePeriod, TimePeriodAdmin)\n', (255, 284), False, 'from django.contrib import admin\n')] |
import qiskit
import qtm.progress_bar
import qtm.constant
import qtm.qfim
import qtm.noise
import qtm.optimizer
import qtm.fubini_study
import numpy as np
import types, typing
def measure(qc: qiskit.QuantumCircuit, qubits, cbits=[]):
"""Measuring the quantu circuit which fully measurement gates
Args:
... | [
"qiskit.execute",
"numpy.array",
"numpy.zeros",
"qiskit.quantum_info.Statevector.from_instruction",
"numpy.expand_dims",
"qiskit.QuantumCircuit"
] | [((3447, 3492), 'qiskit.QuantumCircuit', 'qiskit.QuantumCircuit', (['num_qubits', 'num_qubits'], {}), '(num_qubits, num_qubits)\n', (3468, 3492), False, 'import qiskit\n'), ((3653, 3705), 'qiskit.quantum_info.Statevector.from_instruction', 'qiskit.quantum_info.Statevector.from_instruction', (['qc'], {}), '(qc)\n', (370... |
from datetime import datetime, date
from marqeta.response_models.result import Result
from marqeta.response_models.kyc_question import KycQuestion
from marqeta.response_models import datetime_object
import json
import re
class KycResponse(object):
def __init__(self, json_response):
self.json_response = js... | [
"marqeta.response_models.datetime_object",
"json.dumps",
"marqeta.response_models.result.Result",
"marqeta.response_models.kyc_question.KycQuestion"
] | [((371, 427), 'json.dumps', 'json.dumps', (['self.json_response'], {'default': 'self.json_serial'}), '(self.json_response, default=self.json_serial)\n', (381, 427), False, 'import json\n'), ((672, 723), 'marqeta.response_models.datetime_object', 'datetime_object', (['"""created_time"""', 'self.json_response'], {}), "('... |
#!/usr/bin/env python3
"""
Easy to use Websocket Server.
Source: https://github.com/rharder/handy
June 2018 - Updated for aiohttp v3.3
August 2018 - Updated for Python 3.7, made WebServer support multiple routes on one port
"""
import asyncio
import logging
import weakref
from functools import partial
from typing imp... | [
"logging.getLogger",
"asyncio.sleep",
"weakref.WeakSet",
"aiohttp.web.Application",
"aiohttp.web.AppRunner",
"aiohttp.web.TCPSite",
"functools.partial",
"asyncio.gather",
"aiohttp.web.WebSocketResponse"
] | [((986, 1045), 'logging.getLogger', 'logging.getLogger', (["(__name__ + '.' + self.__class__.__name__)"], {}), "(__name__ + '.' + self.__class__.__name__)\n", (1003, 1045), False, 'import logging\n'), ((2268, 2285), 'aiohttp.web.Application', 'web.Application', ([], {}), '()\n', (2283, 2285), False, 'from aiohttp impor... |
#!/usr/bin/env python
#coding=utf-8
import os
import sys
import json
import time
import urllib2
import platform
import ConfigParser
UPDATE_CONFIG = 0
def checkplay(remotedir,workdir):
global UPDATE_CONFIG
if not remotedir.endswith('/'):
remotedir = remotedir + '/'
orgcode = UPD... | [
"time.sleep",
"ConfigParser.ConfigParser",
"sys.path.append",
"os.remove",
"os.path.exists",
"os.listdir",
"urllib2.urlopen",
"platform.system",
"os.path.isdir",
"os.popen",
"os.getpid",
"json.loads",
"pyutil.downloadFile",
"checksale.checksale",
"os.path.dirname",
"checksync.checksync... | [((814, 849), 'os.path.join', 'os.path.join', (['workdir', '"""play-1.2.3"""'], {}), "(workdir, 'play-1.2.3')\n", (826, 849), False, 'import os\n'), ((865, 895), 'os.path.join', 'os.path.join', (['localdir', '"""play"""'], {}), "(localdir, 'play')\n", (877, 895), False, 'import os\n'), ((989, 1022), 'os.path.join', 'os... |
import pytest
import os
import LabWeaver_analysis as lw_ana
DB_DIR = os.path.abspath("tests/assets/db")
@pytest.fixture
def existing_records_db():
db_path = os.path.join(DB_DIR, "records_existing.db")
return lw_ana.RecordsDB(db_path)
def test_fetch(existing_records_db):
fetched_record = existing_records_db.fi... | [
"os.path.abspath",
"LabWeaver_analysis.RecordsDB",
"os.path.join",
"os.remove"
] | [((72, 106), 'os.path.abspath', 'os.path.abspath', (['"""tests/assets/db"""'], {}), "('tests/assets/db')\n", (87, 106), False, 'import os\n'), ((163, 206), 'os.path.join', 'os.path.join', (['DB_DIR', '"""records_existing.db"""'], {}), "(DB_DIR, 'records_existing.db')\n", (175, 206), False, 'import os\n'), ((215, 240), ... |
# -*- coding: utf-8 -*-
import numpy as np
import random
import sys
from collections import Counter
import json
from argparse import ArgumentParser
from rand_utils import rand_partition
def build_tree(num_leaves = 10, rootdate = 1000):
"""
Starting from a three-node tree, split a randomly chosen branch to in... | [
"numpy.copy",
"rand_utils.rand_partition",
"sys.exit",
"numpy.sqrt",
"argparse.ArgumentParser",
"numpy.random.multivariate_normal",
"json.dumps",
"numpy.random.exponential",
"collections.Counter",
"numpy.array",
"numpy.zeros",
"sys.stderr.write",
"numpy.random.gamma",
"numpy.random.seed",
... | [((6320, 6335), 'numpy.arange', 'np.arange', (['fnum'], {}), '(fnum)\n', (6329, 6335), True, 'import numpy as np\n'), ((13855, 13871), 'argparse.ArgumentParser', 'ArgumentParser', ([], {}), '()\n', (13869, 13871), False, 'from argparse import ArgumentParser\n'), ((1867, 1898), 'numpy.random.uniform', 'np.random.uniform... |
import pandas as pd
import numpy as np
import os
import sys
def load_data(assets, start_date, end_date):
df_open = load_data_from_file('etf_data_open.csv', assets, start_date, end_date)
df_close = load_data_from_file('etf_data_close.csv', assets, start_date, end_date)
df_high = load_data_from_file('etf_da... | [
"os.path.isfile",
"numpy.isnan",
"pandas.read_csv"
] | [((927, 944), 'pandas.read_csv', 'pd.read_csv', (['file'], {}), '(file)\n', (938, 944), True, 'import pandas as pd\n'), ((1757, 1774), 'pandas.read_csv', 'pd.read_csv', (['file'], {}), '(file)\n', (1768, 1774), True, 'import pandas as pd\n'), ((2559, 2576), 'pandas.read_csv', 'pd.read_csv', (['file'], {}), '(file)\n', ... |
import csv
from pprint import pprint
from django.core.management.base import BaseCommand
class Command(BaseCommand):
def handle(self, *args, **options):
with open(args[0]) as csvfile:
reader = csv.DictReader(csvfile)
weights = []
for row in reader:
row['... | [
"csv.DictReader",
"pprint.pprint"
] | [((219, 242), 'csv.DictReader', 'csv.DictReader', (['csvfile'], {}), '(csvfile)\n', (233, 242), False, 'import csv\n'), ((382, 397), 'pprint.pprint', 'pprint', (['weights'], {}), '(weights)\n', (388, 397), False, 'from pprint import pprint\n')] |
import pandas as pd
import numpy as np
from matplotlib import pyplot as plt
import os
from datetime import datetime, date, timedelta
from sklearn.linear_model import LinearRegression
import scipy
import math
import sys
import locator
file_path = os.path.dirname(os.path.realpath(__file__))
proj_path = os.path.abspath(... | [
"pandas.read_csv",
"numpy.log",
"math.log",
"pandas.Index",
"datetime.date.fromtimestamp",
"locator.FirstOfMonthLocator",
"datetime.timedelta",
"pandas.notnull",
"os.path.exists",
"matplotlib.pyplot.close",
"numpy.exp",
"datetime.date",
"pandas.DataFrame",
"matplotlib.pyplot.yscale",
"ma... | [((366, 401), 'os.path.join', 'os.path.join', (['proj_path', '"""datagouv"""'], {}), "(proj_path, 'datagouv')\n", (378, 401), False, 'import os\n'), ((412, 468), 'os.path.join', 'os.path.join', (['proj_path', '"""../../gatsby/trends/generated"""'], {}), "(proj_path, '../../gatsby/trends/generated')\n", (424, 468), Fals... |
import unittest
import numpy as np
from dolo.numeric.ncpsolve import ncpsolve, smooth
def josephy(x):
# Computes the function value F(x) of the NCP-example by Josephy.
n=len(x)
Fx=np.zeros(n)
Fx[0]=3*x[0]**2+2*x[0]*x[1]+2*x[1]**2+x[2]+3*x[3]-6
Fx[1]=2*x[0]**2+x[0]+x[1]**2+3*x[2]+2*x[3]-2
F... | [
"numpy.column_stack",
"numpy.array",
"numpy.zeros",
"numpy.testing.assert_almost_equal",
"dolo.numeric.ncpsolve.ncpsolve",
"unittest.main",
"dolo.numeric.solver.solver"
] | [((198, 209), 'numpy.zeros', 'np.zeros', (['n'], {}), '(n)\n', (206, 209), True, 'import numpy as np\n'), ((633, 649), 'numpy.zeros', 'np.zeros', (['(n, n)'], {}), '((n, n))\n', (641, 649), True, 'import numpy as np\n'), ((5046, 5061), 'unittest.main', 'unittest.main', ([], {}), '()\n', (5059, 5061), False, 'import uni... |
from unittest.mock import MagicMock
import google.protobuf.text_format as text_format
import numpy as np
from banditpylib.bandits import CvarReward
from banditpylib.data_pb2 import Actions, Context
from .ts import ThompsonSampling
class TestThompsonSampling:
"""Test thompson sampling policy"""
def test_simple_... | [
"banditpylib.bandits.CvarReward",
"unittest.mock.MagicMock",
"numpy.array",
"banditpylib.data_pb2.Context",
"banditpylib.data_pb2.Actions"
] | [((346, 379), 'numpy.array', 'np.array', (['[0, 0.7, 0.8, 0.9, 1.0]'], {}), '([0, 0.7, 0.8, 0.9, 1.0])\n', (354, 379), True, 'import numpy as np\n'), ((411, 426), 'banditpylib.bandits.CvarReward', 'CvarReward', (['(0.7)'], {}), '(0.7)\n', (421, 426), False, 'from banditpylib.bandits import CvarReward\n'), ((972, 1001),... |
from maru import pymorphy
from maru.lemmatizer.abstract import ILemmatizer
from maru.tag import Tag
from maru.types import Word
class PymorphyLemmatizer(ILemmatizer):
def lemmatize(self, word: Word, tag: Tag) -> Word:
best_parse = max(
pymorphy.analyze(word),
key=lambda parse: (
... | [
"maru.pymorphy.get_gender",
"maru.pymorphy.analyze",
"maru.pymorphy.get_part_of_speech",
"maru.pymorphy.get_case"
] | [((262, 284), 'maru.pymorphy.analyze', 'pymorphy.analyze', (['word'], {}), '(word)\n', (278, 284), False, 'from maru import pymorphy\n'), ((345, 379), 'maru.pymorphy.get_part_of_speech', 'pymorphy.get_part_of_speech', (['parse'], {}), '(parse)\n', (372, 379), False, 'from maru import pymorphy\n'), ((409, 433), 'maru.py... |
import os
import xcffib
from xcffib.testing import XvfbTest
from xcffib.xproto import Atom, ConfigWindow, EventMask, GetPropertyType
conn = xcffib.connect(os.environ['DISPLAY'])
xproto = xcffib.xproto.xprotoExtension(conn)
def arrange(layout, windowids):
for lay, winid in zip(layout, windowids):
xproto.... | [
"xcffib.xproto.xprotoExtension",
"xcffib.connect"
] | [((142, 179), 'xcffib.connect', 'xcffib.connect', (["os.environ['DISPLAY']"], {}), "(os.environ['DISPLAY'])\n", (156, 179), False, 'import xcffib\n'), ((189, 224), 'xcffib.xproto.xprotoExtension', 'xcffib.xproto.xprotoExtension', (['conn'], {}), '(conn)\n', (218, 224), False, 'import xcffib\n')] |
__author__ = 'krishnasagar'
from django import forms
# Refer for forms.MultipleChoiceField always, its helpful -
# http://www.programcreek.com/python/example/58199/django.forms.MultipleChoiceField
class TrackForm(forms.Form):
def __init__(self, *args, **kwargs):
if 'choices' in kwargs:
choic... | [
"django.forms.TextInput",
"django.forms.SelectMultiple",
"django.forms.DecimalField"
] | [((734, 851), 'django.forms.DecimalField', 'forms.DecimalField', ([], {'label': '"""Rating"""', 'max_value': '(10.0)', 'min_value': '(0.0)', 'decimal_places': '(1)', 'max_digits': '(2)', 'required': '(False)'}), "(label='Rating', max_value=10.0, min_value=0.0,\n decimal_places=1, max_digits=2, required=False)\n", (7... |
import numpy
from xoppy_dabax_util import bragg_calc2
from run_diff_pat import run_diff_pat
from srxraylib.plot.gol import plot
if __name__ == "__main__":
descriptor = 'YB66'
SCANFROM = 0 # in microradiants
SCANTO = 100 # in microradiants
MILLER_INDEX_H = 4
MILLER_INDEX_K = 0
MILLER_INDEX_L = ... | [
"xoppy_dabax_util.bragg_calc2",
"numpy.loadtxt",
"run_diff_pat.run_diff_pat",
"srxraylib.plot.gol.plot"
] | [((457, 679), 'xoppy_dabax_util.bragg_calc2', 'bragg_calc2', ([], {'descriptor': 'descriptor', 'hh': 'MILLER_INDEX_H', 'kk': 'MILLER_INDEX_K', 'll': 'MILLER_INDEX_L', 'temper': 'TEMPER', 'emin': '(ENERGY - 100.0)', 'emax': '(ENERGY + 100.0)', 'estep': '((SCANTO - SCANFROM) / SCANPOINTS)', 'fileout': '"""xcrystal.bra"""... |
import os
import datetime
import math
import traceback
from typing import List
import requests
from loguru import logger
from lxml import etree
from siphon.catalog import TDSCatalog
from dask.utils import memory_repr
import numpy as np
from dateutil import parser
from ooi_harvester.settings import harvest_settings
... | [
"datetime.datetime",
"os.path.exists",
"dask.utils.memory_repr",
"dateutil.parser.parse",
"math.floor",
"datetime.datetime.utcnow",
"loguru.logger.warning",
"os.path.join",
"requests.get",
"numpy.sum",
"os.path.dirname",
"os.mkdir",
"lxml.etree.fromstring",
"ooi_harvester.settings.harvest_... | [((1942, 1962), 'loguru.logger.warning', 'logger.warning', (['resp'], {}), '(resp)\n', (1956, 1962), False, 'from loguru import logger\n'), ((5007, 5040), 'requests.get', 'requests.get', (['catalog.catalog_url'], {}), '(catalog.catalog_url)\n', (5019, 5040), False, 'import requests\n'), ((5060, 5089), 'lxml.etree.froms... |
"""
propertylist
"""
from __future__ import absolute_import, division, print_function
from collections import namedtuple
import logging
from PySide.QtCore import Qt
from mceditlib import nbt
from PySide import QtGui, QtCore
from mcedit2.util.load_ui import registerCustomWidget
log = logging.getLogger(__name__)
cl... | [
"logging.getLogger",
"PySide.QtCore.QModelIndex",
"PySide.QtGui.QSpinBox",
"collections.namedtuple",
"PySide.QtGui.QCheckBox",
"PySide.QtGui.QComboBox",
"PySide.QtGui.QDoubleSpinBox",
"PySide.QtGui.QPlainTextEdit",
"PySide.QtCore.Signal"
] | [((289, 316), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (306, 316), False, 'import logging\n'), ((3256, 3328), 'collections.namedtuple', 'namedtuple', (['"""PropertyListEntry"""', '"""tagName displayName valueType min max"""'], {}), "('PropertyListEntry', 'tagName displayName valueTy... |
import pygame
class UI:
def __init__(self, surface):
# setup
self.display_surface = surface
# health
self.health_border = pygame.image.load(
'graphics/ui/Border_0.png').convert_alpha()
self.health_bar = pygame.image.load(
'graphics/ui/... | [
"pygame.image.load",
"pygame.font.Font",
"pygame.draw.rect",
"pygame.Rect"
] | [((638, 664), 'pygame.font.Font', 'pygame.font.Font', (['None', '(30)'], {}), '(None, 30)\n', (654, 664), False, 'import pygame\n'), ((984, 1058), 'pygame.Rect', 'pygame.Rect', (['self.health_bar_topleft', '(current_bar_width, self.bar_height)'], {}), '(self.health_bar_topleft, (current_bar_width, self.bar_height))\n',... |
# Generated by Django 2.0.3 on 2018-04-18 19:49
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('Buy', '0002_standardset'),
]
operations = [
migrations.AddField(
model_name='singlecardpurchase',
name='initial_sell... | [
"django.db.models.DecimalField"
] | [((347, 409), 'django.db.models.DecimalField', 'models.DecimalField', ([], {'decimal_places': '(2)', 'default': '(0)', 'max_digits': '(6)'}), '(decimal_places=2, default=0, max_digits=6)\n', (366, 409), False, 'from django.db import migrations, models\n')] |
__version__ = '0.6.2'
__version_info__ = tuple(map(int, __version__.split('.')))
from django.utils.translation import ugettext_lazy as _
def __activate_social_auth_monkeypatch():
from social_core.backends.base import BaseAuth
from social_core.backends.open_id import (OPENID_ID_FIELD, OpenIdAuth)
from soc... | [
"django.utils.translation.ugettext_lazy"
] | [((563, 583), 'django.utils.translation.ugettext_lazy', '_', (['"""OpenID identity"""'], {}), "('OpenID identity')\n", (564, 583), True, 'from django.utils.translation import ugettext_lazy as _\n'), ((698, 723), 'django.utils.translation.ugettext_lazy', '_', (['"""LiveJournal username"""'], {}), "('LiveJournal username... |
import subprocess
__all__ = ['view_env', 'create_env', 'remove_env']
def view_env():
"""Get virtual environment info."""
cmd = f"conda info -e"
s = subprocess.Popen(cmd, stdout=subprocess.PIPE, shell=True).communicate()[0]
s = s.decode('utf-8').strip().split('\n')[2:]
s = [i.split(' ') for i in s]... | [
"subprocess.Popen"
] | [((162, 219), 'subprocess.Popen', 'subprocess.Popen', (['cmd'], {'stdout': 'subprocess.PIPE', 'shell': '(True)'}), '(cmd, stdout=subprocess.PIPE, shell=True)\n', (178, 219), False, 'import subprocess\n'), ((599, 656), 'subprocess.Popen', 'subprocess.Popen', (['cmd'], {'stdout': 'subprocess.PIPE', 'shell': '(True)'}), '... |
from test.mock.mock_inversion import MockMapper
from test.mock.mock_galaxy import MockHyperGalaxy
class MockTracer(object):
def __init__(self, unblurred_image_1d, blurring_image_1d, has_light_profile, has_pixelization, has_hyper_galaxy,
has_grid_mappers=False):
self.unblurred_image_1d = ... | [
"test.mock.mock_galaxy.MockHyperGalaxy",
"test.mock.mock_inversion.MockMapper"
] | [((1093, 1105), 'test.mock.mock_inversion.MockMapper', 'MockMapper', ([], {}), '()\n', (1103, 1105), False, 'from test.mock.mock_inversion import MockMapper\n'), ((1178, 1190), 'test.mock.mock_inversion.MockMapper', 'MockMapper', ([], {}), '()\n', (1188, 1190), False, 'from test.mock.mock_inversion import MockMapper\n'... |
"""Blog models."""
from typing import Union
from django.contrib.postgres.fields import ArrayField
from django.db import models
from django.utils import timezone
from django.utils.text import Truncator, slugify
from markdownx.models import MarkdownxField
from .dbfunctions import Unnest
from .signals import post_publ... | [
"django.db.models.Index",
"django.utils.text.slugify",
"django.db.models.TextField",
"django.db.models.Count",
"django.db.models.ManyToManyField",
"django.db.models.DateTimeField",
"django.utils.timezone.now",
"django.db.models.SlugField",
"django.db.models.CharField",
"django.db.models.URLField",... | [((741, 773), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(300)'}), '(max_length=300)\n', (757, 773), False, 'from django.db import models\n'), ((785, 842), 'django.db.models.SlugField', 'models.SlugField', ([], {'max_length': 'SLUG_MAX_LENGTH', 'unique': '(True)'}), '(max_length=SLUG_MAX_LEN... |
import asyncio
import math
import networkx as nx
import ccxt.async_support as ccxt
import datetime
import logging
from .logging_utils import FormatForLogAdapter
__all__ = [
'FeesNotAvailable',
'create_exchange_graph',
'load_exchange_graph',
]
adapter = FormatForLogAdapter(logging.getLogger('peregrinearb.u... | [
"logging.getLogger",
"networkx.DiGraph",
"asyncio.wait",
"networkx.Graph",
"math.log",
"datetime.datetime.now",
"asyncio.sleep"
] | [((287, 342), 'logging.getLogger', 'logging.getLogger', (['"""peregrinearb.utils.single_exchange"""'], {}), "('peregrinearb.utils.single_exchange')\n", (304, 342), False, 'import logging\n'), ((644, 654), 'networkx.Graph', 'nx.Graph', ([], {}), '()\n', (652, 654), True, 'import networkx as nx\n'), ((1927, 1939), 'netwo... |
from pathlib import Path
import fasttext
if __name__ == "__main__":
targets = [
"red", "black", "orange", "white", "gray/black", # colors
"sony", "apple", "canon", "nikon", "dell", # brands
"32", "an", "the", "4", "to", # numbers and stopwords
"inch", "cm", "oz", "gb", "mb", # ... | [
"fasttext.train_unsupervised",
"pathlib.Path"
] | [((418, 520), 'pathlib.Path', 'Path', (['"""/Users/fredriko/PycharmProjects/search_with_machine_learning_course/workspace/titles"""'], {}), "(\n '/Users/fredriko/PycharmProjects/search_with_machine_learning_course/workspace/titles'\n )\n", (422, 520), False, 'from pathlib import Path\n'), ((909, 946), 'fasttext.t... |
import json
import pytest
@pytest.fixture
def test_bib():
with open(".\\test_files\\bib.json") as file:
return json.load(file)
@pytest.fixture
def test_mixed_bib():
with open(".\\test_files\\mixed_bib.json") as file:
return json.load(file)
| [
"json.load"
] | [((126, 141), 'json.load', 'json.load', (['file'], {}), '(file)\n', (135, 141), False, 'import json\n'), ((253, 268), 'json.load', 'json.load', (['file'], {}), '(file)\n', (262, 268), False, 'import json\n')] |
import numpy as np
import pandas as pd
import torch
from physics.protein_os import Protein
import options
from utils import write_pdb, write_pdb_sample, transform_profile, load_protein
from physics.anneal import AnnealCoords, AnnealFrag
# from physics.move import SampleICNext
from physics.grad_minimizer import *
from p... | [
"pandas.read_csv",
"mdtraj.Trajectory",
"os.path.exists",
"physics.anneal.AnnealCoords",
"os.mkdir",
"pandas.DataFrame",
"mdtraj.rmsd",
"utils.write_pdb_sample",
"physics.protein_os.Protein",
"utils.load_protein",
"options.parse_args_and_arch",
"h5py.File",
"utils.test_setup",
"torch.stack... | [((477, 502), 'options.get_fold_parser', 'options.get_fold_parser', ([], {}), '()\n', (500, 502), False, 'import options\n'), ((510, 545), 'options.parse_args_and_arch', 'options.parse_args_and_arch', (['parser'], {}), '(parser)\n', (537, 545), False, 'import options\n'), ((587, 603), 'utils.test_setup', 'test_setup', ... |
import RPi.GPIO as GPIO
import time
# for GPIO numbering, choose BCM
#GPIO.setmode(GPIO.BCM)
# or, for pin numbering, choose BOARD
GPIO.setmode(GPIO.BOARD)
# battery1 = 2
# battery2 = 4
AEnable = 13 #27
AIN1 = 22 #25
AIN2 = 18 #24
# BIN1 = 23 # 16
# BIN2 = 18 # 12
GPIO.setup(AEnable, GPIO.OUT)
GPIO.set... | [
"RPi.GPIO.cleanup",
"RPi.GPIO.setup",
"RPi.GPIO.output",
"time.sleep",
"RPi.GPIO.setmode"
] | [((143, 167), 'RPi.GPIO.setmode', 'GPIO.setmode', (['GPIO.BOARD'], {}), '(GPIO.BOARD)\n', (155, 167), True, 'import RPi.GPIO as GPIO\n'), ((282, 311), 'RPi.GPIO.setup', 'GPIO.setup', (['AEnable', 'GPIO.OUT'], {}), '(AEnable, GPIO.OUT)\n', (292, 311), True, 'import RPi.GPIO as GPIO\n'), ((312, 338), 'RPi.GPIO.setup', 'G... |
# Copyright 2017, <NAME>, All rights reserved.
from bottle import HTTPResponse
from common import Status, overrides
from ..web_app import IHandler, WebApp
from ..serialize import SerializeStatusJson
class StatusHandler(IHandler):
def __init__(self, status: Status):
self.__status = status
@overrides... | [
"common.overrides",
"bottle.HTTPResponse"
] | [((311, 330), 'common.overrides', 'overrides', (['IHandler'], {}), '(IHandler)\n', (320, 330), False, 'from common import Status, overrides\n'), ((558, 585), 'bottle.HTTPResponse', 'HTTPResponse', ([], {'body': 'out_json'}), '(body=out_json)\n', (570, 585), False, 'from bottle import HTTPResponse\n')] |
# Copyright 2020 The HuggingFace Datasets Authors and the current dataset script contributor.
#
# 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.... | [
"datasets.SplitGenerator",
"pandas.read_csv",
"datasets.DatasetInfo",
"datasets.Version",
"datasets.Value"
] | [((2653, 2678), 'datasets.Version', 'datasets.Version', (['"""1.0.0"""'], {}), "('1.0.0')\n", (2669, 2678), False, 'import datasets\n'), ((4638, 4766), 'datasets.DatasetInfo', 'datasets.DatasetInfo', ([], {'description': '_DESCRIPTION', 'features': 'features', 'homepage': '_HOMEPAGE', 'license': '_LICENSE', 'citation':... |
'''
09 - Multiple grouped summaries
Earlier in this chapter, you saw that the .agg() method is useful to
compute multiple statistics on multiple variables. It also works with
grouped data. NumPy, which is imported as np, has many different summary
statistics functions, including: np.min, np.max, np.mean, and np.median... | [
"pandas.read_csv"
] | [((1687, 1728), 'pandas.read_csv', 'pd.read_csv', (['"""content/wallmart_sales.csv"""'], {}), "('content/wallmart_sales.csv')\n", (1698, 1728), True, 'import pandas as pd\n')] |
"""
This code is modified from harveyslash's work (https://github.com/harveyslash/Deep-Image-Analogy-PyTorch)
"""
import mxnet as mx
from mxnet.gluon.model_zoo import vision as models
from mxnet.gluon import nn
from mxnet import nd
from mxnet import autograd
from time import time
from mxnet import optimizer
import sys... | [
"mxnet.autograd.record",
"mxnet.optimizer.Adam",
"mxnet.nd.waitall",
"mxnet.cpu",
"mxnet.gluon.model_zoo.vision.vgg19",
"mxnet.gpu",
"mxnet.nd.array",
"sys.stdout.flush",
"mxnet.gluon.nn.Sequential",
"time.time",
"sys.stdout.write"
] | [((382, 412), 'mxnet.gluon.model_zoo.vision.vgg19', 'models.vgg19', ([], {'pretrained': '(False)'}), '(pretrained=False)\n', (394, 412), True, 'from mxnet.gluon.model_zoo import vision as models\n'), ((560, 591), 'mxnet.nd.array', 'nd.array', (['[0.485, 0.456, 0.406]'], {}), '([0.485, 0.456, 0.406])\n', (568, 591), Fal... |
import json
from .fragment_doc import fragment_srt, fragment_syosetu, has_unbalanced_quotes, extract_kana_kanji
EXTRACT_KANA_KANJI_CASES = [
['asdf.!ä', ''],
['あいうえお', 'あいうえお'],
['asdこfdれ', 'これ'],
['「ああ、畜生」foo', 'ああ畜生'],
]
for [text, target] in EXTRACT_KANA_KANJI_CASES:
if extract_kana_kanji(text)... | [
"json.dumps"
] | [((3641, 3675), 'json.dumps', 'json.dumps', (['result'], {'sort_keys': '(True)'}), '(result, sort_keys=True)\n', (3651, 3675), False, 'import json\n'), ((3679, 3722), 'json.dumps', 'json.dumps', (['expected_result'], {'sort_keys': '(True)'}), '(expected_result, sort_keys=True)\n', (3689, 3722), False, 'import json\n')] |
import os
import math
import time
import datetime
import logging
from . import podio_auth
log = logging.getLogger(__file__)
def try_environment_token():
"""
Try to get the token from the environment variables TETRAPOD_CLIENT_ID and TETRAPOD_ACCESS_TOKEN.
:return:
"""
try:
client_id = os.... | [
"logging.getLogger"
] | [((98, 125), 'logging.getLogger', 'logging.getLogger', (['__file__'], {}), '(__file__)\n', (115, 125), False, 'import logging\n')] |
import sys
import csv
import json
import shutil
from collections import OrderedDict
HW = OrderedDict()
with open('ec2_instance_types.csv', 'r') as f:
reader = csv.reader(f)
for i,row in enumerate(reader):
if i == 0:
header = row
else:
entry = {}
entry['type'... | [
"collections.OrderedDict",
"json.dump",
"csv.reader",
"shutil.copy"
] | [((91, 104), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (102, 104), False, 'from collections import OrderedDict\n'), ((2688, 2747), 'shutil.copy', 'shutil.copy', (['"""hardware.json"""', '"""../../preload/hardware.json"""'], {}), "('hardware.json', '../../preload/hardware.json')\n", (2699, 2747), False... |
import panda3d.core as p3d
import pytest #pylint:disable=wrong-import-order
import simplepbr
#pylint:disable=redefined-outer-name
@pytest.fixture(scope='session')
def showbase():
from direct.showbase.ShowBase import ShowBase
p3d.load_prc_file_data(
'',
'window-type offscreen\n'
'fram... | [
"pytest.fixture",
"panda3d.core.load_prc_file_data",
"direct.showbase.ShowBase.ShowBase",
"simplepbr.init"
] | [((135, 166), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""session"""'}), "(scope='session')\n", (149, 166), False, 'import pytest\n'), ((237, 324), 'panda3d.core.load_prc_file_data', 'p3d.load_prc_file_data', (['""""""', '"""window-type offscreen\nframebuffer-hardware false\n"""'], {}), '(\'\',\n """windo... |
import numpy as np
from .common import *
from . import rotation
def to_homogeneous(x):
x = np.asarray(x)
o = np.ones_like(x[..., :1])
return np.concatenate([x, o], axis=-1)
def from_homogeneous(x):
return x[..., :-1] / x[..., -1:]
def compose(r, t, rtype, out=None):
if out is None:
shape ... | [
"numpy.ones_like",
"numpy.eye",
"numpy.asarray",
"numpy.ndim",
"numpy.zeros",
"numpy.einsum",
"numpy.cos",
"numpy.concatenate",
"numpy.sin",
"numpy.shape",
"numpy.zeros_like"
] | [((96, 109), 'numpy.asarray', 'np.asarray', (['x'], {}), '(x)\n', (106, 109), True, 'import numpy as np\n'), ((118, 142), 'numpy.ones_like', 'np.ones_like', (['x[..., :1]'], {}), '(x[..., :1])\n', (130, 142), True, 'import numpy as np\n'), ((154, 185), 'numpy.concatenate', 'np.concatenate', (['[x, o]'], {'axis': '(-1)'... |
# coding: utf-8
# In[1]:
get_ipython().run_cell_magic('javascript', '', '<!-- Ignore this block -->\nIPython.OutputArea.prototype._should_scroll = function(lines) {\n return false;\n}')
# # Data preprocessing
# 1. convert any non-numeric values to numeric values.
# 2. If required drop out the rows with missi... | [
"matplotlib.pyplot.grid",
"pandas.read_csv",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.close",
"numpy.dot",
"numpy.random.seed",
"pandas.DataFrame",
"numpy.random.random_sample",
"numpy.square",
"matplotlib.pyplot.title",
"warnings.f... | [((734, 767), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (757, 767), False, 'import warnings\n'), ((8116, 8184), 'pandas.read_csv', 'pd.read_csv', (["(directoryPath + '/airq402.dat')"], {'sep': '"""\\\\s+"""', 'header': 'None'}), "(directoryPath + '/airq402.dat', sep='... |
from __future__ import print_function
from measurement.base import MeasureBase, BidimensionalMeasure
from measurement.utils import get_all_measures
for measure in get_all_measures():
classname = measure.__name__
print(classname)
print('-' * len(classname))
print()
if issubclass(measure, MeasureBas... | [
"measurement.utils.get_all_measures"
] | [((165, 183), 'measurement.utils.get_all_measures', 'get_all_measures', ([], {}), '()\n', (181, 183), False, 'from measurement.utils import get_all_measures\n')] |
#coding=utf-8
import tensorflow as tf
import tfop
contrib_image = tf.contrib.image
def blend(image1, image2, factor):
"""Blend image1 and image2 using 'factor'.
Factor can be above 0.0. A value of 0.0 means only image1 is used.
A value of 1.0 means only image2 is used. A value between 0.0 and
1.0 means we ... | [
"tensorflow.tile",
"tensorflow.equal",
"tensorflow.shape",
"tensorflow.transpose",
"tensorflow.reduce_sum",
"tensorflow.histogram_fixed_width",
"tensorflow.ones_like",
"tensorflow.cast",
"tensorflow.slice",
"tensorflow.reduce_min",
"tfop.get_bboxes_from_mask",
"tensorflow.not_equal",
"tensor... | [((883, 902), 'tensorflow.to_float', 'tf.to_float', (['image1'], {}), '(image1)\n', (894, 902), True, 'import tensorflow as tf\n'), ((914, 933), 'tensorflow.to_float', 'tf.to_float', (['image2'], {}), '(image2)\n', (925, 933), True, 'import tensorflow as tf\n'), ((2188, 2203), 'tensorflow.shape', 'tf.shape', (['image']... |
# -*- coding: utf-8 -*-
# Copyright (c) 2017, SELCO and contributors
# For license information, please see license.txt
# -*- coding: utf-8 -*-
# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and contributors
# For license information, please see license.txt
from __future__ import unicode_literals
import frappe
fr... | [
"frappe.db.get_value",
"frappe.new_doc"
] | [((454, 542), 'frappe.db.get_value', 'frappe.db.get_value', (['"""Branch"""', 'self.selco_branch', '"""selco_cash_payment_naming_series"""'], {}), "('Branch', self.selco_branch,\n 'selco_cash_payment_naming_series')\n", (473, 542), False, 'import frappe\n'), ((576, 607), 'frappe.new_doc', 'frappe.new_doc', (['"""Jou... |
from django.db import models
from django.utils.translation import ugettext_lazy as _
class Feature(models.Model):
name = models.CharField('Feature Name', max_length=50, blank=True, unique=True)
description = models.CharField('Feature Description', max_length=150, blank=True)
info_link = models.CharField('... | [
"django.db.models.EmailField",
"django.db.models.FloatField",
"django.utils.translation.ugettext_lazy",
"django.db.models.ForeignKey",
"django.db.models.NullBooleanField",
"django.db.models.ManyToManyField",
"django.db.models.DateTimeField",
"django.db.models.CharField"
] | [((127, 199), 'django.db.models.CharField', 'models.CharField', (['"""Feature Name"""'], {'max_length': '(50)', 'blank': '(True)', 'unique': '(True)'}), "('Feature Name', max_length=50, blank=True, unique=True)\n", (143, 199), False, 'from django.db import models\n'), ((218, 285), 'django.db.models.CharField', 'models.... |
'''
Script to loop through all baseballrefernce.com pages and store the HTML in data frames
'''
import numpy as np
import pandas as pd
from bs4 import BeautifulSoup
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
from selenium.common.exceptions import TimeoutException
import requests
imp... | [
"pandas.DataFrame",
"selenium.webdriver.Chrome",
"time.time",
"pandas.read_csv"
] | [((3378, 3408), 'selenium.webdriver.Chrome', 'webdriver.Chrome', (['chromedriver'], {}), '(chromedriver)\n', (3394, 3408), False, 'from selenium import webdriver\n'), ((1348, 1394), 'pandas.DataFrame', 'pd.DataFrame', ([], {'columns': "['year', 'link', 'html']"}), "(columns=['year', 'link', 'html'])\n", (1360, 1394), T... |
import sys
from amr import JAMR_CorpusReader
if __name__ == '__main__':
args = sys.argv
infile = args[1]
cr = JAMR_CorpusReader()
cr.load_amrs(infile)
gold_amrs = cr.amrs
for sentidx, amr in enumerate(gold_amrs):
for n in amr.alignments:
print(str(sentidx)+'\t'+n+'\t'+','... | [
"amr.JAMR_CorpusReader"
] | [((125, 144), 'amr.JAMR_CorpusReader', 'JAMR_CorpusReader', ([], {}), '()\n', (142, 144), False, 'from amr import JAMR_CorpusReader\n')] |
import sys
from graphqlclient import GraphQLClient
from random import randint
import codecs, json
client = GraphQLClient("https://net.ton.dev/graphql")
mutation_template = '''
mutation {
postRequests(requests:[{id:"%(request_id)s",body:"%(base64_boc)s",expireAt:2e12}])
}
'''
def send_boc(client, boc):
data = {'re... | [
"codecs.encode",
"random.randint",
"graphqlclient.GraphQLClient"
] | [((108, 152), 'graphqlclient.GraphQLClient', 'GraphQLClient', (['"""https://net.ton.dev/graphql"""'], {}), "('https://net.ton.dev/graphql')\n", (121, 152), False, 'from graphqlclient import GraphQLClient\n'), ((334, 353), 'random.randint', 'randint', (['(0)', '(2 ** 32)'], {}), '(0, 2 ** 32)\n', (341, 353), False, 'fro... |
# -*- coding: utf-8 -*-
from __future__ import absolute_import, unicode_literals
import pytest
from demorphy.tokenizer import tokenize
class TestTokenizer:
def test_split_simple(self):
assert tokenize(u"Ich bin krank") == [u"Ich", u"bin", u"krank"]
def test_split_hypen(self):
assert tokenize(... | [
"demorphy.tokenizer.tokenize"
] | [((206, 232), 'demorphy.tokenizer.tokenize', 'tokenize', (['u"""Ich bin krank"""'], {}), "(u'Ich bin krank')\n", (214, 232), False, 'from demorphy.tokenizer import tokenize\n'), ((311, 361), 'demorphy.tokenizer.tokenize', 'tokenize', (['u"""Wir können uns auf der U-Bahn treffen"""'], {}), "(u'Wir können uns auf der U-B... |
import os
from django.apps import AppConfig
class OsfOauth2AdapterConfig(AppConfig):
name = 'osf_oauth2_adapter'
# staging by default so people don't have to run OSF to use this.
osf_api_url = os.environ.get('OSF_API_URL', 'https://staging-api.osf.io').rstrip('/') + '/'
osf_accounts_url = os.environ.... | [
"os.environ.get"
] | [((208, 267), 'os.environ.get', 'os.environ.get', (['"""OSF_API_URL"""', '"""https://staging-api.osf.io"""'], {}), "('OSF_API_URL', 'https://staging-api.osf.io')\n", (222, 267), False, 'import os\n'), ((309, 378), 'os.environ.get', 'os.environ.get', (['"""OSF_ACCOUNTS_URL"""', '"""https://staging-accounts.osf.io"""'], ... |
from typing import Tuple, Type
import numpy as np
from pyjackson.core import ArgList, Field
from pyjackson.generics import Serializer
from ebonite.core.analyzer.base import CanIsAMustHookMixin, TypeHookMixin
from ebonite.core.analyzer.dataset import DatasetHook
from ebonite.core.objects.dataset_type import DatasetTyp... | [
"numpy.array",
"pyjackson.core.Field",
"ebonite.runtime.interface.typing.SizedTypedListType"
] | [((3677, 3714), 'ebonite.runtime.interface.typing.SizedTypedListType', 'SizedTypedListType', (['shape[0]', 'subtype'], {}), '(shape[0], subtype)\n', (3695, 3714), False, 'from ebonite.runtime.interface.typing import ListTypeWithSpec, SizedTypedListType\n'), ((3870, 3883), 'numpy.array', 'np.array', (['obj'], {}), '(obj... |
import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
class MAE(nn.Module):
def __init__(self):
super(MAE, self).__init__()
def forward(self, outputs, target, *args):
val_pixels = (target > 0).float().cuda()
err = torch.abs(target * val_pixels - outputs ... | [
"torch.abs",
"torch.nn.functional.l1_loss",
"torch.nn.functional.mse_loss",
"torch.mean",
"torch.max",
"torch.sqrt",
"torch.nn.functional.avg_pool2d",
"torch.numel"
] | [((280, 333), 'torch.abs', 'torch.abs', (['(target * val_pixels - outputs * val_pixels)'], {}), '(target * val_pixels - outputs * val_pixels)\n', (289, 333), False, 'import torch\n'), ((508, 530), 'torch.mean', 'torch.mean', (['(loss / cnt)'], {}), '(loss / cnt)\n', (518, 530), False, 'import torch\n'), ((1186, 1299), ... |
import dash
import dash_core_components as dcc
import dash_html_components as html
from data_gather import plot_line_graph
from run_save_model import predict_line_graph, train_save_load
from generating_data import generate_sensors_data
# generating sensors data
generate_sensors_data()
train_save_load()
external_style... | [
"run_save_model.train_save_load",
"generating_data.generate_sensors_data",
"run_save_model.predict_line_graph",
"data_gather.plot_line_graph",
"dash.Dash"
] | [((263, 286), 'generating_data.generate_sensors_data', 'generate_sensors_data', ([], {}), '()\n', (284, 286), False, 'from generating_data import generate_sensors_data\n'), ((287, 304), 'run_save_model.train_save_load', 'train_save_load', ([], {}), '()\n', (302, 304), False, 'from run_save_model import predict_line_gra... |
import socket
import json
class udp_emit:
def __init__(self, host, port):
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.sock.connect((host, port))
def emit(self, datadict):
try:
self.sock.sendall(json.dumps(datadict).encode())
... | [
"json.dumps",
"socket.socket"
] | [((99, 147), 'socket.socket', 'socket.socket', (['socket.AF_INET', 'socket.SOCK_DGRAM'], {}), '(socket.AF_INET, socket.SOCK_DGRAM)\n', (112, 147), False, 'import socket\n'), ((283, 303), 'json.dumps', 'json.dumps', (['datadict'], {}), '(datadict)\n', (293, 303), False, 'import json\n')] |
import sys;
from queue import Queue
from multiprocessing.managers import BaseManager
import etl;
import json
import extends;
import time;
authkey= "etlpy".encode('utf-8')
timeout=1;
rpc_port=8888
class ETLJob:
def __init__(self,project,jobname,config,id):
self.project= project;
self.jobname=jobnam... | [
"etl.parallel_reduce",
"multiprocessing.managers.BaseManager.register",
"etl.convert_dict",
"time.sleep",
"etl.LoadProject_dict",
"queue.Queue",
"etl.parallel_map",
"multiprocessing.managers.BaseManager"
] | [((610, 617), 'queue.Queue', 'Queue', ([], {}), '()\n', (615, 617), False, 'from queue import Queue\n'), ((670, 677), 'queue.Queue', 'Queue', ([], {}), '()\n', (675, 677), False, 'from queue import Queue\n'), ((996, 1089), 'multiprocessing.managers.BaseManager.register', 'BaseManager.register', (['"""get_dispatched_job... |
import json
import argparse
import pprint
import csv
parser = argparse.ArgumentParser(description="parse squad qa into scv")
parser.add_argument("--input", type=str)
parser.add_argument("--output", type=str)
args = parser.parse_args()
input_file = args.input
output_file = args.output
with open(input_file, 'r') as f:
... | [
"json.load",
"csv.writer",
"pprint.pprint",
"argparse.ArgumentParser"
] | [((63, 125), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""parse squad qa into scv"""'}), "(description='parse squad qa into scv')\n", (86, 125), False, 'import argparse\n'), ((345, 399), 'pprint.pprint', 'pprint.pprint', (["data['data'][0]['paragraphs'][0]['qas']"], {}), "(data['data']... |
from __future__ import unicode_literals
import logging
import re
from django.contrib import messages
from django.db import ProgrammingError
from django.http import HttpResponse, HttpResponseForbidden, HttpResponseRedirect
from django.shortcuts import redirect
from django.utils.translation import ugettext_lazy as _
fr... | [
"logging.getLogger",
"django.http.HttpResponseRedirect",
"django.utils.translation.ugettext_lazy",
"django.http.HttpResponse",
"django.shortcuts.redirect",
"re.search"
] | [((563, 608), 'logging.getLogger', 'logging.getLogger', (['"""boardinghouse.middleware"""'], {}), "('boardinghouse.middleware')\n", (580, 608), False, 'import logging\n'), ((5534, 5569), 'django.utils.translation.ugettext_lazy', '_', (['"""You may not select that schema"""'], {}), "('You may not select that schema')\n"... |
import torch.nn as nn
import numpy as np
from collections import OrderedDict
from torchmeta.modules import (MetaModule, MetaConv2d, MetaBatchNorm2d,
MetaSequential, MetaLinear)
import torch
def conv_block(in_channels, out_channels, **kwargs):
return MetaSequential(OrderedDict([
... | [
"torch.nn.ConvTranspose2d",
"torch.nn.Sigmoid",
"torch.nn.ReLU",
"math.floor",
"torch.nn.Dropout2d",
"torch.exp",
"torch.nn.Conv2d",
"torch.from_numpy",
"torchmeta.modules.MetaConv2d",
"torch.randn_like",
"torch.nn.Linear",
"torchmeta.modules.MetaLinear",
"torch.reshape"
] | [((2255, 2304), 'torchmeta.modules.MetaLinear', 'MetaLinear', (['feature_size', 'out_features'], {'bias': '(True)'}), '(feature_size, out_features, bias=True)\n', (2265, 2304), False, 'from torchmeta.modules import MetaModule, MetaConv2d, MetaBatchNorm2d, MetaSequential, MetaLinear\n'), ((3610, 3659), 'torchmeta.module... |
from setuptools import setup
setup(
name = 'datoms',
version = '0.1.0',
description = 'A simplistic, Datomic inspired, SQLite backed, REST influenced, schemaless auditable facts storage.',
py_modules = ['datoms'],
license = 'unlicense',
author = '<NAME>',
author_email = '<EMAIL>',
url ... | [
"setuptools.setup"
] | [((31, 350), 'setuptools.setup', 'setup', ([], {'name': '"""datoms"""', 'version': '"""0.1.0"""', 'description': '"""A simplistic, Datomic inspired, SQLite backed, REST influenced, schemaless auditable facts storage."""', 'py_modules': "['datoms']", 'license': '"""unlicense"""', 'author': '"""<NAME>"""', 'author_email'... |
# Copyright 2021 <NAME>. 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 agreed to... | [
"argparse.ArgumentParser",
"python.input.cifar100_input_pipeline.Cifar100",
"os.path.splitext",
"numpy.array",
"python.input.cifar10_input_pipeline.Cifar10",
"python.input.smallNORB_input_pipeline.smallNORB",
"tensorflow.distribute.MirroredStrategy",
"python.input.MNIST_input_pipeline.MNIST",
"os.wa... | [((1302, 1318), 'os.walk', 'os.walk', (['log_dir'], {}), '(log_dir)\n', (1309, 1318), False, 'import os\n'), ((1817, 1849), 'tensorflow.distribute.MirroredStrategy', 'tf.distribute.MirroredStrategy', ([], {}), '()\n', (1847, 1849), True, 'import tensorflow as tf\n'), ((2845, 2870), 'argparse.ArgumentParser', 'argparse.... |
from __future__ import division
from collections import defaultdict
import itertools
import sys
import os
import sqlite3
import click
from kSpider2.click_context import cli
import glob
class kClusters:
source = []
target = []
source2 = []
target2 = []
seq_to_kmers = dict()
names_map = dict()
... | [
"click.option",
"collections.defaultdict",
"os.path.basename",
"kSpider2.click_context.cli.command",
"click.FloatRange"
] | [((6889, 6933), 'kSpider2.click_context.cli.command', 'cli.command', ([], {'name': '"""cluster"""', 'help_priority': '(5)'}), "(name='cluster', help_priority=5)\n", (6900, 6933), False, 'from kSpider2.click_context import cli\n'), ((7111, 7239), 'click.option', 'click.option', (['"""-i"""', '"""--index-prefix"""', '"""... |
import pandas as pd
def parse_bed(log_file, out):
print("chrom\tleft_start\tleft_end\tright_start\tright_end", file=out)
for data_primers in pd.read_csv(
snakemake.input[0],
sep="\t",
header=None,
chunksize=chunksize,
usecols=[0, 1, 2, 5],
):
for row in data... | [
"pandas.read_csv"
] | [((151, 252), 'pandas.read_csv', 'pd.read_csv', (['snakemake.input[0]'], {'sep': '"""\t"""', 'header': 'None', 'chunksize': 'chunksize', 'usecols': '[0, 1, 2, 5]'}), "(snakemake.input[0], sep='\\t', header=None, chunksize=chunksize,\n usecols=[0, 1, 2, 5])\n", (162, 252), True, 'import pandas as pd\n'), ((1054, 1161... |
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.colors as colors
class MapColorControl():
def __init__(self, colour_scheme, map_normalization,data):
self.colors = plt.get_cmap(colour_scheme)(range(256))[:,:3]
self.data = data
if self.data.min() <= 0:
self.d... | [
"matplotlib.pyplot.get_cmap"
] | [((198, 225), 'matplotlib.pyplot.get_cmap', 'plt.get_cmap', (['colour_scheme'], {}), '(colour_scheme)\n', (210, 225), True, 'import matplotlib.pyplot as plt\n')] |
from django.conf.urls import patterns, url
from lattice.views import (lattices)
from lattice.views import (saveLatticeInfo, saveLattice)
from lattice.views import (saveModel)
from lattice.views import (lattice_home, lattice_content_home, lattice_content_search, lattice_content_list, lattice_content_model_list, lattice... | [
"django.conf.urls.url"
] | [((594, 638), 'django.conf.urls.url', 'url', (['"""^lattice/$"""', 'lattices'], {'name': '"""lattices"""'}), "('^lattice/$', lattices, name='lattices')\n", (597, 638), False, 'from django.conf.urls import patterns, url\n'), ((662, 736), 'django.conf.urls.url', 'url', (['"""^lattice/savelatticeinfo/$"""', 'saveLatticeIn... |
import unittest
import torch
from parameterized import parameterized
from torecsys.losses import *
device = 'cuda:0' if torch.cuda.is_available() else 'cpu'
class AdaptiveHingeLossTestCase(unittest.TestCase):
@parameterized.expand([
(4, 32,),
(16, 16,),
(32, 4,),
])
def test_for... | [
"parameterized.parameterized.expand",
"torch.randint",
"torch.cuda.is_available",
"unittest.main",
"torch.Size",
"torch.rand"
] | [((123, 148), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {}), '()\n', (146, 148), False, 'import torch\n'), ((219, 269), 'parameterized.parameterized.expand', 'parameterized.expand', (['[(4, 32), (16, 16), (32, 4)]'], {}), '([(4, 32), (16, 16), (32, 4)])\n', (239, 269), False, 'from parameterized import... |
import torch, math, copy
import scipy.sparse as sp
import numpy as np
from torch.nn.modules.module import Module
import torch.nn as nn
from torch.nn.parameter import Parameter
def normalize(adj, device='cpu'):
if isinstance(adj, torch.Tensor):
adj_ = adj.to(device)
elif isinstance(adj, sp.c... | [
"scipy.sparse.eye",
"torch.eye",
"torch.FloatTensor",
"torch.pow",
"torch.from_numpy",
"torch.mm",
"torch.tensor",
"numpy.stack",
"scipy.sparse.coo_matrix",
"torch.spmm",
"scipy.sparse.diags",
"copy.copy",
"torch.Size",
"numpy.float_power"
] | [((1654, 1676), 'scipy.sparse.coo_matrix', 'sp.coo_matrix', (['adj_def'], {}), '(adj_def)\n', (1667, 1676), True, 'import scipy.sparse as sp\n'), ((1899, 1918), 'scipy.sparse.diags', 'sp.diags', (['norm_unit'], {}), '(norm_unit)\n', (1907, 1918), True, 'import scipy.sparse as sp\n'), ((1942, 1972), 'copy.copy', 'copy.c... |
import os
from sqlite3 import dbapi2 as sqlite3
class GarageDb:
def __init__(self, instance_path, resource_path):
self.db_file = os.path.join(instance_path, 'history.db')
self.init_file = os.path.join(resource_path, 'schema.sql')
# Run init script to ensure database structure
conn ... | [
"sqlite3.dbapi2.connect",
"os.path.join"
] | [((142, 183), 'os.path.join', 'os.path.join', (['instance_path', '"""history.db"""'], {}), "(instance_path, 'history.db')\n", (154, 183), False, 'import os\n'), ((209, 250), 'os.path.join', 'os.path.join', (['resource_path', '"""schema.sql"""'], {}), "(resource_path, 'schema.sql')\n", (221, 250), False, 'import os\n'),... |
from flask_restful import Resource
from flask import request
class Shutdown(Resource):
def get(self):
shutdown = request.environ.get('werkzeug.server.shutdown')
if shutdown is None:
raise RuntimeError('Not running with the Werkzeug Server')
shutdown()
return 'Server shu... | [
"flask.request.environ.get"
] | [((127, 174), 'flask.request.environ.get', 'request.environ.get', (['"""werkzeug.server.shutdown"""'], {}), "('werkzeug.server.shutdown')\n", (146, 174), False, 'from flask import request\n')] |