code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
import logging
import os
import tempfile
from pathlib import Path
from cached_path.common import PathOrStr
logger = logging.getLogger(__name__)
class CacheFile:
"""
This is a context manager that makes robust caching easier.
On `__enter__`, an IO handle to a temporarily file is returned, which can
... | [
"logging.getLogger",
"pathlib.Path",
"os.replace",
"os.path.dirname",
"tempfile.NamedTemporaryFile",
"os.remove"
] | [((118, 145), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (135, 145), False, 'import logging\n'), ((659, 679), 'pathlib.Path', 'Path', (['cache_filename'], {}), '(cache_filename)\n', (663, 679), False, 'from pathlib import Path\n'), ((711, 747), 'os.path.dirname', 'os.path.dirname', ([... |
from setuptools import setup
setup(name='ramscube',
version='0.1',
description='Load RAMS output into iris cubes',
url='http://github.com/mheikenfeld/wrfcube',
author='<NAME>',
author_email='<EMAIL>',
license='GNU',
packages=['ramscube'],
install_requires=[],#['iris','nu... | [
"setuptools.setup"
] | [((30, 295), 'setuptools.setup', 'setup', ([], {'name': '"""ramscube"""', 'version': '"""0.1"""', 'description': '"""Load RAMS output into iris cubes"""', 'url': '"""http://github.com/mheikenfeld/wrfcube"""', 'author': '"""<NAME>"""', 'author_email': '"""<EMAIL>"""', 'license': '"""GNU"""', 'packages': "['ramscube']", ... |
import tensorflow_probability as tfp
import tensorflow as tf
from .settings import float_type
class ConstrainedBijector(tfp.bijectors.Chain):
def __init__(self,a,b,validate_args=False):
"""
Create a bijector that constrains the value to (a,b)
:param a: float scalar
... | [
"tensorflow.atan2",
"tensorflow_probability.bijectors.Softplus",
"tensorflow_probability.bijectors.Identity",
"tensorflow.acos",
"tensorflow.log",
"tensorflow_probability.bijectors.Sigmoid",
"tensorflow_probability.bijectors.AffineScalar",
"tensorflow.reshape",
"tensorflow.convert_to_tensor",
"ten... | [((550, 585), 'tensorflow.convert_to_tensor', 'tf.convert_to_tensor', (['a', 'float_type'], {}), '(a, float_type)\n', (570, 585), True, 'import tensorflow as tf\n'), ((603, 638), 'tensorflow.convert_to_tensor', 'tf.convert_to_tensor', (['b', 'float_type'], {}), '(b, float_type)\n', (623, 638), True, 'import tensorflow ... |
#! /usr/bin/env python
"""
Modul zawiera testy klasy LongestNonEmptyDiagonalFeature
"""
import unittest
from bitmap.bitmap_grayscale import BitmapGrayscale
from feature.simple_features.longest_non_empty_diagonal_feature import LongestNonEmptyDiagonalFeature
from tests.bitmap_generator import BitmapGenerator
class ... | [
"feature.simple_features.longest_non_empty_diagonal_feature.LongestNonEmptyDiagonalFeature",
"tests.bitmap_generator.BitmapGenerator.plain_black"
] | [((492, 528), 'feature.simple_features.longest_non_empty_diagonal_feature.LongestNonEmptyDiagonalFeature', 'LongestNonEmptyDiagonalFeature', (['(0.05)'], {}), '(0.05)\n', (522, 528), False, 'from feature.simple_features.longest_non_empty_diagonal_feature import LongestNonEmptyDiagonalFeature\n'), ((1060, 1099), 'tests.... |
from django.conf import settings
from rest_framework.routers import DefaultRouter, SimpleRouter
from invoice_management_system.invoice_manager.api.urls import router as invoice_router
if settings.DEBUG:
router = DefaultRouter()
else:
router = SimpleRouter()
app_name = "api"
urlpatterns = invoice_router.urls... | [
"rest_framework.routers.SimpleRouter",
"rest_framework.routers.DefaultRouter"
] | [((217, 232), 'rest_framework.routers.DefaultRouter', 'DefaultRouter', ([], {}), '()\n', (230, 232), False, 'from rest_framework.routers import DefaultRouter, SimpleRouter\n'), ((252, 266), 'rest_framework.routers.SimpleRouter', 'SimpleRouter', ([], {}), '()\n', (264, 266), False, 'from rest_framework.routers import De... |
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
# SPDX-License-Identifier: MIT-0
import json
import logging
import sys
import boto3
import research_pacs.shared.dicom_util as rpacs_dicom_util
import research_pacs.shared.util as rpacs_util
from research_pacs.de_identifier.dicom import DicomDeident... | [
"logging.getLogger",
"boto3.client",
"research_pacs.shared.database.DBKeyJsonValue",
"research_pacs.de_identifier.dicom.DicomDeidentifier",
"research_pacs.shared.util.load_file",
"research_pacs.shared.database.DB",
"sys.exit",
"research_pacs.shared.database.DBDicomMapping",
"research_pacs.shared.ort... | [((584, 611), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (601, 611), False, 'import logging\n'), ((630, 651), 'logging.NullHandler', 'logging.NullHandler', ([], {}), '()\n', (649, 651), False, 'import logging\n'), ((1595, 1622), 'research_pacs.shared.util.GracefulKiller', 'rpacs_util.... |
from http.server import HTTPServer
import sys
class HTTP_Server(HTTPServer):
def __init__(self, host, handler):
super(HTTPServer, self).__init__(host, handler)
def handle_error(self, request, client_address):
"""Handle an error gracefully. May be overridden.
The default is to print ... | [
"sys.exc_info",
"traceback.print_exc"
] | [((716, 737), 'traceback.print_exc', 'traceback.print_exc', ([], {}), '()\n', (735, 737), False, 'import traceback\n'), ((378, 392), 'sys.exc_info', 'sys.exc_info', ([], {}), '()\n', (390, 392), False, 'import sys\n')] |
import subprocess
import yaml
from charmhelpers.core import hookenv
from charmhelpers.core.unitdata import kv
def log(msg, *args):
hookenv.log(msg.format(*args), hookenv.INFO)
def log_err(msg, *args):
hookenv.log(msg.format(*args), hookenv.ERROR)
def get_credentials():
"""
Get the credentials fr... | [
"charmhelpers.core.hookenv.status_set",
"charmhelpers.core.unitdata.kv",
"subprocess.run",
"charmhelpers.core.hookenv.config"
] | [((434, 450), 'charmhelpers.core.hookenv.config', 'hookenv.config', ([], {}), '()\n', (448, 450), False, 'from charmhelpers.core import hookenv\n'), ((941, 1039), 'subprocess.run', 'subprocess.run', (["['credential-get']"], {'check': '(True)', 'stdout': 'subprocess.PIPE', 'stderr': 'subprocess.PIPE'}), "(['credential-g... |
import easycorrector.confusion_model.load_model as load_model
import easycorrector.common.common as common
model_name = "confusion_model"
def correct(text):
confusions = load_model.get_confusion_model()
result = []
for err, right in confusions.items():
idx = text.find(err)
if idx > -1:
... | [
"easycorrector.common.common.CorrectItem",
"easycorrector.confusion_model.load_model.get_confusion_model"
] | [((177, 209), 'easycorrector.confusion_model.load_model.get_confusion_model', 'load_model.get_confusion_model', ([], {}), '()\n', (207, 209), True, 'import easycorrector.confusion_model.load_model as load_model\n'), ((436, 497), 'easycorrector.common.common.CorrectItem', 'common.CorrectItem', ([], {'start': '(idx + i)'... |
from django import forms
class UserForm(forms.Form):
username = forms.CharField(label="Soundcloud username", max_length = 100) | [
"django.forms.CharField"
] | [((69, 129), 'django.forms.CharField', 'forms.CharField', ([], {'label': '"""Soundcloud username"""', 'max_length': '(100)'}), "(label='Soundcloud username', max_length=100)\n", (84, 129), False, 'from django import forms\n')] |
# -*- coding: utf-8 -*-
import sys
import os
PROJECT_ROOT = os.path.join(os.path.realpath(os.path.dirname(__file__)), '..', '..', '..', '..', '..', '..')
sys.path.append(os.path.join(PROJECT_ROOT, 'pythonlib'))
import unittest
import json
from copy import deepcopy
from jsonschema import validate, ValidationError
... | [
"os.path.join",
"unittest.main",
"os.path.dirname",
"jsonschema.validate",
"copy.deepcopy",
"json.load"
] | [((172, 211), 'os.path.join', 'os.path.join', (['PROJECT_ROOT', '"""pythonlib"""'], {}), "(PROJECT_ROOT, 'pythonlib')\n", (184, 211), False, 'import os\n'), ((423, 436), 'json.load', 'json.load', (['fh'], {}), '(fh)\n', (432, 436), False, 'import json\n'), ((498, 514), 'copy.deepcopy', 'deepcopy', (['SCHEMA'], {}), '(S... |
#!/usr/bin/env python
from mergecli.mergecli import main
if __name__ == '__main__':
main() | [
"mergecli.mergecli.main"
] | [((90, 96), 'mergecli.mergecli.main', 'main', ([], {}), '()\n', (94, 96), False, 'from mergecli.mergecli import main\n')] |
from test_autolens.integration.tests.imaging.lens_only import lens_x2_light__separate
from test_autolens.integration.tests.imaging.runner import run_a_mock
class TestCase:
def _test__lens_x2_light__separate(self):
run_a_mock(lens_x2_light__separate)
| [
"test_autolens.integration.tests.imaging.runner.run_a_mock"
] | [((228, 263), 'test_autolens.integration.tests.imaging.runner.run_a_mock', 'run_a_mock', (['lens_x2_light__separate'], {}), '(lens_x2_light__separate)\n', (238, 263), False, 'from test_autolens.integration.tests.imaging.runner import run_a_mock\n')] |
try:
import pegtree as pg
except ModuleNotFoundError:
import os
os.system('pip install pegtree')
import pegtree as pg
import re
# 前処理
peg = pg.grammar('nlpcode.pegtree')
parser = pg.generate(peg)
def fix(tree):
a = [tree.epos_]
for t in tree:
a.append(fix(t).epos_)
for key in tre... | [
"pegtree.generate",
"pegtree.grammar",
"os.system"
] | [((158, 187), 'pegtree.grammar', 'pg.grammar', (['"""nlpcode.pegtree"""'], {}), "('nlpcode.pegtree')\n", (168, 187), True, 'import pegtree as pg\n'), ((197, 213), 'pegtree.generate', 'pg.generate', (['peg'], {}), '(peg)\n', (208, 213), True, 'import pegtree as pg\n'), ((76, 108), 'os.system', 'os.system', (['"""pip ins... |
import pygame
pygame.mixer.init()
pygame.init()
pygame.mixer.music.load('asus-yamete-kudasai.mp3')
pygame.mixer.music.play()
pygame.event.wait()
| [
"pygame.mixer.init",
"pygame.init",
"pygame.event.wait",
"pygame.mixer.music.load",
"pygame.mixer.music.play"
] | [((14, 33), 'pygame.mixer.init', 'pygame.mixer.init', ([], {}), '()\n', (31, 33), False, 'import pygame\n'), ((34, 47), 'pygame.init', 'pygame.init', ([], {}), '()\n', (45, 47), False, 'import pygame\n'), ((48, 98), 'pygame.mixer.music.load', 'pygame.mixer.music.load', (['"""asus-yamete-kudasai.mp3"""'], {}), "('asus-y... |
from service_bundle import ServiceBundle
import json
import logging
import config
import sdk_cmd
log = logging.getLogger(__name__)
class BaseTechBundle(ServiceBundle):
def __init__(self, package_name, service_name, scheduler_tasks, service, output_directory):
self.package_name = package_name
se... | [
"logging.getLogger",
"json.loads",
"sdk_cmd.svc_cli"
] | [((105, 132), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (122, 132), False, 'import logging\n'), ((849, 938), 'sdk_cmd.svc_cli', 'sdk_cmd.svc_cli', (['self.package_name', 'self.service_name', '"""describe"""'], {'print_output': '(False)'}), "(self.package_name, self.service_name, 'des... |
import os
import csv
import codecs
import logging
import pandas
__author__ = 'robodasha'
__email__ = '<EMAIL>'
class DataParser(object):
# mapping of columns in the responses.csv file
_MAPPING = {
'response': {
0: 'timestamp', 1: 'research_area', 2: 'research_area_details',
... | [
"logging.getLogger",
"os.path.join",
"pandas.DataFrame",
"codecs.open",
"pandas.notnull",
"csv.reader"
] | [((898, 925), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (915, 925), False, 'import logging\n'), ((2524, 2560), 'pandas.DataFrame', 'pandas.DataFrame', (['data'], {'columns': 'cols'}), '(data, columns=cols)\n', (2540, 2560), False, 'import pandas\n'), ((2952, 3008), 'codecs.open', 'co... |
import unittest
import lib.MessageFormatter as MessageFormatter
class MoccaMessageFormatterTests(unittest.TestCase):
def test_can_set_verbosity_level(self):
MessageFormatter.set_verbosity(MessageFormatter.V_INFO)
self.assertEqual(MessageFormatter.verbosity, MessageFormatter.V_INFO)
Messag... | [
"lib.MessageFormatter._should_log",
"lib.MessageFormatter.set_verbosity"
] | [((171, 226), 'lib.MessageFormatter.set_verbosity', 'MessageFormatter.set_verbosity', (['MessageFormatter.V_INFO'], {}), '(MessageFormatter.V_INFO)\n', (201, 226), True, 'import lib.MessageFormatter as MessageFormatter\n'), ((314, 370), 'lib.MessageFormatter.set_verbosity', 'MessageFormatter.set_verbosity', (['MessageF... |
# ------------------------------------------------------------------------------
# CodeHawk Binary Analyzer
# Author: <NAME>
# ------------------------------------------------------------------------------
# The MIT License (MIT)
#
# Copyright (c) 2021 Aarno Labs, LLC
#
# Permission is hereby granted, free of charge, t... | [
"xml.etree.ElementTree.Element",
"chb.util.fileutil.CHBError"
] | [((4518, 4535), 'xml.etree.ElementTree.Element', 'ET.Element', (['"""ptr"""'], {}), "('ptr')\n", (4528, 4535), True, 'import xml.etree.ElementTree as ET\n'), ((5323, 5342), 'xml.etree.ElementTree.Element', 'ET.Element', (['"""array"""'], {}), "('array')\n", (5333, 5342), True, 'import xml.etree.ElementTree as ET\n'), (... |
import numpy as np
from cleanlab.pruning import get_noise_indices
class ProbaReason:
"""
Assign doubt based on low proba-confidence values from a scikit-learn model.
Arguments:
model: scikit-learn classifier
max_proba: maximum probability threshold for doubt assignment
Usage:
``... | [
"numpy.where",
"numpy.sort",
"numpy.array",
"numpy.linspace",
"numpy.random.seed",
"cleanlab.pruning.get_noise_indices",
"numpy.zeros_like"
] | [((1734, 1766), 'numpy.random.seed', 'np.random.seed', (['self.random_seed'], {}), '(self.random_seed)\n', (1748, 1766), True, 'import numpy as np\n'), ((1828, 1872), 'numpy.where', 'np.where', (['(rvals < self.probability)', 'rvals', '(0)'], {}), '(rvals < self.probability, rvals, 0)\n', (1836, 1872), True, 'import nu... |
import socket
import urllib.parse
from selectors import EVENT_WRITE, EVENT_READ
from ..core.eventloop import Loop, LoopManager
from .model import Response
from ..core.eventQueue import EventQueueManager
@LoopManager.asyncapi
def get(*, url, callback, asyncDone):
urlObj = urllib.parse.urlparse(url)
selector = ... | [
"socket.socket"
] | [((359, 374), 'socket.socket', 'socket.socket', ([], {}), '()\n', (372, 374), False, 'import socket\n')] |
import logging
import platform
import sys
import time
def add_http_prefix(url):
return url if url.startswith("http://") or url.startswith("https://") else "http://" + url
# def mqtt_broker_info(val):
# # Broker hostname can be either "localhost" or "localhost:999"
# return (val[:val.index(":")], int(val[v... | [
"logging.basicConfig",
"platform.system",
"time.time",
"time.sleep"
] | [((402, 419), 'platform.system', 'platform.system', ([], {}), '()\n', (417, 419), False, 'import platform\n'), ((683, 697), 'time.sleep', 'time.sleep', (['(60)'], {}), '(60)\n', (693, 697), False, 'import time\n'), ((1240, 1329), 'logging.basicConfig', 'logging.basicConfig', ([], {'filename': 'filename', 'filemode': 'f... |
import sys
import time
id=0 # first token of each row is a an object id
prevId=0 # variable used to determine when id changes
index={} # id:[startLine,endLine]
offset=0 # number of bytes from beginning of file
line_offset=[] # ordered list of start of each line, in bytes from ... | [
"time.time"
] | [((1372, 1383), 'time.time', 'time.time', ([], {}), '()\n', (1381, 1383), False, 'import time\n'), ((1459, 1470), 'time.time', 'time.time', ([], {}), '()\n', (1468, 1470), False, 'import time\n')] |
#program to locate Python site-packages.
import site
def main():
return (site.getsitepackages())
print(main()) | [
"site.getsitepackages"
] | [((78, 100), 'site.getsitepackages', 'site.getsitepackages', ([], {}), '()\n', (98, 100), False, 'import site\n')] |
import numpy as np
import tensorflow as tf
class spectral_conv_layer(object):
def __init__(self, input_x, in_channel, out_channel,
kernel_size, random_seed, data_format='NHWC', index=0):
"""
A convolutional layer with spectrally-parameterized weights.
:param input_x: Shou... | [
"tensorflow.nn.conv2d",
"tensorflow.glorot_uniform_initializer",
"numpy.sqrt",
"tensorflow.variable_scope",
"tensorflow.transpose",
"tensorflow.imag",
"tensorflow.ifft2d",
"tensorflow.real",
"tensorflow.name_scope",
"tensorflow.fft2d",
"numpy.random.uniform",
"tensorflow.nn.bias_add"
] | [((1129, 1156), 'numpy.sqrt', 'np.sqrt', (['(6 / (n_in + n_out))'], {}), '(6 / (n_in + n_out))\n', (1136, 1156), True, 'import numpy as np\n'), ((1176, 1267), 'numpy.random.uniform', 'np.random.uniform', ([], {'low': '(-limit)', 'high': 'limit', 'size': '(n_in, n_out, kernel_size, kernel_size)'}), '(low=-limit, high=li... |
# type: ignore
__all__ = ["linspace", "py_linspace"]
from mat2py.core import *
from mat2py.core._internal.helper import mp_inference_nargin_decorators
py_linspace = linspace
@mp_inference_nargin_decorators()
def linspace(d1=None, d2=None, n=None, nargin=None):
if nargin == 2:
n = 100
else:
... | [
"mat2py.core._internal.helper.mp_inference_nargin_decorators"
] | [((180, 212), 'mat2py.core._internal.helper.mp_inference_nargin_decorators', 'mp_inference_nargin_decorators', ([], {}), '()\n', (210, 212), False, 'from mat2py.core._internal.helper import mp_inference_nargin_decorators\n')] |
"""Create exam and exam question tables.
Revision ID: fd27cccb76f7
Revises: <KEY>
Create Date: 2017-11-27 11:37:54.705955
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision = 'fd27cccb76f7'
down_revision = '<KEY>'
branch_labels = None
depends_on = None
def upgrade... | [
"alembic.op.drop_table",
"sqlalchemy.ForeignKey",
"sqlalchemy.Column"
] | [((798, 828), 'alembic.op.drop_table', 'op.drop_table', (['"""exam_question"""'], {}), "('exam_question')\n", (811, 828), False, 'from alembic import op\n'), ((833, 854), 'alembic.op.drop_table', 'op.drop_table', (['"""exam"""'], {}), "('exam')\n", (846, 854), False, 'from alembic import op\n'), ((372, 417), 'sqlalchem... |
# coding: utf-8
import cuisine
import fabric.api as fab
import fabix
def install():
fabix.system.apt_import_pubkey('7F0CEB10')
fabix.system.apt_add_repository('10gen', 'dist', 'http://downloads-distro.mongodb.org/repo/ubuntu-upstart')
cuisine.package_update()
cuisine.package_upgrade()
cuisine.pac... | [
"fabix.system.apt_import_pubkey",
"cuisine.dir_ensure",
"fabix.system.upstart.restart",
"cuisine.package_install",
"cuisine.package_update",
"fabix.system.apt_add_repository",
"cuisine.mode_sudo",
"cuisine.package_upgrade"
] | [((91, 133), 'fabix.system.apt_import_pubkey', 'fabix.system.apt_import_pubkey', (['"""7F0CEB10"""'], {}), "('7F0CEB10')\n", (121, 133), False, 'import fabix\n'), ((138, 249), 'fabix.system.apt_add_repository', 'fabix.system.apt_add_repository', (['"""10gen"""', '"""dist"""', '"""http://downloads-distro.mongodb.org/rep... |
# exercise 3.1.4
from sklearn.feature_extraction.text import CountVectorizer
# As before, load the corpus and preprocess:
with open('../Data/textDocs.txt', 'r') as f:
raw_file = f.read()
corpus = raw_file.split('\n')
corpus = list(filter(None, corpus))
# Load and process the stop words in a similar manner:
with o... | [
"sklearn.feature_extraction.text.CountVectorizer"
] | [((495, 566), 'sklearn.feature_extraction.text.CountVectorizer', 'CountVectorizer', ([], {'token_pattern': '"""\\\\b[^\\\\d\\\\W]+\\\\b"""', 'stop_words': 'stopwords'}), "(token_pattern='\\\\b[^\\\\d\\\\W]+\\\\b', stop_words=stopwords)\n", (510, 566), False, 'from sklearn.feature_extraction.text import CountVectorizer\... |
import pytest
from freshbooks.models import ListResult
from tests import get_fixture
class TestListResult:
def test_adding_list_results(self):
data_1 = get_fixture("list_clients_response")["response"]["result"]
client_results_1 = ListResult("clients", "client", data_1)
assert len(client_... | [
"freshbooks.models.ListResult",
"pytest.raises",
"tests.get_fixture"
] | [((254, 293), 'freshbooks.models.ListResult', 'ListResult', (['"""clients"""', '"""client"""', 'data_1'], {}), "('clients', 'client', data_1)\n", (264, 293), False, 'from freshbooks.models import ListResult\n'), ((562, 601), 'freshbooks.models.ListResult', 'ListResult', (['"""clients"""', '"""client"""', 'data_2'], {})... |
import math
from functools import partial
import torch
import torch.nn as nn
import torch.nn.functional as F
import torchvision
from torch.distributions import Categorical, Independent, MixtureSameFamily, Normal
from torch.nn.modules.conv import Conv2d
import einops
from .helpers import Delta, batch_flatten, batch_u... | [
"torch.nn.functional.softplus",
"torch.as_tensor",
"torch.distributions.Normal",
"einops.rearrange"
] | [((3510, 3538), 'torch.distributions.Normal', 'Normal', (['diag_loc', 'diag_scale'], {}), '(diag_loc, diag_scale)\n', (3516, 3538), False, 'from torch.distributions import Categorical, Independent, MixtureSameFamily, Normal\n'), ((3724, 3748), 'torch.nn.functional.softplus', 'F.softplus', (['diag_log_var'], {}), '(diag... |
import grpc
import pi_pb2
import pi_pb2_grpc
from concurrent import futures
def pi(client, k):
return client.Calc(pi_pb2.PiRequest(n=k)).value
def main():
channel = grpc.insecure_channel('localhost:8080')
client = pi_pb2_grpc.PiCalculatorStub(channel)
pool = futures.ThreadPoolExecutor(max_workers=1... | [
"concurrent.futures.ThreadPoolExecutor",
"pi_pb2_grpc.PiCalculatorStub",
"grpc.insecure_channel",
"pi_pb2.PiRequest"
] | [((178, 217), 'grpc.insecure_channel', 'grpc.insecure_channel', (['"""localhost:8080"""'], {}), "('localhost:8080')\n", (199, 217), False, 'import grpc\n'), ((231, 268), 'pi_pb2_grpc.PiCalculatorStub', 'pi_pb2_grpc.PiCalculatorStub', (['channel'], {}), '(channel)\n', (259, 268), False, 'import pi_pb2_grpc\n'), ((280, 3... |
import click
from coder.app import create_app
from coder.extensions import db
from coder.blueprints.billing.gateways.stripecom import Plan as PaymentPlan
# Create an app context for the database connection.
app = create_app()
db.app = app
@click.group()
def cli():
""" Perform various tasks with Stripe's API. ""... | [
"coder.app.create_app",
"coder.blueprints.billing.gateways.stripecom.Plan.list",
"click.argument",
"click.group",
"coder.blueprints.billing.gateways.stripecom.Plan.delete",
"coder.blueprints.billing.gateways.stripecom.Plan.create",
"click.command"
] | [((215, 227), 'coder.app.create_app', 'create_app', ([], {}), '()\n', (225, 227), False, 'from coder.app import create_app\n'), ((244, 257), 'click.group', 'click.group', ([], {}), '()\n', (255, 257), False, 'import click\n'), ((334, 349), 'click.command', 'click.command', ([], {}), '()\n', (347, 349), False, 'import c... |
import datetime
import logging
import time
from typing import Optional
from detectron2.utils.events import EventWriter
from supervisely.app.v1.widgets.compare_gallery import CompareGallery
import sly_globals as g
import os
def preview_predictions(gt_image, pred_image):
gallery_preview = CompareGallery(g.task_i... | [
"supervisely.app.v1.widgets.compare_gallery.CompareGallery",
"sly_globals.sly.image.write",
"sly_globals.api.app.set_fields",
"sly_globals.api.app.set_field",
"sly_globals.api.app.get_field",
"time.time"
] | [((297, 369), 'supervisely.app.v1.widgets.compare_gallery.CompareGallery', 'CompareGallery', (['g.task_id', 'g.api', 'f"""data.galleryPreview"""', 'g.project_meta'], {}), "(g.task_id, g.api, f'data.galleryPreview', g.project_meta)\n", (311, 369), False, 'from supervisely.app.v1.widgets.compare_gallery import CompareGal... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
'''
GOAL
Save Arctic ocean temperature - Pacific side (thetao)
PROGRAMMER
<NAME>
LAST UPDATE
29/04/2020
'''
# Standard libraries
import numpy as np
from netCDF4 import Dataset
# Options
exp = 'D013'
save_var = True
start_year = 2130
end_year = 2179
# Time pa... | [
"numpy.arange",
"netCDF4.Dataset",
"numpy.nanmean",
"numpy.zeros",
"numpy.save"
] | [((825, 852), 'netCDF4.Dataset', 'Dataset', (['filename'], {'mode': '"""r"""'}), "(filename, mode='r')\n", (832, 852), False, 'from netCDF4 import Dataset\n'), ((1067, 1094), 'netCDF4.Dataset', 'Dataset', (['filename'], {'mode': '"""r"""'}), "(filename, mode='r')\n", (1074, 1094), False, 'from netCDF4 import Dataset\n'... |
import os
import sys
import pyx
import argparse
import layouts
import samplers
import data_loader
def main(arguments):
parser = argparse.ArgumentParser(description='Generate clustering visualizations.')
parser.add_argument(
'--tables_dir', dest='tables_dir', default='input/tables',
help='conte... | [
"os.path.exists",
"samplers.available_names",
"argparse.ArgumentParser",
"os.makedirs",
"data_loader.DataLoader",
"pyx.trafo.scale",
"layouts.from_name",
"layouts.available_names",
"sys.exit",
"pyx.canvas.canvas",
"samplers.from_name"
] | [((134, 208), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Generate clustering visualizations."""'}), "(description='Generate clustering visualizations.')\n", (157, 208), False, 'import argparse\n'), ((1330, 1361), 'os.path.exists', 'os.path.exists', (['args.output_dir'], {}), '(args.o... |
from scipy.integrate import odeint
import matplotlib.pyplot as plt
import numpy as np
def radial(y, r, m, k, a, l, E):
"""
Radial ODE with an exponential well
φ = dψ/dr
dφ/dr = -2φ/r - (2m(E-ke^ar) - (l(l+1)/r^2))ψ
:param y: (np.ndarray) First order ODEs
--------------------- all in atomic... | [
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.plot",
"numpy.exp",
"numpy.array",
"numpy.linspace",
"matplotlib.pyplot.ylim",
"matplotlib.pyplot.legend"
] | [((1002, 1035), 'numpy.linspace', 'np.linspace', (['(0.01)', '(10.0)'], {'num': '(2000)'}), '(0.01, 10.0, num=2000)\n', (1013, 1035), True, 'import numpy as np\n'), ((1184, 1207), 'matplotlib.pyplot.plot', 'plt.plot', (['rs', 'sol[:, 0]'], {}), '(rs, sol[:, 0])\n', (1192, 1207), True, 'import matplotlib.pyplot as plt\n... |
from flask import Flask, request, redirect, render_template, session, flash
from flask_sqlalchemy import SQLAlchemy
import cgi
from bcrypt import gensalt, hashpw,checkpw
from app import app, db
from models import Blog, User
@app.route("/login", methods=['GET', 'POST'])
def login():
if request.method == 'GET':
... | [
"flask.render_template",
"flask.request.args.get",
"app.app.run",
"app.db.session.commit",
"flask.flash",
"models.User.query.filter_by",
"models.User.query.all",
"flask.redirect",
"models.Blog.query.all",
"app.app.route",
"models.User",
"app.db.session.add",
"bcrypt.gensalt",
"models.Blog.... | [((226, 270), 'app.app.route', 'app.route', (['"""/login"""'], {'methods': "['GET', 'POST']"}), "('/login', methods=['GET', 'POST'])\n", (235, 270), False, 'from app import app, db\n'), ((954, 1001), 'app.app.route', 'app.route', (['"""/register"""'], {'methods': "['GET', 'POST']"}), "('/register', methods=['GET', 'POS... |
import requests
from bs4 import BeautifulSoup
import re
titleList = ['题名与责任', '著者', '出版项', '主题', '中图分类号', '版本项', '丛编项', '内容提要',
'载体形态项', '一般附注']
# print('$'.join(titleList))
# CLC = "g25*" AND WFM = ( BK )
# ( CLC = "g25*" AND WFM = ( BK ) ) and ( WYR = ( 2011 -> 2018 ) )
# ( CLC = "g25*" AND WFM = ( BK... | [
"bs4.BeautifulSoup",
"requests.get",
"re.compile"
] | [((383, 400), 'requests.get', 'requests.get', (['url'], {}), '(url)\n', (395, 400), False, 'import requests\n'), ((412, 458), 'bs4.BeautifulSoup', 'BeautifulSoup', (['response.content', '"""html.parser"""'], {}), "(response.content, 'html.parser')\n", (425, 458), False, 'from bs4 import BeautifulSoup\n'), ((799, 817), ... |
from __future__ import print_function
from setuptools import setup, find_packages
from setuptools.command.test import test as TestCommand
import io
import codecs
import os
import sys
import bgaas
here = os.path.abspath(os.path.dirname(__file__))
def read(*filenames, **kwargs):
encoding = kwargs.get('encoding', '... | [
"setuptools.setup",
"setuptools.command.test.test.finalize_options",
"io.open",
"pytest.main",
"os.path.dirname",
"sys.exit"
] | [((857, 1822), 'setuptools.setup', 'setup', ([], {'name': '"""bgaas"""', 'version': 'bgaas.__version__', 'url': '"""http://github.com/anseljh/bgaas/"""', 'license': '"""Apache Software License"""', 'author': '"""<NAME>"""', 'tests_require': "['pytest']", 'install_requires': "['csvkit', 'argparse', 'requests', 'logging'... |
"""fileread.py unit tests."""
from unittest.mock import mock_open, patch
import pytest
from pypyr.context import Context
from pypyr.errors import KeyInContextHasNoValueError, KeyNotInContextError
import pypyr.steps.fileread as fileread
def test_fileread_no_input_raises():
"""No input."""
context = Context({... | [
"unittest.mock.mock_open",
"pytest.raises",
"pypyr.context.Context",
"pypyr.steps.fileread.run_step"
] | [((311, 332), 'pypyr.context.Context', 'Context', (["{'k1': 'v1'}"], {}), "({'k1': 'v1'})\n", (318, 332), False, 'from pypyr.context import Context\n'), ((711, 750), 'pypyr.context.Context', 'Context', (["{'k1': 'v1', 'fileRead': None}"], {}), "({'k1': 'v1', 'fileRead': None})\n", (718, 750), False, 'from pypyr.context... |
import json
import logging
from channels.generic.websocket import AsyncWebsocketConsumer
from django_redis import get_redis_connection
from competitions.models import Submission
from utils.data import make_url_sassy
logger = logging.getLogger(__name__)
class SubmissionIOConsumer(AsyncWebsocketConsumer):
#
... | [
"logging.getLogger",
"django_redis.get_redis_connection",
"json.loads",
"json.dumps",
"competitions.models.Submission.objects.get",
"competitions.models.Submission.objects.filter"
] | [((228, 255), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (245, 255), False, 'import logging\n'), ((1283, 1304), 'json.loads', 'json.loads', (['text_data'], {}), '(text_data)\n', (1293, 1304), False, 'import json\n'), ((1621, 1652), 'django_redis.get_redis_connection', 'get_redis_conne... |
import os
import subprocess
import sys
from collections import namedtuple
import json
from typing import List, Tuple
HDFSBlock = namedtuple("HDFSBlock", "path hosts")
class FileData(object):
def __init__(self, filename):
self.blocknames = []
self.dnodenames = []
self.machines = []
... | [
"json.dumps",
"collections.namedtuple",
"os.path.join",
"json.dump"
] | [((130, 167), 'collections.namedtuple', 'namedtuple', (['"""HDFSBlock"""', '"""path hosts"""'], {}), "('HDFSBlock', 'path hosts')\n", (140, 167), False, 'from collections import namedtuple\n'), ((1752, 1768), 'json.dumps', 'json.dumps', (['data'], {}), '(data)\n', (1762, 1768), False, 'import json\n'), ((1884, 1902), '... |
from setuptools import find_packages
from setuptools import setup
import setuptools
from distutils.command.build import build as _build
import subprocess
REQUIRED_PACKAGES = [
'transformers',
'datasets',
'tqdm',
'cloudml-hypertune'
]
setup(
name='trainer',
version='0.1',
install_require... | [
"setuptools.find_packages"
] | [((354, 369), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (367, 369), False, 'from setuptools import find_packages\n')] |
# -*- coding: utf-8 -*-
"""
This tutorial will introduce the basic concepts and workflow of mpcpy.
By the end, we will train a simple model based on emulated data, and use
the model to optimize the control signal of the system. All required data
files for this tutorial are located in doc/userGuide/tutorial.
The mod... | [
"doctest.testmod"
] | [((22223, 22240), 'doctest.testmod', 'doctest.testmod', ([], {}), '()\n', (22238, 22240), False, 'import doctest\n')] |
from PySide import QtCore, QtGui
from ui.ui_dlg_setup_networking import Ui_DlgSetupNetworking
class DlgSetupNetworking(QtGui.QDialog, Ui_DlgSetupNetworking):
def __init__(self, parent=None):
super(DlgSetupNetworking, self).__init__(parent)
self.playlist = parent._mixer.default_layer()._playlist
... | [
"PySide.QtGui.QCheckBox",
"PySide.QtGui.QRegExpValidator",
"PySide.QtCore.QRegExp",
"PySide.QtGui.QColor",
"PySide.QtGui.QDialog.accept",
"PySide.QtGui.QTableWidgetItem",
"PySide.QtGui.QIntValidator",
"PySide.QtGui.QMessageBox"
] | [((618, 653), 'PySide.QtGui.QIntValidator', 'QtGui.QIntValidator', (['(1)', '(65535)', 'self'], {}), '(1, 65535, self)\n', (637, 653), False, 'from PySide import QtCore, QtGui\n'), ((673, 791), 'PySide.QtCore.QRegExp', 'QtCore.QRegExp', (['"""(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\\\.){3}(?:25[0-5]|2[0-4][0-9]|[0... |
from selenium.webdriver import Firefox
url = 'http://selenium.dunossauro.live/aula_05_a.html'
firefox = Firefox()
firefox.get(url)
div_py = firefox.find_element_by_id('python')
div_hk = firefox.find_element_by_id('haskell')
print(div_hk.text)
firefox.quit()
| [
"selenium.webdriver.Firefox"
] | [((106, 115), 'selenium.webdriver.Firefox', 'Firefox', ([], {}), '()\n', (113, 115), False, 'from selenium.webdriver import Firefox\n')] |
import os, re, json
# Find number of verses in each chapter of the Bible
verses_by_chapter_dict = {}
path = "C:\\My Paratext 8 Projects\\MP2\\"
for file in os.listdir(path):
if file.endswith(".SFM"):
full_path = path + file
with open(full_path, 'r') as sfm_book:
contents = sfm_book.read... | [
"json.dumps",
"os.listdir",
"re.compile"
] | [((157, 173), 'os.listdir', 'os.listdir', (['path'], {}), '(path)\n', (167, 173), False, 'import os, re, json\n'), ((1007, 1041), 'json.dumps', 'json.dumps', (['verses_by_chapter_dict'], {}), '(verses_by_chapter_dict)\n', (1017, 1041), False, 'import os, re, json\n'), ((350, 396), 're.compile', 're.compile', (['"""(?<=... |
#!/usr/bin/env python3
# SPDX-License-Identifier: MIT
import sys, pathlib
import time
sys.path.append(str(pathlib.Path(__file__).resolve().parents[1]))
from m1n1.setup import *
from m1n1.loadobjs import *
import argparse
import numpy as np
argparser = argparse.ArgumentParser()
argparser.add_argument("-d", "--domain",... | [
"argparse.ArgumentParser",
"pathlib.Path",
"time.sleep",
"numpy.count_nonzero",
"numpy.concatenate",
"sys.exit",
"numpy.frombuffer"
] | [((254, 279), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (277, 279), False, 'import argparse\n'), ((634, 645), 'sys.exit', 'sys.exit', (['(0)'], {}), '(0)\n', (642, 645), False, 'import sys, pathlib\n'), ((1558, 1593), 'numpy.frombuffer', 'np.frombuffer', (['mask'], {'dtype': 'np.uint8'}), ... |
import os
import json
from argparse import ArgumentDefaultsHelpFormatter, ArgumentParser
def main(parse_args):
merged_splits = {}
for splits_path in parse_args.splits_paths:
with open(splits_path, 'r') as f:
splits = json.load(f)
for split_key in splits:
if not split_... | [
"os.path.exists",
"argparse.ArgumentParser",
"os.path.join",
"json.load",
"json.dump"
] | [((507, 577), 'os.path.join', 'os.path.join', (['parse_args.splits_dir', 'parse_args.merged_splits_filename'], {}), '(parse_args.splits_dir, parse_args.merged_splits_filename)\n', (519, 577), False, 'import os\n'), ((791, 807), 'argparse.ArgumentParser', 'ArgumentParser', ([], {}), '()\n', (805, 807), False, 'from argp... |
import sys
import argparse
sys.path.insert(1,'../')
import psycopg2
import itertools
import numpy as np
import argparse
import yaml
from src.utils.game import rules
from src.utils.sql.connections import connect_to_db
from src.utils.sql.queries import drop_table, check_for_table
if __name__=="__main__":
parse... | [
"src.utils.sql.queries.check_for_table",
"sys.path.insert",
"argparse.ArgumentParser",
"src.utils.sql.connections.connect_to_db",
"src.utils.sql.queries.drop_table"
] | [((28, 53), 'sys.path.insert', 'sys.path.insert', (['(1)', '"""../"""'], {}), "(1, '../')\n", (43, 53), False, 'import sys\n'), ((324, 349), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (347, 349), False, 'import argparse\n'), ((659, 674), 'src.utils.sql.connections.connect_to_db', 'connect_t... |
from noloco.fields import DataTypeFieldsBuilder
from noloco.utils import build_operation_args
PROJECT_DOCUMENT_QUERY = '''query ($projectId: String!) {
project(projectId: $projectId) {
id
name
apiKeys {
user
project
__typename
}
dataTypes {
id
name
display
... | [
"noloco.utils.build_operation_args",
"noloco.fields.DataTypeFieldsBuilder"
] | [((1093, 1116), 'noloco.fields.DataTypeFieldsBuilder', 'DataTypeFieldsBuilder', ([], {}), '()\n', (1114, 1116), False, 'from noloco.fields import DataTypeFieldsBuilder\n'), ((1410, 1449), 'noloco.utils.build_operation_args', 'build_operation_args', (['flattened_options'], {}), '(flattened_options)\n', (1430, 1449), Fal... |
#-----------------------------------------------------------------------------
#
# Copyright (c) 2005, 2006 by Enthought, Inc.
# All rights reserved.
#
# Author: <NAME> <<EMAIL>>
# Author: <NAME> <<EMAIL>>
#
#-----------------------------------------------------------------------------
""" A record of refactorings... | [
"logging.getLogger",
"traits.api.Tuple"
] | [((523, 550), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (540, 550), False, 'import logging\n'), ((1376, 1391), 'traits.api.Tuple', 'Tuple', (['Str', 'Str'], {}), '(Str, Str)\n', (1381, 1391), False, 'from traits.api import Dict, HasPrivateTraits, Int, List, Tuple, Str\n'), ((1393, 14... |
#%%
from datetime import datetime
import numpy as np
import pandas as pd
from tqdm import tqdm
# %%
picks = pd.read_csv('gamma_picks.csv', sep="\t")
events = pd.read_csv('gamma_catalog.csv', sep="\t")
# %%
events["match_id"] = events.apply(lambda x: f'{x["event_idx"]}_{x["file_index"]}', axis=1)
picks["match_id"] = ... | [
"datetime.datetime.strptime",
"pandas.read_csv"
] | [((110, 150), 'pandas.read_csv', 'pd.read_csv', (['"""gamma_picks.csv"""'], {'sep': '"""\t"""'}), "('gamma_picks.csv', sep='\\t')\n", (121, 150), True, 'import pandas as pd\n'), ((160, 202), 'pandas.read_csv', 'pd.read_csv', (['"""gamma_catalog.csv"""'], {'sep': '"""\t"""'}), "('gamma_catalog.csv', sep='\\t')\n", (171,... |
"""test_lexosdoc.py."""
# Import a minimal text loader class, the functions for scrubber pipelines,
# and the scrubber function registry
from lexos.io.basic import Loader
from lexos.tokenizer import lexosdoc, make_doc
# Load a text
data = ["tests/test_data/Austen_Pride.txt"]
loader = Loader()
loader.load(data)
# Mak... | [
"lexos.tokenizer.make_doc",
"lexos.tokenizer.lexosdoc.LexosDoc",
"lexos.io.basic.Loader"
] | [((287, 295), 'lexos.io.basic.Loader', 'Loader', ([], {}), '()\n', (293, 295), False, 'from lexos.io.basic import Loader\n'), ((340, 373), 'lexos.tokenizer.make_doc', 'make_doc', (['loader.texts[0][0:1000]'], {}), '(loader.texts[0][0:1000])\n', (348, 373), False, 'from lexos.tokenizer import lexosdoc, make_doc\n'), ((4... |
"""
Demo code
To run our method, you need a bounding box around the person. The person needs to be centered inside the bounding box and the bounding box should be relatively tight. You can either supply the bounding box directly or provide an [OpenPose](https://github.com/CMU-Perceptual-Computing-Lab/openpose) detecti... | [
"utils.renderer.Renderer",
"numpy.radians",
"torch.from_numpy",
"numpy.array",
"torch.cuda.is_available",
"models.hmr",
"os.walk",
"numpy.mean",
"argparse.ArgumentParser",
"torch.eye",
"numpy.issubdtype",
"numpy.dot",
"models.SMPL",
"numpy.round",
"utils.imutils.crop",
"os.path.splitex... | [((2034, 2059), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (2057, 2059), False, 'import argparse\n'), ((4117, 4153), 'numpy.issubdtype', 'np.issubdtype', (['image.dtype', 'np.float'], {}), '(image.dtype, np.float)\n', (4130, 4153), True, 'import numpy as np\n'), ((7841, 7908), 'torchvision.... |
import logging
from collections import defaultdict
from concurrent.futures import FIRST_EXCEPTION, wait
from itertools import product
from pathlib import Path
from typing import Iterable, List, Optional, Tuple, Union
import numpy as np
import pandas as pd
from hermes.typeo import typeo
from rich.progress imp... | [
"bbhnet.io.timeslides.TimeSlide",
"bbhnet.logging.configure_logging",
"pandas.read_csv",
"itertools.product",
"bbhnet.analysis.analysis.integrate",
"collections.defaultdict",
"rich.progress.Progress",
"bbhnet.analysis.normalizers.GaussianNormalizer",
"pandas.concat",
"pandas.DataFrame",
"bbhnet.... | [((6640, 6657), 'collections.defaultdict', 'defaultdict', (['list'], {}), '(list)\n', (6651, 6657), False, 'from collections import defaultdict\n'), ((12423, 12495), 'logging.info', 'logging.info', (['f"""Accumulated {Tb}s of background matched filter outputs."""'], {}), "(f'Accumulated {Tb}s of background matched filt... |
#
# Copyright (c) 2010, <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 and t... | [
"unittest.TestSuite",
"unittest.FunctionTestCase",
"sys.exit",
"sys.path.append",
"unittest.TextTestRunner"
] | [((1693, 1719), 'sys.path.append', 'sys.path.append', (['"""testing"""'], {}), "('testing')\n", (1708, 1719), False, 'import sys\n'), ((2967, 2987), 'unittest.TestSuite', 'unittest.TestSuite', ([], {}), '()\n', (2985, 2987), False, 'import unittest\n'), ((3185, 3210), 'unittest.TextTestRunner', 'unittest.TextTestRunner... |
"""
Launch lifoid server
Author: <NAME> <<EMAIL>>
Copyright (C) 2017-2018 <NAME>
"""
import traceback
from commis import Command, color
class RunCommand(Command):
name = 'run'
help = 'launch a lifoid server application'
args = {
'--host': {
'metavar': 'ADDR',
'default': ... | [
"traceback.format_exc",
"lifoid.www.app.launch_app",
"commis.color.format"
] | [((1491, 1544), 'commis.color.format', 'color.format', (['""" * Web application stopped"""', 'color.RED'], {}), "(' * Web application stopped', color.RED)\n", (1503, 1544), False, 'from commis import Command, color\n'), ((1148, 1175), 'lifoid.www.app.launch_app', 'launch_app', (['(False)'], {}), '(False, **kwargs)\n', ... |
import os
import re
import shutil
import configparser
import pandas as pd
import numpy as np
from sklearn.preprocessing import LabelEncoder, LabelBinarizer
from download_data import check_folder, remove_folder, read_config
separators = {'comma': ',',
',': ',',
', ': ', ',
'': ... | [
"pandas.Series",
"pandas.isnull",
"sklearn.preprocessing.LabelEncoder",
"os.listdir",
"download_data.remove_folder",
"configparser.ConfigParser",
"numpy.unique",
"download_data.read_config",
"sklearn.preprocessing.LabelBinarizer",
"os.path.join",
"numpy.min",
"numpy.array",
"os.path.isdir",
... | [((879, 910), 'os.path.isdir', 'os.path.isdir', (['processed_folder'], {}), '(processed_folder)\n', (892, 910), False, 'import os\n'), ((956, 982), 'os.mkdir', 'os.mkdir', (['processed_folder'], {}), '(processed_folder)\n', (964, 982), False, 'import os\n'), ((1031, 1056), 'os.listdir', 'os.listdir', (['config_folder']... |
import contextlib
import shutil
import tempfile
from unittest.mock import Mock, patch
from pybundler import cli
@contextlib.contextmanager
def get_temp_dir():
temp_dir = tempfile.mkdtemp()
try:
yield temp_dir
finally:
shutil.rmtree(temp_dir)
@patch('pybundler.cli.subprocess.run')
def te... | [
"unittest.mock.Mock",
"pybundler.cli.release",
"pybundler.cli.test_release",
"pybundler.cli.build_source_wheel",
"tempfile.mkdtemp",
"shutil.rmtree",
"unittest.mock.patch",
"pybundler.cli.install_python_version"
] | [((276, 313), 'unittest.mock.patch', 'patch', (['"""pybundler.cli.subprocess.run"""'], {}), "('pybundler.cli.subprocess.run')\n", (281, 313), False, 'from unittest.mock import Mock, patch\n'), ((440, 477), 'unittest.mock.patch', 'patch', (['"""pybundler.cli.subprocess.run"""'], {}), "('pybundler.cli.subprocess.run')\n"... |
# Copyright 2018 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | [
"tensorflow_io.python.ops.core_ops.io_read_archive",
"tensorflow_io.python.ops.core_ops.io_list_archive_entries"
] | [((954, 1028), 'tensorflow_io.python.ops.core_ops.io_list_archive_entries', 'core_ops.io_list_archive_entries', (['filename'], {'filters': 'filters', 'memory': 'memory'}), '(filename, filters=filters, memory=memory)\n', (986, 1028), False, 'from tensorflow_io.python.ops import core_ops\n'), ((1201, 1267), 'tensorflow_i... |
# Copyright 2022 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, ... | [
"mock.patch",
"requests.get",
"http.server.HTTPServer",
"threading.Thread",
"mock.MagicMock"
] | [((1866, 1944), 'mock.patch', 'mock.patch', (['"""python.bot.startup.health_check_responder.process_handler.psutil"""'], {}), "('python.bot.startup.health_check_responder.process_handler.psutil')\n", (1876, 1944), False, 'import mock\n'), ((2227, 2305), 'mock.patch', 'mock.patch', (['"""python.bot.startup.health_check_... |
from app import my_app
def test_tc001_hello():
response = my_app.test_client().get('/')
assert response.status_code == 200
assert response.data == b'Johnny like pizza'
def test_tc002_secret():
response = my_app.test_client().get('/secret')
assert response.status_code == 200
assert response.d... | [
"app.my_app.test_client"
] | [((64, 84), 'app.my_app.test_client', 'my_app.test_client', ([], {}), '()\n', (82, 84), False, 'from app import my_app\n'), ((224, 244), 'app.my_app.test_client', 'my_app.test_client', ([], {}), '()\n', (242, 244), False, 'from app import my_app\n')] |
from optparse import Option
from six import iteritems
from netutils_linux_monitoring.base_top import BaseTop
from netutils_linux_monitoring.layout import make_table
from netutils_linux_monitoring.numa import Numa
from netutils_linux_monitoring.colors import wrap, cpu_color
class Softirqs(BaseTop):
""" Utility for... | [
"netutils_linux_monitoring.numa.Numa",
"netutils_linux_monitoring.base_top.BaseTop.__init__",
"netutils_linux_monitoring.colors.cpu_color",
"netutils_linux_monitoring.layout.make_table",
"six.iteritems",
"optparse.Option"
] | [((518, 540), 'netutils_linux_monitoring.base_top.BaseTop.__init__', 'BaseTop.__init__', (['self'], {}), '(self)\n', (534, 540), False, 'from netutils_linux_monitoring.base_top import BaseTop\n'), ((1887, 1928), 'netutils_linux_monitoring.layout.make_table', 'make_table', (['header', "['l', 'r', 'r']", 'rows'], {}), "(... |
import logging
import sqlite3
import trough
import flask
import ujson
import trough.settings
def make_app(controller):
controller.check_config()
app = flask.Flask(__name__)
@app.route('/', methods=['POST'])
def simple_provision_writable_segment():
''' deprecated api '''
segment_id = fl... | [
"flask.Flask",
"ujson.dumps",
"flask.request.get_data",
"logging.warning",
"flask.request.json.get",
"trough.settings.configure_logging",
"trough.sync.get_controller",
"flask.Response",
"flask.abort",
"logging.info",
"flask.jsonify"
] | [((5760, 5795), 'trough.settings.configure_logging', 'trough.settings.configure_logging', ([], {}), '()\n', (5793, 5795), False, 'import trough\n'), ((160, 181), 'flask.Flask', 'flask.Flask', (['__name__'], {}), '(__name__)\n', (171, 181), False, 'import flask\n'), ((5813, 5858), 'trough.sync.get_controller', 'trough.s... |
from unittest import TestCase
from feito import Messages
class MessagesTestCase(TestCase):
def test_format(self):
stub_messages = {
'messages': [{
'source': 'pylint',
'code': 'syntax-error',
'location': {
'path': 'tests/feit... | [
"feito.Messages"
] | [((1091, 1114), 'feito.Messages', 'Messages', (['stub_messages'], {}), '(stub_messages)\n', (1099, 1114), False, 'from feito import Messages\n')] |
import struct
from StringIO import StringIO
class Structure(object):
def __init__(self):
if not hasattr(self, "_fields_"):
raise NotImplementedError("No _fields_ in structure")
self.__size__ = 0
self.__struct_fields__ = {}
for _, field_type in self._fiel... | [
"StringIO.StringIO",
"struct.calcsize"
] | [((10979, 11001), 'StringIO.StringIO', 'StringIO', (['self.Context'], {}), '(self.Context)\n', (10987, 11001), False, 'from StringIO import StringIO\n'), ((398, 425), 'struct.calcsize', 'struct.calcsize', (['field_type'], {}), '(field_type)\n', (413, 425), False, 'import struct\n'), ((936, 963), 'struct.calcsize', 'str... |
import shutil
filenames = ['negex_combined.txt','ts_negex_357072.txt']
with open('out/negex_all.txt','wb') as wfd:
for f in filenames:
with open('output/{0}'.format(f),'rb') as fd:
shutil.copyfileobj(fd, wfd)
| [
"shutil.copyfileobj"
] | [((206, 233), 'shutil.copyfileobj', 'shutil.copyfileobj', (['fd', 'wfd'], {}), '(fd, wfd)\n', (224, 233), False, 'import shutil\n')] |
import requests
from requests.models import Response
from onion.onion import Onion
def get(url: str, headers=None, params=None) -> Response:
onion = Onion()
res = requests.get(url, headers=headers, params=params, proxies=onion.proxies)
return res
def post(url: str, headers=None, params=None) -> Respons... | [
"requests.post",
"requests.get",
"requests.delete",
"requests.put",
"onion.onion.Onion"
] | [((156, 163), 'onion.onion.Onion', 'Onion', ([], {}), '()\n', (161, 163), False, 'from onion.onion import Onion\n'), ((174, 246), 'requests.get', 'requests.get', (['url'], {'headers': 'headers', 'params': 'params', 'proxies': 'onion.proxies'}), '(url, headers=headers, params=params, proxies=onion.proxies)\n', (186, 246... |
"""
Tests for grdtrack.
"""
import os
import numpy as np
import numpy.testing as npt
import pandas as pd
import pytest
from pygmt import grdtrack
from pygmt.exceptions import GMTInvalidInput
from pygmt.helpers import GMTTempFile, data_kind
from pygmt.helpers.testing import load_static_earth_relief
TEST_DATA_DIR = os.... | [
"os.path.exists",
"pygmt.helpers.GMTTempFile",
"pygmt.helpers.data_kind",
"pandas.read_csv",
"pygmt.grdtrack",
"os.path.join",
"os.path.dirname",
"numpy.array",
"pytest.raises",
"pytest.fixture",
"numpy.loadtxt",
"pygmt.helpers.testing.load_static_earth_relief"
] | [((379, 419), 'os.path.join', 'os.path.join', (['TEST_DATA_DIR', '"""track.txt"""'], {}), "(TEST_DATA_DIR, 'track.txt')\n", (391, 419), False, 'import os\n'), ((423, 471), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""module"""', 'name': '"""dataarray"""'}), "(scope='module', name='dataarray')\n", (437, 471), ... |
from unittest.mock import Mock, ANY
from click.testing import CliRunner
from taskit.infrastructure.cli.taskit import cli, State
def test_cli_state(state):
assert isinstance(state, State)
def test_cli():
runner = CliRunner()
result = runner.invoke(cli, [])
assert result.exit_code == 0
| [
"click.testing.CliRunner"
] | [((224, 235), 'click.testing.CliRunner', 'CliRunner', ([], {}), '()\n', (233, 235), False, 'from click.testing import CliRunner\n')] |
#https://docs.python.org/3.5/library/tarfile.html#tarfile-objects
import tarfile
import os
src = "/imatge/lpanagiotis/projects/saliency/epic-kitchens/object_detection_images"
dst = "/imatge/lpanagiotis/work/Epic-Kitchens/object_detection_images"
# Folder Structure corresponds to : train/test -> person -> videos
fo... | [
"os.path.exists",
"tarfile.open",
"os.listdir",
"os.path.join",
"os.mkdir"
] | [((414, 434), 'os.path.join', 'os.path.join', (['src', 'x'], {}), '(src, x)\n', (426, 434), False, 'import os\n'), ((448, 469), 'os.listdir', 'os.listdir', (['root_path'], {}), '(root_path)\n', (458, 469), False, 'import os\n'), ((519, 547), 'os.path.join', 'os.path.join', (['src', 'x', 'person'], {}), '(src, x, person... |
import tensorflow as tf
import numpy as np
import pandas as pd
from tophat.constants import *
from tophat.data import (InteractionsSource, InteractionsDerived,
FeatureSource,
TrainDataLoader,
)
from tophat.embedding import EmbeddingMap
from toph... | [
"tophat.embedding.EmbeddingMap",
"tophat.sampling.pair_sampler.PairSampler.from_data_loader",
"tensorflow.placeholder",
"tophat.data.TrainDataLoader",
"tophat.nets.bilinear.BilinearNet",
"tensorflow.name_scope",
"tophat.tasks.factorization.FactorizationTask",
"tensorflow.expand_dims",
"tensorflow.tr... | [((1696, 1739), 'tensorflow.train.AdamOptimizer', 'tf.train.AdamOptimizer', ([], {'learning_rate': '(0.001)'}), '(learning_rate=0.001)\n', (1718, 1739), True, 'import tensorflow as tf\n'), ((4643, 4904), 'tophat.data.TrainDataLoader', 'TrainDataLoader', ([], {'interactions_train': 'interactions', 'group_features': 'gro... |
import os.path as osp
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch_geometric.datasets import CoraFull
import torch_geometric.nn as tgnn
import torch_geometric.transforms as T
from torch_geometric.datasets import Planetoid
dataset = 'Cora'
transform = T.Compose([
T.RandomNodeSplit(n... | [
"torch.nn.ReLU",
"torch.nn.functional.nll_loss",
"torch_geometric.transforms.TargetIndegree",
"torch_geometric.transforms.RandomNodeSplit",
"torch.no_grad",
"os.path.realpath",
"torch.nn.functional.log_softmax",
"torch_geometric.datasets.Planetoid",
"torch_geometric.nn.GATConv"
] | [((460, 505), 'torch_geometric.datasets.Planetoid', 'Planetoid', (['path', 'dataset'], {'transform': 'transform'}), '(path, dataset, transform=transform)\n', (469, 505), False, 'from torch_geometric.datasets import Planetoid\n'), ((1331, 1346), 'torch.no_grad', 'torch.no_grad', ([], {}), '()\n', (1344, 1346), False, 'i... |
import json
import logging
import os
def load_parameters(path_parameters_json):
'''
Function loads the parameters from the provided parameters.json file in a dictionary.
:param path_parameters_json: path of parameters.json file
:return parameters: dictionary with parameters set in parameters.json file... | [
"logging.getLogger",
"logging.StreamHandler",
"logging.Formatter",
"os.path.join",
"json.load",
"json.dump"
] | [((1128, 1207), 'logging.Formatter', 'logging.Formatter', ([], {'fmt': '"""%(asctime)s - %(levelname)s - %(module)s - %(message)s"""'}), "(fmt='%(asctime)s - %(levelname)s - %(module)s - %(message)s')\n", (1145, 1207), False, 'import logging\n'), ((1223, 1246), 'logging.StreamHandler', 'logging.StreamHandler', ([], {})... |
from protopixel import Content
content = Content('Remote Web Interface')
content.web_path('remote') # directory relative to this file
| [
"protopixel.Content"
] | [((42, 73), 'protopixel.Content', 'Content', (['"""Remote Web Interface"""'], {}), "('Remote Web Interface')\n", (49, 73), False, 'from protopixel import Content\n')] |
from __future__ import division, print_function
from ScopeFoundry import BaseMicroscopeApp
#from ScopeFoundry.helper_funcs import sibling_path, load_qt_ui_file
import logging
logging.basicConfig(level=logging.DEBUG)
class SpecTestApp(BaseMicroscopeApp):
name = 'spec_test_app'
def setup(self):
#... | [
"logging.basicConfig"
] | [((176, 216), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.DEBUG'}), '(level=logging.DEBUG)\n', (195, 216), False, 'import logging\n')] |
####################################
# Author: <NAME>
# Date: July 2017
# Project: Document Modeling with External Attention for Sentence Extraction
####################################
'''
Subsamples data to ~half the size and
generates .doc and .question files, each with format
<story_id>
wid wid wid...
... | [
"os.path.join"
] | [((703, 749), 'os.path.join', 'os.path.join', (['DATA_JSON_DIR', '"""train_v1.1.json"""'], {}), "(DATA_JSON_DIR, 'train_v1.1.json')\n", (715, 749), False, 'import os, sys\n'), ((1442, 1503), 'os.path.join', 'os.path.join', (['PREPROC_DATA_DIR', '"""msmarco"""', '"""training.indexes"""'], {}), "(PREPROC_DATA_DIR, 'msmar... |
# -*- encoding: utf-8 -*-
# Copyright (c) 2019 Dantali0n
#
# 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 ... | [
"radloggerpy.hacking.checks.check_builtins_gettext",
"radloggerpy.hacking.checks.check_assert_empty",
"radloggerpy.hacking.checks.check_assert_true",
"radloggerpy.hacking.checks.check_python3_no_iteritems",
"radloggerpy.hacking.checks.check_oslo_i18n_wrapper",
"radloggerpy.hacking.checks.check_log_warn_de... | [((1250, 1298), 'radloggerpy.hacking.checks.no_redundant_import_alias', 'checks.no_redundant_import_alias', (['offending_line'], {}), '(offending_line)\n', (1282, 1298), False, 'from radloggerpy.hacking import checks\n'), ((1546, 1592), 'radloggerpy.hacking.checks.no_redundant_import_alias', 'checks.no_redundant_import... |
#!/usr/bin/env python
from direct.showbase.ShowBase import ShowBase
from panda3d.core import CollisionTraverser, CollisionNode
from panda3d.core import CollisionHandlerQueue, CollisionRay
from panda3d.core import Filename, AmbientLight, DirectionalLight
from panda3d.core import PandaNode, NodePath, Camera, TextNode
fr... | [
"panda3d.core.LVector3",
"panda3d.core.DirectionalLight",
"panda3d.core.CollisionTraverser",
"direct.gui.OnscreenText.OnscreenText",
"panda3d.core.CollideMask.allOff",
"os.path.join",
"panda3d.core.CollisionHandlerQueue",
"panda3d.core.CollisionRay",
"panda3d.core.CollideMask.bit",
"panda3d.core.C... | [((638, 800), 'direct.gui.OnscreenText.OnscreenText', 'OnscreenText', ([], {'text': 'msg', 'style': '(1)', 'fg': '(1, 1, 1, 1)', 'scale': '(0.05)', 'shadow': '(0, 0, 0, 1)', 'parent': 'base.a2dTopLeft', 'pos': '(0.08, -pos - 0.04)', 'align': 'TextNode.ALeft'}), '(text=msg, style=1, fg=(1, 1, 1, 1), scale=0.05, shadow=(... |
# -*- coding: utf-8 -*-
# vim: set ft=python ts=4 sw=4 expandtab:
import datetime
from unittest.mock import MagicMock, patch
import pytest
from apscheduler.triggers.cron import CronTrigger
from apscheduler.triggers.date import DateTrigger
from busypie import SECOND, wait
from tzlocal import get_localzone
from vplan.... | [
"busypie.wait",
"vplan.engine.scheduler.schedule_immediate_job",
"tzlocal.get_localzone",
"vplan.util.now",
"unittest.mock.MagicMock",
"vplan.engine.config.SchedulerConfig",
"vplan.engine.scheduler.unschedule_daily_job",
"vplan.engine.scheduler.schedule_daily_job",
"vplan.engine.scheduler.shutdown_s... | [((1046, 1056), 'vplan.util.now', 'now', ([], {'tz': 'tz'}), '(tz=tz)\n', (1049, 1056), False, 'from vplan.util import now\n'), ((2332, 2370), 'unittest.mock.patch', 'patch', (['"""vplan.engine.scheduler.config"""'], {}), "('vplan.engine.scheduler.config')\n", (2337, 2370), False, 'from unittest.mock import MagicMock, ... |
import argparse
import json
import os
import sys
import jsonschema
from tools.utils import get_json_files
def check_schemas(data_root, schemas_dir, verbose=False):
schemas = ('category.json', 'video.json')
all_file_paths = get_json_files(data_root)
error_count = 0
for schema, file_paths in zip(sch... | [
"argparse.ArgumentParser",
"os.path.join",
"jsonschema.validate",
"tools.utils.get_json_files",
"json.load"
] | [((235, 260), 'tools.utils.get_json_files', 'get_json_files', (['data_root'], {}), '(data_root)\n', (249, 260), False, 'from tools.utils import get_json_files\n'), ((1323, 1348), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (1346, 1348), False, 'import argparse\n'), ((365, 398), 'os.path.join... |
#! /home/steve/anaconda3/bin/python3.7
import numpy as np
train_images = np.load("train_images.npy")
padded_train_images = []
print("padding train images")
for i in train_images:
entry=[]
entry.append(np.zeros(32))
entry.append(np.zeros(32))
for j in i:
entry.append([0,0]+list(j)+[0,0])
e... | [
"numpy.array",
"numpy.zeros",
"numpy.load"
] | [((74, 101), 'numpy.load', 'np.load', (['"""train_images.npy"""'], {}), "('train_images.npy')\n", (81, 101), True, 'import numpy as np\n'), ((535, 561), 'numpy.load', 'np.load', (['"""test_images.npy"""'], {}), "('test_images.npy')\n", (542, 561), True, 'import numpy as np\n'), ((486, 515), 'numpy.array', 'np.array', (... |
# Author : dfm066
# Problem : 74
# The number 145 is well known for the property that the sum of the factorial
# of its digits is equal to 145: 1! + 4! + 5! = 1 + 24 + 120 = 145
# Perhaps less well known is 169, in that it produces the longest chain of
# numbers that link back to 169; it turns out that there are o... | [
"time.time"
] | [((1381, 1392), 'time.time', 'time.time', ([], {}), '()\n', (1390, 1392), False, 'import time\n'), ((1433, 1444), 'time.time', 'time.time', ([], {}), '()\n', (1442, 1444), False, 'import time\n')] |
#! /usr/bin/python
import random,argparse,sys
parser = argparse.ArgumentParser()
import numpy as np
class MDP():
def __init__(self,S,A,gamma,mdptype,rseed):
random.seed(rseed)
if mdptype=="continuing":
self.generateContinuingMDP(S,A,gamma,mdptype)
else:
assert mdptyp... | [
"random.uniform",
"random.shuffle",
"argparse.ArgumentParser",
"random.seed",
"sys.exit",
"random.random",
"random.randint"
] | [((55, 80), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (78, 80), False, 'import random, argparse, sys\n'), ((170, 188), 'random.seed', 'random.seed', (['rseed'], {}), '(rseed)\n', (181, 188), False, 'import random, argparse, sys\n'), ((523, 547), 'random.randint', 'random.randint', (['(0)',... |
"""Swatch service."""
import sys
import threading
from swatch.app import SwatchApp
threading.current_thread().name = "swatch"
cli = sys.modules["flask.cli"]
cli.show_server_banner = lambda *x: None
if __name__ == "__main__":
swatch_app = SwatchApp()
swatch_app.start()
| [
"threading.current_thread",
"swatch.app.SwatchApp"
] | [((86, 112), 'threading.current_thread', 'threading.current_thread', ([], {}), '()\n', (110, 112), False, 'import threading\n'), ((247, 258), 'swatch.app.SwatchApp', 'SwatchApp', ([], {}), '()\n', (256, 258), False, 'from swatch.app import SwatchApp\n')] |
# This file is part of the DomainSharedContactsEditor (DSCE) application.
#
# DSCE 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.... | [
"grouprenderer.GroupCellRenderer",
"logging.debug",
"orgrenderer.OrgCellRenderer",
"domaindata.metadata.get_col_idx",
"emailcellrenderer.EmailCellRenderer",
"wx.grid.GridTableMessage",
"phonerenderer.PhoneCellRenderer",
"domaindata.get_grid_table",
"wx.Point",
"wx.grid.GridCellAttr",
"addressren... | [((1662, 1693), 'domaindata.get_grid_table', 'domaindata.get_grid_table', (['self'], {}), '(self)\n', (1687, 1693), False, 'import domaindata\n'), ((2086, 2140), 'observer.subscribe', 'observer.subscribe', (['self.appendRow', 'pmsg.CONTACT_ADDED'], {}), '(self.appendRow, pmsg.CONTACT_ADDED)\n', (2104, 2140), False, 'im... |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'GUI.ui'
#
# Created by: PyQt5 UI code generator 5.15.2
#
# WARNING: Any manual changes made to this file will be lost when pyuic5 is
# run again. Do not edit this file unless you know what you are doing.
from PyQt5 import QtCore, QtWidgets
... | [
"PyQt5.QtWidgets.QWidget",
"PyQt5.QtCore.QMetaObject.connectSlotsByName",
"PyQt5.QtWidgets.QFrame",
"PyQt5.QtWidgets.QHBoxLayout",
"PyQt5.QtWidgets.QSplitter",
"PyQt5.QtWidgets.QProgressBar",
"PyQt5.QtCore.QRect",
"PyQt5.QtWidgets.QStatusBar",
"PyQt5.QtWidgets.QLabel",
"PyQt5.QtWidgets.QVBoxLayout... | [((630, 659), 'PyQt5.QtWidgets.QWidget', 'QtWidgets.QWidget', (['MainWindow'], {}), '(MainWindow)\n', (647, 659), False, 'from PyQt5 import QtCore, QtWidgets\n'), ((739, 775), 'PyQt5.QtWidgets.QFrame', 'QtWidgets.QFrame', (['self.centralwidget'], {}), '(self.centralwidget)\n', (755, 775), False, 'from PyQt5 import QtCo... |
import questionary
import json
from pathlib import Path
from src.utils.utils import isNumber
import src.utils.constants as constants
def createConfigFile(ConfigFileName):
config = {
"auth": {
"ssoEnabled": False,
"sso":{
"browserCookie":"",
},
... | [
"questionary.password",
"pathlib.Path",
"json.dumps",
"questionary.text",
"questionary.print",
"questionary.confirm",
"questionary.select",
"json.load"
] | [((612, 727), 'questionary.print', 'questionary.print', (['"""Let\'s get some information about New Relic (destination) 🔑"""'], {'style': '"""bold italic fg:darkred"""'}), '("Let\'s get some information about New Relic (destination) 🔑",\n style=\'bold italic fg:darkred\')\n', (629, 727), False, 'import questionary... |
import sys
from data.battle import enemy_gen
sys.setrecursionlimit(10**6) # test
def events(character):
if character.location == "d3":
if character.d3_event_4:
print("In the distance you see a man sitting down in the grass staring at you, maybe you should\n"
"go t... | [
"data.battle.enemy_gen",
"sys.setrecursionlimit"
] | [((49, 79), 'sys.setrecursionlimit', 'sys.setrecursionlimit', (['(10 ** 6)'], {}), '(10 ** 6)\n', (70, 79), False, 'import sys\n'), ((605, 625), 'data.battle.enemy_gen', 'enemy_gen', (['character'], {}), '(character)\n', (614, 625), False, 'from data.battle import enemy_gen\n'), ((1169, 1189), 'data.battle.enemy_gen', ... |
#https://docs.python-guide.org/scenarios/scrape/
from lxml import html
import requests
import json
oga = []
urls =[]
# primera pagina
urls.append('https://www.infocasas.com.py/alquiler/casas-y-departamentos/asuncion/')
#print( len(urls) )
for uri in urls:
#page = requests.get('https://www.infocasas.c... | [
"lxml.html.fromstring",
"json.dumps",
"requests.get"
] | [((1632, 1657), 'json.dumps', 'json.dumps', (['oga'], {'indent': '(4)'}), '(oga, indent=4)\n', (1642, 1657), False, 'import json\n'), ((388, 405), 'requests.get', 'requests.get', (['uri'], {}), '(uri)\n', (400, 405), False, 'import requests\n'), ((417, 446), 'lxml.html.fromstring', 'html.fromstring', (['page.content'],... |
import boto3
import casbin
from moto import mock_dynamodb2
import pytest
import botocore.exceptions
table_name = "casbin_rule"
endpoint_url = "http://localhost:8000"
policy_line = "mock,policy,line"
@mock_dynamodb2
@pytest.mark.parametrize("create_table", [True, False])
def test_init(create_table):
from python_d... | [
"boto3.client.return_value.scan.assert_called_with",
"casbin.persist.load_policy_line.assert_called_with",
"pytest.mark.parametrize",
"boto3.resource",
"casbin.model.model.Model",
"pytest.raises",
"python_dycasbin.adapter.Adapter"
] | [((219, 273), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""create_table"""', '[True, False]'], {}), "('create_table', [True, False])\n", (242, 273), False, 'import pytest\n'), ((359, 385), 'boto3.resource', 'boto3.resource', (['"""dynamodb"""'], {}), "('dynamodb')\n", (373, 385), False, 'import boto3\n')... |
import pickle
from bci4als.ml_model import MLModel
from bci4als.experiments.online import OnlineExperiment
from bci4als.eeg import EEG
def run_experiment(model_path: str):
model = pickle.load(open(model_path, 'rb'))
SYNTHETIC_BOARD = -1
CYTON_DAISY = 2
eeg = EEG(board_id=CYTON_DAISY)
exp = Onl... | [
"bci4als.eeg.EEG",
"bci4als.experiments.online.OnlineExperiment"
] | [((280, 305), 'bci4als.eeg.EEG', 'EEG', ([], {'board_id': 'CYTON_DAISY'}), '(board_id=CYTON_DAISY)\n', (283, 305), False, 'from bci4als.eeg import EEG\n'), ((317, 471), 'bci4als.experiments.online.OnlineExperiment', 'OnlineExperiment', ([], {'eeg': 'eeg', 'model': 'model', 'num_trials': '(10)', 'buffer_time': '(3)', 't... |
import aspose.pydrawing as drawing
import aspose.slides as slides
#ExStart:ThumbnailFromSlideInNotes
# The path to the documents directory.
dataDir = "./examples/data/"
outDir = "./examples/out/"
# Instantiate a Presentation class that represents the presentation file
with slides.Presentation(dataDir + "welcome-to-p... | [
"aspose.slides.Presentation"
] | [((277, 336), 'aspose.slides.Presentation', 'slides.Presentation', (["(dataDir + 'welcome-to-powerpoint.pptx')"], {}), "(dataDir + 'welcome-to-powerpoint.pptx')\n", (296, 336), True, 'import aspose.slides as slides\n')] |
import logging
logger = logging.getLogger(__name__)
class Configuration():
def __init__(self):
self.profiler_registry = {}
self.dataset_registry = {}
def profiler(self, name, **args):
logger.debug('Register profiler {}, opt={}'.format(name, args))
def decorator(f):
... | [
"logging.getLogger"
] | [((25, 52), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (42, 52), False, 'import logging\n')] |
from src.surface_rl_decoder.surface_code import SurfaceCode
from src.surface_rl_decoder.surface_code_util import (
NON_TRIVIAL_LOOP_REWARD,
SYNDROME_LEFT_REWARD,
SOLVED_EPISODE_REWARD,
TERMINAL_ACTION,
copy_array_values,
create_syndrome_output_stack,
)
from tests.data_episode_test import (
_... | [
"src.surface_rl_decoder.surface_code_util.create_syndrome_output_stack",
"src.surface_rl_decoder.surface_code.SurfaceCode",
"src.surface_rl_decoder.surface_code_util.copy_array_values"
] | [((532, 545), 'src.surface_rl_decoder.surface_code.SurfaceCode', 'SurfaceCode', ([], {}), '()\n', (543, 545), False, 'from src.surface_rl_decoder.surface_code import SurfaceCode\n'), ((999, 1012), 'src.surface_rl_decoder.surface_code.SurfaceCode', 'SurfaceCode', ([], {}), '()\n', (1010, 1012), False, 'from src.surface_... |
from time import time
import torch
import argparse
from flask import Flask, request, render_template, Response
import shutil
from iterativeutil import *
import os
os.sys.path.append("..")
from model_backup import G,D
from util import load_image, save_image
app = Flask(__name__)
prev_G_path = 'default.pt... | [
"flask.render_template",
"flask.Flask",
"util.load_image",
"os.remove",
"os.path.exists",
"os.listdir",
"os.sys.path.append",
"os.path.isdir",
"os.mkdir",
"torch.autograd.Variable",
"model_backup.G",
"shutil.copyfile",
"flask.Response",
"flask.request.files.get",
"time.time",
"torch.ca... | [((170, 194), 'os.sys.path.append', 'os.sys.path.append', (['""".."""'], {}), "('..')\n", (188, 194), False, 'import os\n'), ((276, 291), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (281, 291), False, 'from flask import Flask, request, render_template, Response\n'), ((469, 494), 'os.listdir', 'os.listdi... |
import numpy as np
import pandas as pd
from scipy.spatial import distance_matrix
from sklearn.preprocessing import scale
from scipy.stats import linregress
from matplotlib import pyplot as plt
import os
def normalize(a):
return np.interp(a, (a.min(), a.max()), (-1, +1))
def plot_diff(x, node, path):
x_norm = normal... | [
"pandas.read_csv",
"matplotlib.pyplot.ylabel",
"numpy.where",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.clf",
"matplotlib.pyplot.close",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.tight_layout",
"matplotlib.pyplot.title"
] | [((1418, 1492), 'pandas.read_csv', 'pd.read_csv', (['"""/home/hduser/iit_data/node_clusters/master_clusters_200.csv"""'], {}), "('/home/hduser/iit_data/node_clusters/master_clusters_200.csv')\n", (1429, 1492), True, 'import pandas as pd\n'), ((1505, 1578), 'pandas.read_csv', 'pd.read_csv', (['"""/home/hduser/iit_data/n... |
from robin8.qtum_contract_handler import QtumContractHandler
from bitcoinrpc.authproxy import AuthServiceProxy, JSONRPCException
import time
contract_owner = 'qgh88fssi4JrkH8LLvkqvC7SzGxvyApYis'
contract_owner_hex = 'fdc1ae05c161833cdf135863e332126e15d7568c'
contract_address = '4f9ab7a8f5a2238b4315978e14305ce8db856f34... | [
"time.sleep"
] | [((1970, 1985), 'time.sleep', 'time.sleep', (['(300)'], {}), '(300)\n', (1980, 1985), False, 'import time\n')] |