code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
"""Views for the irodsbackend app"""
import logging
from django.conf import settings
from django.http import JsonResponse
from rest_framework.exceptions import NotAuthenticated
from rest_framework.response import Response
from rest_framework.views import APIView
from sodar.users.auth import fallback_to_auth_basic
... | [
"logging.getLogger",
"django.http.JsonResponse",
"projectroles.plugins.get_backend_api",
"projectroles.models.RoleAssignment.objects.get_assignment",
"rest_framework.response.Response",
"rest_framework.exceptions.NotAuthenticated"
] | [((531, 558), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (548, 558), False, 'import logging\n'), ((2263, 2320), 'projectroles.models.RoleAssignment.objects.get_assignment', 'RoleAssignment.objects.get_assignment', (['user', 'self.project'], {}), '(user, self.project)\n', (2300, 2320),... |
# This file is part of the pyMOR project (http://www.pymor.org).
# Copyright Holders: <NAME>, <NAME>, <NAME>
# License: BSD 2-Clause License (http://opensource.org/licenses/BSD-2-Clause)
from __future__ import absolute_import, division, print_function
import numpy as np
import pytest
from pymor.operators.numpy impor... | [
"numpy.eye",
"pymor.operators.constructions.Concatenation",
"numpy.random.random",
"pymor.operators.cg.InterpolationOperator",
"pymor.operators.constructions.FixedParameterOperator",
"pymor.discretizers.elliptic.discretize_elliptic_cg",
"numpy.random.randint",
"numpy.random.seed",
"pytest.fixture",
... | [((9939, 10545), 'pytest.fixture', 'pytest.fixture', ([], {'params': '(thermalblock_operator_with_arrays_and_products_generators +\n thermalblock_assemble_operator_with_arrays_and_products_generators +\n thermalblock_concatenation_operator_with_arrays_and_products_generators +\n thermalblock_identity_operator_... |
# test stm module
import stm
import pyb
# test storing a full 32-bit number
# turn on then off the A15(=yellow) LED
BSRR = 0x18
stm.mem32[stm.GPIOA + BSRR] = 0x00008000
pyb.delay(100)
print(hex(stm.mem32[stm.GPIOA + stm.GPIO_ODR] & 0x00008000))
stm.mem32[stm.GPIOA + BSRR] = 0x80000000
print(hex(stm.mem32[stm.GPIOA + ... | [
"pyb.delay"
] | [((171, 185), 'pyb.delay', 'pyb.delay', (['(100)'], {}), '(100)\n', (180, 185), False, 'import pyb\n')] |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Jun 11 23:41:29 2021
"""
from PyOECP import References
from PyOECP import Transform
import matplotlib.pyplot as plt
import numpy as np
''' Example 1 Methanol
This script tries to convert the reflection coefficients from VNAs.
The data files and VNAs ar... | [
"PyOECP.References.Methanol_Barthel",
"matplotlib.pyplot.savefig",
"PyOECP.Transform.Stuchly",
"numpy.imag",
"PyOECP.References.Parser",
"PyOECP.Transform.Marsland",
"numpy.real",
"PyOECP.Transform.Komarov",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.rc"
] | [((527, 570), 'PyOECP.References.Parser', 'References.Parser', (["(address + 'S11Short.csv')"], {}), "(address + 'S11Short.csv')\n", (544, 570), False, 'from PyOECP import References\n'), ((579, 621), 'PyOECP.References.Parser', 'References.Parser', (["(address + 'S11Open.csv')"], {}), "(address + 'S11Open.csv')\n", (5... |
import torch
import numpy as np
import torch.nn as nn
import cv2
from scipy import signal
import imageio
from PIL import Image
import os
import os.path as osp
import numbers
import math
from torch.nn import functional as F
'''
convert image to tensor and back
'''
img = imageio.imread(pth, pilmode='RG... | [
"numpy.random.normal",
"torch.nn.functional.pad",
"PIL.Image.fromarray",
"os.path.join",
"math.sqrt",
"torch.from_numpy",
"numpy.ascontiguousarray",
"torch.exp",
"PIL.Image.from_numpy",
"torch.arange",
"torch.sum",
"imageio.imread",
"torch.clamp"
] | [((289, 323), 'imageio.imread', 'imageio.imread', (['pth'], {'pilmode': '"""RGB"""'}), "(pth, pilmode='RGB')\n", (303, 323), False, 'import imageio\n'), ((804, 825), 'PIL.Image.from_numpy', 'Image.from_numpy', (['img'], {}), '(img)\n', (820, 825), False, 'from PIL import Image\n'), ((2836, 2879), 'torch.nn.functional.p... |
#! /usr/bin/env python
import rospy
from session_two.msg import ListInt
from geometry_msgs.msg import TransformStamped
import tf2_ros
from std_srvs.srv import Empty, EmptyResponse
count = 0
f = 0
way_points = []
def input_callback(data):
global f
global way_points
way_points = data.data
if f == 0:
... | [
"geometry_msgs.msg.TransformStamped",
"std_srvs.srv.EmptyResponse",
"rospy.init_node",
"rospy.Service",
"rospy.Time.now",
"tf2_ros.StaticTransformBroadcaster",
"rospy.spin",
"rospy.Subscriber",
"rospy.loginfo"
] | [((1158, 1216), 'rospy.Subscriber', 'rospy.Subscriber', (['"""/set_waypoint"""', 'ListInt', 'input_callback'], {}), "('/set_waypoint', ListInt, input_callback)\n", (1174, 1216), False, 'import rospy\n'), ((1215, 1243), 'rospy.init_node', 'rospy.init_node', (['"""flag_bear"""'], {}), "('flag_bear')\n", (1230, 1243), Fal... |
# This file is part of the Blockchain Data Trading Simulator
# https://gitlab.com/MatthiasLohr/bdtsim
#
# Copyright 2020 <NAME> <<EMAIL>>
#
# 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
#
... | [
"bdtsim.account.Account",
"bdtsim.account_related_diff_collection.FundsDiffCollection"
] | [((821, 912), 'bdtsim.account.Account', 'Account', (['"""Seller"""', '"""0x3f2c7f45cb3014e2b9d12b7fb331bdfdad6170ce5e4a0d94890aa64162569756"""'], {}), "('Seller',\n '0x3f2c7f45cb3014e2b9d12b7fb331bdfdad6170ce5e4a0d94890aa64162569756')\n", (828, 912), False, 'from bdtsim.account import Account\n'), ((917, 1007), 'bdt... |
# imports
import sys
import argparse
from gaevol import gaevol
parser = argparse.ArgumentParser(description="Enter string you want to see evolve:")
parser.add_argument("string", help="Add string without number and special characters")
parser.add_argument("populate", help="Enter poplation of each Generation")
parser.ad... | [
"gaevol.gaevol",
"argparse.ArgumentParser"
] | [((73, 148), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Enter string you want to see evolve:"""'}), "(description='Enter string you want to see evolve:')\n", (96, 148), False, 'import argparse\n'), ((569, 614), 'gaevol.gaevol', 'gaevol', (['sys.argv[1]', 'sys.argv[2]', 'sys.argv[3]']... |
import os
import statsd
STATS_URL = os.environ['STATS_URL']
STATS_PORT = int(os.environ['STATS_PORT'])
stats_client = statsd.StatsClient(STATS_URL, STATS_PORT,prefix='notisrvr')
class StatsD:
stats_client = stats_client
@staticmethod
def timer(stat_name, start_time, tags: dict = {}):
stats_cli... | [
"statsd.StatsClient"
] | [((121, 181), 'statsd.StatsClient', 'statsd.StatsClient', (['STATS_URL', 'STATS_PORT'], {'prefix': '"""notisrvr"""'}), "(STATS_URL, STATS_PORT, prefix='notisrvr')\n", (139, 181), False, 'import statsd\n')] |
from django.db import models
from django.core.validators import MaxValueValidator, MinValueValidator, URLValidator
from django.utils.safestring import mark_safe
import codecs
import markdown
# Author Model
# 或为多作者铺路
class Author(models.Model):
author = models.CharField(max_length=40)
def __str__(self):
... | [
"markdown.markdown",
"django.core.validators.URLValidator",
"django.core.validators.MaxValueValidator",
"django.db.models.ManyToManyField",
"django.db.models.FileField",
"django.db.models.BooleanField",
"django.db.models.ImageField",
"django.db.models.PositiveIntegerField",
"django.utils.safestring.... | [((259, 290), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(40)'}), '(max_length=40)\n', (275, 290), False, 'from django.db import models\n'), ((489, 520), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(40)'}), '(max_length=40)\n', (505, 520), False, 'from django.db im... |
"""
Sugarscape Constant Growback Model
================================
Replication of the model found in Netlogo:
<NAME>. and <NAME>. (2009). NetLogo Sugarscape 2 Constant Growback model.
http://ccl.northwestern.edu/netlogo/models/Sugarscape2ConstantGrowback.
Center for Connected Learning and Computer-Based Modeling,... | [
"os.makedirs",
"mesa.space.MultiGrid",
"datetime.datetime.now",
"numpy.ndarray",
"numpy.genfromtxt"
] | [((1655, 1702), 'mesa.space.MultiGrid', 'MultiGrid', (['self.height', 'self.width'], {'torus': '(False)'}), '(self.height, self.width, torus=False)\n', (1664, 1702), False, 'from mesa.space import MultiGrid\n'), ((2133, 2167), 'numpy.genfromtxt', 'np.genfromtxt', (['"""src/sugar-map.txt"""'], {}), "('src/sugar-map.txt'... |
from requests import Session
from requests.adapters import HTTPAdapter
from urllib3 import Retry
class RetrySession(Session):
def __init__(self, retries=3, backoff_factor=0.5, status_forcelist=None):
super().__init__()
retry = Retry(total=retries, read=retries, backoff_factor=backoff_factor, statu... | [
"urllib3.Retry",
"requests.adapters.HTTPAdapter"
] | [((249, 353), 'urllib3.Retry', 'Retry', ([], {'total': 'retries', 'read': 'retries', 'backoff_factor': 'backoff_factor', 'status_forcelist': 'status_forcelist'}), '(total=retries, read=retries, backoff_factor=backoff_factor,\n status_forcelist=status_forcelist)\n', (254, 353), False, 'from urllib3 import Retry\n'), ... |
#!/usr/bin/env python3
from tree import *
class BSTIterator(object):
def __init__(self, root):
"""
:type root: TreeNode
"""
from collections import deque
self.stack = deque()
while root:
self.stack.append(root)
root = root.left
def next... | [
"collections.deque"
] | [((214, 221), 'collections.deque', 'deque', ([], {}), '()\n', (219, 221), False, 'from collections import deque\n')] |
# -*- coding: utf-8 -*-
# Copyright (c) 2016, 2017, 2018, 2019 Sqreen. All rights reserved.
# Please refer to our terms for more information:
#
# https://www.sqreen.io/terms.html
#
import logging
from ..actions import ACTION_STORE, ActionName
from ..ip_radix import Radix
from ..rules import RuleCallback
from ..sd... | [
"logging.getLogger"
] | [((346, 373), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (363, 373), False, 'import logging\n')] |
from collections.abc import Callable, Iterable, Mapping
from scipy.sparse import csr_matrix, csc_matrix
from scipy.sparse.linalg import expm
import cupy as cp
import math
import neuwon.species.voronoi
import numba.cuda
import numpy as np
F = 96485.3321233100184 # Faraday's constant, Coulombs per Mole of electrons
R = ... | [
"numpy.abs",
"cupy.get_array_module",
"numpy.array",
"cupy.maximum",
"cupy.fuse",
"math.exp"
] | [((13008, 13017), 'cupy.fuse', 'cp.fuse', ([], {}), '()\n', (13015, 13017), True, 'import cupy as cp\n'), ((12327, 12368), 'cupy.get_array_module', 'cp.get_array_module', (['inside_concentration'], {}), '(inside_concentration)\n', (12346, 12368), True, 'import cupy as cp\n'), ((12606, 12647), 'cupy.get_array_module', '... |
from functools import lru_cache
from math import floor
from problem import Problem
from utils.math import product
class ChampernownesConstant(Problem, name="Champernowne's constant", expected=210):
@classmethod
def naive_nth_champ(cls, n: int):
c = ''
for _ in range(1, n):
c += st... | [
"functools.lru_cache",
"problem.Problem.solution"
] | [((425, 436), 'functools.lru_cache', 'lru_cache', ([], {}), '()\n', (434, 436), False, 'from functools import lru_cache\n'), ((977, 995), 'problem.Problem.solution', 'Problem.solution', ([], {}), '()\n', (993, 995), False, 'from problem import Problem\n')] |
import os
import argparse
import tensorflow as tf ## tf.1.12
def parse_args():
parser = argparse.ArgumentParser(description="Tensorflow pb to tflite convert tools.")
parser.add_argument('--pb', '-p', type=str,
default='resnet34_tf.22.5.nhwc.pb',
help='path to pb model.')
parser.add... | [
"tensorflow.contrib.lite.TocoConverter.from_frozen_graph",
"argparse.ArgumentParser"
] | [((93, 170), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Tensorflow pb to tflite convert tools."""'}), "(description='Tensorflow pb to tflite convert tools.')\n", (116, 170), False, 'import argparse\n'), ((641, 714), 'tensorflow.contrib.lite.TocoConverter.from_frozen_graph', 'tf.contr... |
"""
Module for running FaIR
"""
import logging
import multiprocessing
from concurrent.futures import ProcessPoolExecutor
import numpy as np
from scmdata import ScmRun, run_append
from ...settings import config
from ..utils._parallel_process import _parallel_process
from ._compat import fair_scm
LOGGER = logging.getL... | [
"logging.getLogger",
"numpy.asarray",
"multiprocessing.cpu_count",
"numpy.sum",
"scmdata.run_append",
"numpy.vstack",
"concurrent.futures.ProcessPoolExecutor",
"numpy.arange"
] | [((308, 335), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (325, 335), False, 'import logging\n'), ((1550, 1565), 'scmdata.run_append', 'run_append', (['res'], {}), '(res)\n', (1560, 1565), False, 'from scmdata import ScmRun, run_append\n'), ((9283, 9306), 'numpy.sum', 'np.sum', (['forc... |
"""Uses Mk4py, aka metakit.
Python bindings are native-compiled: http://equi4.com/metakit/python.html
"""
from __future__ import print_function, absolute_import
import Mk4py
import numpy as np
import os
import struct
import zlib
from argparse import ArgumentParser
from construct import (
Struct, Int64ul, Array, Con... | [
"numpy.column_stack",
"numpy.array",
"construct.Const",
"construct.Adapter.__init__",
"argparse.ArgumentParser",
"matplotlib.pyplot.plot",
"construct.Array",
"zlib.decompress",
"struct.unpack",
"construct.Struct",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.show",
"construct.GreedyRange",... | [((4705, 4726), 'construct.GreedyRange', 'GreedyRange', (['Property'], {}), '(Property)\n', (4716, 4726), False, 'from construct import Struct, Int64ul, Array, Const, Float64l, Int32sl, Int16ul, Switch, Int32ul, Bytes, Padding, Adapter, Container, GreedyRange, IfThenElse, Peek, Embedded, ExprAdapter, this\n'), ((3699, ... |
# mypy: ignore-errors
"""
This file implements the distillator to distill the information of the provided dataset in the
weights of a neural network.
"""
import itertools
import math
from typing import Optional, Union
from rlo import analytics
from rlo.dataset import PolicyNetDataset, StateValueDataset
from rlo.tf_mod... | [
"rlo.analytics.event",
"itertools.count",
"math.ceil",
"rlo.utils.rng"
] | [((5866, 5886), 'math.ceil', 'math.ceil', (['(N * split)'], {}), '(N * split)\n', (5875, 5886), False, 'import math\n'), ((6089, 6192), 'rlo.analytics.event', 'analytics.event', (['"""distill_train_split"""'], {'dataset': 'examples_shuffled_dataset[:num_train]', 'verbosity': '(1)'}), "('distill_train_split', dataset=ex... |
#!/usr/bin/env python3
# -*- coding=utf-8 -*-
"""
格式化目标对象
"""
import os
import re
import sys
import copy
import logging
import socket
import click
from netaddr import IPNetwork
from netaddr.core import AddrFormatError
from .settings import opts
from . import addons
class Target(object):
"""
测试目标对象，不... | [
"logging.getLogger",
"socket.socket",
"click.secho",
"os.path.isfile",
"sys.modules.get",
"copy.deepcopy",
"netaddr.IPNetwork"
] | [((359, 389), 'logging.getLogger', 'logging.getLogger', (['"""TotalPass"""'], {}), "('TotalPass')\n", (376, 389), False, 'import logging\n'), ((1217, 1279), 'click.secho', 'click.secho', (["('[x] %s No port specified.' % self.host)"], {'fg': '"""red"""'}), "('[x] %s No port specified.' % self.host, fg='red')\n", (1228,... |
'''
This program is not working completely I'm sorry about it because it's my fault.
This program have to worked for Count the greenPixels on webcam but it is not working very well.
Thank you
Sincerely,
<NAME>
'''
import cv2
import numpy as np
class greenfinder():
img = cv2.VideoCapture(0)
lower... | [
"cv2.inRange",
"cv2.imshow",
"numpy.array",
"cv2.bitwise_or",
"cv2.VideoCapture",
"cv2.waitKey"
] | [((286, 305), 'cv2.VideoCapture', 'cv2.VideoCapture', (['(0)'], {}), '(0)\n', (302, 305), False, 'import cv2\n'), ((329, 353), 'numpy.array', 'np.array', (['[45, 100, 100]'], {}), '([45, 100, 100])\n', (337, 353), True, 'import numpy as np\n'), ((377, 401), 'numpy.array', 'np.array', (['[75, 255, 255]'], {}), '([75, 25... |
"""Main module for running the Flask app for Fintrist."""
from fintrist.scheduling import scheduler
from fintrist_app.index import launch
def run():
"""Main method to run the app."""
scheduler.start()
launch(debug=True)
if __name__ == "__main__":
run()
| [
"fintrist.scheduling.scheduler.start",
"fintrist_app.index.launch"
] | [((192, 209), 'fintrist.scheduling.scheduler.start', 'scheduler.start', ([], {}), '()\n', (207, 209), False, 'from fintrist.scheduling import scheduler\n'), ((214, 232), 'fintrist_app.index.launch', 'launch', ([], {'debug': '(True)'}), '(debug=True)\n', (220, 232), False, 'from fintrist_app.index import launch\n')] |
"""
This script creates a query file from the test.group.json.
The query file should be used as a part of the benchmark data.
Specifically, the model takes the query file and generates responses for
each query and then those responses are passed to the evaluator to get the score.
The format of query file is one query ... | [
"logging.basicConfig",
"json.load",
"logging.info",
"argparse.ArgumentParser"
] | [((418, 457), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (437, 457), False, 'import logging\n'), ((472, 497), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (495, 497), False, 'import argparse\n'), ((769, 810), 'logging.info', 'loggi... |
import abc
import json
import logging
import queue
import random
from concurrent.futures.thread import ThreadPoolExecutor
import websocket
import threading
from typing import Type
from bpsenti.refinitiv.pipeline import PipelineStream
from .rooms import RefiRooms
from .security import TokenManagement
from ..helpers.u... | [
"logging.getLogger",
"json.loads",
"json.dumps",
"threading.Event",
"queue.Queue",
"concurrent.futures.thread.ThreadPoolExecutor",
"random.randint"
] | [((356, 383), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (373, 383), False, 'import logging\n'), ((466, 479), 'queue.Queue', 'queue.Queue', ([], {}), '()\n', (477, 479), False, 'import queue\n'), ((2091, 2110), 'json.loads', 'json.loads', (['message'], {}), '(message)\n', (2101, 2110)... |
# Plots intermediate output difference tensors
import matplotlib.pyplot as plt
import csv
from paths import get_intermediate_path
filelist = {
# "AlexNet_Q10.10_accurate.csv" : "20 bit static",
# "AlexNet_Q10.9_accurate.csv" : "19 bit static",
# "AlexNet_Q10.8_accurate.csv" : "18 bit static",
# "Ale... | [
"matplotlib.pyplot.xticks",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"paths.get_intermediate_path",
"matplotlib.pyplot.title",
"matplotlib.pyplot.yscale",
"csv.reader",
"matplotlib.pyplot.show"
] | [((3598, 3624), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""Layer number"""'], {}), "('Layer number')\n", (3608, 3624), True, 'import matplotlib.pyplot as plt\n'), ((3625, 3638), 'matplotlib.pyplot.xticks', 'plt.xticks', (['x'], {}), '(x)\n', (3635, 3638), True, 'import matplotlib.pyplot as plt\n'), ((3639, 3661), ... |
import sspi, sspicon
import win32api
import base64
import logging
logger = logging.getLogger(__name__)
from flask import Response
from flask import _request_ctx_stack as stack
from flask import make_response
from flask import request, session, g
import threading
from functools import wraps
from socket impo... | [
"logging.getLogger",
"sspi.ServerAuth",
"threading.Lock",
"win32api.GetUserNameEx",
"base64.b64encode",
"base64.b64decode",
"functools.wraps",
"uuid.uuid4",
"datetime.datetime.now",
"flask.Response",
"win32api.GetUserName",
"flask.make_response",
"socket.gethostname",
"flask.request.header... | [((79, 106), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (96, 106), False, 'import logging\n'), ((553, 569), 'threading.Lock', 'threading.Lock', ([], {}), '()\n', (567, 569), False, 'import threading\n'), ((950, 963), 'socket.gethostname', 'gethostname', ([], {}), '()\n', (961, 963), F... |
"""Main entry points for scripts."""
from __future__ import print_function
import os
from argparse import ArgumentParser, ArgumentDefaultsHelpFormatter
from .. import utils as cutils
from .. import shear as cshear
def shear(argv=None):
"""Compute the shear."""
description = """Compute the shear."""
pro... | [
"os.path.exists",
"os.path.basename",
"argparse.ArgumentParser"
] | [((409, 523), 'argparse.ArgumentParser', 'ArgumentParser', ([], {'prog': 'prog', 'usage': 'usage', 'description': 'description', 'formatter_class': 'ArgumentDefaultsHelpFormatter'}), '(prog=prog, usage=usage, description=description,\n formatter_class=ArgumentDefaultsHelpFormatter)\n', (423, 523), False, 'from argpa... |
"""mcpython - a minecraft clone written in python licenced under MIT-licence
authors: uuk, xkcdjerry
original game by forgleman licenced under MIT-licence
minecraft by Mojang
blocks based on 1.14.4.jar of minecraft, downloaded on 20th of July, 2019"""
from . import State, StatePartGame
import gui.InventoryHandler
imp... | [
"globals.inventoryhandler.show",
"pyglet.gl.glClearColor",
"globals.statehandler.switch_to",
"globals.inventoryhandler.reload_config",
"globals.inventoryhandler.hide"
] | [((2137, 2189), 'globals.inventoryhandler.show', 'G.inventoryhandler.show', (["G.player.inventorys['chat']"], {}), "(G.player.inventorys['chat'])\n", (2160, 2189), True, 'import globals as G\n'), ((2263, 2304), 'pyglet.gl.glClearColor', 'pyglet.gl.glClearColor', (['(0.5)', '(0.69)', '(1.0)', '(1)'], {}), '(0.5, 0.69, 1... |
import logging
import requests
from PIL import Image
from collections import defaultdict
from io import BytesIO
from gis_metadata.iso_metadata_parser import IsoParser
from gis_metadata.utils import format_xpaths, ParserProperty
from parserutils.collections import wrap_value
from parserutils.elements import get_remote... | [
"logging.getLogger",
"parserutils.urls.url_to_parts",
"PIL.Image.new",
"parserutils.elements.get_remote_element",
"io.BytesIO",
"requests.head",
"parserutils.collections.wrap_value",
"collections.defaultdict",
"parserutils.urls.parts_to_url",
"gis_metadata.utils.ParserProperty",
"parserutils.url... | [((958, 985), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (975, 985), False, 'import logging\n'), ((1239, 1250), 'restle.fields.TextField', 'TextField', ([], {}), '()\n', (1248, 1250), False, 'from restle.fields import TextField\n'), ((1263, 1285), 'restle.fields.TextField', 'TextField... |
# -*- coding: utf-8 -*-
"""Components blueprint."""
from flask import jsonify, request
from flask_smorest import Blueprint
from ..controllers.components import create_component, get_component, update_component, \
delete_component, pagination_components, total_rows_components
from ..utils import to_snake_case
bp... | [
"flask.request.args.get",
"flask.request.get_json",
"flask_smorest.Blueprint",
"flask.jsonify"
] | [((323, 356), 'flask_smorest.Blueprint', 'Blueprint', (['"""components"""', '__name__'], {}), "('components', __name__)\n", (332, 356), False, 'from flask_smorest import Blueprint\n'), ((473, 497), 'flask.request.args.get', 'request.args.get', (['"""name"""'], {}), "('name')\n", (489, 497), False, 'from flask import js... |
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from db import *
from direct import Configuration
def upgrade():
config = Configuration()
session = Session()
frontend = session.query(Frontend).\
filter_by(name='https',
binds=':5443 ssl crt /usr/local/haproxy/var/c... | [
"direct.Configuration"
] | [((144, 159), 'direct.Configuration', 'Configuration', ([], {}), '()\n', (157, 159), False, 'from direct import Configuration\n')] |
import os
from pathlib import Path
import time
class Source_file_generator:
"""
Library to easily generate proximal functions
"""
number_of_spaces_in_tab=4
def __init__(self,location,function_type):
"""
Parameters
---------
location : target location
functio... | [
"time.strftime",
"pathlib.Path"
] | [((530, 550), 'pathlib.Path', 'Path', (['self._location'], {}), '(self._location)\n', (534, 550), False, 'from pathlib import Path\n'), ((843, 868), 'time.strftime', 'time.strftime', (['"""%H:%M:%S"""'], {}), "('%H:%M:%S')\n", (856, 868), False, 'import time\n'), ((786, 805), 'time.strftime', 'time.strftime', (['"""%x"... |
"""Migrate settings to Redis
Revision ID: 485d2a94f8f4
Revises: <PASSWORD>
Create Date: 2021-04-04 22:16:38.872930+00:00
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision = "485d2a94f8f4"
down_revision = "<PASSWORD>"
branch_labels = None
depends_on = None
def upg... | [
"alembic.op.drop_table",
"alembic.op.f",
"sqlalchemy.Text",
"sqlalchemy.PrimaryKeyConstraint",
"sqlalchemy.Integer",
"alembic.op.execute",
"sqlalchemy.Enum"
] | [((463, 488), 'alembic.op.drop_table', 'op.drop_table', (['"""settings"""'], {}), "('settings')\n", (476, 488), False, 'from alembic import op\n'), ((493, 528), 'alembic.op.execute', 'op.execute', (['"""DROP TYPE settingskey"""'], {}), "('DROP TYPE settingskey')\n", (503, 528), False, 'from alembic import op\n'), ((346... |
from conftest import rvo_output, rvo_err
from click.testing import CliRunner
from rvo import cli
def test_delete_yes():
options = ['delete', '569e5eed6815b47ce7bdb583', '--yes']
output = ["Removed"]
rvo_output(options,output)
def test_delete_input_yes():
runner = CliRunner()
result = runner.invoke... | [
"conftest.rvo_output",
"click.testing.CliRunner",
"conftest.rvo_err"
] | [((212, 239), 'conftest.rvo_output', 'rvo_output', (['options', 'output'], {}), '(options, output)\n', (222, 239), False, 'from conftest import rvo_output, rvo_err\n'), ((282, 293), 'click.testing.CliRunner', 'CliRunner', ([], {}), '()\n', (291, 293), False, 'from click.testing import CliRunner\n'), ((533, 544), 'click... |
import os
from flask import Flask
from flask_bootstrap import Bootstrap
from .config import config
bootstrap = Bootstrap()
def getenv(key: str) -> str:
return os.getenv(key)
def get_field_value(field):
return field.data
def create_app(test_config=None):
# create and configure the app
app = Flas... | [
"os.makedirs",
"flask.Flask",
"os.getenv",
"flask_bootstrap.Bootstrap"
] | [((114, 125), 'flask_bootstrap.Bootstrap', 'Bootstrap', ([], {}), '()\n', (123, 125), False, 'from flask_bootstrap import Bootstrap\n'), ((168, 182), 'os.getenv', 'os.getenv', (['key'], {}), '(key)\n', (177, 182), False, 'import os\n'), ((316, 362), 'flask.Flask', 'Flask', (['__name__'], {'instance_relative_config': '(... |
import datetime
from apscheduler.schedulers.blocking import BlockingScheduler
from .pushFeedJobs import pushFeedJobs
from .pushLinkJobs import pushLinkJobs
from .clusterDocsJob import clusterDocsJob
from .archiveStaleDocs import archiveStaleDocs
from .reprocessCurrentClusters import reprocessCurrentClusters
from .not... | [
"datetime.datetime.now",
"datetime.timedelta",
"apscheduler.schedulers.blocking.BlockingScheduler"
] | [((492, 515), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (513, 515), False, 'import datetime\n'), ((549, 568), 'apscheduler.schedulers.blocking.BlockingScheduler', 'BlockingScheduler', ([], {}), '()\n', (566, 568), False, 'from apscheduler.schedulers.blocking import BlockingScheduler\n'), ((872... |
import time
from datetime import datetime
from typing import Any, Callable, Mapping, MutableMapping, MutableSequence, Sequence, Optional
from unittest.mock import patch
from snuba.utils.metrics.backends.dummy import DummyMetricsBackend
from snuba.utils.streams.abstract import Consumer
from snuba.utils.streams.batching... | [
"datetime.datetime",
"unittest.mock.patch",
"snuba.utils.metrics.backends.dummy.DummyMetricsBackend",
"snuba.utils.streams.kafka.TopicPartition"
] | [((3024, 3042), 'unittest.mock.patch', 'patch', (['"""time.time"""'], {}), "('time.time')\n", (3029, 3042), False, 'from unittest.mock import patch\n'), ((2548, 2580), 'snuba.utils.metrics.backends.dummy.DummyMetricsBackend', 'DummyMetricsBackend', ([], {'strict': '(True)'}), '(strict=True)\n', (2567, 2580), False, 'fr... |
from encomp.units import Q
from encomp.gases import convert_gas_volume
def test_convert_gas_volume():
ret = convert_gas_volume(
Q(1, 'm3'),
'N',
(Q(2, 'bar'), Q(25, 'degC'))
)
assert ret.check(Q(0, 'liter'))
| [
"encomp.units.Q"
] | [((144, 154), 'encomp.units.Q', 'Q', (['(1)', '"""m3"""'], {}), "(1, 'm3')\n", (145, 154), False, 'from encomp.units import Q\n'), ((234, 247), 'encomp.units.Q', 'Q', (['(0)', '"""liter"""'], {}), "(0, 'liter')\n", (235, 247), False, 'from encomp.units import Q\n'), ((178, 189), 'encomp.units.Q', 'Q', (['(2)', '"""bar"... |
#Script to test a running container
import unittest
import requests
baseURL="http://virtualpresencepicture:8098"
class test_containerAPI(unittest.TestCase):
#Actual tests below
def test_WeCanGetToSwaggerFile(self):
result = requests.get(baseURL + "/api/swagger.json")
self.assertEqual(result.status_code, 20... | [
"requests.get"
] | [((233, 276), 'requests.get', 'requests.get', (["(baseURL + '/api/swagger.json')"], {}), "(baseURL + '/api/swagger.json')\n", (245, 276), False, 'import requests\n')] |
# -*- coding: utf-8 -*-
"""Untitled15.ipynb
Automatically generated by Colaboratory.
Original file is located at
https://colab.research.google.com/drive/1nmm_l7PsXx5lnEqzn4aonhGCYkIZSxOA
"""
import os
from PIL import Image # PIL library is required
import pyglet
from pyglet import gl
from pyglet.gl import glu
... | [
"pyglet.gl.glPolygonMode",
"pyglet.gl.glClear",
"PIL.Image.open",
"pyglet.app.run",
"pyglet.gl.glTranslatef",
"pyglet.gl.glRotatef",
"pyglet.gl.glViewport",
"pyglet.gl.glClearColor",
"pyglet.gl.glLoadIdentity",
"pyglet.graphics.draw",
"pyglet.window.Window",
"pyglet.gl.glMatrixMode",
"pyglet... | [((3036, 3121), 'pyglet.window.Window', 'pyglet.window.Window', ([], {'width': '(400)', 'height': '(400)', 'caption': '"""Heightmap"""', 'resizable': '(True)'}), "(width=400, height=400, caption='Heightmap', resizable=True\n )\n", (3056, 3121), False, 'import pyglet\n'), ((3137, 3160), 'pyglet.gl.glClearColor', 'gl.... |
from __future__ import print_function
import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits
from sklearn.decomposition import PCA
# For reproducibility
np.random.seed(1000)
if __name__ == '__main__':
# Load MNIST digits
digits = load_digits()
# Show some random dig... | [
"sklearn.decomposition.PCA",
"sklearn.datasets.load_digits",
"numpy.random.randint",
"numpy.random.seed",
"numpy.cumsum",
"matplotlib.pyplot.subplots",
"numpy.arange",
"matplotlib.pyplot.show"
] | [((193, 213), 'numpy.random.seed', 'np.random.seed', (['(1000)'], {}), '(1000)\n', (207, 213), True, 'import numpy as np\n'), ((279, 292), 'sklearn.datasets.load_digits', 'load_digits', ([], {}), '()\n', (290, 292), False, 'from sklearn.datasets import load_digits\n'), ((340, 376), 'numpy.random.randint', 'np.random.ra... |
import numpy as np
from sklearn.model_selection import KFold
from sklearn.mixture import GaussianMixture
from routines import Routines
import configparser
config = configparser.ConfigParser()
config.read('../system.ini')
routines = Routines(config) | [
"routines.Routines",
"configparser.ConfigParser"
] | [((165, 192), 'configparser.ConfigParser', 'configparser.ConfigParser', ([], {}), '()\n', (190, 192), False, 'import configparser\n'), ((233, 249), 'routines.Routines', 'Routines', (['config'], {}), '(config)\n', (241, 249), False, 'from routines import Routines\n')] |
# -*- coding: utf-8 -*-
# Resource object code
#
# Created by: The Resource Compiler for PyQt5 (Qt v5.10.1)
#
# WARNING! All changes made in this file will be lost!
from PyQt5 import QtCore
qt_resource_data = b"\
\x00\x00\x76\x65\
\x89\
\x50\x4e\x47\x0d\x0a\x1a\x0a\x00\x00\x00\x0d\x49\x48\x44\x52\x00\
\x00\x01\x0e\x... | [
"PyQt5.QtCore.qVersion",
"PyQt5.QtCore.qUnregisterResourceData",
"PyQt5.QtCore.qRegisterResourceData"
] | [((126376, 126477), 'PyQt5.QtCore.qRegisterResourceData', 'QtCore.qRegisterResourceData', (['rcc_version', 'qt_resource_struct', 'qt_resource_name', 'qt_resource_data'], {}), '(rcc_version, qt_resource_struct,\n qt_resource_name, qt_resource_data)\n', (126404, 126477), False, 'from PyQt5 import QtCore\n'), ((126505,... |
# Getting data from: brasil.io
import requests
import json
import pandas as pd
class Tracker:
apiUrl = 'https://brasil.io/api/dataset/covid19/caso/data/?format=json&is_last=True&place_type=state'
def __init__(self):
self.dfRes = self.callApi()
self.totalDeaths = self.dfRes['deaths'].su... | [
"pandas.DataFrame.from_records",
"json.loads",
"requests.request"
] | [((432, 468), 'requests.request', 'requests.request', (['"""GET"""', 'self.apiUrl'], {}), "('GET', self.apiUrl)\n", (448, 468), False, 'import requests\n'), ((487, 510), 'json.loads', 'json.loads', (['apiRes.text'], {}), '(apiRes.text)\n', (497, 510), False, 'import json\n'), ((528, 573), 'pandas.DataFrame.from_records... |
from django.db import models
class Setting(models.Model):
key = models.CharField(max_length=100, unique=True, db_index=True)
name = models.CharField(max_length=100)
value = models.CharField(max_length=100)
def __str__(self):
return self.name
| [
"django.db.models.CharField"
] | [((70, 130), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(100)', 'unique': '(True)', 'db_index': '(True)'}), '(max_length=100, unique=True, db_index=True)\n', (86, 130), False, 'from django.db import models\n'), ((142, 174), 'django.db.models.CharField', 'models.CharField', ([], {'max_length'... |
from sqlalchemy import Column, ForeignKey, Integer, String, Text
from model.base import Base
class ZSTQ_TY(Base):
__tablename__ = 'zstq_ty'
class_name = '在绍台企-团员'
foreign_key = 'zstq_id'
export_docx = False
field = [
'id', 'name', 'sex', 'job', 'taiwanese_id'
]
zstq_id = Column... | [
"sqlalchemy.String",
"sqlalchemy.ForeignKey"
] | [((330, 351), 'sqlalchemy.ForeignKey', 'ForeignKey', (['"""zstq.id"""'], {}), "('zstq.id')\n", (340, 351), False, 'from sqlalchemy import Column, ForeignKey, Integer, String, Text\n'), ((371, 382), 'sqlalchemy.String', 'String', (['(100)'], {}), '(100)\n', (377, 382), False, 'from sqlalchemy import Column, ForeignKey, ... |
"""empty message
Revision ID: 97519c3acc64
Revises: <PASSWORD>
Create Date: 2016-11-17 00:36:18.728149
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision = '97519c3acc64'
down_revision = '<PASSWORD>'
branch_labels = None
depends_on = None
def upgrade():
op.cre... | [
"alembic.op.create_check_constraint"
] | [((314, 486), 'alembic.op.create_check_constraint', 'op.create_check_constraint', (['"""invoices_afa_gwg_check"""', '"""invoices"""', '"""afa is not null and gwg is false or afa is null and gwg is true or afa is null and gwg is false"""'], {}), "('invoices_afa_gwg_check', 'invoices',\n 'afa is not null and gwg is fa... |
#!/usr/bin/python
#
# Copyright (c) 2019 Wind River Systems, Inc.
#
# SPDX-License-Identifier: Apache-2.0
#
import sys
from fm_api import constants as fm_constants
from fm_api import fm_api
from sysinv.common import constants as sysinv_constants
def update_alarm(alarm_state, alarm_id, reason_text=None):
""" Up... | [
"fm_api.fm_api.FaultAPIs",
"fm_api.fm_api.Fault"
] | [((365, 383), 'fm_api.fm_api.FaultAPIs', 'fm_api.FaultAPIs', ([], {}), '()\n', (381, 383), False, 'from fm_api import fm_api\n'), ((600, 1019), 'fm_api.fm_api.Fault', 'fm_api.Fault', ([], {'alarm_id': 'alarm_id', 'alarm_state': 'alarm_state', 'entity_type_id': 'fm_constants.FM_ENTITY_TYPE_HOST', 'entity_instance_id': '... |
import time
import cv2
import numpy as np
from ..openvino_base.base_model import Base
EMOTION_STATES = ("neutral", "happy", "sad", "surprise", "anger")
class Emotions(Base):
"""Class for the Emotions Recognition Model."""
def __init__(
self,
model_name,
source_width=None,
s... | [
"numpy.vstack",
"numpy.argmax"
] | [((846, 866), 'numpy.argmax', 'np.argmax', (['emo_state'], {}), '(emo_state)\n', (855, 866), True, 'import numpy as np\n'), ((757, 785), 'numpy.vstack', 'np.vstack', (['inference_results'], {}), '(inference_results)\n', (766, 785), True, 'import numpy as np\n')] |
from manimlib.imports import *
import numpy as np
import bats
# slide scene
from manim_reveal import SlideScene
# manim interface with bats
from manimtda import *
import matplotlib
from scipy.spatial import ConvexHull
def gen_circle2(n, r=1.0):
theta = np.linspace(0, 2*np.pi*(1 - 1./n), n)
pts = np.array([r*... | [
"numpy.random.normal",
"numpy.mean",
"bats.bivariate_cover",
"bats.Matrix",
"bats.Nerve",
"bats.LInfDist",
"scipy.spatial.ConvexHull",
"numpy.array",
"numpy.linspace",
"bats.Euclidean",
"bats.F2",
"numpy.cos",
"numpy.zeros",
"numpy.random.uniform",
"numpy.sin"
] | [((260, 304), 'numpy.linspace', 'np.linspace', (['(0)', '(2 * np.pi * (1 - 1.0 / n))', 'n'], {}), '(0, 2 * np.pi * (1 - 1.0 / n), n)\n', (271, 304), True, 'import numpy as np\n'), ((476, 530), 'numpy.random.uniform', 'np.random.uniform', ([], {'low': '(-scale)', 'high': 'scale', 'size': '(n, 2)'}), '(low=-scale, high=s... |
import unittest
import numpy as np
from pecanpy.graph import BaseGraph, AdjlstGraph, SparseGraph, DenseGraph
MAT = np.array([[0, 1, 1], [1, 0, 0], [1, 0, 0]], dtype=float)
INDPTR = np.array([0, 2, 3, 4], dtype=np.uint32)
INDICES = np.array([1, 2, 0, 0], dtype=np.uint32)
DATA = np.array([1.0, 1.0, 1.0, 1.0], dtype=np.... | [
"numpy.all",
"pecanpy.graph.DenseGraph.from_mat",
"pecanpy.graph.AdjlstGraph.from_mat",
"numpy.array",
"pecanpy.graph.BaseGraph",
"unittest.main",
"pecanpy.graph.SparseGraph.from_mat"
] | [((117, 173), 'numpy.array', 'np.array', (['[[0, 1, 1], [1, 0, 0], [1, 0, 0]]'], {'dtype': 'float'}), '([[0, 1, 1], [1, 0, 0], [1, 0, 0]], dtype=float)\n', (125, 173), True, 'import numpy as np\n'), ((183, 222), 'numpy.array', 'np.array', (['[0, 2, 3, 4]'], {'dtype': 'np.uint32'}), '([0, 2, 3, 4], dtype=np.uint32)\n', ... |
from objects.evaluaciones import Actividad
from objects.catedras import *
class Evento:
def __init__(self, tipo, acciones, tiempo, prioridad):
"""
:param tiempo: dia de ocurrencia de evento
:type tiempo: int
:param tipo: tipo del evento creado
:type tipo: class
... | [
"objects.evaluaciones.Actividad"
] | [((2683, 2727), 'objects.evaluaciones.Actividad', 'Actividad', (['(i + 1)', 'actual', 'contenidos[actual]'], {}), '(i + 1, actual, contenidos[actual])\n', (2692, 2727), False, 'from objects.evaluaciones import Actividad\n')] |
#!/bin/env python3
from argparse import ArgumentParser, REMAINDER
from .build import build, parse_cmake_option
from .utils import cmake_exe, str2bool
def run():
parser = ArgumentParser(description='Quick cmake build helper tool')
parser.add_argument("-B", "--build-type", metavar="BUILD_TYPE",
... | [
"argparse.ArgumentParser"
] | [((176, 235), 'argparse.ArgumentParser', 'ArgumentParser', ([], {'description': '"""Quick cmake build helper tool"""'}), "(description='Quick cmake build helper tool')\n", (190, 235), False, 'from argparse import ArgumentParser, REMAINDER\n')] |
from django.conf.urls import include, url
from rest_framework import routers
from ultimanager import views
router = routers.DefaultRouter()
router.register('teams', views.TeamViewSet, base_name='team')
urlpatterns = [
url(
r'^games/(?P<pk>[0-9]+)/$',
views.GameDetailView.as_view(),
nam... | [
"ultimanager.views.PossessionDetailView.as_view",
"ultimanager.views.PossessionListView.as_view",
"ultimanager.views.PointDetailView.as_view",
"ultimanager.views.ThrowListView.as_view",
"ultimanager.views.PlayerDetailView.as_view",
"ultimanager.views.GameListView.as_view",
"django.conf.urls.include",
... | [((120, 143), 'rest_framework.routers.DefaultRouter', 'routers.DefaultRouter', ([], {}), '()\n', (141, 143), False, 'from rest_framework import routers\n'), ((277, 307), 'ultimanager.views.GameDetailView.as_view', 'views.GameDetailView.as_view', ([], {}), '()\n', (305, 307), False, 'from ultimanager import views\n'), (... |
# This Python file uses the following encoding: utf-8
"""autogenerated by genpy from line_tracing/hsv_thresh.msg. Do not edit."""
import sys
python3 = True if sys.hexversion > 0x03000000 else False
import genpy
import struct
class hsv_thresh(genpy.Message):
_md5sum = "0a5aabfc8bbb0749ec67edd76bf4b306"
_type = "li... | [
"struct.Struct",
"genpy.DeserializationError"
] | [((4694, 4714), 'struct.Struct', 'struct.Struct', (['"""<9B"""'], {}), "('<9B')\n", (4707, 4714), False, 'import struct\n'), ((3218, 3247), 'genpy.DeserializationError', 'genpy.DeserializationError', (['e'], {}), '(e)\n', (3244, 3247), False, 'import genpy\n'), ((4433, 4462), 'genpy.DeserializationError', 'genpy.Deseri... |
# coding: utf-8
from src.Implement.StatusImplement import StatusImplement
class StatusInterface(object):
@staticmethod
def get_status(cluster, data):
return StatusImplement.get_status(cluster, data)
| [
"src.Implement.StatusImplement.StatusImplement.get_status"
] | [((177, 218), 'src.Implement.StatusImplement.StatusImplement.get_status', 'StatusImplement.get_status', (['cluster', 'data'], {}), '(cluster, data)\n', (203, 218), False, 'from src.Implement.StatusImplement import StatusImplement\n')] |
#!/usr/bin/env python
# File name: chop_chain_joiner.py
# Author: <NAME>
# Date created: 5/24/2017
# Date last modified: 5/24/2017
# Python Version: 3.6
"""
Description:
This script 'fills in' missing residues in PDB files and creates a fixed PDB file.
In order to fill in the gaps, Modeller is used to create a homolog... | [
"os.listdir",
"os.makedirs",
"argparse.ArgumentParser",
"chain_joiner.make_seq.get_sequence",
"chain_joiner.make_model.model",
"os.path.basename",
"chain_joiner.make_alignment.align",
"os.system"
] | [((2021, 3376), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'prog': '"""make_model.py"""', 'formatter_class': 'argparse.RawDescriptionHelpFormatter', 'description': '"""\n This script \'fills in\' missing residues in PDB files and creates a fixed PDB file. \n In order to fill in the gaps, Modeller... |
# Copyright 2016 <NAME> (<EMAIL>)
#
# 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 writ... | [
"diskimage_builder.block_device.utils.parse_abs_size_spec"
] | [((807, 836), 'diskimage_builder.block_device.utils.parse_abs_size_spec', 'parse_abs_size_spec', (['tspec[0]'], {}), '(tspec[0])\n', (826, 836), False, 'from diskimage_builder.block_device.utils import parse_abs_size_spec\n')] |
import sys
import libcst as cst
from jinja2 import Environment, FunctionLoader
from oarepo_model_builder.templates import templates
from oarepo_model_builder.outputs import OutputBase
from oarepo_model_builder.utils.cst import MergingTransformer
from oarepo_model_builder.utils.verbose import log
class PythonOutput(O... | [
"isort.file",
"oarepo_model_builder.utils.cst.MergingTransformer",
"oarepo_model_builder.templates.templates.get_template",
"libcst.parse_module",
"isort.settings.Config",
"oarepo_model_builder.utils.verbose.log"
] | [((913, 943), 'oarepo_model_builder.utils.verbose.log', 'log', (['(2)', '"""Saving %s"""', 'self.path'], {}), "(2, 'Saving %s', self.path)\n", (916, 943), False, 'from oarepo_model_builder.utils.verbose import log\n'), ((2080, 2142), 'libcst.parse_module', 'cst.parse_module', (['rendered'], {'config': 'self.cst.config_... |
from django import forms
class SearchForm(forms.Form):
term = forms.CharField(label="") | [
"django.forms.CharField"
] | [((67, 92), 'django.forms.CharField', 'forms.CharField', ([], {'label': '""""""'}), "(label='')\n", (82, 92), False, 'from django import forms\n')] |
from matplotlib import pyplot as plt
import numpy as np
from math import cos, sin, atan
class Neuron():
def __init__(self, x, y, weight=[]):
self.x = x
self.y = y
if weight: self.weight = weight
def draw(self,texter):
circle = plt.Circle((self.x, self.y), radius=neuron_radius, ... | [
"matplotlib.pyplot.text",
"matplotlib.pyplot.Circle",
"matplotlib.pyplot.xticks",
"matplotlib.pyplot.gca",
"numpy.size",
"math.cos",
"matplotlib.pyplot.annotate",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.yticks",
"matplotlib.pyplot.Line2D",
"matplotlib.pyplot.axis",
"math.sin",
"matplo... | [((269, 331), 'matplotlib.pyplot.Circle', 'plt.Circle', (['(self.x, self.y)'], {'radius': 'neuron_radius', 'fill': '(False)'}), '((self.x, self.y), radius=neuron_radius, fill=False)\n', (279, 331), True, 'from matplotlib import pyplot as plt\n'), ((347, 425), 'matplotlib.pyplot.annotate', 'plt.annotate', (['texter', '(... |
from keras.models import Sequential
from keras.layers import Embedding, Bidirectional, LSTM
from keras_contrib.layers import CRF
import pickle
from data import load_data
EMBED_DIM = 40
BIRNN_UNITS = 50
def model(train=True):
(train_X, train_Y), (dev_X, dev_Y), (vocab, chunks) = load_data()
model ... | [
"keras.layers.LSTM",
"data.load_data",
"keras.models.Sequential"
] | [((293, 304), 'data.load_data', 'load_data', ([], {}), '()\n', (302, 304), False, 'from data import load_data\n'), ((322, 334), 'keras.models.Sequential', 'Sequential', ([], {}), '()\n', (332, 334), False, 'from keras.models import Sequential\n'), ((428, 473), 'keras.layers.LSTM', 'LSTM', (['(BIRNN_UNITS // 2)'], {'ret... |
#!/usr/bin/env python3
# Copyright 2017 <NAME> <<EMAIL>>
#
# 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... | [
"re.compile",
"threading.Lock",
"subprocess.Popen",
"multiprocessing.cpu_count",
"tempfile.NamedTemporaryFile",
"re.sub",
"threading.Thread"
] | [((952, 983), 're.compile', 're.compile', (['"""RE\\\\[([^\\\\]]+)\\\\]"""'], {}), "('RE\\\\[([^\\\\]]+)\\\\]')\n", (962, 983), False, 'import re\n'), ((995, 1011), 'threading.Lock', 'threading.Lock', ([], {}), '()\n', (1009, 1011), False, 'import threading\n'), ((1143, 1172), 'tempfile.NamedTemporaryFile', 'tempfile.N... |
# -*- coding: utf-8 -*-
"""
model manager module.
"""
from sqlalchemy.orm import registry
import pyrin.utils.sqlalchemy as sqlalchemy_utils
from pyrin.core.mixin import HookMixin
from pyrin.core.structs import Manager
from pyrin.database.model import ModelPackage
from pyrin.database.model.hooks import ModelHookBase
... | [
"pyrin.database.model.exceptions.EntitiesAreNotCollectedError",
"sqlalchemy.orm.registry"
] | [((879, 905), 'sqlalchemy.orm.registry', 'registry', ([], {'constructor': 'None'}), '(constructor=None)\n', (887, 905), False, 'from sqlalchemy.orm import registry\n'), ((3543, 3618), 'pyrin.database.model.exceptions.EntitiesAreNotCollectedError', 'EntitiesAreNotCollectedError', (['"""Application entities are not colle... |
import time
from datetime import datetime
import requests
import config
from util import logging
COIN_GECKO_BASE_URL = 'https://api.coingecko.com/api/v3/'
log = logging.get_custom_logger(__name__, config.LOG_LEVEL)
class CoinGecko:
@staticmethod
def get_id_by_symbol(symbol):
url = COIN_GECKO_BASE_... | [
"time.sleep",
"util.logging.get_custom_logger",
"requests.get"
] | [((165, 218), 'util.logging.get_custom_logger', 'logging.get_custom_logger', (['__name__', 'config.LOG_LEVEL'], {}), '(__name__, config.LOG_LEVEL)\n', (190, 218), False, 'from util import logging\n'), ((359, 376), 'requests.get', 'requests.get', (['url'], {}), '(url)\n', (371, 376), False, 'import requests\n'), ((793, ... |
"""Handles loading of model and predicting user input"""
import tensorflow as tf
def make_prediction(input_arr):
"""
Takes in 2D numpy array of user input
Loads pretrained model and predicts based on user input
Returns predicted price per night of listing.
"""
nn_model = tf.keras.models.load_... | [
"tensorflow.keras.models.load_model"
] | [((299, 357), 'tensorflow.keras.models.load_model', 'tf.keras.models.load_model', (['"""bayesian_optimization_model/"""'], {}), "('bayesian_optimization_model/')\n", (325, 357), True, 'import tensorflow as tf\n')] |
#!/usr/bin/env python
# encoding: utf8
#
# Grab http://www.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt
#
from __future__ import print_function
import os, sys
from argparse import ArgumentParser
from robofab.objects.objectsRF import OpenFont
from unicode_util import parseUnicodeDataFile, MainCategories as UniMainC... | [
"robofab.objects.objectsRF.OpenFont",
"unicode_util.parseUnicodeDataFile",
"argparse.ArgumentParser"
] | [((1940, 2037), 'argparse.ArgumentParser', 'ArgumentParser', ([], {'description': '"""Set robofont color marks on glyphs based on unicode categories"""'}), "(description=\n 'Set robofont color marks on glyphs based on unicode categories')\n", (1954, 2037), False, 'from argparse import ArgumentParser\n'), ((2621, 265... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""Contains methods that reference APIs used by bot."""
import configparser
from functools import lru_cache
import logging
import pixivpy3 # type: ignore
from .exceptions import APIError
@lru_cache(maxsize=32)
def pixiv_tags(illust_id: int, conf: configparser.Sectio... | [
"logging.getLogger",
"functools.lru_cache",
"pixivpy3.AppPixivAPI"
] | [((242, 263), 'functools.lru_cache', 'lru_cache', ([], {'maxsize': '(32)'}), '(maxsize=32)\n', (251, 263), False, 'from functools import lru_cache\n'), ((618, 645), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (635, 645), False, 'import logging\n'), ((725, 747), 'pixivpy3.AppPixivAPI', ... |
from cmdty_storage import CmdtyStorage, three_factor_seasonal_value
from matplotlib import pyplot as plt
import pandas as pd
import numpy as np
NUM_STORAGE_FACILITIES = 4
DATA_LAG = 0
def perform_valuation():
german_gas_storage_sets = list()
gas_storage_facilities = list()
# Load the ... | [
"pandas.Series",
"pandas.period_range",
"pandas.read_excel",
"pandas.PeriodIndex"
] | [((1721, 1776), 'pandas.period_range', 'pd.period_range', ([], {'start': 'begin_date', 'periods': '(25)', 'freq': '"""M"""'}), "(start=begin_date, periods=25, freq='M')\n", (1736, 1776), True, 'import pandas as pd\n'), ((2394, 2527), 'pandas.PeriodIndex', 'pd.PeriodIndex', ([], {'freq': '"""D"""', 'data': "['2021-07-21... |
# -*- coding: utf-8 -*-
'''Chemical Engineering Design Library (ChEDL). Utilities for process modeling.
Copyright (C) 2019, 2020 <NAME> <<EMAIL>>
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 wi... | [
"fluids.numerics.newton",
"chemicals.virial.BVirial_Pitzer_Curl"
] | [((2555, 2604), 'chemicals.virial.BVirial_Pitzer_Curl', 'BVirial_Pitzer_Curl', (['T', 'Tcs[i]', 'Pcs[i]', 'omegas[i]'], {}), '(T, Tcs[i], Pcs[i], omegas[i])\n', (2574, 2604), False, 'from chemicals.virial import BVirial_Pitzer_Curl, Z_from_virial_density_form\n'), ((2735, 2787), 'chemicals.virial.BVirial_Pitzer_Curl', ... |
from Crypto.Hash import SHA256
from Crypto.Random import random
from lib.helpers import read_hex
# ed: this is the first file we should fix
# Project TODO: Is this the best choice of prime? Why? Why not? Feel free to replace!
# 1536 bit safe prime for Diffie-Hellman key exchange
# obtained from RFC 3526
raw_prime =... | [
"lib.helpers.read_hex"
] | [((2127, 2147), 'lib.helpers.read_hex', 'read_hex', (['prime_4096'], {}), '(prime_4096)\n', (2135, 2147), False, 'from lib.helpers import read_hex\n')] |
from collections import defaultdict
class Solution(object):
def groupAnagrams(self, strs):
"""
:type strs: List[str]
:rtype: List[List[str]]
"""
anagrams = defaultdict(list)
map(lambda s: anagrams[''.join(sorted(s))].append(s), strs)
return anagrams.values()... | [
"collections.defaultdict"
] | [((202, 219), 'collections.defaultdict', 'defaultdict', (['list'], {}), '(list)\n', (213, 219), False, 'from collections import defaultdict\n')] |
from hale_hub.extensions import db
from hale_hub.constants import MAX_STRING_LENGTH
class RoomStatModel(db.Model):
"""Table containing statistics on rooms around house. Different variables should be grouped together around
the same lock-stepped time frame"""
id = db.Column(db.Integer, primary_key=True)
... | [
"hale_hub.extensions.db.Column",
"hale_hub.extensions.db.String"
] | [((279, 318), 'hale_hub.extensions.db.Column', 'db.Column', (['db.Integer'], {'primary_key': '(True)'}), '(db.Integer, primary_key=True)\n', (288, 318), False, 'from hale_hub.extensions import db\n'), ((330, 368), 'hale_hub.extensions.db.Column', 'db.Column', (['db.DateTime'], {'nullable': '(False)'}), '(db.DateTime, n... |
"""
.. module:: magneticSensor
:synopsis: Magnetic sensor reader
.. moduleauthor:: <NAME> <<EMAIL>>
Data reader for Arduino controlled magnetic field sensor
"""
__author__ = '<NAME>'
import time
import numpy as np
from serial.serialutil import SerialException
from labtools.log import create_logger
from labtools... | [
"numpy.mean",
"serial.tools.list_ports.comports",
"time.sleep",
"numpy.append",
"numpy.array",
"serial.Serial",
"numpy.empty",
"labtools.utils.instr.InstrError",
"time.time",
"labtools.log.create_logger"
] | [((615, 648), 'labtools.log.create_logger', 'create_logger', (['__name__', 'LOGLEVEL'], {}), '(__name__, LOGLEVEL)\n', (628, 648), False, 'from labtools.log import create_logger\n'), ((923, 933), 'serial.tools.list_ports.comports', 'comports', ([], {}), '()\n', (931, 933), False, 'from serial.tools.list_ports import co... |
from __future__ import division
import numpy as np
from scipy.fftpack import fft, ifft
from mpl_toolkits.mplot3d.axes3d import Axes3D
import matplotlib.pyplot as plt
from matplotlib import cm
from math import sqrt, pi
def initialize_all(y0, t0, t1, n):
""" An initialization routine for the different ODE s... | [
"numpy.linspace",
"numpy.empty"
] | [((524, 546), 'numpy.linspace', 'np.linspace', (['t0', 't1', 'n'], {}), '(t0, t1, n)\n', (535, 546), True, 'import numpy as np\n'), ((482, 508), 'numpy.empty', 'np.empty', (['n'], {'dtype': 'complex'}), '(n, dtype=complex)\n', (490, 508), True, 'import numpy as np\n'), ((422, 459), 'numpy.empty', 'np.empty', (['(n, y0.... |
"""
methods for dealing with blog posts
"""
from cgi import escape
from datetime import datetime
from db_schema import Post
from google.appengine.ext import ndb
import hmac
import json
def add_comment(blog_id, commenter, comment_content):
"""
add a comment to a blog post
:param blog_id:
:param commen... | [
"hmac.new",
"json.loads",
"json.dumps",
"datetime.datetime.now",
"google.appengine.ext.ndb.Key",
"db_schema.Post.query",
"cgi.escape",
"db_schema.Post"
] | [((396, 420), 'google.appengine.ext.ndb.Key', 'ndb.Key', (['"""Post"""', 'blog_id'], {}), "('Post', blog_id)\n", (403, 420), False, 'from google.appengine.ext import ndb\n'), ((518, 543), 'json.loads', 'json.loads', (['json_comments'], {}), '(json_comments)\n', (528, 543), False, 'import json\n'), ((655, 690), 'cgi.esc... |
import os
import sys
import subprocess
import pytest
from network_wrangler import ProjectCard
from network_wrangler import RoadwayNetwork
from network_wrangler import TransitNetwork
from network_wrangler import Scenario
from network_wrangler.logger import WranglerLogger
"""
Run just the tests labeled scenario using `p... | [
"network_wrangler.ProjectCard.build_link_selection_query",
"network_wrangler.Scenario.create_scenario",
"subprocess.Popen",
"network_wrangler.RoadwayNetwork.read",
"os.path.join",
"network_wrangler.logger.WranglerLogger.info",
"os.getcwd",
"pytest.mark.parametrize",
"network_wrangler.ProjectCard.rea... | [((592, 633), 'os.path.join', 'os.path.join', (['STPAUL_DIR', '"""shape.geojson"""'], {}), "(STPAUL_DIR, 'shape.geojson')\n", (604, 633), False, 'import os\n'), ((653, 690), 'os.path.join', 'os.path.join', (['STPAUL_DIR', '"""link.json"""'], {}), "(STPAUL_DIR, 'link.json')\n", (665, 690), False, 'import os\n'), ((710, ... |
import numpy as np
import os, sys, random, copy
import torch
try:
sys.path.remove('/opt/ros/kinetic/lib/python2.7/dist-packages')
except:
pass
from detectron2.structures import BoxMode
from detectron2.data import MetadataCatalog, DatasetCatalog
from detectron2.utils.visualizer import Visualizer
from detectron... | [
"numpy.tile",
"os.listdir",
"detectron2.data.build.build_detection_train_loader",
"data.cgrcnn_dataset_as_torch_loader.cgrcnn_dataset_torch",
"numpy.hstack",
"torch.utils.data.RandomSampler",
"sys.path.remove",
"detectron2.structures.Instances",
"numpy.array",
"detectron2.data.build.build_batch_da... | [((71, 134), 'sys.path.remove', 'sys.path.remove', (['"""/opt/ros/kinetic/lib/python2.7/dist-packages"""'], {}), "('/opt/ros/kinetic/lib/python2.7/dist-packages')\n", (86, 134), False, 'import os, sys, random, copy\n'), ((696, 716), 'os.listdir', 'os.listdir', (['img_path'], {}), '(img_path)\n', (706, 716), False, 'imp... |
import discord_notify as dn
from typing import List
import logging
from datetime import datetime as dtt
import pandas as pd
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
notifier = dn.Notifier(
"https://discord.com/api/webhooks/829733851798437970/EIIAHfucMPrmOJ3x3uTBY1ofCKvMhVQYVcDD4-OznIAwc... | [
"logging.getLogger",
"datetime.datetime.now",
"discord_notify.Notifier"
] | [((134, 161), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (151, 161), False, 'import logging\n'), ((205, 350), 'discord_notify.Notifier', 'dn.Notifier', (['"""https://discord.com/api/webhooks/829733851798437970/EIIAHfucMPrmOJ3x3uTBY1ofCKvMhVQYVcDD4-OznIAwcq4qvHOjmjvoT9PdldDhcDNS"""'], ... |
# jsb/plugs/core/welcome.py
#
#
""" send welcome message. """
## jsb imports
from jsb.lib.commands import cmnds
from jsb.lib.examples import examples
## welcome command
def handle_welcome(bot, event):
""" no arguments - display welcome message. """
event.reply("Welcome to JSONBOT - you can give this bot co... | [
"jsb.lib.commands.cmnds.add",
"jsb.lib.examples.examples.add"
] | [((381, 444), 'jsb.lib.commands.cmnds.add', 'cmnds.add', (['"""welcome"""', 'handle_welcome', "['OPER', 'USER', 'GUEST']"], {}), "('welcome', handle_welcome, ['OPER', 'USER', 'GUEST'])\n", (390, 444), False, 'from jsb.lib.commands import cmnds\n'), ((445, 499), 'jsb.lib.examples.examples.add', 'examples.add', (['"""wel... |
import urlparse
from urllib import urlencode
from django.conf import settings
import jwt
from mozpay.verify import verify_claims, verify_keys
from nose.tools import eq_
import amo
from amo.helpers import absolutify
from amo.urlresolvers import reverse
from mkt.webpay.webpay_jwt import (get_product_jwt, WebAppProduct... | [
"urlparse.parse_qs",
"mkt.webpay.webpay_jwt.WebAppProduct",
"nose.tools.eq_",
"mkt.webpay.webpay_jwt.InAppProduct",
"stats.models.Contribution.objects.get",
"mozpay.verify.verify_keys",
"mozpay.verify.verify_claims",
"amo.urlresolvers.reverse",
"mkt.webpay.webpay_jwt.get_product_jwt",
"amo.helpers... | [((633, 658), 'mkt.webpay.webpay_jwt.WebAppProduct', 'WebAppProduct', (['self.addon'], {}), '(self.addon)\n', (646, 658), False, 'from mkt.webpay.webpay_jwt import get_product_jwt, WebAppProduct, InAppProduct\n'), ((680, 744), 'mkt.webpay.webpay_jwt.get_product_jwt', 'get_product_jwt', (['self.product'], {'region': 're... |
# TODO: remove all references to this file and replace with hydra params
import os
# os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
# os.environ["CUDA_VISIBLE_DEVICES"] = "2"
# os.environ["HYDRA_FULL_ERROR"] = "1"
# directories
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
DATA_DIR = os.path.join(BASE_DIR, "d... | [
"os.path.abspath",
"os.path.join"
] | [((295, 325), 'os.path.join', 'os.path.join', (['BASE_DIR', '"""data"""'], {}), "(BASE_DIR, 'data')\n", (307, 325), False, 'import os\n'), ((347, 391), 'os.path.join', 'os.path.join', (['DATA_DIR', '"""surface_form_dicts"""'], {}), "(DATA_DIR, 'surface_form_dicts')\n", (359, 391), False, 'import os\n'), ((422, 480), 'o... |
#!/usr/bin/env python
import io, re, argparse, os.path, sys
import oyaml as yaml
from distutils.spawn import find_executable
bash_exe=find_executable('bash')
helm_exe = os.environ.get("HELM_BIN","helm")
debug = os.environ.get("HELM_DEBUG","false")
namespace = os.environ.get("HELM_NAMESPACE","kube-system")
context = os... | [
"distutils.spawn.find_executable",
"argparse.ArgumentParser",
"subprocess.Popen",
"sys.exit",
"oyaml.safe_load"
] | [((135, 158), 'distutils.spawn.find_executable', 'find_executable', (['"""bash"""'], {}), "('bash')\n", (150, 158), False, 'from distutils.spawn import find_executable\n'), ((3854, 3897), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'prog': '"""helm deploy"""'}), "(prog='helm deploy')\n", (3877, 3897), F... |
import time
from calibration_point import CalibrationPoint
from calibration_results import CalibrationResults
class Calibrator:
def __init__(self, calibration_log, frequency_counter, device_factory, vdd_volts_range):
if calibration_log is None:
raise TypeError('calibration_log')
if frequency_counter is None:... | [
"calibration_results.CalibrationResults",
"time.sleep",
"calibration_point.CalibrationPoint"
] | [((2843, 2920), 'calibration_point.CalibrationPoint', 'CalibrationPoint', (['samples', 'vdd_volts', 'temperature_celsius', 'clock_frequency_hz'], {}), '(samples, vdd_volts, temperature_celsius, clock_frequency_hz)\n', (2859, 2920), False, 'from calibration_point import CalibrationPoint\n'), ((1846, 1898), 'calibration_... |
import logging
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import model
import simulation
import complexity
import rateless
import plot
import stats
from math import log2
from evaluation.binsearch import SampleEvaluator
from evaluation import analytic
from solvers.heuristicsolver import Heur... | [
"pandas.read_csv",
"matplotlib.pyplot.ylabel",
"math.log2",
"matplotlib.pyplot.semilogy",
"numpy.fromiter",
"plot.encode_decode_plot",
"numpy.searchsorted",
"matplotlib.pyplot.xlabel",
"stats.order_mean_shiftexp",
"matplotlib.pyplot.style.use",
"numpy.diff",
"simulation.simulate_parameter_list... | [((378, 401), 'matplotlib.pyplot.style.use', 'plt.style.use', (['"""ggplot"""'], {}), "('ggplot')\n", (391, 401), True, 'import matplotlib.pyplot as plt\n'), ((402, 437), 'matplotlib.pyplot.rc', 'plt.rc', (['"""pgf"""'], {'texsystem': '"""pdflatex"""'}), "('pgf', texsystem='pdflatex')\n", (408, 437), True, 'import matp... |
r"""
Finite dimensional Hopf algebras with basis
"""
#*****************************************************************************
# Copyright (C) 2008 <NAME> (CNRS) <<EMAIL>>
#
# Distributed under the terms of the GNU General Public License (GPL)
# http://www.gnu.org/licenses/
#********************... | [
"sage.categories.all.FiniteDimensionalBialgebrasWithBasis",
"sage.categories.all.HopfAlgebrasWithBasis"
] | [((1602, 1641), 'sage.categories.all.FiniteDimensionalBialgebrasWithBasis', 'FiniteDimensionalBialgebrasWithBasis', (['R'], {}), '(R)\n', (1638, 1641), False, 'from sage.categories.all import FiniteDimensionalBialgebrasWithBasis, HopfAlgebrasWithBasis\n'), ((1643, 1667), 'sage.categories.all.HopfAlgebrasWithBasis', 'Ho... |
import c4d
from c4d import documents
from . import Utilities as util
from .CustomIterators import ObjectIterator
from .Utilities import dazToC4Dutils
from .IkMax import applyDazIK, ikmaxUtils
from .AllSceneToZero import AllSceneToZero
dazName = "Object_"
class DazToC4D:
def figureFixBrute(self):
"""Har... | [
"c4d.BaseTag",
"c4d.DrawViews",
"c4d.documents.GetActiveDocument",
"c4d.Vector",
"c4d.EventAdd"
] | [((388, 421), 'c4d.documents.GetActiveDocument', 'c4d.documents.GetActiveDocument', ([], {}), '()\n', (419, 421), False, 'import c4d\n'), ((1841, 1874), 'c4d.documents.GetActiveDocument', 'c4d.documents.GetActiveDocument', ([], {}), '()\n', (1872, 1874), False, 'import c4d\n'), ((2564, 2593), 'c4d.documents.GetActiveDo... |
import json
from enum import Enum
from test.util import TestCase
from OpenCast.app.command.video import CreateVideo
from OpenCast.app.tool.json_encoder import (
EnhancedJSONEncoder,
EventEncoder,
ModelEncoder,
)
from OpenCast.domain.event.video import VideoCreated
from OpenCast.domain.model.player import P... | [
"OpenCast.domain.model.video.Path",
"OpenCast.domain.service.identity.IdentityService.random",
"OpenCast.domain.model.player.Player",
"OpenCast.domain.model.video.Video",
"OpenCast.domain.model.video.Stream",
"json.dumps",
"OpenCast.domain.service.identity.IdentityService.id_video",
"OpenCast.domain.e... | [((529, 553), 'OpenCast.domain.service.identity.IdentityService.random', 'IdentityService.random', ([], {}), '()\n', (551, 553), False, 'from OpenCast.domain.service.identity import IdentityService\n'), ((562, 609), 'json.dumps', 'json.dumps', (["{'id': id}"], {'cls': 'EnhancedJSONEncoder'}), "({'id': id}, cls=Enhanced... |
import subprocess, re, sys,os, os.path, shutil, time, glob
ROOT="/home/blackie/dump/KDABViewer"
BUILDROOT=ROOT+"/build"
ITERATIONS=5
FOREAL=1
CCACHE="/usr/lib/ccache"
def runCommand(cmd):
print(" ".join(cmd))
if FOREAL:
process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
... | [
"re.compile",
"subprocess.Popen",
"os.chdir",
"os.mkdir",
"shutil.rmtree",
"time.time",
"glob.glob"
] | [((4118, 4164), 're.compile', 're.compile', (['"""^#include *<(Q.*/)?([a-zA-Z_]+)>"""'], {}), "('^#include *<(Q.*/)?([a-zA-Z_]+)>')\n", (4128, 4164), False, 'import subprocess, re, sys, os, os.path, shutil, time, glob\n'), ((1666, 1677), 'time.time', 'time.time', ([], {}), '()\n', (1675, 1677), False, 'import subproces... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sat Jun 23 21:02:09 2018
@author: airos
"""
import librosa
import numpy as np
import matplotlib.pyplot as plt
from rednoise_fun import rednoise, wave2stft, stft2power, get_mean_bandwidths, get_var_bandwidths, stft2wave, savewave, get_date, matchvol, get_p... | [
"rednoise_fun.rednoise",
"rednoise_fun.get_mean_bandwidths",
"rednoise_fun.wave2stft",
"rednoise_fun.get_date",
"matplotlib.pyplot.plot",
"rednoise_fun.stft2wave",
"rednoise_fun.get_pitch_mean",
"rednoise_fun.pitch_sqrt",
"rednoise_fun.get_var_bandwidths",
"rednoise_fun.get_pitch",
"rednoise_fun... | [((503, 519), 'rednoise_fun.wave2stft', 'wave2stft', (['noise'], {}), '(noise)\n', (512, 519), False, 'from rednoise_fun import rednoise, wave2stft, stft2power, get_mean_bandwidths, get_var_bandwidths, stft2wave, savewave, get_date, matchvol, get_pitch, get_pitch_mean, load_wave, pitch_sqrt\n'), ((535, 552), 'rednoise_... |
import gym
import gym.spaces
#from gym import spaces
env = gym.make('CartPole-v0')
def softmax_action(env,memory_state,observation,θ_action):
prob_list=np.exp(θ_action[memory_state,env.observation]) ##clipping the softmax function to prevent saturation
#print(memory_state)
den=np.sum(prob_list)
prob=[... | [
"gym.make"
] | [((60, 83), 'gym.make', 'gym.make', (['"""CartPole-v0"""'], {}), "('CartPole-v0')\n", (68, 83), False, 'import gym\n')] |
"""友駿ホームページから情報を取得する."""
import logging
import re
import time
from datetime import date, datetime
from urllib.parse import urlencode, urljoin
import requests
from bs4 import BeautifulSoup
import settings
logger = logging.getLogger()
def get_horse_latest_statuses(today):
"""友駿馬の直近の近況を返す.
Arguments:
... | [
"logging.getLogger",
"argparse.ArgumentParser",
"settings.YUSHUN_HORSE_ID.split",
"datetime.datetime.strptime",
"requests.get",
"time.sleep",
"bs4.BeautifulSoup",
"re.fullmatch",
"datetime.date",
"urllib.parse.urljoin",
"urllib.parse.urlencode",
"datetime.date.today",
"pprint.pprint"
] | [((216, 235), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (233, 235), False, 'import logging\n'), ((427, 462), 'settings.YUSHUN_HORSE_ID.split', 'settings.YUSHUN_HORSE_ID.split', (['""";"""'], {}), "(';')\n", (457, 462), False, 'import settings\n'), ((1020, 1069), 'urllib.parse.urlencode', 'urlencode', ... |
"""
This example schedules a large number of dynamic tasks and then runs them (in multiple processes)
as a way to gauge the total throughput of Pyncette for a particular backend.
To run this example, configure the selected backend in the Pyncette constructor, then run populate the database.
python examples/benchm... | [
"logging.getLogger",
"pyncette.Pyncette",
"asyncio.sleep",
"argparse.ArgumentParser",
"coloredlogs.install",
"random.randrange",
"time.perf_counter",
"uvloop.install",
"uuid.uuid4",
"datetime.datetime.now",
"asyncio.gather",
"multiprocessing.sharedctypes.RawValue"
] | [((1072, 1099), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1089, 1099), False, 'import logging\n'), ((1133, 1258), 'pyncette.Pyncette', 'Pyncette', ([], {'repository_factory': 'redis_repository', 'redis_url': '"""redis://localhost"""', 'redis_namespace': '"""benchmark"""', 'batch_siz... |
#!/usr/bin/env python
from flask import Flask, request
from decimal import *
from pprint import pprint
import rrdtool
import logging
app = Flask(__name__)
@app.route('/log_temp')
def log_temp():
# show the post with the given id, the id is an integer
temp=Decimal(request.args.get('temp'))
humidity=Decimal... | [
"flask.request.args.get",
"flask.Flask"
] | [((140, 155), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (145, 155), False, 'from flask import Flask, request\n'), ((362, 388), 'flask.request.args.get', 'request.args.get', (['"""sensor"""'], {}), "('sensor')\n", (378, 388), False, 'from flask import Flask, request\n'), ((274, 298), 'flask.request.arg... |
from urllib.parse import quote_plus as qp
from bunny3.command import BunnyCommand
class youtube(BunnyCommand):
def __init__(self):
super().__init__()
self.aliases = ["youtube"]
self.description = "Youtube Search"
self.name = "Youtube"
self.url = "https://www.youtube.com/"
... | [
"urllib.parse.quote_plus"
] | [((425, 433), 'urllib.parse.quote_plus', 'qp', (['args'], {}), '(args)\n', (427, 433), True, 'from urllib.parse import quote_plus as qp\n')] |
import os
import lldb
class AtomicLLSyntheticFormatter:
count = None
def __init__(self, valobj, dict):
self.valobj = valobj
def next_node(self, node):
return (node
.GetChildMemberWithName('hook')
.GetChildMemberWithName('next')
)
def is_valid(s... | [
"os.path.basename"
] | [((3656, 3682), 'os.path.basename', 'os.path.basename', (['__file__'], {}), '(__file__)\n', (3672, 3682), False, 'import os\n')] |
"""Implementation of sequence subpackage"""
__all__ = [
"AbstractSequence",
"TrivialSequence",
"FiniteSequence",
"OrderedLoopingSequence",
"ShuffledLoopingSequence",
"WithPeek",
]
from collections.abc import Iterable, Iterator
from abc import abstractmethod
import random
from nextsong.sample ... | [
"nextsong.sample.weighted_choice",
"random.shuffle",
"random.randint",
"nextsong.sample.sublist"
] | [((5187, 5216), 'random.randint', 'random.randint', (['*self.__count'], {}), '(*self.__count)\n', (5201, 5216), False, 'import random\n'), ((5292, 5337), 'nextsong.sample.sublist', 'sublist', (['self.__items', 'count'], {'weights': 'weights'}), '(self.__items, count, weights=weights)\n', (5299, 5337), False, 'from next... |
import glob
import random
training_rate = 0.9999
val_rate = 0.0001
def find_files(path, pattren="*.wav"):
filenames = []
for filename in glob.iglob(f'{path}/**/*{pattren}', recursive=True):
filenames.append(filename)
return filenames
def create_metadata(path="datasets"):
wav_lists = find_fi... | [
"random.shuffle",
"glob.iglob"
] | [((148, 199), 'glob.iglob', 'glob.iglob', (['f"""{path}/**/*{pattren}"""'], {'recursive': '(True)'}), "(f'{path}/**/*{pattren}', recursive=True)\n", (158, 199), False, 'import glob\n'), ((339, 364), 'random.shuffle', 'random.shuffle', (['wav_lists'], {}), '(wav_lists)\n', (353, 364), False, 'import random\n')] |
#!/usr/bin/env python
# -*- coding: utf-8 -*-、
import threading
import time
class MyThread1(threading.Thread):
def run(self):
# 对mutexA上锁
mutexA.acquire()
# mutexA上锁后， 延时1秒， 等待另外那个线程 把mutexB上锁
print(self.name+'----do1---up----')
time.sleep(1)
# 此时会堵塞， 因为这个mutexB已经... | [
"threading.Lock",
"time.sleep"
] | [((880, 896), 'threading.Lock', 'threading.Lock', ([], {}), '()\n', (894, 896), False, 'import threading\n'), ((906, 922), 'threading.Lock', 'threading.Lock', ([], {}), '()\n', (920, 922), False, 'import threading\n'), ((276, 289), 'time.sleep', 'time.sleep', (['(1)'], {}), '(1)\n', (286, 289), False, 'import time\n'),... |