code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
from setuptools import find_packages, setup
setup(
name="regulations",
version="9.0.0",
packages=find_packages(),
include_package_data=True,
install_requires=[
'cached-property',
'django==3.2.13',
'enum34;python_version<"3.4"',
'futures;python_version<"3"',
... | [
"setuptools.find_packages"
] | [((111, 126), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (124, 126), False, 'from setuptools import find_packages, setup\n')] |
"""
Simulation of the VPython camera geometry.
Version using wx widgets. <NAME>, England, 11 March 2014.
================================================================================"""
from __future__ import division, print_function
import visual as vs # for 3D panel
import wx # for widgets
# Draw window &... | [
"wx.Button",
"visual.vector",
"visual.dot",
"visual.window",
"visual.cylinder",
"visual.label",
"visual.arctan",
"wx.StaticText",
"wx.RadioBox",
"wx.MessageBox",
"visual.curve",
"visual.faces",
"visual.degrees",
"visual.box",
"visual.arrow",
"visual.tan",
"visual.rate"
] | [((386, 462), 'visual.window', 'vs.window', ([], {'width': '(1024)', 'height': '(720)', 'menus': '(False)', 'title': '"""SIMULATE VPYTHON GUI"""'}), "(width=1024, height=720, menus=False, title='SIMULATE VPYTHON GUI')\n", (395, 462), True, 'import visual as vs\n'), ((3478, 3549), 'visual.cylinder', 'vs.cylinder', ([], ... |
import numpy as np
import tensorflow as tf
from tensorflow.keras.wrappers.scikit_learn import KerasClassifier
from tensorflow.keras.layers import Conv1D, Conv2D, Conv3D, MaxPool1D, \
MaxPool2D, MaxPool3D, Dense, Flatten, Dropout
from mil.errors.custom_exceptions import Dimensi... | [
"tensorflow.keras.layers.Conv3D",
"tensorflow.transpose",
"tensorflow.reduce_sum",
"tensorflow.GradientTape",
"tensorflow.keras.layers.MaxPool1D",
"tensorflow.keras.layers.Dense",
"mil.errors.custom_exceptions.DimensionError",
"tensorflow.keras.layers.Conv2D",
"tensorflow.matmul",
"tensorflow.kera... | [((657, 683), 'tensorflow.transpose', 'tf.transpose', (['soft', '[1, 0]'], {}), '(soft, [1, 0])\n', (669, 683), True, 'import tensorflow as tf\n'), ((699, 727), 'tensorflow.expand_dims', 'tf.expand_dims', (['soft'], {'axis': '(1)'}), '(soft, axis=1)\n', (713, 727), True, 'import tensorflow as tf\n'), ((978, 1010), 'ten... |
"""
Echo plugin example
"""
import core
import random, string
def randomword(length):
letters = string.ascii_lowercase
return ''.join(random.choice(letters) for i in range(length))
global locked
locked = []
PLUGINVERSION = 2
# Always name this variable as `plugin`
# If you dont, module loader will fail to load ... | [
"core.message",
"random.choice",
"core.Plugin"
] | [((341, 354), 'core.Plugin', 'core.Plugin', ([], {}), '()\n', (352, 354), False, 'import core\n'), ((921, 959), 'core.message', 'core.message', (['"""Chat is already locked"""'], {}), "('Chat is already locked')\n", (933, 959), False, 'import core\n'), ((1488, 1607), 'core.message', 'core.message', ([], {'text': '"""He... |
import scipy.stats as st
from sklearn import metrics
from sklearn.metrics import auc
import matplotlib.pyplot as plt
#import tensorflow as tf
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
import tensorflow_addons as tfa
import math
import sys
import os.path as osp
import numpy as np
import PIL.Image
import... | [
"numpy.clip",
"tensorflow.compat.v1.disable_v2_behavior",
"sklearn.metrics.auc",
"numpy.array2string",
"keras.backend.learning_phase",
"math.cos",
"numpy.array",
"sklearn.metrics.roc_curve",
"scipy.stats.sem",
"tensorflow.compat.v1.zeros",
"tensorflow.compat.v1.train.GradientDescentOptimizer",
... | [((176, 200), 'tensorflow.compat.v1.disable_v2_behavior', 'tf.disable_v2_behavior', ([], {}), '()\n', (198, 200), True, 'import tensorflow.compat.v1 as tf\n'), ((528, 538), 'numpy.mean', 'np.mean', (['x'], {}), '(x)\n', (535, 538), True, 'import numpy as np\n'), ((810, 860), 'sklearn.metrics.roc_curve', 'metrics.roc_cu... |
""" This module contains facilities to store configuration files. """
import yaml
class ConfigSaver():
"""ConfigSaver saves a Python object as a yaml file."""
def __init__(self):
self._indent = 4
def save(self,
file: str,
configs: dict):
"""Store configurations ... | [
"yaml.dump"
] | [((507, 557), 'yaml.dump', 'yaml.dump', (['configs', 'yaml_file'], {'indent': 'self._indent'}), '(configs, yaml_file, indent=self._indent)\n', (516, 557), False, 'import yaml\n')] |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
import os
import numpy as np
import pandas as pd
import datetime as dt
import netCDF4 as cdf
import matplotlib.pyplot as plt
import matplotlib.ticker as mticker
import cartopy
cartopy.config['data_dir'] = '/data/project/cartopy/'
import cartopy.crs as ccrs
impor... | [
"sys.path.insert",
"extra_sparqls.get_station_class",
"numpy.sqrt",
"pandas.read_csv",
"icoscp.cpb.dobj.Dobj",
"extra_sparqls.get_icos_stations_atc_samplingheight",
"pandas.to_datetime",
"os.path.exists",
"os.listdir",
"os.readlink",
"netCDF4.num2date",
"netCDF4.Dataset",
"os.path.split",
... | [((597, 614), 'os.getenv', 'os.getenv', (['"""HOME"""'], {}), "('HOME')\n", (606, 614), False, 'import os\n'), ((615, 667), 'sys.path.insert', 'sys.path.insert', (['(0)', "(my_home + '/new_jupyter/modules')"], {}), "(0, my_home + '/new_jupyter/modules')\n", (630, 667), False, 'import sys\n'), ((2593, 2614), 'netCDF4.Da... |
import os
import requests
from ..version import version
latest_url = "https://github.com/mazurwiktor/albion-online-stats/releases/latest"
def get_version():
return version
def latest_version():
req = requests.get(latest_url)
if req.status_code == 200:
return os.path.basename(req.url)
retur... | [
"os.path.basename",
"requests.get"
] | [((214, 238), 'requests.get', 'requests.get', (['latest_url'], {}), '(latest_url)\n', (226, 238), False, 'import requests\n'), ((285, 310), 'os.path.basename', 'os.path.basename', (['req.url'], {}), '(req.url)\n', (301, 310), False, 'import os\n')] |
from app.service.entities import (
Candidates,
RequestPlag,
ResponsePlag
)
from app.service.exceptions import ServiceException
class TestAPI:
def test_check_ok(self, client, mocker):
request_data = {
"lang": "some lang",
"ref_code": "some code",
"candidate... | [
"app.service.entities.ResponsePlag",
"app.service.entities.Candidates"
] | [((1256, 1287), 'app.service.entities.ResponsePlag', 'ResponsePlag', ([], {'uuid': '(2)', 'percent': '(1)'}), '(uuid=2, percent=1)\n', (1268, 1287), False, 'from app.service.entities import Candidates, RequestPlag, ResponsePlag\n'), ((835, 874), 'app.service.entities.Candidates', 'Candidates', ([], {'uuid': '(1)', 'cod... |
# Generated by Django 2.2.3 on 2019-11-24 16:58
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [("core", "0004_auto_20171005_2028")]
operations = [
migrations.AlterField(
model_name="organization",
name="classification",
... | [
"django.db.models.CharField"
] | [((332, 767), 'django.db.models.CharField', 'models.CharField', ([], {'blank': '(True)', 'choices': "[('legislature', 'Legislature'), ('executive', 'Executive'), ('upper',\n 'Upper Chamber'), ('lower', 'Lower Chamber'), ('party', 'Party'), (\n 'committee', 'Committee'), ('commission', 'Commission'), ('corporation... |
import pyxel
import math
pyxel.init(200, 200)
pyxel.cls(7)
for i in range(0, 360, 1):
iRadian = math.radians(i)
lineColor = int(i * 7 / 360)
pyxel.line(100, 100, 100 + 100 * math.sin(iRadian * 2),
100 + 100 * math.cos(iRadian * 3), lineColor)
pyxel.show()
| [
"math.radians",
"pyxel.init",
"math.cos",
"pyxel.cls",
"pyxel.show",
"math.sin"
] | [((26, 46), 'pyxel.init', 'pyxel.init', (['(200)', '(200)'], {}), '(200, 200)\n', (36, 46), False, 'import pyxel\n'), ((47, 59), 'pyxel.cls', 'pyxel.cls', (['(7)'], {}), '(7)\n', (56, 59), False, 'import pyxel\n'), ((271, 283), 'pyxel.show', 'pyxel.show', ([], {}), '()\n', (281, 283), False, 'import pyxel\n'), ((101, 1... |
import os
import util
from requests.auth import AuthBase
import json
import env
import requests
import sys
################################################################
# USERS
################################################################
def get(token, status_code=200, params={}, count=1):
print()
reque... | [
"json.loads",
"env.env_var.get",
"util.print_request",
"requests.get"
] | [((458, 515), 'requests.get', 'requests.get', (['request_url'], {'headers': 'headers', 'params': 'params'}), '(request_url, headers=headers, params=params)\n', (470, 515), False, 'import requests\n'), ((520, 568), 'util.print_request', 'util.print_request', (['"""GET"""', 'response', 'request_url'], {}), "('GET', respo... |
from requests import Session
from dataclasses import dataclass
from polzyFunctions.GlobalSystemConstants import GlobalSystemConstants
globalSystemConstants = GlobalSystemConstants()
@dataclass
class BackendSystemConnectorClasses():
backendDict = {}
class SessionBuffer(object):
# This class must be a single... | [
"polzyFunctions.GlobalSystemConstants.GlobalSystemConstants"
] | [((159, 182), 'polzyFunctions.GlobalSystemConstants.GlobalSystemConstants', 'GlobalSystemConstants', ([], {}), '()\n', (180, 182), False, 'from polzyFunctions.GlobalSystemConstants import GlobalSystemConstants\n')] |
# Copyright (c) Microsoft Corporation.
# Licensed under the MIT license.
"""
This script is gathers information about a model training run using
the log file of the run (or the saved stdout of the run).
The information are gathered with `grep` commands on key strings.
We assume that the log file contains one single r... | [
"argparse.ArgumentParser",
"petridish.analysis.model_util.model_nparam",
"petridish.analysis.model_util.model_errors",
"petridish.analysis.model_util.model_multi_add",
"petridish.analysis.model_util.verb_print"
] | [((889, 914), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (912, 914), False, 'import argparse\n'), ((1416, 1435), 'petridish.analysis.model_util.model_multi_add', 'model_multi_add', (['fn'], {}), '(fn)\n', (1431, 1435), False, 'from petridish.analysis.model_util import verb_print, model_mult... |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'ui/DeckNamePrompt.ui'
#
# Created by: PyQt5 UI code generator 5.15.6
#
# WARNING: Any manual changes made to this file will be lost when pyuic5 is
# run again. Do not edit this file unless you know what you are doing.
from PyQt5 import Qt... | [
"PyQt5.QtWidgets.QDialogButtonBox",
"PyQt5.QtWidgets.QComboBox",
"PyQt5.QtWidgets.QSizePolicy",
"PyQt5.QtWidgets.QSpacerItem",
"PyQt5.QtCore.QMetaObject.connectSlotsByName",
"PyQt5.QtWidgets.QHBoxLayout",
"PyQt5.QtWidgets.QLabel",
"PyQt5.QtWidgets.QVBoxLayout",
"PyQt5.QtWidgets.QLineEdit",
"PyQt5.... | [((672, 715), 'PyQt5.QtWidgets.QVBoxLayout', 'QtWidgets.QVBoxLayout', (['DeckNamePromptDialog'], {}), '(DeckNamePromptDialog)\n', (693, 715), False, 'from PyQt5 import QtCore, QtGui, QtWidgets\n'), ((808, 831), 'PyQt5.QtWidgets.QVBoxLayout', 'QtWidgets.QVBoxLayout', ([], {}), '()\n', (829, 831), False, 'from PyQt5 impo... |
# coding: utf-8
import pprint
import re
import six
from huaweicloudsdkcore.sdk_response import SdkResponse
class CreateCompareTaskResponse(SdkResponse):
"""
Attributes:
openapi_types (dict): The key is attribute name
and the value is attribute type.
attribute_map ... | [
"six.iteritems"
] | [((5390, 5423), 'six.iteritems', 'six.iteritems', (['self.openapi_types'], {}), '(self.openapi_types)\n', (5403, 5423), False, 'import six\n')] |
import logging
from kedro.extras.logging import ColorHandler
def test_color_logger(caplog):
log = logging.getLogger(__name__)
for handler in log.handlers:
log.removeHandler(handler) # pragma: no cover
log.addHandler(ColorHandler())
log.info("Test")
for record in caplog.records:
... | [
"logging.getLogger",
"kedro.extras.logging.ColorHandler"
] | [((105, 132), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (122, 132), False, 'import logging\n'), ((241, 255), 'kedro.extras.logging.ColorHandler', 'ColorHandler', ([], {}), '()\n', (253, 255), False, 'from kedro.extras.logging import ColorHandler\n')] |
# -*- coding: utf-8 -*-
# Generated by Django 1.9.9 on 2018-01-25 18:30
from __future__ import unicode_literals
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('menu', '0010_auto_20180125_1325'),
]
operations = [
migrations.RemoveField(
... | [
"django.db.migrations.RemoveField"
] | [((288, 358), 'django.db.migrations.RemoveField', 'migrations.RemoveField', ([], {'model_name': '"""menu"""', 'name': '"""expiration_date_temp"""'}), "(model_name='menu', name='expiration_date_temp')\n", (310, 358), False, 'from django.db import migrations\n')] |
from ray.experimental.client.api import ClientAPI
from ray.experimental.client.api import APIImpl
from typing import Optional, List, Tuple
from contextlib import contextmanager
import logging
logger = logging.getLogger(__name__)
# _client_api has to be external to the API stub, below.
# Otherwise, ray.remote() that ... | [
"logging.getLogger",
"ray.experimental.client.server.core_ray_api.CoreRayAPI",
"ray.experimental.client.worker.Worker",
"ray.experimental.client.api.ClientAPI"
] | [((203, 230), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (220, 230), False, 'import logging\n'), ((1186, 1247), 'ray.experimental.client.worker.Worker', 'Worker', (['conn_str'], {'secure': 'secure', 'metadata': 'metadata', 'stub': 'stub'}), '(conn_str, secure=secure, metadata=metadata... |
# Generated by Django 2.2.5 on 2020-01-20 12:25
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
("cases", "0047_notice_published_at"),
]
operations = [
migrations.AddField(
model_name="notice",... | [
"django.db.models.ForeignKey"
] | [((369, 480), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'blank': '(True)', 'null': '(True)', 'on_delete': 'django.db.models.deletion.PROTECT', 'to': '"""cases.CaseType"""'}), "(blank=True, null=True, on_delete=django.db.models.\n deletion.PROTECT, to='cases.CaseType')\n", (386, 480), False, 'from dja... |
"""
pypowermate: python library for Griffin Powermate Bluetooth controllers
"""
from bluepy import btle
import struct
import threading
import time
# Hardcoding these handles probably isn't the right way to do this. Instead, we
# should discover these via UUID. However, bluepy's API isn't expressive enough
# to support... | [
"threading.Thread.__init__",
"bluepy.btle.DefaultDelegate.__init__",
"bluepy.btle.Peripheral",
"time.monotonic",
"time.sleep",
"struct.unpack"
] | [((3198, 3229), 'threading.Thread.__init__', 'threading.Thread.__init__', (['self'], {}), '(self)\n', (3223, 3229), False, 'import threading\n'), ((1914, 1949), 'bluepy.btle.DefaultDelegate.__init__', 'btle.DefaultDelegate.__init__', (['self'], {}), '(self)\n', (1943, 1949), False, 'from bluepy import btle\n'), ((3628,... |
import pytest
from compas.geometry import Frame
import compas_rrc as rrc
def test_move_to_joints():
joints = [30, 90, 0, 0, 0]
extaxe = [0, 0, 100]
inst = rrc.MoveToJoints(joints, extaxe, 100, rrc.Zone.FINE)
assert inst.float_values == [30, 90, 0, 0, 0, 0, 0, 0, 100, 0, 0, 0, 100, -1]
assert not... | [
"compas_rrc.RobotJoints",
"compas.geometry.Frame.worldXY",
"pytest.raises",
"compas_rrc.ExternalAxes",
"compas_rrc.MoveToJoints"
] | [((170, 222), 'compas_rrc.MoveToJoints', 'rrc.MoveToJoints', (['joints', 'extaxe', '(100)', 'rrc.Zone.FINE'], {}), '(joints, extaxe, 100, rrc.Zone.FINE)\n', (186, 222), True, 'import compas_rrc as rrc\n'), ((466, 498), 'compas_rrc.RobotJoints', 'rrc.RobotJoints', (['(30)', '(90)', '(0)', '(0)', '(0)'], {}), '(30, 90, 0... |
from methods.indirect_influence import indirect_pagerank, indirect_paths
from methods.direct_influence import pairwise_inf
from classes.GraphQW import GraphQW, nx
""" LRIC centrality
Arguments:
graph - input graph (Graph or DiGraph object, NetworkX package)
q (optional) - quota (threshold of influence) for each node ... | [
"methods.indirect_influence.indirect_paths",
"methods.indirect_influence.indirect_pagerank",
"classes.GraphQW.GraphQW"
] | [((1238, 1275), 'classes.GraphQW.GraphQW', 'GraphQW', (['graph', 'q', 'dq', 'group_size', 'dw'], {}), '(graph, q, dq, group_size, dw)\n', (1245, 1275), False, 'from classes.GraphQW import GraphQW, nx\n'), ((2674, 2711), 'classes.GraphQW.GraphQW', 'GraphQW', (['graph', 'q', 'dq', 'group_size', 'dw'], {}), '(graph, q, dq... |
import glob
import yaml
# This script takes all ECS and custom fields already loaded, and lets users
# filter out the ones they don't need.
def filter(fields, subset_file_globs):
'''
Takes the deeply nested field structure and the subset file names.
It returns a copy of the fields that matches the white... | [
"glob.glob"
] | [((1183, 1195), 'glob.glob', 'glob.glob', (['g'], {}), '(g)\n', (1192, 1195), False, 'import glob\n')] |
from users.models import User
class CustomBackend(object):
"""authenticate when given email,phone number or secret key and password """
def get_by_email(self,email,password):
try:
user = User.objects.get(email=email)
if password:
if user.check_password(pas... | [
"users.models.User.objects.get"
] | [((223, 252), 'users.models.User.objects.get', 'User.objects.get', ([], {'email': 'email'}), '(email=email)\n', (239, 252), False, 'from users.models import User\n'), ((707, 730), 'users.models.User.objects.get', 'User.objects.get', ([], {'pk': 'pk'}), '(pk=pk)\n', (723, 730), False, 'from users.models import User\n')] |
from rpython.rtyper.lltypesystem import rffi
from .apiset import API
@API.func("HPy HPyImport_ImportModule(HPyContext *ctx, const char *name)")
def HPyImport_ImportModule(space, handles, ctx, name):
w_name = space.newtext(rffi.constcharp2str(name))
caller = space.getexecutioncontext().gettopframe_nohidden()
... | [
"rpython.rtyper.lltypesystem.rffi.constcharp2str"
] | [((227, 252), 'rpython.rtyper.lltypesystem.rffi.constcharp2str', 'rffi.constcharp2str', (['name'], {}), '(name)\n', (246, 252), False, 'from rpython.rtyper.lltypesystem import rffi\n')] |
from django.forms.models import ModelChoiceField, ModelMultipleChoiceField
from django.urls.base import reverse
from blitz_work.fields import BCheckRadioInput, BModelChoice, BModelMultipleChoice, BText
from django.db.models import DateTimeField,BooleanField
from importlib import import_module
from django.forms import M... | [
"django.urls.base.reverse",
"importlib.import_module",
"blitz_work.fields.BModelMultipleChoice",
"django.urls.get_resolver",
"django.forms.widgets.SelectDateWidget",
"django.forms.widgets.NumberInput",
"blitz_work.fields.BCheckRadioInput",
"blitz_work.fields.BModelChoice",
"django.urls.resolve"
] | [((1546, 1564), 'blitz_work.fields.BCheckRadioInput', 'BCheckRadioInput', ([], {}), '()\n', (1562, 1564), False, 'from blitz_work.fields import BCheckRadioInput, BModelChoice, BModelMultipleChoice, BText\n'), ((1910, 1970), 'blitz_work.fields.BModelChoice', 'BModelChoice', ([], {'choices': 'form.fields[field_name].widg... |
from TwitterAPI import TwitterAPI
from tqdm import tqdm
from time import sleep
class Threader(object):
def __init__(self, tweets, api, user=None, wait=None, max_char=280, end_string=True):
"""Create a thread of tweets.
Note that you will need your Twitter API / Application keys for
this to... | [
"time.sleep"
] | [((4478, 4494), 'time.sleep', 'sleep', (['self.wait'], {}), '(self.wait)\n', (4483, 4494), False, 'from time import sleep\n')] |
#!/usr/local/bin/python
#
# NPR Sunday Puzzle Solver for 2018-10-21 puzzle
#
# Written in 2018 by <NAME> <EMAIL>
#
# To the extent possible under law, the author(s) have dedicated all
# copyright and related and neighboring rights to this software to the
# public domain worldwide. This software is distributed without a... | [
"itertools.permutations"
] | [((1984, 2008), 'itertools.permutations', 'permutations', (['input_list'], {}), '(input_list)\n', (1996, 2008), False, 'from itertools import permutations\n')] |
"""
Population.py
Author: <NAME>
Affiliation: University of Colorado at Boulder
Created on: Fri May 29 18:30:49 MDT 2015
Description:
"""
import numpy as np
import matplotlib.pyplot as pl
from scipy.integrate import cumtrapz
from ..util.ReadData import read_lit
from ..physics.Constants import s_per_yr
from ..util... | [
"numpy.random.normal",
"numpy.abs",
"numpy.trapz",
"numpy.log",
"scipy.integrate.cumtrapz",
"numpy.diff",
"numpy.array",
"matplotlib.pyplot.figure",
"numpy.linspace",
"numpy.interp",
"matplotlib.pyplot.draw",
"numpy.logspace"
] | [((980, 1038), 'scipy.integrate.cumtrapz', 'cumtrapz', (['integrand'], {'x': 'self.pop.ham.halos.lnM', 'initial': '(0.0)'}), '(integrand, x=self.pop.ham.halos.lnM, initial=0.0)\n', (988, 1038), False, 'from scipy.integrate import cumtrapz\n'), ((2773, 2782), 'matplotlib.pyplot.draw', 'pl.draw', ([], {}), '()\n', (2780,... |
#!/usr/bin/env python
# encoding: utf-8
def acoustics(solver_type='classic',iplot=True,htmlplot=False,outdir='./_output',problem='figure 9.4'):
"""
This example solves the 1-dimensional variable-coefficient acoustics
equations in a medium with a single interface.
"""
from numpy import sqrt, abs... | [
"numpy.abs",
"pyclaw.Grid",
"pyclaw.State",
"pyclaw.Solution",
"pyclaw.plot.interactive_plot",
"pyclaw.SharpClawSolver1D",
"pyclaw.Controller",
"pyclaw.ClawSolver1D",
"pyclaw.plot.html_plot",
"pyclaw.Dimension",
"pyclaw.util.run_app_from_main"
] | [((809, 846), 'pyclaw.Dimension', 'pyclaw.Dimension', (['"""x"""', '(-5.0)', '(5.0)', '(500)'], {}), "('x', -5.0, 5.0, 500)\n", (825, 846), False, 'import pyclaw\n'), ((855, 869), 'pyclaw.Grid', 'pyclaw.Grid', (['x'], {}), '(x)\n', (866, 869), False, 'import pyclaw\n'), ((908, 938), 'pyclaw.State', 'pyclaw.State', (['g... |
import time
from math import floor
from intelhex import IntelHex
from binho.errors import DriverCapabilityError, CapabilityError, DeviceError
from binho.interfaces.i2cDevice import I2CDevice
from binho.programmer import binhoProgrammer
BASE_DEVICE_ADDRESS = 0x50
EEPROM_MODELS = {
"24AA00": {"page_size": 1, "max... | [
"binho.errors.DriverCapabilityError",
"binho.errors.CapabilityError",
"math.floor",
"binho.errors.DeviceError",
"time.sleep",
"intelhex.IntelHex",
"binho.interfaces.i2cDevice.I2CDevice"
] | [((15821, 15870), 'binho.errors.DriverCapabilityError', 'DriverCapabilityError', (['"""Unknown model of EEPROM."""'], {}), "('Unknown model of EEPROM.')\n", (15842, 15870), False, 'from binho.errors import DriverCapabilityError, CapabilityError, DeviceError\n'), ((21005, 21015), 'intelhex.IntelHex', 'IntelHex', ([], {}... |
import tensorflow as tf
import tensorflow.python.keras.backend as K
import numpy as np
from dataset_utils import NUM_HEADING_BIN
from paz.optimization.losses.frustumpointnet_loss import ExtractBox3DCorners
class frustum_data_loader(object):
def __init__(self, batch_size=32):
# g_type_object_of_interest =... | [
"tensorflow.cast",
"tensorflow.data.TFRecordDataset",
"tensorflow.io.parse_single_example",
"tensorflow.python.keras.backend.get_session",
"tensorflow.io.FixedLenFeature",
"paz.optimization.losses.frustumpointnet_loss.ExtractBox3DCorners",
"tensorflow.zeros"
] | [((2676, 2739), 'tensorflow.io.parse_single_example', 'tf.io.parse_single_example', (['tfexample_message', 'keys_to_features'], {}), '(tfexample_message, keys_to_features)\n', (2702, 2739), True, 'import tensorflow as tf\n'), ((4095, 4158), 'tensorflow.io.parse_single_example', 'tf.io.parse_single_example', (['tfexampl... |
# coding=utf-8
##########################################################
# Authors: <NAME>, <NAME>, <NAME>
# Affiliation: University of Geneva
# Version: 1.4.5
# Date: 13.01.2022
# Downscaling of Swiss LCLU data
##########################################################
# import libraries
import numpy, math
import pa... | [
"osgeo.gdal.Open",
"numpy.unique",
"math.sqrt",
"shutil.copyfile",
"pandas.read_excel",
"osgeo.gdal.GetDriverByName"
] | [((1436, 1471), 'shutil.copyfile', 'shutil.copyfile', (['originalp', 'targetp'], {}), '(originalp, targetp)\n', (1451, 1471), False, 'import shutil\n'), ((1541, 1576), 'shutil.copyfile', 'shutil.copyfile', (['originala', 'targeta'], {}), '(originala, targeta)\n', (1556, 1576), False, 'import shutil\n'), ((1643, 1661), ... |
import datetime
from database.database_schemas import Schemas
from sqlalchemy import Column, ForeignKey, Integer, String, DateTime
from sqlalchemy.dialects.mysql import BIGINT, SMALLINT, DOUBLE, TIMESTAMP, TINYINT, LONGTEXT
from database.base import Base
class Parameters(Base):
"""Maps to PARAMETERS table in in... | [
"sqlalchemy.Column"
] | [((462, 492), 'sqlalchemy.Column', 'Column', (['String'], {'nullable': '(False)'}), '(String, nullable=False)\n', (468, 492), False, 'from sqlalchemy import Column, ForeignKey, Integer, String, DateTime\n'), ((515, 545), 'sqlalchemy.Column', 'Column', (['String'], {'nullable': '(False)'}), '(String, nullable=False)\n',... |
import pandas as pd
import random
import LotteryProcess
import OpenFile
def main():
""" init """
lottery_num = OpenFile.OpenFuncs.openConfig()["lottery_num"]
ShouldPreprocessExecute = bool(OpenFile.OpenFuncs.openConfig()["ShouldPreprocessExecute"])
directory_path = "../100thAnniversary"
p... | [
"LotteryProcess.DataFormating.generateOtherRandomNumbers",
"LotteryProcess.DataFormating.generateLotteryDataFrame",
"pandas.read_csv",
"OpenFile.OpenFuncs.openConfig",
"LotteryProcess.preprocess.preprocessDataFrame"
] | [((614, 645), 'pandas.read_csv', 'pd.read_csv', (['lottery_list_fpath'], {}), '(lottery_list_fpath)\n', (625, 645), True, 'import pandas as pd\n'), ((669, 743), 'LotteryProcess.preprocess.preprocessDataFrame', 'LotteryProcess.preprocess.preprocessDataFrame', (['df', 'ShouldPreprocessExecute'], {}), '(df, ShouldPreproce... |
# -*- coding: utf-8 -*-
# Part of Odoo. See LICENSE file for full copyright and licensing details.
from datetime import datetime, timedelta, time
from unittest.mock import patch
from odoo.addons.event.tests.common import TestEventCommon
from odoo.addons.mail.tests.common import mail_new_test_user
from odoo.fields imp... | [
"datetime.datetime",
"datetime.time",
"odoo.addons.mail.tests.common.mail_new_test_user",
"datetime.timedelta",
"unittest.mock.patch"
] | [((574, 604), 'datetime.datetime', 'datetime', (['(2020)', '(7)', '(6)', '(10)', '(0)', '(0)'], {}), '(2020, 7, 6, 10, 0, 0)\n', (582, 604), False, 'from datetime import datetime, timedelta, time\n'), ((635, 655), 'datetime.datetime', 'datetime', (['(2020)', '(7)', '(6)'], {}), '(2020, 7, 6)\n', (643, 655), False, 'fro... |
import re
import pathlib
from setuptools import setup, find_packages
here = pathlib.Path(__file__).parent.resolve()
README = (here / 'README.md').read_text(encoding='utf-8')
VERSION = (here / 'VERSION').read_text()
setup(
name='core_utils',
version=VERSION,
description='',
long_description=README,
... | [
"setuptools.find_packages",
"pathlib.Path"
] | [((495, 521), 'setuptools.find_packages', 'find_packages', ([], {'where': '"""src"""'}), "(where='src')\n", (508, 521), False, 'from setuptools import setup, find_packages\n'), ((77, 99), 'pathlib.Path', 'pathlib.Path', (['__file__'], {}), '(__file__)\n', (89, 99), False, 'import pathlib\n')] |
from games.abstract_state import GameState, ArraySlice
from utils import np_one_hot, one_hot_to_int, one_hot_arrays_to_list_of_ints
import numpy as np
from numba import jit
@jit(nopython=True)
def extract_tricks(full_state, first_row, num_played_cards):
finished_tricks = max(0, (num_played_cards - 1) // 3)
fi... | [
"numpy.abs",
"utils.one_hot_arrays_to_list_of_ints",
"utils.np_one_hot",
"games.abstract_state.ArraySlice",
"numpy.sum",
"numba.jit",
"numpy.concatenate",
"utils.one_hot_to_int"
] | [((176, 194), 'numba.jit', 'jit', ([], {'nopython': '(True)'}), '(nopython=True)\n', (179, 194), False, 'from numba import jit\n'), ((804, 838), 'games.abstract_state.ArraySlice', 'ArraySlice', ([], {'slice_in_array': '(-1, 0)'}), '(slice_in_array=(-1, 0))\n', (814, 838), False, 'from games.abstract_state import GameSt... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import threading
import operator
from random import random, randint, gauss, shuffle, choice
from math import exp
from scipy.spatial.distance import euclidean
import numpy as np
import numba as nb
# class GOThread(threading.Thread):
# def __init__(self, target, *a... | [
"numba.vectorize",
"numpy.random.choice",
"numpy.delete",
"numpy.sum",
"numpy.array",
"random.random",
"random.randint",
"numpy.arange"
] | [((2760, 2774), 'numba.vectorize', 'nb.vectorize', ([], {}), '()\n', (2772, 2774), True, 'import numba as nb\n'), ((2917, 2931), 'numba.vectorize', 'nb.vectorize', ([], {}), '()\n', (2929, 2931), True, 'import numba as nb\n'), ((1226, 1236), 'numpy.sum', 'np.sum', (['ps'], {}), '(ps)\n', (1232, 1236), True, 'import num... |
import os, re, sys, time
import datetime as dt
import pandas as pd
import numpy as np
from .bot import Bot
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support.ui import WebDriverWait
class FacebookBot(Bot):
LOGIN_URL = 'https://www.facebook.com/'
SHARE_URL = "https://www.facebo... | [
"time.sleep",
"pandas.DataFrame.from_dict",
"re.compile"
] | [((4638, 4679), 'pandas.DataFrame.from_dict', 'pd.DataFrame.from_dict', (['shared_posts_dict'], {}), '(shared_posts_dict)\n', (4660, 4679), True, 'import pandas as pd\n'), ((2244, 2257), 'time.sleep', 'time.sleep', (['(1)'], {}), '(1)\n', (2254, 2257), False, 'import os, re, sys, time\n'), ((518, 535), 're.compile', 'r... |
# coding: utf-8
from mock import patch
from httmock import urlmatch, HTTMock
from nose.tools import eq_
from acmd import tool_repo, Server
from test_utils.compat import StringIO
@urlmatch(netloc='localhost:4502', method='DELETE')
def service_rm(url, request):
return {
'content': '',
'status_code'... | [
"mock.patch",
"nose.tools.eq_",
"acmd.Server",
"httmock.HTTMock",
"acmd.tool_repo.get_tool",
"test_utils.compat.StringIO",
"httmock.urlmatch"
] | [((182, 232), 'httmock.urlmatch', 'urlmatch', ([], {'netloc': '"""localhost:4502"""', 'method': '"""DELETE"""'}), "(netloc='localhost:4502', method='DELETE')\n", (190, 232), False, 'from httmock import urlmatch, HTTMock\n'), ((335, 377), 'mock.patch', 'patch', (['"""sys.stdout"""'], {'new_callable': 'StringIO'}), "('sy... |
from typing import Tuple, Optional, List
import gurobipy.gurobipy as grb
from bidict import bidict
from common import TMachineSchedule, is_non_zero, has_solution
class Subproblem:
"""
Knapsack problem.
"""
def __init__(self,
machine_id: int,
model: grb.Model,
... | [
"common.has_solution",
"common.is_non_zero"
] | [((646, 678), 'common.has_solution', 'has_solution', (['self._model.status'], {}), '(self._model.status)\n', (658, 678), False, 'from common import TMachineSchedule, is_non_zero, has_solution\n'), ((1081, 1099), 'common.is_non_zero', 'is_non_zero', (['var.x'], {}), '(var.x)\n', (1092, 1099), False, 'from common import ... |
import time
import random
import duckdb
db = duckdb.connect(':memory:')
db.execute('select setseed(0.5)')
db.execute('create table data AS SELECT id, (random() * 100000)::INTEGER val FROM range(0,1000000) tbl(id)')
db.commit()
print("Beginning query...")
start = time.time()
db.execute('select val, row_number() over(o... | [
"duckdb.connect",
"time.time"
] | [((46, 72), 'duckdb.connect', 'duckdb.connect', (['""":memory:"""'], {}), "(':memory:')\n", (60, 72), False, 'import duckdb\n'), ((265, 276), 'time.time', 'time.time', ([], {}), '()\n', (274, 276), False, 'import time\n'), ((374, 385), 'time.time', 'time.time', ([], {}), '()\n', (383, 385), False, 'import time\n')] |
"""Implements various reconstruction losses for MIMIC MVAE."""
import torch
from torch import nn
import math
sigm = nn.Sigmoid()
def sigmloss1d(a, b):
"""Get 1D sigmoid loss, applying the sigmoid function to the inputs beforehand.
Args:
a (torch.Tensor): Predicted output
b (torch.Tensor): Tru... | [
"torch.nn.Sigmoid",
"torch.log",
"torch.mean",
"torch.max",
"torch.flatten"
] | [((116, 128), 'torch.nn.Sigmoid', 'nn.Sigmoid', ([], {}), '()\n', (126, 128), False, 'from torch import nn\n'), ((1681, 1711), 'torch.flatten', 'torch.flatten', (['a1'], {'start_dim': '(1)'}), '(a1, start_dim=1)\n', (1694, 1711), False, 'import torch\n'), ((1725, 1755), 'torch.flatten', 'torch.flatten', (['br'], {'star... |
#-*-coding:utf-8-*-
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import re
from absl import app as absl_app
from absl import flags
import tensorflow as tf # pylint: disable=g-bad-import-order
from resnet import resnet_model
from resnet impor... | [
"resnet.resnet_run_loop.resnet_model_fn",
"tensorflow.image.resize_images",
"tensorflow.image.convert_image_dtype",
"tensorflow.logging.set_verbosity",
"os.walk",
"resnet.resnet_run_loop.learning_rate_with_decay",
"resnet.resnet_run_loop.define_resnet_flags",
"absl.flags.FLAGS.set_default",
"absl.ap... | [((919, 936), 'os.walk', 'os.walk', (['data_dir'], {}), '(data_dir)\n', (926, 936), False, 'import os\n'), ((1693, 1734), 'tensorflow.image.per_image_standardization', 'tf.image.per_image_standardization', (['image'], {}), '(image)\n', (1727, 1734), True, 'import tensorflow as tf\n'), ((2147, 2209), 'tensorflow.parse_s... |
"""
Module with functions and methods for NEXUS files.
Parsing and writing of NEXUS files is currently done with a very simple,
string manipulation strategy.
"""
# TODO: allow to output taxa and character names between quotes, if necessary
# TODO: sort using assumptions (charset) if provided
# TODO: support comments ... | [
"enum.auto",
"collections.defaultdict",
"re.search"
] | [((7948, 7964), 'collections.defaultdict', 'defaultdict', (['set'], {}), '(set)\n', (7959, 7964), False, 'from collections import defaultdict\n'), ((1201, 1207), 'enum.auto', 'auto', ([], {}), '()\n', (1205, 1207), False, 'from enum import Enum, auto\n'), ((1231, 1237), 'enum.auto', 'auto', ([], {}), '()\n', (1235, 123... |
"""
Utilities to aid unit testing L{eliot} and code that uses it.
"""
from __future__ import unicode_literals
from unittest import SkipTest
from functools import wraps
from pyrsistent import PClass, field
from six import text_type
from ._action import (
ACTION_STATUS_FIELD,
ACTION_TYPE_FIELD,
STARTED_ST... | [
"pyrsistent.PClass.__new__",
"pyrsistent.field",
"functools.wraps"
] | [((1896, 1917), 'pyrsistent.field', 'field', ([], {'mandatory': '(True)'}), '(mandatory=True)\n', (1901, 1917), False, 'from pyrsistent import PClass, field\n'), ((1935, 1956), 'pyrsistent.field', 'field', ([], {'mandatory': '(True)'}), '(mandatory=True)\n', (1940, 1956), False, 'from pyrsistent import PClass, field\n'... |
#!/usr/bin/python3
# Transfer vector graph (.svg) into LEdit code (.tco)
# usage: python3 svg2tco.py [-s SHIFTX SHIFTY] MASKFILENAME > OUTPUTCODE.tco
# NOTICE: Currently, only boxes(rectangles) & polygons will work.
import xml.dom.minidom
import sys
def polygonProcess(pgpcps): # since codes about polygon and path sha... | [
"sys.exit"
] | [((1450, 1460), 'sys.exit', 'sys.exit', ([], {}), '()\n', (1458, 1460), False, 'import sys\n'), ((1522, 1532), 'sys.exit', 'sys.exit', ([], {}), '()\n', (1530, 1532), False, 'import sys\n')] |
# -*- coding: utf-8 -*-
##############################################################################
#
# Copyright (c) 2019 Zope Foundation and Contributors.
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL). A copy of the ZPL should accompany this ... | [
"relstorage.options.Options.copy_valid_options",
"warnings.catch_warnings",
"relstorage.options.Options",
"relstorage.config.RelStorageFactory",
"relstorage.config.MySQLAdapterFactory",
"warnings.simplefilter"
] | [((1586, 1639), 'relstorage.options.Options', 'options.Options', ([], {'name': '"""name"""', 'driver': 'self.DRIVER_NAME'}), "(name='name', driver=self.DRIVER_NAME)\n", (1601, 1639), False, 'from relstorage import options\n'), ((2081, 2119), 'relstorage.config.RelStorageFactory', 'config.RelStorageFactory', (['root_zco... |
import _io
import torch
import pickle
from torchvision import transforms
from PIL import Image
from ocrd_typegroups_classifier.data.classmap import ClassMap
from ocrd_typegroups_classifier.data.classmap import IndexRemap
class TypegroupsClassifier:
""" Class wrapping type group information and a classifier.
... | [
"pickle.dump",
"torch.stack",
"pickle.load",
"ocrd_typegroups_classifier.data.classmap.ClassMap",
"torch.cuda.is_available",
"torch.no_grad",
"torchvision.transforms.ToTensor"
] | [((1498, 1514), 'ocrd_typegroups_classifier.data.classmap.ClassMap', 'ClassMap', (['groups'], {}), '(groups)\n', (1506, 1514), False, 'from ocrd_typegroups_classifier.data.classmap import ClassMap\n'), ((2348, 2366), 'pickle.load', 'pickle.load', (['input'], {}), '(input)\n', (2359, 2366), False, 'import pickle\n'), ((... |
from django.db import models
from django.conf import settings
from numpy import delete
from mainapp.models import Product
class CartQuerySet(models.query.QuerySet):
def delete(self, *args, **kwargs):
for item in self:
item.product.quantity += item.quantity
item.product.save()
... | [
"django.db.models.DateTimeField",
"django.db.models.PositiveIntegerField",
"django.db.models.ForeignKey"
] | [((712, 806), 'django.db.models.ForeignKey', 'models.ForeignKey', (['settings.AUTH_USER_MODEL'], {'on_delete': 'models.CASCADE', 'related_name': '"""cart"""'}), "(settings.AUTH_USER_MODEL, on_delete=models.CASCADE,\n related_name='cart')\n", (729, 806), False, 'from django.db import models\n'), ((817, 869), 'django.... |
import faker.providers.misc as misc
def get_uuid() -> str:
return str(misc.uuid.uuid4())
| [
"faker.providers.misc.uuid.uuid4"
] | [((76, 93), 'faker.providers.misc.uuid.uuid4', 'misc.uuid.uuid4', ([], {}), '()\n', (91, 93), True, 'import faker.providers.misc as misc\n')] |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# Copyright (c) 2016 <NAME> (http://www.jdhp.org)
# This script is provided under the terms and conditions of the MIT license:
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Softw... | [
"pywi.io.images.image_generator",
"pywi.processing.filtering.pixel_clusters.filter_pixels_clusters_stats",
"pywi.benchmark.metrics.refbased.mse",
"time.perf_counter",
"traceback.print_tb",
"datetime.datetime.now",
"sys.exc_info",
"numpy.isfinite",
"numpy.nanmax",
"copy.deepcopy",
"numpy.nanmin",... | [((4905, 4924), 'time.perf_counter', 'time.perf_counter', ([], {}), '()\n', (4922, 4924), False, 'import time\n'), ((5060, 5132), 'pywi.io.images.image_generator', 'image_generator', (['input_file_or_dir_path_list'], {'max_num_images': 'max_num_img'}), '(input_file_or_dir_path_list, max_num_images=max_num_img)\n', (507... |
import sys
sys.path.append('..')
import argparse
from batchgenerators.utilities.file_and_folder_operations import *
from nnunet.training.model_restore import load_model_and_checkpoint_files
from fvcore.nn.flop_count import _DEFAULT_SUPPORTED_OPS, FlopCountAnalysis, flop_count
import numpy as np
import torch
import os
j... | [
"argparse.ArgumentParser",
"nnunet.training.model_restore.load_model_and_checkpoint_files",
"fvcore.nn.flop_count.FlopCountAnalysis",
"numpy.array",
"sys.path.append"
] | [((11, 32), 'sys.path.append', 'sys.path.append', (['""".."""'], {}), "('..')\n", (26, 32), False, 'import sys\n'), ((349, 374), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (372, 374), False, 'import argparse\n'), ((725, 828), 'nnunet.training.model_restore.load_model_and_checkpoint_files', ... |
# -*- coding: utf-8 -*-
"""
Created on Tue Dec 19 00:04:41 2017
@author <NAME>
"""
import os
import time
while (True):
#sistem çağrısı yapılarak arp -a komutu çalıştırılıp tmp file ına dump edilir
os.system('arp -a> tmp')
#tmp file ı okunur
infile = open('tmp', 'r')
arp_mac = [... | [
"os.system",
"time.strftime",
"time.sleep"
] | [((218, 242), 'os.system', 'os.system', (['"""arp -a> tmp"""'], {}), "('arp -a> tmp')\n", (227, 242), False, 'import os\n'), ((1200, 1214), 'time.sleep', 'time.sleep', (['(15)'], {}), '(15)\n', (1210, 1214), False, 'import time\n'), ((1069, 1088), 'time.strftime', 'time.strftime', (['"""%X"""'], {}), "('%X')\n", (1082,... |
#!/usr/bin/env python
"""create_min_chi2_table.py.
Create Table of minimum Chi_2 values and save to a table.
"""
import argparse
import logging
import sys
from joblib import Parallel, delayed
from logutils import BraceMessage as __
from bin.coadd_analysis_script import main as coadd_analysis
from bin.coadd_chi2_db im... | [
"logutils.BraceMessage",
"argparse.ArgumentParser",
"bin.coadd_chi2_db.main",
"joblib.Parallel",
"simulators.iam_script.main",
"sys.exit",
"joblib.delayed",
"bin.coadd_analysis_script.main"
] | [((494, 561), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Do iam simulations on stars."""'}), "(description='Do iam simulations on stars.')\n", (517, 561), False, 'import argparse\n'), ((2106, 2117), 'sys.exit', 'sys.exit', (['(0)'], {}), '(0)\n', (2114, 2117), False, 'import sys\n'),... |
import models.local_model as model
import models.dataloader as dataloader
from models import training
import argparse
import torch
import config.config_loader as cfg_loader
parser = argparse.ArgumentParser(
description='Train Model'
)
parser.add_argument('config', type=str, help='Path to config file.')
args = par... | [
"models.dataloader.VoxelizedDataset",
"argparse.ArgumentParser",
"config.config_loader.load",
"models.local_model.get_models",
"torch.device"
] | [((183, 233), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Train Model"""'}), "(description='Train Model')\n", (206, 233), False, 'import argparse\n'), ((345, 373), 'config.config_loader.load', 'cfg_loader.load', (['args.config'], {}), '(args.config)\n', (360, 373), True, 'import confi... |
#CLIENT
import socket, threading, json
class Client:
def __init__(self):
self._username = "User"
self._serverHost = "127.0.0.1"
self._port = 4500
self._socket = None
print("Pager Client\n")
self.loadConfig()
self.connect()
... | [
"json.load",
"threading.Thread",
"json.dumps",
"socket.socket"
] | [((422, 463), 'threading.Thread', 'threading.Thread', ([], {'target': 'self.getMessages'}), '(target=self.getMessages)\n', (438, 463), False, 'import socket, threading, json\n'), ((488, 529), 'threading.Thread', 'threading.Thread', ([], {'target': 'self.sendMessage'}), '(target=self.sendMessage)\n', (504, 529), False, ... |
#!/usr/bin/python
# Copyright (c) 2020, 2021 Oracle and/or its affiliates.
# This software is made available to you under the terms of the GPL 3.0 license or the Apache 2.0 license.
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
# Apache License v2.0
# See LICENSE.TXT for d... | [
"ansible.module_utils.basic.AnsibleModule",
"ansible_collections.oracle.oci.plugins.module_utils.oci_common_utils.get_common_arg_spec",
"ansible_collections.oracle.oci.plugins.module_utils.oci_resource_utils.get_custom_class"
] | [((6270, 6336), 'ansible_collections.oracle.oci.plugins.module_utils.oci_resource_utils.get_custom_class', 'get_custom_class', (['"""ExecutionPlanStatsComparisionFactsHelperCustom"""'], {}), "('ExecutionPlanStatsComparisionFactsHelperCustom')\n", (6286, 6336), False, 'from ansible_collections.oracle.oci.plugins.module_... |
from contextlib import suppress
from aiogram import Dispatcher, types
from aiogram.dispatcher.filters import IsReplyFilter, IDFilter
from bot.blocklists import banned, shadowbanned
from bot.handlers.adminmode import extract_id
async def cmd_ban(message: types.Message):
try:
user_id = extract_id(message)... | [
"aiogram.dispatcher.filters.IDFilter",
"bot.blocklists.shadowbanned.remove",
"contextlib.suppress",
"aiogram.dispatcher.filters.IsReplyFilter",
"bot.blocklists.banned.remove",
"bot.handlers.adminmode.extract_id"
] | [((301, 320), 'bot.handlers.adminmode.extract_id', 'extract_id', (['message'], {}), '(message)\n', (311, 320), False, 'from bot.handlers.adminmode import extract_id\n'), ((693, 712), 'bot.handlers.adminmode.extract_id', 'extract_id', (['message'], {}), '(message)\n', (703, 712), False, 'from bot.handlers.adminmode impo... |
# Copyright (c) 2019, <NAME> <<EMAIL>>
#
# SPDX-License-Identifier: BSD-2-Clause
from typing import Any
from attr import evolve
from htmlmin import minify
def available() -> bool:
return True
def run(item: Any, **_kwargs: Any) -> Any:
if isinstance(item.content, str):
content = minify(
... | [
"attr.evolve",
"htmlmin.minify"
] | [((301, 512), 'htmlmin.minify', 'minify', ([], {'input': 'item.content', 'remove_comments': '(True)', 'remove_empty_space': '(True)', 'remove_all_empty_space': '(True)', 'reduce_empty_attributes': '(True)', 'reduce_boolean_attributes': '(True)', 'remove_optional_attribute_quotes': '(True)'}), '(input=item.content, remo... |
'''
This file contains a dictionary with the standard value of the model parameters.
Unelss otherwise specified the parameters will take this value.
'''
import numpy as np
import copy
# ---- Evaluate mutation probability
L = 50 # lenght of AA chain involved in binding
pmut_per_base_per_division =... | [
"numpy.log",
"copy.deepcopy",
"numpy.power"
] | [((928, 941), 'numpy.log', 'np.log', (['(5e-08)'], {}), '(5e-08)\n', (934, 941), True, 'import numpy as np\n'), ((963, 976), 'numpy.log', 'np.log', (['(5e-07)'], {}), '(5e-07)\n', (969, 976), True, 'import numpy as np\n'), ((998, 1011), 'numpy.log', 'np.log', (['(1e-10)'], {}), '(1e-10)\n', (1004, 1011), True, 'import ... |
# Credit: https://sebastianraschka.com/Articles/2014_sqlite_in_python_tutorial.html
import sqlite3
import time
import torch
from PIL import Image
import io
sqlite_file_name = 'db_realistic_test.sqlite'
# TODO: Refactor to programmatically connect columns and their properties (uniqueness etc.). But multiple columns... | [
"PIL.Image.open",
"sqlite3.connect",
"torch.load",
"io.BytesIO",
"torch.save",
"time.time"
] | [((776, 809), 'sqlite3.connect', 'sqlite3.connect', (['sqlite_file_name'], {}), '(sqlite_file_name)\n', (791, 809), False, 'import sqlite3\n'), ((1861, 1893), 'torch.load', 'torch.load', (['"""Aaron_Eckhart_1.pt"""'], {}), "('Aaron_Eckhart_1.pt')\n", (1871, 1893), False, 'import torch\n'), ((1906, 1952), 'PIL.Image.ope... |
# Get the Python helper library from https://twilio.com/docs/libraries/python
import os
from twilio.rest import Client
# Get your Account SID and Auth Token from https://twilio.com/console
# To set up environmental variables, see http://twil.io/secure
account = os.environ['TWILIO_ACCOUNT_SID']
token = os.environ['TWIL... | [
"twilio.rest.Client"
] | [((346, 368), 'twilio.rest.Client', 'Client', (['account', 'token'], {}), '(account, token)\n', (352, 368), False, 'from twilio.rest import Client\n')] |
# coding: utf8
# Functions used by nipype interface.
# Initiate the pipeline
def init_input_node(pet):
from clinica.utils.filemanip import get_subject_id
from clinica.utils.ux import print_begin_image
# Extract image ID
image_id = get_subject_id(pet)
print_begin_image(image_id)
return pet
... | [
"nipype.interfaces.utility.Rename",
"nibabel.load",
"numpy.where",
"nipype.utils.filemanip.split_filename",
"clinica.utils.filemanip.get_subject_id",
"clinica.utils.stream.cprint",
"os.getcwd",
"nilearn.image.resample_to_img",
"numpy.isnan",
"os.path.basename",
"nibabel.Nifti1Image",
"clinica.... | [((251, 270), 'clinica.utils.filemanip.get_subject_id', 'get_subject_id', (['pet'], {}), '(pet)\n', (265, 270), False, 'from clinica.utils.filemanip import get_subject_id\n'), ((275, 302), 'clinica.utils.ux.print_begin_image', 'print_begin_image', (['image_id'], {}), '(image_id)\n', (292, 302), False, 'from clinica.uti... |
from typing import Optional, List
from torch.nn import Module
from torch.optim import Optimizer
from torch.utils.data import ConcatDataset
from avalanche.benchmarks.utils import AvalancheConcatDataset
from avalanche.training import default_logger
from avalanche.training.plugins import StrategyPlugin, EvaluationPlugin... | [
"avalanche.benchmarks.utils.AvalancheConcatDataset"
] | [((2477, 2540), 'avalanche.benchmarks.utils.AvalancheConcatDataset', 'AvalancheConcatDataset', (['[self.dataset, self.experience.dataset]'], {}), '([self.dataset, self.experience.dataset])\n', (2499, 2540), False, 'from avalanche.benchmarks.utils import AvalancheConcatDataset\n')] |
from __future__ import print_function, absolute_import
import sys
import os
sys.path.append(os.path.dirname(__file__))
__name__='conda_pack'
from .core import CondaEnv, File, CondaPackException, pack
from ._version import get_versions
__version__ = get_versions()['version']
del get_versions
from .cli import main
main(... | [
"os.path.dirname"
] | [((92, 117), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (107, 117), False, 'import os\n')] |
from collections import namedtuple
import datetime
import logging
import os
import random
import time
import uuid
from dotenv import load_dotenv
from hop import Stream
from hop.plugins.snews import SNEWSHeartbeat, SNEWSObservation
logger = logging.getLogger("snews")
Detector = namedtuple("Detector", "detector_id ... | [
"logging.getLogger",
"collections.namedtuple",
"logging.debug",
"os.getenv",
"datetime.datetime.utcnow",
"time.sleep",
"hop.Stream",
"dotenv.load_dotenv",
"uuid.uuid4",
"random.random"
] | [((244, 270), 'logging.getLogger', 'logging.getLogger', (['"""snews"""'], {}), "('snews')\n", (261, 270), False, 'import logging\n'), ((284, 330), 'collections.namedtuple', 'namedtuple', (['"""Detector"""', '"""detector_id location"""'], {}), "('Detector', 'detector_id location')\n", (294, 330), False, 'from collection... |
import time
load_start_time = time.time()
import csv
import nltk
import re
import numpy as np
import pandas as pd
from dateutil import parser
import gensim, logging
from gensim.models import Word2Vec
from nltk.tokenize import sent_tokenize, word_tokenize
from nltk.corpus import stopwords
from nltk.stem.porter import ... | [
"dateutil.parser.parse",
"nltk.corpus.stopwords.words",
"numpy.where",
"gensim.models.Word2Vec",
"nltk.stem.porter.PorterStemmer",
"numpy.array",
"nltk.tokenize.sent_tokenize",
"csv.reader",
"pandas.DataFrame",
"time.time"
] | [((30, 41), 'time.time', 'time.time', ([], {}), '()\n', (39, 41), False, 'import time\n'), ((398, 424), 'nltk.corpus.stopwords.words', 'stopwords.words', (['"""english"""'], {}), "('english')\n", (413, 424), False, 'from nltk.corpus import stopwords\n'), ((469, 484), 'nltk.stem.porter.PorterStemmer', 'PorterStemmer', (... |
import os
from opensfm import dataset
from opensfm import dense
from opensfm.dataset import DataSet
def run_dataset(data: DataSet, subfolder, interactive) -> None:
"""Compute depthmap on a dataset with has SfM ran already.
Args:
subfolder: dataset's subfolder where to store results
interacti... | [
"opensfm.dense.compute_depthmaps",
"os.path.join",
"opensfm.dataset.UndistortedDataSet"
] | [((387, 426), 'os.path.join', 'os.path.join', (['data.data_path', 'subfolder'], {}), '(data.data_path, subfolder)\n', (399, 426), False, 'import os\n'), ((442, 514), 'opensfm.dataset.UndistortedDataSet', 'dataset.UndistortedDataSet', (['data', 'udata_path'], {'io_handler': 'data.io_handler'}), '(data, udata_path, io_ha... |
#!/usr/bin/python
import sys, time
import numpy as np
from math import *
import argparse
import general_scripts as gs
from distutils.version import LooseVersion
def read_file(fn, field, key="none"):
legs=[]
nplots=0
nlines=[]
xlist=[]
ylist=[]
tmp=0
tmpx=[]
tmpy=[]
if key=="none":... | [
"argparse.ArgumentParser",
"general_scripts.print_sxylist",
"numpy.array",
"numpy.zeros",
"numpy.stack",
"numpy.array_equal",
"numpy.interp",
"sys.exit",
"distutils.version.LooseVersion",
"time.time"
] | [((2807, 3199), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Takes a number of xmgrace-like files containing equivalent dataeach from a different replicate, and perform averaging acrossthese files.More info: For each file containing sets of difference curves,e.g. s0, s1, s2... perform ... |
# train_networks.py
# For training CNNs and SDNs via IC-only and SDN-training strategies
# It trains and save the resulting models to an output directory specified in the main function
import os
# os.environ['CUDA_VISIBLE_DEVICES'] = '0'
import copy
import torch
import time
import os
import random
import numpy as np
f... | [
"deeplearning.network_architectures.create_vgg16bn",
"deeplearning.network_architectures.get_net_params",
"deeplearning.network_architectures.load_model",
"deeplearning.aux_funcs.get_dataset",
"deeplearning.aux_funcs.get_sdn_ic_only_optimizer",
"deeplearning.network_architectures.load_params",
"deeplear... | [((5525, 5573), 'deeplearning.network_architectures.create_vgg16bn', 'arcs.create_vgg16bn', (['None', '"""cifar10"""', 'None', '(True)'], {}), "(None, 'cifar10', None, True)\n", (5544, 5573), True, 'from deeplearning import network_architectures as arcs\n'), ((5756, 5767), 'architectures.CNNs.VGG.VGG', 'VGG', (['params... |
"""
Evaluation Scripts
"""
from __future__ import absolute_import
from __future__ import division
from collections import namedtuple, OrderedDict
from network import mynn
import argparse
import logging
import os
import torch
import time
import numpy as np
from config import cfg, assert_and_infer_cfg
import network
imp... | [
"network.get_net",
"sklearn.metrics.auc",
"config.assert_and_infer_cfg",
"numpy.array",
"sklearn.metrics.roc_curve",
"os.path.exists",
"os.listdir",
"argparse.ArgumentParser",
"numpy.random.seed",
"numpy.concatenate",
"torchvision.transforms.ToTensor",
"torch.nn.SyncBatchNorm.convert_sync_batc... | [((756, 781), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (771, 781), False, 'import os\n'), ((806, 863), 'os.path.join', 'os.path.join', (['dirname', '"""pretrained/r101_os8_base_cty.pth"""'], {}), "(dirname, 'pretrained/r101_os8_base_cty.pth')\n", (818, 863), False, 'import os\n'), ((892... |
from datetime import timedelta
from feast import BigQuerySource, Entity, Feature, FeatureView, ValueType
nonexistent_source = BigQuerySource(
table_ref="project.dataset.nonexistent_table", event_timestamp_column=""
)
driver = Entity(name="driver", value_type=ValueType.INT64, description="driver id",)
nonexisten... | [
"feast.Feature",
"datetime.timedelta",
"feast.Entity",
"feast.BigQuerySource"
] | [((128, 220), 'feast.BigQuerySource', 'BigQuerySource', ([], {'table_ref': '"""project.dataset.nonexistent_table"""', 'event_timestamp_column': '""""""'}), "(table_ref='project.dataset.nonexistent_table',\n event_timestamp_column='')\n", (142, 220), False, 'from feast import BigQuerySource, Entity, Feature, FeatureV... |
import re
def urljoin(*pieces):
"""Join a URL
Joins the pieces together to an URL.
Cannot be replaced by urllib.parse.urljoin,
because that doesn't join parts of a path and
doesn't allow for multiple pieces to be joined.
Arguments:
*pieces {str} -- pieces of URL
"""
return ... | [
"re.sub"
] | [((646, 681), 're.sub', 're.sub', (['"""\\\\W|^(?=\\\\d)"""', '"""_"""', 'string'], {}), "('\\\\W|^(?=\\\\d)', '_', string)\n", (652, 681), False, 'import re\n')] |
"""
renderers.py
============
Functions to render output to:
* HTML specification document
* Python classes for IOOS compliance checker plugin
"""
from jinja2 import Environment, PackageLoader, select_autoescape
env = Environment(
loader=PackageLoader('check_maker', 'templates'),
autoescape=... | [
"jinja2.select_autoescape",
"jinja2.PackageLoader"
] | [((261, 302), 'jinja2.PackageLoader', 'PackageLoader', (['"""check_maker"""', '"""templates"""'], {}), "('check_maker', 'templates')\n", (274, 302), False, 'from jinja2 import Environment, PackageLoader, select_autoescape\n'), ((320, 354), 'jinja2.select_autoescape', 'select_autoescape', (["['html', 'xml']"], {}), "(['... |
import collections
import itertools
from online_cognacy_ident.align import normalized_levenshtein as ldn
class dataset(object):
def __init__(self, datei):
self.datei = datei
def get_asjp_pairs(self, initial_cutoff, as_int_tuples=True):
exc = ["%", "~", "*", "$", "\"", " "]
with open... | [
"itertools.combinations",
"collections.OrderedDict",
"online_cognacy_ident.align.normalized_levenshtein"
] | [((844, 869), 'collections.OrderedDict', 'collections.OrderedDict', ([], {}), '()\n', (867, 869), False, 'import collections\n'), ((1191, 1223), 'itertools.combinations', 'itertools.combinations', (['value', '(2)'], {}), '(value, 2)\n', (1213, 1223), False, 'import itertools\n'), ((1249, 1266), 'online_cognacy_ident.al... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from datetime import datetime
import pandas as pd
from kavalkilu import LogWithInflux
from servertools import (
SlackWeatherNotification,
OpenWeather,
OWMLocation,
Plants,
Plant
)
# Initiate Log, including a suffix to the log name to denote which insta... | [
"kavalkilu.LogWithInflux",
"pandas.Timedelta",
"pandas.to_datetime",
"servertools.OpenWeather",
"datetime.datetime.now",
"servertools.SlackWeatherNotification"
] | [((348, 394), 'kavalkilu.LogWithInflux', 'LogWithInflux', (['"""frost_warn"""'], {'log_dir': '"""weather"""'}), "('frost_warn', log_dir='weather')\n", (361, 394), False, 'from kavalkilu import LogWithInflux\n'), ((402, 416), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (414, 416), False, 'from datetime im... |
from OpenGL import GL
import glm
import importlib
import Helpers
importlib.reload(Helpers)
from Helpers import compile_shader, link_program, create_program_attribute_layout, create_vertex_array_and_draw_call,\
flatten_vertex_data, validate_vertex_data, validate_attribute_bindings
def create_cube(s):
... | [
"OpenGL.GL.glDisable",
"OpenGL.GL.glDeleteVertexArrays",
"OpenGL.GL.glClearDepth",
"OpenGL.GL.glUseProgram",
"OpenGL.GL.glDeleteProgram",
"glm.mat4",
"OpenGL.GL.glClear",
"OpenGL.GL.glBindVertexArray",
"Helpers.link_program",
"OpenGL.GL.glEnable",
"glm.value_ptr",
"glm.perspective",
"glm.vec... | [((69, 94), 'importlib.reload', 'importlib.reload', (['Helpers'], {}), '(Helpers)\n', (85, 94), False, 'import importlib\n'), ((4456, 4491), 'OpenGL.GL.glClearColor', 'GL.glClearColor', (['(0.2)', '(0.2)', '(0.2)', '(0.0)'], {}), '(0.2, 0.2, 0.2, 0.0)\n', (4471, 4491), False, 'from OpenGL import GL\n'), ((4497, 4517), ... |
# Copyright 2022 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | [
"numpy.ones_like",
"official.nlp.data.tagging_dataloader.TaggingDataConfig",
"absl.testing.parameterized.parameters",
"tensorflow.io.TFRecordWriter",
"tensorflow.test.main",
"numpy.random.randint",
"tensorflow.train.Features",
"official.nlp.data.tagging_dataloader.TaggingDataLoader"
] | [((924, 957), 'tensorflow.io.TFRecordWriter', 'tf.io.TFRecordWriter', (['output_path'], {}), '(output_path)\n', (944, 957), True, 'import tensorflow as tf\n'), ((1853, 1890), 'absl.testing.parameterized.parameters', 'parameterized.parameters', (['(True)', '(False)'], {}), '(True, False)\n', (1877, 1890), False, 'from a... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# filename: app/views/miniprogram_api.py
import os
import sys
basedir = os.path.join(os.path.dirname(__file__),"..") # 根目录为app
cachedir = os.path.join(basedir,"cache")
textdir = os.path.join(basedir,"text")
import re
from collections import OrderedDict
import simplejso... | [
"collections.OrderedDict",
"simplejson.dumps",
"os.path.join",
"pypinyin.lazy_pinyin",
"flask.safe_join",
"os.path.dirname",
"flask.request.json.get",
"os.path.abspath",
"re.error"
] | [((188, 218), 'os.path.join', 'os.path.join', (['basedir', '"""cache"""'], {}), "(basedir, 'cache')\n", (200, 218), False, 'import os\n'), ((228, 257), 'os.path.join', 'os.path.join', (['basedir', '"""text"""'], {}), "(basedir, 'text')\n", (240, 257), False, 'import os\n'), ((2184, 2573), 'collections.OrderedDict', 'Or... |
from setuptools import setup
setup(
name='cart',
version='1.0.0',
description='cart-regression-trees',
author='<NAME>',
packages=['cart'], # same as name
install_requires=['pandas', 'numpy','sklearn'], # external packages as dependencies
) | [
"setuptools.setup"
] | [((30, 195), 'setuptools.setup', 'setup', ([], {'name': '"""cart"""', 'version': '"""1.0.0"""', 'description': '"""cart-regression-trees"""', 'author': '"""<NAME>"""', 'packages': "['cart']", 'install_requires': "['pandas', 'numpy', 'sklearn']"}), "(name='cart', version='1.0.0', description='cart-regression-trees',\n ... |
import os
import unittest
from BaseSpacePy.api.BaseMountInterface import BaseMountInterface, BaseMountInterfaceException
def get_basemount_root():
import getpass
username = getpass.getuser()
config_name = "hoth"
basemount_root = "/basespace"
basemount_target = "%s.%s" % (username, config_name)
... | [
"getpass.getuser",
"BaseSpacePy.api.BaseMountInterface.BaseMountInterface",
"os.path.join",
"unittest.main"
] | [((429, 486), 'os.path.join', 'os.path.join', (['basemount_root', '"""Projects"""', '"""BaseSpaceDemo"""'], {}), "(basemount_root, 'Projects', 'BaseSpaceDemo')\n", (441, 486), False, 'import os\n'), ((523, 568), 'os.path.join', 'os.path.join', (['project_path', '"""Samples"""', '"""BC_1"""'], {}), "(project_path, 'Samp... |
'''
marqeta-python
The Marqeta Python library provides access to the Marqeta platform Core API.
This library is released as a Beta. If you find anything that needs fixing or can be improved,
please create an issue on GitHub.
**Version:** v0.1.0
**Author:** Marqeta, Inc.
**Copyright:** (c) 2019 Marqeta, Inc.
**Li... | [
"marqeta.errors.MarqetaError",
"json.dumps",
"requests.get",
"requests.delete",
"sys.version.split"
] | [((7245, 7406), 'requests.get', 'requests.get', ([], {'url': '(self.base_url + endpoint)', 'auth': '(self.application_token, self.access_token)', 'headers': 'headers', 'params': 'query_params', 'timeout': 'self.timeout'}), '(url=self.base_url + endpoint, auth=(self.application_token,\n self.access_token), headers=he... |
# -*- coding:utf-8 -*-
import cv2
import numpy as np
def cvcar(videoUrl, pic):
weightsPath = 'yolov3.weights' # 模型权重文件
configPath = 'yolov3.cfg' # 模型配置文件
labelsPath = 'yolov3.txt' # 模型类别标签文件
# 初始化一些参数
LABELS = open(labelsPath).read().strip().split("\n")
boxes = []
confidences = []
... | [
"cv2.dnn.blobFromImage",
"cv2.imwrite",
"cv2.rectangle",
"numpy.argmax",
"cv2.putText",
"numpy.array",
"cv2.VideoCapture",
"cv2.dnn.NMSBoxes",
"cv2.imread",
"cv2.dnn.readNetFromDarknet"
] | [((387, 438), 'cv2.dnn.readNetFromDarknet', 'cv2.dnn.readNetFromDarknet', (['configPath', 'weightsPath'], {}), '(configPath, weightsPath)\n', (413, 438), False, 'import cv2\n'), ((509, 532), 'cv2.imwrite', 'cv2.imwrite', (['pic', 'frame'], {}), '(pic, frame)\n', (520, 532), False, 'import cv2\n'), ((545, 560), 'cv2.imr... |
import warnings
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': ':memory:',
}
}
warnings.simplefilter('ignore', Warning)
INSTALLED_APPS = (
'django.contrib.admin',
'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'... | [
"warnings.simplefilter"
] | [((133, 173), 'warnings.simplefilter', 'warnings.simplefilter', (['"""ignore"""', 'Warning'], {}), "('ignore', Warning)\n", (154, 173), False, 'import warnings\n')] |
from docs.source.plots.logical_systems.draw_logic import draw_system
from yvain.logical_systems import Dombi
if __name__ == '__main__':
draw_system(Dombi(0.1), "Dombi system with $p = 0.1$")
| [
"yvain.logical_systems.Dombi"
] | [((153, 163), 'yvain.logical_systems.Dombi', 'Dombi', (['(0.1)'], {}), '(0.1)\n', (158, 163), False, 'from yvain.logical_systems import Dombi\n')] |
import os
import importlib
env = os.environ.get('DJANGO_SETTINGS_ENV')
app = os.environ.get('DJANGO_SETTINGS_APP')
module_paths = []
module_paths.append('settings.base')
if env:
module_paths.append('settings.envs.{env}'.format(env=env))
if app:
module_paths.append('settings.apps.{app}'.format(app=app))
... | [
"os.environ.get",
"importlib.import_module"
] | [((36, 73), 'os.environ.get', 'os.environ.get', (['"""DJANGO_SETTINGS_ENV"""'], {}), "('DJANGO_SETTINGS_ENV')\n", (50, 73), False, 'import os\n'), ((80, 117), 'os.environ.get', 'os.environ.get', (['"""DJANGO_SETTINGS_APP"""'], {}), "('DJANGO_SETTINGS_APP')\n", (94, 117), False, 'import os\n'), ((414, 450), 'importlib.i... |
# -*- coding: utf-8 -*-
"""
Created on Sat Oct 16 15:45:10 2021
@author: trite
"""
from MIDISynth import midi2piece
import numpy as np
from pathlib import Path
file_name = 'tempest'
file_path = Path('..') / Path('data') / Path('midi') \
/ Path(file_name + 'mid')
piece = midi2piece(file_name, file_path... | [
"pathlib.Path",
"numpy.arange",
"MIDISynth.midi2piece"
] | [((289, 326), 'MIDISynth.midi2piece', 'midi2piece', (['file_name', 'file_path', '(1.0)'], {}), '(file_name, file_path, 1.0)\n', (299, 326), False, 'from MIDISynth import midi2piece\n'), ((257, 280), 'pathlib.Path', 'Path', (["(file_name + 'mid')"], {}), "(file_name + 'mid')\n", (261, 280), False, 'from pathlib import P... |
from collections import namedtuple, deque
from random import sample, random, randint
from math import exp
from numpy import array, zeros, argmax
import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv1D, MaxPool1D, LSTM, Dropout, Flatten, Dense
from tensorflow.keras.op... | [
"random.sample",
"collections.namedtuple",
"collections.deque",
"tensorflow.keras.layers.Dropout",
"numpy.argmax",
"numpy.max",
"tensorflow.keras.optimizers.Adam",
"numpy.array",
"numpy.zeros",
"tensorflow.keras.layers.Dense",
"tensorflow.keras.layers.LSTM",
"tensorflow.keras.layers.Conv1D",
... | [((548, 637), 'collections.namedtuple', 'namedtuple', (['"""Transition"""', "('Current_State', 'Action', 'Reward', 'Next_State', 'done')"], {}), "('Transition', ('Current_State', 'Action', 'Reward', 'Next_State',\n 'done'))\n", (558, 637), False, 'from collections import namedtuple, deque\n'), ((1070, 1096), 'collec... |
#!/usr/bin/env python3
####################
# Node
class DagrNode(object):
nodes_by_name = dict()
def __init__(self, name, parents=[], cmd=None):
self.name = name
self.parents = set(parents)
assert name not in DagrNode.nodes_by_name
DagrNode.nodes_by_name[name] = self
... | [
"subprocess.list2cmdline",
"threading.Lock",
"threading.enumerate",
"subprocess.Popen",
"multiprocessing.cpu_count",
"threading.Event",
"sys.stderr.write",
"shlex.quote",
"threading.Thread",
"threading.Condition",
"time.time",
"sys.stdout.write"
] | [((6103, 6130), 'multiprocessing.cpu_count', 'multiprocessing.cpu_count', ([], {}), '()\n', (6128, 6130), False, 'import multiprocessing\n'), ((4570, 4587), 'shlex.quote', 'shlex.quote', (['args'], {}), '(args)\n', (4581, 4587), False, 'import shlex\n'), ((7351, 7362), 'time.time', 'time.time', ([], {}), '()\n', (7360,... |
import csv
from datetime import datetime, timezone
import numpy as np
from exetera.core.session import Session
from exetera.core.persistence import DataStore
from exetera.core import utils, dataframe, dataset
from exetera.core import persistence as prst
from exeteracovid.algorithms.test_type_from_mechanism import tes... | [
"exeteracovid.algorithms.test_type_from_mechanism.pcr_standard_summarize",
"numpy.ones_like",
"exetera.core.session.Session",
"exetera.core.persistence.foreign_key_is_in_primary_key",
"numpy.where",
"csv.writer",
"exeteracovid.algorithms.test_type_from_mechanism.test_type_from_mechanism_v2",
"numpy.lo... | [((1109, 1120), 'exetera.core.persistence.DataStore', 'DataStore', ([], {}), '()\n', (1118, 1120), False, 'from exetera.core.persistence import DataStore\n'), ((1130, 1156), 'datetime.datetime.now', 'datetime.now', (['timezone.utc'], {}), '(timezone.utc)\n', (1142, 1156), False, 'from datetime import datetime, timezone... |
# Generated by Django 3.0.2 on 2020-04-22 01:46
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('users', '0019_auto_20200421_2005'),
]
operations = [
migrations.AlterField(
model_name='comment',
name='comment_text... | [
"django.db.models.TextField"
] | [((341, 381), 'django.db.models.TextField', 'models.TextField', ([], {'verbose_name': '"""comment"""'}), "(verbose_name='comment')\n", (357, 381), False, 'from django.db import migrations, models\n')] |
#!/bin/python
# Copyright 2018 <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, publish, di... | [
"configparser.ConfigParser",
"xml_writers.NetworkWriter",
"multiprocessing.cpu_count",
"os.getcwd",
"xml_writers.ConfigWriter"
] | [((4813, 4841), 'xml_writers.ConfigWriter', 'writers.ConfigWriter', (['config'], {}), '(config)\n', (4833, 4841), True, 'import xml_writers as writers\n'), ((4894, 4923), 'xml_writers.NetworkWriter', 'writers.NetworkWriter', (['config'], {}), '(config)\n', (4915, 4923), True, 'import xml_writers as writers\n'), ((1487,... |
import operator
import logging
import numpy as np
import pandas as pd
from .coordinates import Coordinates
from .visual import VisualAttributes
from .visual import COLORS
from .exceptions import IncompatibleAttribute
from .component_link import (ComponentLink, CoordinateComponentLink,
Bin... | [
"numpy.product",
"logging.debug",
"numpy.unique",
"numpy.searchsorted",
"numpy.asarray",
"numpy.can_cast",
"numpy.issubdtype",
"numpy.isfinite",
"numpy.broadcast_arrays",
"numpy.random.RandomState"
] | [((5012, 5080), 'logging.debug', 'logging.debug', (['"""Using %s to index data of shape %s"""', 'key', 'self.shape'], {}), "('Using %s to index data of shape %s', key, self.shape)\n", (5025, 5080), False, 'import logging\n'), ((5236, 5273), 'numpy.can_cast', 'np.can_cast', (['self.data[0]', 'np.complex'], {}), '(self.d... |
import sys
from timeit import timeit
import matplotlib.pyplot as plt
import numpy as np
# from numba import jit, njit
# from numba.typed import List
from statistics import mean
import ray
from multiprocessing import Pool
# Silences Numba warnings about a Python list being passed into a numba function
import warnings
... | [
"statistics.mean",
"ray.get",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"julia.Main.include",
"numpy.array",
"multiprocessing.Pool",
"matplotlib.pyplot.autoscale",
"matplotlib.pyplot.title",
"matplotlib.pyplot.xlim",
"warnings.filterwarnings",
"matplot... | [((320, 353), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (343, 353), False, 'import warnings\n'), ((878, 912), 'numpy.array', 'np.array', (['pyList'], {'dtype': 'np.float64'}), '(pyList, dtype=np.float64)\n', (886, 912), True, 'import numpy as np\n'), ((4029, 4057), 'j... |
from typeguard import typechecked
from exasol_data_science_utils_python.preprocessing.sql.schema.identifier import ExasolIdentifier
from exasol_data_science_utils_python.utils.repr_generation_for_object import generate_repr_for_object
class SchemaName(ExasolIdentifier):
@typechecked
def __init__(self, schema... | [
"exasol_data_science_utils_python.utils.repr_generation_for_object.generate_repr_for_object"
] | [((604, 634), 'exasol_data_science_utils_python.utils.repr_generation_for_object.generate_repr_for_object', 'generate_repr_for_object', (['self'], {}), '(self)\n', (628, 634), False, 'from exasol_data_science_utils_python.utils.repr_generation_for_object import generate_repr_for_object\n')] |
#!/usr/bin/python
# -*- coding: utf-8 -*-
from __future__ import absolute_import, division, print_function
__metaclass__ = type
DOCUMENTATION = '''
---
module: oracle_stats_prefs
short_description: Manage DBMS_STATS global preferences
description:
- Manage DBMS_STATS global preferences
- Can be run locally o... | [
"cx_Oracle.connect",
"cx_Oracle.makedsn"
] | [((4025, 4081), 'cx_Oracle.connect', 'cx_Oracle.connect', (['wallet_connect'], {'mode': 'cx_Oracle.SYSDBA'}), '(wallet_connect, mode=cx_Oracle.SYSDBA)\n', (4042, 4081), False, 'import cx_Oracle\n'), ((4164, 4197), 'cx_Oracle.connect', 'cx_Oracle.connect', (['wallet_connect'], {}), '(wallet_connect)\n', (4181, 4197), Fa... |
import sys
import argparse
import math
from numpy import *
import matplotlib.pyplot as plt
from GridWorldMDP import *
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Simple grid world MDP")
parser.add_argument("--gamma", help="Discount factor", type=float, required=True)
parser.ad... | [
"argparse.ArgumentParser"
] | [((160, 220), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Simple grid world MDP"""'}), "(description='Simple grid world MDP')\n", (183, 220), False, 'import argparse\n')] |