code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
import json
import configparser
from utils import ui
_logger = ui.get_logger()
class Accounts:
def __init__(self, session, base_url):
self.config = configparser.ConfigParser()
self.config.read('etrade/config.ini')
self.session = session
self.base_url = base_url
self.accou... | [
"utils.ui.get_logger",
"configparser.ConfigParser",
"json.loads",
"json.dumps"
] | [((65, 80), 'utils.ui.get_logger', 'ui.get_logger', ([], {}), '()\n', (78, 80), False, 'from utils import ui\n'), ((164, 191), 'configparser.ConfigParser', 'configparser.ConfigParser', ([], {}), '()\n', (189, 191), False, 'import configparser\n'), ((670, 712), 'json.dumps', 'json.dumps', (['data'], {'indent': '(2)', 's... |
#-----------------------------------------------------------------------------
# Copyright (c) 2013-2020, PyInstaller Development Team.
#
# Distributed under the terms of the GNU General Public License (version 2
# or later) with exception for distributing the bootloader.
#
# The full license is in the file COPYING.txt... | [
"wx.lib.pubsub.pub.subscribe",
"wx.lib.pubsub.pub.sendMessage"
] | [((3207, 3256), 'wx.lib.pubsub.pub.subscribe', 'Publisher.subscribe', (['on_message', '"""topic.subtopic"""'], {}), "(on_message, 'topic.subtopic')\n", (3226, 3256), True, 'from wx.lib.pubsub import pub as Publisher\n'), ((3261, 3305), 'wx.lib.pubsub.pub.sendMessage', 'Publisher.sendMessage', (['"""topic.subtopic"""', ... |
import argparse
import datetime
import gym
import numpy as np
import itertools
import torch
from .sac import SAC
from torch.utils.tensorboard import SummaryWriter
from .replay_memory import ReplayMemory
import random
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
def create_arguments(arg_dict... | [
"torch.cuda.is_available",
"argparse.ArgumentParser",
"itertools.count",
"torch.from_numpy"
] | [((336, 405), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""PyTorch Soft Actor-Critic Args"""'}), "(description='PyTorch Soft Actor-Critic Args')\n", (359, 405), False, 'import argparse\n'), ((252, 277), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {}), '()\n', (275, 277),... |
"""
Copyright 2017-2019 Government of Canada - Public Services and Procurement Canada - buyandsell.gc.ca
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
... | [
"sys.path.append",
"von_anchor.wallet.Wallet",
"von_anchor.nodepool.NodePoolManager",
"logging.basicConfig",
"von_anchor.util.ok_role",
"von_anchor.TrusteeAnchor",
"os.path.realpath",
"von_anchor.indytween.Role.get",
"von_anchor.NominalAnchor",
"von_anchor.frill.inis2dict",
"von_anchor.error.Ext... | [((887, 918), 'sys.path.append', 'sys_path.append', (['DIR_VON_ANCHOR'], {}), '(DIR_VON_ANCHOR)\n', (902, 918), True, 'from sys import exit as sys_exit, path as sys_path\n'), ((3583, 3602), 'von_anchor.frill.inis2dict', 'inis2dict', (['ini_path'], {}), '(ini_path)\n', (3592, 3602), False, 'from von_anchor.frill import ... |
# -*- coding: utf-8 -*-
# NOTE! THis file will change frequently as features are developed and used.
# Examples of developed frameworks and uses will be spun off into separate files as needed.
# Current use: developing menus for menu-based games (dating games etc.)
#
import sys
sys.path.append('../')
import pyglet
impo... | [
"sys.path.append",
"boop.drawables.Label",
"pyglet.app.run",
"random.randint",
"boop.scene.Scene.__init__",
"boop.batchdraw.BatchDraw.on_draw",
"pyglet.graphics.Batch",
"boop.scene.SceneManager",
"boop.drawtools.make_crosshair",
"pyglet.font.load",
"boop.drawable.Drawable.__init__",
"boop.draw... | [((279, 301), 'sys.path.append', 'sys.path.append', (['"""../"""'], {}), "('../')\n", (294, 301), False, 'import sys\n'), ((2054, 2130), 'pyglet.gl.Config', 'pyglet.gl.Config', ([], {'sample_buffers': '(1)', 'samples': '(4)', 'double_buffer': '(1)', 'depth_size': '(8)'}), '(sample_buffers=1, samples=4, double_buffer=1,... |
import FWCore.ParameterSet.Config as cms
from RecoEgamma.ElectronIdentification.electronIdCutBasedExt_cfi import *
eidVeryLooseMC = eidCutBasedExt.clone()
eidVeryLooseMC.electronIDType = 'classbased'
eidVeryLooseMC.electronQuality = 'veryloose'
eidVeryLooseMC.electronVersion = 'V06'
eidVeryLooseMC.additionalCategorie... | [
"FWCore.ParameterSet.Config.vdouble"
] | [((402, 489), 'FWCore.ParameterSet.Config.vdouble', 'cms.vdouble', (['(9999.0)', '(9999.0)', '(9999.0)', '(9999.0)', '(9999.0)', '(9999.0)', '(9999.0)', '(9999.0)', '(9999.0)'], {}), '(9999.0, 9999.0, 9999.0, 9999.0, 9999.0, 9999.0, 9999.0, 9999.0,\n 9999.0)\n', (413, 489), True, 'import FWCore.ParameterSet.Config a... |
"""Test i18n/segment.py"""
import os.path
import shutil
from path import Path
import polib
from i18n.segment import segment_pofile
from . import I18nToolTestCase
HERE = Path(__file__).dirname()
TEST_DATA = HERE / "data"
WORK = HERE / "work"
class SegmentTest(I18nToolTestCase):
"""Test segment_pofile."""
... | [
"shutil.copyfile",
"polib.pofile",
"path.Path",
"i18n.segment.segment_pofile"
] | [((175, 189), 'path.Path', 'Path', (['__file__'], {}), '(__file__)\n', (179, 189), False, 'from path import Path\n'), ((623, 644), 'polib.pofile', 'polib.pofile', (['pofile1'], {}), '(pofile1)\n', (635, 644), False, 'import polib\n'), ((659, 680), 'polib.pofile', 'polib.pofile', (['pofile2'], {}), '(pofile2)\n', (671, ... |
"""
Correct Me If I am Wrong
<NAME>
Website : http://hanifmu.com
Email : <EMAIL>
Telegram : https://t.me/muhammad_hanif
"""
from netmiko import ConnectHandler
device = {
'device_type': 'cisco_ios',
'ip': '10.10.1.1',
'username': 'hanif',
'password': '<PASSWORD>',
'secret':'hanif'
}
net_conne... | [
"netmiko.ConnectHandler"
] | [((325, 349), 'netmiko.ConnectHandler', 'ConnectHandler', ([], {}), '(**device)\n', (339, 349), False, 'from netmiko import ConnectHandler\n')] |
'''
Description:
A linked list of length n is given such that each node contains an additional random pointer, which could point to any node in the list, or null.
Construct a deep copy of the list. The deep copy should consist of exactly n brand new nodes, where each new node has its value set to the value of its co... | [
"unittest.main"
] | [((4420, 4435), 'unittest.main', 'unittest.main', ([], {}), '()\n', (4433, 4435), False, 'import unittest\n')] |
import json
import hashlib
import base58
from aleph.chains.common import get_verification_buffer
from aleph.chains.register import register_verifier
from nacl.signing import VerifyKey
import logging
LOGGER = logging.getLogger("chains.near")
CHAIN_NAME = "NEAR"
async def verify_signature(message):
"""Verifies a... | [
"json.loads",
"base58.b58decode",
"aleph.chains.common.get_verification_buffer",
"nacl.signing.VerifyKey",
"hashlib.sha256",
"aleph.chains.register.register_verifier",
"logging.getLogger"
] | [((211, 243), 'logging.getLogger', 'logging.getLogger', (['"""chains.near"""'], {}), "('chains.near')\n", (228, 243), False, 'import logging\n'), ((1213, 1260), 'aleph.chains.register.register_verifier', 'register_verifier', (['CHAIN_NAME', 'verify_signature'], {}), '(CHAIN_NAME, verify_signature)\n', (1230, 1260), Fal... |
from multiprocessing import Process, Queue
import collections
import queue
import time
import serial
import numpy
import pandas as pd
from scipy import signal
from scipy import fftpack
import math
import sys
import PySimpleGUI as sg
import pygame
import pygame.camera
from pygame.locals import *
import io
import base64
... | [
"os.remove",
"PySimpleGUI.Multiline",
"multiprocessing.Queue",
"pygame.camera.init",
"collections.deque",
"serial.Serial",
"PySimpleGUI.Window",
"datetime.datetime.now",
"json.dump",
"time.clock_gettime",
"PySimpleGUI.Graph",
"pygame.init",
"pygame.camera.Camera",
"queue.put",
"sys.exit"... | [((9024, 9037), 'pygame.init', 'pygame.init', ([], {}), '()\n', (9035, 9037), False, 'import pygame\n'), ((9042, 9062), 'pygame.camera.init', 'pygame.camera.init', ([], {}), '()\n', (9060, 9062), False, 'import pygame\n'), ((9074, 9121), 'pygame.camera.Camera', 'pygame.camera.Camera', (['"""/dev/video0"""', '(640, 480)... |
from bs4 import BeautifulSoup
import mechanize
import click
'''
A command line application that allows you to perform tasks
from the command line interface on Facebook. But only one
option can be used at a time and all options being used together
will not allow you to use the total functionality of this program.
'''
... | [
"click.option",
"click.echo",
"click.command",
"mechanize.Browser",
"bs4.BeautifulSoup",
"mechanize.CookieJar"
] | [((426, 441), 'click.command', 'click.command', ([], {}), '()\n', (439, 441), False, 'import click\n'), ((444, 538), 'click.option', 'click.option', (['"""--score"""'], {'is_flag': '(True)', 'help': '"""Gives score summary of all ongoing matches."""'}), "('--score', is_flag=True, help=\n 'Gives score summary of all ... |
from bson.errors import InvalidId
from flask import current_app as app, request
from flask_jwt_extended import jwt_required
from flask_restful import Resource
from aquascope.webserver.data_access.db import upload
from aquascope.webserver.data_access.util import upload_package_from_stream
from aquascope.webserver.schem... | [
"aquascope.webserver.data_access.util.upload_package_from_stream",
"aquascope.webserver.data_access.db.upload.update_tags",
"aquascope.webserver.data_access.db.upload.find",
"aquascope.webserver.schema.upload.UploadTagsSchema",
"aquascope.webserver.data_access.db.upload.get",
"flask.request.get_json"
] | [((685, 757), 'aquascope.webserver.data_access.util.upload_package_from_stream', 'upload_package_from_stream', (['filename', 'request.stream', 'db', 'storage_client'], {}), '(filename, request.stream, db, storage_client)\n', (711, 757), False, 'from aquascope.webserver.data_access.util import upload_package_from_stream... |
import argparse
class CPU():
def __init__(self):
self.A = 0
self.D = 0
self.PC = 0
def tick(self, instruction, inM, reset):
a_instr = instruction & 0x8000 == 0
c_instr = not a_instr
jmp = instruction & 0b111
dst = (instruction & 0b111000) >> 3
... | [
"argparse.ArgumentParser"
] | [((4091, 4116), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (4114, 4116), False, 'import argparse\n')] |
import random as rd
class KNNEngine:
def __init__(self,
model_list,
batch_size_list,
opt_list,
learn_rate_list,
activation_list):
self.model_list = model_list
self.model_layer_list = list()
for midx in m... | [
"random.choice"
] | [((4000, 4021), 'random.choice', 'rd.choice', (['confs_list'], {}), '(confs_list)\n', (4009, 4021), True, 'import random as rd\n'), ((5935, 5956), 'random.choice', 'rd.choice', (['confs_list'], {}), '(confs_list)\n', (5944, 5956), True, 'import random as rd\n')] |
from __future__ import print_function
import tensorflow as tf
from functools import partial
import os
from os import listdir
from os.path import isfile, join
import shutil
import sys
from glob import glob
import math
import json
import logging
import numpy as np
from PIL import Image
from datetime import datetime
from ... | [
"functools.partial",
"json.dump",
"os.makedirs",
"tensorflow.summary.scalar",
"os.path.realpath",
"numpy.zeros",
"tensorflow.reduce_mean",
"datetime.datetime.now",
"tensorflow.core.framework.summary_pb2.Summary.Value",
"os.path.exists",
"tensorflow.python.client.device_lib.list_local_devices",
... | [((616, 638), 'tensorflow.reduce_mean', 'tf.reduce_mean', (['tensor'], {}), '(tensor)\n', (630, 638), True, 'import tensorflow as tf\n'), ((698, 748), 'tensorflow.summary.scalar', 'tf.summary.scalar', (["(name + '_ave')", 'ave', 'collections'], {}), "(name + '_ave', ave, collections)\n", (715, 748), True, 'import tenso... |
from dagster import repository, PipelineDefinition, fs_io_manager, in_process_executor
from dagster_utils.resources.beam.dataflow_beam_runner import dataflow_beam_runner
from dagster_utils.resources.google_storage import google_storage_client
from dagster_utils.resources.slack import console_slack_client
from dap_orch... | [
"dap_orchestration.pipelines.firecloud.to_job",
"dap_orchestration.config.preconfigure_resource_for_mode",
"dap_orchestration.repositories.common.build_pipeline_failure_sensor"
] | [((750, 812), 'dap_orchestration.pipelines.firecloud.to_job', 'firecloud.to_job', ([], {'resource_defs': "{'gcs': google_storage_client}"}), "(resource_defs={'gcs': google_storage_client})\n", (766, 812), False, 'from dap_orchestration.pipelines import refresh_data_all, firecloud\n'), ((912, 943), 'dap_orchestration.re... |
"""
4 6 digit numbers and their sum. Print and fold
"""
from random import randint
lstj = []
for j in range(4):
sum_int = 0
lsti = []
for i in range(4):
randnum = randint(99999, 1000000)
sum_int += randnum
lsti.append(randnum)
lsti.append(sum_int)
lstj.append(lsti)
for i in... | [
"random.randint"
] | [((184, 207), 'random.randint', 'randint', (['(99999)', '(1000000)'], {}), '(99999, 1000000)\n', (191, 207), False, 'from random import randint\n')] |
import os
import mangadex_py.http as http
from concurrent.futures import ThreadPoolExecutor
from tqdm import tqdm
import time
#import mangadex_py.report_health as report
def normal_download(path, link) :
if not os.path.exists(path) :
req = http.get(link)
# try : #https://github.com/Proxymiity/Manga... | [
"tqdm.tqdm",
"os.path.exists",
"time.sleep",
"mangadex_py.http.get",
"concurrent.futures.ThreadPoolExecutor",
"os.path.join"
] | [((216, 236), 'os.path.exists', 'os.path.exists', (['path'], {}), '(path)\n', (230, 236), False, 'import os\n'), ((253, 267), 'mangadex_py.http.get', 'http.get', (['link'], {}), '(link)\n', (261, 267), True, 'import mangadex_py.http as http\n'), ((1777, 1797), 'os.path.exists', 'os.path.exists', (['path'], {}), '(path)... |
""" This module contains functions that return a new, single point in a given
parameter space. In general, these functions are not used to return
multi-dimensional arrays. These functions are intended to be called only a
few times.
"""
import numpy
from mystic import math
def uniform(lower_bounds, upper_bounds):
... | [
"mystic.math.fillpts",
"numpy.random.uniform",
"numpy.zeros"
] | [((742, 759), 'numpy.zeros', 'numpy.zeros', (['ndim'], {}), '(ndim)\n', (753, 759), False, 'import numpy\n'), ((1658, 1727), 'mystic.math.fillpts', 'math.fillpts', (['lower_bounds', 'upper_bounds', 'n_new_pts', 'data', 'rtol', 'dist'], {}), '(lower_bounds, upper_bounds, n_new_pts, data, rtol, dist)\n', (1670, 1727), Fa... |
import plot_line
import numpy as np
import reader
import render_figure
class PlotAltitude(plot_line.LinePlot):
def __init__(self, fig_cluster, fig_name, fig):
self.fig = fig
self.fig_name = fig_name
self.fig_cluster = fig_cluster
self.config = self.get_config()
self.index_a... | [
"numpy.nanmax",
"numpy.isnan",
"numpy.nanmin",
"numpy.append",
"numpy.array",
"numpy.delete",
"render_figure.RenderFigure"
] | [((461, 473), 'numpy.array', 'np.array', (['[]'], {}), '([])\n', (469, 473), True, 'import numpy as np\n'), ((516, 528), 'numpy.array', 'np.array', (['[]'], {}), '([])\n', (524, 528), True, 'import numpy as np\n'), ((2201, 2228), 'numpy.append', 'np.append', (['self.alt_x', 'time'], {}), '(self.alt_x, time)\n', (2210, ... |
# Copyright 2019, The Jelly Bean World Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may not
# use this file except in compliance with the License. You may obtain a copy of
# the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by ... | [
"numpy.array",
"gym.envs.registration.register"
] | [((10444, 10473), 'numpy.array', 'np.array', (['[0, -1, 1, 0, 0, 0]'], {}), '([0, -1, 1, 0, 0, 0])\n', (10452, 10473), True, 'import numpy as np\n'), ((10758, 10898), 'gym.envs.registration.register', 'register', ([], {'id': '"""JBW-v0"""', 'entry_point': '"""jbw.environment:JBWEnv"""', 'kwargs': "{'sim_config': sim_co... |
import plotly.graph_objects as go
import pandas as pd
import numpy as np
def plot_flops(flops_df):
fig = go.Figure()
fig.add_trace(go.Scatter(x=flops_df.index, y=flops_df[1], name='flops_dp - Gauss Jacobi', line=dict(color='#2A9D8F')))
fig.add_trace(go.Scatter(x=flops_df.index, y=flops_df[2], name='flops_a... | [
"pandas.read_csv",
"plotly.graph_objects.Figure"
] | [((3028, 3078), 'pandas.read_csv', 'pd.read_csv', (["(path + 'l3')"], {'header': 'None', 'index_col': '(0)'}), "(path + 'l3', header=None, index_col=0)\n", (3039, 3078), True, 'import pandas as pd\n'), ((3103, 3155), 'pandas.read_csv', 'pd.read_csv', (["(path + 'time')"], {'header': 'None', 'index_col': '(0)'}), "(path... |
from setuptools import setup, find_packages
# Import ``__version__`` variable
exec(open('mustaching/_version.py').read())
with open('README.rst') as f:
readme = f.read()
with open('LICENSE.txt') as f:
license = f.read()
setup(
name='mustaching',
version=__version__,
author='<NAME>',
url='ht... | [
"setuptools.find_packages"
] | [((607, 647), 'setuptools.find_packages', 'find_packages', ([], {'exclude': "('tests', 'docs')"}), "(exclude=('tests', 'docs'))\n", (620, 647), False, 'from setuptools import setup, find_packages\n')] |
# Generated by Django 2.0.2 on 2020-07-10 13:41
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('article', '0002_category_is_nav'),
]
operations = [
migrations.AlterField(
model_name='tag',
name='name',
... | [
"django.db.models.CharField"
] | [((328, 360), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(100)'}), '(max_length=100)\n', (344, 360), False, 'from django.db import migrations, models\n')] |
import click
from hoss.tools.upload import upload_directory
@click.command()
@click.argument('dataset_name', metavar='DATASET_NAME', type=str, nargs=1)
@click.argument('directory', type=str, nargs=1)
@click.option('--namespace', '-n', type=str, default="default", show_default=True,
help="Namespace that ... | [
"hoss.tools.upload.upload_directory",
"click.option",
"click.argument",
"click.command"
] | [((63, 78), 'click.command', 'click.command', ([], {}), '()\n', (76, 78), False, 'import click\n'), ((80, 153), 'click.argument', 'click.argument', (['"""dataset_name"""'], {'metavar': '"""DATASET_NAME"""', 'type': 'str', 'nargs': '(1)'}), "('dataset_name', metavar='DATASET_NAME', type=str, nargs=1)\n", (94, 153), Fals... |
# Generated by Django 2.2.7 on 2019-11-20 13:09
from django.db import migrations, models
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
migrations.CreateModel(
name='Flight',
fields=[
('id', mo... | [
"django.db.models.TimeField",
"django.db.models.CharField",
"django.db.models.AutoField",
"django.db.models.DecimalField",
"django.db.models.IntegerField",
"django.db.models.DateField"
] | [((318, 411), 'django.db.models.AutoField', 'models.AutoField', ([], {'auto_created': '(True)', 'primary_key': '(True)', 'serialize': '(False)', 'verbose_name': '"""ID"""'}), "(auto_created=True, primary_key=True, serialize=False,\n verbose_name='ID')\n", (334, 411), False, 'from django.db import migrations, models\... |
import sys
def get_logger_traceback(): # noqa
"""
Returns a traceback object for a log event.
A traceback object is only available when an exception has been thrown. To get one for a log event
we throw an exception and then wrap it in our own Traceback proxy that hides parts of the stack trace
l... | [
"sys.exc_info"
] | [((463, 477), 'sys.exc_info', 'sys.exc_info', ([], {}), '()\n', (475, 477), False, 'import sys\n')] |
# Copyright 2020 Standard Cyborg
#
# 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... | [
"scsdk.scsdk_native.Node",
"scsdk.scsdk_native.DepthImageNode",
"scsdk.scsdk_native.ColorImageNode",
"scsdk.scsdk_native.DepthImage",
"scsdk.scsdk_native.GeometryNode",
"scsdk.scsdk_native.WriteSceneGraphToGltf",
"numpy.zeros",
"scsdk.scsdk_native.ColorImage",
"PIL.Image.open",
"numpy.array",
"s... | [((764, 776), 'scsdk.scsdk_native.Node', 'scsdk.Node', ([], {}), '()\n', (774, 776), True, 'from scsdk import scsdk_native as scsdk\n'), ((876, 896), 'scsdk.scsdk_native.GeometryNode', 'scsdk.GeometryNode', ([], {}), '()\n', (894, 896), True, 'from scsdk import scsdk_native as scsdk\n'), ((951, 994), 'numpy.array', 'np... |
import abc
import asyncio
from cached_property import cached_property
class ActorMeta(abc.ABCMeta):
"""Helper class to implement syntactic sugar for actors."""
def __new__(cls, name, bases, dct):
if 'main' in dct and not isinstance(dct['main'], cached_property):
# automatically wraps acto... | [
"asyncio.isfuture",
"cached_property.cached_property",
"asyncio.ensure_future",
"asyncio.iscoroutine",
"asyncio.Queue"
] | [((3733, 3749), 'asyncio.Queue', 'asyncio.Queue', (['(1)'], {}), '(1)\n', (3746, 3749), False, 'import asyncio\n'), ((438, 466), 'cached_property.cached_property', 'cached_property', (["dct['main']"], {}), "(dct['main'])\n", (453, 466), False, 'from cached_property import cached_property\n'), ((1598, 1623), 'asyncio.is... |
# Copyright (C) 2020 GreenWaves Technologies, SAS
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as
# published by the Free Software Foundation, either version 3 of the
# License, or (at your option) any later version.
# This progr... | [
"quantization.new_qrec.QRec.copy_ktype",
"utils.node_id.NodeId",
"logging.getLogger"
] | [((956, 995), 'logging.getLogger', 'logging.getLogger', (["('nntool.' + __name__)"], {}), "('nntool.' + __name__)\n", (973, 995), False, 'import logging\n'), ((1653, 1670), 'utils.node_id.NodeId', 'NodeId', (['keep_node'], {}), '(keep_node)\n', (1659, 1670), False, 'from utils.node_id import NodeId\n'), ((2021, 2076), ... |
# The MIT License (MIT)
# Copyright (c) 2021 <NAME>
# Copyright (c) 2015 <NAME>
# Copyright (c) 2013 <NAME>
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including wi... | [
"struct.pack"
] | [((3811, 3849), 'struct.pack', 'struct.pack', (['""">B"""', '(major << 5 | length)'], {}), "('>B', major << 5 | length)\n", (3822, 3849), False, 'import struct\n'), ((2756, 2780), 'struct.pack', 'struct.pack', (['""">d"""', 'float'], {}), "('>d', float)\n", (2767, 2780), False, 'import struct\n'), ((3881, 3924), 'struc... |
# Copyright 2021 gRPC authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing... | [
"absl.flags.adopt_module_key_flags",
"datetime.timedelta",
"absl.testing.absltest.main"
] | [((781, 827), 'absl.flags.adopt_module_key_flags', 'flags.adopt_module_key_flags', (['xds_k8s_testcase'], {}), '(xds_k8s_testcase)\n', (809, 827), False, 'from absl import flags\n'), ((1514, 1543), 'datetime.timedelta', 'datetime.timedelta', ([], {'seconds': '(5)'}), '(seconds=5)\n', (1532, 1543), False, 'import dateti... |
from __future__ import print_function, division, absolute_import
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.utils.model_zoo as model_zoo
from detectron2.layers import (
ShapeSpec,
)
from .backbone import Backbone
from .build import BACKBONE_REGISTRY
class BasicConv2d(nn.Modul... | [
"torch.nn.ReLU",
"torch.nn.functional.avg_pool2d",
"torch.nn.Conv2d",
"torch.cat",
"detectron2.layers.ShapeSpec",
"torch.nn.BatchNorm2d",
"torch.nn.Linear",
"torch.nn.MaxPool2d",
"torch.nn.AvgPool2d",
"torch.nn.functional.pad"
] | [((468, 573), 'torch.nn.Conv2d', 'nn.Conv2d', (['in_planes', 'out_planes'], {'kernel_size': 'kernel_size', 'stride': 'stride', 'padding': 'padding', 'bias': '(False)'}), '(in_planes, out_planes, kernel_size=kernel_size, stride=stride,\n padding=padding, bias=False)\n', (477, 573), True, 'import torch.nn as nn\n'), (... |
# -*- coding: utf-8 -*-
# Generated by Django 1.9.1 on 2016-01-20 22:32
from __future__ import unicode_literals
import datetime
from decimal import Decimal
from django.conf import settings
import django.contrib.postgres.fields
import django.contrib.postgres.fields.hstore
import django.contrib.postgres.fields.jsonb
imp... | [
"django.db.models.TextField",
"django.db.migrations.swappable_dependency",
"django.db.models.ManyToManyField",
"decimal.Decimal",
"django.db.models.ForeignKey",
"django.contrib.postgres.operations.HStoreExtension",
"django.db.models.CharField",
"django.db.models.PositiveIntegerField",
"django.db.mod... | [((760, 817), 'django.db.migrations.swappable_dependency', 'migrations.swappable_dependency', (['settings.AUTH_USER_MODEL'], {}), '(settings.AUTH_USER_MODEL)\n', (791, 817), False, 'from django.db import migrations, models\n'), ((853, 870), 'django.contrib.postgres.operations.HStoreExtension', 'HStoreExtension', ([], {... |
import datetime
import logging
import os
import click
from predicu.data import load_bedcounts
from predicu.plot import generate_plots
from predicu.preprocessing import preprocess_bedcounts
@click.group()
def cli():
pass
@cli.command(name="export")
@click.option("--output-dir", "-o", default="/tmp", type=str)
... | [
"predicu.data.load_bedcounts",
"click.argument",
"os.makedirs",
"os.path.isdir",
"click.option",
"datetime.datetime.now",
"predicu.preprocessing.preprocess_bedcounts",
"click.Choice",
"logging.info",
"logging.getLogger",
"matplotlib.use",
"click.group",
"os.path.join",
"predicu.plot.genera... | [((194, 207), 'click.group', 'click.group', ([], {}), '()\n', (205, 207), False, 'import click\n'), ((259, 319), 'click.option', 'click.option', (['"""--output-dir"""', '"""-o"""'], {'default': '"""/tmp"""', 'type': 'str'}), "('--output-dir', '-o', default='/tmp', type=str)\n", (271, 319), False, 'import click\n'), ((3... |
import sys
# Class to store Trie(Patterns)
# It handles all cases particularly the case where a pattern Pi is a subtext of a pattern Pj for i != j
class Trie_patterns:
def __init__(self, patterns):
self.build_trie(patterns)
def search_text(self, pattern, index):
if len(self.trie) == 0:
... | [
"sys.stdin.readline"
] | [((2985, 3005), 'sys.stdin.readline', 'sys.stdin.readline', ([], {}), '()\n', (3003, 3005), False, 'import sys\n'), ((3023, 3043), 'sys.stdin.readline', 'sys.stdin.readline', ([], {}), '()\n', (3041, 3043), False, 'import sys\n'), ((3106, 3126), 'sys.stdin.readline', 'sys.stdin.readline', ([], {}), '()\n', (3124, 3126)... |
import base64
try:
import cryptography
from cryptography.fernet import Fernet, InvalidToken
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.kdf.pbkdf2 import PBKDF2HMAC
HAS_CRYPTO = True
except:
HA... | [
"cryptography.hazmat.backends.default_backend",
"cryptography.fernet.Fernet",
"cryptography.hazmat.primitives.hashes.SHA256"
] | [((957, 969), 'cryptography.fernet.Fernet', 'Fernet', (['base'], {}), '(base)\n', (963, 969), False, 'from cryptography.fernet import Fernet, InvalidToken\n'), ((1445, 1457), 'cryptography.fernet.Fernet', 'Fernet', (['base'], {}), '(base)\n', (1451, 1457), False, 'from cryptography.fernet import Fernet, InvalidToken\n'... |
"""
Copyright (c) <2018> YoongiKim
See the file license.txt for copying permission.
"""
import tensorflow as tf
import random
import os
import numpy as np
# import matplotlib.pyplot as plt
import cv2
from tensorflow.examples.tutorials.mnist import input_data
tf.set_random_seed(777) # reproducibility
# This path ... | [
"tensorflow.contrib.layers.xavier_initializer",
"tensorflow.reshape",
"os.walk",
"numpy.shape",
"tensorflow.matmul",
"tensorflow.Variable",
"tensorflow.nn.conv2d",
"tensorflow.nn.relu",
"os.path.exists",
"tensorflow.set_random_seed",
"tensorflow.nn.softmax_cross_entropy_with_logits_v2",
"tenso... | [((264, 287), 'tensorflow.set_random_seed', 'tf.set_random_seed', (['(777)'], {}), '(777)\n', (282, 287), True, 'import tensorflow as tf\n'), ((1447, 1473), 'tensorflow.placeholder', 'tf.placeholder', (['tf.float32'], {}), '(tf.float32)\n', (1461, 1473), True, 'import tensorflow as tf\n'), ((1501, 1540), 'tensorflow.pl... |
from pathfinder.Graph import Graph
from pathfinder.Algorithms import Dijkstra
from pathfinder.Algorithms import AStar
from pathfinder.Algorithms import Algorithm
from utils.m_parser import args
algorithm = AStar()
if args.algo == "Dijkstra":
algorithm = Dijkstra()
class GraphVisualizer:
def __init__(self, ... | [
"pathfinder.Algorithms.AStar",
"pathfinder.Algorithms.Dijkstra"
] | [((208, 215), 'pathfinder.Algorithms.AStar', 'AStar', ([], {}), '()\n', (213, 215), False, 'from pathfinder.Algorithms import AStar\n'), ((261, 271), 'pathfinder.Algorithms.Dijkstra', 'Dijkstra', ([], {}), '()\n', (269, 271), False, 'from pathfinder.Algorithms import Dijkstra\n')] |
"""
Appraise evaluation framework
See LICENSE for usage details
"""
from datetime import datetime, timedelta
import django
from django.core.management.base import BaseCommand, CommandError
from django.test import Client
from django.template.response import SimpleTemplateResponse
from Campaign.utils import CAMPAIGN_... | [
"django.test.Client",
"datetime.timedelta",
"django.core.management.base.CommandError",
"Campaign.utils.CAMPAIGN_TASK_TYPES.keys",
"datetime.datetime.now",
"django.test.utils.setup_test_environment"
] | [((1691, 1733), 'django.test.utils.setup_test_environment', 'django.test.utils.setup_test_environment', ([], {}), '()\n', (1731, 1733), False, 'import django\n'), ((1830, 1861), 'django.test.Client', 'Client', ([], {'SERVER_NAME': '"""localhost"""'}), "(SERVER_NAME='localhost')\n", (1836, 1861), False, 'from django.tes... |
from robot.libraries.BuiltIn import BuiltIn
def invalidate_driver():
sl = BuiltIn().get_library_instance("SeleniumLibrary")
sl.register_driver(None, "tidii")
sl.register_driver(None, "foobar")
| [
"robot.libraries.BuiltIn.BuiltIn"
] | [((80, 89), 'robot.libraries.BuiltIn.BuiltIn', 'BuiltIn', ([], {}), '()\n', (87, 89), False, 'from robot.libraries.BuiltIn import BuiltIn\n')] |
import cv2
if __name__ == "__main__":
img = cv2.imread("C:/Users/ASUS/Documents/test_folder_1/test_segmentation/2.jpg")
cv2.imwrite("imgorg.png",img)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
cv2.imwrite("gray.png",gray)
ret, thresh = cv2.threshold(gray, 199, 255, cv2.THRESH_BINARY_INV)
... | [
"cv2.Canny",
"cv2.cvtColor",
"cv2.imwrite",
"cv2.threshold",
"cv2.imread"
] | [((50, 125), 'cv2.imread', 'cv2.imread', (['"""C:/Users/ASUS/Documents/test_folder_1/test_segmentation/2.jpg"""'], {}), "('C:/Users/ASUS/Documents/test_folder_1/test_segmentation/2.jpg')\n", (60, 125), False, 'import cv2\n'), ((130, 160), 'cv2.imwrite', 'cv2.imwrite', (['"""imgorg.png"""', 'img'], {}), "('imgorg.png', ... |
import json
import re
from discord.ext import commands, tasks
from bs4 import BeautifulSoup
from config.utils.cache import cache
class Youtube(commands.Cog):
"""Some youtube related commands"""
def __init__(self, bot):
self.bot = bot
@tasks.loop(hours=1)
async def invalidate_search_cache(s... | [
"discord.ext.commands.Cog.listener",
"config.utils.cache.cache",
"discord.ext.tasks.loop",
"discord.ext.commands.group",
"bs4.BeautifulSoup",
"re.compile"
] | [((261, 280), 'discord.ext.tasks.loop', 'tasks.loop', ([], {'hours': '(1)'}), '(hours=1)\n', (271, 280), False, 'from discord.ext import commands, tasks\n'), ((414, 437), 'discord.ext.commands.Cog.listener', 'commands.Cog.listener', ([], {}), '()\n', (435, 437), False, 'from discord.ext import commands, tasks\n'), ((97... |
from all_net_def import *
import os
import numpy as np
import torch
from torch import nn
from torch.utils.data import Dataset, DataLoader
import t1_audio_process
np.set_printoptions(threshold=np.inf)
class AudioDataset_test(Dataset):
def __init__(self, csv_file, transform=None):
self.data = np.load(csv_f... | [
"t1_audio_process.test",
"numpy.set_printoptions",
"numpy.load",
"torch.utils.data.DataLoader",
"torch.load",
"torch.max",
"numpy.reshape",
"torch.cuda.is_available",
"torch.is_tensor",
"os.listdir",
"torch.tensor"
] | [((163, 200), 'numpy.set_printoptions', 'np.set_printoptions', ([], {'threshold': 'np.inf'}), '(threshold=np.inf)\n', (182, 200), True, 'import numpy as np\n'), ((1029, 1053), 'torch.load', 'torch.load', (['"""t1_cnn.pth"""'], {}), "('t1_cnn.pth')\n", (1039, 1053), False, 'import torch\n'), ((1095, 1118), 't1_audio_pro... |
import related
from adaptive_alerting_detector_build.config import MODEL_SERVICE_USER
from adaptive_alerting_detector_build.detectors import DetectorUUID
@related.immutable
class DetectorMappingUser:
id = related.StringField()
@related.immutable
class DetectorMappingOperandField:
key = related.StringField(... | [
"related.StringField",
"related.BooleanField",
"related.IntegerField",
"related.ChildField",
"related.SequenceField"
] | [((212, 233), 'related.StringField', 'related.StringField', ([], {}), '()\n', (231, 233), False, 'import related\n'), ((300, 321), 'related.StringField', 'related.StringField', ([], {}), '()\n', (319, 321), False, 'import related\n'), ((334, 355), 'related.StringField', 'related.StringField', ([], {}), '()\n', (353, 35... |
import clr
clr.AddReference('RevitAPI')
from Autodesk.Revit.DB import *
items = UnwrapElement(IN[0])
booleans = list()
for item in items:
try:
if item.CurtainGrids:
booleans.append(True)
else:
booleans.append(False)
except:
booleans.append(False)
OUT = booleans | [
"clr.AddReference"
] | [((11, 39), 'clr.AddReference', 'clr.AddReference', (['"""RevitAPI"""'], {}), "('RevitAPI')\n", (27, 39), False, 'import clr\n')] |
from contentful.cda import utils
from contentful.cda.resources import Asset, ContentType, Entry, Space
from test import BaseTestCase
class UtilsTestCase(BaseTestCase):
def test_class_for_type(self):
self.assertIs(utils.class_for_type('Asset'), Asset)
self.assertIs(utils.class_for_type('ContentType... | [
"contentful.cda.utils.class_for_type"
] | [((227, 256), 'contentful.cda.utils.class_for_type', 'utils.class_for_type', (['"""Asset"""'], {}), "('Asset')\n", (247, 256), False, 'from contentful.cda import utils\n'), ((287, 322), 'contentful.cda.utils.class_for_type', 'utils.class_for_type', (['"""ContentType"""'], {}), "('ContentType')\n", (307, 322), False, 'f... |
""" Usage:
load_pretrained_word_embeddings [--glove=GLOVE_FN]
"""
from docopt import docopt
import numpy as np
from word_index import Word_index
import logging
logging.basicConfig(level = logging.DEBUG)
import sys
sys.path.append("./common")
from symbols import UNK_INDEX, UNK_SYMBOL, UNK_VALUE
from keras.layers im... | [
"sys.path.append",
"logging.debug",
"keras_bert.load_trained_model_from_checkpoint",
"logging.basicConfig",
"docopt.docopt",
"codecs.open",
"tokenization.FullTokenizer",
"numpy.asarray",
"keras.layers.SpatialDropout1D",
"logging.info",
"keras.layers.Lambda",
"keras.backend.mean",
"symbols.UN... | [((165, 205), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.DEBUG'}), '(level=logging.DEBUG)\n', (184, 205), False, 'import logging\n'), ((219, 246), 'sys.path.append', 'sys.path.append', (['"""./common"""'], {}), "('./common')\n", (234, 246), False, 'import sys\n'), ((7553, 7568), 'docopt.docop... |
#!/usr/bin/env python3
"""blag's core methods.
"""
import argparse
import os
import shutil
import logging
import configparser
import sys
from jinja2 import Environment, ChoiceLoader, FileSystemLoader, PackageLoader
import feedgenerator
from blag.markdown import markdown_factory, convert_markdown
from blag.devserve... | [
"os.makedirs",
"logging.basicConfig",
"argparse.ArgumentParser",
"blag.markdown.markdown_factory",
"jinja2.ChoiceLoader",
"os.walk",
"os.path.exists",
"blag.markdown.convert_markdown",
"sys.exit",
"jinja2.PackageLoader",
"jinja2.FileSystemLoader",
"os.path.relpath",
"shutil.copy",
"shutil.... | [((345, 372), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (362, 372), False, 'import logging\n'), ((373, 474), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO', 'format': '"""%(asctime)s %(levelname)s %(name)s %(message)s"""'}), "(level=logging.INFO, format=\... |
#!/usr/bin/env python
from getpass import getpass
from rich import print
from napalm import get_network_driver
device = {
"hostname": "arista4.lasthop.io",
"username": "pyclass",
"password": getpass(),
"optional_args": {},
}
driver = get_network_driver("eos")
device = driver(**device)
print()
print("... | [
"napalm.get_network_driver",
"rich.print",
"getpass.getpass"
] | [((252, 277), 'napalm.get_network_driver', 'get_network_driver', (['"""eos"""'], {}), "('eos')\n", (270, 277), False, 'from napalm import get_network_driver\n'), ((305, 312), 'rich.print', 'print', ([], {}), '()\n', (310, 312), False, 'from rich import print\n'), ((313, 347), 'rich.print', 'print', (['"""\n\n>>>Test de... |
import os
import stat
import asyncio
import jwt
import psutil
import aiofiles
from time import time, sleep
from urllib.parse import quote
from tornado.web import RequestHandler
from backend_extensions import generate_zip_path, get_user_id, record_access_times
from shop_extensions import get_product_dict, get_goods_na... | [
"shop_logger.logger.warning",
"os.mkdir",
"os.path.abspath",
"os.remove",
"asyncio.get_event_loop",
"psutil.virtual_memory",
"os.stat",
"backend_extensions.record_access_times",
"asyncio.set_event_loop",
"code.BaseError",
"os.path.exists",
"psutil.cpu_percent",
"urllib.parse.quote",
"shop_... | [((3914, 3932), 'os.stat', 'os.stat', (['file_path'], {}), '(file_path)\n', (3921, 3932), False, 'import os\n'), ((7799, 7827), 'asyncio.set_event_loop', 'asyncio.set_event_loop', (['loop'], {}), '(loop)\n', (7821, 7827), False, 'import asyncio\n'), ((11391, 11470), 'shop_logger.download_logger.warning', 'download_logg... |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
'''
@File : main.py
@Description: 播报音箱案例（本案例符合HaaS Python 2.0 API标准，请务必按照“HaaS EDU K1快速开始”（https://haas.iot.aliyun.com/haasapi/#/Python/docs/zh-CN/startup/HaaS_EDU_K1_startup）文章的说明烧录固件
@Date : 2022年02月11日
@Author : ethan.lcz
@version : v2... | [
"netmgr.getInfo",
"netmgr.disconnect",
"netmgr.getStatus",
"netmgr.init",
"utime.sleep",
"ujson.loads",
"time.sleep",
"netmgr.connect",
"aliyunIoT.Device",
"speech_utils.Speaker"
] | [((912, 921), 'netmgr.init', 'nm.init', ([], {}), '()\n', (919, 921), True, 'import netmgr as nm\n'), ((943, 957), 'netmgr.getStatus', 'nm.getStatus', ([], {}), '()\n', (955, 957), True, 'import netmgr as nm\n'), ((962, 977), 'netmgr.disconnect', 'nm.disconnect', ([], {}), '()\n', (975, 977), True, 'import netmgr as nm... |
import gws
import gws.types as t
import gws.lib.units as units
import gws.lib.gis
class Config(gws.Config):
"""Zoom levels and resolutions"""
resolutions: t.Optional[t.List[float]] #: allowed resolutions
initResolution: t.Optional[float] #: initial resolution
scales: t.Optional[t.List[float]] #:... | [
"gws.lib.units.scale2res",
"gws.get",
"gws.Data"
] | [((1946, 1973), 'gws.get', 'gws.get', (['cfg', '"""resolutions"""'], {}), "(cfg, 'resolutions')\n", (1953, 1973), False, 'import gws\n'), ((2013, 2035), 'gws.get', 'gws.get', (['cfg', '"""scales"""'], {}), "(cfg, 'scales')\n", (2020, 2035), False, 'import gws\n'), ((2135, 2150), 'gws.get', 'gws.get', (['cfg', 'r'], {})... |
#!/usr/bin/env python3
# cython: language_level=3
# -*- coding: utf-8 -*-
from mathics.core.element import KeyComparable
from mathics.core.expression import Expression
from mathics.core.symbols import strip_context
from mathics.core.pattern import Pattern, StopGenerator
from mathics.core.util import function_arguments... | [
"mathics.core.pattern.Pattern.create",
"mathics.core.symbols.strip_context",
"mathics.core.util.function_arguments",
"itertools.chain"
] | [((915, 938), 'mathics.core.pattern.Pattern.create', 'Pattern.create', (['pattern'], {}), '(pattern)\n', (929, 938), False, 'from mathics.core.pattern import Pattern, StopGenerator\n'), ((7535, 7563), 'mathics.core.util.function_arguments', 'function_arguments', (['function'], {}), '(function)\n', (7553, 7563), False, ... |
from sensors.sensor import Sensor
from matplotlib import pyplot as plt
from PIL import Image
import numpy as np
import pygame
import io
class OverviewSensor(Sensor):
def __init__(self, **kwargs):
super(OverviewSensor, self).__init__(**kwargs)
self.name = 'overview'
def get_sensory_input(self... | [
"matplotlib.pyplot.show",
"matplotlib.pyplot.imshow",
"numpy.zeros",
"pygame.image.tostring",
"matplotlib.pyplot.draw",
"matplotlib.pyplot.figure",
"PIL.Image.frombytes"
] | [((398, 438), 'pygame.image.tostring', 'pygame.image.tostring', (['env.screen', '"""RGB"""'], {}), "(env.screen, 'RGB')\n", (419, 438), False, 'import pygame\n'), ((459, 504), 'PIL.Image.frombytes', 'Image.frombytes', (['"""RGB"""', '(width, height)', 'data'], {}), "('RGB', (width, height), data)\n", (474, 504), False,... |
import logging
from typing import List
from . import api_helpers, model_helpers
from .. import models
# Use this logger to forward log messages to CloudWatch Logs.
LOG = logging.getLogger(__name__)
LOG.setLevel(logging.DEBUG)
def list_detector_models(afd_client) -> List[models.ResourceModel]:
# For contract_del... | [
"logging.getLogger"
] | [((172, 199), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (189, 199), False, 'import logging\n')] |
import discord
from discord.ext import commands
from discord import Embed
class On_Member_Remove(commands.Cog):
def __init__(self, client):
self.client = client
@commands.Cog.listener()
async def on_member_remove(self, member):
channel = discord.utils.get(member.guild.channels, id=87831851... | [
"discord.utils.get",
"discord.ext.commands.Cog.listener"
] | [((180, 203), 'discord.ext.commands.Cog.listener', 'commands.Cog.listener', ([], {}), '()\n', (201, 203), False, 'from discord.ext import commands\n'), ((268, 331), 'discord.utils.get', 'discord.utils.get', (['member.guild.channels'], {'id': '(878318513981366352)'}), '(member.guild.channels, id=878318513981366352)\n', ... |
import re
fileboi = open('./car/car.data','r')
newCar = open('./car/newCarBoi.data','w+')
for line in fileboi:
copy = line
copy = re.sub(r'5more',"5",copy)
copy = re.sub(r'more',"5",copy)
newCar.write(copy) | [
"re.sub"
] | [((138, 164), 're.sub', 're.sub', (['"""5more"""', '"""5"""', 'copy'], {}), "('5more', '5', copy)\n", (144, 164), False, 'import re\n'), ((175, 200), 're.sub', 're.sub', (['"""more"""', '"""5"""', 'copy'], {}), "('more', '5', copy)\n", (181, 200), False, 'import re\n')] |
from brownie import DappToken, TokenFarm
from scripts.helpful_scripts import get_account, get_contract, get_verify_status
from web3 import Web3
import yaml
import json
import os
import shutil
KEPT_BALANCE = Web3.toWei(100, "ether")
def deploy_token_farm_and_dapp_token(frontend_update=False):
account = get_accoun... | [
"json.dump",
"yaml.load",
"brownie.DappToken.deploy",
"scripts.helpful_scripts.get_account",
"shutil.rmtree",
"os.path.exists",
"scripts.helpful_scripts.get_contract",
"web3.Web3.toWei",
"shutil.copytree",
"scripts.helpful_scripts.get_verify_status"
] | [((208, 232), 'web3.Web3.toWei', 'Web3.toWei', (['(100)', '"""ether"""'], {}), "(100, 'ether')\n", (218, 232), False, 'from web3 import Web3\n'), ((310, 323), 'scripts.helpful_scripts.get_account', 'get_account', ([], {}), '()\n', (321, 323), False, 'from scripts.helpful_scripts import get_account, get_contract, get_ve... |
# -*- coding: utf-8 -*-
#main sirbot script
ON = 1
SPLASH = 1
##try:
import lib.sirbot.initialize as initialize
if(SPLASH == 1):
#display splash
splash = initialize.splashing()
root = splash.root()
#import configurations
from lib.sirbot.configloader import configloader
config = configloader()
#import ... | [
"lib.sirbot.configloader.configloader",
"lib.sirbot.application.application",
"lib.sirbot.interfaceDEV.interface",
"time.sleep",
"lib.sirbot.assetloader.assetloader",
"lib.sirbot.shutdown.shutdown",
"multiprocessing.Queue",
"lib.sirbot.initialize.splashing"
] | [((296, 310), 'lib.sirbot.configloader.configloader', 'configloader', ([], {}), '()\n', (308, 310), False, 'from lib.sirbot.configloader import configloader\n'), ((165, 187), 'lib.sirbot.initialize.splashing', 'initialize.splashing', ([], {}), '()\n', (185, 187), True, 'import lib.sirbot.initialize as initialize\n'), (... |
# Copyright (c) Meta Platforms, Inc. and affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
"""End-to-end test for 1D GMM with K > 2 number of components"""
import logging
import unittest
# Comments after imports suggest alternati... | [
"torch.distributions.Gamma",
"torch.ones",
"torch.distributions.Categorical",
"beanmachine.ppl.inference.bmg_inference.BMGInference",
"torch.manual_seed",
"beanmachine.ppl.SingleSiteNewtonianMonteCarlo",
"torch.distributions.Normal",
"torch.tensor",
"logging.getLogger"
] | [((737, 758), 'torch.manual_seed', 'torch.manual_seed', (['(42)'], {}), '(42)\n', (754, 758), False, 'import torch\n'), ((691, 723), 'logging.getLogger', 'logging.getLogger', (['"""beanmachine"""'], {}), "('beanmachine')\n", (708, 723), False, 'import logging\n'), ((1011, 1029), 'torch.distributions.Normal', 'dist.Norm... |
import datetime
import re
from dataclasses import dataclass
from typing import Optional
import requests
QUERY_ENDPOINT = "https://www.mvp.sos.ga.gov/MVP/voterDetails.do"
COUNTIES = {
"APPLING": "001",
"ATKINSON": "002",
"BACON": "003",
"BAKER": "004",
"BALDWIN": "005",
"BANKS": "006",
"BA... | [
"datetime.datetime.strptime",
"re.search"
] | [((4151, 4213), 're.search', 're.search', (['f"""<span id=[\'"]{spanid}[\'"]>([^<]*)</span>"""', 'html'], {}), '(f\'<span id=[\\\'"]{spanid}[\\\'"]>([^<]*)</span>\', html)\n', (4160, 4213), False, 'import re\n'), ((4298, 4386), 're.search', 're.search', (['f"""input type="hidden" name="idVoter" id="idVoter" value="(\\\... |
#!/usr/bin/env python3
import re
import json
"""
### PROCESS ###
1: Check for extensions from list of extensions and filter it out.
2: Split string at square brackets or paranthesis and form a list. (noBracketsList)
3: Clean each string in the list by removing common separators and trailing spaces.
4: Remove delimiter... | [
"re.split",
"re.escape"
] | [((6418, 6458), 're.split', 're.split', (['"""\\\\[|]|\\\\(|\\\\)"""', 'self.filename'], {}), "('\\\\[|]|\\\\(|\\\\)', self.filename)\n", (6426, 6458), False, 'import re\n'), ((7941, 7962), 're.escape', 're.escape', (['releaseVer'], {}), '(releaseVer)\n', (7950, 7962), False, 'import re\n'), ((10876, 10892), 're.escape... |
"""!Configures logging.
This module configures logging for stdout, stderr and the jlogfile.
It also contains the jlogger, a logger.Logger object that is used to
log directly to the jlogfile, and jlogdomain: a string name of the
logger domain for the jlogfile."""
##@var __all__
# Symbols epxorted by "from produtil.lo... | [
"logging.Formatter.__init__",
"logging.Formatter",
"sys.stderr.fileno",
"logging.setLoggerClass",
"os.path.dirname",
"sys.stderr.isatty",
"sys.stdout.fileno",
"os.path.exists",
"threading.current_thread",
"os.open",
"os.dup2",
"logging.StreamHandler",
"sys.stdout.isatty",
"logging.Handler.... | [((826, 855), 'logging.getLogger', 'logging.getLogger', (['jlogdomain'], {}), '(jlogdomain)\n', (843, 855), False, 'import logging, os, sys, traceback, threading\n'), ((12141, 12170), 'os.open', 'os.open', (['stdoutfile', 'openmode'], {}), '(stdoutfile, openmode)\n', (12148, 12170), False, 'import logging, os, sys, tra... |
import os
from subprocess import run
import pytest
@pytest.mark.parametrize(
"shell,expected",
(
pytest.param("zsh", "_mk_completion()", id="zsh"),
pytest.param("bash", "_mk_completion()", id="bash"),
),
)
def test_show_completion_script(shell, expected) -> None:
"""Tests completion s... | [
"subprocess.run",
"os.environ.copy",
"pytest.param"
] | [((351, 368), 'os.environ.copy', 'os.environ.copy', ([], {}), '()\n', (366, 368), False, 'import os\n'), ((417, 522), 'subprocess.run', 'run', (["['mk', '--show-completion']"], {'universal_newlines': '(True)', 'capture_output': '(True)', 'env': 'env', 'check': '(False)'}), "(['mk', '--show-completion'], universal_newli... |
from app_pypeach_django.application.helper.scrapy import ScrapyHelper, HttpErrorException, ScrapyIllegalException
from app_pypeach_django.test.test_base import UnitTestBase
"""
scrapyのテストです
"""
__author__ = "t.ebinuma"
__version__ = "1.0"
__date__ = "31 January 2019"
class TestScrapyHelper(UnitTestBase):
def te... | [
"app_pypeach_django.application.helper.scrapy.ScrapyHelper.is_exists_class_name",
"app_pypeach_django.application.helper.scrapy.ScrapyHelper.get_url_parameter",
"app_pypeach_django.application.helper.scrapy.ScrapyHelper.get_html"
] | [((411, 475), 'app_pypeach_django.application.helper.scrapy.ScrapyHelper.get_html', 'ScrapyHelper.get_html', (['"""http://mocjax.com/example/scrape/"""', '(True)'], {}), "('http://mocjax.com/example/scrape/', True)\n", (432, 475), False, 'from app_pypeach_django.application.helper.scrapy import ScrapyHelper, HttpErrorE... |
import asyncio
import configparser
import logging
import logging.config
import os
import re
import threading
import subprocess
import time
import PySimpleGUIQt as sg
import yaml
from pypresence import Presence
from watch import watch
CONFIGDEFAULT = {
"path.journaldir": os.environ["USERPROFILE"] + "/Saved Games/... | [
"threading.Thread",
"watch.watch",
"pypresence.Presence",
"subprocess.Popen",
"asyncio.new_event_loop",
"asyncio.set_event_loop",
"configparser.RawConfigParser",
"os.path.realpath",
"os.path.exists",
"logging.config.dictConfig",
"PySimpleGUIQt.SystemTray",
"re.search",
"logging.getLogger"
] | [((1272, 1299), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1289, 1299), False, 'import logging\n'), ((1451, 1481), 'configparser.RawConfigParser', 'configparser.RawConfigParser', ([], {}), '()\n', (1479, 1481), False, 'import configparser\n'), ((985, 1011), 'os.path.realpath', 'os.pa... |
from unicodedata import category
import unittest
from importlib_metadata import email
from app import db
from app.models import User, Pitch
class TestPitch(unittest.TestCase):
def setUp(self):
self.user_Cynthia = User(username = 'Cynthia', password = '<PASSWORD>', email = '<EMAIL>')
self.new_pitch... | [
"app.models.User",
"app.models.Pitch",
"app.models.Pitch.query.delete",
"app.models.Pitch.query.all",
"app.models.User.query.delete"
] | [((227, 291), 'app.models.User', 'User', ([], {'username': '"""Cynthia"""', 'password': '"""<PASSWORD>"""', 'email': '"""<EMAIL>"""'}), "(username='Cynthia', password='<PASSWORD>', email='<EMAIL>')\n", (231, 291), False, 'from app.models import User, Pitch\n'), ((323, 423), 'app.models.Pitch', 'Pitch', ([], {'title': '... |
#coding=utf-8
import sys
sys.path.append('script/')
import podPackageHelper
def main():
specName = sys.argv[1]
podPackageHelper.readpodspec(specName) #得到用户选择的spec中的tag prefix
podPackageHelper.getTagVersion() #获取用户输入的新版本号
specInfo = podPackageHelper.getSpecInfo()
oldVersion = specInfo['... | [
"sys.path.append",
"podPackageHelper.pushSpec",
"podPackageHelper.getSpecInfo",
"podPackageHelper.gitTagCommand",
"podPackageHelper.getTagVersion",
"podPackageHelper.writeNewVersionToSpec",
"podPackageHelper.runPodPushCommand",
"podPackageHelper.getRepoInfo",
"podPackageHelper.readpodspec"
] | [((25, 51), 'sys.path.append', 'sys.path.append', (['"""script/"""'], {}), "('script/')\n", (40, 51), False, 'import sys\n'), ((121, 159), 'podPackageHelper.readpodspec', 'podPackageHelper.readpodspec', (['specName'], {}), '(specName)\n', (149, 159), False, 'import podPackageHelper\n'), ((191, 223), 'podPackageHelper.g... |
'''
Created on May 9, 2019
@author: gsq
Trains and evaluates rank-one network
'''
import sys
sys.path.append('../')
import argparse
import os.path
import time
import logging
import tensorflow as tf
import numpy as np
from common.load_DIV2K import Dataloader
from RODec_model import RODec
logging.basicConfig(level=l... | [
"tensorflow.gfile.Exists",
"argparse.ArgumentParser",
"tensorflow.trainable_variables",
"tensorflow.variables_initializer",
"time.strftime",
"tensorflow.global_variables",
"tensorflow.Variable",
"RODec_model.RODec.__init__",
"sys.path.append",
"common.load_DIV2K.Dataloader",
"tensorflow.placehol... | [((95, 117), 'sys.path.append', 'sys.path.append', (['"""../"""'], {}), "('../')\n", (110, 117), False, 'import sys\n'), ((293, 332), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (312, 332), False, 'import logging\n'), ((342, 369), 'logging.getLogger', 'loggin... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import pyglet
from pyglet.app.base import EventLoop
class Mainloop(EventLoop):
def __init__(self):
EventLoop.__init__(self)
def idle(self):
dt = self.clock.update_time()
self.clock.call_scheduled_functions(dt)
try:
for... | [
"pyglet.app.base.EventLoop.__init__"
] | [((159, 183), 'pyglet.app.base.EventLoop.__init__', 'EventLoop.__init__', (['self'], {}), '(self)\n', (177, 183), False, 'from pyglet.app.base import EventLoop\n')] |
# Generated by Django 2.1.11 on 2019-11-13 22:40
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('configurations', '0024_remove_d3mconfiguration_problem_root'),
]
operations = [
migrations.AddField(
model_name='d3mconfigurati... | [
"django.db.models.BooleanField"
] | [((385, 480), 'django.db.models.BooleanField', 'models.BooleanField', ([], {'default': '(True)', 'help_text': '"""The user may choose this datast from a list"""'}), "(default=True, help_text=\n 'The user may choose this datast from a list')\n", (404, 480), False, 'from django.db import migrations, models\n')] |
from common.libs.harri_db import db_session
__author__ = 'omar'
class DBSessionMiddleware(object):
def process_response(self, request, response):
db_session.remove()
return response
| [
"common.libs.harri_db.db_session.remove"
] | [((170, 189), 'common.libs.harri_db.db_session.remove', 'db_session.remove', ([], {}), '()\n', (187, 189), False, 'from common.libs.harri_db import db_session\n')] |
"""
migro.uploader.utils
~~~~~~~~~~~~~~~~~~~~
Helpers functions.
"""
import hashlib
import hmac
import time
from aiohttp import ClientSession, TCPConnector
from asyncio import get_event_loop
from urllib.parse import urljoin
from migro import settings
from aiohttp import ClientSession, TCPConnector
fr... | [
"asyncio.get_event_loop",
"urllib.parse.urljoin",
"hmac.new",
"time.time",
"aiohttp.TCPConnector"
] | [((353, 369), 'asyncio.get_event_loop', 'get_event_loop', ([], {}), '()\n', (367, 369), False, 'from asyncio import get_event_loop\n'), ((706, 741), 'urllib.parse.urljoin', 'urljoin', (['settings.UPLOAD_BASE', 'path'], {}), '(settings.UPLOAD_BASE, path)\n', (713, 741), False, 'from urllib.parse import urljoin\n'), ((40... |
import json
import pathlib
import threading
import time
import click
import urlpath
from cortex.parser import repository
from cortex.utils import logging,\
dispatchers
from cortex.core import snapshot_xcoder
from cortex.utils.plugin_runner import PluginRunner
module_logger = logging.get... | [
"click.argument",
"cortex.parser.repository.Repository.get",
"time.sleep",
"cortex.utils.dispatchers.repository.ConsumerRepository.get_repo",
"cortex.utils.logging.log_exception",
"pathlib.Path",
"click.Path",
"cortex.utils.logging.get_logger",
"click.group",
"cortex.utils.dispatchers.repository.D... | [((309, 337), 'cortex.utils.logging.get_logger', 'logging.get_logger', (['__file__'], {}), '(__file__)\n', (327, 337), False, 'from cortex.utils import logging, dispatchers\n'), ((340, 362), 'click.group', 'click.group', (['"""parsers"""'], {}), "('parsers')\n", (351, 362), False, 'import click\n'), ((408, 430), 'click... |
import logging
import torch
from torch import nn
from torchvision.models import detection
class MaskRCNN(nn.Module):
@staticmethod
def load(state_dict):
# todo(will.brennan) - improve this... might want to save a categories file with this instead
category_prefix = '_categories.'
categ... | [
"torchvision.models.detection.faster_rcnn.FastRCNNPredictor",
"logging.debug",
"torchvision.models.detection.maskrcnn_resnet50_fpn",
"logging.info",
"torch.Tensor",
"torchvision.models.detection.mask_rcnn.MaskRCNNPredictor"
] | [((633, 694), 'logging.info', 'logging.info', (['f"""creating model with categories: {categories}"""'], {}), "(f'creating model with categories: {categories}')\n", (645, 694), False, 'import logging\n'), ((959, 1007), 'torchvision.models.detection.maskrcnn_resnet50_fpn', 'detection.maskrcnn_resnet50_fpn', ([], {'pretra... |
import unicodedata
from pyglet.window import key
from pyglet.libs.darwin.cocoapy import *
NSArray = ObjCClass('NSArray')
NSApplication = ObjCClass('NSApplication')
# This custom NSTextView subclass is used for capturing all of the
# on_text, on_text_motion, and on_text_motion_select events.
class PygletTextView_Imp... | [
"unicodedata.category"
] | [((1262, 1291), 'unicodedata.category', 'unicodedata.category', (['text[0]'], {}), '(text[0])\n', (1282, 1291), False, 'import unicodedata\n')] |
import mileage_calculator as MC
def main():
input_destination = str(input("What is your destination? 📍 "))
input_mileage = float(input("What is your mileage? 🚗 "))
input_gas_price = float(input("What is the gas price? 💵 "))
input_tank_size = float(input("What is your tank size? 🛢 "))
output ... | [
"mileage_calculator.Trip"
] | [((318, 393), 'mileage_calculator.Trip', 'MC.Trip', (['input_destination', 'input_mileage', 'input_gas_price', 'input_tank_size'], {}), '(input_destination, input_mileage, input_gas_price, input_tank_size)\n', (325, 393), True, 'import mileage_calculator as MC\n')] |
import os
from abc import abstractmethod
from pippin.config import get_output_loc, get_data_loc
from pippin.dataprep import DataPrep
from pippin.task import Task
from pippin.snana_sim import SNANASimulation
from pippin.snana_fit import SNANALightCurveFit
class Classifier(Task):
""" Classification task
CONFI... | [
"pippin.task.Task.logger.info",
"pippin.config.get_output_loc",
"pippin.classifiers.factory.ClassifierFactory.get",
"os.path.dirname",
"pippin.task.Task.fail_config",
"os.path.exists",
"pippin.task.Task.get_task_of_type",
"pippin.task.Task.logger.warn",
"pippin.config.get_data_loc"
] | [((5381, 5435), 'pippin.task.Task.get_task_of_type', 'Task.get_task_of_type', (['prior_tasks', 'SNANALightCurveFit'], {}), '(prior_tasks, SNANALightCurveFit)\n', (5402, 5435), False, 'from pippin.task import Task\n'), ((5456, 5517), 'pippin.task.Task.get_task_of_type', 'Task.get_task_of_type', (['prior_tasks', 'DataPre... |
import os
import torch
import torch.nn as nn
from torch.utils.data import Dataset
from utils.processing import get_features
from utils.variables import *
class ProteinDataset(Dataset):
def __init__(self, pdbids, coord_dir, device="cpu"):
self.pdbids = pdbids
self.coord_dir = coord_dir
self... | [
"torch.nn.ReLU",
"utils.processing.get_features",
"torch.nn.Sequential",
"torch.nn.LayerNorm",
"torch.nn.Linear",
"os.path.join"
] | [((474, 531), 'os.path.join', 'os.path.join', (['self.coord_dir', "(self.pdbids[index] + '.txt')"], {}), "(self.coord_dir, self.pdbids[index] + '.txt')\n", (486, 531), False, 'import os\n'), ((547, 583), 'utils.processing.get_features', 'get_features', (['fp'], {'device': 'self.device'}), '(fp, device=self.device)\n', ... |
from django.db import models
from django.contrib.auth.models import User
class Script(models.Model):
name = models.CharField(max_length=100, unique=True)
code = models.TextField()
def __unicode__(self):
return self.name
| [
"django.db.models.CharField",
"django.db.models.TextField"
] | [((111, 156), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(100)', 'unique': '(True)'}), '(max_length=100, unique=True)\n', (127, 156), False, 'from django.db import models\n'), ((166, 184), 'django.db.models.TextField', 'models.TextField', ([], {}), '()\n', (182, 184), False, 'from django.db ... |
import numpy as np
from matplotlib import pyplot as plt
from ..Xfit.MCMC_straight_line import mcmc_sl
from ..Xfit.fit_basic import fit_basic
from ..Xfit.FitPoissonGamma import fit_pg
from ..Xplot.niceplot import niceplot
from matplotlib.offsetbox import AnchoredText
from matplotlib import ticker
from ..misc.running_mea... | [
"numpy.std",
"numpy.ones",
"numpy.histogram",
"numpy.mean",
"numpy.array",
"numpy.arange",
"numpy.diff",
"matplotlib.colors.LogNorm",
"numpy.where"
] | [((1376, 1415), 'numpy.histogram', 'np.histogram', (['x'], {'bins': '(100)', 'density': '(True)'}), '(x, bins=100, density=True)\n', (1388, 1415), True, 'import numpy as np\n'), ((1567, 1586), 'numpy.array', 'np.array', (['[0, ymax]'], {}), '([0, ymax])\n', (1575, 1586), True, 'import numpy as np\n'), ((5477, 5501), 'n... |
from sqlalchemy import Column, Date, Float, ForeignKey, Integer, String
from sqlalchemy.orm import declarative_base, relationship
Base = declarative_base()
# TODO: Learn ALembic and implement a schema update option without data loss.
class ShoppingList(Base):
__tablename__ = 'shopping_list'
id = Column(Int... | [
"sqlalchemy.orm.relationship",
"sqlalchemy.Column",
"sqlalchemy.ForeignKey",
"sqlalchemy.orm.declarative_base"
] | [((138, 156), 'sqlalchemy.orm.declarative_base', 'declarative_base', ([], {}), '()\n', (154, 156), False, 'from sqlalchemy.orm import declarative_base, relationship\n'), ((310, 343), 'sqlalchemy.Column', 'Column', (['Integer'], {'primary_key': '(True)'}), '(Integer, primary_key=True)\n', (316, 343), False, 'from sqlalc... |
#!/usr/bin/env python3
import os
import sys
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
prefix = sys.argv[1]
filenames = [f for f in os.listdir(".") if f.startswith(prefix) and f.endswith(".csv")]
_, ax = plt.subplots(1)
y_acc = None
for filename in filenames:
df = pd.read_csv(filenam... | [
"matplotlib.pyplot.title",
"pandas.read_csv",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.subplots",
"os.listdir",
"matplotlib.pyplot.savefig"
] | [((235, 250), 'matplotlib.pyplot.subplots', 'plt.subplots', (['(1)'], {}), '(1)\n', (247, 250), True, 'import matplotlib.pyplot as plt\n'), ((1622, 1653), 'matplotlib.pyplot.title', 'plt.title', (['"""Class-IL on EMNIST"""'], {}), "('Class-IL on EMNIST')\n", (1631, 1653), True, 'import matplotlib.pyplot as plt\n'), ((1... |
from schematics import Model
from schematics.types import StringType, IntType, BooleanType, ModelType, FloatType
class DiskTags(Model):
volume_id = StringType(serialize_when_none=False)
volume_type = StringType(choices=('standard', 'io1', 'gp2', 'gp3', 'sc1', 'st1'),
serialize_whe... | [
"schematics.types.IntType",
"schematics.types.BooleanType",
"schematics.types.FloatType",
"schematics.types.StringType",
"schematics.types.ModelType"
] | [((154, 191), 'schematics.types.StringType', 'StringType', ([], {'serialize_when_none': '(False)'}), '(serialize_when_none=False)\n', (164, 191), False, 'from schematics.types import StringType, IntType, BooleanType, ModelType, FloatType\n'), ((210, 308), 'schematics.types.StringType', 'StringType', ([], {'choices': "(... |
from django.conf.urls import url
from django.contrib import admin
from django.contrib.auth import views as auth_views
from django.views.generic.base import TemplateView
import UserActions.views as my_views
app_name = "user"
urlpatterns = [
url(r'^$', TemplateView.as_view(template_name='index.html'), name='home'),... | [
"django.views.generic.base.TemplateView.as_view",
"django.conf.urls.url"
] | [((325, 379), 'django.conf.urls.url', 'url', (['"""^my_login/$"""', 'my_views.my_login'], {'name': '"""my_login"""'}), "('^my_login/$', my_views.my_login, name='my_login')\n", (328, 379), False, 'from django.conf.urls import url\n'), ((386, 443), 'django.conf.urls.url', 'url', (['"""^my_logout/$"""', 'my_views.my_logou... |
import networking
from threading import Thread
class GameServer:
def __init__(self, ip: str, port: int):
self.ip = ip
self.port = port
self.server = networking.NetworkingServer(ip, port)
self.players: dict[str, tuple[int, int]] = {}
# start player updater
players... | [
"threading.Thread",
"networking.NetworkingServer"
] | [((180, 217), 'networking.NetworkingServer', 'networking.NetworkingServer', (['ip', 'port'], {}), '(ip, port)\n', (207, 217), False, 'import networking\n'), ((331, 375), 'threading.Thread', 'Thread', ([], {'target': 'self.pos_updater', 'daemon': '(True)'}), '(target=self.pos_updater, daemon=True)\n', (337, 375), False,... |
import json
import requests
from cryptojwt.key_jar import KeyJar
from oidcmsg.message import Message
issuer = "https://127.0.0.1:8000"
issuer_metadata_url = '{}/.well-known/openid-configuration'.format(issuer)
issuer_metadata = requests.get(issuer_metadata_url, verify=False).text
issuer_jwks_uri = json.loads(issuer_... | [
"cryptojwt.key_jar.KeyJar",
"oidcmsg.message.Message",
"json.loads",
"requests.get"
] | [((410, 430), 'json.loads', 'json.loads', (['jwks_raw'], {}), '(jwks_raw)\n', (420, 430), False, 'import json\n'), ((458, 466), 'cryptojwt.key_jar.KeyJar', 'KeyJar', ([], {}), '()\n', (464, 466), False, 'from cryptojwt.key_jar import KeyJar\n'), ((231, 278), 'requests.get', 'requests.get', (['issuer_metadata_url'], {'v... |
#!src/env/bin/python
"""Initialize and launch the MTT REST server."""
import logging
import os
import signal
import socket
import sys
import cherrypy
from cherrypy.process.plugins import Daemonizer, PIDFile
from configobj import ConfigObj
from validate import Validator
from webapp.dispatchers import Root, Submit, F... | [
"webapp.dispatchers.Submit",
"configobj.ConfigObj",
"logging.Formatter",
"cherrypy.process.plugins.PIDFile",
"cherrypy.process.plugins.Daemonizer",
"webapp.dispatchers.Detail",
"logging.FileHandler",
"cherrypy.engine.restart",
"cherrypy.config.update",
"socket.gethostname",
"webapp.dispatchers.R... | [((1004, 1028), 'logging.getLogger', 'logging.getLogger', (['"""mtt"""'], {}), "('mtt')\n", (1021, 1028), False, 'import logging\n'), ((1074, 1096), 'cherrypy.engine.exit', 'cherrypy.engine.exit', ([], {}), '()\n', (1094, 1096), False, 'import cherrypy\n'), ((1128, 1139), 'sys.exit', 'sys.exit', (['(0)'], {}), '(0)\n',... |
# Copyright (c) 2019, <NAME>
# License: MIT-License
# Created: 2019-03-11
from typing import TYPE_CHECKING, List, Sequence, Iterable
from ezdxf.lldxf.const import SUBCLASS_MARKER, DXFStructureError, DXF2010, DXFTypeError
from ezdxf.lldxf.attributes import DXFAttributes, DefSubclass, DXFAttr, XType
from ezdxf.lldxf.pack... | [
"ezdxf.lldxf.const.DXFStructureError",
"ezdxf.lldxf.const.DXFTypeError",
"ezdxf.lldxf.attributes.DXFAttributes",
"ezdxf.lldxf.attributes.DXFAttr",
"ezdxf.math.vector.Vector"
] | [((3601, 3641), 'ezdxf.lldxf.attributes.DXFAttributes', 'DXFAttributes', (['base_class', 'acdb_geo_data'], {}), '(base_class, acdb_geo_data)\n', (3614, 3641), False, 'from ezdxf.lldxf.attributes import DXFAttributes, DefSubclass, DXFAttr, XType\n'), ((749, 771), 'ezdxf.lldxf.attributes.DXFAttr', 'DXFAttr', (['(90)'], {... |
from django.db import models
from django.conf import settings
class Question(models.Model):
"""
Questions are written by users and they can have multiple answers.
Each question is identified by the 'slug' field.
"""
author = models.ForeignKey(settings.AUTH_USER_MODEL, on_delete=models.CASCADE, re... | [
"django.db.models.TextField",
"django.db.models.ManyToManyField",
"django.db.models.ForeignKey",
"django.db.models.CharField",
"django.db.models.SlugField",
"django.db.models.DateTimeField"
] | [((248, 347), 'django.db.models.ForeignKey', 'models.ForeignKey', (['settings.AUTH_USER_MODEL'], {'on_delete': 'models.CASCADE', 'related_name': '"""questions"""'}), "(settings.AUTH_USER_MODEL, on_delete=models.CASCADE,\n related_name='questions')\n", (265, 347), False, 'from django.db import models\n'), ((358, 390)... |
from db.dbSession.abstractSession import AbstractSession
from db.models.kanji import Kanji, KanjiAlternative, Onyomi, Kunyomi
class KanjiSession(AbstractSession):
def addKanji(self, KanjiData):
with self.session_scope() as session:
kanji = Kanji(KanjiData.name, KanjiData.primary,
... | [
"db.models.kanji.Kunyomi",
"db.models.kanji.KanjiAlternative",
"db.models.kanji.Kanji",
"db.models.kanji.Onyomi"
] | [((266, 343), 'db.models.kanji.Kanji', 'Kanji', (['KanjiData.name', 'KanjiData.primary', 'KanjiData.progress', 'KanjiData.level'], {}), '(KanjiData.name, KanjiData.primary, KanjiData.progress, KanjiData.level)\n', (271, 343), False, 'from db.models.kanji import Kanji, KanjiAlternative, Onyomi, Kunyomi\n'), ((511, 542),... |
# -*- coding: utf-8 -*-
#
# Copyright (C) 2006-2007 <NAME> <<EMAIL>>
#
# This software is licensed as described in the file COPYING, which
# you should have received as part of this distribution.
#
"""CLY exception hierarchy."""
import string
__all__ = ['Error', 'InvalidHelp', 'InvalidNodePath', 'InvalidAnonymousN... | [
"doctest.testmod",
"string.Template"
] | [((2464, 2481), 'doctest.testmod', 'doctest.testmod', ([], {}), '()\n', (2479, 2481), False, 'import doctest\n'), ((1564, 1604), 'string.Template', 'string.Template', (['(message or self.message)'], {}), '(message or self.message)\n', (1579, 1604), False, 'import string\n')] |
#!/usr/bin/python
# -*- coding: utf-8 -*-
# ************************************************************
# Copyright © 2019-2021 Acronis International GmbH.
# This source code is distributed under MIT software license.
# ************************************************************
import json # used for manipulatin... | [
"os.path.dirname",
"sys.path.insert",
"json.dumps",
"common.base_operations.Config",
"os.path.join",
"common.base_operations.Acronis"
] | [((520, 549), 'sys.path.insert', 'sys.path.insert', (['(0)', 'base_path'], {}), '(0, base_path)\n', (535, 549), False, 'import sys\n'), ((735, 752), 'common.base_operations.Config', 'Config', ([], {'full': '(True)'}), '(full=True)\n', (741, 752), False, 'from common.base_operations import Config, BearerAuth, Tenant, Us... |
import torch
import gym
import network_sim
import args
# from stable_baselines.common.policies import MlpPolicy
# from stable_baselines3.common.policies import FeedForwardPolicy
from stable_baselines3.common.torch_layers import MlpExtractor
from stable_baselines3 import PPO
from stable_baselines3.common.policies import... | [
"stable_baselines3.PPO.load",
"os.mkdir",
"gym.make",
"os.path.exists",
"args.get_args",
"os.path.join"
] | [((573, 588), 'args.get_args', 'args.get_args', ([], {}), '()\n', (586, 588), False, 'import args\n'), ((1824, 1856), 'os.path.join', 'os.path.join', (['log_path', '"""models"""'], {}), "(log_path, 'models')\n", (1836, 1856), False, 'import os\n'), ((1869, 1900), 'os.path.join', 'os.path.join', (['log_path', '"""jsons"... |
# Copyright (c) 2019, ACE IoT Solutions LLC.
# 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 copyright notice, this
# list of conditi... | [
"grequests.get",
"copy.deepcopy",
"xml.etree.ElementTree.fromstring",
"logging.getLogger",
"time.time",
"grequests.map"
] | [((1879, 1909), 'logging.getLogger', 'logging.getLogger', (['"""ted_meter"""'], {}), "('ted_meter')\n", (1896, 1909), False, 'import logging\n'), ((6603, 6614), 'time.time', 'time.time', ([], {}), '()\n', (6612, 6614), False, 'import time\n'), ((7921, 7939), 'grequests.map', 'grequests.map', (['req'], {}), '(req)\n', (... |
# Generated by the protocol buffer compiler. DO NOT EDIT!
# source: hello.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 google.protobuf import reflection as _reflect... | [
"google.protobuf.symbol_database.Default",
"google.protobuf.descriptor.FieldDescriptor",
"google.protobuf.descriptor_pb2.FileOptions",
"google.protobuf.descriptor.MethodDescriptor"
] | [((478, 504), 'google.protobuf.symbol_database.Default', '_symbol_database.Default', ([], {}), '()\n', (502, 504), True, 'from google.protobuf import symbol_database as _symbol_database\n'), ((6542, 6570), 'google.protobuf.descriptor_pb2.FileOptions', 'descriptor_pb2.FileOptions', ([], {}), '()\n', (6568, 6570), False,... |
# This file is part of the Data Cleaning Library (openclean).
#
# Copyright (C) 2018-2021 New York University.
#
# openclean is released under the Revised BSD License. See file LICENSE for
# full license details.
"""Unit tests for basic token list transformers."""
import pytest
from openclean.function.token.base im... | [
"openclean.function.token.base.UpperTokens",
"openclean.function.token.base.LowerTokens",
"openclean.function.token.base.StandardizeTokens",
"openclean.function.token.base.SortTokens",
"openclean.function.token.base.TokenPrefix",
"openclean.function.token.base.ReverseTokens",
"openclean.function.token.b... | [((1398, 1428), 'openclean.function.token.base.SortTokens', 'SortTokens', ([], {'key': '(lambda x: x[1])'}), '(key=lambda x: x[1])\n', (1408, 1428), False, 'from openclean.function.token.base import CapitalizeTokens, LowerTokens, ReverseTokens, SortTokens, StandardizeTokens, Token, TokenPrefix, TokenTransformerPipeline... |
from typing import Optional
import numpy as np
from xarray import Dataset
from .api import create_genotype_call_dataset
from .utils import split_array_chunks
def simulate_genotype_call_dataset(
n_variant: int,
n_sample: int,
n_ploidy: int = 2,
n_allele: int = 2,
n_contig: int = 1,
seed: Opti... | [
"numpy.unique",
"numpy.arange",
"numpy.random.RandomState"
] | [((1451, 1483), 'numpy.random.RandomState', 'np.random.RandomState', ([], {'seed': 'seed'}), '(seed=seed)\n', (1472, 1483), True, 'import numpy as np\n'), ((1729, 1746), 'numpy.unique', 'np.unique', (['contig'], {}), '(contig)\n', (1738, 1746), True, 'import numpy as np\n'), ((1676, 1695), 'numpy.arange', 'np.arange', ... |