code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
from river.compat import River2SKLRegressor, River2SKLClassifier
import river.linear_model as linear_model
import typing
from river import optim
__all__ = [
"ALMAClassifier",
"PAClassifier",
"PARegressor",
"SoftmaxRegression",
"LinearRegression",
"LogisticRegression",
"Perceptron",
]
cla... | [
"river.linear_model.pa.PARegressor",
"river.linear_model.pa.PAClassifier",
"river.linear_model.Perceptron",
"river.linear_model.softmax.SoftmaxRegression",
"river.linear_model.LogisticRegression",
"river.linear_model.alma.ALMAClassifier",
"river.linear_model.LinearRegression"
] | [((780, 894), 'river.linear_model.LogisticRegression', 'linear_model.LogisticRegression', (['optimizer', 'loss', 'l2', 'intercept_init', 'intercept_lr', 'clip_gradient', 'initializer'], {}), '(optimizer, loss, l2, intercept_init,\n intercept_lr, clip_gradient, initializer)\n', (811, 894), True, 'import river.linear_... |
from django.shortcuts import render
from .models import Prices
from .functions.nfttoday import ticketssoldlast24h, ticketsscannedlast24h, \
eventslast24h
from .functions.nftmonthly import get_last30daysinteractions
from .functions.eventsmonthly import get_last30daysevents
from .functions.eventsthirtydays import eve... | [
"django.shortcuts.render"
] | [((942, 1086), 'django.shortcuts.render', 'render', (['request', '"""NFTInfo/interactions.html"""', "{'last30daysscperiodnames': last30daysscperiodnames, 'last30daysscvalues':\n last30daysscvalues}"], {}), "(request, 'NFTInfo/interactions.html', {'last30daysscperiodnames':\n last30daysscperiodnames, 'last30dayssc... |
import numpy as np
from scipy.sparse.csgraph import connected_components as inner_conn_comp
def dot_matrix(X):
X_norm = X - np.mean(X, axis=0)
X_norm /= np.max(np.linalg.norm(X, axis=1))
return X_norm.dot(X_norm.T)
def connected_components(sym_mat, thresh=1e-4):
binary_mat = sym_mat > sym_mat.max() ... | [
"numpy.abs",
"numpy.mean",
"numpy.log10",
"scipy.sparse.csgraph.connected_components",
"numpy.linalg.norm"
] | [((350, 413), 'scipy.sparse.csgraph.connected_components', 'inner_conn_comp', (['binary_mat'], {'directed': '(False)', 'return_labels': '(True)'}), '(binary_mat, directed=False, return_labels=True)\n', (365, 413), True, 'from scipy.sparse.csgraph import connected_components as inner_conn_comp\n'), ((555, 566), 'numpy.a... |
#!/usr/bin/env python
import argparse
import os
import yaml
DESCRIPTION = """This tool is used to add documentation data into the
templates from a doc data file."""
def parse_args():
parser = argparse.ArgumentParser(description=DESCRIPTION)
parser.add_argument('doc_data_file', action='store',
... | [
"os.listdir",
"yaml.safe_dump",
"argparse.ArgumentParser",
"os.path.join",
"yaml.safe_load"
] | [((201, 249), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': 'DESCRIPTION'}), '(description=DESCRIPTION)\n', (224, 249), False, 'import argparse\n'), ((681, 710), 'yaml.safe_load', 'yaml.safe_load', (['doc_data_yaml'], {}), '(doc_data_yaml)\n', (695, 710), False, 'import yaml\n'), ((804, 833... |
"Program Exits"
'sys Module Exits'
import sys
# sys.exit(N) # exit with status N, else exits on end of script
# print('This line will not be printed')
"""
Interestingly, this call really just raises the built-in SystemExit exception. Because of
this, we can catch it as usual to in... | [
"sys.exit"
] | [((432, 442), 'sys.exit', 'sys.exit', ([], {}), '()\n', (440, 442), False, 'import sys\n')] |
"""Tuner class. Currently a minimum working demo."""
import hyperopt
import random
from matchzoo import engine
def tune(model: engine.BaseModel, max_evals: int = 32) -> list:
"""
Tune the `model` `max_evals` times.
Construct a hyper parameter searching space by extracting all parameters
in `model` ... | [
"hyperopt.fmin",
"random.random",
"hyperopt.Trials"
] | [((909, 926), 'hyperopt.Trials', 'hyperopt.Trials', ([], {}), '()\n', (924, 926), False, 'import hyperopt\n'), ((1292, 1423), 'hyperopt.fmin', 'hyperopt.fmin', ([], {'fn': '_test_wrapper', 'space': 'model.params.hyper_space', 'algo': 'hyperopt.tpe.suggest', 'max_evals': 'max_evals', 'trials': 'trials'}), '(fn=_test_wra... |
import os
import sys
from distutils.command.build_ext import build_ext
from distutils.core import Extension
from distutils.errors import CCompilerError
from distutils.errors import DistutilsExecError
from distutils.errors import DistutilsPlatformError
# C Extensions
with_extensions = os.getenv("PENDULUM_EXTENSIONS",... | [
"distutils.core.Extension",
"distutils.command.build_ext.build_ext.build_extension",
"distutils.command.build_ext.build_ext.run",
"os.getenv"
] | [((288, 326), 'os.getenv', 'os.getenv', (['"""PENDULUM_EXTENSIONS"""', 'None'], {}), "('PENDULUM_EXTENSIONS', None)\n", (297, 326), False, 'import os\n'), ((566, 645), 'distutils.core.Extension', 'Extension', (['"""pendulum._extensions._helpers"""', "['pendulum/_extensions/_helpers.c']"], {}), "('pendulum._extensions._... |
import dsmirai.client_broker as client_broker
import dsmirai.intent_based_networking as intent_based_networking
from operator import itemgetter
from dsmirai.persistent_model import helpers
from dsmirai.persistent_model import dashboard_helper
import dsmirai.onos_helpers as onos_helpers
"""
Code communication: migra... | [
"dsmirai.persistent_model.helpers.insert_entry",
"dsmirai.intent_based_networking.IntentBasedNetworking",
"dsmirai.persistent_model.helpers.matching",
"dsmirai.persistent_model.helpers.get_overlay_port",
"dsmirai.persistent_model.helpers.matching_ip",
"dsmirai.persistent_model.helpers.name_control",
"ds... | [((556, 594), 'dsmirai.client_broker.ClientBroker', 'client_broker.ClientBroker', (['queue_name'], {}), '(queue_name)\n', (582, 594), True, 'import dsmirai.client_broker as client_broker\n'), ((606, 632), 'dsmirai.onos_helpers.OnosHelpers', 'onos_helpers.OnosHelpers', ([], {}), '()\n', (630, 632), True, 'import dsmirai... |
'''
BSD 3-Clause License
Copyright (c) 2018, <NAME>
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
* Redistributions of source code must retain the above copyright notice, this
list of conditions an... | [
"random.Random"
] | [((1586, 1601), 'random.Random', 'random.Random', ([], {}), '()\n', (1599, 1601), False, 'import random\n')] |
from django.core.management.base import BaseCommand
from account.utils import send_bulk_reminders
class Command(BaseCommand):
help = 'Send reminders to users who have not signed in today'
def handle(self, *args, **options):
self.stdout.write('Preparing to send reminder emails...')
send_bulk_... | [
"account.utils.send_bulk_reminders"
] | [((310, 331), 'account.utils.send_bulk_reminders', 'send_bulk_reminders', ([], {}), '()\n', (329, 331), False, 'from account.utils import send_bulk_reminders\n')] |
from django.http import HttpResponse
from django.db.models import Q, Sum, Count
from django.shortcuts import render, get_object_or_404
from django.contrib.auth.decorators import login_required
from django.utils import timezone
from .models import Account
from .models import AccountAddon
from ..productofferings.models ... | [
"django.shortcuts.render",
"django.http.HttpResponse",
"django.shortcuts.get_object_or_404",
"django.utils.timezone.now",
"django.db.models.Q"
] | [((759, 825), 'django.shortcuts.render', 'render', (['request', '"""accounts/index.html"""', "{'accounts': accounts_obj}"], {}), "(request, 'accounts/index.html', {'accounts': accounts_obj})\n", (765, 825), False, 'from django.shortcuts import render, get_object_or_404\n'), ((863, 905), 'django.http.HttpResponse', 'Htt... |
"""
:author: hxq, shy
"""
import numpy as np
from mindspore import ops
DIV = ops.Div()
def l2_regularizer(input_x, axis=1):
"""
:param input_x:
:param axis:
:return:
"""
return DIV(input_x, ((input_x**2).sum(axis=axis, keepdims=True))**0.5)
def set_rng_seed(seed):
"""
:param seed:
... | [
"mindspore.ops.Div",
"numpy.random.seed"
] | [((78, 87), 'mindspore.ops.Div', 'ops.Div', ([], {}), '()\n', (85, 87), False, 'from mindspore import ops\n'), ((344, 364), 'numpy.random.seed', 'np.random.seed', (['seed'], {}), '(seed)\n', (358, 364), True, 'import numpy as np\n')] |
#!/usr/bin/env python
# This is designed as a reference implementation of the UVHDF5 specification. It shows a conversion of SMA data in the UVFITS format to the UVHDF5 format.
import argparse
parser = argparse.ArgumentParser(description="Convert SMA FITS files into UVHDF5 file format.")
parser.add_argument("FITS", ... | [
"numpy.tile",
"argparse.ArgumentParser",
"numpy.any",
"h5py.File",
"numpy.squeeze",
"astropy.io.fits.open",
"numpy.arange"
] | [((205, 296), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Convert SMA FITS files into UVHDF5 file format."""'}), "(description=\n 'Convert SMA FITS files into UVHDF5 file format.')\n", (228, 296), False, 'import argparse\n'), ((580, 600), 'astropy.io.fits.open', 'fits.open', (['arg... |
# -*- coding: utf-8 -*-
import sys
reload(sys)
sys.setdefaultencoding("utf-8")
import os
import json
from PySide.QtCore import *
from PySide.QtGui import *
class SceneController(QObject):
def __init__(self):
super(SceneController,self).__init__()
self.path = ""
self.view = None
self.needSave = False
def... | [
"sys.setdefaultencoding"
] | [((47, 78), 'sys.setdefaultencoding', 'sys.setdefaultencoding', (['"""utf-8"""'], {}), "('utf-8')\n", (69, 78), False, 'import sys\n')] |
import unittest
from tests.base import Base
from sparkquantum.dtqw.mesh.percolation.percolation import is_percolation
from sparkquantum.dtqw.mesh.percolation.permanent import Permanent, is_permanent
# TODO: implement test_generate
class TestPermanent(Base):
def setUp(self):
super().setUp()
self.... | [
"unittest.main",
"sparkquantum.dtqw.mesh.percolation.permanent.Permanent",
"sparkquantum.dtqw.mesh.percolation.permanent.is_permanent",
"sparkquantum.dtqw.mesh.percolation.percolation.is_percolation"
] | [((880, 895), 'unittest.main', 'unittest.main', ([], {}), '()\n', (893, 895), False, 'import unittest\n'), ((362, 383), 'sparkquantum.dtqw.mesh.percolation.permanent.Permanent', 'Permanent', (['self.edges'], {}), '(self.edges)\n', (371, 383), False, 'from sparkquantum.dtqw.mesh.percolation.permanent import Permanent, i... |
from collections import deque
class Solution(object):
def isValid(self, s):
"""
:type s: str
:rtype: bool
"""
d = deque([])
started = False
opening = ['[', '{', '(']
closing = [']', '}', ')']
pairs = {']': '[', '}': '{', ')': '('}
op... | [
"collections.deque"
] | [((159, 168), 'collections.deque', 'deque', (['[]'], {}), '([])\n', (164, 168), False, 'from collections import deque\n')] |
# -*- coding: utf-8 -*-
"""Base pytest configuration file."""
import os
import shutil
import sys
# clear log directory
def clear_log_directory():
"""Clear the App log directory."""
log_directory = 'log'
if os.path.isdir(log_directory):
print('Clearing log directory.')
for log_file in os.li... | [
"os.path.getsize",
"sys.path.insert",
"os.listdir",
"os.access",
"os.path.join",
"os.getcwd",
"os.path.isfile",
"sys.path.remove",
"os.path.isdir",
"shutil.rmtree",
"os.walk",
"os.remove"
] | [((220, 248), 'os.path.isdir', 'os.path.isdir', (['log_directory'], {}), '(log_directory)\n', (233, 248), False, 'import os\n'), ((1454, 1465), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (1463, 1465), False, 'import os\n'), ((1714, 1745), 'os.path.join', 'os.path.join', (['cwd', '"""lib_latest"""'], {}), "(cwd, 'lib_l... |
from __future__ import print_function
import time
import subprocess
import socket
from config import ES_HOST_TUNNEL_CFG
es_local_tunnel_port = 9209
def port_open(host, port):
s = socket.socket()
try:
s.connect((host, port))
return True
except socket.error:
return False
class ES... | [
"subprocess.Popen",
"time.sleep",
"socket.socket"
] | [((187, 202), 'socket.socket', 'socket.socket', ([], {}), '()\n', (200, 202), False, 'import socket\n'), ((1098, 1111), 'time.sleep', 'time.sleep', (['(2)'], {}), '(2)\n', (1108, 1111), False, 'import time\n'), ((551, 575), 'subprocess.Popen', 'subprocess.Popen', (['"""true"""'], {}), "('true')\n", (567, 575), False, '... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import h5py
import collections as cl
import numpy as np
from isce3 import antenna as ant
class AntennaParser:
"""Class for parsing NISAR Antenna HDF5 file.
Parameters
----------
filename : str
filename of HDF5 antenna file.
Attributes
... | [
"numpy.ceil",
"collections.namedtuple",
"h5py.File",
"numpy.linspace",
"numpy.zeros",
"numpy.interp"
] | [((1036, 1093), 'h5py.File', 'h5py.File', (['filename'], {'mode': '"""r"""', 'libver': '"""latest"""', 'swmr': '(True)'}), "(filename, mode='r', libver='latest', swmr=True)\n", (1045, 1093), False, 'import h5py\n'), ((7225, 7287), 'numpy.linspace', 'np.linspace', (['beam_first.angle[0]', 'beam_last.angle[-1]', 'num_ang... |
#! /usr/bin/env python
import setuptools
__name__ == "__main__" and setuptools.setup(
use_scm_version=True, setup_requires=["setuptools-scm"]
)
| [
"setuptools.setup"
] | [((72, 145), 'setuptools.setup', 'setuptools.setup', ([], {'use_scm_version': '(True)', 'setup_requires': "['setuptools-scm']"}), "(use_scm_version=True, setup_requires=['setuptools-scm'])\n", (88, 145), False, 'import setuptools\n')] |
#!/usr/bin/python3
import turtle
def halfcircle(N, a=1):
for i in range(180):
turtle.forward(N)
turtle.left(a)
return 0
def main() -> int:
turtle.shape("turtle")
turtle.tracer(False)
turtle.penup()
turtle.goto(0,-200)
turtle.pendown()
turtle.begin_fill()
halfcircle... | [
"turtle.begin_fill",
"turtle.shape",
"turtle.pendown",
"turtle.penup",
"turtle.width",
"turtle.tracer",
"turtle.color",
"turtle.forward",
"turtle.right",
"turtle.goto",
"turtle.left",
"turtle.mainloop",
"turtle.end_fill"
] | [((170, 192), 'turtle.shape', 'turtle.shape', (['"""turtle"""'], {}), "('turtle')\n", (182, 192), False, 'import turtle\n'), ((197, 217), 'turtle.tracer', 'turtle.tracer', (['(False)'], {}), '(False)\n', (210, 217), False, 'import turtle\n'), ((222, 236), 'turtle.penup', 'turtle.penup', ([], {}), '()\n', (234, 236), Fa... |
from django.db import models
from utils.models import CreateUpdateTracker, nb, GetOrNoneManager
from taggit.managers import TaggableManager
# Create your models here.
class Bookmark(CreateUpdateTracker):
user = models.ForeignKey("tgbot.User", on_delete=models.CASCADE)
url = models.URLField(**nb)
tags = ... | [
"django.db.models.URLField",
"taggit.managers.TaggableManager",
"django.db.models.ForeignKey"
] | [((218, 275), 'django.db.models.ForeignKey', 'models.ForeignKey', (['"""tgbot.User"""'], {'on_delete': 'models.CASCADE'}), "('tgbot.User', on_delete=models.CASCADE)\n", (235, 275), False, 'from django.db import models\n'), ((286, 307), 'django.db.models.URLField', 'models.URLField', ([], {}), '(**nb)\n', (301, 307), Fa... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Aug 12 15:21:31 2019
@author: qinayan
"""
import os
import numpy as np
def find_DEM_bn(eta):
#-------------
# find the boundary index
#-------------
nrows,ncols = eta.shape
eta_vector = eta.flatten()*1.0
validID = np.where(eta_vector>0... | [
"numpy.where",
"os.getcwd",
"os.chdir",
"numpy.array",
"numpy.save"
] | [((1201, 1223), 'numpy.array', 'np.array', (['bn_ID_unique'], {}), '(bn_ID_unique)\n', (1209, 1223), True, 'import numpy as np\n'), ((1244, 1259), 'numpy.array', 'np.array', (['bn_ID'], {}), '(bn_ID)\n', (1252, 1259), True, 'import numpy as np\n'), ((1285, 1305), 'numpy.array', 'np.array', (['ghostbn_ID'], {}), '(ghost... |
from django.db import models
from regularTour.models import RegularTourModel
from django.core.validators import MinValueValidator, MaxValueValidator
# Create your models here.
class RegTourScheduleModel(models.Model):
date = models.DateField()
startTime = models.TimeField()
slot = models.IntegerField(valid... | [
"django.db.models.DateField",
"django.core.validators.MaxValueValidator",
"django.db.models.TimeField",
"django.db.models.ForeignKey",
"django.core.validators.MinValueValidator",
"django.db.models.CharField"
] | [((230, 248), 'django.db.models.DateField', 'models.DateField', ([], {}), '()\n', (246, 248), False, 'from django.db import models\n'), ((265, 283), 'django.db.models.TimeField', 'models.TimeField', ([], {}), '()\n', (281, 283), False, 'from django.db import models\n'), ((427, 458), 'django.db.models.CharField', 'model... |
from django.db.models.query import QuerySet
from odata_query.grammar import ODataLexer, ODataParser # type: ignore
from .django_q import AstToDjangoQVisitor
def apply_odata_query(queryset: QuerySet, odata_query: str) -> QuerySet:
"""
Shorthand for applying an OData query to a Django QuerySet.
Args:
... | [
"odata_query.grammar.ODataParser",
"odata_query.grammar.ODataLexer"
] | [((495, 507), 'odata_query.grammar.ODataLexer', 'ODataLexer', ([], {}), '()\n', (505, 507), False, 'from odata_query.grammar import ODataLexer, ODataParser\n'), ((521, 534), 'odata_query.grammar.ODataParser', 'ODataParser', ([], {}), '()\n', (532, 534), False, 'from odata_query.grammar import ODataLexer, ODataParser\n'... |
# Copyright (c) 2021 - present / Neuralmagic, Inc. 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 b... | [
"marshmallow.fields.Int",
"marshmallow.fields.Nested",
"marshmallow.fields.Str",
"marshmallow.validate.OneOf",
"marshmallow.fields.Bool"
] | [((923, 950), 'marshmallow.fields.Str', 'fields.Str', ([], {'allow_none': '(True)'}), '(allow_none=True)\n', (933, 950), False, 'from marshmallow import Schema, fields, validate\n'), ((966, 993), 'marshmallow.fields.Str', 'fields.Str', ([], {'allow_none': '(True)'}), '(allow_none=True)\n', (976, 993), False, 'from mars... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Nekozilla is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# Nekozilla is distributed... | [
"neko3.permission_bits.Permissions.__members__.keys"
] | [((1344, 1390), 'neko3.permission_bits.Permissions.__members__.keys', 'permission_bits.Permissions.__members__.keys', ([], {}), '()\n', (1388, 1390), False, 'from neko3 import permission_bits\n'), ((1050, 1096), 'neko3.permission_bits.Permissions.__members__.keys', 'permission_bits.Permissions.__members__.keys', ([], {... |
'''input
100000
457992974
3
6
10
3628800
'''
# -*- coding: utf-8 -*-
# AtCoder Beginner Contest
# Problem B
if __name__ == '__main__':
from math import factorial
training_count = int(input())
print(factorial(training_count) % (10 ** 9 + 7))
| [
"math.factorial"
] | [((242, 267), 'math.factorial', 'factorial', (['training_count'], {}), '(training_count)\n', (251, 267), False, 'from math import factorial\n')] |
from enum import Enum
from trader.combat import Combat, CombatEventCode
from trader.search import Search, SearchAction, SearchEventCode
from trader.trade import Trade
class EncounterState:
"""A base class for all encounter state objects."""
def doTurn(self, encounter):
"""
Do the n... | [
"trader.trade.Trade",
"trader.combat.Combat",
"trader.search.Search"
] | [((1359, 1377), 'trader.combat.Combat', 'Combat', (['combatants'], {}), '(combatants)\n', (1365, 1377), False, 'from trader.combat import Combat, CombatEventCode\n'), ((2897, 2916), 'trader.trade.Trade', 'Trade', (['game', 'beings'], {}), '(game, beings)\n', (2902, 2916), False, 'from trader.trade import Trade\n'), ((4... |
import numpy as np
from sklearn.metrics.scorer import _BaseScorer
from solnml.components.utils.constants import CLS_TASKS, IMG_CLS
from solnml.datasets.base_dl_dataset import DLDataset
from solnml.components.evaluators.base_dl_evaluator import get_estimator_with_parameters
from solnml.components.ensemble.dl_ensemble.b... | [
"functools.reduce",
"numpy.array",
"solnml.components.models.img_classification.nn_utils.nn_aug.aug_hp_space.get_test_transforms",
"solnml.components.evaluators.base_dl_evaluator.get_estimator_with_parameters"
] | [((4078, 4098), 'numpy.array', 'np.array', (['final_pred'], {}), '(final_pred)\n', (4086, 4098), True, 'import numpy as np\n'), ((2462, 2580), 'solnml.components.evaluators.base_dl_evaluator.get_estimator_with_parameters', 'get_estimator_with_parameters', (['self.task_type', 'config', 'self.max_epoch', 'dataset', 'self... |
import os
import unittest
import cwepr.io
import cwepr.dataset
ROOTPATH = os.path.split(os.path.abspath(__file__))[0]
class TestTxtImporter(unittest.TestCase):
def test_import(self):
source = os.path.join(ROOTPATH, 'testdata/noisy_data')
importer = cwepr.io.TxtImporter(source=source)
dat... | [
"os.path.abspath",
"os.path.join"
] | [((90, 115), 'os.path.abspath', 'os.path.abspath', (['__file__'], {}), '(__file__)\n', (105, 115), False, 'import os\n'), ((208, 253), 'os.path.join', 'os.path.join', (['ROOTPATH', '"""testdata/noisy_data"""'], {}), "(ROOTPATH, 'testdata/noisy_data')\n", (220, 253), False, 'import os\n')] |
import os
import sys
import logging
import paddle
import argparse
import functools
import math
import time
import numpy as np
import paddle.fluid as fluid
sys.path[0] = os.path.join(
os.path.dirname("__file__"), os.path.pardir, os.path.pardir)
from paddleslim.common import get_logger
import models
from utility impo... | [
"paddle.fluid.data",
"argparse.ArgumentParser",
"paddleslim.common.get_logger",
"paddle.fluid.default_startup_program",
"models.inception_v4.InceptionV4",
"paddle.fluid.CPUPlace",
"reader_cv2.val",
"os.path.join",
"paddle.fluid.io.save_inference_model",
"os.path.dirname",
"paddle.fluid.default_m... | [((401, 441), 'paddleslim.common.get_logger', 'get_logger', (['__name__'], {'level': 'logging.INFO'}), '(__name__, level=logging.INFO)\n', (411, 441), False, 'from paddleslim.common import get_logger\n'), ((452, 496), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '__doc__'}), '(description=... |
import random
print("------------------------------")
print(" M&M guessing game!")
print("------------------------------")
print("Guess the number of M&Ms and you get lunch on the house!")
mm_count = random.randint(1, 100)
attempt_limit = 5
attempts = 0
while attempts < attempt_limit:
try:
guess_tex... | [
"random.randint"
] | [((207, 229), 'random.randint', 'random.randint', (['(1)', '(100)'], {}), '(1, 100)\n', (221, 229), False, 'import random\n')] |
"""
Created on Tue Jul 28 12:19:11 2020
@author: <NAME>
"""
import numpy as np
import matplotlib.pyplot as plt
import time
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.optimizers import RMSprop
from tensorflow.keras.layers import Dense, Dropout, Flatten, Conv2D, MaxPoo... | [
"horovod.tensorflow.keras.size",
"tensorflow.keras.layers.BatchNormalization",
"horovod.tensorflow.keras.callbacks.MetricAverageCallback",
"horovod.tensorflow.keras.callbacks.LearningRateWarmupCallback",
"horovod.tensorflow.keras.init",
"horovod.tensorflow.keras.rank",
"numpy.mean",
"tensorflow.keras.... | [((1339, 1349), 'horovod.tensorflow.keras.init', 'hvd.init', ([], {}), '()\n', (1347, 1349), True, 'import horovod.tensorflow.keras as hvd\n'), ((1432, 1483), 'tensorflow.config.experimental.list_physical_devices', 'tf.config.experimental.list_physical_devices', (['"""GPU"""'], {}), "('GPU')\n", (1476, 1483), True, 'im... |
import datetime as dt
import decimal
import typing as t
import uuid
import marshmallow.fields as f
NoneType = type(None)
TYPE_MAPPING = {
bool: f.Boolean,
decimal.Decimal: f.Decimal,
dt.date: f.Date,
dt.datetime: f.DateTime,
dt.time: f.Time,
dt.timedelta: f.TimeDelta,
float: f.Float,
i... | [
"marshmallow.fields.List",
"marshmallow.fields.Dict"
] | [((983, 1015), 'marshmallow.fields.List', 'f.List', (['subfield'], {}), '(subfield, **field_kwargs)\n', (989, 1015), True, 'import marshmallow.fields as f\n'), ((1168, 1222), 'marshmallow.fields.Dict', 'f.Dict', ([], {'keys': 'keyfield', 'values': 'valfield'}), '(keys=keyfield, values=valfield, **field_kwargs)\n', (117... |
from django.shortcuts import render, get_object_or_404
from django.views.generic import (TemplateView, DetailView,
ListView, CreateView,
UpdateView,DeleteView,FormView,)
from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger
from ... | [
"django.shortcuts.render",
"django.shortcuts.get_object_or_404",
"django.core.paginator.Paginator"
] | [((519, 545), 'django.core.paginator.Paginator', 'Paginator', (['departments', '(10)'], {}), '(departments, 10)\n', (528, 545), False, 'from django.core.paginator import Paginator, EmptyPage, PageNotAnInteger\n'), ((954, 1041), 'django.shortcuts.render', 'render', (['request', '"""home/dept_list.html"""', "{'department... |
# -*- coding: utf-8 -*-
import json, os
README_URL = os.environ['ILS_LOC_MPR__README_URL']
## auth
SUPER_USERS = json.loads( os.environ['ILS_LOC_MPR__SUPER_USERS_JSON'] )
STAFF_USERS = json.loads( os.environ['ILS_LOC_MPR__STAFF_USERS_JSON'] ) # users permitted access to admin
STAFF_GROUP = os.environ['ILS_LOC_MPR_... | [
"json.loads"
] | [((117, 172), 'json.loads', 'json.loads', (["os.environ['ILS_LOC_MPR__SUPER_USERS_JSON']"], {}), "(os.environ['ILS_LOC_MPR__SUPER_USERS_JSON'])\n", (127, 172), False, 'import json, os\n'), ((189, 244), 'json.loads', 'json.loads', (["os.environ['ILS_LOC_MPR__STAFF_USERS_JSON']"], {}), "(os.environ['ILS_LOC_MPR__STAFF_US... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Author: <NAME>
# Copyright (c) 2020
# E-mail: <EMAIL>
import random
from vx.com.py.clustering.BKmeans import *
from vx.com.py.clustering.BKmeansFE import *
class Sampling:
# input: smsize, X, type
# output: ramdoms ids
@staticmethod
def execute(X=None, ... | [
"random.shuffle",
"random.seed"
] | [((470, 484), 'random.seed', 'random.seed', (['(7)'], {}), '(7)\n', (481, 484), False, 'import random\n'), ((542, 559), 'random.shuffle', 'random.shuffle', (['e'], {}), '(e)\n', (556, 559), False, 'import random\n')] |
from skillmodels.estimation.parse_params import parse_params
from skillmodels.estimation.parse_params import restore_unestimated_quantities
import numpy as np
from skillmodels.fast_routines.kalman_filters import normal_unscented_predict
from skillmodels.fast_routines.kalman_filters import sqrt_unscented_predict
from sk... | [
"skillmodels.fast_routines.kalman_filters.sqrt_unscented_predict",
"skillmodels.estimation.parse_params.restore_unestimated_quantities",
"skillmodels.fast_routines.kalman_filters.sqrt_probit_update",
"numpy.log",
"skillmodels.fast_routines.kalman_filters.normal_unscented_predict",
"skillmodels.fast_routin... | [((2098, 2144), 'skillmodels.estimation.parse_params.restore_unestimated_quantities', 'restore_unestimated_quantities', ([], {}), '(**restore_args)\n', (2128, 2144), False, 'from skillmodels.estimation.parse_params import restore_unestimated_quantities\n'), ((2149, 2190), 'skillmodels.estimation.parse_params.parse_para... |
import os
import pandas as pd
path = os.getcwd()
fN = (path + './data/fn.txt')
cleveland = (path + "./data/c.csv")
switzerland = (path + "./data/s.csv")
hungarian = (path + "./data/h.csv")
va = (path + "./data/lb.csv")
m_Data = (path + "./data/Merged_Data.csv")
headers = pd.read_csv(fN, sep='\n', header=None)
clev... | [
"pandas.read_csv",
"os.getcwd"
] | [((38, 49), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (47, 49), False, 'import os\n'), ((274, 312), 'pandas.read_csv', 'pd.read_csv', (['fN'], {'sep': '"""\n"""', 'header': 'None'}), "(fN, sep='\\n', header=None)\n", (285, 312), True, 'import pandas as pd\n')] |
import numpy as np
import math
# Convert point-spread function to optical transfer function
def psf2otf(psf, outSize=None):
# Prepare psf for conversion
data = prepare_psf(psf, outSize)
# Compute the OTF
otf = np.fft.fftn(data)
return np.complex64(otf)
def prepare_psf(psf, outSize=None, dtype=None):
if ... | [
"numpy.roll",
"numpy.int32",
"numpy.fft.fftn",
"numpy.zeros",
"numpy.float32",
"numpy.complex64"
] | [((220, 237), 'numpy.fft.fftn', 'np.fft.fftn', (['data'], {}), '(data)\n', (231, 237), True, 'import numpy as np\n'), ((248, 265), 'numpy.complex64', 'np.complex64', (['otf'], {}), '(otf)\n', (260, 265), True, 'import numpy as np\n'), ((361, 376), 'numpy.float32', 'np.float32', (['psf'], {}), '(psf)\n', (371, 376), Tru... |
import caffe.proto.caffe_pb2 as caffe_pb2
from os.path import join
from caffe_config import CaffeConfig
from to_string import to_string
class SolverConfig(CaffeConfig):
def __init__(self, base_lr=0.001, lr_policy="step", solver_type="SGD", step_size=10000, display=20, momentum=0.9, gamma=0.1, weight_decay=5e-4):
... | [
"caffe_config.CaffeConfig.__init__",
"caffe.proto.caffe_pb2.SolverParameter",
"os.path.join",
"to_string.to_string"
] | [((328, 354), 'caffe_config.CaffeConfig.__init__', 'CaffeConfig.__init__', (['self'], {}), '(self)\n', (348, 354), False, 'from caffe_config import CaffeConfig\n'), ((716, 795), 'os.path.join', 'join', (['self.scen_dir', "('stage%s_%s_solver.prototxt' % (self.stage, self.net_type))"], {}), "(self.scen_dir, 'stage%s_%s_... |
import matplotlib.pyplot as plt
import mxnet as mx
import numpy as np
from mxnet import autograd
from NLP.src.training import utils
def train(train_data, model, loss, epochs, batch_size,
context, trainer, freeze_embedding=False):
"""
Train an RNN model, given the input list
param train_data: tr... | [
"mxnet.nd.sum",
"matplotlib.pyplot.grid",
"mxnet.autograd.record",
"NLP.src.training.utils.get_batch",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"numpy.arange"
] | [((1810, 1820), 'matplotlib.pyplot.grid', 'plt.grid', ([], {}), '()\n', (1818, 1820), True, 'import matplotlib.pyplot as plt\n'), ((1825, 1845), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""Epochs"""'], {}), "('Epochs')\n", (1835, 1845), True, 'import matplotlib.pyplot as plt\n'), ((1850, 1868), 'matplotlib.pyplot.y... |
import torch
try:
from torch.utils.data import IterableDataset
except ImportError:
class IterableDataset:
pass
class BatchChecker:
def __init__(self, data, init_counter=0):
self.counter = init_counter
self.data = data
self.true_batch = None
def check(self, batch):
... | [
"torch.utils.data.sampler.WeightedRandomSampler",
"torch.distributed.is_initialized",
"torch.distributed.get_world_size",
"torch.utils.data.distributed.DistributedSampler",
"torch.distributed.get_rank",
"torch.distributed.is_available",
"torch.zeros",
"torch.ones"
] | [((1251, 1304), 'torch.ones', 'torch.ones', (['(num_iters * batch_size)'], {'dtype': 'torch.float'}), '(num_iters * batch_size, dtype=torch.float)\n', (1261, 1304), False, 'import torch\n'), ((1862, 1897), 'torch.zeros', 'torch.zeros', (['(num_iters * batch_size)'], {}), '(num_iters * batch_size)\n', (1873, 1897), Fals... |
#!/usr/bin/python3
# -*- coding: utf-8 -*-
from twisted.internet import defer, reactor
def loadRemoteData(callback):
print("---> loadRemoteData callback: ", callback)
import time
time.sleep(1)
callback(1) # 将1传给getResult, 只有callback之后才能触发callbacks结果
def loadRemoteData2(callback):
pri... | [
"twisted.internet.reactor.callInThread",
"twisted.internet.defer.returnValue",
"time.sleep",
"twisted.internet.reactor.run",
"twisted.internet.reactor.callLater",
"twisted.internet.defer.Deferred"
] | [((200, 213), 'time.sleep', 'time.sleep', (['(1)'], {}), '(1)\n', (210, 213), False, 'import time\n'), ((390, 403), 'time.sleep', 'time.sleep', (['(1)'], {}), '(1)\n', (400, 403), False, 'import time\n'), ((483, 499), 'twisted.internet.defer.Deferred', 'defer.Deferred', ([], {}), '()\n', (497, 499), False, 'from twiste... |
'''
Function:
Downloader
Author:
Charles
WeChat public account:
Charles_pikachu
'''
import os
import re
import json
import shutil
import base64
import requests
from alive_progress import alive_bar
from .misc import touchdir, filterBadCharacter
'''Downloader'''
class Downloader():
def __init__(self, pa... | [
"os.listdir",
"requests.Session",
"img2pdf.convert",
"imp.reload",
"os.path.join",
"base64.b64decode",
"PyPDF2.PdfFileMerger",
"shutil.rmtree",
"alive_progress.alive_bar",
"re.findall",
"PyPDF2.PdfFileReader",
"re.search"
] | [((7923, 7941), 'imp.reload', 'reload', (['pdfmetrics'], {}), '(pdfmetrics)\n', (7929, 7941), False, 'from imp import reload\n'), ((412, 430), 'requests.Session', 'requests.Session', ([], {}), '()\n', (428, 430), False, 'import requests\n'), ((1231, 1316), 'os.path.join', 'os.path.join', (["paperinfo['savedir']", 'f"""... |
import vessel_scoring.add_measures
import six
class BaseModel(object):
# def train_on_messages(self, messages):
# messages = AddMeasures(messages, self.windows)
# y_train = utils.is_fishy(train_data)
# model.fit(train_data, y_train)
# return model
def predict_messages(s... | [
"six.iteritems"
] | [((745, 763), 'six.iteritems', 'six.iteritems', (['msg'], {}), '(msg)\n', (758, 763), False, 'import six\n')] |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 流畅的Python 第二章示例程序2-9
# python中collections.namedtuple提供了可命名元组
# 它可以用来构建一个带字段名的元组和一个有名字的类
from collections import namedtuple
# 创建一个具名元组需要两个参数，一个是类名，另一个是类的各个字段的名字。
# 后者可以是由数个字符串组成的可迭代对象，或者是由空格分隔开的字段名组成的字符串
City = namedtuple('City', 'name country population coordinates')
t... | [
"collections.namedtuple"
] | [((261, 318), 'collections.namedtuple', 'namedtuple', (['"""City"""', '"""name country population coordinates"""'], {}), "('City', 'name country population coordinates')\n", (271, 318), False, 'from collections import namedtuple\n'), ((575, 608), 'collections.namedtuple', 'namedtuple', (['"""LatLong"""', '"""lat long""... |
import io
from unittest import TestCase
from unittest import mock
from unittest.mock import patch
from python.implementations.problem2381 import Problem2381
TARGET = 'sys.stdout'
@patch('builtins.input', create=True)
class Test2381(TestCase):
def test_2381_5_1(self, mocked_input):
mocked_input.side_effe... | [
"io.StringIO",
"python.implementations.problem2381.Problem2381",
"unittest.mock.patch"
] | [((184, 220), 'unittest.mock.patch', 'patch', (['"""builtins.input"""'], {'create': '(True)'}), "('builtins.input', create=True)\n", (189, 220), False, 'from unittest.mock import patch\n'), ((441, 454), 'io.StringIO', 'io.StringIO', ([], {}), '()\n', (452, 454), False, 'import io\n'), ((502, 515), 'python.implementatio... |
from django.db import models
class Pessoa(models.Model):
nome = models.CharField(max_length=100)
servico = models.CharField(max_length=100)
telefone = models.CharField(max_length=30)
def __str__(self):
return self.nome
| [
"django.db.models.CharField"
] | [((72, 104), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(100)'}), '(max_length=100)\n', (88, 104), False, 'from django.db import models\n'), ((120, 152), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(100)'}), '(max_length=100)\n', (136, 152), False, 'from django.db ... |
from datetime import datetime
from typing import Dict, Optional
from uuid import uuid4
from flask import current_app as app
from lighthouse.constants.fields import (
FIELD_LAB_ID,
FIELD_LH_SAMPLE_UUID,
FIELD_RESULT,
FIELD_RNA_ID,
FIELD_ROOT_SAMPLE_ID,
)
from lighthouse.types import SampleDoc
def... | [
"datetime.datetime.now",
"flask.current_app.config.get",
"uuid.uuid4"
] | [((1136, 1143), 'uuid.uuid4', 'uuid4', ([], {}), '()\n', (1141, 1143), False, 'from uuid import uuid4\n'), ((3471, 3485), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (3483, 3485), False, 'from datetime import datetime\n'), ((1441, 1477), 'flask.current_app.config.get', 'app.config.get', (['"""BECKMAN_ROB... |
"""
Author: shikechen
Function: display dices, use matplotlib
Version: 3.0
Date: 2019/2/22
"""
import random
import matplotlib.pyplot as plt
def roll_dice():
return random.randint(1, 6)
def main():
total_times = 100
result_list = [0] * 11
roll_list = list(range(2, 13))
roll_dict... | [
"random.randint",
"matplotlib.pyplot.scatter",
"matplotlib.pyplot.show"
] | [((187, 207), 'random.randint', 'random.randint', (['(1)', '(6)'], {}), '(1, 6)\n', (201, 207), False, 'import random\n'), ((846, 883), 'matplotlib.pyplot.scatter', 'plt.scatter', (['x', 'roll1_list'], {'alpha': '(0.5)'}), '(x, roll1_list, alpha=0.5)\n', (857, 883), True, 'import matplotlib.pyplot as plt\n'), ((888, 92... |
"""Flappy, game inspired by Flappy Bird.
Exercises
1. Keep score.
2. Vary the speed.
3. Vary the size of the balls.
4. Allow the bird to move forward and back.
"""
from random import *
from turtle import *
from freegames import vector
writer = Turtle(visible=False)
state={'score':0}
bird = vector(0, 0)
balls = []
s... | [
"freegames.vector"
] | [((295, 307), 'freegames.vector', 'vector', (['(0)', '(0)'], {}), '(0, 0)\n', (301, 307), False, 'from freegames import vector\n'), ((413, 426), 'freegames.vector', 'vector', (['(0)', '(30)'], {}), '(0, 30)\n', (419, 426), False, 'from freegames import vector\n'), ((1119, 1133), 'freegames.vector', 'vector', (['(199)',... |
import os
import platform
import socket
import subprocess
from random import choice
from typing import List
from urllib.request import Request, urlopen
#######################################################################
# allow downloading stuff with a random user agent
# see http://wolfprojects.altervista.org/art... | [
"random.choice",
"subprocess.Popen",
"platform.system",
"os.startfile",
"urllib.request.urlopen",
"socket.setdefaulttimeout"
] | [((1505, 1546), 'socket.setdefaulttimeout', 'socket.setdefaulttimeout', (['timeout_seconds'], {}), '(timeout_seconds)\n', (1529, 1546), False, 'import socket\n'), ((2056, 2082), 'urllib.request.urlopen', 'urlopen', (['req'], {'timeout': '(3000)'}), '(req, timeout=3000)\n', (2063, 2082), False, 'from urllib.request impo... |
#!/usr/bin/python3
# -*- coding: utf-8 -*-
import os
from setuptools import setup
def read(f):
return open(os.path.join(os.path.dirname(__file__), f)).read()
setup(
name = "modulemd",
version = "0.1",
author = "<NAME>",
author_email = "<EMAIL>",
description = ("A python3 library for manipulat... | [
"os.path.dirname"
] | [((126, 151), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (141, 151), False, 'import os\n')] |
from django.db import models
from django.contrib.auth.models import AbstractUser
# Create your models here.
class User(AbstractUser, models.Model):
email = models.EmailField(unique = True)
class Choices(models.Model):
choice = models.CharField(max_length=5000)
is_answer = models.BooleanField(default=False... | [
"django.db.models.EmailField",
"django.db.models.IntegerField",
"django.db.models.ForeignKey",
"django.db.models.ManyToManyField",
"django.db.models.BooleanField",
"django.db.models.DateTimeField",
"django.db.models.CharField"
] | [((161, 191), 'django.db.models.EmailField', 'models.EmailField', ([], {'unique': '(True)'}), '(unique=True)\n', (178, 191), False, 'from django.db import models\n'), ((237, 270), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(5000)'}), '(max_length=5000)\n', (253, 270), False, 'from django.db ... |
"""
Query Resource Limits from another channel with the factory source
"""
import pprint
import pandas as pd
import argparse
from decisionengine.framework.modules import SourceProxy
import logging
PRODUCES = ['GCE_Resource_Limits']
class GCEResourceLimits(SourceProxy.SourceProxy):
"""
Consumes factory data ... | [
"logging.getLogger",
"pprint.pprint",
"argparse.ArgumentParser"
] | [((1849, 1872), 'pprint.pprint', 'pprint.pprint', (['template'], {}), '(template)\n', (1862, 1872), False, 'import pprint\n'), ((2038, 2063), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (2061, 2063), False, 'import argparse\n'), ((529, 548), 'logging.getLogger', 'logging.getLogger', ([], {})... |
#%% [markdown]
# # Contrastive Hebbian Learning
#
# Contrastive Hebbian Learning (CHL) is an algorithm that can be used to perform supervised learning in a neural network. It unites the power of backpropagation with the plausibility of Hebbian learning, and is thus a favorite of researchers in computational neuroscien... | [
"matplotlib.pyplot.imshow",
"numpy.copy",
"matplotlib.pyplot.ylabel",
"numpy.random.random",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"numpy.exp",
"numpy.sum",
"numpy.zeros",
"numpy.array",
"numpy.random.seed",
"matplotlib.pyplot.title",
"matplotlib.pyplot.subplots",
"numpy.ar... | [((7251, 7268), 'numpy.random.seed', 'np.random.seed', (['(1)'], {}), '(1)\n', (7265, 7268), True, 'import numpy as np\n'), ((7276, 7299), 'numpy.zeros', 'np.zeros', (['(1, n_inputs)'], {}), '((1, n_inputs))\n', (7284, 7299), True, 'import numpy as np\n'), ((7358, 7381), 'numpy.zeros', 'np.zeros', (['(1, n_hidden)'], {... |
from django.urls import path
from . import views
urlpatterns = [
path('<int:product_id>/', views.detail, name='detail'),
path('', views.Index.as_view(), name='index'),
path('contacto/', views.ContactView.as_view(), name='contacto'),
path('quienes-somos/', views.Quienes.as_view(), name='quienes'),
... | [
"django.urls.path"
] | [((72, 126), 'django.urls.path', 'path', (['"""<int:product_id>/"""', 'views.detail'], {'name': '"""detail"""'}), "('<int:product_id>/', views.detail, name='detail')\n", (76, 126), False, 'from django.urls import path\n')] |
#!/usr/bin/env python
# encoding: utf-8
"""
*Convert the Collate of tables within database to `latin1_swedish_ci` and the charset to `latin1`*
:Author:
<NAME>
:Date Created:
April 28, 2014
.. todo::
@review: when complete pull all general functions and classes into dryxPython
# @review Code to be a... | [
"fundamentals.times.calculate_time_difference",
"fundamentals.times.get_now_sql_datetime",
"fundamentals.tools"
] | [((1658, 1703), 'fundamentals.tools', 'tools', ([], {'arguments': 'arguments', 'docString': '__doc__'}), '(arguments=arguments, docString=__doc__)\n', (1663, 1703), False, 'from fundamentals import tools, times\n'), ((2379, 2407), 'fundamentals.times.get_now_sql_datetime', 'times.get_now_sql_datetime', ([], {}), '()\n'... |
import hashlib
import hmac
from Crypto.Protocol.KDF import PBKDF2
def mnemonics_to_seed(seed, passphrase=b""):
salt = b"mn<PASSWORD>" + passphrase
def prf(p, s):
hx = hmac.new(p, msg=s, digestmod=hashlib.sha512)
return hx.digest()
res = PBKDF2(password=seed, salt=salt, dkLen=64, prf=prf... | [
"hmac.new",
"Crypto.Protocol.KDF.PBKDF2"
] | [((270, 333), 'Crypto.Protocol.KDF.PBKDF2', 'PBKDF2', ([], {'password': 'seed', 'salt': 'salt', 'dkLen': '(64)', 'prf': 'prf', 'count': '(2048)'}), '(password=seed, salt=salt, dkLen=64, prf=prf, count=2048)\n', (276, 333), False, 'from Crypto.Protocol.KDF import PBKDF2\n'), ((187, 231), 'hmac.new', 'hmac.new', (['p'], ... |
from tir import Webapp
import unittest
class CTBA211(unittest.TestCase):
@classmethod
def setUpClass(inst):
inst.oHelper = Webapp()
inst.oHelper.Setup("SIGACTB", "30/06/2015", "T1", "M PR 02 ", "34")
inst.oHelper.Program("CTBA211")
###################################... | [
"unittest.main",
"tir.Webapp"
] | [((9642, 9657), 'unittest.main', 'unittest.main', ([], {}), '()\n', (9655, 9657), False, 'import unittest\n'), ((143, 151), 'tir.Webapp', 'Webapp', ([], {}), '()\n', (149, 151), False, 'from tir import Webapp\n')] |
import mimetypes
import os
import boto3
BUCKET = "hc-flask-assets"
def write_to_s3(bucket_name: str, from_file: str, to_file: str, mimetype) -> None:
s3 = boto3.resource("s3")
s3.Bucket(bucket_name).upload_file(
from_file, to_file, ExtraArgs={"ACL": "public-read", "ContentType": mimetype}
)
d... | [
"mimetypes.guess_type",
"boto3.resource",
"os.walk"
] | [((164, 184), 'boto3.resource', 'boto3.resource', (['"""s3"""'], {}), "('s3')\n", (178, 184), False, 'import boto3\n'), ((361, 387), 'mimetypes.guess_type', 'mimetypes.guess_type', (['file'], {}), '(file)\n', (381, 387), False, 'import mimetypes\n'), ((535, 552), 'os.walk', 'os.walk', (['"""static"""'], {}), "('static'... |
#!/usr/bin/env python3
#
# Copyright (C) 2019 jayson
#
import json
import logging
import contextlib
import utils.logging
from utils import connection
from config import RABBITMQ_MASTER
from pika.adapters.blocking_connection import BlockingChannel
from pika.spec import Basic, BasicProperties
@contextlib.... | [
"utils.connection.get_exchange_connection",
"json.loads"
] | [((895, 972), 'utils.connection.get_exchange_connection', 'connection.get_exchange_connection', (['RABBITMQ_MASTER', '"""logs_routing"""', '"""direct"""'], {}), "(RABBITMQ_MASTER, 'logs_routing', 'direct')\n", (929, 972), False, 'from utils import connection\n'), ((540, 556), 'json.loads', 'json.loads', (['body'], {}),... |
import FWCore.ParameterSet.Config as cms
from FWCore.ParameterSet.VarParsing import VarParsing
# Cmd line options
options = VarParsing ('analysis')
options.register('produceByRun',
True,
VarParsing.multiplicity.singleton,
VarParsing.varType.bool,
"Acc... | [
"FWCore.ParameterSet.VarParsing.VarParsing",
"Configuration.AlCa.GlobalTag.GlobalTag",
"FWCore.ParameterSet.Config.untracked.int32",
"FWCore.ParameterSet.Config.untracked.uint32",
"FWCore.ParameterSet.Config.Process",
"FWCore.ParameterSet.Config.untracked.vstring",
"Calibration.EcalCalibAlgos.EcalPhiSym... | [((125, 147), 'FWCore.ParameterSet.VarParsing.VarParsing', 'VarParsing', (['"""analysis"""'], {}), "('analysis')\n", (135, 147), False, 'from FWCore.ParameterSet.VarParsing import VarParsing\n'), ((1024, 1049), 'FWCore.ParameterSet.Config.Process', 'cms.Process', (['"""ECALPHISYM"""'], {}), "('ECALPHISYM')\n", (1035, 1... |
# Copyright 2017 the V8 project authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import lldb
import re
def jst(debugger, *args):
"""Print the current JavaScript stack trace"""
target = debugger.GetSelectedTarget()
process = targe... | [
"re.compile"
] | [((1221, 1256), 're.compile', 're.compile', (['"""([^(<]+)(?:\\\\(.+\\\\))?"""'], {}), "('([^(<]+)(?:\\\\(.+\\\\))?')\n", (1231, 1256), False, 'import re\n'), ((1269, 1345), 're.compile', 're.compile', (['"""^v8::internal::Per\\\\w+AssertType::(\\\\w+)_ASSERT, (false|true)>"""'], {}), "('^v8::internal::Per\\\\w+AssertT... |
# Copyright (c) 2020, eQualit.ie inc.
# All rights reserved.
#
# This source code is licensed under the BSD-style license found in the
# LICENSE file in the root directory of this source tree.
from baskerville.features.updateable_features import UpdaterRatio
from baskerville.util.enums import FeatureComputeType
from ... | [
"pyspark.sql.functions.lit",
"pyspark.sql.functions.col",
"baskerville.features.feature_html_total.FeatureHtmlTotal.feature_name_from_class",
"baskerville.features.feature_css_total.FeatureCssTotal.feature_name_from_class"
] | [((2382, 2423), 'baskerville.features.feature_css_total.FeatureCssTotal.feature_name_from_class', 'FeatureCssTotal.feature_name_from_class', ([], {}), '()\n', (2421, 2423), False, 'from baskerville.features.feature_css_total import FeatureCssTotal\n'), ((2437, 2479), 'baskerville.features.feature_html_total.FeatureHtml... |
from src.lottery import lottery
# grin lottery #1
# block height 1550360
# https://grinexplorer.net/block/00003fdaff2ab03fcbdeed39307a4ad90c0bbf4394d23026b7b4b794d8f6b932
def test_grinventions_1():
rn = 25
input_hash = '00003fdaff2ab03fcbdeed39307a4ad90c0bbf4394d23026b7b4b794d8f6b932'
seed, tickets, shuff... | [
"src.lottery.lottery"
] | [((326, 349), 'src.lottery.lottery', 'lottery', (['input_hash', 'rn'], {}), '(input_hash, rn)\n', (333, 349), False, 'from src.lottery import lottery\n'), ((896, 919), 'src.lottery.lottery', 'lottery', (['input_hash', 'rn'], {}), '(input_hash, rn)\n', (903, 919), False, 'from src.lottery import lottery\n'), ((1328, 135... |
import unittest
import os
from xl_helper.Utils import Utils
from tests.util.TestingUtils import TestingUtils
class UtilsTest(unittest.TestCase):
config = TestingUtils.get_test_config()
downloads_username = config.get('downloads', 'username')
downloads_password = config.get('downloads', 'password')
... | [
"tests.util.TestingUtils.TestingUtils.get_test_config",
"os.getcwd",
"xl_helper.Utils.Utils.download",
"os.path.isfile",
"xl_helper.Utils.Utils.build_url",
"unittest.main",
"os.remove"
] | [((162, 192), 'tests.util.TestingUtils.TestingUtils.get_test_config', 'TestingUtils.get_test_config', ([], {}), '()\n', (190, 192), False, 'from tests.util.TestingUtils import TestingUtils\n'), ((2378, 2393), 'unittest.main', 'unittest.main', ([], {}), '()\n', (2391, 2393), False, 'import unittest\n'), ((1537, 1614), '... |
import os
import shutil
import ssl
import urllib.request
from pathlib import Path
from subprocess import run
VERSION = "2.0.1"
RELEASE = 20211007
DEFAULT_DEST = Path(__file__).parent
fname = (
f"MMSetup_64bit_{VERSION}_{RELEASE}.exe"
if os.name == "nt"
else f"Micro-Manager-{VERSION}-{RELEASE}.dmg"
)
ssl._... | [
"argparse.ArgumentParser",
"pathlib.Path",
"os.getenv",
"ssl.create_default_context",
"os.rename",
"subprocess.run",
"shutil.copytree",
"os.unlink"
] | [((162, 176), 'pathlib.Path', 'Path', (['__file__'], {}), '(__file__)\n', (166, 176), False, 'from pathlib import Path\n'), ((789, 817), 'ssl.create_default_context', 'ssl.create_default_context', ([], {}), '()\n', (815, 817), False, 'import ssl\n'), ((1370, 1428), 'subprocess.run', 'run', (["['hdiutil', 'attach', '-no... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Jun 20 16:23:57 2019
@author: hitansh
"""
import numpy as np
import os
import sys
# import tarfile
import tensorflow as tf
# import zipfile
# from distutils.version import StrictVersion
# from collections import defaultdict
# from io import StringIO
# f... | [
"numpy.uint8",
"tensorflow.gfile.GFile",
"sys.path.append",
"os.walk",
"tensorflow.Graph",
"os.path.exists",
"tensorflow.Session",
"tensorflow.GraphDef",
"os.mkdir",
"tensorflow.get_default_graph",
"object_detection.utils.label_map_util.create_category_index_from_labelmap",
"tensorflow.import_... | [((587, 608), 'sys.path.append', 'sys.path.append', (['""".."""'], {}), "('..')\n", (602, 608), False, 'import sys\n'), ((1176, 1237), 'os.chdir', 'os.chdir', (['"""../../../data/TensorFlow/workspace/training_demo/"""'], {}), "('../../../data/TensorFlow/workspace/training_demo/')\n", (1184, 1237), False, 'import os\n')... |
import copy
import json
from typing import Any, Dict
import requests
import common.log
from authpolicy import AuthPolicy
logger = common.log.get_logger()
def build_policy(method_arn: str, user_id: str, allow: bool = False) -> Any:
"""Create API Gateway policy."""
if allow:
# example of methodArn:
... | [
"authpolicy.AuthPolicy",
"json.dumps",
"copy.deepcopy"
] | [((1666, 1688), 'copy.deepcopy', 'copy.deepcopy', (['request'], {}), '(request)\n', (1679, 1688), False, 'import copy\n'), ((720, 759), 'authpolicy.AuthPolicy', 'AuthPolicy', (['principalId', 'aws_account_id'], {}), '(principalId, aws_account_id)\n', (730, 759), False, 'from authpolicy import AuthPolicy\n'), ((3633, 36... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
from __future__ import print_function
import sys
sys.path.insert(0, "..")
import typesentry # noqa
_tc = typesentry.Config()
typed = _tc.typed
TypeError = _tc.TypeError
ValueError = _tc.ValueError
__all__ = ("typed", "TypeError", "ValueError")
| [
"sys.path.insert",
"typesentry.Config"
] | [((98, 122), 'sys.path.insert', 'sys.path.insert', (['(0)', '""".."""'], {}), "(0, '..')\n", (113, 122), False, 'import sys\n'), ((157, 176), 'typesentry.Config', 'typesentry.Config', ([], {}), '()\n', (174, 176), False, 'import typesentry\n')] |
import explorerhat as eh
from time import sleep
while True:
eh.light.off()
eh.light.red.on()
sleep(0.5)
eh.light.yellow.on()
sleep(0.5)
eh.light.green.on()
sleep(0.5)
eh.light.blue.on()
sleep(0.5)
| [
"explorerhat.light.green.on",
"explorerhat.light.red.on",
"explorerhat.light.off",
"time.sleep",
"explorerhat.light.yellow.on",
"explorerhat.light.blue.on"
] | [((66, 80), 'explorerhat.light.off', 'eh.light.off', ([], {}), '()\n', (78, 80), True, 'import explorerhat as eh\n'), ((85, 102), 'explorerhat.light.red.on', 'eh.light.red.on', ([], {}), '()\n', (100, 102), True, 'import explorerhat as eh\n'), ((107, 117), 'time.sleep', 'sleep', (['(0.5)'], {}), '(0.5)\n', (112, 117), ... |
from argparse import ArgumentParser
import logging
import csv
import json
import os
import shutil
logger = logging.getLogger(__name__)
def main():
parser = ArgumentParser("This program converts the COMMON-VOICE data format to "
"the default CSV audio file format.")
parser.add_argument("-i", "--input... | [
"logging.getLogger",
"os.path.exists",
"logging.StreamHandler",
"argparse.ArgumentParser",
"os.makedirs",
"logging.Formatter",
"csv.writer",
"os.path.join",
"os.path.splitext",
"os.path.split",
"shutil.copy",
"csv.reader",
"os.walk"
] | [((109, 136), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (126, 136), False, 'import logging\n'), ((163, 279), 'argparse.ArgumentParser', 'ArgumentParser', (['"""This program converts the COMMON-VOICE data format to the default CSV audio file format."""'], {}), "(\n 'This program co... |
from visual_sudoku_solver import extractor
import numpy as np
import cv2.cv2 as cv2
# load sudoku image
img = cv2.imread('data/image.jpg')
# crop and save
crop = extractor.sudoku_image(img, 400)
cv2.imwrite('data/cropped.jpg', crop)
# read digits and save
digits = extractor.digits_from_sudoku_image(crop)
np.savetxt... | [
"cv2.cv2.imread",
"visual_sudoku_solver.extractor.digits_from_sudoku_image",
"cv2.cv2.waitKey",
"cv2.cv2.destroyAllWindows",
"visual_sudoku_solver.extractor.sudoku_image",
"cv2.cv2.imwrite",
"cv2.cv2.imshow"
] | [((112, 140), 'cv2.cv2.imread', 'cv2.imread', (['"""data/image.jpg"""'], {}), "('data/image.jpg')\n", (122, 140), True, 'import cv2.cv2 as cv2\n'), ((165, 197), 'visual_sudoku_solver.extractor.sudoku_image', 'extractor.sudoku_image', (['img', '(400)'], {}), '(img, 400)\n', (187, 197), False, 'from visual_sudoku_solver ... |
# -*- coding: utf-8 -*-
# Generated by Django 1.9.7 on 2016-06-25 21:31
from __future__ import unicode_literals
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('cl_app', '0002_auto_20160624_1600'),
]
operations =... | [
"django.db.migrations.RenameField",
"django.db.models.ForeignKey"
] | [((331, 422), 'django.db.migrations.RenameField', 'migrations.RenameField', ([], {'model_name': '"""profile"""', 'old_name': '"""city"""', 'new_name': '"""profile_city"""'}), "(model_name='profile', old_name='city', new_name=\n 'profile_city')\n", (353, 422), False, 'from django.db import migrations, models\n'), ((5... |
from __future__ import print_function
from __future__ import unicode_literals
import csv
import os
import re
from django.core.management.base import BaseCommand, CommandError
from django.core.exceptions import MultipleObjectsReturned
import core.models
from core.models import Entry
from core.models import Postnummer... | [
"csv.DictReader",
"re.match",
"core.models.Entry.objects.bulk_create",
"core.models.Entry.objects.get",
"os.path.isfile",
"core.models.Postnummer.objects.get"
] | [((2533, 2583), 're.match', 're.match', (['"""\\\\W(\\\\d{4})\\\\W(.+)$"""', 'last_address_line'], {}), "('\\\\W(\\\\d{4})\\\\W(.+)$', last_address_line)\n", (2541, 2583), False, 'import re\n'), ((452, 470), 'os.path.isfile', 'os.path.isfile', (['fn'], {}), '(fn)\n', (466, 470), False, 'import os\n'), ((588, 606), 'csv... |
# Automatically generated SST Python input
import sst
# Define shared parameters
cpu_params = {
"commFreq" : "10",
"do_write" : "1",
"num_loadstore" : "10000",
"memSize" : "0x40000000",
}
l1_params = {
"access_latency_cycles" : "1",
"cache_frequency" : "2 Ghz",
"replacement_policy" : "lru"... | [
"sst.setStatisticOutput",
"sst.enableAllStatisticsForComponentType",
"sst.setStatisticLoadLevel",
"sst.Link",
"sst.Component"
] | [((840, 888), 'sst.Component', 'sst.Component', (['"""cpu0"""', '"""memHierarchy.trivialCPU"""'], {}), "('cpu0', 'memHierarchy.trivialCPU')\n", (853, 888), False, 'import sst\n'), ((981, 1030), 'sst.Component', 'sst.Component', (['"""c0.l1cache"""', '"""memHierarchy.Cache"""'], {}), "('c0.l1cache', 'memHierarchy.Cache'... |
# -*- coding: UTF-8 -*-
import re
import smtplib
from validate_email import validate_email
def is_mail(val):
val = re.match('^[_a-z0-9-]+(\.[_a-z0-9-]+)*@[a-z0-9-]+(\.[a-z0-9-]+)*(\.[a-z]{2,4})$', val)
return (val is not None)
def is_valid(val):
return (validate_email(val) == True)
def is_verify(val):
... | [
"validate_email.validate_email",
"re.match"
] | [((120, 218), 're.match', 're.match', (['"""^[_a-z0-9-]+(\\\\.[_a-z0-9-]+)*@[a-z0-9-]+(\\\\.[a-z0-9-]+)*(\\\\.[a-z]{2,4})$"""', 'val'], {}), "(\n '^[_a-z0-9-]+(\\\\.[_a-z0-9-]+)*@[a-z0-9-]+(\\\\.[a-z0-9-]+)*(\\\\.[a-z]{2,4})$',\n val)\n", (128, 218), False, 'import re\n'), ((268, 287), 'validate_email.validate_em... |
"""
Multi-node example (GPU)
"""
import os
import numpy as np
import torch
from test_tube import HyperOptArgumentParser, Experiment
from pytorch_lightning import Trainer
from examples.new_project_templates.lightning_module_template import LightningTemplateModel
SEED = 2334
torch.manual_seed(SEED)
np.random.seed(SEED)... | [
"torch.manual_seed",
"os.path.join",
"os.path.realpath",
"examples.new_project_templates.lightning_module_template.LightningTemplateModel.add_model_specific_args",
"pytorch_lightning.Trainer",
"numpy.random.seed",
"test_tube.Experiment",
"test_tube.HyperOptArgumentParser",
"examples.new_project_temp... | [((276, 299), 'torch.manual_seed', 'torch.manual_seed', (['SEED'], {}), '(SEED)\n', (293, 299), False, 'import torch\n'), ((300, 320), 'numpy.random.seed', 'np.random.seed', (['SEED'], {}), '(SEED)\n', (314, 320), True, 'import numpy as np\n'), ((546, 577), 'examples.new_project_templates.lightning_module_template.Ligh... |
from classes.player import Player
from classes.score import Score
from classes.virus import Virus
from classes.constants import STATES
import random
import pyxel
class Game:
def __init__(self):
pyxel.init(256, 150, caption='Corong', fps=60)
self.virus = Virus()
self.state = STATES['0']
... | [
"classes.player.Player",
"random.choice",
"classes.score.Score",
"pyxel.init",
"pyxel.run",
"pyxel.btn",
"pyxel.cls",
"classes.virus.Virus",
"pyxel.load"
] | [((210, 256), 'pyxel.init', 'pyxel.init', (['(256)', '(150)'], {'caption': '"""Corong"""', 'fps': '(60)'}), "(256, 150, caption='Corong', fps=60)\n", (220, 256), False, 'import pyxel\n'), ((278, 285), 'classes.virus.Virus', 'Virus', ([], {}), '()\n', (283, 285), False, 'from classes.virus import Virus\n'), ((342, 354),... |
#!/usr/bin/env python
# *-* coding: utf-8 *-*
import sys
import re
import socket
if sys.version_info[0] < 3:
import pyping
from logger import PrintLog
else:
from sec_utils.logger import PrintLog
'''
\brief This is a basic network testing class.
This class's sole purpose is to test for REALLY basic netwo... | [
"sec_utils.logger.PrintLog",
"pyping.ping",
"socket.socket",
"sys.exit"
] | [((1089, 1134), 'sec_utils.logger.PrintLog', 'PrintLog', (['"""Network Pen-Tester ready."""', '"""Info"""'], {}), "('Network Pen-Tester ready.', 'Info')\n", (1097, 1134), False, 'from sec_utils.logger import PrintLog\n'), ((2796, 2847), 'sec_utils.logger.PrintLog', 'PrintLog', (['"""Scanning for unwanted ports..."""', ... |
import numpy as np
import multiprocessing
OPTIMAL_CHUNK_SIZE_EFAST = 50
get_chunk_size_eFAST = lambda num_params: min(OPTIMAL_CHUNK_SIZE_EFAST, num_params)
def random_samples(iterations, num_params, seed=None):
"""Random standard uniform sampling for all iterations and parameters with an option of fixing random ... | [
"numpy.tile",
"numpy.ceil",
"numpy.random.rand",
"numpy.ones",
"numpy.sin",
"numpy.floor",
"numpy.fill_diagonal",
"numpy.kron",
"numpy.linspace",
"numpy.zeros",
"numpy.random.seed",
"multiprocessing.Pool",
"numpy.random.uniform",
"numpy.vstack",
"numpy.full",
"numpy.transpose",
"nump... | [((627, 647), 'numpy.random.seed', 'np.random.seed', (['seed'], {}), '(seed)\n', (641, 647), True, 'import numpy as np\n'), ((662, 700), 'numpy.random.rand', 'np.random.rand', (['iterations', 'num_params'], {}), '(iterations, num_params)\n', (676, 700), True, 'import numpy as np\n'), ((1521, 1541), 'numpy.random.seed',... |
import imgkit
import cv2
from utils import io
imgkit.from_file("output/0.html", "1.jpg")
img = cv2.imread("1.jpg")
bboxs, texts = io.load_anno("output/0.txt")
for i in range(len(bboxs)):
x1, y1, x2, y2 = bboxs[i]
img = cv2.rectangle(img, (int(x1), int(y1)), (int(x2), int(y2)), (255, 0, 0), 1)
cv2.imwrite(... | [
"utils.io.load_anno",
"cv2.imwrite",
"cv2.imread",
"imgkit.from_file"
] | [((47, 89), 'imgkit.from_file', 'imgkit.from_file', (['"""output/0.html"""', '"""1.jpg"""'], {}), "('output/0.html', '1.jpg')\n", (63, 89), False, 'import imgkit\n'), ((98, 117), 'cv2.imread', 'cv2.imread', (['"""1.jpg"""'], {}), "('1.jpg')\n", (108, 117), False, 'import cv2\n'), ((134, 162), 'utils.io.load_anno', 'io.... |
import sys
import random
import time
import json
def partition(arr, low, high):
pivot = arr[(high+low)//2]
i = low - 1
j = high + 1
while True:
i += 1
while arr[i] < pivot:
i += 1
j -= 1
while arr[j] > pivot:
j -= 1
if i >= j:
... | [
"sys.exit"
] | [((790, 800), 'sys.exit', 'sys.exit', ([], {}), '()\n', (798, 800), False, 'import sys\n')] |
# Generated by Django 4.0.2 on 2022-03-27 14:17
from django.db import migrations, models
import pictures.models
class Migration(migrations.Migration):
initial = True
dependencies = []
operations = [
migrations.CreateModel(
name="Profile",
fields=[
(
... | [
"django.db.models.PositiveIntegerField",
"django.db.models.CharField",
"django.db.models.BigAutoField"
] | [((363, 459), 'django.db.models.BigAutoField', 'models.BigAutoField', ([], {'auto_created': '(True)', 'primary_key': '(True)', 'serialize': '(False)', 'verbose_name': '"""ID"""'}), "(auto_created=True, primary_key=True, serialize=False,\n verbose_name='ID')\n", (382, 459), False, 'from django.db import migrations, m... |
__all__ = []
import hydra
import wandb
from omegaconf import DictConfig
from pytorch_lightning import LightningModule, Trainer
from pytorch_lightning.loggers import WandbLogger
from src.data.dataloaders import dataloaders
from src.path import CONF_PATH, WEIGHTS_PATH
@hydra.main(config_path=CONF_PATH.as_posix(), con... | [
"src.path.CONF_PATH.as_posix",
"src.data.dataloaders.dataloaders",
"hydra.utils.instantiate",
"pytorch_lightning.loggers.WandbLogger",
"wandb.finish"
] | [((408, 438), 'src.data.dataloaders.dataloaders', 'dataloaders', (['config.batch_size'], {}), '(config.batch_size)\n', (419, 438), False, 'from src.data.dataloaders import dataloaders\n'), ((486, 523), 'hydra.utils.instantiate', 'hydra.utils.instantiate', (['config.model'], {}), '(config.model)\n', (509, 523), False, '... |
from ete3 import NCBITaxa
from Bio import SeqIO
from Bio.Seq import Seq
import os
from tqdm import tqdm
ncbi = NCBITaxa()
with open("data/metadat.csv") as handle:
name2file = { l.split("\t")[0] : l.split("\t")[1][:-1] for l in handle}
species = list(set([" ".join(n.split()[0:2]).replace(" sp.","") for n in nam... | [
"os.path.exists",
"tqdm.tqdm",
"ete3.NCBITaxa",
"Bio.SeqIO.parse",
"Bio.SeqIO.write"
] | [((113, 123), 'ete3.NCBITaxa', 'NCBITaxa', ([], {}), '()\n', (121, 123), False, 'from ete3 import NCBITaxa\n'), ((1907, 1949), 'Bio.SeqIO.write', 'SeqIO.write', (['seqs', '"""mycocosm.faa"""', '"""fasta"""'], {}), "(seqs, 'mycocosm.faa', 'fasta')\n", (1918, 1949), False, 'from Bio import SeqIO\n'), ((1400, 1448), 'os.p... |
import math
def buildSparseTable(arr, n):
for i in range(0, n):
lookup[i][0] = arr[i]
j = 1
while (1 << j) <= n:
i = 0
while (i + (1 << j) - 1) < n:
if (lookup[i][j - 1] <
lookup[i + (1 << (j - 1))][j - 1]):
lookup[i][j] = lookup[i][j - 1]
else:
lookup[i][j] = lookup[i + (1 << (... | [
"math.log2"
] | [((386, 406), 'math.log2', 'math.log2', (['(R - L + 1)'], {}), '(R - L + 1)\n', (395, 406), False, 'import math\n')] |
from __future__ import print_function,division,absolute_import
from CoolProp import AbstractState
#fluid = "R407C"
#fluid = "R32[0.381109419953993]&R125[0.179558888662016]&R134A[0.439331691383991]"
#fluid = "R32[0.40]&R125[0.15]&R134A[0.45]"
fluids = ["R32","R125","R134a"]
moles = [0.381109419953993,0.1795588886620... | [
"CoolProp.Plots.PropertyPlot",
"CoolProp.Plots.Common.process_fluid_state",
"matplotlib.pyplot.show",
"CoolProp.Plots.Common.get_critical_point"
] | [((2765, 2875), 'CoolProp.Plots.Common.process_fluid_state', 'process_fluid_state', (['"""HEOS::R32[0.381109419953993]&R125[0.179558888662016]&R134A[0.439331691383991]"""'], {}), "(\n 'HEOS::R32[0.381109419953993]&R125[0.179558888662016]&R134A[0.439331691383991]'\n )\n", (2784, 2875), False, 'from CoolProp.Plots.... |
from datetime import datetime
from django.conf import settings
import requests
import olympia.core.logger
from olympia.devhub.models import BlogPost
log = olympia.core.logger.getLogger('z.cron')
def update_blog_posts():
"""Update the blog post cache."""
items = requests.get(settings.DEVELOPER_BLOG_URL, ... | [
"datetime.datetime.strptime",
"olympia.devhub.models.BlogPost.objects.count",
"olympia.devhub.models.BlogPost.objects.all",
"requests.get"
] | [((278, 331), 'requests.get', 'requests.get', (['settings.DEVELOPER_BLOG_URL'], {'timeout': '(10)'}), '(settings.DEVELOPER_BLOG_URL, timeout=10)\n', (290, 331), False, 'import requests\n'), ((377, 399), 'olympia.devhub.models.BlogPost.objects.all', 'BlogPost.objects.all', ([], {}), '()\n', (397, 399), False, 'from olym... |
import daiquiri.core.env as env
FILES_BASE_PATH = env.get_abspath('FILES_BASE_PATH')
FILES_BASE_URL = env.get('FILES_BASE_URL')
| [
"daiquiri.core.env.get_abspath",
"daiquiri.core.env.get"
] | [((51, 85), 'daiquiri.core.env.get_abspath', 'env.get_abspath', (['"""FILES_BASE_PATH"""'], {}), "('FILES_BASE_PATH')\n", (66, 85), True, 'import daiquiri.core.env as env\n'), ((103, 128), 'daiquiri.core.env.get', 'env.get', (['"""FILES_BASE_URL"""'], {}), "('FILES_BASE_URL')\n", (110, 128), True, 'import daiquiri.core... |
from PyQt5 import QtCore, QtGui, QtWidgets
from PyQt5.QtGui import *
from PyQt5.QtCore import *
from PyQt5.QtWidgets import *
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
MainWindow.setObjectName("MainWindow")
MainWindow.resize(915, 600)
self.centralwidget = QtWidgets.QWidge... | [
"PyQt5.QtWidgets.QWidget",
"PyQt5.QtCore.QMetaObject.connectSlotsByName",
"PyQt5.QtCore.QRect",
"PyQt5.QtWidgets.QStatusBar",
"PyQt5.QtWidgets.QLabel",
"PyQt5.QtWidgets.QPushButton"
] | [((304, 333), 'PyQt5.QtWidgets.QWidget', 'QtWidgets.QWidget', (['MainWindow'], {}), '(MainWindow)\n', (321, 333), False, 'from PyQt5 import QtCore, QtGui, QtWidgets\n'), ((423, 464), 'PyQt5.QtWidgets.QPushButton', 'QtWidgets.QPushButton', (['self.centralwidget'], {}), '(self.centralwidget)\n', (444, 464), False, 'from ... |
import sys
import django
django.setup()
from busshaming.data_processing import realtime_validator
if __name__ == '__main__':
if len(sys.argv) != 2:
print(f'Usage: {sys.argv[0]} <route_id>')
sys.exit(1)
realtime_validator.validate_route(sys.argv[1])
| [
"busshaming.data_processing.realtime_validator.validate_route",
"django.setup",
"sys.exit"
] | [((25, 39), 'django.setup', 'django.setup', ([], {}), '()\n', (37, 39), False, 'import django\n'), ((230, 276), 'busshaming.data_processing.realtime_validator.validate_route', 'realtime_validator.validate_route', (['sys.argv[1]'], {}), '(sys.argv[1])\n', (263, 276), False, 'from busshaming.data_processing import realti... |
# MIT Licence
# Methods to predict the SSIM, taken from
# https://github.com/Po-Hsun-Su/pytorch-ssim/blob/master/pytorch_ssim/__init__.py
from math import exp
import torch
import torch.nn.functional as F
from torch.autograd import Variable
def gaussian(window_size, sigma):
gauss = torch.Tensor(
[
... | [
"torch.nn.functional.conv2d",
"numpy.transpose",
"cv2.imread",
"numpy.expand_dims"
] | [((884, 948), 'torch.nn.functional.conv2d', 'F.conv2d', (['img1', 'window'], {'padding': '(window_size // 2)', 'groups': 'channel'}), '(img1, window, padding=window_size // 2, groups=channel)\n', (892, 948), True, 'import torch.nn.functional as F\n'), ((959, 1023), 'torch.nn.functional.conv2d', 'F.conv2d', (['img2', 'w... |
#!/usr/bin/env python3
"""
Validate configuration files using the provided schemas.
"""
import json
import os
import re
import sys
import jsonschema
RE_LANGUAGE = re.compile(r'[.][a-z]+$')
RE_COMMENT = re.compile(r'^\s*[/]{2}.*$', flags=re.MULTILINE)
VERBOSE = False
SUCCESS_CODE = 0
if '-v' in sys.argv:
VERBOS... | [
"jsonschema.Draft4Validator",
"os.listdir",
"re.compile",
"os.path.join",
"sys.argv.remove",
"os.path.isfile",
"sys.exit",
"json.load",
"re.search"
] | [((166, 190), 're.compile', 're.compile', (['"""[.][a-z]+$"""'], {}), "('[.][a-z]+$')\n", (176, 190), False, 'import re\n'), ((205, 253), 're.compile', 're.compile', (['"""^\\\\s*[/]{2}.*$"""'], {'flags': 're.MULTILINE'}), "('^\\\\s*[/]{2}.*$', flags=re.MULTILINE)\n", (215, 253), False, 'import re\n'), ((625, 662), 'os... |
'''
XlPy/Link_Finder/search/single
______________________________
Checks if a sequenced peptide matches back to an unsequenced,
theoretical peptide massfingerprint.
:copyright: (c) 2015 The Regents of the University of California.
:license: GNU GPL, see licenses/GNU GPLv3.txt for more details.... | [
"collections.namedtuple",
"xldlib.utils.iterables.num_product",
"numpy.where",
"xldlib.chemical.Molecule",
"numpy.array",
"models.data.unpack_data.__get__",
"copy.deepcopy",
"xlpy.tools.mass.PrecursorMass.calculate_mass.__get__"
] | [((1147, 1189), 'collections.namedtuple', 'namedtuple', (['"""MS1"""', '"""ends basemass mass mz"""'], {}), "('MS1', 'ends basemass mass mz')\n", (1157, 1189), False, 'from collections import namedtuple\n'), ((1202, 1259), 'collections.namedtuple', 'namedtuple', (['"""Search"""', '"""ends basemass mass mz ppm exper z""... |
import numpy as np
def sqsum(a):
"""
Calculate the squared sum of a list
Parameters
----------
a: list
the list of numbers to be calculated
Return
------
float
the squared sum
Examples
--------
>>> a = [1, 2, 3]
>>> sqsum(a)
14
"""
a... | [
"numpy.array",
"numpy.sum"
] | [((323, 334), 'numpy.array', 'np.array', (['a'], {}), '(a)\n', (331, 334), True, 'import numpy as np\n'), ((346, 360), 'numpy.sum', 'np.sum', (['(a ** 2)'], {}), '(a ** 2)\n', (352, 360), True, 'import numpy as np\n')] |
import comedi
import time
com = comedi.comedi_open("/dev/comedi0")
# start (or resume) recording
print('starting recording')
# set strobe pin low
comedi.comedi_dio_bitfield2(com, 0, 1, 0, 16)
# set last data pin ("D15"; 16th pin) high
comedi.comedi_dio_bitfield2(com, 0, 1, 1, 15)
# set strobe pin high
comedi.comed... | [
"comedi.comedi_dio_bitfield2",
"comedi.comedi_open",
"time.sleep"
] | [((33, 67), 'comedi.comedi_open', 'comedi.comedi_open', (['"""/dev/comedi0"""'], {}), "('/dev/comedi0')\n", (51, 67), False, 'import comedi\n'), ((149, 194), 'comedi.comedi_dio_bitfield2', 'comedi.comedi_dio_bitfield2', (['com', '(0)', '(1)', '(0)', '(16)'], {}), '(com, 0, 1, 0, 16)\n', (176, 194), False, 'import comed... |