code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
import pandas as pd
import numpy as np
class CorrectBias(object):
def __init__(self, taper_width, npv_observations):
self.taper_width = taper_width
self.sampled_controls_loc, self.sampled_controls_beta = self.get_data(npv_observations)
self.est_mean_alpha = np.mean(self.sampled_controls_be... | [
"numpy.mean",
"numpy.abs",
"numpy.reshape",
"pandas.read_csv",
"numpy.where",
"numpy.array",
"numpy.zeros",
"numpy.sum",
"numpy.setdiff1d"
] | [((7861, 7895), 'pandas.read_csv', 'pd.read_csv', (['"""npv_obs_example.csv"""'], {}), "('npv_obs_example.csv')\n", (7872, 7895), True, 'import pandas as pd\n'), ((288, 323), 'numpy.mean', 'np.mean', (['self.sampled_controls_beta'], {}), '(self.sampled_controls_beta)\n', (295, 323), True, 'import numpy as np\n'), ((304... |
"""
This module holds default translations from pandas syntax to sql for 3 kinds of operations...
1. scalar - elementwise operations (e.g. array1 + array2)
2. aggregation - operations that result in a single number (e.g. array1.mean())
3. window - operations that do calculations across a window
(e.g. array... | [
"sqlalchemy.sql.func.date_trunc",
"itertools.chain",
"sqlalchemy.sql.func.distinct",
"sqlalchemy.sql.func.left",
"sqlalchemy.sql.text",
"sqlalchemy.sql.cast",
"sqlalchemy.sql.util.visitors.traverse",
"sqlalchemy.sql.func.greatest",
"warnings.warn",
"sqlalchemy.sql.func.lag",
"sqlalchemy.sql.func... | [((1828, 1888), 'sqlalchemy.sql.util.visitors.traverse', 'sql.util.visitors.traverse', (['clause', '{}', "{'over': append_win}"], {}), "(clause, {}, {'over': append_win})\n", (1854, 1888), False, 'from sqlalchemy import sql\n'), ((4784, 4816), 'sqlalchemy.sql.cast', 'sql.cast', (['monday0', 'types.Numeric'], {}), '(mon... |
"""Get agent details from the public api."""
import json
from typing import Dict, Optional
from ostorlab.apis import request
class AgentDetailsAPIRequest(request.APIRequest):
"""Get agent details for a specified agent_key."""
def __init__(self, agent_key: str) -> None:
"""Initializer"""
self... | [
"json.dumps"
] | [((1395, 1436), 'json.dumps', 'json.dumps', (["{'agentKey': self._agent_key}"], {}), "({'agentKey': self._agent_key})\n", (1405, 1436), False, 'import json\n')] |
#!/usr/bin/env python3
import argparse
import os
from pathlib import Path
import subprocess
import sys
def get_alarm_location():
config_path = Path('~/.alarm-location').expanduser()
default = Path('~/bin/alarm.py').expanduser()
try:
with config_path.open() as f:
return f.read().strip('... | [
"subprocess.run",
"pathlib.Path",
"argparse.ArgumentParser",
"sys.exit"
] | [((1709, 1795), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Add an alarm. Blank fields default to "*"."""'}), '(description=\n \'Add an alarm. Blank fields default to "*".\')\n', (1732, 1795), False, 'import argparse\n'), ((1582, 1639), 'subprocess.run', 'subprocess.run', (["['cron... |
import numpy as np
def expected_calibration_error(y_pred, proba, y_true, n_bins=10):
intervals = np.linspace(0, 1, n_bins+1)
accuracy = (y_pred == y_true).astype(int)
num_predictions = y_pred.shape[0]
error = 0
for lower, upper in zip(intervals[:-1], intervals[1:]):
mask = np.logical_an... | [
"numpy.abs",
"numpy.linspace",
"numpy.logical_and"
] | [((104, 133), 'numpy.linspace', 'np.linspace', (['(0)', '(1)', '(n_bins + 1)'], {}), '(0, 1, n_bins + 1)\n', (115, 133), True, 'import numpy as np\n'), ((307, 352), 'numpy.logical_and', 'np.logical_and', (['(proba > lower)', '(proba <= upper)'], {}), '(proba > lower, proba <= upper)\n', (321, 352), True, 'import numpy ... |
import pytest
import requests
from tenacity import RetryError
import pipeline_tools.shared.submission.get_upload_urn as getter
from pipeline_tools.shared.http_requests import HttpRequests
from pipeline_tools.tests.http_requests_manager import HttpRequestsManager
@pytest.fixture(scope='module')
def test_data():
c... | [
"pipeline_tools.shared.submission.get_upload_urn.get_upload_urn",
"pipeline_tools.tests.http_requests_manager.HttpRequestsManager",
"pytest.raises",
"pytest.fixture",
"pipeline_tools.shared.http_requests.HttpRequests"
] | [((267, 297), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""module"""'}), "(scope='module')\n", (281, 297), False, 'import pytest\n'), ((677, 702), 'pipeline_tools.shared.submission.get_upload_urn.get_upload_urn', 'getter.get_upload_urn', (['js'], {}), '(js)\n', (698, 702), True, 'import pipeline_tools.shared.... |
import asyncio
def main():
loop = asyncio.get_event_loop()
# Initialize components
hisayer = HiSayer()
loop.create_task(hisayer.run())
splitter = StringSplitter()
loop.create_task(splitter.run())
lowercaser = LowerCaser()
loop.create_task(lowercaser.run())
uppercaser = UpperCas... | [
"asyncio.get_event_loop",
"asyncio.Queue"
] | [((40, 64), 'asyncio.get_event_loop', 'asyncio.get_event_loop', ([], {}), '()\n', (62, 64), False, 'import asyncio\n'), ((921, 936), 'asyncio.Queue', 'asyncio.Queue', ([], {}), '()\n', (934, 936), False, 'import asyncio\n'), ((1102, 1117), 'asyncio.Queue', 'asyncio.Queue', ([], {}), '()\n', (1115, 1117), False, 'import... |
from unittest import TestCase
EXAMPLES_PATH = '../examples'
SKIPPED_EXAMPLES = {472, 473, 477}
def _set_test_class():
import re
from imp import load_module, find_module, PY_SOURCE
from pathlib import Path
def _load_module(name, file, pathname, description):
try:
load_module(name,... | [
"pathlib.Path",
"re.compile",
"re.match",
"imp.load_module",
"imp.find_module"
] | [((752, 781), 're.compile', 're.compile', (['"""\\\\d+\\\\. .+\\\\.py"""'], {}), "('\\\\d+\\\\. .+\\\\.py')\n", (762, 781), False, 'import re\n'), ((303, 349), 'imp.load_module', 'load_module', (['name', 'file', 'pathname', 'description'], {}), '(name, file, pathname, description)\n', (314, 349), False, 'from imp impor... |
from dolo.numeric.tensor import sdot,mdot
import numpy as np
TOL = 1e-10
# credits : second_order_solver is adapted from <NAME>'s port of Uhlig's Toolkit.
def second_order_solver(FF,GG,HH):
from scipy.linalg import qz
from dolo.numeric.extern.qz import qzdiv
from numpy import array,mat,c_,r_,eye,z... | [
"numpy.eye",
"numpy.linalg.solve",
"scipy.linalg.qz",
"dolo.numeric.tensor.sdot",
"dolo.numeric.extern.qz.qzdiv",
"numpy.diag",
"numpy.kron",
"numpy.array",
"numpy.zeros",
"numpy.diagflat",
"numpy.real_if_close",
"slycot.sb04qd"
] | [((422, 431), 'numpy.array', 'array', (['FF'], {}), '(FF)\n', (427, 431), False, 'from numpy import array, mat, c_, r_, eye, zeros, real_if_close, diag, allclose, where, diagflat\n'), ((448, 458), 'numpy.array', 'array', (['(-GG)'], {}), '(-GG)\n', (453, 458), False, 'from numpy import array, mat, c_, r_, eye, zeros, r... |
from selenium import webdriver
import time
from selenium.webdriver.common.by import By
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.support import expected_conditions as EC
browser = webdriver.Chrome("C:\\Windows\\chromedriver.exe")
browser.get("http://localhost:1667")
browser.ma... | [
"selenium.webdriver.Chrome",
"selenium.webdriver.support.expected_conditions.visibility_of_element_located",
"selenium.webdriver.support.wait.WebDriverWait",
"time.sleep"
] | [((222, 271), 'selenium.webdriver.Chrome', 'webdriver.Chrome', (['"""C:\\\\Windows\\\\chromedriver.exe"""'], {}), "('C:\\\\Windows\\\\chromedriver.exe')\n", (238, 271), False, 'from selenium import webdriver\n'), ((336, 349), 'time.sleep', 'time.sleep', (['(2)'], {}), '(2)\n', (346, 349), False, 'import time\n'), ((414... |
import hppuml
import sys
with open(sys.argv[1], 'rb') as f:
data = f.read()
print(hppuml.run(data))
| [
"hppuml.run"
] | [((91, 107), 'hppuml.run', 'hppuml.run', (['data'], {}), '(data)\n', (101, 107), False, 'import hppuml\n')] |
"""Utility or convienence functions.
----
Copyright 2019 Data Driven Empathy LLC
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 without limitation the rights to u... | [
"re.findall"
] | [((1501, 1535), 're.findall', 're.findall', (['"""[\\\\w\\\\\'\\\\\\\\-]+"""', 'text'], {}), '("[\\\\w\\\\\'\\\\\\\\-]+", text)\n', (1511, 1535), False, 'import re\n')] |
def plot_rdm(rdm, mat=0, cmap=None):
'''function to visualize RDM based rank transformed and scaled similarity values
(only for plotting, raw/initial values remain unchanged'''
from os.path import join as opj
from scipy.io.matlab import loadmat
from nilearn.connectome import sym_matrix_to_vec
... | [
"scipy.stats.rankdata",
"pandas.read_csv",
"nilearn.connectome.vec_to_sym_matrix",
"seaborn.heatmap",
"nilearn.connectome.sym_matrix_to_vec",
"matplotlib.pyplot.tight_layout",
"sklearn.preprocessing.MinMaxScaler",
"scipy.io.matlab.loadmat"
] | [((708, 733), 'pandas.read_csv', 'pd.read_csv', (['rdm'], {'sep': '""","""'}), "(rdm, sep=',')\n", (719, 733), True, 'import pandas as pd\n'), ((870, 892), 'nilearn.connectome.sym_matrix_to_vec', 'sym_matrix_to_vec', (['rdm'], {}), '(rdm)\n', (887, 892), False, 'from nilearn.connectome import sym_matrix_to_vec\n'), ((9... |
import unittest
from color import Color
from point import Point
from patterns.checker_board import CheckerBoard
class TestCheckerBoard(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.white = Color(red=1, green=1, blue=1)
cls.black = Color(red=0, green=0, blue=0)
def test_color_... | [
"unittest.main",
"color.Color",
"patterns.checker_board.CheckerBoard",
"point.Point"
] | [((1854, 1869), 'unittest.main', 'unittest.main', ([], {}), '()\n', (1867, 1869), False, 'import unittest\n'), ((220, 249), 'color.Color', 'Color', ([], {'red': '(1)', 'green': '(1)', 'blue': '(1)'}), '(red=1, green=1, blue=1)\n', (225, 249), False, 'from color import Color\n'), ((270, 299), 'color.Color', 'Color', ([]... |
# Copyright (c) 2017 <NAME>
#
# SPDX-License-Identifier: BSD-3-Clause
# The BSD-3-Clause license for this file can be found in the LICENSE file included with this distribution
# or at https://spdx.org/licenses/BSD-3-Clause.html#licenseText
import os
import logging
import collections
from time import time
f... | [
"logging.getLogger",
"collections.deque",
"struct.pack",
"pywinusb.hid.find_all_hid_devices",
"time.time",
"struct.unpack_from"
] | [((453, 483), 'logging.getLogger', 'logging.getLogger', (['"""MBOOT:USB"""'], {}), "('MBOOT:USB')\n", (470, 483), False, 'import logging\n'), ((2870, 2906), 'struct.pack', 'pack', (['"""<2BH"""', 'report_id', '(0)', 'data_len'], {}), "('<2BH', report_id, 0, data_len)\n", (2874, 2906), False, 'from struct import pack, u... |
import jenkins
import pandas as pd
from kpireport.datasource import Datasource
import logging
LOG = logging.getLogger(__name__)
class JenkinsDatasource(Datasource):
"""Provides accessors for listing all jobs and builds from a Jenkins host.
The Jenkins Datasource exposes an RPC-like interface to fetch all ... | [
"logging.getLogger",
"pandas.json_normalize",
"jenkins.Jenkins"
] | [((103, 130), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (120, 130), False, 'import logging\n'), ((956, 1012), 'jenkins.Jenkins', 'jenkins.Jenkins', (['host'], {'username': 'user', 'password': 'api_token'}), '(host, username=user, password=api_token)\n', (971, 1012), False, 'import je... |
from setuptools import setup, Extension
import versioneer
commands = versioneer.get_cmdclass().copy()
extension = Extension('demo.ext',
sources=['demo/ext.c'],
)
setup(name="demoappext",
version=versioneer.get_version(),
description="Demo",
url="url",
author="author",
... | [
"setuptools.Extension",
"versioneer.get_cmdclass",
"versioneer.get_version"
] | [((116, 161), 'setuptools.Extension', 'Extension', (['"""demo.ext"""'], {'sources': "['demo/ext.c']"}), "('demo.ext', sources=['demo/ext.c'])\n", (125, 161), False, 'from setuptools import setup, Extension\n'), ((70, 95), 'versioneer.get_cmdclass', 'versioneer.get_cmdclass', ([], {}), '()\n', (93, 95), False, 'import v... |
import unittest
from stensorflow.engine.start_server import start_local_server
import tensorflow as tf
import stensorflow as stf
from stensorflow.random.random import random_init
from stensorflow.basic.basic_class.private import PrivateTensor
from stensorflow.ml.logistic_regression import LogisticRegression
from stenso... | [
"tensorflow.random.normal",
"stensorflow.ml.logistic_regression.LogisticRegression",
"stensorflow.ml.logistic_regression2.LogisticRegression2",
"stensorflow.PrivateTensor",
"os.path.join",
"os.environ.get",
"tensorflow.compat.v1.disable_eager_execution",
"unittest.main",
"tensorflow.compat.v1.Sessio... | [((400, 432), 'os.environ.get', 'os.environ.get', (['"""stf_home"""', '""".."""'], {}), "('stf_home', '..')\n", (414, 432), False, 'import os\n'), ((452, 497), 'os.path.join', 'os.path.join', (['stf_home', '"""conf"""', '"""config.json"""'], {}), "(stf_home, 'conf', 'config.json')\n", (464, 497), False, 'import os\n'),... |
# -*- coding: utf-8 -*-
"""Collection of mathematical functions."""
import numpy as np
from .core import (angle, besselI0, besselI1, besselK0, besselK1, cos,
cot, det, dot, exp, exp10, imag, log, log10, max, median,
min, pow, rand, randn, real, rms, round, rrms, sign,
... | [
"numpy.abs",
"numpy.sign"
] | [((1011, 1021), 'numpy.sign', 'np.sign', (['x'], {}), '(x)\n', (1018, 1021), True, 'import numpy as np\n'), ((988, 997), 'numpy.abs', 'np.abs', (['x'], {}), '(x)\n', (994, 997), True, 'import numpy as np\n'), ((1038, 1053), 'numpy.abs', 'np.abs', (['(x / tol)'], {}), '(x / tol)\n', (1044, 1053), True, 'import numpy as ... |
from django.shortcuts import render, get_object_or_404
from joblistings.models import Job
from jobapplications.models import JobApplication, Resume, CoverLetter, Education, Experience, Ranking, SupportingDocument
from jobapplications.forms import ApplicationForm, resumeUpload, FilterApplicationForm
from django_sendfile... | [
"notifications.signals.notify.send",
"accounts.models.User.objects.get",
"jobapplications.models.Ranking.objects.filter",
"announcements.models.GlobalAnnouncement.objects.filter",
"io.BytesIO",
"jobapplications.models.Experience.objects.filter",
"django.utils.http.urlsafe_base64_decode",
"PyPDF2.PdfFi... | [((2744, 2773), 'django.shortcuts.get_object_or_404', 'get_object_or_404', (['Job'], {'pk': 'pk'}), '(Job, pk=pk)\n', (2761, 2773), False, 'from django.shortcuts import render, get_object_or_404\n'), ((3901, 3944), 'django.shortcuts.render', 'render', (['request', '"""add-resume.html"""', 'context'], {}), "(request, 'a... |
"""Tests for the base DTA record"""
from unittest.mock import patch
from swissdta.records.record import DTARecord
@patch('swissdta.records.header.DTAHeader.validate')
def test_validate_header(mocker):
"""Verifies that the record validation triggers the header validation."""
record = DTARecord()
assert n... | [
"unittest.mock.patch",
"swissdta.records.record.DTARecord"
] | [((119, 170), 'unittest.mock.patch', 'patch', (['"""swissdta.records.header.DTAHeader.validate"""'], {}), "('swissdta.records.header.DTAHeader.validate')\n", (124, 170), False, 'from unittest.mock import patch\n'), ((296, 307), 'swissdta.records.record.DTARecord', 'DTARecord', ([], {}), '()\n', (305, 307), False, 'from... |
import os
import sys
d = "localedata"
d = os.path.join(sys._MEIPASS, d)
import babel.localedata
babel.localedata._dirname = d
| [
"os.path.join"
] | [((43, 72), 'os.path.join', 'os.path.join', (['sys._MEIPASS', 'd'], {}), '(sys._MEIPASS, d)\n', (55, 72), False, 'import os\n')] |
import unittest
import hail as hl
from .flags import (
get_expr_for_consequence_lc_lof_flag,
get_expr_for_variant_lc_lof_flag,
get_expr_for_genes_with_lc_lof_flag,
get_expr_for_consequence_loftee_flag_flag,
get_expr_for_variant_loftee_flag_flag,
get_expr_for_genes_with_loftee_flag_flag,
)
cl... | [
"unittest.main",
"hail.struct"
] | [((4205, 4220), 'unittest.main', 'unittest.main', ([], {}), '()\n', (4218, 4220), False, 'import unittest\n'), ((443, 504), 'hail.struct', 'hl.struct', ([], {'gene_id': '"""foo"""', 'lof': '"""LC"""', 'lof_flags': '""""""', 'lof_info': '""""""'}), "(gene_id='foo', lof='LC', lof_flags='', lof_info='')\n", (452, 504), Tr... |
# Copyright Amazon.com Inc. or its affiliates. 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. A copy of the
# License is located at
#
# http://aws.amazon.com/apache2.0/
#
# or in the "license" file accompanyin... | [
"logging.getLogger",
"acktest.aws.identity.get_region",
"boto3.client",
"re.match",
"logging.exception",
"boto3.resource",
"acktest.resources.read_bootstrap_config",
"logging.info",
"e2e.bootstrap_resources.TestBootstrapResources"
] | [((1050, 1062), 'acktest.aws.identity.get_region', 'get_region', ([], {}), '()\n', (1060, 1062), False, 'from acktest.aws.identity import get_region\n'), ((1078, 1122), 'boto3.client', 'boto3.client', (['"""dynamodb"""'], {'region_name': 'region'}), "('dynamodb', region_name=region)\n", (1090, 1122), False, 'import bot... |
# Generated by Django 3.2.9 on 2022-01-07 19:32
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('users', '0004_alter_profile_countries'),
]
operations = [
migrations.AddField(
model_name='profile',
name='username'... | [
"django.db.models.CharField"
] | [((340, 383), 'django.db.models.CharField', 'models.CharField', ([], {'blank': '(True)', 'max_length': '(35)'}), '(blank=True, max_length=35)\n', (356, 383), False, 'from django.db import migrations, models\n')] |
# -*- coding: utf-8 -*-
from django.conf import settings
from django.contrib.auth import REDIRECT_FIELD_NAME
from django.contrib.auth.decorators import login_required as django_login_required, user_passes_test
from django.contrib.auth.views import redirect_to_login
from django.core.exceptions import PermissionDenied
f... | [
"django.contrib.auth.decorators.user_passes_test",
"django.contrib.auth.views.redirect_to_login",
"django.shortcuts.resolve_url",
"django.contrib.auth.decorators.login_required"
] | [((3654, 3718), 'django.contrib.auth.views.redirect_to_login', 'redirect_to_login', (['path', 'resolved_login_url', 'redirect_field_name'], {}), '(path, resolved_login_url, redirect_field_name)\n', (3671, 3718), False, 'from django.contrib.auth.views import redirect_to_login\n'), ((881, 969), 'django.contrib.auth.decor... |
import sqlite3, random, time
cnx = sqlite3.connect('taqueria.db')
cursor = cnx.cursor()
def queryTacos():
consultarTacos = cursor.execute("SELECT ID, Nombre_Taco FROM tacos")
return consultarTacos.fetchall()
def queryClientes():
consultarClientes = cursor.execute("SELECT ID, Nombre FROM clientes")
re... | [
"random.randint",
"sqlite3.connect",
"time.sleep"
] | [((36, 66), 'sqlite3.connect', 'sqlite3.connect', (['"""taqueria.db"""'], {}), "('taqueria.db')\n", (51, 66), False, 'import sqlite3, random, time\n'), ((1895, 1917), 'random.randint', 'random.randint', (['(0)', '(100)'], {}), '(0, 100)\n', (1909, 1917), False, 'import sqlite3, random, time\n'), ((3495, 3508), 'time.sl... |
from plenum.common.constants import DOMAIN_LEDGER_ID
from plenum.test.stasher import delay_rules
from plenum.test.delayers import cr_delay
from plenum.test.test_node import checkNodesConnected
from plenum.test.pool_transactions.helper import \
disconnect_node_and_ensure_disconnected
from indy_node.test.helper imp... | [
"sovtokenfees.test.helpers.HelperNode.fill_auth_map_for_node",
"indy_node.test.helper.start_stopped_node",
"plenum.test.delayers.cr_delay",
"sovtokenfees.test.helper.ensure_all_nodes_have_same_data",
"plenum.test.pool_transactions.helper.disconnect_node_and_ensure_disconnected",
"plenum.test.test_node.che... | [((806, 898), 'plenum.test.pool_transactions.helper.disconnect_node_and_ensure_disconnected', 'disconnect_node_and_ensure_disconnected', (['looper', 'nodes', 'lagging_node.name'], {'stopNode': '(True)'}), '(looper, nodes, lagging_node.name,\n stopNode=True)\n', (845, 898), False, 'from plenum.test.pool_transactions.... |
"""Remove comments that are only linked to an @name."""
import logging
from uuid import UUID
from fluiddb.data.comment import CommentObjectLink
from fluiddb.data.tag import getTags
from fluiddb.data.value import TagValue
from fluiddb.scripts.commands import setupStore
BATCH_SIZE = 100
def migrate(store):
# Fi... | [
"logging.basicConfig",
"fluiddb.data.value.TagValue.objectID.is_in",
"uuid.UUID",
"fluiddb.scripts.commands.setupStore",
"logging.info",
"logging.error",
"fluiddb.data.tag.getTags"
] | [((2269, 2402), 'logging.basicConfig', 'logging.basicConfig', ([], {'filename': '"""/mnt/unlink-log/unlink.log"""', 'level': 'logging.INFO', 'format': '"""%(asctime)s %(levelname)8s %(message)s"""'}), "(filename='/mnt/unlink-log/unlink.log', level=logging.\n INFO, format='%(asctime)s %(levelname)8s %(message)s')\n... |
from functools import wraps
from flask import abort
from flask.ext.login import current_user
def admin_required(func):
@wraps(func)
def decorated_function(*args, **kwargs):
if not current_user.is_admin():
abort(403)
return func(*args, **kwargs)
return decorated_function
| [
"flask.abort",
"functools.wraps",
"flask.ext.login.current_user.is_admin"
] | [((125, 136), 'functools.wraps', 'wraps', (['func'], {}), '(func)\n', (130, 136), False, 'from functools import wraps\n'), ((197, 220), 'flask.ext.login.current_user.is_admin', 'current_user.is_admin', ([], {}), '()\n', (218, 220), False, 'from flask.ext.login import current_user\n'), ((234, 244), 'flask.abort', 'abort... |
'''
Created by auto_sdk on 2016.03.15
'''
from top.api.base import RestApi
class FenxiaoDistributorItemsGetRequest(RestApi):
def __init__(self,domain='gw.api.taobao.com',port=80):
RestApi.__init__(self,domain, port)
self.distributor_id = None
self.end_modified = None
self.page_no = None
self.page_size = None... | [
"top.api.base.RestApi.__init__"
] | [((183, 219), 'top.api.base.RestApi.__init__', 'RestApi.__init__', (['self', 'domain', 'port'], {}), '(self, domain, port)\n', (199, 219), False, 'from top.api.base import RestApi\n')] |
import os
def delete_png():
list = os.listdir()
images = [x for x in list if ".png" in x]
for x in images:
os.remove(x)
| [
"os.listdir",
"os.remove"
] | [((39, 51), 'os.listdir', 'os.listdir', ([], {}), '()\n', (49, 51), False, 'import os\n'), ((127, 139), 'os.remove', 'os.remove', (['x'], {}), '(x)\n', (136, 139), False, 'import os\n')] |
import chemprop
import sys
import os
# command line arguments passed to the program, where first arg is optical property(ies), second arg is split type, and third arg is a bool for using same test set
inputs = sys.argv[1:] #e.g. both_peaks scaffold same_test_set
optical_properties = inputs[0]
split_type = inputs[1] #g... | [
"chemprop.args.PredictArgs",
"chemprop.train.cross_validate",
"chemprop.args.TrainArgs",
"os.path.join",
"os.getcwd",
"chemprop.train.make_predictions"
] | [((426, 437), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (435, 437), False, 'import os\n'), ((1564, 1655), 'chemprop.train.cross_validate', 'chemprop.train.cross_validate', ([], {'args': 'train_args', 'train_func': 'chemprop.train.run_training'}), '(args=train_args, train_func=chemprop.train.\n run_training)\n', (1... |
import io, os
from google.cloud import vision
from Nutrition import get_food, traduzione
import csv
import re
os.environ['GOOGLE_APPLICATION_CREDENTIALS'] = r"API_key\\Vision_key.json"
client = vision.ImageAnnotatorClient()
file_name = r"Immagini\\Cibo.png"
### Cose da scartare come sottostringa###
no_food = ["Food"... | [
"google.cloud.vision.ImageAnnotatorClient",
"io.open",
"google.cloud.vision.types.Image",
"Nutrition.traduzione",
"csv.reader",
"Nutrition.get_food"
] | [((195, 224), 'google.cloud.vision.ImageAnnotatorClient', 'vision.ImageAnnotatorClient', ([], {}), '()\n', (222, 224), False, 'from google.cloud import vision\n'), ((541, 563), 'csv.reader', 'csv.reader', (['csv_filter'], {}), '(csv_filter)\n', (551, 563), False, 'import csv\n'), ((871, 906), 'google.cloud.vision.types... |
#! /usr/bin/env python
"""Basic Model Interface implementation for the pyMarshMorpho2D model."""
import numpy as np
from bmipy import Bmi
from pymarshmorpho2d import MarshEvolver
from landlab import load_params
_DEFAULT_PARAMETERS = {
'rel_sl_rise_rate': 0.001 / 365.0,
'tidal_range': 3.1,
}
class MarshMorp... | [
"numpy.finfo",
"numpy.array",
"numpy.zeros",
"landlab.load_params"
] | [((7366, 7459), 'numpy.array', 'np.array', (['[self.grid.number_of_node_rows, self.grid.number_of_node_columns]'], {'dtype': 'np.int'}), '([self.grid.number_of_node_rows, self.grid.number_of_node_columns],\n dtype=np.int)\n', (7374, 7459), True, 'import numpy as np\n'), ((7744, 7755), 'numpy.zeros', 'np.zeros', (['(... |
"""
Authors: <NAME>.
Copyright:
Copyright (c) 2021 Microsoft Research
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 without limitation the rights
to use, copy, mo... | [
"tests.utils.assert_almost_equal",
"onnx.helper.make_node",
"tests.utils.make_onnx_graph",
"pytest.mark.skip",
"pytest.param",
"tests.utils.Compiler",
"pytest.mark.parametrize",
"tests.utils.run_onnx",
"os.path.dirname",
"numpy.zeros",
"tests.utils.ONNXConfig",
"pytest.skip",
"numpy.random.r... | [((4021, 4066), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""dtype"""', '[np.single]'], {}), "('dtype', [np.single])\n", (4044, 4066), False, 'import pytest\n'), ((6702, 6747), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""dtype"""', '[np.single]'], {}), "('dtype', [np.single])\n", (6725, 6... |
# PyGEP: Gene Expression Programming for Python
# Copyright (C) 2007 <NAME>
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later ve... | [
"random.random",
"pygep.util.stats.fitness_stats",
"random.shuffle",
"random.choice"
] | [((5213, 5238), 'pygep.util.stats.fitness_stats', 'stats.fitness_stats', (['self'], {}), '(self)\n', (5232, 5238), False, 'from pygep.util import stats\n'), ((10582, 10602), 'random.shuffle', 'random.shuffle', (['orgs'], {}), '(orgs)\n', (10596, 10602), False, 'import random, string\n'), ((7665, 7695), 'random.choice',... |
# -*- coding: utf-8 -*-
"""コントローラ
本ライブラリにおけるコントローラとは人間に代わってアクション選択を行うプログラムを指す。
"""
import random
class Randomizer(object):
"""選択可能なアクションからランダムに選択を行うコントローラ
"""
def __init__(self, params):
"""初期化
@param params: dict パラメータ
'actions': 選択可能なアクションの数
'seed': 乱数シード
... | [
"random.randint",
"random.seed"
] | [((706, 741), 'random.randint', 'random.randint', (['(0)', '(self.actions - 1)'], {}), '(0, self.actions - 1)\n', (720, 741), False, 'import random\n'), ((486, 513), 'random.seed', 'random.seed', (["params['seed']"], {}), "(params['seed'])\n", (497, 513), False, 'import random\n')] |
import pygame as pg
import sys
from settings import *
from managers.resourcemanager import ResourceManager as GR
from escenas.gui.button import Button
#######################################
# Direferentes tipos de botones #
#######################################
#Botón Clásico
class ClasicButton(Button):
... | [
"escenas.gui.button.Button.__init__",
"managers.resourcemanager.ResourceManager.load_font"
] | [((376, 438), 'escenas.gui.button.Button.__init__', 'Button.__init__', (['self', 'GR.BTN_BG', 'text', 'callback'], {'dx': 'dx', 'dy': 'dy'}), '(self, GR.BTN_BG, text, callback, dx=dx, dy=dy)\n', (391, 438), False, 'from escenas.gui.button import Button\n'), ((697, 761), 'escenas.gui.button.Button.__init__', 'Button.__i... |
# -*- coding: utf-8 -*-
# Copyright (c) 2020, VMRaid Technologies and contributors
# For license information, please see license.txt
from __future__ import unicode_literals
import vmraid
from vmraid.model.document import Document
from vmraid import _
class NavbarSettings(Document):
def validate(self):
self.validat... | [
"vmraid.get_single",
"vmraid._",
"vmraid.get_hooks",
"vmraid.db.get_single_value",
"vmraid.whitelist"
] | [((853, 887), 'vmraid.whitelist', 'vmraid.whitelist', ([], {'allow_guest': '(True)'}), '(allow_guest=True)\n', (869, 887), False, 'import vmraid\n'), ((920, 989), 'vmraid.db.get_single_value', 'vmraid.db.get_single_value', (['"""Navbar Settings"""', '"""app_logo"""'], {'cache': '(True)'}), "('Navbar Settings', 'app_log... |
import numpy as np
class Graph:
"""Class that specifies graph.
Graph is an object that consists of vertices and edges.
We can divide it into several objects, each object contains as many vertices
as the number of letters in alphabet.
We assign label to each vertex, in out case letters.
For ea... | [
"numpy.sum",
"numpy.arange"
] | [((977, 1007), 'numpy.arange', 'np.arange', (['self.objects_number'], {}), '(self.objects_number)\n', (986, 1007), True, 'import numpy as np\n'), ((1302, 1370), 'numpy.sum', 'np.sum', (['((char_image - self.string[:, i - char_width + 1:i + 1]) ** 2)'], {}), '((char_image - self.string[:, i - char_width + 1:i + 1]) ** 2... |
import demistomock as demisto
from CommonServerPython import *
SCRIPT_NAME = 'ListCreator'
def configure_list(list_name: str, list_data: str) -> bool:
"""Create system lists using the createList built-in method.
"""
demisto.debug(f'{SCRIPT_NAME} - Setting "{list_name}" list.')
res = demisto.executeC... | [
"demistomock.debug",
"demistomock.executeCommand",
"demistomock.args"
] | [((231, 292), 'demistomock.debug', 'demisto.debug', (['f"""{SCRIPT_NAME} - Setting "{list_name}" list."""'], {}), '(f\'{SCRIPT_NAME} - Setting "{list_name}" list.\')\n', (244, 292), True, 'import demistomock as demisto\n'), ((304, 392), 'demistomock.executeCommand', 'demisto.executeCommand', (['"""createList"""', "{'li... |
# Generated by Django 3.0.7 on 2021-04-21 19:28
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('portfolio', '0023_auto_20210102_2321'),
('moex', '0040_newsearchsecurity'),
]
operations = [
migrations.DeleteModel(
name='NewSe... | [
"django.db.migrations.DeleteModel"
] | [((273, 321), 'django.db.migrations.DeleteModel', 'migrations.DeleteModel', ([], {'name': '"""NewSearchSecurity"""'}), "(name='NewSearchSecurity')\n", (295, 321), False, 'from django.db import migrations\n')] |
from uuid import uuid4
from django.contrib.auth.base_user import AbstractBaseUser
from django.contrib.auth.models import PermissionsMixin, Group as BaseGroup
# from django.contrib.auth.validators import UnicodeUsernameValidator
from django.conf import settings
from django.core import validators
from django.db import m... | [
"django.core.validators.URLValidator",
"django.core.validators.ProhibitNullCharactersValidator",
"django.core.validators.EmailValidator",
"django.utils.translation.gettext_lazy",
"django.core.validators.MinLengthValidator",
"django.db.models.DateTimeField",
"django.db.models.UUIDField"
] | [((533, 611), 'django.db.models.UUIDField', 'models.UUIDField', ([], {'primary_key': '(True)', 'default': 'uuid4', 'editable': '(False)', 'unique': '(True)'}), '(primary_key=True, default=uuid4, editable=False, unique=True)\n', (549, 611), False, 'from django.db import models\n'), ((1158, 1236), 'django.db.models.UUIDF... |
from rest_framework import permissions
from mt_jwt_auth.jwt_user.jwt_user import JWTUser
from mt_jwt_auth.jwt_user.utils.common import jwt_decode_handler, get_jwt_value
class JWTBasePermission(permissions.BasePermission):
def has_permission(self, request, view):
token = get_jwt_value(request)
if... | [
"mt_jwt_auth.jwt_user.utils.common.jwt_decode_handler",
"mt_jwt_auth.jwt_user.jwt_user.JWTUser",
"mt_jwt_auth.jwt_user.utils.common.get_jwt_value"
] | [((287, 309), 'mt_jwt_auth.jwt_user.utils.common.get_jwt_value', 'get_jwt_value', (['request'], {}), '(request)\n', (300, 309), False, 'from mt_jwt_auth.jwt_user.utils.common import jwt_decode_handler, get_jwt_value\n'), ((439, 464), 'mt_jwt_auth.jwt_user.utils.common.jwt_decode_handler', 'jwt_decode_handler', (['token... |
from collections import defaultdict
from typing import DefaultDict, List, Optional
from beagle.nodes import Edge, Node
class AlertedOn(Edge):
__name__ = "Alerted On"
timestamp: int
def __init__(self) -> None:
super().__init__()
class Alert(Node):
__name__ = "Alert"
__color__ = "#FFFF... | [
"collections.defaultdict"
] | [((697, 719), 'collections.defaultdict', 'defaultdict', (['AlertedOn'], {}), '(AlertedOn)\n', (708, 719), False, 'from collections import defaultdict\n')] |
import dataclasses
import itertools
import operator
import xml.etree.ElementTree as ET
from abc import ABC, abstractmethod
import collections
from copy import deepcopy
from functools import reduce
from typing import Optional, Callable, List, Union, Iterable
import more_itertools.more
import numpy as np
from more_iter... | [
"pytest.approx",
"tests.util.only_fixed_rolls",
"collections.namedtuple",
"numpy.random.choice",
"examples.tree_search.hashmap.create_gamestate_hash",
"xml.etree.ElementTree.indent",
"more_itertools.collapse",
"numpy.array",
"numpy.zeros",
"xml.etree.ElementTree.Element",
"xml.etree.ElementTree.... | [((806, 925), 'collections.namedtuple', 'collections.namedtuple', (['"""HeuristicVector"""', "['score', 'tv_on_pitch', 'ball_position', 'ball_carried', 'ball_marked']"], {}), "('HeuristicVector', ['score', 'tv_on_pitch',\n 'ball_position', 'ball_carried', 'ball_marked'])\n", (828, 925), False, 'import collections\n'... |
# -*- coding: utf-8 -*-
import zipline.transforms.ta as ta
import zipline.utils.events as zpEvents
import zipline.finance.commission as zpCommission
import zipline.finance.slippage as zpSlippage
import zipline as zp
import logbook
import datetime
import pandas as pd
''' mid 2016-3-16 18:27
此程序来自Quantopian同名程序
schedule_... | [
"logging.getLogger",
"datetime.datetime",
"logging.StreamHandler",
"zipline.finance.slippage.VolumeShareSlippage",
"zipline.finance.commission.PerTrade",
"logging.Formatter",
"matplotlib.pyplot.gcf",
"json.dumps",
"zipline.utils.events.date_rules.week_start",
"logbook.log.info",
"matplotlib.pypl... | [((465, 496), 'logging.getLogger', 'logging.getLogger', (['"""mid\'logger"""'], {}), '("mid\'logger")\n', (482, 496), False, 'import logging\n'), ((542, 573), 'logging.FileHandler', 'logging.FileHandler', (['"""test.log"""'], {}), "('test.log')\n", (561, 573), False, 'import logging\n'), ((628, 651), 'logging.StreamHan... |
import numpy as np
from .muscle_simulation_stepupdate import step_update_state
class MuscleTendonComplex:
def __init__(self, nameMuscle, frcmax, vmax, lslack, lopt,
lce, r, phiref, phimaxref, rho, dirAng, phiScale,
offsetCorr, timestep, angJoi, eref=0.04, act=0.01,
... | [
"numpy.arccos",
"numpy.array",
"numpy.zeros",
"numpy.sum",
"numpy.cos",
"numpy.sin"
] | [((1671, 1696), 'numpy.zeros', 'np.zeros', (['self.typeMuscle'], {}), '(self.typeMuscle)\n', (1679, 1696), True, 'import numpy as np\n'), ((6950, 6970), 'numpy.array', 'np.array', (['(rTIAmax,)'], {}), '((rTIAmax,))\n', (6958, 6970), True, 'import numpy as np\n'), ((6988, 7010), 'numpy.array', 'np.array', (['(phirefTIA... |
# -*- coding: utf-8 -*-
import os
import sys
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
# Sphinx setup.
extensions = ["sphinx.ext.autodoc", ] # 'sphinx.ext.mathjax']
templates_path = ["_templates"]
source_suffix = ".rst"
master_doc = "index"
# Project specs.
project = u"kplr"
c... | [
"os.path.abspath"
] | [((98, 123), 'os.path.abspath', 'os.path.abspath', (['__file__'], {}), '(__file__)\n', (113, 123), False, 'import os\n')] |
from django.db import models
# Create your models here.
class Subscriber(models.Model):
name = models.CharField("Name", max_length=50)
age = models.IntegerField("Age")
email = models.EmailField("Email")
| [
"django.db.models.EmailField",
"django.db.models.CharField",
"django.db.models.IntegerField"
] | [((101, 140), 'django.db.models.CharField', 'models.CharField', (['"""Name"""'], {'max_length': '(50)'}), "('Name', max_length=50)\n", (117, 140), False, 'from django.db import models\n'), ((151, 177), 'django.db.models.IntegerField', 'models.IntegerField', (['"""Age"""'], {}), "('Age')\n", (170, 177), False, 'from dja... |
# run with `sudo python servo.py`
# servo doesn't turn all the way. SetAngle is wrong
import RPi.GPIO as GPIO
import time
GPIO.setwarnings(False)
GPIO.setmode(GPIO.BOARD)
GPIO.setup(3, GPIO.OUT)
p = GPIO.PWM(3, 50)
p.start(2.5)
try:
while True:
p.ChangeDutyCycle(2.5) # turn towards 0 degree
tim... | [
"RPi.GPIO.cleanup",
"RPi.GPIO.setup",
"RPi.GPIO.output",
"RPi.GPIO.setwarnings",
"time.sleep",
"RPi.GPIO.PWM",
"RPi.GPIO.setmode"
] | [((124, 147), 'RPi.GPIO.setwarnings', 'GPIO.setwarnings', (['(False)'], {}), '(False)\n', (140, 147), True, 'import RPi.GPIO as GPIO\n'), ((149, 173), 'RPi.GPIO.setmode', 'GPIO.setmode', (['GPIO.BOARD'], {}), '(GPIO.BOARD)\n', (161, 173), True, 'import RPi.GPIO as GPIO\n'), ((174, 197), 'RPi.GPIO.setup', 'GPIO.setup', ... |
'''interface with serlib.cparser module
We'll use platform defined C-types int (np.intc) and long long int
(np.ulonglong) for maximal portability because python C-api does not
support fixed width C types: https://docs.python.org/3/c-api/long.html
For numpy reference see
https://numpy.org/devdocs/user/basics.types.html... | [
"numpy.array",
"numpy.zeros"
] | [((2250, 2291), 'numpy.zeros', 'np.zeros', (['buffer_size'], {'dtype': 'np.ulonglong'}), '(buffer_size, dtype=np.ulonglong)\n', (2258, 2291), True, 'import numpy as np\n'), ((2964, 2996), 'numpy.array', 'np.array', (['address'], {'dtype': 'np.intc'}), '(address, dtype=np.intc)\n', (2972, 2996), True, 'import numpy as n... |
import os
import glob
import time
import sys
import datetime
import logging
path = 'path/to/downloads/'
os.chdir(path)
# create logger with 'DIRECTORY_CLEANUP'
logger = logging.getLogger('DIRECTORY_CLEANUP')
logger.setLevel('INFO')
# create file handler which logs even debug messages
fh = logging.FileHandler(f'cleanu... | [
"logging.getLogger",
"logging.Formatter",
"os.path.join",
"datetime.timedelta",
"os.chdir",
"os.path.isfile",
"os.stat",
"datetime.date.today",
"glob.glob",
"os.remove"
] | [((105, 119), 'os.chdir', 'os.chdir', (['path'], {}), '(path)\n', (113, 119), False, 'import os\n'), ((171, 209), 'logging.getLogger', 'logging.getLogger', (['"""DIRECTORY_CLEANUP"""'], {}), "('DIRECTORY_CLEANUP')\n", (188, 209), False, 'import logging\n'), ((430, 503), 'logging.Formatter', 'logging.Formatter', (['"""%... |
import os
import os.path as osp
import math
import numpy as np
# ---- load random results from 'process.txt' ----
random_res = []
for seed in range(10):
main_path = osp.join('Experiment', 'optimal', 'seed%d'%seed)
sub_p_res = []
for power in range(0, 35, 5):
fpath = osp.join(main_path, 'power%d'%p... | [
"os.makedirs",
"comms.Environment",
"os.path.join",
"numpy.array",
"run.test"
] | [((1385, 1421), 'os.path.join', 'osp.join', (['"""Resdata"""', '"""noise_compare"""'], {}), "('Resdata', 'noise_compare')\n", (1393, 1421), True, 'import os.path as osp\n'), ((1422, 1459), 'os.makedirs', 'os.makedirs', (['save_path'], {'exist_ok': '(True)'}), '(save_path, exist_ok=True)\n', (1433, 1459), False, 'import... |
import numpy as np
import sys
pp = "/Users/andres.perez/source/parametric_spatial_audio_processing"
sys.path.append(pp)
import parametric_spatial_audio_processing as psa
import matplotlib.pyplot as plt
import scipy.stats
from utils import *
from file_utils import build_result_dict_from_metadata_array, build_metadata_r... | [
"matplotlib.pyplot.grid",
"parametric_spatial_audio_processing.compute_energy_density",
"parametric_spatial_audio_processing.compute_DOA",
"sys.path.append",
"parametric_spatial_audio_processing.Stft.fromSignal",
"numpy.asarray",
"parametric_spatial_audio_processing.Stft",
"numpy.max",
"matplotlib.p... | [((100, 119), 'sys.path.append', 'sys.path.append', (['pp'], {}), '(pp)\n', (115, 119), False, 'import sys\n'), ((1116, 1175), 'parametric_spatial_audio_processing.Signal', 'psa.Signal', (['data[start_frame:end_frame].T', 'sr', '"""acn"""', '"""n3d"""'], {}), "(data[start_frame:end_frame].T, sr, 'acn', 'n3d')\n", (1126... |
# MIT License
#
# Copyright (c) 2020 <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 without limitation the rights
# to use, copy, modify, merge,... | [
"random.uniform",
"os.getenv",
"asyncio.gather"
] | [((6857, 6923), 'asyncio.gather', 'asyncio.gather', (['*cls._workers'], {'return_exceptions': 'ignore_exceptions'}), '(*cls._workers, return_exceptions=ignore_exceptions)\n', (6871, 6923), False, 'import asyncio\n'), ((6354, 6392), 'os.getenv', 'os.getenv', (['"""EMBEDDED_WORKER_TYPES"""', '""""""'], {}), "('EMBEDDED_W... |
#!/usr/bin/env python3
"""
A script to monitor folders and subdirectories for file movement, creation
or modification so that files are automatically converted from predefined
filetypes to target filetypes set by the user.
Zamzar API keys can be obtained by registering at: https://developers.zamzar.com... | [
"os.path.exists",
"Watch.Watch",
"time.sleep",
"sys.exit",
"json.load"
] | [((773, 795), 'json.load', 'json.load', (['config_file'], {}), '(config_file)\n', (782, 795), False, 'import json\n'), ((684, 695), 'sys.exit', 'sys.exit', (['(0)'], {}), '(0)\n', (692, 695), False, 'import sys\n'), ((1027, 1038), 'sys.exit', 'sys.exit', (['(0)'], {}), '(0)\n', (1035, 1038), False, 'import sys\n'), ((1... |
import numpy as np
import pandas as pd
import pytest
import xarray as xr
from esmvalcore.experimental import Recipe
from esmvalcore.experimental.recipe_output import DataFile
from ewatercycle.forcing import generate, load
from ewatercycle.forcing._lisflood import LisfloodForcing
def test_plot():
f = LisfloodForc... | [
"ewatercycle.forcing.load",
"esmvalcore.experimental.recipe_output.DataFile",
"pytest.raises",
"ewatercycle.forcing.generate",
"ewatercycle.forcing._lisflood.LisfloodForcing",
"numpy.random.randn",
"pandas.date_range"
] | [((308, 411), 'ewatercycle.forcing._lisflood.LisfloodForcing', 'LisfloodForcing', ([], {'directory': '"""."""', 'start_time': '"""1989-01-02T00:00:00Z"""', 'end_time': '"""1999-01-02T00:00:00Z"""'}), "(directory='.', start_time='1989-01-02T00:00:00Z', end_time=\n '1999-01-02T00:00:00Z')\n", (323, 411), False, 'from ... |
# -*- coding: utf-8 -*-
"""Simple purchase documents model"""
from decimal import Decimal
from sqlalchemy_utils import ChoiceType
from . import db
from .supplier import Supplier
class PurchaseDocument(db.Model):
__tablename__ = 'purchase_document'
TYPE_FACTURA_A = 'FACTURA_A'
TYPE_PRESUPUESTO = 'PRESU... | [
"sqlalchemy_utils.ChoiceType"
] | [((814, 831), 'sqlalchemy_utils.ChoiceType', 'ChoiceType', (['TYPES'], {}), '(TYPES)\n', (824, 831), False, 'from sqlalchemy_utils import ChoiceType\n'), ((1209, 1229), 'sqlalchemy_utils.ChoiceType', 'ChoiceType', (['STATUSES'], {}), '(STATUSES)\n', (1219, 1229), False, 'from sqlalchemy_utils import ChoiceType\n'), ((2... |
import os
import time
import threading
import json
from datetime import datetime as dt, timedelta
from monthdelta import monthdelta
from dateutil.parser import parse as date_parse
from flask_production import TaskScheduler
from flask_production.hols import TradingHolidays
from flask_production.sched import LOGGER, BadS... | [
"dateutil.parser.parse",
"monthdelta.monthdelta",
"flask_production.hols.TradingHolidays",
"json.dumps",
"flask_production.TaskScheduler",
"time.sleep",
"os.path.isfile",
"datetime.datetime.now",
"pytest.raises",
"datetime.datetime.timestamp",
"flask_production.sched.LOGGER.removeHandler",
"th... | [((365, 380), 'time.sleep', 'time.sleep', (['(0.1)'], {}), '(0.1)\n', (375, 380), False, 'import time\n'), ((525, 549), 'os.path.isfile', 'os.path.isfile', (['log_file'], {}), '(log_file)\n', (539, 549), False, 'import os\n'), ((601, 616), 'flask_production.TaskScheduler', 'TaskScheduler', ([], {}), '()\n', (614, 616),... |
"""``cubi-tk sea-snap pull-isa``: pull ISA files from SODAR.
More Information
----------------
- Also see ``cubi-tk sea-snap`` :ref:`cli_main <CLI documentation>` and ``cubi-tk sea-snap pull-isa --help`` for more information.
- `Sea-snap Pipeline GitLab Project <https://cubi-gitlab.bihealth.org/CUBI/Pipelines/sea-sna... | [
"uuid.UUID",
"logzero.logger.error",
"pathlib.Path",
"os.environ.get",
"requests.get",
"logzero.logger.warn",
"logzero.logger.info",
"logzero.logger.debug"
] | [((3611, 3642), 'logzero.logger.info', 'logger.info', (['"""Fetching %s"""', 'url'], {}), "('Fetching %s', url)\n", (3622, 3642), False, 'from logzero import logger\n'), ((3651, 3668), 'requests.get', 'requests.get', (['url'], {}), '(url)\n', (3663, 3668), False, 'import requests\n'), ((3733, 3757), 'pathlib.Path', 'Pa... |
"""Add admin-manager role
Revision ID: 1050
Revises: 1040
Create Date: 2017-11-21 11:20:00.000000
"""
# revision identifiers, used by Alembic.
revision = '1<PASSWORD>'
down_revision = '1040'
from alembic import op
def upgrade():
op.execute("COMMIT") # See: http://stackoverflow.com/a/30910417/15720
op.exe... | [
"alembic.op.execute"
] | [((239, 259), 'alembic.op.execute', 'op.execute', (['"""COMMIT"""'], {}), "('COMMIT')\n", (249, 259), False, 'from alembic import op\n'), ((314, 432), 'alembic.op.execute', 'op.execute', (['"""ALTER TYPE user_roles_enum ADD VALUE IF NOT EXISTS \'admin-manager\' AFTER \'admin-ccs-sourcing\';"""'], {}), '(\n "ALTER TY... |
from stellar.models import get_unique_hash, Table, Snapshot
def test_get_unique_hash():
assert get_unique_hash()
assert get_unique_hash() != get_unique_hash()
assert len(get_unique_hash()) == 32
def test_table():
table = Table(
table_name='hapsu',
snapshot=Snapshot(
snaps... | [
"stellar.models.Snapshot",
"stellar.models.get_unique_hash"
] | [((101, 118), 'stellar.models.get_unique_hash', 'get_unique_hash', ([], {}), '()\n', (116, 118), False, 'from stellar.models import get_unique_hash, Table, Snapshot\n'), ((130, 147), 'stellar.models.get_unique_hash', 'get_unique_hash', ([], {}), '()\n', (145, 147), False, 'from stellar.models import get_unique_hash, Ta... |
from base_component import *
import os
import xml.etree.ElementTree as ET
class ParseV4L2Headers(Component):
"""
Component which parses the v4l2 headers to get ioctl function pointer structure members.
"""
def __init__(self, value_dict):
c2xml_path = None
kernel_src_dir = None
... | [
"os.path.exists",
"xml.etree.ElementTree.parse",
"os.stat",
"os.path.join",
"os.getcwd",
"os.chdir",
"os.path.isdir",
"os.system"
] | [((3038, 3101), 'os.path.join', 'os.path.join', (['self.kernel_src_dir', '"""include/media/v4l2-ioctl.h"""'], {}), "(self.kernel_src_dir, 'include/media/v4l2-ioctl.h')\n", (3050, 3101), False, 'import os\n'), ((3113, 3142), 'os.path.exists', 'os.path.exists', (['v4l2_hdr_file'], {}), '(v4l2_hdr_file)\n', (3127, 3142), ... |
from fastapi import FastAPI
import graphene
from starlette.graphql import GraphQLApp
from schema import Query, Mutation
app = FastAPI()
app.add_route(
"/graphiql", GraphQLApp(schema=graphene.Schema(query=Query, mutation=Mutation))
)
@app.get("/")
def main():
return {"Hello": "World"} | [
"fastapi.FastAPI",
"graphene.Schema"
] | [((127, 136), 'fastapi.FastAPI', 'FastAPI', ([], {}), '()\n', (134, 136), False, 'from fastapi import FastAPI\n'), ((187, 234), 'graphene.Schema', 'graphene.Schema', ([], {'query': 'Query', 'mutation': 'Mutation'}), '(query=Query, mutation=Mutation)\n', (202, 234), False, 'import graphene\n')] |
#
# GraphicsBindingsDocument.py
# GraphicsBindings
#
# Converted by u.fiedler on feb 2005
# with great help from <NAME> - Thank you Bob!
#
# The original version was written in Objective-C by <NAME>
# http://homepage.mac.com/mmalc/CocoaExamples/controllers.html
import objc
from Cocoa import NSDocument, NSKeyedAr... | [
"objc.ivar",
"Cocoa.NSValueTransformer.setValueTransformer_forName_",
"objc.IBOutlet",
"Cocoa.NSKeyedArchiver.archivedDataWithRootObject_",
"RadiansToDegreesTransformer.RadiansToDegreesTransformer.alloc",
"Cocoa.NSKeyedUnarchiver.unarchiveObjectWithData_",
"objc.super"
] | [((3363, 3449), 'Cocoa.NSValueTransformer.setValueTransformer_forName_', 'NSValueTransformer.setValueTransformer_forName_', (['vt', '"""RadiansToDegreesTransformer"""'], {}), "(vt,\n 'RadiansToDegreesTransformer')\n", (3410, 3449), False, 'from Cocoa import NSDocument, NSKeyedArchiver, NSKeyedUnarchiver, NSValueTran... |
# Generated by Django 2.0.3 on 2018-05-13 10:03
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('game', '0011_session_clone'),
]
operations = [
migrations.AlterField(
model_name='session',
name='clone',
... | [
"django.db.models.IntegerField"
] | [((328, 358), 'django.db.models.IntegerField', 'models.IntegerField', ([], {'null': '(True)'}), '(null=True)\n', (347, 358), False, 'from django.db import migrations, models\n')] |
from unittest.mock import patch
from pytest import mark
@mark.parametrize('return_code, pretend, world', [(b'0', False, False), (b'0', True, False),
(b'0', True, True), (b'1', False, False),
(b'1', False, True), (b'1'... | [
"pyerge.tmerge.check_emerge_opts",
"pyerge.tmerge.run_check",
"pyerge.tmerge.is_portage_running",
"pyerge.tmerge.deep_clean",
"pytest.mark.parametrize",
"argparse.Namespace",
"unittest.mock.patch",
"pyerge.tmerge.run_emerge",
"pyerge.tmerge.deep_run"
] | [((60, 266), 'pytest.mark.parametrize', 'mark.parametrize', (['"""return_code, pretend, world"""', "[(b'0', False, False), (b'0', True, False), (b'0', True, True), (b'1', \n False, False), (b'1', False, True), (b'1', True, False), (b'1', True, True)\n ]"], {}), "('return_code, pretend, world', [(b'0', False, Fals... |
# 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, software
# distributed under the... | [
"heat_dashboard.test.helpers.create_mocks",
"heat_dashboard.test.helpers.IsHttpRequest",
"django.urls.reverse"
] | [((761, 816), 'heat_dashboard.test.helpers.create_mocks', 'test.create_mocks', (["{api.heat: ('resource_types_list',)}"], {}), "({api.heat: ('resource_types_list',)})\n", (778, 816), True, 'from heat_dashboard.test import helpers as test\n'), ((1293, 1346), 'heat_dashboard.test.helpers.create_mocks', 'test.create_mocks... |
# -*- coding: utf-8 -*-
from setuptools import setup, find_packages
with open('README') as stream:
long_desc = stream.read()
version = "0.13"
requires = [
'path.py>=10.0',
'simplejson',
'Sphinx<=1.4.9',
]
extra_require = {
'view directive': ['tryton >= 3.2'],
'proteus': ['proteus >= 3.2']... | [
"setuptools.find_packages"
] | [((1071, 1086), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (1084, 1086), False, 'from setuptools import setup, find_packages\n')] |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
import argparse
import sys
import ast
import re
class SetupParserError(Exception):
pass
def extractRequires(src, dumpfname=None):
# https://docs.python.org/3.5/distutils/setupscript.html#relationships-between-distributions-and-packages
re_package_name = re... | [
"ast.iter_child_nodes",
"argparse.ArgumentParser",
"re.compile",
"ast.dump",
"ast.parse"
] | [((318, 342), 're.compile', 're.compile', (['"""([^><=!]+)"""'], {}), "('([^><=!]+)')\n", (328, 342), False, 'import re\n'), ((355, 369), 'ast.parse', 'ast.parse', (['src'], {}), '(src)\n', (364, 369), False, 'import ast\n'), ((3704, 3730), 'ast.iter_child_nodes', 'ast.iter_child_nodes', (['tree'], {}), '(tree)\n', (37... |
import os
import re
from typing import (
List,
Optional,
)
from kb_notes.config import (
Config,
WIKILINK_PATTERN,
)
from kb_notes.helpers import execute_command
from kb_notes.types import WikiLinkRegexMatch
class NoteFinder:
def __init__(self, config: Config):
self.config = config
d... | [
"re.compile",
"kb_notes.helpers.execute_command",
"os.path.join",
"kb_notes.config.WIKILINK_PATTERN.finditer",
"os.path.basename"
] | [((663, 839), 'kb_notes.helpers.execute_command', 'execute_command', (["['rg', '-l', '-e',\n f'\\\\[\\\\[{note_name}(#([-a-zA-Z0-9\\\\.\\\\s]*))?(\\\\|([-a-zA-Z0-9\\\\.\\\\s]*))?(\\\\^([-a-zA-Z0-9\\\\.\\\\s]*))?\\\\]\\\\]'\n , self.config.note_folder]"], {}), "(['rg', '-l', '-e',\n f'\\\\[\\\\[{note_name}(#([-... |
import time
import json
from math import sqrt
from typing import List
from multiprocessing import Process, Event, Queue, Lock
from src.base import EdgiseBase
from grove.adc import ADC
from config import cfg
import json
class ACSensor(Process, EdgiseBase):
def __init__(self, stop_event: Event, logging_q: Queue, i... | [
"multiprocessing.Process.__init__",
"json.dumps",
"math.sqrt",
"time.sleep",
"grove.adc.ADC",
"src.base.EdgiseBase.__init__"
] | [((733, 738), 'grove.adc.ADC', 'ADC', ([], {}), '()\n', (736, 738), False, 'from grove.adc import ADC\n'), ((786, 808), 'multiprocessing.Process.__init__', 'Process.__init__', (['self'], {}), '(self)\n', (802, 808), False, 'from multiprocessing import Process, Event, Queue, Lock\n'), ((817, 880), 'src.base.EdgiseBase._... |
from numpy import ndarray
from typing import Tuple, Dict
from lib.util import distance_nb_moves
from lib.positions import get_human_positions, get_our_positions, get_opponent_positions
from lib.constants import (
WINNING_WEIGHT,
ABSOLUTE_WIN_WEIGHT,
POPULATION_WEIGHT,
HUMAN_WIN_WEIGHT,
)
def compute_... | [
"lib.positions.get_our_positions",
"lib.positions.get_human_positions",
"lib.positions.get_opponent_positions",
"lib.util.distance_nb_moves"
] | [((490, 537), 'lib.util.distance_nb_moves', 'distance_nb_moves', (['our_position', 'human_position'], {}), '(our_position, human_position)\n', (507, 537), False, 'from lib.util import distance_nb_moves\n'), ((1829, 1879), 'lib.util.distance_nb_moves', 'distance_nb_moves', (['our_position', 'opponent_position'], {}), '(... |
#!/usr/bin/python3
# -*- coding: utf-8 -*-
# Util functions
# @author <EMAIL>
from lxml import etree
from lxml.etree import tostring
from itertools import chain
from nltk.tokenize import wordpunct_tokenize
from random import shuffle
from sklearn import metrics
import numpy
import operator
import pandas
import re
impor... | [
"sklearn.metrics.f1_score",
"random.shuffle",
"pandas.read_csv",
"numpy.average",
"lxml.etree.SubElement",
"subprocess.Popen",
"lxml.etree.parse",
"torch.stack",
"lxml.etree.write",
"sklearn.metrics.precision_score",
"sklearn.metrics.recall_score",
"subprocess.call",
"lxml.etree.fromstring",... | [((2212, 2233), 'lxml.etree.parse', 'etree.parse', (['filename'], {}), '(filename)\n', (2223, 2233), False, 'from lxml import etree\n'), ((2680, 2700), 'lxml.etree.write', 'etree.write', (['outfile'], {}), '(outfile)\n', (2691, 2700), False, 'from lxml import etree\n'), ((2733, 2765), 'pandas.DataFrame', 'pandas.DataFr... |
from mitmproxy.test import tflow
from mitmproxy.tools.console import common
from ...conftest import skip_appveyor
@skip_appveyor
def test_format_flow():
f = tflow.tflow(resp=True)
assert common.format_flow(f, True)
assert common.format_flow(f, True, hostheader=True)
assert common.format_flow(f, True,... | [
"mitmproxy.test.tflow.tflow",
"mitmproxy.tools.console.common.format_flow"
] | [((164, 186), 'mitmproxy.test.tflow.tflow', 'tflow.tflow', ([], {'resp': '(True)'}), '(resp=True)\n', (175, 186), False, 'from mitmproxy.test import tflow\n'), ((198, 225), 'mitmproxy.tools.console.common.format_flow', 'common.format_flow', (['f', '(True)'], {}), '(f, True)\n', (216, 225), False, 'from mitmproxy.tools.... |
# -*- coding: utf-8 -*-
'''
@author: nixiaopan
@time: 2022/4/9 23:58
'''
import logging
from wxcloudrun.mapper.utils import get_table_column_name
from wxcloudrun.utils.SQL.DBUtils import db_utils
need_escape_string_list = ["goods_name", "specification", "brand", "pic_path",
"live_recording... | [
"wxcloudrun.utils.SQL.DBUtils.db_utils.execute_insert_sql_and_get_primary_key",
"wxcloudrun.mapper.utils.get_table_column_name",
"wxcloudrun.utils.SQL.DBUtils.db_utils.escape_string",
"wxcloudrun.utils.SQL.DBUtils.db_utils.execute_single_sql"
] | [((906, 942), 'wxcloudrun.mapper.utils.get_table_column_name', 'get_table_column_name', (['"""cooperation"""'], {}), "('cooperation')\n", (927, 942), False, 'from wxcloudrun.mapper.utils import get_table_column_name\n'), ((1540, 1596), 'wxcloudrun.utils.SQL.DBUtils.db_utils.execute_insert_sql_and_get_primary_key', 'db_... |
import os
import argparse
import numpy as np
import processors as pe
from paz.backend.camera import VideoPlayer
from paz.backend.camera import Camera
from demo_pipeline import DetectEigenFaces
if __name__ == "__main__":
parser = argparse.ArgumentParser(description='Real-time face classifier')
parser.add_argum... | [
"os.path.exists",
"os.listdir",
"demo_pipeline.DetectEigenFaces",
"argparse.ArgumentParser",
"os.makedirs",
"paz.backend.camera.VideoPlayer",
"os.path.join",
"processors.CalculateCosineSimilarity",
"numpy.load",
"paz.backend.camera.Camera"
] | [((235, 299), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Real-time face classifier"""'}), "(description='Real-time face classifier')\n", (258, 299), False, 'import argparse\n'), ((2071, 2119), 'os.path.join', 'os.path.join', (['args.database_path', '"""database.npy"""'], {}), "(args.... |
from django.db import models
from django.contrib.auth.models import User
from django.utils import timezone
class Person(models.Model):
name = models.CharField(max_length=255)
additional_info = models.CharField(max_length=1025, null=True, blank=True)
address = models.ForeignKey('core.Address', related_name... | [
"django.db.models.DateTimeField",
"django.utils.timezone.now",
"django.db.models.CharField",
"django.db.models.ForeignKey"
] | [((148, 180), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(255)'}), '(max_length=255)\n', (164, 180), False, 'from django.db import models\n'), ((203, 259), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(1025)', 'null': '(True)', 'blank': '(True)'}), '(max_length=1025... |
import os
import glob
import copy
import random
import time
import numpy as np
import numpy.ma as ma
import cv2
from PIL import Image
import matplotlib.pyplot as plt
import scipy.io as scio
from scipy.spatial.transform import Rotation as R
from sklearn.neighbors import KDTree
import torch
import torch.nn as nn
im... | [
"numpy.ma.masked_equal",
"cv2.projectPoints",
"torch.LongTensor",
"affpose.YCB_Aff.eval.eval_utils.get_error_metrics",
"scipy.io.loadmat",
"torch.max",
"time.sleep",
"cv2.imshow",
"affpose.YCB_Aff.utils.bbox.extract_bboxs_from_label.get_bbox",
"affpose.YCB_Aff.eval.eval_utils.get_obj_stats",
"li... | [((708, 736), 'sys.path.append', 'sys.path.append', (['"""../../../"""'], {}), "('../../../')\n", (723, 736), False, 'import sys\n'), ((2249, 2310), 'lib.network.PoseNet', 'PoseNet', ([], {'num_points': 'config.NUM_PT', 'num_obj': 'config.NUM_OBJECTS'}), '(num_points=config.NUM_PT, num_obj=config.NUM_OBJECTS)\n', (2256... |
import os
import cv2
import time
from . import darknetanpr as darknet
import imutils, imagezmq
def convertBack(x, y, w, h):
xmin = int(round(x - (w / 2)))
xmax = int(round(x + (w / 2)))
ymin = int(round(y - (h / 2)))
ymax = int(round(y + (h / 2)))
return xmin, ymin, xmax, ymax
def cropDetected(det... | [
"os.path.abspath",
"os.path.exists",
"re.search"
] | [((834, 860), 'os.path.exists', 'os.path.exists', (['configPath'], {}), '(configPath)\n', (848, 860), False, 'import os\n'), ((982, 1008), 'os.path.exists', 'os.path.exists', (['weightPath'], {}), '(weightPath)\n', (996, 1008), False, 'import os\n'), ((1130, 1154), 'os.path.exists', 'os.path.exists', (['metaPath'], {})... |
#########################################################
#讀取檔案
#########################################################
#csv file
import csv
import os
script_dir = os.path.dirname(__file__)
rel_path = "../data/raw/"
abs_file_path = os.path.join(script_dir, rel_path)
# 開啟 CSV 檔案
f = open("%stest.csv"%... | [
"os.path.dirname",
"os.path.join",
"csv.reader"
] | [((176, 201), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (191, 201), False, 'import os\n'), ((246, 280), 'os.path.join', 'os.path.join', (['script_dir', 'rel_path'], {}), '(script_dir, rel_path)\n', (258, 280), False, 'import os\n'), ((367, 380), 'csv.reader', 'csv.reader', (['f'], {}), '... |
from django.shortcuts import render, redirect
from django.urls import reverse_lazy
from django.http import JsonResponse
from myfiles.models import Announcement, OMRSheet
from myfiles.forms import AnnouncementsForm, OMRSheetsForm
from django.views.generic import TemplateView, ListView, CreateView, DeleteView
from braces... | [
"django.utils.timezone.make_aware",
"dateutil.relativedelta.relativedelta",
"django.http.JsonResponse",
"myfiles.models.OMRSheet.objects.all",
"django.urls.reverse_lazy",
"myfiles.forms.OMRSheetsForm"
] | [((899, 940), 'django.urls.reverse_lazy', 'reverse_lazy', (['"""upload:announcements_list"""'], {}), "('upload:announcements_list')\n", (911, 940), False, 'from django.urls import reverse_lazy\n'), ((1740, 1781), 'django.urls.reverse_lazy', 'reverse_lazy', (['"""upload:announcements_list"""'], {}), "('upload:announceme... |
from __future__ import annotations
import vtk
from custom_types import *
from ui import ui_utils
import constants
import vtk.util.numpy_support as numpy_support
class GaussianData:
def make_symmetric(self, other: GaussianData):
# reflection = np.eye(3)
# reflection[0, 0] = -1
# self.total... | [
"vtk.vtkTransformPolyDataFilter",
"ui.ui_utils.load_vtk_obj",
"vtk.vtkPolyDataMapper",
"vtk.vtkTransform",
"vtk.vtkActor",
"vtk.vtkPoints",
"ui.ui_utils.set_default_properties",
"vtk.util.numpy_support.numpy_to_vtk",
"vtk.vtkMatrix4x4"
] | [((4142, 4219), 'ui.ui_utils.load_vtk_obj', 'ui_utils.load_vtk_obj', (['f"""{constants.DATA_ROOT}/ui_resources/simple_brick.obj"""'], {}), "(f'{constants.DATA_ROOT}/ui_resources/simple_brick.obj')\n", (4163, 4219), False, 'from ui import ui_utils\n'), ((5281, 5299), 'vtk.vtkTransform', 'vtk.vtkTransform', ([], {}), '()... |
import FWCore.ParameterSet.Config as cms
siStripMatchedRecHits = cms.EDProducer("SiStripRecHitConverter",
ClusterProducer = cms.InputTag('siStripClusters'),
StripCPE = cms.ESInputTag('StripCPEfromTrackAngleESProducer:StripCPEfromTrackAngle'),
Matcher = cms.ESInputTag('SiStripRecHi... | [
"FWCore.ParameterSet.Config.string",
"FWCore.ParameterSet.Config.InputTag",
"FWCore.ParameterSet.Config.ESInputTag",
"FWCore.ParameterSet.Config.untracked.int32",
"FWCore.ParameterSet.Config.bool"
] | [((132, 163), 'FWCore.ParameterSet.Config.InputTag', 'cms.InputTag', (['"""siStripClusters"""'], {}), "('siStripClusters')\n", (144, 163), True, 'import FWCore.ParameterSet.Config as cms\n'), ((191, 264), 'FWCore.ParameterSet.Config.ESInputTag', 'cms.ESInputTag', (['"""StripCPEfromTrackAngleESProducer:StripCPEfromTrack... |
# Generated by Django 2.0.1 on 2018-01-25 15:59
from django.conf import settings
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('AuthorizationManagement', '0003_auto_20180125_1450'),
]
operations = [
migrations.AlterField(
m... | [
"django.db.models.ManyToManyField"
] | [((387, 460), 'django.db.models.ManyToManyField', 'models.ManyToManyField', ([], {'related_name': '"""owner"""', 'to': 'settings.AUTH_USER_MODEL'}), "(related_name='owner', to=settings.AUTH_USER_MODEL)\n", (409, 460), False, 'from django.db import migrations, models\n')] |
# Standard Library
from logging import getLogger
from logging.config import dictConfig
from pathlib import Path
from typing import List
# Third Party Library
import yaml
from fastapi import Depends
from fastapi import FastAPI
from fastapi import HTTPException
from fastapi.security.http import HTTPAuthorizationCredenti... | [
"logging.getLogger",
"fastapi.security.http.HTTPBearer",
"fastapi.FastAPI",
"fastapi.HTTPException",
"pathlib.Path",
"logging.config.dictConfig",
"yaml.safe_load",
"fastapi.Depends"
] | [((762, 781), 'logging.getLogger', 'getLogger', (['__name__'], {}), '(__name__)\n', (771, 781), False, 'from logging import getLogger\n'), ((789, 798), 'fastapi.FastAPI', 'FastAPI', ([], {}), '()\n', (796, 798), False, 'from fastapi import FastAPI\n'), ((1287, 1299), 'fastapi.security.http.HTTPBearer', 'HTTPBearer', ([... |
import os
import tempfile
from bgmol.util.importing import import_openmm
_, unit, app = import_openmm()
from bgmol.systems import OpenMMSystem
from torchvision.datasets.utils import download_url
from ..util.pdbpatch import fixed_atom_names
__all__ = ["FAST_FOLDER_NAMES", "FastFolder"]
class FastFolder(OpenMMSystem... | [
"os.path.join",
"torchvision.datasets.utils.download_url",
"bgmol.util.importing.import_openmm",
"os.path.isfile",
"tempfile.gettempdir"
] | [((90, 105), 'bgmol.util.importing.import_openmm', 'import_openmm', ([], {}), '()\n', (103, 105), False, 'from bgmol.util.importing import import_openmm\n'), ((2607, 2628), 'tempfile.gettempdir', 'tempfile.gettempdir', ([], {}), '()\n', (2626, 2628), False, 'import tempfile\n'), ((3995, 4020), 'os.path.join', 'os.path.... |
# Generated by Django 3.1 on 2020-08-22 12:55
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
("clubs", "0032_auto_20200821_1340"),
]
operations = [
migrations.AlterModelOptions(
name="report",
options={
... | [
"django.db.migrations.AlterModelOptions",
"django.db.models.BooleanField"
] | [((231, 373), 'django.db.migrations.AlterModelOptions', 'migrations.AlterModelOptions', ([], {'name': '"""report"""', 'options': "{'ordering': ['name'], 'permissions': [('generate_reports',\n 'Can generate reports')]}"}), "(name='report', options={'ordering': ['name'],\n 'permissions': [('generate_reports', 'Can ... |
import json
from mock import ANY
from lib.response import OkResponse
from tests.commands.commands_test_base import CommandsTestBase
class GetAudioTest(CommandsTestBase):
def test_get_audio(self):
self.pipeline_mock.amix.getAudioVolumes.return_value = [1.0, 0.0, 0.25]
response = self.commands.ge... | [
"json.loads"
] | [((471, 499), 'json.loads', 'json.loads', (['response.args[1]'], {}), '(response.args[1])\n', (481, 499), False, 'import json\n')] |
from .output_base import OutputBase
import numpy as np
class InMemoryOutput(OutputBase):
_aliases = ["memory"]
def __init__(self):
super(InMemoryOutput,self).__init__()
self.rows = []
self.meta = {}
self.final_meta = {}
self.comments = []
def _write_parameters(self,... | [
"numpy.array"
] | [((868, 918), 'numpy.array', 'np.array', (['[row[column_index] for row in self.rows]'], {}), '([row[column_index] for row in self.rows])\n', (876, 918), True, 'import numpy as np\n')] |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# ressample.py
#
# (c) 2015 <NAME>
#
# MIT License
from __future__ import print_function
from _common import StreamContext
from argparse import ArgumentParser
import random
import errno
import logging
from operator import itemgetter
from typing import Iterator, L... | [
"logging.getLogger",
"_common.StreamContext",
"argparse.ArgumentParser",
"operator.itemgetter",
"random.SystemRandom"
] | [((333, 360), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (350, 360), False, 'import logging\n'), ((1227, 1445), 'argparse.ArgumentParser', 'ArgumentParser', ([], {'description': '"""Samples lines from an input stream."""', 'epilog': '"""Bear in mind that the sample is collected in mem... |
# Generated by Django 2.1.7 on 2019-02-26 11:17
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('common', '0013_logentry_logchain'),
]
operations = [
migrations.AddField(
model_name='configuration',
name='can_see_... | [
"django.db.models.URLField",
"django.db.models.CharField"
] | [((354, 540), 'django.db.models.CharField', 'models.CharField', ([], {'choices': "[('no', 'no'), ('name-only', 'name-only'), ('name-contact', 'name-contact')]", 'default': '"""no"""', 'max_length': '(12)', 'verbose_name': '"""Members can see other members"""'}), "(choices=[('no', 'no'), ('name-only', 'name-only'), (\n ... |
from django.conf import settings
from django.db import models
class Sample1(models.Model):
"Generated Model"
user_id = models.BigIntegerField()
password = models.TextField()
| [
"django.db.models.TextField",
"django.db.models.BigIntegerField"
] | [((129, 153), 'django.db.models.BigIntegerField', 'models.BigIntegerField', ([], {}), '()\n', (151, 153), False, 'from django.db import models\n'), ((169, 187), 'django.db.models.TextField', 'models.TextField', ([], {}), '()\n', (185, 187), False, 'from django.db import models\n')] |
"""Support for Blink system camera sensors."""
import logging
from homeassistant.components.sensor import SensorEntity
from homeassistant.const import (
DEVICE_CLASS_SIGNAL_STRENGTH,
DEVICE_CLASS_TEMPERATURE,
SIGNAL_STRENGTH_DECIBELS_MILLIWATT,
TEMP_FAHRENHEIT,
)
from .const import DOMAIN, TYPE_TEMPER... | [
"logging.getLogger"
] | [((357, 384), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (374, 384), False, 'import logging\n')] |
# Generated by Django 4.0 on 2022-01-08 14:12
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('auth', '0012_alter_user_first_name_max_length'),
('accounts', '0001_initial'),
]
operations = [
migra... | [
"django.db.models.OneToOneField",
"django.db.models.DateField",
"django.db.models.PositiveSmallIntegerField",
"django.db.models.CharField"
] | [((416, 471), 'django.db.models.CharField', 'models.CharField', ([], {'blank': '(True)', 'max_length': '(255)', 'null': '(True)'}), '(blank=True, max_length=255, null=True)\n', (432, 471), False, 'from django.db import migrations, models\n'), ((594, 633), 'django.db.models.DateField', 'models.DateField', ([], {'blank':... |
import bcrypt
import hashlib
from hashgen.utilities import string_generator_and_encoding
class Algorithms:
def __init__(self, algorithm, difficulty) -> None:
self.algorithm = algorithm
self.difficulty = difficulty
def bcrypt_gen(self, difficulty):
string = string_generator_and_encoding(difficulty=... | [
"hashgen.utilities.string_generator_and_encoding",
"bcrypt.gensalt",
"hashlib.new"
] | [((279, 331), 'hashgen.utilities.string_generator_and_encoding', 'string_generator_and_encoding', ([], {'difficulty': 'difficulty'}), '(difficulty=difficulty)\n', (308, 331), False, 'from hashgen.utilities import string_generator_and_encoding\n'), ((454, 506), 'hashgen.utilities.string_generator_and_encoding', 'string_... |
import numpy
def entropy2(*args):
''' E = ENTROPY2(MTX,BINSIZE)
Compute the first-order sample entropy of MTX. Samples of VEC are
first discretized. Optional argument BINSIZE controls the
discretization, and defaults to 256/(max(VEC)-min(VEC)).
NOTE: This is a heavily ... | [
"numpy.where",
"numpy.array",
"numpy.log2"
] | [((469, 489), 'numpy.array', 'numpy.array', (['args[0]'], {}), '(args[0])\n', (480, 489), False, 'import numpy\n'), ((1062, 1087), 'numpy.where', 'numpy.where', (['(bincount > 0)'], {}), '(bincount > 0)\n', (1073, 1087), False, 'import numpy\n'), ((1137, 1150), 'numpy.log2', 'numpy.log2', (['H'], {}), '(H)\n', (1147, 1... |
from typing import List
import discord
from src.utils.api_manager import APIManager
from src.utils.embeds_manager import EmbedsManager
from src.utils.permissions_manager import PermissionsManager
api_manager = APIManager()
permissions_manager = PermissionsManager()
async def init_server(client: discord.Client, mes... | [
"src.utils.api_manager.APIManager",
"src.utils.permissions_manager.PermissionsManager",
"src.utils.embeds_manager.EmbedsManager.error_embed",
"src.utils.embeds_manager.EmbedsManager.complete_embed"
] | [((213, 225), 'src.utils.api_manager.APIManager', 'APIManager', ([], {}), '()\n', (223, 225), False, 'from src.utils.api_manager import APIManager\n'), ((248, 268), 'src.utils.permissions_manager.PermissionsManager', 'PermissionsManager', ([], {}), '()\n', (266, 268), False, 'from src.utils.permissions_manager import P... |