code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
import datetime
import time
import unittest
from unittest.mock import patch, PropertyMock, MagicMock
from api.emulation import EmulationStatus
from api.emulation.task_manager import TaskManager
from api.emulation.task_queue import TaskQueue
from api.emulation.task_worker import TaskWorker
class TestTaskManager(unitte... | [
"api.emulation.task_manager.TaskManager",
"unittest.mock.MagicMock",
"datetime.datetime.now",
"unittest.main",
"datetime.timedelta",
"unittest.mock.patch"
] | [((339, 365), 'unittest.mock.patch', 'patch', (['"""redis.StrictRedis"""'], {}), "('redis.StrictRedis')\n", (344, 365), False, 'from unittest.mock import patch, PropertyMock, MagicMock\n'), ((371, 390), 'unittest.mock.patch', 'patch', (['"""time.sleep"""'], {}), "('time.sleep')\n", (376, 390), False, 'from unittest.moc... |
from main import connect
from hashlib import sha256
def insert_query_get_id(query):
connection = connect(host="std-mysql", username="std_1450_mw", password="<PASSWORD>")
cursor = connection.cursor()
cursor.execute("USE std_1450_mw;")
cursor.execute(query)
connection.commit()
cursor.execute("SE... | [
"main.connect"
] | [((103, 175), 'main.connect', 'connect', ([], {'host': '"""std-mysql"""', 'username': '"""std_1450_mw"""', 'password': '"""<PASSWORD>"""'}), "(host='std-mysql', username='std_1450_mw', password='<PASSWORD>')\n", (110, 175), False, 'from main import connect\n'), ((1250, 1322), 'main.connect', 'connect', ([], {'host': '"... |
from copy import deepcopy
import time
import json
import requests
from typing import List, Dict
from .base import BaseStoreClient
from natrix.common import exception as natrix_exception
from natrix.common.natrixlog import NatrixLogging
from benchmark.types.events import benchmark_command_mapping
logger = NatrixLogg... | [
"json.loads",
"requests.post",
"natrix.common.exception.NetworkException",
"natrix.common.natrixlog.NatrixLogging",
"copy.deepcopy",
"time.time"
] | [((310, 338), 'natrix.common.natrixlog.NatrixLogging', 'NatrixLogging', ([], {'name': '__name__'}), '(name=__name__)\n', (323, 338), False, 'from natrix.common.natrixlog import NatrixLogging\n'), ((2312, 2347), 'copy.deepcopy', 'deepcopy', (['benchmark_command_mapping'], {}), '(benchmark_command_mapping)\n', (2320, 234... |
import os
import json
from collections import OrderedDict
import torch
from torchtext.data import Dataset, Field, Example
from torchtext.vocab import Vocab
class Corpus(object):
def __init__(self, data_dir):
self.data_dir = data_dir
fname = 'corpus.json'
# fields
id_field = Field(... | [
"collections.OrderedDict",
"torchtext.data.Field",
"torchtext.data.Dataset",
"os.path.join",
"json.load",
"torchtext.data.Example.fromlist"
] | [((314, 353), 'torchtext.data.Field', 'Field', ([], {'sequential': '(False)', 'unk_token': 'None'}), '(sequential=False, unk_token=None)\n', (319, 353), False, 'from torchtext.data import Dataset, Field, Example\n'), ((375, 402), 'torchtext.data.Field', 'Field', ([], {'include_lengths': '(True)'}), '(include_lengths=Tr... |
"""
Reads in current year's Arctic sea ice extent from Sea Ice Index 2 (NSIDC)
Website : ftp://sidads.colorado.edu/DATASETS/NOAA/G02135/north/daily/data/
Author : <NAME>
Date : 5 September 2016
"""
### Import modules
import numpy as np
import datetime
import matplotlib.pyplot as plt
from mpl_toolkits.basema... | [
"numpy.reshape",
"matplotlib.pyplot.savefig",
"numpy.where",
"netCDF4.Dataset",
"datetime.datetime.now",
"matplotlib.pyplot.figure",
"mpl_toolkits.basemap.Basemap",
"matplotlib.pyplot.annotate",
"matplotlib.pyplot.rc",
"numpy.nanmean",
"numpy.meshgrid",
"numpy.arange"
] | [((561, 584), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (582, 584), False, 'import datetime\n'), ((778, 806), 'numpy.arange', 'np.arange', (['(1979)', '(2010 + 1)', '(1)'], {}), '(1979, 2010 + 1, 1)\n', (787, 806), True, 'import numpy as np\n'), ((950, 973), 'datetime.datetime.now', 'datetime.... |
import os
import utils
import single
extensions = ['jpg', 'jpeg', 'png', 'ico', 'bmp', 'tiff', 'pnm']
def batch_convert(input_path, specific_format, output_path, format):
failed = 0
succeeded = 0
images = utils.System.files_tree_list(input_path, extensions=[specific_format])
print("~ Total found image... | [
"utils.System.files_tree_list",
"single.single_convert"
] | [((219, 289), 'utils.System.files_tree_list', 'utils.System.files_tree_list', (['input_path'], {'extensions': '[specific_format]'}), '(input_path, extensions=[specific_format])\n', (247, 289), False, 'import utils\n'), ((619, 690), 'single.single_convert', 'single.single_convert', (['image', '(output_path + os.sep + im... |
import rethinkdb as r
def create_tables():
from .registry import model_registry
created_tables = r.table_list().run()
for model_cls in model_registry.all().values():
if model_cls._table not in created_tables:
result = r.table_create(model_cls._table).run()
if result['table... | [
"rethinkdb.table_list",
"rethinkdb.table",
"rethinkdb.table_drop",
"rethinkdb.table_create"
] | [((108, 122), 'rethinkdb.table_list', 'r.table_list', ([], {}), '()\n', (120, 122), True, 'import rethinkdb as r\n'), ((576, 590), 'rethinkdb.table_list', 'r.table_list', ([], {}), '()\n', (588, 590), True, 'import rethinkdb as r\n'), ((253, 285), 'rethinkdb.table_create', 'r.table_create', (['model_cls._table'], {}), ... |
#!/usr/bin/env python3.7
# ******************************************
# Dev: marius-joe
# ******************************************
# Logging Utilities
# v1.0.7
# ******************************************
"""Utility functions for logging"""
import os, sys
import logging
from logging.handlers impor... | [
"logging.getLogger",
"os.path.exists",
"logging.StreamHandler",
"os.listdir",
"fire.Fire",
"pathlib.Path",
"logging.Formatter",
"os.rename",
"time.strftime",
"os.path.splitext",
"os.path.join",
"os.path.split",
"time.gmtime",
"os.path.dirname",
"time.localtime",
"time.time",
"os.remo... | [((776, 795), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (793, 795), False, 'import logging\n'), ((1356, 1388), 'logging.Formatter', 'logging.Formatter', (['"""%(message)s"""'], {}), "('%(message)s')\n", (1373, 1388), False, 'import logging\n'), ((728, 754), 'os.path.dirname', 'os.path.dirname', (['pat... |
import numpy as np
import tensorflow as tf
from patchy_san import *
from progress.bar import IncrementalBar
import sys
# Default parameters
C1 = 152
SMALL_EMBEDDING_SIZE = 30
FINAL_EMBEDDING_SIZE = 25
def make_network(params = parameters_PS):
"""
Makes a network taking as input the Patchy-San transformation d... | [
"tensorflow.keras.layers.Reshape",
"progress.bar.IncrementalBar",
"tensorflow.reduce_sum",
"tensorflow.keras.layers.Permute",
"tensorflow.keras.optimizers.Adam",
"tensorflow.keras.layers.Dense",
"tensorflow.distribute.get_strategy",
"tensorflow.clip_by_value",
"tensorflow.keras.Input",
"tensorflow... | [((5439, 5485), 'tensorflow.keras.optimizers.Adam', 'tf.keras.optimizers.Adam', ([], {'learning_rate': '(0.0001)'}), '(learning_rate=0.0001)\n', (5463, 5485), True, 'import tensorflow as tf\n'), ((492, 585), 'tensorflow.keras.Input', 'tf.keras.Input', ([], {'shape': '(params[key_WIDTH], params[key_NUMBER_OF_FEATURES] *... |
#!/usr/bin/env python
import lsgtuner
import re
import opentuner
from lsgtuner import IntegerStepParameter
class pta(lsgtuner.LSGBinary):
debug=True
binary = "./run.sh"
make_target = "pta"
inputs = ['../../inputs/tshark'] #, '../../inputs/vim'] #, '../../inputs/pine']
params = [IntegerStepParamet... | [
"opentuner.default_argparser",
"lsgtuner.IntegerStepParameter",
"re.compile"
] | [((785, 828), 're.compile', 're.compile', (['"""SOLVE runtime2: ([0-9.]+) ms."""'], {}), "('SOLVE runtime2: ([0-9.]+) ms.')\n", (795, 828), False, 'import re\n'), ((905, 934), 'opentuner.default_argparser', 'opentuner.default_argparser', ([], {}), '()\n', (932, 934), False, 'import opentuner\n'), ((302, 361), 'lsgtuner... |
import sys
sys.path.append("..")
import unittest
from run import main
import json
import io
from contextlib import redirect_stdout
import os
class Test_Magic(unittest.TestCase):
def test_scraping(self):
main('-f data.json'.split())
with open('data.json') as file_:
data = json.load(fi... | [
"contextlib.redirect_stdout",
"json.load",
"unittest.main",
"io.StringIO",
"sys.path.append",
"os.remove"
] | [((11, 32), 'sys.path.append', 'sys.path.append', (['""".."""'], {}), "('..')\n", (26, 32), False, 'import sys\n'), ((1478, 1493), 'unittest.main', 'unittest.main', ([], {}), '()\n', (1491, 1493), False, 'import unittest\n'), ((374, 396), 'os.remove', 'os.remove', (['"""data.json"""'], {}), "('data.json')\n", (383, 396... |
# -*- coding: utf-8 -*-
# ------------------------------------------------------------------------------
# Created by <NAME> (<EMAIL>)
# Created On: 2020-1-20
# ------------------------------------------------------------------------------
import argparse
import os
import os.path as osp
import torch
import _init_path... | [
"os.path.exists",
"utils.utils.load_eval_model",
"argparse.ArgumentParser",
"os.makedirs",
"utils.utils.get_model",
"utils.utils.get_dataset",
"configs.update_config",
"utils.utils.get_det_criterion",
"detection.utils.metrics.eval_fcos_det",
"shutil.rmtree",
"os.path.join",
"torch.utils.data.D... | [((644, 698), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""FCOS Evaluation"""'}), "(description='FCOS Evaluation')\n", (667, 698), False, 'import argparse\n'), ((1060, 1084), 'configs.update_config', 'update_config', (['cfg', 'args'], {}), '(cfg, args)\n', (1073, 1084), False, 'from co... |
from fetcher import fetch
from robotsparser import RobotsParser
from linkcollector import LinkCollector
from workqueue import WorkQueue
from dbhandler import dbhandler
from urlobj import URLObj
from blacklist import Blacklist
from urllist import URLList
import traceback
import logging
import os.path
import sys
class ... | [
"robotsparser.RobotsParser",
"dbhandler.dbhandler",
"blacklist.Blacklist",
"logging.debug",
"urlobj.URLObj",
"fetcher.fetch",
"linkcollector.LinkCollector",
"workqueue.WorkQueue",
"urllist.URLList",
"sys.exit",
"logging.info"
] | [((380, 398), 'dbhandler.dbhandler', 'dbhandler', (['dbfname'], {}), '(dbfname)\n', (389, 398), False, 'from dbhandler import dbhandler\n'), ((450, 461), 'workqueue.WorkQueue', 'WorkQueue', ([], {}), '()\n', (459, 461), False, 'from workqueue import WorkQueue\n'), ((691, 713), 'linkcollector.LinkCollector', 'LinkCollec... |
# #####################################################################################################################
'''
This file is a scratchpad of code used for preparing the folders of the dataset, including:
- Inverting a greyscale image, so that all cells are on a black background
- Pulling a random subset... | [
"os.path.exists",
"PIL.Image.fromarray",
"os.listdir",
"PIL.Image.open",
"random.shuffle",
"pandas.read_csv",
"PIL.Image.merge",
"image_slicer.slice",
"image_slicer.save_tiles",
"numpy.zeros",
"torchvision.transforms.functional._is_pil_image",
"PIL.ImageOps.invert",
"os.system",
"numpy.rou... | [((1576, 1596), 'os.listdir', 'os.listdir', (['file_dir'], {}), '(file_dir)\n', (1586, 1596), False, 'import os\n'), ((2217, 2237), 'os.path.exists', 'os.path.exists', (['mini'], {}), '(mini)\n', (2231, 2237), False, 'import os\n'), ((2269, 2295), 'os.system', 'os.system', (["('mkdir ' + mini)"], {}), "('mkdir ' + mini... |
#!/usr/bin/python3
#
# Copyright © 2017 jared <<EMAIL>>
#
from pydub import AudioSegment, scipy_effects, effects
import os
import settings, util
# combine two audio samples with a crossfade
def combine_samples(acc, file2, CROSSFADE_DUR=100):
util.debug_print('combining ' + file2)
sample2 = AudioSegment.from_w... | [
"pydub.AudioSegment.from_wav",
"pydub.effects.normalize",
"pydub.scipy_effects.high_pass_filter",
"util.debug_print",
"pydub.scipy_effects.band_pass_filter",
"pydub.AudioSegment.from_file",
"pydub.scipy_effects.low_pass_filter"
] | [((248, 286), 'util.debug_print', 'util.debug_print', (["('combining ' + file2)"], {}), "('combining ' + file2)\n", (264, 286), False, 'import settings, util\n'), ((301, 329), 'pydub.AudioSegment.from_wav', 'AudioSegment.from_wav', (['file2'], {}), '(file2)\n', (322, 329), False, 'from pydub import AudioSegment, scipy_... |
from django.contrib import admin
from .models import Auth0User, ActiveUserSignupLink
admin.site.register(Auth0User)
admin.site.register(
ActiveUserSignupLink,
readonly_fields=("secret", "signup_url", "users_created_with_this_link"),
exclude=("created_users",),
list_display=("secret", "is_active", "comm... | [
"django.contrib.admin.site.register"
] | [((86, 116), 'django.contrib.admin.site.register', 'admin.site.register', (['Auth0User'], {}), '(Auth0User)\n', (105, 116), False, 'from django.contrib import admin\n'), ((117, 354), 'django.contrib.admin.site.register', 'admin.site.register', (['ActiveUserSignupLink'], {'readonly_fields': "('secret', 'signup_url', 'us... |
import info
from Package.PipPackageBase import PipPackageBase
class subinfo(info.infoclass):
def setTargets(self):
self.svnTargets["master"] = f"https://github.com/TheOneRing/python-coloredlogs.git|winansi"
self.defaultTarget = "master"
def setDependencies(self):
self.runtimeDependen... | [
"Package.PipPackageBase.PipPackageBase.__init__"
] | [((544, 573), 'Package.PipPackageBase.PipPackageBase.__init__', 'PipPackageBase.__init__', (['self'], {}), '(self)\n', (567, 573), False, 'from Package.PipPackageBase import PipPackageBase\n')] |
from __future__ import print_function
from tqdm import *
import sys
import argparse
import torch
from torch.autograd import Variable
from torch.utils.data import DataLoader
import torch.utils.data.distributed
import torchvision.transforms as transforms
import torchvision.datasets as datasets
from models.resnet_imagen... | [
"torchvision.transforms.CenterCrop",
"sys.exit",
"argparse.ArgumentParser",
"torchvision.transforms.RandomResizedCrop",
"torchvision.transforms.RandomHorizontalFlip",
"torchvision.transforms.Normalize",
"torch.utils.data.DataLoader",
"torchvision.transforms.Resize",
"torch.no_grad",
"torchvision.t... | [((503, 682), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': "('Implementation of Section V-B for `Precise Approximation of Convolutional Neural'\n + 'Networks for Homomorphically Encrypted Data.`')"}), "(description=\n 'Implementation of Section V-B for `Precise Approximation of Conv... |
from aspr.constants import OUTPUTS, SPT_FN
import random, os, click
import numpy as np
from os.path import join, exists
@click.command()
@click.option('-i', '--identifier', required=True, help='Name of new spawntime set')
@click.option('-n', '--n-nodes', type=int, default=20, help = 'Number of nodes to spawn')
... | [
"os.path.exists",
"os.makedirs",
"click.option",
"os.path.join",
"random.seed",
"click.command"
] | [((127, 142), 'click.command', 'click.command', ([], {}), '()\n', (140, 142), False, 'import random, os, click\n'), ((145, 233), 'click.option', 'click.option', (['"""-i"""', '"""--identifier"""'], {'required': '(True)', 'help': '"""Name of new spawntime set"""'}), "('-i', '--identifier', required=True, help=\n 'Nam... |
# -*- coding: utf-8 -*-
"""\
Test the natsort command-line tool functions.
"""
from __future__ import print_function, unicode_literals
import pytest
import re
import sys
from pytest import raises
from compat.mock import patch, call
from compat.hypothesis import (
assume,
given,
sampled_from,
integers,
... | [
"natsort.__main__.check_filter",
"compat.mock.call",
"re.compile",
"compat.hypothesis.integers",
"compat.hypothesis.text",
"compat.hypothesis.sampled_from",
"re.match",
"compat.hypothesis.floats",
"re.findall",
"pytest.raises",
"natsort.__main__.main",
"pytest.mark.skipif",
"natsort.__main__... | [((5521, 5599), 'pytest.mark.skipif', 'pytest.mark.skipif', (['(not use_hypothesis)'], {'reason': '"""requires python2.7 or greater"""'}), "(not use_hypothesis, reason='requires python2.7 or greater')\n", (5539, 5599), False, 'import pytest\n'), ((5802, 5880), 'pytest.mark.skipif', 'pytest.mark.skipif', (['(not use_hyp... |
from google.cloud import storage
from pathlib import Path
storage_client = storage.Client()
bucket = storage_client.get_bucket('pit_transcriptions')
path = Path('./transcript_pablo/flac')
prefix = 'pablo'
for p in path.iterdir():
dest_name = (p.name)
dest_blob = bucket.blob(f'{prefix}/{dest_name}')
dest_b... | [
"google.cloud.storage.Client",
"pathlib.Path"
] | [((76, 92), 'google.cloud.storage.Client', 'storage.Client', ([], {}), '()\n', (90, 92), False, 'from google.cloud import storage\n'), ((158, 189), 'pathlib.Path', 'Path', (['"""./transcript_pablo/flac"""'], {}), "('./transcript_pablo/flac')\n", (162, 189), False, 'from pathlib import Path\n')] |
import json
import os
import shutil
from flask import (
Blueprint, request, send_from_directory,
make_response)
from insgraph.db import get_db
from insgraph.utils import httputil
bp = Blueprint('caseManagement', __name__, url_prefix='/caseManagement')
@bp.route('/getProjectList', methods=['GET'])
def getPr... | [
"insgraph.db.get_db",
"json.dumps",
"insgraph.utils.httputil.Response_headers",
"flask.Blueprint"
] | [((195, 262), 'flask.Blueprint', 'Blueprint', (['"""caseManagement"""', '__name__'], {'url_prefix': '"""/caseManagement"""'}), "('caseManagement', __name__, url_prefix='/caseManagement')\n", (204, 262), False, 'from flask import Blueprint, request, send_from_directory, make_response\n'), ((563, 587), 'json.dumps', 'jso... |
import logging
from typing import Optional
from colorlog import ColoredFormatter
class levelFilter(logging.Filter):
r"""Log level filter.
Arguments:
level (int): filter log level. Only logs with level higher than ``level`` will be kept.
"""
def __init__(self, level: int):
self.leve... | [
"logging.getLogger",
"logging.StreamHandler",
"logging.Formatter",
"logging.FileHandler",
"colorlog.ColoredFormatter"
] | [((1058, 1182), 'colorlog.ColoredFormatter', 'ColoredFormatter', (['STREAM_LOG_FORMAT'], {'datefmt': 'None', 'reset': '(True)', 'log_colors': 'LOG_COLOR', 'secondary_log_colors': '{}', 'style': '"""%"""'}), "(STREAM_LOG_FORMAT, datefmt=None, reset=True, log_colors=\n LOG_COLOR, secondary_log_colors={}, style='%')\n"... |
# Copyright 2021 UW-IT, University of Washington
# SPDX-License-Identifier: Apache-2.0
from unittest import TestCase
from uw_uwnetid.subscription_233 import get_office365edu_prod_subs,\
get_office365edu_test_subs
from restclients_core.exceptions import DataFailureException
from uw_uwnetid.util import fdao_uwnetid_o... | [
"uw_uwnetid.subscription_233.get_office365edu_test_subs",
"uw_uwnetid.subscription_233.get_office365edu_prod_subs"
] | [((454, 488), 'uw_uwnetid.subscription_233.get_office365edu_prod_subs', 'get_office365edu_prod_subs', (['"""bill"""'], {}), "('bill')\n", (480, 488), False, 'from uw_uwnetid.subscription_233 import get_office365edu_prod_subs, get_office365edu_test_subs\n'), ((602, 636), 'uw_uwnetid.subscription_233.get_office365edu_tes... |
# Generated by Django 2.2.4 on 2019-08-25 18:32
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('models', '0014_brandcategory'),
]
operations = [
migrations.AddField(
model_name='brand',
... | [
"django.db.models.ForeignKey"
] | [((362, 469), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'default': '(1)', 'on_delete': 'django.db.models.deletion.DO_NOTHING', 'to': '"""models.BrandCategory"""'}), "(default=1, on_delete=django.db.models.deletion.DO_NOTHING,\n to='models.BrandCategory')\n", (379, 469), False, 'from django.db import ... |
#!/usr/bin/env python3
import sys
import speech_recognition as sr
from transcribe.secrets import (
bing_speech_api_key,
google_credentials_json,
google_preferred_phrases,
)
class TranscriptionStatus(object):
success = "success"
request_error = "request error"
transcription_error = "unintelligib... | [
"speech_recognition.Recognizer",
"speech_recognition.AudioFile",
"sys.exc_info"
] | [((1075, 1090), 'speech_recognition.Recognizer', 'sr.Recognizer', ([], {}), '()\n', (1088, 1090), True, 'import speech_recognition as sr\n'), ((1642, 1657), 'speech_recognition.Recognizer', 'sr.Recognizer', ([], {}), '()\n', (1655, 1657), True, 'import speech_recognition as sr\n'), ((591, 606), 'speech_recognition.Reco... |
import tensorflow
from PIL import Image
import numpy
import argparse
import os
import sys
import pandas
from ModelsEnum import Models
sys.path.insert(0, os.path.abspath(
os.path.join(os.path.dirname(__file__), '..')))
def predict(model, imgPath, imgHeight, imgWidth):
# 如果 imgPath 是数组
if isinstance(imgPat... | [
"os.path.exists",
"PIL.Image.open",
"argparse.ArgumentParser",
"numpy.argmax",
"os.path.isfile",
"os.path.dirname",
"models.modelMulClassi.modelDefinition.model.load_weights",
"tensorflow.expand_dims"
] | [((539, 569), 'tensorflow.expand_dims', 'tensorflow.expand_dims', (['img', '(0)'], {}), '(img, 0)\n', (561, 569), False, 'import tensorflow\n'), ((720, 745), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (743, 745), False, 'import argparse\n'), ((188, 213), 'os.path.dirname', 'os.path.dirname'... |
# -*- coding: utf-8 -*-
# Octowire Framework
# Copyright (c) ImmunIT - <NAME> / <NAME>
# License: Apache 2.0
# <NAME> / Eresse <<EMAIL>>
# <NAME> / Ghecko <<EMAIL>>
import shutil
import time
from beautifultable import BeautifulTable, ALIGN_LEFT
from octowire_framework.module.AModule import AModule
from octowire.gpi... | [
"octowire.spi.SPI",
"time.sleep",
"shutil.get_terminal_size",
"beautifultable.BeautifulTable",
"owfmodules.avrisp.device_id.DeviceID",
"octowire.gpio.GPIO"
] | [((1652, 1678), 'shutil.get_terminal_size', 'shutil.get_terminal_size', ([], {}), '()\n', (1676, 1678), False, 'import shutil\n'), ((2570, 2602), 'owfmodules.avrisp.device_id.DeviceID', 'DeviceID', ([], {'owf_config': 'self.config'}), '(owf_config=self.config)\n', (2578, 2602), False, 'from owfmodules.avrisp.device_id ... |
'''
Job request creation and manipulation library for the Voxel51 Platform API.
| Copyright 2017-2019, Voxel51, Inc.
| `voxel51.com <https://voxel51.com/>`_
|
'''
# pragma pylint: disable=redefined-builtin
# pragma pylint: disable=unused-wildcard-import
# pragma pylint: disable=wildcard-import
from __future__ import a... | [
"collections.OrderedDict"
] | [((5611, 5624), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (5622, 5624), False, 'from collections import OrderedDict\n')] |
#!/usr/bin/env python
from importlib import import_module
import time
import subprocess
import os
from flask import Flask, render_template, Response, request, send_file, jsonify
# import camera driver. Otherwise use pi camera by default
if os.environ.get('CAMERA'):
Camera = import_module('camera_' + os.environ['CA... | [
"flask.render_template",
"importlib.import_module",
"utils.write_boolean_to_file",
"flask.Flask",
"subprocess.Popen",
"camera_pi.Camera",
"os.environ.get",
"flask.request.form.get",
"flask.send_file",
"flask.jsonify"
] | [((241, 265), 'os.environ.get', 'os.environ.get', (['"""CAMERA"""'], {}), "('CAMERA')\n", (255, 265), False, 'import os\n'), ((396, 411), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (401, 411), False, 'from flask import Flask, render_template, Response, request, send_file, jsonify\n'), ((540, 569), 'fla... |
from mmseg.apis import inference_segmentor, init_segmentor
import mmcv
import os
import numpy as np
import tqdm
import argparse
def show_result(result,
palette=None):
seg = result[0]
palette = np.array(palette)
color_seg = np.zeros((seg.shape[0], seg.shape[1], 3), dtype=np.uint8)... | [
"os.listdir",
"os.makedirs",
"argparse.ArgumentParser",
"mmseg.apis.inference_segmentor",
"tqdm.tqdm",
"os.path.join",
"numpy.array",
"numpy.zeros",
"mmseg.apis.init_segmentor"
] | [((497, 522), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (520, 522), False, 'import argparse\n'), ((724, 763), 'os.makedirs', 'os.makedirs', (['output_path'], {'exist_ok': '(True)'}), '(output_path, exist_ok=True)\n', (735, 763), False, 'import os\n'), ((775, 797), 'os.listdir', 'os.listdir... |
from selenium import webdriver
from webdriver_manager.chrome import ChromeDriverManager
class Chrome(object):
def __init__(self):
super().__init__()
self.driver = webdriver.Chrome(ChromeDriverManager().install())
| [
"webdriver_manager.chrome.ChromeDriverManager"
] | [((203, 224), 'webdriver_manager.chrome.ChromeDriverManager', 'ChromeDriverManager', ([], {}), '()\n', (222, 224), False, 'from webdriver_manager.chrome import ChromeDriverManager\n')] |
import yaml
import os, sys, stat
from flask import Flask, request, abort, jsonify
import logging as log
import requests
import uuid
DEF_HOST = '0.0.0.0'
DEF_PORT = 6000
DEF_RESDIR = '/tmp/ga_results'
DEF_ROUTEPATH = "/flowbster"
DEF_LOGLEVEL = log.DEBUG
DEF_LOGFORMAT = '%(asctime)s\t%(name)s\t%(levelname)s\t%(message)... | [
"logging.basicConfig",
"os.path.exists",
"flask.request.args.get",
"requests.post",
"logging.debug",
"os.makedirs",
"flask.Flask",
"os.path.join",
"yaml.load",
"logging.warning",
"flask.request.form.get",
"uuid.uuid4",
"logging.info",
"flask.jsonify"
] | [((2537, 2613), 'logging.basicConfig', 'log.basicConfig', ([], {'stream': 'sys.stdout', 'level': 'DEF_LOGLEVEL', 'format': 'DEF_LOGFORMAT'}), '(stream=sys.stdout, level=DEF_LOGLEVEL, format=DEF_LOGFORMAT)\n', (2552, 2613), True, 'import logging as log\n'), ((2620, 2635), 'flask.Flask', 'Flask', (['__name__'], {}), '(__... |
from _utils import *
import json
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
import os
import seaborn as sns
datadir = "../PPO_Analysis/training_analysis/"
figdir = "../PPO_Analysis/"
fileList = os.listdir(datadir)
paraSetting = ['0503', '0504', '0505', '0506', '0507']
for file in fileList... | [
"os.listdir",
"matplotlib.pyplot.savefig",
"seaborn.color_palette",
"matplotlib.pyplot.ylabel",
"pandas.read_csv",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.style.use",
"matplotlib.pyplot.figure",
"pandas.DataFrame",
"numpy.arange",
... | [((225, 244), 'os.listdir', 'os.listdir', (['datadir'], {}), '(datadir)\n', (235, 244), False, 'import os\n'), ((468, 483), 'numpy.arange', 'np.arange', (['(3)', '(8)'], {}), '(3, 8)\n', (477, 483), True, 'import numpy as np\n'), ((493, 512), 'seaborn.color_palette', 'sns.color_palette', ([], {}), '()\n', (510, 512), T... |
from typing import NamedTuple
import torch
from kmtools import structure_tools
class ProteinData(NamedTuple):
sequence: str
row_index: torch.LongTensor
col_index: torch.LongTensor
distances: torch.FloatTensor
def extract_seq_and_adj(structure, chain_id, remove_hetatms=False):
domain, result_df ... | [
"kmtools.structure_tools.DomainDef",
"kmtools.structure_tools.get_chain_sequence",
"kmtools.structure_tools.extract_domain"
] | [((461, 503), 'kmtools.structure_tools.get_chain_sequence', 'structure_tools.get_chain_sequence', (['domain'], {}), '(domain)\n', (495, 503), False, 'from kmtools import structure_tools\n'), ((1232, 1294), 'kmtools.structure_tools.DomainDef', 'structure_tools.DomainDef', (['model_id', 'chain_id', '(1)', 'num_residues']... |
import sys
import os
import time
sys.path.append(os.getcwd())
from cluster.prepare_data import get_headers_pairs_list, write_dist_matrix
from cluster.token_edit_distance import get_distance_matrix
if len(sys.argv) < 3:
print(
"Too few arguments. You should provide: \n1. dataset_filename" +
"\n2. ... | [
"time.perf_counter",
"os.getcwd",
"cluster.prepare_data.get_headers_pairs_list",
"sys.exit",
"cluster.prepare_data.write_dist_matrix"
] | [((372, 391), 'time.perf_counter', 'time.perf_counter', ([], {}), '()\n', (389, 391), False, 'import time\n'), ((477, 532), 'cluster.prepare_data.get_headers_pairs_list', 'get_headers_pairs_list', (['dataset_filename_'], {'verbose': '(True)'}), '(dataset_filename_, verbose=True)\n', (499, 532), False, 'from cluster.pre... |
from x_rebirth_station_calculator.station_data import modules
from x_rebirth_station_calculator.station_data.station_base import Station
names = {'L044': 'Wheat Plantation',
'L049': 'Weizenplantage'}
smodules = [modules.ValleyForge(production_method='al', efficiency=140),
modules.ValleyForge(prod... | [
"x_rebirth_station_calculator.station_data.modules.ValleyForge",
"x_rebirth_station_calculator.station_data.station_base.Station"
] | [((379, 403), 'x_rebirth_station_calculator.station_data.station_base.Station', 'Station', (['names', 'smodules'], {}), '(names, smodules)\n', (386, 403), False, 'from x_rebirth_station_calculator.station_data.station_base import Station\n'), ((223, 282), 'x_rebirth_station_calculator.station_data.modules.ValleyForge',... |
"""Marmot Dataset Module."""
from pathlib import Path
from typing import List
import numpy as np
import pytorch_lightning as pl
from albumentations import Compose
from PIL import Image
from torch.utils.data import Dataset, DataLoader
class MarmotDataset(Dataset):
"""Marmot Dataset."""
def __init__(self, da... | [
"PIL.Image.open",
"pathlib.Path",
"numpy.concatenate",
"torch.utils.data.DataLoader"
] | [((3878, 3986), 'torch.utils.data.DataLoader', 'DataLoader', (['self.complaint_train'], {'batch_size': 'self.batch_size', 'shuffle': '(True)', 'num_workers': 'self.num_workers'}), '(self.complaint_train, batch_size=self.batch_size, shuffle=True,\n num_workers=self.num_workers)\n', (3888, 3986), False, 'from torch.ut... |
#!/usr/bin/env python3
# ssb/adt/lfs.ps
# logical file system for SSB
import copy
from datetime import datetime
import os
import sys
import uuid
import ssb.adt.tangle
# ---------------------------------------------------------------------------
# this is the UUID for the SSB filesystem namespace
# (we picked a ran... | [
"uuid.uuid5",
"uuid.UUID",
"os.urandom",
"os.path.normpath",
"copy.copy"
] | [((709, 727), 'uuid.UUID', 'uuid.UUID', (['NS_UUID'], {}), '(NS_UUID)\n', (718, 727), False, 'import uuid\n'), ((743, 769), 'uuid.uuid5', 'uuid.uuid5', (['ns', '(salt + key)'], {}), '(ns, salt + key)\n', (753, 769), False, 'import uuid\n'), ((2890, 2911), 'copy.copy', 'copy.copy', (['self._pars'], {}), '(self._pars)\n'... |
import time, os
from pynvml import *
from subprocess import Popen
import numpy as np
nvmlInit()
import pandas as pd
def run_command(cmd, minmem=2,use_env_variable=True, admissible_gpus=[1],sleep=60):
sufficient_memory = False
gpu_idx=0
while not sufficient_memory:
time.sleep(sleep)
# Check... | [
"numpy.minimum",
"numpy.argmax",
"time.sleep",
"pandas.DataFrame",
"numpy.maximum",
"sys.path.append"
] | [((1360, 1382), 'sys.path.append', 'sys.path.append', (['"""../"""'], {}), "('../')\n", (1375, 1382), False, 'import sys\n'), ((6385, 6438), 'pandas.DataFrame', 'pd.DataFrame', ([], {'data': 'rows_model', 'columns': "['model_path']"}), "(data=rows_model, columns=['model_path'])\n", (6397, 6438), True, 'import pandas as... |
from rest_framework_nested import routers
from panel.api import views
router = routers.DefaultRouter()
router.register(r'events', views.EventViewSet)
router.register(r'links', views.LinkViewSet)
router.register(r'messages', views.MessageViewSet)
router.register(r'notifications', views.NotificationViewSet)
message_ro... | [
"rest_framework_nested.routers.DefaultRouter",
"rest_framework_nested.routers.NestedSimpleRouter"
] | [((80, 103), 'rest_framework_nested.routers.DefaultRouter', 'routers.DefaultRouter', ([], {}), '()\n', (101, 103), False, 'from rest_framework_nested import routers\n'), ((327, 390), 'rest_framework_nested.routers.NestedSimpleRouter', 'routers.NestedSimpleRouter', (['router', '"""messages"""'], {'lookup': '"""parent"""... |
from django.contrib import admin
from .models import BgpPeering
@admin.register(BgpPeering)
class BgpPeeringAdmin(admin.ModelAdmin):
list_display = ("device", "peer_name", "remote_as", "remote_ip")
| [
"django.contrib.admin.register"
] | [((67, 93), 'django.contrib.admin.register', 'admin.register', (['BgpPeering'], {}), '(BgpPeering)\n', (81, 93), False, 'from django.contrib import admin\n')] |
from django.contrib import admin
import partnerships.models as partnerships_models
@admin.register(partnerships_models.Partnership)
class PartnershipAdmin(admin.ModelAdmin):
pass
| [
"django.contrib.admin.register"
] | [((87, 134), 'django.contrib.admin.register', 'admin.register', (['partnerships_models.Partnership'], {}), '(partnerships_models.Partnership)\n', (101, 134), False, 'from django.contrib import admin\n')] |
#!/usr/bin/env python
import math
import pyemf
if "radians" not in dir(math):
def radians(deg):
return deg * math.pi / 180.0
math.radians = radians
print("Test of world transformations.")
def path(emf, text, x, y, size=300):
emf.BeginPath()
emf.MoveTo(x, y)
emf.LineTo(x + 100, y + 30... | [
"math.cos",
"math.sin",
"pyemf.EMF",
"math.radians"
] | [((983, 1027), 'pyemf.EMF', 'pyemf.EMF', (['width', 'height', 'dpi'], {'verbose': '(False)'}), '(width, height, dpi, verbose=False)\n', (992, 1027), False, 'import pyemf\n'), ((2072, 2087), 'math.radians', 'math.radians', (['d'], {}), '(d)\n', (2084, 2087), False, 'import math\n'), ((2453, 2468), 'math.radians', 'math.... |
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from anchor.app.handlers import LoadHandler
from anchor.app.utils.styles import MAIN_WINDOW_STYLE
from anchor.app.widgets import CefBrowserView, NavigationBar
from anchor.app.widgets.SideBar import SideBar
class MainWindow(QMainWindow... | [
"anchor.app.widgets.CefBrowserView",
"anchor.app.handlers.LoadHandler",
"anchor.app.widgets.SideBar.SideBar",
"anchor.app.widgets.NavigationBar"
] | [((888, 915), 'anchor.app.handlers.LoadHandler', 'LoadHandler', (['self.app', 'self'], {}), '(self.app, self)\n', (899, 915), False, 'from anchor.app.handlers import LoadHandler\n'), ((944, 1008), 'anchor.app.widgets.CefBrowserView', 'CefBrowserView', (['self.app'], {'parent': 'self', 'load_handler': 'load_handler'}), ... |
from gitpandas import Repository
import time
__author__ = 'willmcginnis'
if __name__ == '__main__':
g = Repository(working_dir='..')
st = time.time()
blame = g.cumulative_blame(branch='master', include_globs=['*.py', '*.html', '*.sql', '*.md'], limit=None, skip=None)
print(blame.head())
print(ti... | [
"gitpandas.Repository",
"time.time"
] | [((111, 139), 'gitpandas.Repository', 'Repository', ([], {'working_dir': '""".."""'}), "(working_dir='..')\n", (121, 139), False, 'from gitpandas import Repository\n'), ((150, 161), 'time.time', 'time.time', ([], {}), '()\n', (159, 161), False, 'import time\n'), ((346, 357), 'time.time', 'time.time', ([], {}), '()\n', ... |
import datetime as dt
from functools import partial
import logging
from math import isfinite
import os
import re
import pathlib
from typing import Any, NamedTuple, Optional
import numpy as np
from pydantic import BaseModel, Field
import jinja2
import requests
from rich.progress import track
from urllib.parse import ur... | [
"jinja2.Environment",
"math.isfinite",
"re.match",
"logging.warning",
"os.path.join",
"requests.get",
"os.path.dirname",
"urllib.parse.urljoin",
"jinja2.FileSystemLoader",
"rich.progress.track",
"re.search"
] | [((1971, 2118), 're.match', 're.match', (['"""^(?P<compound_id>[A-Z_]{3}-[A-Z_]{3}-[0-9a-f]{8}-[0-9]+)(_(?P<microstate_index>[0-9]+))?([_0-9]*)$"""', 'compound_or_microstate_id'], {}), "(\n '^(?P<compound_id>[A-Z_]{3}-[A-Z_]{3}-[0-9a-f]{8}-[0-9]+)(_(?P<microstate_index>[0-9]+))?([_0-9]*)$'\n , compound_or_microst... |
import cv2
from filters import sepia, greyscale
# Global Config
confidence_threshold = 0.55
rgb_color = (255, 34, 15)
# Files
configPath = "src/lib/trained_config.pbtxt"
weightsPath = "src/lib/trained_model/frozen_inference_graph.pb"
classFile = "src/lib/coco.names"
# Functions
def create_detection_model():
... | [
"filters.greyscale",
"cv2.rectangle",
"cv2.imshow",
"cv2.dnn_DetectionModel",
"cv2.destroyAllWindows",
"cv2.VideoCapture",
"filters.sepia",
"cv2.waitKey"
] | [((1849, 1868), 'cv2.VideoCapture', 'cv2.VideoCapture', (['(0)'], {}), '(0)\n', (1865, 1868), False, 'import cv2\n'), ((2458, 2481), 'cv2.destroyAllWindows', 'cv2.destroyAllWindows', ([], {}), '()\n', (2479, 2481), False, 'import cv2\n'), ((339, 386), 'cv2.dnn_DetectionModel', 'cv2.dnn_DetectionModel', (['weightsPath',... |
import torch
from fairseq.models import FairseqEncoder
from fairseq.models.fairseq_encoder import EncoderOut
class MultisourceEncoder(FairseqEncoder):
"""
A wrapper around a dictionary of :class:`FairseqEncoder` objects.
Very similiar to CompositeEncoder, but each encoder takes separate inputs
and is... | [
"fairseq.models.fairseq_encoder.EncoderOut",
"torch.cat"
] | [((2130, 2168), 'torch.cat', 'torch.cat', (['[out[0] for out in outs]', '(0)'], {}), '([out[0] for out in outs], 0)\n', (2139, 2168), False, 'import torch\n'), ((2200, 2238), 'torch.cat', 'torch.cat', (['[out[1] for out in outs]', '(1)'], {}), '([out[1] for out in outs], 1)\n', (2209, 2238), False, 'import torch\n'), (... |
import tensorflow as tf
import numpy as np
import time
from capslayer import layers
from capslayer import losses
from capslayer import ops
class SquashTest(tf.test.TestCase):
def testSquash(self):
"""Checks the value and shape of the squash output given an input."""
input_tensor = tf.ones((1, 1,... | [
"tensorflow.ones",
"tensorflow.test.main",
"capslayer.ops.squash",
"numpy.array",
"numpy.linalg.norm",
"time.time",
"capslayer.ops._squash"
] | [((3204, 3218), 'tensorflow.test.main', 'tf.test.main', ([], {}), '()\n', (3216, 3218), True, 'import tensorflow as tf\n'), ((306, 333), 'tensorflow.ones', 'tf.ones', (['(1, 1, 1, 1, 1, 1)'], {}), '((1, 1, 1, 1, 1, 1))\n', (313, 333), True, 'import tensorflow as tf\n'), ((353, 377), 'capslayer.ops.squash', 'ops.squash'... |
from dataclasses import dataclass
import astropy.constants as c
from math import pi, log10
from star.validators import val_seismology
# Constants
vmax0: float = 3.05 # mHz
deltav0: float = 134.9 # µHz
Teff0: int = 5777
M_sun: float = c.M_sun.to('g').value
R_sun: float = c.R_sun.to('cm').value
G: float =... | [
"astropy.constants.G.to",
"astropy.constants.R_sun.to",
"astropy.constants.M_sun.to",
"math.log10",
"star.validators.val_seismology.check_input"
] | [((248, 263), 'astropy.constants.M_sun.to', 'c.M_sun.to', (['"""g"""'], {}), "('g')\n", (258, 263), True, 'import astropy.constants as c\n'), ((286, 302), 'astropy.constants.R_sun.to', 'c.R_sun.to', (['"""cm"""'], {}), "('cm')\n", (296, 302), True, 'import astropy.constants as c\n'), ((321, 345), 'astropy.constants.G.t... |
from django.contrib.auth import login, logout
from django.contrib.auth.forms import AuthenticationForm
from django.contrib.auth.views import LoginView
from django.http import HttpResponseRedirect
from django.shortcuts import redirect
from django.urls import reverse_lazy
from django.views.generic import FormView, Redire... | [
"django.forms.PasswordInput",
"django.utils.decorators.method_decorator",
"django.urls.reverse_lazy",
"django.shortcuts.redirect",
"django.forms.EmailInput",
"django.forms.TextInput",
"django.contrib.auth.logout"
] | [((2655, 2704), 'django.utils.decorators.method_decorator', 'method_decorator', (['login_required'], {'name': '"""dispatch"""'}), "(login_required, name='dispatch')\n", (2671, 2704), False, 'from django.utils.decorators import method_decorator\n'), ((3290, 3339), 'django.utils.decorators.method_decorator', 'method_deco... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Provide the 'Efficient Lifelong Learning Algorithm' (ELLA).
The ELLA algorithm is an online multi-task learning algorithm that maintains a shared knowledge database that can be
trained and used to incorporate new knowledge to improve the performance on multiple tasks [1... | [
"torch.abs",
"numpy.sum",
"torch.zeros",
"torch.inverse",
"torch.randn"
] | [((8683, 8710), 'torch.zeros', 'torch.zeros', (['(d * k, d * k)'], {}), '((d * k, d * k))\n', (8694, 8710), False, 'import torch\n'), ((8781, 8804), 'torch.zeros', 'torch.zeros', (['(d * k, 1)'], {}), '((d * k, 1))\n', (8792, 8804), False, 'import torch\n'), ((8877, 8891), 'torch.zeros', 'torch.zeros', (['k'], {}), '(k... |
import exceptions as errors
#
# Connect Four
#
# 7x6 Game Board
#
# 5 . . . . . . .
# 4 . . . . . . .
# 3 . . . . . . .
# 2 . . . . . . .
# 1 . . . . . . .
# 0 . . . . . . .
# 0 1 2 3 4 5 6
#
# http://en.wikipedia.org/wiki/Connect_Four
# https://en.wikipedia.org/wiki/Solved_game
# The game was solved mathematically... | [
"exceptions.InvalidColumnError",
"exceptions.FullColumnError",
"exceptions.InvalidBoardError",
"exceptions.InvalidPlayerError",
"exceptions.OutOfTurnError"
] | [((1837, 1878), 'exceptions.FullColumnError', 'errors.FullColumnError', (['"""Column is full."""'], {}), "('Column is full.')\n", (1859, 1878), True, 'import exceptions as errors\n'), ((1251, 1295), 'exceptions.InvalidPlayerError', 'errors.InvalidPlayerError', (['"""Invalid player."""'], {}), "('Invalid player.')\n", (... |
import argparse
import os
import codecs
def shard(input_file, output_file_format, bytes_per_shard, max_shards=None):
if not os.path.exists(input_file):
raise ValueError('Could not find input file {}'.format(input_file))
if '{index}' not in output_file_format:
raise ValueError('output_file_form... | [
"os.path.exists",
"os.makedirs",
"argparse.ArgumentParser",
"os.path.join",
"os.path.dirname",
"codecs.open"
] | [((1525, 1581), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Text file sharder"""'}), "(description='Text file sharder')\n", (1548, 1581), False, 'import argparse\n'), ((2593, 2631), 'os.path.join', 'os.path.join', (['args.output', 'args.format'], {}), '(args.output, args.format)\n', (... |
from blenderneuron.section import Section
import numpy as np
import math
import numpy as np
class BlenderSection(Section):
def __init__(self):
super(BlenderSection, self).__init__()
self.was_split = False
self.split_sections = []
def from_full_NEURON_section_dict(sel... | [
"numpy.sqrt",
"math.ceil",
"numpy.reshape",
"numpy.isclose",
"numpy.square",
"numpy.array",
"numpy.sum",
"numpy.min",
"numpy.cumsum"
] | [((2166, 2186), 'numpy.array', 'np.array', (['self.radii'], {}), '(self.radii)\n', (2174, 2186), True, 'import numpy as np\n'), ((5768, 5783), 'numpy.square', 'np.square', (['diff'], {}), '(diff)\n', (5777, 5783), True, 'import numpy as np\n'), ((5799, 5817), 'numpy.sum', 'np.sum', (['sq'], {'axis': '(1)'}), '(sq, axis... |
"""
Define request handlers used by the zendesk_proxy djangoapp
"""
import logging
from edx_rest_framework_extensions.auth.jwt.authentication import JwtAuthentication
from edx_rest_framework_extensions.auth.session.authentication import SessionAuthenticationAllowInactiveUser
from rest_framework import status
from rest... | [
"logging.getLogger",
"rest_framework.response.Response",
"openedx.core.djangoapps.zendesk_proxy.utils.create_zendesk_ticket"
] | [((673, 700), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (690, 700), False, 'import logging\n'), ((2732, 2761), 'rest_framework.response.Response', 'Response', ([], {'status': 'proxy_status'}), '(status=proxy_status)\n', (2740, 2761), False, 'from rest_framework.response import Respon... |
"""The instruction decoder part of the RISC-V CPU"""
from baremetal import *
from chips_v.utils import *
def decode(instruction, src1, src2, fwd1, fwd2, fwd_val, this_pc):
rs1 = instruction[19:15]
rs2 = instruction[24:20]
opcode = instruction[6:0]
shamt = instruction[24:20]
funct3 = instruction[... | [
"itertools.product"
] | [((7618, 7729), 'itertools.product', 'itertools.product', (['instruction_stim', 'src1_stim', 'src2_stim', 'fwd1_stim', 'fwd2_stim', 'fwd_val_stim', 'this_pc_stim'], {}), '(instruction_stim, src1_stim, src2_stim, fwd1_stim,\n fwd2_stim, fwd_val_stim, this_pc_stim)\n', (7635, 7729), False, 'import itertools\n')] |
# coding=utf-8
# 【本程序使用前提必须 xx1.txt、xx2.txt 等的单字完全一样，字数一样】
import os
import os.path #文件夹遍历函数
#获取目标文件夹的路径
filedir = 'data'
#获取当前文件夹中的文件名称列表
filenames=os.listdir(filedir)
#打开当前目录下的result.txt文件，如果没有则创建
f = open('result.txt', 'w', encoding='utf-8')
dictList = []
#先遍历所有文件
for filename in filenames:
filepath =... | [
"os.listdir"
] | [((157, 176), 'os.listdir', 'os.listdir', (['filedir'], {}), '(filedir)\n', (167, 176), False, 'import os\n')] |
"""
Module to play sounds in the game.
class AudioDevice
Audio device needs to be constructed to play sounds.
Use free standing functions to play sounds.
Only one audio device should be created.
Functions:
play_destroy_brick(audio_device: AudioDevice)
play_hit_brick(audio_device: AudioDevice)
... | [
"pygame.mixer.init",
"pygame.mixer.Sound"
] | [((1096, 1115), 'pygame.mixer.init', 'pygame.mixer.init', ([], {}), '()\n', (1113, 1115), False, 'import pygame\n'), ((1176, 1204), 'pygame.mixer.Sound', 'pygame.mixer.Sound', (['filename'], {}), '(filename)\n', (1194, 1204), False, 'import pygame\n')] |
import os
import time
from slackclient import SlackClient
BOT_ID = os.environ.get('BOT_ID')
# Constants
AT_BOT = "<@" + BOT_ID + ">"
PYTHON_COMMAND = 'py'
slack_client = SlackClient(os.environ.get('SLACK_BOT_TOKEN'))
def parse_slack_output(slack_rtm_output):
"""
The Slack Real Time Messaging API is an events ... | [
"os.environ.get",
"time.sleep"
] | [((71, 95), 'os.environ.get', 'os.environ.get', (['"""BOT_ID"""'], {}), "('BOT_ID')\n", (85, 95), False, 'import os\n'), ((188, 221), 'os.environ.get', 'os.environ.get', (['"""SLACK_BOT_TOKEN"""'], {}), "('SLACK_BOT_TOKEN')\n", (202, 221), False, 'import os\n'), ((2090, 2122), 'time.sleep', 'time.sleep', (['READ_WEBSOC... |
from djfilters import filters
from .models import (BooleanModel, DateFieldModel, EmailModel, IpModel,
NumberModel, RelatedIntIdModel, RelatedSlugIdModel,
TextModel)
# Simple Filters
class TextFieldFilter(filters.Filter):
text = filters.CharField(max_length=10, required=... | [
"djfilters.filters.CharField",
"djfilters.filters.BooleanField"
] | [((278, 326), 'djfilters.filters.CharField', 'filters.CharField', ([], {'max_length': '(10)', 'required': '(False)'}), '(max_length=10, required=False)\n', (295, 326), False, 'from djfilters import filters\n'), ((377, 399), 'djfilters.filters.BooleanField', 'filters.BooleanField', ([], {}), '()\n', (397, 399), False, '... |
import pickle
import time
import numpy as np
import torch
import tqdm
from liga.models import load_data_to_gpu
from liga.utils import common_utils
def statistics_info(cfg, ret_dict, metric, disp_dict):
for cur_thresh in cfg.MODEL.POST_PROCESSING.RECALL_THRESH_LIST:
metric['recall_roi_%s' % str(cur_thres... | [
"liga.models.load_data_to_gpu",
"numpy.mean",
"liga.utils.common_utils.merge_results_dist",
"pickle.dump",
"liga.utils.common_utils.get_dist_info",
"torch.cuda.device_count",
"torch.no_grad",
"time.time",
"torch.nn.parallel.DistributedDataParallel"
] | [((2656, 2667), 'time.time', 'time.time', ([], {}), '()\n', (2665, 2667), False, 'import time\n'), ((2258, 2283), 'torch.cuda.device_count', 'torch.cuda.device_count', ([], {}), '()\n', (2281, 2283), False, 'import torch\n'), ((2347, 2449), 'torch.nn.parallel.DistributedDataParallel', 'torch.nn.parallel.DistributedData... |
import unittest
from base import BaseTestCase
class PassportTestCase(unittest.TestCase, BaseTestCase):
"""
Test cases for Credit Card number removal removal.
"""
def test_passport_long(self):
"""
Expect clash with NINO
BEFORE: My passport number is 5333800068GBR8812049F25092... | [
"scrubadub.Scrubber"
] | [((897, 917), 'scrubadub.Scrubber', 'scrubadub.Scrubber', ([], {}), '()\n', (915, 917), False, 'import scrubadub\n')] |
import os
# Folders structures
HERE = os.path.abspath(os.path.join(os.path.realpath(__file__), os.pardir))
ROOT = os.path.join(HERE, os.pardir)
PROBLEMS_FOLDER = os.path.join(HERE, "problems")
BIN_FOLDER = os.path.join(HERE, "bin")
TEMP_FOLDER = os.path.join(HERE, "temp")
def clean_lines(lines):
return list(map(... | [
"os.path.realpath",
"os.path.join"
] | [((115, 144), 'os.path.join', 'os.path.join', (['HERE', 'os.pardir'], {}), '(HERE, os.pardir)\n', (127, 144), False, 'import os\n'), ((163, 193), 'os.path.join', 'os.path.join', (['HERE', '"""problems"""'], {}), "(HERE, 'problems')\n", (175, 193), False, 'import os\n'), ((207, 232), 'os.path.join', 'os.path.join', (['H... |
from pathlib import Path
import scipy.io as sio
import h5py
import tqdm
from multiprocessing import Pool
from .io import load_mat
def mat2h5(mat_dir, h5_path, keys=("F", "u", "list"), worker=1):
"""Conver mat files to hdf5.
Args:
mat_dir (str): mat file dir
h5_path (str): hdf5 file path
... | [
"pathlib.Path",
"scipy.io.loadmat",
"tqdm.tqdm",
"h5py.File",
"multiprocessing.Pool"
] | [((414, 427), 'pathlib.Path', 'Path', (['mat_dir'], {}), '(mat_dir)\n', (418, 427), False, 'from pathlib import Path\n'), ((1516, 1535), 'scipy.io.loadmat', 'sio.loadmat', (['mat_fn'], {}), '(mat_fn)\n', (1527, 1535), True, 'import scipy.io as sio\n'), ((649, 672), 'h5py.File', 'h5py.File', (['h5_path', '"""w"""'], {})... |
from utils import test, swap
def lomutopartition(x, low, high):
return high
def hoarepartition(x, low, high):
return low
def sedgewickpartition(x, low, high):
choices = [x[low], x[high], x[int((high - low)/2)]]
sortedchoices = choices.copy()
sortedchoices.sort()
median = sortedchoices[1]
... | [
"utils.swap",
"utils.test"
] | [((2463, 2478), 'utils.test', 'test', (['quicksort'], {}), '(quicksort)\n', (2467, 2478), False, 'from utils import test, swap\n'), ((1934, 1953), 'utils.swap', 'swap', (['x', 'i', 'divider'], {}), '(x, i, divider)\n', (1938, 1953), False, 'from utils import test, swap\n'), ((1991, 2010), 'utils.swap', 'swap', (['x', '... |
# -*- coding: utf-8 -*-
# @Time : 19/12/10 11:57
# @Author : qgking
# @Email : <EMAIL>
# @Software: PyCharm
# @Desc :
import torch.nn as nn
from models.gen_models.seg_branch import DeepLabDecoder
from module.gen_backbone import BACKBONE
class DeepLab_Aux(nn.Module):
def __init__(self, backbone='resnet101... | [
"models.gen_models.seg_branch.DeepLabDecoder"
] | [((558, 652), 'models.gen_models.seg_branch.DeepLabDecoder', 'DeepLabDecoder', ([], {'backbone': 'backbone', 'num_class': 'num_classes', 'return_features': 'return_features'}), '(backbone=backbone, num_class=num_classes, return_features=\n return_features)\n', (572, 652), False, 'from models.gen_models.seg_branch im... |
from route_66.server import server
server.launch()
| [
"route_66.server.server.launch"
] | [((36, 51), 'route_66.server.server.launch', 'server.launch', ([], {}), '()\n', (49, 51), False, 'from route_66.server import server\n')] |
# <NAME> (Joshua)
# CIS 41A Spring 2020
# Unit D take-home assignment
# Part One - Sets
from collections import namedtuple
class1 = {'Li', 'Audry', 'Jia', 'Migel', 'Tanya'}
class2 = {'Sasha', 'Migel', 'Tanya', 'Hiroto', 'Audry'}
class3 = {'Migel', 'Zhang', 'Hiroto', 'Anita', 'Jia'}
print (f'Students in all three cla... | [
"collections.namedtuple"
] | [((823, 862), 'collections.namedtuple', 'namedtuple', (['"""Movie"""', '"""title year genre"""'], {}), "('Movie', 'title year genre')\n", (833, 862), False, 'from collections import namedtuple\n'), ((1049, 1099), 'collections.namedtuple', 'namedtuple', (['"""Moviestars"""', '"""title year genre stars"""'], {}), "('Movi... |
import numpy as np
import networkx as nx
import matplotlib.pyplot as plt
import threading
from threading import Lock, Thread
import random
import time as timeee
transactionCounter = 0
lock = Lock()
succesfulAttacks = 0
failedAttacks = 0
class User(object):
def __init__(self, id: int, malicious: bool):
s... | [
"random.sample",
"random.uniform",
"threading.Lock",
"matplotlib.pyplot.xlabel",
"networkx.draw_networkx_nodes",
"networkx.OrderedDiGraph",
"networkx.draw_networkx_labels",
"networkx.get_node_attributes",
"matplotlib.pyplot.yticks",
"numpy.random.uniform",
"time.time"
] | [((193, 199), 'threading.Lock', 'Lock', ([], {}), '()\n', (197, 199), False, 'from threading import Lock, Thread\n'), ((3086, 3099), 'time.time', 'timeee.time', ([], {}), '()\n', (3097, 3099), True, 'import time as timeee\n'), ((3311, 3330), 'networkx.OrderedDiGraph', 'nx.OrderedDiGraph', ([], {}), '()\n', (3328, 3330)... |
#!/usr/bin/env python3
"""
Build a package to be installed by opkg for use with CVRA package management.
See https://raymii.org/s/tutorials/Building_IPK_packages_by_hand.html for
reference.
"""
import argparse
import tempfile
import subprocess
import os
import shutil
import contextlib
import logging
logger = logging... | [
"logging.basicConfig",
"tempfile.TemporaryDirectory",
"argparse.ArgumentParser",
"os.makedirs",
"os.path.join",
"os.getcwd",
"os.chdir",
"os.path.dirname",
"os.path.basename"
] | [((331, 357), 'os.path.basename', 'os.path.basename', (['__file__'], {}), '(__file__)\n', (347, 357), False, 'import os\n'), ((412, 423), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (421, 423), False, 'import os\n'), ((428, 442), 'os.chdir', 'os.chdir', (['path'], {}), '(path)\n', (436, 442), False, 'import os\n'), ((5... |
import csv
import sys
def main(marker_file):
markers = list()
with open(marker_file, newline='') as fh:
reader = csv.reader(fh)
last_marker = ('', '')
for row in reader:
marker = (row[0], row[1], f'V{row[2]}', row[3], row[4], '1')
if last_marker != (row[1], row[2... | [
"csv.reader"
] | [((130, 144), 'csv.reader', 'csv.reader', (['fh'], {}), '(fh)\n', (140, 144), False, 'import csv\n')] |
from sequrity import TOKEN
from telebot import TeleBot
from main import Pizza
bot = TeleBot(TOKEN)
handler = Pizza()
@bot.message_handler()
def answer(message):
bot.send_message(
message.chat.id,
handler.get_response(message.chat.id, message.text)
)
if __name__ == '__main__':
bot.polli... | [
"main.Pizza",
"telebot.TeleBot"
] | [((86, 100), 'telebot.TeleBot', 'TeleBot', (['TOKEN'], {}), '(TOKEN)\n', (93, 100), False, 'from telebot import TeleBot\n'), ((111, 118), 'main.Pizza', 'Pizza', ([], {}), '()\n', (116, 118), False, 'from main import Pizza\n')] |
#! /usr/bin/python36
print("content-type: text/html")
print("\n")
import cgi
import subprocess as sp
print("""
<form method="post" action="softwares.py">
Enter the UserName: <input type="text" name="username"/><br>
Select the Plattform:<br>
<select name="software">
<option value="firefox">Mozilla Firefox</... | [
"cgi.FieldStorage"
] | [((479, 497), 'cgi.FieldStorage', 'cgi.FieldStorage', ([], {}), '()\n', (495, 497), False, 'import cgi\n')] |
from ProjectEulerCommons.Base import *
from ProjectEulerCommons.Fractions import fraction
Answer(
prod([fraction(numerator, denominator)
for numerator in range(10, 100) for denominator in range(numerator + 1, 100)
if (
(
str(denominator)[1] == str(numerator)[0]
and denominat... | [
"ProjectEulerCommons.Fractions.fraction"
] | [((109, 141), 'ProjectEulerCommons.Fractions.fraction', 'fraction', (['numerator', 'denominator'], {}), '(numerator, denominator)\n', (117, 141), False, 'from ProjectEulerCommons.Fractions import fraction\n')] |
"""Submodule of keepasshttp, implementing the KeePass protocol."""
import logging
import requests
from . import common
from . import crypto
from . import password
from . import util
logger = logging.getLogger(__name__)
DEFAULT_KEEPASS_URL = 'http://localhost:19455/'
def associate(requestor=None):
"""Send a ne... | [
"logging.getLogger"
] | [((194, 221), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (211, 221), False, 'import logging\n')] |
import scipy.io as sio
from pathlib import Path
import numpy as np
import pyqtgraph as pg
from pyqtgraph.Qt import QtGui
mask = np.array([np.ones(32), np.ones(32), np.ones(32),np.concatenate((np.zeros(14), np.ones(18))),
np.concatenate((np.zeros(14), np.ones(18))),
np.concat... | [
"numpy.clip",
"numpy.copy",
"numpy.mean",
"pyqtgraph.Qt.QtGui.QApplication.instance",
"numpy.unique",
"pyqtgraph.Qt.QtGui.QWidget",
"pathlib.Path",
"numpy.ones",
"scipy.io.loadmat",
"pyqtgraph.Qt.QtGui.QGridLayout",
"numpy.max",
"pyqtgraph.Qt.QtGui.QApplication",
"numpy.linspace",
"numpy.z... | [((2765, 2834), 'pathlib.Path', 'Path', (['"""../../Data_Collection/3kOhm_FB/data_MT_FabianGeiger_5sess.mat"""'], {}), "('../../Data_Collection/3kOhm_FB/data_MT_FabianGeiger_5sess.mat')\n", (2769, 2834), False, 'from pathlib import Path\n'), ((2845, 2883), 'scipy.io.loadmat', 'sio.loadmat', (['filename'], {'squeeze_me'... |
import Inline
info = {
"friendly_name": "Link (External)",
"example_template": "scheme://authority/path?query|Text To Display",
"summary": "A more flexible way of linking to an external resource.",
"details": """
<p>Links to external resources can be embedded in the page by
<i>naked linking</i... | [
"Inline.collectSpan",
"Inline.ExternalLink"
] | [((767, 791), 'Inline.collectSpan', 'Inline.collectSpan', (['rest'], {}), '(rest)\n', (785, 791), False, 'import Inline\n'), ((987, 1023), 'Inline.ExternalLink', 'Inline.ExternalLink', (['target', 'vistext'], {}), '(target, vistext)\n', (1006, 1023), False, 'import Inline\n')] |
from sqlalchemy import func
from typing import Dict, Union
from db.db import db, convert_timestamp
ItemJSON = Dict[int, Union[str, float, int, float]]
ALLItemJSON = Dict[int, Union[str, float, int, int, str]]
class ItemModel(db.Model):
__tablename__ = 'items'
id = db.Column(db.Integer, primary_key=True, autoi... | [
"db.db.db.String",
"sqlalchemy.func.count",
"sqlalchemy.func.sum",
"db.db.convert_timestamp",
"db.db.db.relationship",
"db.db.db.session.commit",
"db.db.db.ForeignKey",
"db.db.db.session.add",
"db.db.db.Float",
"db.db.db.Column",
"db.db.db.session.delete"
] | [((275, 334), 'db.db.db.Column', 'db.Column', (['db.Integer'], {'primary_key': '(True)', 'autoincrement': '(True)'}), '(db.Integer, primary_key=True, autoincrement=True)\n', (284, 334), False, 'from db.db import db, convert_timestamp\n'), ((445, 464), 'db.db.db.Column', 'db.Column', (['db.Float'], {}), '(db.Float)\n', ... |
"""
This script is a proof of concept to train GCN as fast as possible and with as
little lines of code as possible.
It uses a custom training function instead of the standard Keras fit(), and
can train GCN for 200 epochs in a few tenths of a second (~0.20 on a GTX 1050).
"""
import tensorflow as tf
from tensorflow.ker... | [
"tensorflow.random.set_seed",
"spektral.transforms.AdjToSpTensor",
"spektral.transforms.LayerPreprocess",
"spektral.utils.tic",
"spektral.models.gcn.GCN",
"tensorflow.keras.optimizers.Adam",
"tensorflow.GradientTape",
"spektral.utils.toc",
"tensorflow.keras.losses.CategoricalCrossentropy"
] | [((623, 649), 'tensorflow.random.set_seed', 'tf.random.set_seed', ([], {'seed': '(0)'}), '(seed=0)\n', (641, 649), True, 'import tensorflow as tf\n'), ((937, 1009), 'spektral.models.gcn.GCN', 'GCN', ([], {'n_labels': 'dataset.n_labels', 'n_input_channels': 'dataset.n_node_features'}), '(n_labels=dataset.n_labels, n_inp... |
"""empty message
Revision ID: 137ed4905569
Revises: <PASSWORD>
Create Date: 2016-09-26 17:22:28.928084
"""
# revision identifiers, used by Alembic.
revision = '<PASSWORD>'
down_revision = '<PASSWORD>'
import sqlalchemy as sa
from alembic import op
def upgrade():
### commands auto generated by Alembic - please... | [
"alembic.op.drop_column",
"sqlalchemy.Integer"
] | [((515, 548), 'alembic.op.drop_column', 'op.drop_column', (['"""test"""', '"""timeout"""'], {}), "('test', 'timeout')\n", (529, 548), False, 'from alembic import op\n'), ((380, 392), 'sqlalchemy.Integer', 'sa.Integer', ([], {}), '()\n', (390, 392), True, 'import sqlalchemy as sa\n')] |
from django.contrib import messages
from django.contrib.auth import login
from django.contrib.auth.decorators import login_required
from django.contrib.auth.views import PasswordChangeView
from django.contrib.sites.shortcuts import get_current_site
from django.core.mail import EmailMessage
from django.db import transac... | [
"django.db.models.Count",
"django.db.models.Avg",
"django.core.mail.EmailMessage",
"django.utils.http.urlsafe_base64_decode",
"django.shortcuts.render",
"django.shortcuts.get_object_or_404",
"django.shortcuts.redirect",
"django.urls.reverse_lazy",
"django.contrib.sites.shortcuts.get_current_site",
... | [((1738, 1807), 'django.utils.decorators.method_decorator', 'method_decorator', (['[login_required, teacher_required]'], {'name': '"""dispatch"""'}), "([login_required, teacher_required], name='dispatch')\n", (1754, 1807), False, 'from django.utils.decorators import method_decorator\n'), ((2538, 2607), 'django.utils.de... |
"""
As substantial work has been placed—a few months of development—to make this fully featured music bot free for public use, please refrain from discrediting author or falsely claiming this open source work.
BSD 3-Clause License
Copyright (c) 2021, taku#3343 (Discord)
All rights reserved.
Redistribution and use in... | [
"json.loads",
"re.compile",
"json.dumps",
"asyncio.Lock",
"core.models.getLogger"
] | [((1899, 1918), 'core.models.getLogger', 'getLogger', (['__name__'], {}), '(__name__)\n', (1908, 1918), False, 'from core.models import getLogger\n'), ((1936, 1996), 're.compile', 're.compile', (['"""\\\\s*[(\\\\[](?:official .+?|lyrics?)[)\\\\]]"""', 're.I'], {}), "('\\\\s*[(\\\\[](?:official .+?|lyrics?)[)\\\\]]', re... |
from sqlalchemy import create_engine
from sqlalchemy_utils import database_exists, create_database, drop_database
from sqlalchemy.exc import DatabaseError
from sqlalchemy.schema import DropTable
class Database:
def __init__(
self,
username=None,
password=None,
host=None,
po... | [
"sqlalchemy_utils.drop_database",
"sqlalchemy_utils.database_exists",
"sqlalchemy.create_engine",
"sqlalchemy.schema.DropTable",
"pandas.DataFrame"
] | [((2115, 2183), 'sqlalchemy.create_engine', 'create_engine', (['self.DB_URL'], {'echo': '(False)', 'isolation_level': '"""AUTOCOMMIT"""'}), "(self.DB_URL, echo=False, isolation_level='AUTOCOMMIT')\n", (2128, 2183), False, 'from sqlalchemy import create_engine\n'), ((2877, 2903), 'sqlalchemy_utils.drop_database', 'drop_... |
from context import zettel
from zettel.util import links_from_markdown
markup_example_3_links = """Table of Content
...
[siyach](evernote:///view/536854/s1/d9b2c4a8-9c77-4202-a6b0-1007f572754f/d9b2c4a8-9c77-4202-a6b0-1007f572754f/) bla
7193. [Predigt Vineyard Dirk: Freude](evernote:///view/536854/s1/a42586cd-3993-4... | [
"zettel.util.links_from_markdown"
] | [((562, 605), 'zettel.util.links_from_markdown', 'links_from_markdown', (['markup_example_3_links'], {}), '(markup_example_3_links)\n', (581, 605), False, 'from zettel.util import links_from_markdown\n')] |
import numpy as np
import pandas as pd
def classify_prices(discount):
price_classification = [] # Change/remove this line
for d in discount:
if float(d) <= 0:
category = 'no_discount'
price_classification.append(category)
elif 0 <= float(d) <= 0.1:
category = 'discounted'
price_classification.append(c... | [
"numpy.array",
"numpy.loadtxt",
"numpy.round"
] | [((1051, 1079), 'numpy.array', 'np.array', (['data'], {'dtype': 'np.int'}), '(data, dtype=np.int)\n', (1059, 1079), True, 'import numpy as np\n'), ((1119, 1148), 'numpy.array', 'np.array', (['data1'], {'dtype': 'np.int'}), '(data1, dtype=np.int)\n', (1127, 1148), True, 'import numpy as np\n'), ((911, 939), 'numpy.loadt... |
import os
import torch
def setup_model(net, phase, cvphase, model_dir, pretrained_dir, project_home_dir, best_epoch):
"""Set up model.
Either create model directories to save to (train phase), or load pretrained model weights state dict from pretrained directory (test phase).
Keyword arguments:
net --... | [
"os.path.exists",
"torch.cuda.is_available",
"os.makedirs"
] | [((847, 873), 'os.path.exists', 'os.path.exists', (['model_path'], {}), '(model_path)\n', (861, 873), False, 'import os\n'), ((883, 906), 'os.makedirs', 'os.makedirs', (['model_path'], {}), '(model_path)\n', (894, 906), False, 'import os\n'), ((1265, 1290), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {})... |
from namex.utils.logging import setup_logging
from namex.models import State
from .abstract_nro_resource import AbstractNROResource
from .abstract_solr_resource import AbstractSolrResource
setup_logging() # Important to do this first
class AbstractNameRequestResource(AbstractNROResource, AbstractSolrResource):
... | [
"namex.utils.logging.setup_logging"
] | [((192, 207), 'namex.utils.logging.setup_logging', 'setup_logging', ([], {}), '()\n', (205, 207), False, 'from namex.utils.logging import setup_logging\n')] |
# valueIterationAgents.py
# -----------------------
# Licensing Information: Please do not distribute or publish solutions to this
# project. You are free to use and extend these projects for educational
# purposes. The Pacman AI projects were developed at UC Berkeley, primarily by
# <NAME> (<EMAIL>) and <NAME> (<EMAIL... | [
"mdp.getTransitionStatesAndProbs",
"mdp.getPossibleActions",
"mdp.getReward",
"util.Counter",
"mdp.getStates"
] | [((1358, 1372), 'util.Counter', 'util.Counter', ([], {}), '()\n', (1370, 1372), False, 'import mdp, util\n'), ((1553, 1568), 'mdp.getStates', 'mdp.getStates', ([], {}), '()\n', (1566, 1568), False, 'import mdp, util\n'), ((3092, 3106), 'util.Counter', 'util.Counter', ([], {}), '()\n', (3104, 3106), False, 'import mdp, ... |
import os
from os.path import expanduser
os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID" # see issue #152
os.environ["CUDA_VISIBLE_DEVICES"]="0"
import numpy as np
import tensorflow as tf
from copy import deepcopy
from sklearn.utils import shuffle
HOME_DIR = os.getcwd()
seed = 1731
np.random.seed(seed)
... | [
"os.path.exists",
"numpy.eye",
"numpy.reshape",
"os.makedirs",
"tensorflow.keras.datasets.mnist.load_data",
"sklearn.utils.shuffle",
"tensorflow.random.set_random_seed",
"numpy.argmax",
"os.getcwd",
"numpy.random.seed",
"copy.deepcopy",
"numpy.arange",
"numpy.random.shuffle"
] | [((270, 281), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (279, 281), False, 'import os\n'), ((298, 318), 'numpy.random.seed', 'np.random.seed', (['seed'], {}), '(seed)\n', (312, 318), True, 'import numpy as np\n'), ((320, 351), 'tensorflow.random.set_random_seed', 'tf.random.set_random_seed', (['seed'], {}), '(seed)\n... |
import torch
import torch.autograd as autograd
import torch.nn as nn
import pdb
from textcnn import TextCNN
class Discriminator(nn.Module):
def __init__(self, vocab_size, emb_dim, filter_num, filter_sizes, dropout=0.0):
super(Discriminator, self).__init__()
self.query_cnn = TextCNN(emb_dim, filte... | [
"torch.nn.ReLU",
"torch.nn.Dropout",
"torch.nn.Embedding",
"torch.nn.Softmax",
"torch.load",
"torch.nn.BCELoss",
"torch.sum",
"torch.save",
"torch.nn.Linear",
"torch.cat",
"textcnn.TextCNN"
] | [((298, 340), 'textcnn.TextCNN', 'TextCNN', (['emb_dim', 'filter_num', 'filter_sizes'], {}), '(emb_dim, filter_num, filter_sizes)\n', (305, 340), False, 'from textcnn import TextCNN\n'), ((369, 411), 'textcnn.TextCNN', 'TextCNN', (['emb_dim', 'filter_num', 'filter_sizes'], {}), '(emb_dim, filter_num, filter_sizes)\n', ... |
"""Setup the pylonsapp application"""
import logging
import pylons.test
from pylonsapp.config.environment import load_environment
from pylonsapp.model.meta import Session, metadata
log = logging.getLogger(__name__)
def setup_app(command, conf, vars):
"""Place any commands to setup pylonsapp here"""
# Don't ... | [
"logging.getLogger",
"pylonsapp.config.environment.load_environment",
"pylonsapp.model.meta.Session.commit",
"pylonsapp.model.meta.Session.add",
"pylonsapp.model.meta.metadata.create_all",
"pylonsapp.model.Owner"
] | [((190, 217), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (207, 217), False, 'import logging\n'), ((534, 572), 'pylonsapp.model.meta.metadata.create_all', 'metadata.create_all', ([], {'bind': 'Session.bind'}), '(bind=Session.bind)\n', (553, 572), False, 'from pylonsapp.model.meta impor... |
import logging
import time
from pathlib import Path
from threading import Lock, Thread
from typing import Generator, List, Optional, Tuple
# import imageio
import numpy as np
import torch
from decord import cpu # , gpu
from decord import VideoReader
from imageio.plugins.ffmpeg import FfmpegFormat
from rich import get... | [
"logging.getLogger",
"utils.utils.guided_filter",
"rich.get_console",
"torch.cuda.device_count",
"time.sleep",
"utils.utils.modcrop",
"torch.cuda.is_available",
"architectures.get_network",
"utils.utils.mod2normal",
"utils.utils.recompose_tensor",
"pathlib.Path",
"threading.Lock",
"torch.set... | [((10564, 10580), 'pathlib.Path', 'Path', (['model_path'], {}), '(model_path)\n', (10568, 10580), False, 'from pathlib import Path\n'), ((6347, 6389), 'utils.defaults.get_network_G_config', 'get_network_G_config', (['net_dict', 'self.scale'], {}), '(net_dict, self.scale)\n', (6367, 6389), False, 'from utils.defaults im... |
from bug_reporting.models import Feedback
from django.contrib import admin
class FeedbackAdmin(admin.ModelAdmin):
list_display = ('comment', 'type', 'user', 'date', 'error_id')
#TODO: limit comment display to some number of characters
admin.site.register(Feedback, FeedbackAdmin)
| [
"django.contrib.admin.site.register"
] | [((245, 289), 'django.contrib.admin.site.register', 'admin.site.register', (['Feedback', 'FeedbackAdmin'], {}), '(Feedback, FeedbackAdmin)\n', (264, 289), False, 'from django.contrib import admin\n')] |
import random
import pygame
import entity
import global_vars as g
EVENT_NONE = 0
EVENT_FODDER = 1
EVENT_SINE = 2
EVENT_GRUNT = 3
EVENT_SENTRY = 4
EVENT_HPUP = 5
EVENT_SCOPE = 6
EVENT_AS = 7
enemySpawn = {EVENT_FODDER: [], EVENT_SINE: [],
EVENT_GRUNT: [], EVENT_SENTRY: []}
buffSpawn = {... | [
"random.random",
"random.uniform",
"random.randint"
] | [((523, 579), 'random.randint', 'random.randint', (['entity.RFODDER', '(size[0] - entity.RFODDER)'], {}), '(entity.RFODDER, size[0] - entity.RFODDER)\n', (537, 579), False, 'import random\n'), ((662, 718), 'random.randint', 'random.randint', (['entity.RSENTRY', '(size[0] - entity.RSENTRY)'], {}), '(entity.RSENTRY, size... |
import unittest
from pymatgen.core import Structure
from veidt.monte_carlo.base import StateDict, StaticState
from veidt.monte_carlo.state import AtomNumberState, IsingState
from veidt.monte_carlo.state import SpinStructure, Chain
import os
file_path = os.path.dirname(__file__)
def unequal_site_number(list1, list2):... | [
"veidt.monte_carlo.state.Chain",
"veidt.monte_carlo.base.StaticState",
"veidt.monte_carlo.state.SpinStructure",
"veidt.monte_carlo.base.StateDict",
"os.path.join",
"veidt.monte_carlo.state.IsingState",
"os.path.dirname",
"unittest.main",
"veidt.monte_carlo.state.AtomNumberState"
] | [((254, 279), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (269, 279), False, 'import os\n'), ((3294, 3309), 'unittest.main', 'unittest.main', ([], {}), '()\n', (3307, 3309), False, 'import unittest\n'), ((474, 498), 'veidt.monte_carlo.state.IsingState', 'IsingState', (['[0, 1, 0, 1]'], {})... |
# -*- coding: UTF8 -*-
import requests
import json
import configparser as cfg
# $ pip install pyTelegramBotAPI
import telebot
from telebot import types
""" markup = types.ReplyKeyboardMarkup()
markup.add('a', 'v', 'd')
tb.send_message(chat_id, message, reply_markup=markup)
# or add strings one row at a time:
markup =... | [
"json.loads",
"configparser.ConfigParser",
"requests.get",
"telebot.types.ReplyKeyboardMarkup",
"telebot.TeleBot"
] | [((669, 696), 'telebot.TeleBot', 'telebot.TeleBot', (['self.token'], {}), '(self.token)\n', (684, 696), False, 'import telebot\n'), ((3313, 3331), 'configparser.ConfigParser', 'cfg.ConfigParser', ([], {}), '()\n', (3329, 3331), True, 'import configparser as cfg\n'), ((3583, 3600), 'requests.get', 'requests.get', (['url... |
from django.contrib import admin
from favourite.api.models import Favourite
admin.site.register(Favourite)
| [
"django.contrib.admin.site.register"
] | [((78, 108), 'django.contrib.admin.site.register', 'admin.site.register', (['Favourite'], {}), '(Favourite)\n', (97, 108), False, 'from django.contrib import admin\n')] |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# etips
#
# Copyright (c) Siemens AG, 2020
# Authors:
# <NAME> <<EMAIL>>
# License-Identifier: MIT
from pathlib import Path
from joblib import dump
import numpy as np
from sklearn.model_selection import KFold
from sklearn.dummy import DummyClassifier
from utils import ... | [
"pathlib.Path",
"numpy.argmax",
"utils.fix_random_seed",
"sklearn.dummy.DummyClassifier",
"utils.load_counting_data",
"sklearn.model_selection.KFold",
"joblib.dump"
] | [((405, 423), 'utils.fix_random_seed', 'fix_random_seed', (['(0)'], {}), '(0)\n', (420, 423), False, 'from utils import fix_random_seed, load_counting_data, load_mnist_data\n'), ((439, 455), 'pathlib.Path', 'Path', (['"""../data/"""'], {}), "('../data/')\n", (443, 455), False, 'from pathlib import Path\n'), ((526, 566)... |