code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
from pathlib import Path
from datetime import timezone, timedelta
import pytest
from photomanager.pyexiftool import ExifTool
from photomanager.photofile import PhotoFile
FIXTURE_DIR = Path(__file__).resolve().parent.parent / "test_files"
ALL_IMG_DIRS = pytest.mark.datafiles(
FIXTURE_DIR / "A",
FIXTURE_DIR / "B... | [
"pathlib.Path",
"photomanager.pyexiftool.ExifTool",
"pytest.mark.datafiles",
"photomanager.photofile.PhotoFile",
"datetime.timedelta"
] | [((254, 355), 'pytest.mark.datafiles', 'pytest.mark.datafiles', (["(FIXTURE_DIR / 'A')", "(FIXTURE_DIR / 'B')", "(FIXTURE_DIR / 'C')"], {'keep_top_dir': '(True)'}), "(FIXTURE_DIR / 'A', FIXTURE_DIR / 'B', FIXTURE_DIR /\n 'C', keep_top_dir=True)\n", (275, 355), False, 'import pytest\n'), ((406, 588), 'photomanager.ph... |
from django import template
from django.conf import settings
import shortuuid
from django_unicorn.call_method_parser import InvalidKwarg, parse_kwarg
from ..settings import get_setting
register = template.Library()
@register.inclusion_tag("unicorn/scripts.html")
def unicorn_scripts():
return {"MINIFIED": ge... | [
"django_unicorn.call_method_parser.parse_kwarg",
"django.template.TemplateSyntaxError",
"django.template.Variable",
"django.template.Library",
"shortuuid.uuid"
] | [((202, 220), 'django.template.Library', 'template.Library', ([], {}), '()\n', (218, 220), False, 'from django import template\n'), ((956, 1041), 'django.template.TemplateSyntaxError', 'template.TemplateSyntaxError', (['("%r tag\'s argument should be in quotes" % tag_name)'], {}), '("%r tag\'s argument should be in quo... |
import numpy as np
def convert_weights(d, cfg):
has_fpn = cfg.MODEL.NECK.NAME == "FPN"
use_res5_in_stage2 = cfg.MODEL.ROI_HEADS.NAME == "Res5ROIHeads"
is_retina = cfg.MODEL.NECK.TOP_BLOCK_TYPE == "P6P7"
ret = {}
def _convert_conv(src, dst):
src_w = d.pop(src + ".weight").transpose(2, 3, 1... | [
"numpy.stack",
"numpy.log2",
"numpy.reshape",
"numpy.arange"
] | [((3357, 3416), 'numpy.stack', 'np.stack', (['[idx_ymin, idx_xmin, idx_ymax, idx_xmax]'], {'axis': '(-1)'}), '([idx_ymin, idx_xmin, idx_ymax, idx_xmax], axis=-1)\n', (3365, 3416), True, 'import numpy as np\n'), ((3432, 3471), 'numpy.reshape', 'np.reshape', (['idxs', '[num_reg_classes * 4]'], {}), '(idxs, [num_reg_class... |
# -*- coding: utf-8 -*-
"""
Created on Mon Dec 9 01:58:58 2019
@author: iqbalsublime
"""
#================================================================================================================
#---------------------------------------------------------------------------------------------------------... | [
"random.shuffle",
"pandas.read_csv",
"time.clock",
"matplotlib.pyplot.style.use",
"collections.Counter",
"numpy.array",
"pandas.DataFrame",
"sklearn.preprocessing.MinMaxScaler"
] | [((993, 1016), 'matplotlib.pyplot.style.use', 'plt.style.use', (['"""ggplot"""'], {}), "('ggplot')\n", (1006, 1016), True, 'import matplotlib.pyplot as plt\n'), ((2826, 2867), 'pandas.read_csv', 'pd.read_csv', (['"""chronic_kidney_disease.csv"""'], {}), "('chronic_kidney_disease.csv')\n", (2837, 2867), True, 'import pa... |
import json
def application(environ, start_response):
try:
request_body_size = int(environ.get('CONTENT_LENGTH', 0))
except (ValueError):
request_body_size = 0
request_body = environ['wsgi.input'].read(request_body_size)
reqj = json.loads(request_body)
res = { "result": 0 }
fo... | [
"json.loads",
"json.dumps"
] | [((262, 286), 'json.loads', 'json.loads', (['request_body'], {}), '(request_body)\n', (272, 286), False, 'import json\n'), ((475, 490), 'json.dumps', 'json.dumps', (['res'], {}), '(res)\n', (485, 490), False, 'import json\n')] |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import numpy as np
import tensorflow as tf
from cleverhans.utils_tf import model_train, model_eval, tf_model_load
from cleverhans.utils import AccuracyReport, set_log_lev... | [
"cleverhans.utils_tf.tf_model_load",
"cleverhans.utils_tf.model_eval",
"tensorflow.placeholder",
"cleverhans.utils.AccuracyReport",
"numpy.random.RandomState"
] | [((704, 720), 'cleverhans.utils.AccuracyReport', 'AccuracyReport', ([], {}), '()\n', (718, 720), False, 'from cleverhans.utils import AccuracyReport, set_log_level\n'), ((768, 829), 'tensorflow.placeholder', 'tf.placeholder', (['tf.float32'], {'shape': "self.data_params['x_shape']"}), "(tf.float32, shape=self.data_para... |
from PyQt5.QtWidgets import *
from PyQt5.QtCore import Qt
import json
class QConfigWidget(QWidget):
"""A widget that allows adding of QtWidgets into a QFormLayout where the
left column will always be a label matching the name supplied when adding
widgets to the right column. The values of all the QtWidgets... | [
"json.load"
] | [((5128, 5140), 'json.load', 'json.load', (['f'], {}), '(f)\n', (5137, 5140), False, 'import json\n')] |
#! /usr/bin/env python
# -*- coding: utf-8 -*-
"""Batch processing for GRD products
"""
import os
import json
import itertools
import logging
import pandas as pd
from pathlib import Path
from godale._concurrent import Executor
from ost import Sentinel1Scene
from ost.s1 import grd_to_ard
from ost.helpers import ras... | [
"logging.getLogger",
"ost.helpers.raster.create_tscan_vrt",
"pathlib.Path",
"godale._concurrent.Executor",
"itertools.product",
"pandas.DataFrame.from_dict",
"json.load",
"os.cpu_count",
"pandas.DataFrame",
"pandas.concat",
"ost.Sentinel1Scene"
] | [((508, 535), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (525, 535), False, 'import logging\n'), ((1898, 1964), 'pandas.DataFrame', 'pd.DataFrame', ([], {'columns': "['identifier', 'outfile', 'out_ls', 'error']"}), "(columns=['identifier', 'outfile', 'out_ls', 'error'])\n", (1910, 196... |
""" Fetch a URL and process its response using async io """
import asyncio
import aiohttp
import io
async def fetch_page(url):
""" Asynchronous URL fetcher """
future = aiohttp.request('GET', url)
# Wait for the future
response = await future
return response
async def parse_response(don... | [
"asyncio.get_event_loop",
"asyncio.wait",
"aiohttp.request"
] | [((583, 607), 'asyncio.get_event_loop', 'asyncio.get_event_loop', ([], {}), '()\n', (605, 607), False, 'import asyncio\n'), ((184, 211), 'aiohttp.request', 'aiohttp.request', (['"""GET"""', 'url'], {}), "('GET', url)\n", (199, 211), False, 'import aiohttp\n'), ((866, 898), 'asyncio.wait', 'asyncio.wait', (['tasks'], {'... |
# Modified by Microsoft Corporation.
# Licensed under the MIT license.
import json
import operator
import os
import pickle
import subprocess
import sys
import time
from collections import deque
from contextlib import contextmanager
from datetime import datetime
from importlib import reload
from pprint import pformat
... | [
"pandas.read_csv",
"torch.cuda.device_count",
"yaml.load",
"numpy.array_split",
"numpy.array",
"pydash.is_empty",
"operator.itemgetter",
"torch.multiprocessing.cpu_count",
"numpy.arange",
"ujson.load",
"regex.search",
"os.path.exists",
"pydash.is_dict",
"numpy.isscalar",
"subprocess.Pope... | [((525, 539), 'torch.multiprocessing.cpu_count', 'mp.cpu_count', ([], {}), '()\n', (537, 539), True, 'import torch.multiprocessing as mp\n'), ((588, 631), 'regex.compile', 're.compile', (['"""(\\\\d{4}_\\\\d{2}_\\\\d{2}_\\\\d{6})"""'], {}), "('(\\\\d{4}_\\\\d{2}_\\\\d{2}_\\\\d{6})')\n", (598, 631), True, 'import regex ... |
# pylint: disable=no-self-use,invalid-name,protected-access
from __future__ import division
from __future__ import absolute_import
from nltk.tree import Tree
from allennlp.data.dataset_readers import PennTreeBankConstituencySpanDatasetReader
from allennlp.common.testing import AllenNlpTestCase
from allennlp.data.da... | [
"allennlp.data.dataset_readers.dataset_utils.span_utils.enumerate_spans",
"allennlp.data.dataset_readers.PennTreeBankConstituencySpanDatasetReader",
"nltk.tree.Tree.fromstring",
"itertools.izip"
] | [((684, 727), 'allennlp.data.dataset_readers.PennTreeBankConstituencySpanDatasetReader', 'PennTreeBankConstituencySpanDatasetReader', ([], {}), '()\n', (725, 727), False, 'from allennlp.data.dataset_readers import PennTreeBankConstituencySpanDatasetReader\n'), ((2083, 2594), 'nltk.tree.Tree.fromstring', 'Tree.fromstrin... |
import os
import logging
import sys
sys.path.append('../../')
from loader import *
from parameters import *
from plotting import *
logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.INFO)
def create_tag_provider(include_topic):
def get_tags(name):
tags = name.split("/")[-1].split("... | [
"logging.basicConfig",
"sys.path.append",
"logging.info"
] | [((37, 62), 'sys.path.append', 'sys.path.append', (['"""../../"""'], {}), "('../../')\n", (52, 62), False, 'import sys\n'), ((134, 209), 'logging.basicConfig', 'logging.basicConfig', ([], {'format': '"""%(levelname)s:%(message)s"""', 'level': 'logging.INFO'}), "(format='%(levelname)s:%(message)s', level=logging.INFO)\n... |
from django.http import HttpResponseRedirect, HttpResponse
from django.shortcuts import render, redirect
from bookapp import models
from bookapp.forms import AfegirLlibreForm, SolicitarImatgesForm, SolicitarMaquetacioForm, PujarMaquetacio, pujarImatge, \
SolicitarPublicacioForm, EnviarMissatgeForm, SolicitarTraducc... | [
"bookapp.models.TematiquesLlibre.objects.filter",
"users.models.CustomUser.objects.filter",
"bookapp.forms.PujarMaquetacio",
"fpdf.FPDF",
"bookapp.models.solicitudMaquetacio.objects.filter",
"django.core.files.base.File",
"bookapp.models.Comentari.objects.filter",
"django.urls.reverse",
"bookapp.mod... | [((771, 799), 'django.shortcuts.render', 'render', (['request', '"""home.html"""'], {}), "(request, 'home.html')\n", (777, 799), False, 'from django.shortcuts import render, redirect\n'), ((859, 901), 'users.models.CustomUser.objects.get', 'CustomUser.objects.get', ([], {'email': 'request.user'}), '(email=request.user)... |
#!/usr/bin/env python3
"""get files info"""
import datetime
import glob
import hashlib
import os
import json
import pytz
class FilesInfo:
"""get files info"""
def __init__(self):
self.files = []
self.file_number = 22
self.experiment_date_time = "2017"
self.total_file_size = 1... | [
"datetime.datetime.fromtimestamp",
"json.dumps",
"os.path.basename",
"os.stat",
"glob.glob"
] | [((554, 600), 'glob.glob', 'glob.glob', (["(my_dir + '/**/**.*')"], {'recursive': '(True)'}), "(my_dir + '/**/**.*', recursive=True)\n", (563, 600), False, 'import glob\n'), ((3186, 3207), 'json.dumps', 'json.dumps', (['orig_dict'], {}), '(orig_dict)\n', (3196, 3207), False, 'import json\n'), ((1140, 1157), 'os.stat', ... |
import logging
import sys
import can
LOGGER = logging.getLogger(__name__)
class CanBus:
def __init__(self, interface, sender):
self.interface = interface
self.sender = int(str(sender), 16)
def __enter__(self):
try:
self.bus = can.interface.Bus(
channel=sel... | [
"logging.getLogger",
"can.interface.Bus",
"can.Message",
"sys.exit",
"can.Notifier"
] | [((47, 74), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (64, 74), False, 'import logging\n'), ((685, 754), 'can.Message', 'can.Message', ([], {'arbitration_id': 'self.sender', 'data': 'data', 'extended_id': '(False)'}), '(arbitration_id=self.sender, data=data, extended_id=False)\n', (6... |
#!/usr/bin/env python
# coding: utf-8
# # Plotting graphs with Seaborn
# In[2]:
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
# In[3]:
iris = sns.load_dataset('iris')
iris.shape
# In[4]:
iris.head()
# In[5]:
iris['species'].unique()
# # Univariate Analys... | [
"seaborn.displot",
"seaborn.load_dataset",
"seaborn.histplot",
"seaborn.heatmap",
"seaborn.boxplot",
"seaborn.kdeplot",
"seaborn.scatterplot",
"matplotlib.pyplot.scatter",
"seaborn.countplot",
"seaborn.violinplot",
"seaborn.jointplot",
"seaborn.pairplot",
"matplotlib.pyplot.show"
] | [((198, 222), 'seaborn.load_dataset', 'sns.load_dataset', (['"""iris"""'], {}), "('iris')\n", (214, 222), True, 'import seaborn as sns\n'), ((2415, 2465), 'seaborn.histplot', 'sns.histplot', ([], {'data': 'iris', 'x': '"""petal_length"""', 'bins': '(30)'}), "(data=iris, x='petal_length', bins=30)\n", (2427, 2465), True... |
import os
from PyQt5.QtGui import QIcon
from PyQt5.QtCore import Qt
from PyQt5.QtWidgets import *
from cad.sketch import Sketch
from cad.solver import *
directory = os.path.dirname(__file__)
def icon_path(name: str) -> str:
return os.path.join(directory, 'icons', name)
class Application(QMainWindow):
de... | [
"os.path.dirname",
"os.path.join",
"cad.sketch.Sketch"
] | [((168, 193), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (183, 193), False, 'import os\n'), ((240, 278), 'os.path.join', 'os.path.join', (['directory', '"""icons"""', 'name'], {}), "(directory, 'icons', name)\n", (252, 278), False, 'import os\n'), ((718, 730), 'cad.sketch.Sketch', 'Sketch... |
# Copyright The Cloud Custodian Authors.
# SPDX-License-Identifier: Apache-2.0
from setuptools import setup
import os
description = ""
if os.path.exists('README.md'):
description = open('README.md', 'r').read()
setup(
name="c7n_autodoc",
version='0.3',
description="Cloud Custodian - Automated Policy ... | [
"os.path.exists",
"setuptools.setup"
] | [((140, 167), 'os.path.exists', 'os.path.exists', (['"""README.md"""'], {}), "('README.md')\n", (154, 167), False, 'import os\n'), ((218, 773), 'setuptools.setup', 'setup', ([], {'name': '"""c7n_autodoc"""', 'version': '"""0.3"""', 'description': '"""Cloud Custodian - Automated Policy Documentation"""', 'classifiers': ... |
import random
from .dictionary import ADJECTIVES, ANIMALS
__all__ = [ 'animal_pair' ]
def animal_pair():
return u'%s-%s' % (
random.choice(ADJECTIVES),
random.choice(ANIMALS),
)
| [
"random.choice"
] | [((142, 167), 'random.choice', 'random.choice', (['ADJECTIVES'], {}), '(ADJECTIVES)\n', (155, 167), False, 'import random\n'), ((177, 199), 'random.choice', 'random.choice', (['ANIMALS'], {}), '(ANIMALS)\n', (190, 199), False, 'import random\n')] |
# Copyright 2018 Yahoo Inc.
# Licensed under the terms of the Apache 2.0 license.
# Please see LICENSE file in the project root for terms.
# This example demonstrates how to leverage Spark for parallel inferencing from a SavedModel.
#
# Normally, you can use TensorFlowOnSpark to just form a TensorFlow cluster for trai... | [
"tensorflow.saved_model.load",
"numpy.reshape",
"argparse.ArgumentParser",
"tensorflow.io.parse_single_example",
"numpy.argmax",
"tensorflow.io.gfile.makedirs",
"tensorflow.io.FixedLenFeature",
"pyspark.conf.SparkConf",
"tensorflow.reshape",
"tensorflowonspark.TFParallel.run",
"tensorflow.cast"
... | [((1076, 1126), 'tensorflow.saved_model.load', 'tf.saved_model.load', (['args.export_dir'], {'tags': '"""serve"""'}), "(args.export_dir, tags='serve')\n", (1095, 1126), True, 'import tensorflow as tf\n'), ((2005, 2038), 'tensorflow.io.gfile.makedirs', 'tf.io.gfile.makedirs', (['args.output'], {}), '(args.output)\n', (2... |
# Copyright 2020 Determined AI. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law o... | [
"tensorflow.compat.v1.data.get_output_types",
"tensorflow.executing_eagerly",
"tensorflow.compat.v1.data.make_one_shot_iterator",
"tensorflow.compat.v1.data.get_output_shapes",
"tensorflow.data.Dataset.from_generator",
"tensorflow.compat.v1.Session"
] | [((2130, 2152), 'tensorflow.executing_eagerly', 'tf.executing_eagerly', ([], {}), '()\n', (2150, 2152), True, 'import tensorflow as tf\n'), ((3014, 3139), 'tensorflow.data.Dataset.from_generator', 'tf.data.Dataset.from_generator', (['stream.iterator_fn'], {'output_types': 'stream.output_types', 'output_shapes': 'stream... |
#!/usr/bin/env python
from visualization_msgs.msg import Marker
from visualization_msgs.msg import MarkerArray
import rospy
import math
topic = "visualization_marker_array"
publisher = rospy.Publisher(topic, MarkerArray)
rospy.init_node("register")
markerArray = MarkerArray()
count = 0
MARKERS_MAX = 100
while not... | [
"visualization_msgs.msg.Marker",
"rospy.is_shutdown",
"visualization_msgs.msg.MarkerArray",
"rospy.init_node",
"math.cos",
"rospy.sleep",
"rospy.Publisher"
] | [((187, 222), 'rospy.Publisher', 'rospy.Publisher', (['topic', 'MarkerArray'], {}), '(topic, MarkerArray)\n', (202, 222), False, 'import rospy\n'), ((224, 251), 'rospy.init_node', 'rospy.init_node', (['"""register"""'], {}), "('register')\n", (239, 251), False, 'import rospy\n'), ((267, 280), 'visualization_msgs.msg.Ma... |
# rrs-web - admin interface definitions
#
# Copyright (C) 2014 Intel Corporation
#
# Licensed under the MIT license, see COPYING.MIT for details
#
# SPDX-License-Identifier: MIT
from django.utils.functional import curry
from django.contrib import admin
from django.contrib.admin import DateFieldListFilter
from django ... | [
"rrs.models.Milestone",
"layerindex.models.PythonEnvironment.get_default_python2_environment",
"django.contrib.admin.site.register",
"rrs.models.MaintenancePlan.objects.all",
"django.core.exceptions.ValidationError",
"layerindex.models.PythonEnvironment.get_default_python3_environment"
] | [((7750, 7808), 'django.contrib.admin.site.register', 'admin.site.register', (['MaintenancePlan', 'MaintenancePlanAdmin'], {}), '(MaintenancePlan, MaintenancePlanAdmin)\n', (7769, 7808), False, 'from django.contrib import admin\n'), ((7809, 7851), 'django.contrib.admin.site.register', 'admin.site.register', (['Release'... |
from utils.cell import cell
from utils.maze import maze
from utils.statistics import *
from utils.configuration import *
from utils.algorithms import *
from pygame.locals import *
import cProfile
PROGRAM_END = False
pygame.init()
pygame.display.set_caption("<NAME> || maze generator + pathfinding")
sub1 = mainSurface... | [
"utils.maze.maze"
] | [((475, 485), 'utils.maze.maze', 'maze', (['sub1'], {}), '(sub1)\n', (479, 485), False, 'from utils.maze import maze\n'), ((511, 521), 'utils.maze.maze', 'maze', (['sub2'], {}), '(sub2)\n', (515, 521), False, 'from utils.maze import maze\n'), ((547, 557), 'utils.maze.maze', 'maze', (['sub3'], {}), '(sub3)\n', (551, 557... |
import requests
from screen_translate.Mbox import Mbox
from screen_translate.LangCode import *
# ----------------------------------------------------------------
# Imports Library
# Google Translate
try:
from deep_translator import GoogleTranslator
except ConnectionError as e:
print("Error: No Internet Connect... | [
"requests.post",
"deep_translator.PonsTranslator",
"requests.get",
"deep_translator.MyMemoryTranslator",
"deep_translator.GoogleTranslator"
] | [((3571, 3658), 'deep_translator.MyMemoryTranslator', 'MyMemoryTranslator', ([], {'source': 'from_LanguageCode_Memory', 'target': 'to_LanguageCode_Memory'}), '(source=from_LanguageCode_Memory, target=\n to_LanguageCode_Memory)\n', (3589, 3658), False, 'from deep_translator import MyMemoryTranslator\n'), ((4652, 4726... |
from abc import ABC
from pathlib import Path
import pandas as pd
import scrapy
from src.crawl.utils import cleanup
from settings import YEAR, CRAWLING_OUTPUT_FOLDER
BASE_URL = 'https://ku-portal.kyushu-u.ac.jp/campusweb/slbssbdr.do?value(risyunen)={}&value(semekikn)=1&value(kougicd)={}&value(crclumcd)=ZZ'
PROG_DATA... | [
"pathlib.Path"
] | [((328, 342), 'pathlib.Path', 'Path', (['__file__'], {}), '(__file__)\n', (332, 342), False, 'from pathlib import Path\n'), ((626, 640), 'pathlib.Path', 'Path', (['__file__'], {}), '(__file__)\n', (630, 640), False, 'from pathlib import Path\n')] |
#!/usr/bin/python -tt
# -*- coding: utf-8 -*-
# Copyright (c) 2017, Intel Corporation
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# 1. Redistributions of source code must retain the above co... | [
"struct.Struct",
"binascii.crc32"
] | [((2313, 2350), 'struct.Struct', 'struct.Struct', (["('%sHHHH3cBI' % _ENDIAN)"], {}), "('%sHHHH3cBI' % _ENDIAN)\n", (2326, 2350), False, 'import struct\n'), ((3581, 3606), 'binascii.crc32', 'binascii.crc32', (['data[:-4]'], {}), '(data[:-4])\n', (3595, 3606), False, 'import binascii\n'), ((3783, 3813), 'struct.Struct',... |
"""
Copyright 2015 herd contributors
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 wr... | [
"setuptools.find_packages"
] | [((1310, 1325), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (1323, 1325), False, 'from setuptools import setup, find_packages\n')] |
import os
import time
try:
import yaml
except:
pass
from setuptools import setup, find_packages
# allow setup.py to be run from any path
os.chdir(os.path.normpath(os.path.join(os.path.abspath(__file__), os.pardir)))
if os.path.exists("./VERSION"):
with open("./VERSION", "r") as f:
AVI_PIP_VERSION ... | [
"os.path.abspath",
"os.path.exists",
"setuptools.find_packages",
"time.gmtime"
] | [((229, 256), 'os.path.exists', 'os.path.exists', (['"""./VERSION"""'], {}), "('./VERSION')\n", (243, 256), False, 'import os\n'), ((350, 363), 'time.gmtime', 'time.gmtime', ([], {}), '()\n', (361, 363), False, 'import time\n'), ((652, 667), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (665, 667), Fal... |
# coding: utf-8
# pylint: disable=invalid-name, no-member, too-many-arguments
""" wrapper function of distmesh for EIT """
# Copyright (c) <NAME>. All rights reserved.
# Distributed under the (new) BSD License. See LICENSE.txt for more info.
from __future__ import division, absolute_import, print_function
import numpy... | [
"numpy.mean",
"numpy.iscomplex",
"numpy.sqrt",
"numpy.ones",
"numpy.size",
"numpy.array",
"numpy.arange"
] | [((1358, 1372), 'numpy.array', 'np.array', (['bbox'], {}), '(bbox)\n', (1366, 1372), True, 'import numpy as np\n'), ((3520, 3535), 'numpy.arange', 'np.arange', (['n_el'], {}), '(n_el)\n', (3529, 3535), True, 'import numpy as np\n'), ((3598, 3633), 'numpy.ones', 'np.ones', (['t.shape[0]'], {'dtype': 'np.float'}), '(t.sh... |
# -*- coding: utf-8 -*-
'''
Support for the softwareupdate command on MacOS.
'''
from __future__ import absolute_import
# Import python libs
import re
import os
# import salt libs
import salt.utils
import salt.utils.mac_utils
from salt.exceptions import CommandExecutionError, SaltInvocationError
__virtualname__ = '... | [
"os.path.join",
"os.walk",
"re.compile"
] | [((1094, 1152), 're.compile', 're.compile', (['"""(?m)^ [*|-] ([^ ].*)[\\\\r\\\\n].*\\\\(([^\\\\)]+)"""'], {}), "('(?m)^ [*|-] ([^ ].*)[\\\\r\\\\n].*\\\\(([^\\\\)]+)')\n", (1104, 1152), False, 'import re\n'), ((1956, 2010), 're.compile', 're.compile', (['"""(?m)^ [*|-] ([^ ].*)[\\\\r\\\\n].*restart*"""'], {}), "(... |
import numpy as np
import mxnet as mx
from collections import namedtuple
def get_network_fc(network_path, network_epoch, normalize_inputs):
batch_def = namedtuple('Batch', ['data'])
sym, arg_params, aux_params = mx.model.load_checkpoint(network_path, network_epoch)
network = mx.mod.Module(symbol=sym.get_i... | [
"collections.namedtuple",
"numpy.array",
"numpy.zeros",
"mxnet.gpu",
"mxnet.nd.array",
"mxnet.model.load_checkpoint",
"numpy.transpose"
] | [((1153, 1195), 'numpy.zeros', 'np.zeros', (['[6, 224, 224, 3]'], {'dtype': 'np.uint8'}), '([6, 224, 224, 3], dtype=np.uint8)\n', (1161, 1195), True, 'import numpy as np\n'), ((157, 186), 'collections.namedtuple', 'namedtuple', (['"""Batch"""', "['data']"], {}), "('Batch', ['data'])\n", (167, 186), False, 'from collect... |
from sqlalchemy.engine import ResultProxy
from drone_squadron.crud.drone_crud import DroneCrud
from drone_squadron.crud.squadron_crud import SquadronCrud
class TestDrone:
def test_post(self, log_in, test_client):
with SquadronCrud() as crud:
result = crud.insert(name="<NAME>", user=1) # typ... | [
"drone_squadron.crud.squadron_crud.SquadronCrud",
"drone_squadron.crud.drone_crud.DroneCrud"
] | [((234, 248), 'drone_squadron.crud.squadron_crud.SquadronCrud', 'SquadronCrud', ([], {}), '()\n', (246, 248), False, 'from drone_squadron.crud.squadron_crud import SquadronCrud\n'), ((1300, 1314), 'drone_squadron.crud.squadron_crud.SquadronCrud', 'SquadronCrud', ([], {}), '()\n', (1312, 1314), False, 'from drone_squadr... |
import time
def primise(n):
if n == 2:
return [2]
elif n < 2:
return []
s = []
for i in range(3, n + 1):
if i % 2 != 0:
s.append(i)
mroot = n ** 0.5
half = (n + 1) / 2 - 1
i = 0
m = 3
while m <= mroot:
if s[i]:
j = int((m * m ... | [
"time.time"
] | [((1033, 1044), 'time.time', 'time.time', ([], {}), '()\n', (1042, 1044), False, 'import time\n'), ((1115, 1126), 'time.time', 'time.time', ([], {}), '()\n', (1124, 1126), False, 'import time\n')] |
# -*- coding: utf-8 -*-
# Copyright (c) 2019, VMRaid Technologies and contributors
# For license information, please see license.txt
import google.oauth2.credentials
import requests
from googleapiclient.discovery import build
from googleapiclient.errors import HttpError
import vmraid
from vmraid import _
from vmraid... | [
"vmraid.db.commit",
"vmraid.get_list",
"vmraid.integrations.doctype.google_settings.google_settings.get_auth_url",
"vmraid.utils.get_request_site_address",
"vmraid.utils.now_datetime",
"vmraid.throw",
"vmraid._",
"vmraid.cache",
"googleapiclient.discovery.build",
"vmraid.get_doc",
"vmraid.db.get... | [((1728, 1746), 'vmraid.whitelist', 'vmraid.whitelist', ([], {}), '()\n', (1744, 1746), False, 'import vmraid\n'), ((3521, 3539), 'vmraid.whitelist', 'vmraid.whitelist', ([], {}), '()\n', (3537, 3539), False, 'import vmraid\n'), ((4714, 4732), 'vmraid.whitelist', 'vmraid.whitelist', ([], {}), '()\n', (4730, 4732), Fals... |
# -*- coding: utf-8 -*-
#
# Copyright Contributors to the Conu project.
# SPDX-License-Identifier: MIT
#
import subprocess
import logging
import time
from conu import DockerBackend, DockerRunBuilder
environment = ["-e", "POSTGRESQL_USER=user",
"-e", "POSTGRESQL_PASSWORD=<PASSWORD>",
"-... | [
"conu.DockerRunBuilder",
"time.sleep",
"conu.DockerBackend"
] | [((356, 398), 'conu.DockerBackend', 'DockerBackend', ([], {'logging_level': 'logging.DEBUG'}), '(logging_level=logging.DEBUG)\n', (369, 398), False, 'from conu import DockerBackend, DockerRunBuilder\n'), ((790, 858), 'conu.DockerRunBuilder', 'DockerRunBuilder', ([], {'command': "['psql', endpoint]", 'additional_opts': ... |
"""Basic Breakpoint API Examples."""
import numpy as np
import pandas as pd
from portformer import BreakpointAPI
def examples():
"""List of major Breakpoint API examples"""
# Read environment variable = BREAKPOINT_API_KEY
api = BreakpointAPI(api_key=None)
# Get Latest AAPL forecasts
breakpoint... | [
"numpy.random.normal",
"numpy.random.seed",
"portformer.BreakpointAPI",
"pandas.bdate_range"
] | [((244, 271), 'portformer.BreakpointAPI', 'BreakpointAPI', ([], {'api_key': 'None'}), '(api_key=None)\n', (257, 271), False, 'from portformer import BreakpointAPI\n'), ((1749, 1776), 'portformer.BreakpointAPI', 'BreakpointAPI', ([], {'api_key': 'None'}), '(api_key=None)\n', (1762, 1776), False, 'from portformer import ... |
import httpretty
import json
import unittest
def setUp_method_with_http_mocking(test_class):
original_setUp = test_class.setUp if hasattr(test_class, 'setUp') else None
def new_setUp(self):
httpretty.enable()
self.addCleanup(httpretty.disable)
if original_setUp:
original_... | [
"httpretty.last_request",
"httpretty.enable",
"httpretty.httprettified",
"httpretty.register_uri"
] | [((622, 648), 'httpretty.httprettified', 'httpretty.httprettified', (['x'], {}), '(x)\n', (645, 648), False, 'import httpretty\n'), ((990, 1087), 'httpretty.register_uri', 'httpretty.register_uri', ([], {'method': 'method', 'uri': 'uri', 'body': 'response_body', 'content_type': 'content_type'}), '(method=method, uri=ur... |
import cupy
from cupy._core import internal
def take(a, indices, axis=None, out=None):
"""Takes elements of an array at specified indices along an axis.
This is an implementation of "fancy indexing" at single axis.
This function does not support ``mode`` option.
Args:
a (cupy.ndarray): Arra... | [
"cupy.isscalar",
"cupy.arange",
"cupy.result_type",
"cupy.broadcast_arrays",
"cupy.empty",
"cupy.array",
"cupy._core.internal._normalize_axis_index",
"cupy.copyto"
] | [((1470, 1512), 'cupy._core.internal._normalize_axis_index', 'internal._normalize_axis_index', (['axis', 'ndim'], {}), '(axis, ndim)\n', (1500, 1512), False, 'from cupy._core import internal\n'), ((6517, 6546), 'cupy.result_type', 'cupy.result_type', (['*choicelist'], {}), '(*choicelist)\n', (6533, 6546), False, 'impor... |
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
import scarlet.scheduling.fields
class Migration(migrations.Migration):
dependencies = [
('contenttypes', '0002_remove_content_type_name'),
]
operations = [
migrations.CreateModel(
... | [
"django.db.models.DateTimeField",
"django.db.models.AutoField",
"django.db.models.CharField",
"django.db.models.ForeignKey"
] | [((392, 485), 'django.db.models.AutoField', 'models.AutoField', ([], {'verbose_name': '"""ID"""', 'serialize': '(False)', 'auto_created': '(True)', 'primary_key': '(True)'}), "(verbose_name='ID', serialize=False, auto_created=True,\n primary_key=True)\n", (408, 485), False, 'from django.db import models, migrations\... |
import psycopg2
def createStops(conn):
c = conn.cursor()
c.execute('''
CREATE TABLE IF NOT EXISTS stops(
stop_id TEXT PRIMARY KEY,
name TEXT,
lon DOUBLE PRECISION,
lat DOUBLE PRECISION);
''')
c.execute('''CREATE INDEX CONCURRENTLY IF NOT EXISTS
lon... | [
"psycopg2.connect"
] | [((663, 686), 'psycopg2.connect', 'psycopg2.connect', (['creds'], {}), '(creds)\n', (679, 686), False, 'import psycopg2\n')] |
import logging
import time
import unittest
from multiprocessing import Process
from os import kill
import snap7
from snap7.server import mainloop
logging.basicConfig(level=logging.WARNING)
ip = '127.0.0.1'
tcpport = 1102
db_number = 1
rack = 1
slot = 1
class TestClient(unittest.TestCase):
@classmethod
def... | [
"logging.basicConfig",
"os.kill",
"multiprocessing.Process",
"time.sleep",
"snap7.client.Client",
"unittest.skip"
] | [((148, 190), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.WARNING'}), '(level=logging.WARNING)\n', (167, 190), False, 'import logging\n'), ((754, 859), 'unittest.skip', 'unittest.skip', (['"""TODO: RuntimeWarning: coroutine \'TestClient.test_as_db_read\' was never awaited"""'], {}), '(\n "T... |
#!/usr/bin/env python
import os.path
import sys
import tempfile
import argparse
import gemini.version
def add_inheritance_args(parser, min_kindreds=1, depth=True, gt_ll=False,
allow_unaffected=True, lenient=True, gq=True):
"""Common arguments added to various sub-parsers"""
parser.add_argument('db',
... | [
"gemini.gemini_stats.stats",
"gemini.genewise.add_args",
"gemini.gemini_bcolz.create",
"gemini.gemini_windower.windower",
"gemini.gemini_load_chunk.load",
"gemini.gim.AutoRec",
"gemini.gemini_annotate.annotate",
"gemini.gim.XRec",
"gemini.gim.XDom",
"gemini.gemini_update.release",
"argparse.Argu... | [((4141, 4240), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'prog': '"""gemini"""', 'formatter_class': 'argparse.ArgumentDefaultsHelpFormatter'}), "(prog='gemini', formatter_class=argparse.\n ArgumentDefaultsHelpFormatter)\n", (4164, 4240), False, 'import argparse\n'), ((54327, 54352), 'gemini.genewi... |
import time
import unittest
from MiscUtils.Funcs import (
asclocaltime, commas, charWrap, wordWrap, excstr,
hostName, localIP, localTimeDelta, positiveId,
safeDescription, timestamp, uniqueId, valueForString)
class TestFuncs(unittest.TestCase):
"""Unit tests for the functions in MiscUtils.Funcs."""
... | [
"MiscUtils.Funcs.localTimeDelta",
"MiscUtils.Funcs.charWrap",
"MiscUtils.Funcs.excstr",
"MiscUtils.Funcs.positiveId",
"MiscUtils.Funcs.asclocaltime",
"MiscUtils.Funcs.commas",
"MiscUtils.Funcs.hostName",
"MiscUtils.Funcs.timestamp",
"MiscUtils.Funcs.wordWrap",
"MiscUtils.Funcs.uniqueId",
"MiscUt... | [((2735, 2745), 'MiscUtils.Funcs.hostName', 'hostName', ([], {}), '()\n', (2743, 2745), False, 'from MiscUtils.Funcs import asclocaltime, commas, charWrap, wordWrap, excstr, hostName, localIP, localTimeDelta, positiveId, safeDescription, timestamp, uniqueId, valueForString\n'), ((2908, 2917), 'MiscUtils.Funcs.localIP',... |
from pypy.conftest import gettestobjspace
from pypy.module._rawffi.tracker import Tracker
class AppTestTracker:
def setup_class(cls):
Tracker.DO_TRACING = True
space = gettestobjspace(usemodules=('_rawffi','struct'))
cls.space = space
def test_array(self):
import _rawffi
... | [
"_rawffi.Structure",
"pypy.conftest.gettestobjspace",
"_rawffi.CallbackPtr",
"_rawffi._num_of_allocated_objects",
"_rawffi.Array"
] | [((190, 239), 'pypy.conftest.gettestobjspace', 'gettestobjspace', ([], {'usemodules': "('_rawffi', 'struct')"}), "(usemodules=('_rawffi', 'struct'))\n", (205, 239), False, 'from pypy.conftest import gettestobjspace\n'), ((332, 367), '_rawffi._num_of_allocated_objects', '_rawffi._num_of_allocated_objects', ([], {}), '()... |
"""Implements the :py:class:`RolesClient` class."""
from datetime import datetime, timezone
from typing import Callable, Optional, List, Dict, Any
from flask import current_app, has_app_context
import pymongo
from .exceptions import InvalidEntity
__all__ = ['RolesClient']
class RolesClient:
"""This class impl... | [
"datetime.datetime.now",
"flask.has_app_context",
"flask.current_app.logger.info"
] | [((4721, 4738), 'flask.has_app_context', 'has_app_context', ([], {}), '()\n', (4736, 4738), False, 'from flask import current_app, has_app_context\n'), ((4752, 4813), 'flask.current_app.logger.info', 'current_app.logger.info', (['f"""revoking role {role} for {entity}"""'], {}), "(f'revoking role {role} for {entity}')\n... |
# -*- coding: utf-8 -*-
#!/bin/env python3
# 194-67-90-149
import os, sys
import time
import io
import getopt
import subprocess
import time
import signal
import yaml
import requests
os.system('cls')
re = "\033[1;31m"
gr = "\033[1;32m"
cy="\033[1;36m"
logo = (f"""
_ __ {re}___ __{... | [
"requests.post",
"yaml.dump",
"time.sleep",
"io.open",
"os.system"
] | [((185, 201), 'os.system', 'os.system', (['"""cls"""'], {}), "('cls')\n", (194, 201), False, 'import os, sys\n'), ((798, 814), 'os.system', 'os.system', (['"""cls"""'], {}), "('cls')\n", (807, 814), False, 'import os, sys\n'), ((934, 950), 'os.system', 'os.system', (['"""cls"""'], {}), "('cls')\n", (943, 950), False, '... |
from application import db
from application.models import Base
from sqlalchemy.sql import text
class Song(Base):
views = db.Column(db.Integer, nullable=False)
account_id = db.Column(db.Integer, db.ForeignKey(
'account.id'), nullable=False)
album_id = db.Column(db.Integer, db.ForeignKey('album.id'... | [
"sqlalchemy.sql.text",
"application.db.Column",
"application.db.engine.execute",
"application.db.ForeignKey"
] | [((127, 164), 'application.db.Column', 'db.Column', (['db.Integer'], {'nullable': '(False)'}), '(db.Integer, nullable=False)\n', (136, 164), False, 'from application import db\n'), ((205, 232), 'application.db.ForeignKey', 'db.ForeignKey', (['"""account.id"""'], {}), "('account.id')\n", (218, 232), False, 'from applica... |
from spacy.tokens import Doc
def convert(cols, matched_token_idx):
#temp_path = os.path.join(this_dir,'temp.conllu')
matched_i = [list(map(lambda x: str(x+1), matched)) for matched in matched_token_idx]
for matched in matched_i:
cols = change_head(matched, cols)
return cols
def ch... | [
"spacy.tokens.Doc"
] | [((2035, 2073), 'spacy.tokens.Doc', 'Doc', (['vocab'], {'words': 'words', 'spaces': 'spaces'}), '(vocab, words=words, spaces=spaces)\n', (2038, 2073), False, 'from spacy.tokens import Doc\n')] |
# Generated by Django 2.1.1 on 2018-11-26 19:17
import django.contrib.postgres.fields
import django.contrib.postgres.fields.jsonb
import django.core.validators
from django.db import migrations, models
import functools
import main.models
import utils.validators
class Migration(migrations.Migration):
dependencies... | [
"functools.partial",
"django.db.models.CharField",
"django.db.models.BooleanField"
] | [((900, 1044), 'django.db.models.BooleanField', 'models.BooleanField', ([], {'default': '(True)', 'help_text': '"""Will guides be used with HDR (Homology Directed Repair)?"""', 'verbose_name': '"""HDR experiment?"""'}), "(default=True, help_text=\n 'Will guides be used with HDR (Homology Directed Repair)?',\n ver... |
from typing import TYPE_CHECKING
from drip.utils import json_list, json_object
if TYPE_CHECKING:
from requests import Session
class Broadcasts:
session: 'Session'
@json_list('broadcasts')
def broadcasts(self, marshall=True, **params):
"""
broadcasts(page=0, per_page=100, status='al... | [
"drip.utils.json_object",
"drip.utils.json_list"
] | [((182, 205), 'drip.utils.json_list', 'json_list', (['"""broadcasts"""'], {}), "('broadcasts')\n", (191, 205), False, 'from drip.utils import json_list, json_object\n'), ((1187, 1212), 'drip.utils.json_object', 'json_object', (['"""broadcasts"""'], {}), "('broadcasts')\n", (1198, 1212), False, 'from drip.utils import j... |
import os
import posixpath
import re
import _import_wrapper as iw
import _common as common
def init():
iw.addrule('swg', Swig)
class Swig(iw.CustomCommand):
def __init__(self, path, unit):
self._tool = unit.get('SWIG_TOOL')
self._library_dir = unit.get('SWIG_LIBRARY') or 'contrib/tools/swig... | [
"os.path.exists",
"posixpath.join",
"os.makedirs",
"_import_wrapper.addrule",
"os.path.join",
"os.path.splitext",
"_common.join_intl_paths",
"os.path.dirname",
"os.path.basename",
"_common.get"
] | [((110, 133), '_import_wrapper.addrule', 'iw.addrule', (['"""swg"""', 'Swig'], {}), "('swg', Swig)\n", (120, 133), True, 'import _import_wrapper as iw\n'), ((554, 582), 'os.path.basename', 'os.path.basename', (['self._path'], {}), '(self._path)\n', (570, 582), False, 'import os\n'), ((619, 646), 'os.path.dirname', 'os.... |
import os
import tqdm
import torch
import numpy as np
from lib.helpers.save_helper import load_checkpoint
from lib.helpers.decode_helper import extract_dets_from_outputs
from lib.helpers.decode_helper import decode_detections
class Tester(object):
def __init__(self, cfg, model, data_loader, logger):
self.... | [
"os.makedirs",
"os.path.join",
"lib.helpers.decode_helper.extract_dets_from_outputs",
"torch.cuda.is_available",
"torch.set_grad_enabled",
"lib.helpers.decode_helper.decode_detections",
"lib.helpers.save_helper.load_checkpoint"
] | [((923, 952), 'torch.set_grad_enabled', 'torch.set_grad_enabled', (['(False)'], {}), '(False)\n', (945, 952), False, 'import torch\n'), ((2504, 2536), 'os.path.join', 'os.path.join', (['output_dir', '"""data"""'], {}), "(output_dir, 'data')\n", (2516, 2536), False, 'import os\n'), ((2545, 2583), 'os.makedirs', 'os.make... |
from cymunk import Vec2d
from math import radians, sin, cos
class RobotMecanumControl:
def __init__(self, root, robot):
self.root = root
self.r = robot
self.ang_vel_max = radians(30)
self.wheel_vectors = []
w, h = self.r.siz
# needs to be smaller as the impulses ... | [
"cymunk.Vec2d",
"math.cos",
"math.sin",
"math.radians"
] | [((202, 213), 'math.radians', 'radians', (['(30)'], {}), '(30)\n', (209, 213), False, 'from math import radians, sin, cos\n'), ((1155, 1166), 'math.radians', 'radians', (['(45)'], {}), '(45)\n', (1162, 1166), False, 'from math import radians, sin, cos\n'), ((2259, 2275), 'cymunk.Vec2d', 'Vec2d', (['wheel_pos'], {}), '(... |
import serial #Serial imported for Serial communication
import time #Required to use delay functions
import pyautogui
ArduinoSerial = serial.Serial('COM11',9600) #Create Serial port object called arduinoSerialData
time.sleep(2) #wait for 2 seconds for the communication to get established
# a(2) | ... | [
"pyautogui.hotkey",
"serial.Serial",
"time.sleep",
"pyautogui.typewrite"
] | [((139, 167), 'serial.Serial', 'serial.Serial', (['"""COM11"""', '(9600)'], {}), "('COM11', 9600)\n", (152, 167), False, 'import serial\n'), ((220, 233), 'time.sleep', 'time.sleep', (['(2)'], {}), '(2)\n', (230, 233), False, 'import time\n'), ((573, 608), 'pyautogui.typewrite', 'pyautogui.typewrite', (["['space']", '(0... |
"""small modifications to samples table
Create Date: 2021-06-02 21:12:45.468074
"""
import enumtables # noqa: F401
import sqlalchemy as sa
from alembic import op
revision = "20210602_211244"
down_revision = "20210526_162747"
branch_labels = None
depends_on = None
def upgrade():
op.alter_column(
"sampl... | [
"sqlalchemy.sql.text",
"alembic.op.get_bind",
"sqlalchemy.BOOLEAN",
"sqlalchemy.text"
] | [((640, 749), 'sqlalchemy.sql.text', 'sa.sql.text', (['"""UPDATE aspen.samples SET organism =\'Severe acute respiratory syndrome coronavirus 2\'"""'], {}), '(\n "UPDATE aspen.samples SET organism =\'Severe acute respiratory syndrome coronavirus 2\'"\n )\n', (651, 749), True, 'import sqlalchemy as sa\n'), ((766, 7... |
import os
import shutil
import sys
import tarfile
import tempfile
import genomicsdb
import pandas as pd
def run_test():
genomicsdb.version()
gdb = genomicsdb.connect("ws", "callset_t0_1_2.json", "vid.json", "chr1_10MB.fasta.gz", ["DP"], 40)
try:
gdb.query_variant_calls()
... | [
"tempfile.TemporaryDirectory",
"os.path.exists",
"tarfile.open",
"sys.exit",
"os.makedirs",
"os.chdir",
"genomicsdb.connect",
"shutil.rmtree",
"pandas.DataFrame",
"genomicsdb.version"
] | [((1338, 1381), 'tarfile.open', 'tarfile.open', (['"""test/inputs/sanity.test.tgz"""'], {}), "('test/inputs/sanity.test.tgz')\n", (1350, 1381), False, 'import tarfile\n'), ((1407, 1424), 'os.chdir', 'os.chdir', (['tmp_dir'], {}), '(tmp_dir)\n', (1415, 1424), False, 'import os\n'), ((1438, 1460), 'shutil.rmtree', 'shuti... |
import torch as to
import torch.nn as nn
from abc import ABC, abstractmethod
from typing import Sequence, Callable, Tuple
import pyrado
from pyrado.policies.base_recurrent import RecurrentPolicy
from pyrado.policies.fnn import FNN
from pyrado.policies.initialization import init_param
from pyrado.policies.rnn import de... | [
"pyrado.policies.rnn.default_unpack_hidden",
"torch.stack",
"pyrado.policies.fnn.FNN",
"pyrado.ShapeErr",
"torch.nn.Linear",
"pyrado.policies.rnn.default_pack_hidden",
"pyrado.policies.initialization.init_param",
"torch.nn.GRU"
] | [((2654, 2852), 'pyrado.policies.fnn.FNN', 'FNN', ([], {'input_size': 'spec.obs_space.flat_dim', 'output_size': 'shared_hidden_sizes[-1]', 'hidden_sizes': 'shared_hidden_sizes', 'hidden_nonlin': 'shared_hidden_nonlin', 'dropout': 'shared_dropout', 'output_nonlin': 'None'}), '(input_size=spec.obs_space.flat_dim, output_... |
import pytest
from AutomationFramework.page_objects.qos.qos import QOS
from AutomationFramework.tests.base_test import BaseTest
class TestQOSScheduler(BaseTest):
test_case_file = 'qos_scheduler.yml'
@pytest.mark.parametrize('create_page_object_arg', [{'test_case_file': test_case_file,
... | [
"pytest.mark.parametrize"
] | [((211, 379), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""create_page_object_arg"""', "[{'test_case_file': test_case_file, 'test_case_name':\n 'qos_scheduler_policy_name', 'page_object_class': QOS}]"], {}), "('create_page_object_arg', [{'test_case_file':\n test_case_file, 'test_case_name': 'qos_sc... |
# Copyright 2012 The Chromium OS Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""This module provides utility functions for string processing."""
from collections import namedtuple
import logging
def DecodeUTF8(data):
"""Deco... | [
"collections.namedtuple",
"logging.warning"
] | [((699, 746), 'collections.namedtuple', 'namedtuple', (['"""Node"""', "['line', 'childs', 'level']"], {}), "('Node', ['line', 'childs', 'level'])\n", (709, 746), False, 'from collections import namedtuple\n'), ((2198, 2260), 'logging.warning', 'logging.warning', (['"""Can not extract key, value pair in %s"""', 'line'],... |
from pyontutils import sheets
from pyontutils.sheets import Sheet
from pyontutils.namespaces import ilxtr
from neurondm.sheets import CutsV1, Row as RowBase
from neurondm.core import Config, NeuronEBM
from neurondm.phenotype_namespaces import Species
class NeuronNerves(NeuronEBM):
owlClass = ilxtr.NeuronNerves
... | [
"neurondm.core.Config"
] | [((959, 975), 'neurondm.core.Config', 'Config', (['"""nerves"""'], {}), "('nerves')\n", (965, 975), False, 'from neurondm.core import Config, NeuronEBM\n')] |
from __future__ import annotations
from typing import TYPE_CHECKING
from openhab_creator import _
from openhab_creator.models.configuration import Configuration
from openhab_creator.models.configuration.equipment.types.pollencount import \
PollenType
from openhab_creator.models.sitemap import Page, Sitemap, Text,... | [
"openhab_creator.models.sitemap.Page",
"openhab_creator._",
"openhab_creator.output.sitemap.SitemapCreatorPipeline"
] | [((605, 639), 'openhab_creator.output.sitemap.SitemapCreatorPipeline', 'SitemapCreatorPipeline', ([], {'mainpage': '(6)'}), '(mainpage=6)\n', (627, 639), False, 'from openhab_creator.output.sitemap import SitemapCreatorPipeline\n'), ((943, 967), 'openhab_creator.models.sitemap.Page', 'Page', (['"""pollenCountToday"""']... |
"""
Test smd0 and eventbuilder for handling step dgrams.
See https://docs.google.com/spreadsheets/d/1VlVCwEVGahab3omAFJLaF8DJWFcz-faI9Q9aHa7QTUw/edit?usp=sharing for test setup.
"""
import os, time, glob, sys
from psana.smdreader import SmdReader
from psana.dgram import Dgram
from setup_input_files import setup_input_... | [
"psana.DataSource",
"pathlib.Path",
"psana.dgram.Dgram",
"os.close",
"psana.smdreader.SmdReader",
"os.open",
"os.path.join",
"os.environ.get",
"numpy.asarray",
"numpy.max",
"numpy.zeros",
"setup_input_files.setup_input_files",
"time.time"
] | [((481, 516), 'os.environ.get', 'os.environ.get', (['"""TEST_XTC_DIR"""', '"""."""'], {}), "('TEST_XTC_DIR', '.')\n", (495, 516), False, 'import os, time, glob, sys\n'), ((527, 566), 'os.path.join', 'os.path.join', (['test_xtc_dir', '""".tmp_smd0"""'], {}), "(test_xtc_dir, '.tmp_smd0')\n", (539, 566), False, 'import os... |
from random import randrange
from datetime import datetime
from bson import ObjectId
import json, operator
Key_Name = "name"
Key_ID = "_id"
Key_Location = "location"
Key_Description = "description"
Key_Latitude = "latitude"
Key_Longitude = "longitude"
Key_Times = "times"
Key_StartTimeStr = "startTimeString"
Key_EndTim... | [
"random.randrange",
"datetime.datetime.strptime",
"json.dumps",
"operator.itemgetter",
"bson.ObjectId"
] | [((4764, 4791), 'json.dumps', 'json.dumps', (['self.dictionary'], {}), '(self.dictionary)\n', (4774, 4791), False, 'import json, operator\n'), ((5779, 5818), 'datetime.datetime.strptime', 'datetime.strptime', (['startTimeStr', 'parser'], {}), '(startTimeStr, parser)\n', (5796, 5818), False, 'from datetime import dateti... |
#!/usr/bin/env python3
# Copyright: 2017, CCX Technologies
"""Test the method wrapper and decorators."""
import unittest
import typing
import asyncio
import random
import string
import time
from multiprocessing import Process
import adbus
service_name = 'adbus.test'
object_path = '/adbus/test/Tests1'
object_interfa... | [
"adbus.client.get",
"random.choice",
"adbus.client.set_",
"test_server.Test.setUpClass",
"adbus.client.Listen",
"adbus.client.call",
"multiprocessing.Process",
"time.sleep",
"adbus.Service",
"adbus.client.get_all",
"test_server.Test",
"asyncio.sleep",
"unittest.main",
"unittest.skip",
"a... | [((5522, 5569), 'unittest.skip', 'unittest.skip', (['"""long test used for development"""'], {}), "('long test used for development')\n", (5535, 5569), False, 'import unittest\n'), ((8682, 8697), 'unittest.main', 'unittest.main', ([], {}), '()\n', (8695, 8697), False, 'import unittest\n'), ((644, 671), 'random.randint'... |
import random
import string
from generator.type import RandomRandomizedType
class Parameter:
def __init__(self, datatype, name, final=False):
self.datatype = datatype
self.name = name
self.final = final
def __str__(self):
return "{final}{datatype} {name}".format(
... | [
"generator.type.RandomRandomizedType",
"random.choice",
"random.getrandbits"
] | [((514, 536), 'generator.type.RandomRandomizedType', 'RandomRandomizedType', ([], {}), '()\n', (534, 536), False, 'from generator.type import RandomRandomizedType\n'), ((823, 845), 'generator.type.RandomRandomizedType', 'RandomRandomizedType', ([], {}), '()\n', (843, 845), False, 'from generator.type import RandomRando... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# (c) The University of Strathclude 2019-2020
# Author: <NAME>
#
# Contact:
# <EMAIL>
#
# <NAME>,
# Strathclyde Institute of Pharmaceutical and Biomedical Sciences
# The University of Strathclyde
# 161 Cathedral Street
# Glasgow
# G4 0RE
# Scotland,
# UK
#
# The MIT Licens... | [
"pyani.download.DLStatus",
"pathlib.Path",
"subprocess.run",
"pyani.download.ASMIDs",
"pytest.fixture",
"pytest.skip"
] | [((5264, 5292), 'pytest.fixture', 'pytest.fixture', ([], {'autouse': '(True)'}), '(autouse=True)\n', (5278, 5292), False, 'import pytest\n'), ((2102, 2116), 'pathlib.Path', 'Path', (['__file__'], {}), '(__file__)\n', (2106, 2116), False, 'from pathlib import Path\n'), ((2400, 2497), 'subprocess.run', 'subprocess.run', ... |
# -*- coding: utf-8 -*-
from contextlib import closing
from future.moves.urllib import request
import json
import codecs
import sqlite3
from . import util
class BitcoindConnection(object):
def __init__(self, url, username, password):
super(BitcoindConnection, self).__init__()
self.id = 'bitcoin_... | [
"codecs.getreader",
"sqlite3.Connection",
"json.dumps",
"future.moves.urllib.request.urlopen",
"future.moves.urllib.request.Request",
"future.moves.urllib.request.HTTPPasswordMgrWithDefaultRealm",
"future.moves.urllib.request.HTTPHandler",
"future.moves.urllib.request.HTTPBasicAuthHandler"
] | [((429, 470), 'future.moves.urllib.request.HTTPPasswordMgrWithDefaultRealm', 'request.HTTPPasswordMgrWithDefaultRealm', ([], {}), '()\n', (468, 470), False, 'from future.moves.urllib import request\n'), ((722, 747), 'future.moves.urllib.request.Request', 'request.Request', (['self.url'], {}), '(self.url)\n', (737, 747)... |
# -*- coding: utf-8 -*-
# Generated by the protocol buffer compiler. DO NOT EDIT!
# source: persistent_volume_claim.proto
import sys
_b=sys.version_info[0]<3 and (lambda x:x) or (lambda x:x.encode('latin1'))
from google.protobuf import descriptor as _descriptor
from google.protobuf import message as _message
from goo... | [
"google.protobuf.reflection.GeneratedProtocolMessageType",
"google.protobuf.symbol_database.Default",
"google.protobuf.descriptor.FieldDescriptor"
] | [((477, 503), 'google.protobuf.symbol_database.Default', '_symbol_database.Default', ([], {}), '()\n', (501, 503), True, 'from google.protobuf import symbol_database as _symbol_database\n'), ((6722, 6902), 'google.protobuf.reflection.GeneratedProtocolMessageType', '_reflection.GeneratedProtocolMessageType', (['"""Persi... |
# -*- coding = utf-8 -*-
# @Time:2021/3/713:29
# @Author:Linyu
# @Software:PyCharm
import pymysql
from pymysql import *
from flask_wtf import FlaskForm
from wtforms import StringField,SubmitField
from wtforms.validators import DataRequired
import random
from matplotlib import pyplot as plt
from wordcloud import WordCl... | [
"random.randint",
"wtforms.validators.DataRequired",
"wtforms.SubmitField"
] | [((4314, 4333), 'wtforms.SubmitField', 'SubmitField', (['"""随心之旅"""'], {}), "('随心之旅')\n", (4325, 4333), False, 'from wtforms import StringField, SubmitField\n'), ((6260, 6282), 'random.randint', 'random.randint', (['(1)', '(862)'], {}), '(1, 862)\n', (6274, 6282), False, 'import random\n'), ((5648, 5675), 'random.randi... |
"""Aggregation function for CLI specified options and config file options.
This holds the logic that uses the collected and merged config files and
applies the user-specified command-line configuration on top of it.
"""
import argparse
import logging
from typing import List
from typing import Tuple
from flake8.option... | [
"logging.getLogger",
"flake8.options.config.MergedConfigParser"
] | [((392, 419), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (409, 419), False, 'import logging\n'), ((1372, 1450), 'flake8.options.config.MergedConfigParser', 'config.MergedConfigParser', ([], {'option_manager': 'manager', 'config_finder': 'config_finder'}), '(option_manager=manager, con... |
import mysql.connector as sql
conn=sql.connect(host='localhost',user='root',passwd='<PASSWORD>',database='electronic_shop')
cur=conn.cursor()
if conn.is_connected:
print(' ELECTRONIC SHOP SYSTEM')
print(' 1.Admin')
print... | [
"mysql.connector.connect"
] | [((35, 131), 'mysql.connector.connect', 'sql.connect', ([], {'host': '"""localhost"""', 'user': '"""root"""', 'passwd': '"""<PASSWORD>"""', 'database': '"""electronic_shop"""'}), "(host='localhost', user='root', passwd='<PASSWORD>', database=\n 'electronic_shop')\n", (46, 131), True, 'import mysql.connector as sql\n... |
from collections import defaultdict, deque
class Solution:
def findOrder(self, numCourses, prerequisites):
"""
:type numCourses: int
:type prerequisites: List[List[int]]
:rtype: List[int]
"""
adj_list = defaultdict(list)
indegree = {}
for dest, src ... | [
"collections.defaultdict"
] | [((258, 275), 'collections.defaultdict', 'defaultdict', (['list'], {}), '(list)\n', (269, 275), False, 'from collections import defaultdict, deque\n')] |
from flask_restplus import Api
authorizations = {
'apikey': {
'type': 'apiKey',
'in': 'header',
'name': 'X-Token'
}
}
api = Api(version='1.0', title='PMS API', description='PMS API', authorizations=authorizations)
api.namespaces.pop(0)
ns = api.namespace('v1', description='这是自定义名称空间')
... | [
"flask_restplus.Api"
] | [((158, 252), 'flask_restplus.Api', 'Api', ([], {'version': '"""1.0"""', 'title': '"""PMS API"""', 'description': '"""PMS API"""', 'authorizations': 'authorizations'}), "(version='1.0', title='PMS API', description='PMS API', authorizations=\n authorizations)\n", (161, 252), False, 'from flask_restplus import Api\n'... |
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from keyname import keyname as kn
from slugify import slugify
import subprocess
import sys
from iterpop import iterpop as ip
def facet(df):
return sns.FacetGrid(
df,
col='Overloaded',
row='Mesh',
margin_titles... | [
"subprocess.check_output",
"keyname.keyname.unpack",
"pandas.read_csv",
"seaborn.color_palette",
"matplotlib.pyplot.clf",
"slugify.slugify",
"iterpop.iterpop.pophomogeneous",
"seaborn.FacetGrid"
] | [((1553, 1574), 'pandas.read_csv', 'pd.read_csv', (['filename'], {}), '(filename)\n', (1564, 1574), True, 'import pandas as pd\n'), ((226, 313), 'seaborn.FacetGrid', 'sns.FacetGrid', (['df'], {'col': '"""Overloaded"""', 'row': '"""Mesh"""', 'margin_titles': '"""true"""', 'sharex': '(False)'}), "(df, col='Overloaded', r... |
import copy
import numpy as np
import math
class Transformation:
def __init__(self, is_array = False, num_instances = 1):
# self.tx = 0.0
# self.ty = 0.0
# self.tz = 0.0
# self.rx = 0.0
# self.ry = 0.0
# self.rz = 0.0
# self.sx = 1.0
# self.sy = 1.0
... | [
"numpy.eye",
"math.radians",
"numpy.array",
"numpy.matmul",
"copy.deepcopy"
] | [((373, 382), 'numpy.eye', 'np.eye', (['(4)'], {}), '(4)\n', (379, 382), True, 'import numpy as np\n'), ((640, 712), 'numpy.array', 'np.array', (['[[1, 0, 0, tx_], [0, 1, 0, ty_], [0, 0, 1, tz_], [0, 0, 0, 1]]'], {}), '([[1, 0, 0, tx_], [0, 1, 0, ty_], [0, 0, 1, tz_], [0, 0, 0, 1]])\n', (648, 712), True, 'import numpy ... |
import numpy as np
import xarray as xr
import xgcm
from . import constants
# none of the connecitons are "reversed" in the xgcm parlance
FV3_FACE_CONNECTIONS = {
"tile": {
0: {
"x": ((4, "y", False), (1, "x", False)),
"y": ((5, "y", False), (2, "x", False)),
},
1: {
... | [
"xgcm.Grid"
] | [((2870, 2937), 'xgcm.Grid', 'xgcm.Grid', (['ds'], {'coords': 'coords', 'face_connections': 'FV3_FACE_CONNECTIONS'}), '(ds, coords=coords, face_connections=FV3_FACE_CONNECTIONS)\n', (2879, 2937), False, 'import xgcm\n')] |
from infi.clickhouse_orm import migrations
from ee.clickhouse.sql.events import EVENTS_WITH_PROPS_TABLE_SQL
operations = [
migrations.RunSQL(EVENTS_WITH_PROPS_TABLE_SQL),
]
| [
"infi.clickhouse_orm.migrations.RunSQL"
] | [((129, 175), 'infi.clickhouse_orm.migrations.RunSQL', 'migrations.RunSQL', (['EVENTS_WITH_PROPS_TABLE_SQL'], {}), '(EVENTS_WITH_PROPS_TABLE_SQL)\n', (146, 175), False, 'from infi.clickhouse_orm import migrations\n')] |
#!/usr/bin/env python3
import sys, os
from os.path import join
import subprocess
from datetime import datetime
import glob
from pprint import pprint
HERE = os.path.dirname(os.path.realpath(__file__))
def Build(so_result_location, log_file_name, conan_docker_name):
os.chdir(HERE)
slash = join(".", ".").replace('.... | [
"subprocess.run",
"os.path.join",
"os.getcwd",
"os.path.realpath",
"os.chdir",
"datetime.datetime.now",
"pprint.pprint"
] | [((174, 200), 'os.path.realpath', 'os.path.realpath', (['__file__'], {}), '(__file__)\n', (190, 200), False, 'import sys, os\n'), ((270, 284), 'os.chdir', 'os.chdir', (['HERE'], {}), '(HERE)\n', (278, 284), False, 'import sys, os\n'), ((687, 708), 'pprint.pprint', 'pprint', (['docker_script'], {}), '(docker_script)\n',... |
from collections.abc import Sequence
import operator
import urllib.parse
import requests
import cachetools
BASE_URL = "http://archive.org/"
def _session(base_url, retries):
# TODO: backoff?
session = requests.Session()
adapter = requests.adapters.HTTPAdapter(max_retries=retries)
session.mount(base... | [
"logging.basicConfig",
"operator.attrgetter",
"requests.Session",
"argparse.ArgumentParser",
"requests.adapters.HTTPAdapter",
"json.dump",
"sys.stdout.write"
] | [((214, 232), 'requests.Session', 'requests.Session', ([], {}), '()\n', (230, 232), False, 'import requests\n'), ((247, 297), 'requests.adapters.HTTPAdapter', 'requests.adapters.HTTPAdapter', ([], {'max_retries': 'retries'}), '(max_retries=retries)\n', (276, 297), False, 'import requests\n'), ((3092, 3117), 'argparse.A... |
# Copyright (c) 2018, IBM.
#
# This source code is licensed under the Apache License, Version 2.0 found in
# the LICENSE.txt file in the root directory of this source tree.
import json
from qiskit import __version__
from IBMQuantumExperience import IBMQuantumExperience
from packaging import version
import argparse
imp... | [
"qiskit.IBMQ.get_backend",
"qiskit.wrapper.load_qasm_file",
"qiskit.Aer.backends",
"qiskit.QuantumCircuit.from_qasm_file",
"qiskit.IBMQ.backends",
"qiskit.IBMQ.enable_account",
"packaging.version.parse",
"qiskit.Aer.get_backend"
] | [((441, 467), 'packaging.version.parse', 'version.parse', (['__version__'], {}), '(__version__)\n', (454, 467), False, 'from packaging import version\n'), ((471, 491), 'packaging.version.parse', 'version.parse', (['"""0.6"""'], {}), "('0.6')\n", (484, 491), False, 'from packaging import version\n'), ((1553, 1577), 'qis... |
# encoding: utf-8
from __future__ import unicode_literals
import mock
import os
import django
from django.test import TestCase
from unittest import skipIf
from data_importer.importers.generic import GenericImporter
from data_importer.readers.xls_reader import XLSReader
from data_importer.readers.xlsx_reader import XLSX... | [
"unittest.skipIf",
"os.path.join",
"os.path.dirname",
"data_importer.importers.generic.GenericImporter",
"mock.MagicMock"
] | [((588, 613), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (603, 613), False, 'import os\n'), ((1850, 1922), 'unittest.skipIf', 'skipIf', (['(django.VERSION < (1, 4))', '"""not supported in this library version"""'], {}), "(django.VERSION < (1, 4), 'not supported in this library version')\n... |
"""Extend length of Contact.track_number field
Revision ID: fddfa70f811b
Revises: eb8a93498c02
Create Date: 2021-12-03 16:49:33.809704+00:00
"""
import sqlalchemy as sa
from alembic import op
# revision identifiers, used by Alembic.
revision = "<KEY>"
down_revision = "eb8a93498c02"
branch_labels = None
depends_on = ... | [
"sqlalchemy.VARCHAR",
"sqlalchemy.String",
"alembic.op.batch_alter_table"
] | [((417, 462), 'alembic.op.batch_alter_table', 'op.batch_alter_table', (['"""Contacts"""'], {'schema': 'None'}), "('Contacts', schema=None)\n", (437, 462), False, 'from alembic import op\n'), ((799, 844), 'alembic.op.batch_alter_table', 'op.batch_alter_table', (['"""Contacts"""'], {'schema': 'None'}), "('Contacts', sche... |
import requests
import json
import time
import os
import urllib
import logging
class RadiamAPI(object):
def __init__(self, **kwargs):
self.logger = None
self.osf = False
self.baseurl = "http://radiamapi:8000" # Docker API container
self.headers = {
"Content-Type": "appl... | [
"json.loads",
"requests.post",
"json.dumps",
"urllib.parse.quote",
"requests.get",
"requests.delete"
] | [((2882, 2903), 'json.loads', 'json.loads', (['resp.text'], {}), '(resp.text)\n', (2892, 2903), False, 'import json\n'), ((3203, 3241), 'requests.get', 'requests.get', (['url'], {'headers': 'get_headers'}), '(url, headers=get_headers)\n', (3215, 3241), False, 'import requests\n'), ((3362, 3383), 'json.loads', 'json.loa... |
# Generated by Django 2.1.2 on 2018-12-08 21:17
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
import django.db.models.expressions
class Migration(migrations.Migration):
initial = True
dependencies = [
migrations.swappable_dependency(setti... | [
"django.db.models.TextField",
"django.db.models.ForeignKey",
"django.db.models.AutoField",
"django.db.models.DateTimeField",
"django.db.migrations.swappable_dependency",
"django.db.models.CharField"
] | [((283, 340), 'django.db.migrations.swappable_dependency', 'migrations.swappable_dependency', (['settings.AUTH_USER_MODEL'], {}), '(settings.AUTH_USER_MODEL)\n', (314, 340), False, 'from django.db import migrations, models\n'), ((1769, 1865), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'on_delete': 'djang... |
import rpy2.rinterface as ri
ri.initr()
def test_init_from_r():
pairlist = ri.baseenv.find('pairlist')
pl = pairlist(a=ri.StrSexpVector(['1', ]),
b=ri.StrSexpVector(['3', ]))
assert pl.typeof == ri.RTYPES.LISTSXP
def test_names():
pairlist = ri.baseenv.find('pairlist')
pl = p... | [
"rpy2.rinterface.StrSexpVector",
"rpy2.rinterface.initr",
"rpy2.rinterface.baseenv.find"
] | [((31, 41), 'rpy2.rinterface.initr', 'ri.initr', ([], {}), '()\n', (39, 41), True, 'import rpy2.rinterface as ri\n'), ((83, 110), 'rpy2.rinterface.baseenv.find', 'ri.baseenv.find', (['"""pairlist"""'], {}), "('pairlist')\n", (98, 110), True, 'import rpy2.rinterface as ri\n'), ((282, 309), 'rpy2.rinterface.baseenv.find'... |
from jukeboxcore import ostool
def test_detect_sys():
""" Detect Platform
:returns: None
:rtype: None
:raises: None
"""
ostool.detect_sys()
def test_get_interface():
""" Get PlatformInterface for your Platform
:returns: None
:rtype: None
:raises: None
"""
ostool.get... | [
"jukeboxcore.ostool.get_interface",
"jukeboxcore.ostool.detect_sys"
] | [((147, 166), 'jukeboxcore.ostool.detect_sys', 'ostool.detect_sys', ([], {}), '()\n', (164, 166), False, 'from jukeboxcore import ostool\n'), ((310, 332), 'jukeboxcore.ostool.get_interface', 'ostool.get_interface', ([], {}), '()\n', (330, 332), False, 'from jukeboxcore import ostool\n'), ((470, 492), 'jukeboxcore.ostoo... |
"""Load mdx_dict_c2e.
mdx_e2c = joblib.load("./mdx_dict_e2c.lzma")
mdx_c2e = joblib.load("./mdx_dict_e2c.lzma")
"""
from pathlib import Path
import joblib
c_dir = Path(__file__).parent
# lazy load in __init__.py like this?
# mdx_e2c = importlib.import_module("tinybee.mdx_e2c")
# mdx_e2c = mdx_e2c.mdx_e2c
# mdx_c2e ... | [
"pathlib.Path",
"joblib.load"
] | [((409, 449), 'joblib.load', 'joblib.load', (["(c_dir / 'mdx_dict_c2e.lzma')"], {}), "(c_dir / 'mdx_dict_c2e.lzma')\n", (420, 449), False, 'import joblib\n'), ((165, 179), 'pathlib.Path', 'Path', (['__file__'], {}), '(__file__)\n', (169, 179), False, 'from pathlib import Path\n')] |
import math
import pygame as pg
from const import MOVE_SPEED, CARD_SIZE
class CardSprite(pg.sprite.Sprite):
def __init__(self, pos_x, pos_y, picture_path):
super().__init__()
self.image = pg.image.load(picture_path)
self.image = pg.transform.scale(self.image, CARD_SIZE)
self.rect... | [
"math.pow",
"math.cos",
"math.atan2",
"pygame.image.load",
"math.sin",
"pygame.transform.scale"
] | [((212, 239), 'pygame.image.load', 'pg.image.load', (['picture_path'], {}), '(picture_path)\n', (225, 239), True, 'import pygame as pg\n'), ((261, 302), 'pygame.transform.scale', 'pg.transform.scale', (['self.image', 'CARD_SIZE'], {}), '(self.image, CARD_SIZE)\n', (279, 302), True, 'import pygame as pg\n'), ((853, 947)... |
# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import... | [
"pulumi.getter",
"pulumi.log.warn",
"pulumi.set",
"pulumi.get"
] | [((6361, 6402), 'pulumi.getter', 'pulumi.getter', ([], {'name': '"""authenticateCognito"""'}), "(name='authenticateCognito')\n", (6374, 6402), False, 'import pulumi\n'), ((6747, 6785), 'pulumi.getter', 'pulumi.getter', ([], {'name': '"""authenticateOidc"""'}), "(name='authenticateOidc')\n", (6760, 6785), False, 'import... |
#
# Copyright 2005 Free Software Foundation, Inc.
#
# This file is part of GNU Radio
#
# GNU Radio 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, or (at your option)
# any later version.
#
#... | [
"os.read"
] | [((976, 1008), 'os.read', 'os.read', (['file_descriptor', 'nbytes'], {}), '(file_descriptor, nbytes)\n', (983, 1008), False, 'import os\n')] |
from copy import deepcopy
import nouns
import results
from IPython.core.display import HTML, display
x = nouns.get_x()
t = nouns.Templates(folders=[nouns.BUILTIN_TEMPLATES_FOLDER], preprocess=x)
def get_css():
css = results.resource_text("css/custom.css")
return f"<style>{css}</style>"
def load_css(css):
... | [
"results.resource_text",
"IPython.core.display.HTML",
"copy.deepcopy",
"nouns.get_x",
"nouns.Templates"
] | [((107, 120), 'nouns.get_x', 'nouns.get_x', ([], {}), '()\n', (118, 120), False, 'import nouns\n'), ((125, 196), 'nouns.Templates', 'nouns.Templates', ([], {'folders': '[nouns.BUILTIN_TEMPLATES_FOLDER]', 'preprocess': 'x'}), '(folders=[nouns.BUILTIN_TEMPLATES_FOLDER], preprocess=x)\n', (140, 196), False, 'import nouns\... |
#!/usr/bin/env python3
"""Script to train a model through refined labels on ImageNet's train set."""
import argparse
import logging
import pprint
import os
import sys
import time
import torch
from torch import nn
from models import model_factory
import opts
import test
import utils
import mul_cifar100
import dateti... | [
"opts.add_general_flags",
"opts.add_model_flags",
"torch.optim.SGD",
"utils.topk_accuracy",
"argparse.ArgumentParser",
"opts.add_training_flags",
"opts.add_label_refinery_flags",
"mul_cifar100.mul_CIFAR100DataLoader",
"utils.is_model_cuda",
"utils.general_setup",
"datetime.datetime.now",
"os.p... | [((341, 364), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (362, 364), False, 'import datetime\n'), ((518, 582), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '__doc__', 'allow_abbrev': '(False)'}), '(description=__doc__, allow_abbrev=False)\n', (541, 582), False, 'im... |
import logging
import unittest
import numpy as np
from astropy import units as u
from flarestack.cosmo import get_rate
from flarestack.cosmo.rates import source_maps
from flarestack.cosmo.rates.tde_rates import tde_evolutions, local_tde_rates
from flarestack.cosmo.rates.sfr_rates import sfr_evolutions, local_sfr_rates
... | [
"flarestack.cosmo.rates.sfr_rates.sfr_evolutions.keys",
"flarestack.cosmo.rates.ccsn_rates.sn_subclass_rates.items",
"flarestack.cosmo.rates.grb_rates.grb_evolutions.keys",
"flarestack.cosmo.rates.frb_rates.local_frb_rates.keys",
"flarestack.cosmo.rates.ccsn_rates.kcc_rates.keys",
"flarestack.cosmo.get_ra... | [((606, 630), 'numpy.linspace', 'np.linspace', (['(0.0)', '(8.0)', '(5)'], {}), '(0.0, 8.0, 5)\n', (617, 630), True, 'import numpy as np\n'), ((3597, 3612), 'unittest.main', 'unittest.main', ([], {}), '()\n', (3610, 3612), False, 'import unittest\n'), ((748, 797), 'logging.info', 'logging.info', (['"""Testing get_rates... |
import matplotlib.pyplot as plt
import numpy as np
from scipy.integrate import quad
def smooth_product(u, v, domain=(0, 1)):
approx, _ = quad(lambda x: u(x)*v(x), *domain) # Discard error
return approx
def least_squares(func, basis, inner, **kwargs):
# Take the inner product of each pair of basis
l... | [
"numpy.linalg.solve",
"numpy.exp",
"matplotlib.pyplot.close",
"numpy.linspace",
"numpy.loadtxt",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.show"
] | [((593, 618), 'numpy.linalg.solve', 'np.linalg.solve', (['lhs', 'rhs'], {}), '(lhs, rhs)\n', (608, 618), True, 'import numpy as np\n'), ((923, 940), 'numpy.linspace', 'np.linspace', (['(0)', '(1)'], {}), '(0, 1)\n', (934, 940), True, 'import numpy as np\n'), ((1005, 1019), 'matplotlib.pyplot.subplots', 'plt.subplots', ... |
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
import discord
import os
from typing import Dict, List, Set, Tuple
from cache import PssCache
import emojis
import pss_assert
import pss_entity as entity
import pss_core as core
import pss_lookups as lookups
import settings
import utility as util
# ---------- Constants ... | [
"pss_assert.valid_entity_name",
"pss_entity.EntityDesignsRetriever",
"pss_assert.parameter_is_valid_integer",
"pss_lookups.EQUIPMENT_MASK_LOOKUP.keys",
"pss_lookups.COLLECTION_PERK_LOOKUP.get",
"cache.PssCache",
"os.system",
"pss_lookups.SPECIAL_ABILITIES_LOOKUP.keys"
] | [((24400, 24567), 'pss_entity.EntityDesignsRetriever', 'entity.EntityDesignsRetriever', (['CHARACTER_DESIGN_BASE_PATH', 'CHARACTER_DESIGN_KEY_NAME', 'CHARACTER_DESIGN_DESCRIPTION_PROPERTY_NAME'], {'cache_name': '"""CharacterDesigns"""'}), "(CHARACTER_DESIGN_BASE_PATH,\n CHARACTER_DESIGN_KEY_NAME, CHARACTER_DESIGN_DE... |
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not... | [
"proton.utils.BlockingConnection",
"proton.Url",
"os.path.join",
"re.match",
"os.getcwd",
"system_test.main_module",
"system_test.Qdrouterd.Config",
"proton.SASL.extended",
"proton.SSLDomain",
"re.findall",
"re.search"
] | [((27673, 27705), 'proton.SSLDomain', 'SSLDomain', (['SSLDomain.MODE_CLIENT'], {}), '(SSLDomain.MODE_CLIENT)\n', (27682, 27705), False, 'from proton import Url, SSLDomain, SSLUnavailable, SASL\n'), ((34467, 34499), 'proton.SSLDomain', 'SSLDomain', (['SSLDomain.MODE_CLIENT'], {}), '(SSLDomain.MODE_CLIENT)\n', (34476, 34... |
from logging import Logger
from os.path import basename
from typing import TYPE_CHECKING
from urllib.parse import urlparse
import boto3
from jsonschema import ValidationError, validate
from linz_logger import get_log
from ..aws_message_attributes import (
DATA_TYPE_STRING,
MESSAGE_ATTRIBUTE_TYPE_DATASET,
... | [
"urllib.parse.urlparse",
"mypy_boto3_sqs.type_defs.MessageAttributeValueTypeDef",
"boto3.resource",
"jsonschema.validate",
"linz_logger.get_log"
] | [((1231, 1240), 'linz_logger.get_log', 'get_log', ([], {}), '()\n', (1238, 1240), False, 'from linz_logger import get_log\n'), ((1276, 1297), 'boto3.resource', 'boto3.resource', (['"""sqs"""'], {}), "('sqs')\n", (1290, 1297), False, 'import boto3\n'), ((1518, 1817), 'jsonschema.validate', 'validate', (['event', "{'type... |
from logic import Logic
import hints
from gui import open_file
class Harness:
FILE_OPEN_OPTIONS = dict(defaultextension='.txt',
filetypes=[('text files', '*.txt')],
title='Wybierz plik z listą słówek')
def __init__(self):
self._logic = Logic(... | [
"logic.Logic",
"gui.open_file"
] | [((314, 321), 'logic.Logic', 'Logic', ([], {}), '()\n', (319, 321), False, 'from logic import Logic\n'), ((439, 450), 'gui.open_file', 'open_file', ([], {}), '()\n', (448, 450), False, 'from gui import open_file\n')] |
import numpy as np
import matplotlib.pyplot as plt
import itertools
import threading
import imp
"""This module is for developing the machinery required to make neural nets and analyse local and global codes
This module does stuff.
"""
__version__ = '0.1'
__author__ = '<NAME>'
__date__ = 'Jan 2017'
class ThreadedR... | [
"numpy.random.rand",
"matplotlib.pyplot.ylabel",
"numpy.log",
"imp.lock_held",
"numpy.linalg.norm",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"numpy.ndenumerate",
"matplotlib.pyplot.axhline",
"imp.acquire_lock",
"matplotlib.pyplot.Rectangle",
"matplotlib.pyplot.NullLocator",
"num... | [((4652, 4675), 'numpy.ones', 'np.ones', (['out[z].T.shape'], {}), '(out[z].T.shape)\n', (4659, 4675), True, 'import numpy as np\n'), ((5523, 5536), 'matplotlib.pyplot.figure', 'plt.figure', (['(1)'], {}), '(1)\n', (5533, 5536), True, 'import matplotlib.pyplot as plt\n'), ((6121, 6142), 'matplotlib.pyplot.ylabel', 'plt... |