code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
import re
if __name__ == '__main__':
n = int(input())
r = r'^[H|h][I|i]\s[^D|d]'
for _ in range(n):
s = input()
if re.match(r, s):
print(s)
| [
"re.match"
] | [((144, 158), 're.match', 're.match', (['r', 's'], {}), '(r, s)\n', (152, 158), False, 'import re\n')] |
from unittest import mock
from decimal import Decimal as D
from freezegun import freeze_time
from oscar.core.loading import get_model, get_class
from oscar.test import factories
from ..calculator import CCHTaxCalculator
from ..prices import ShippingCharge
from .base import BaseTest
from .base import p
import requests
i... | [
"oscar.test.factories.create_purchase_info",
"pybreaker.CircuitBreaker",
"unittest.mock.MagicMock",
"requests.exceptions.ReadTimeout",
"oscar.core.loading.get_model",
"oscar.test.factories.create_product",
"oscar.core.loading.get_class",
"freezegun.freeze_time",
"unittest.mock.patch",
"decimal.Dec... | [((346, 375), 'oscar.core.loading.get_model', 'get_model', (['"""basket"""', '"""Basket"""'], {}), "('basket', 'Basket')\n", (355, 375), False, 'from oscar.core.loading import get_model, get_class\n'), ((394, 431), 'oscar.core.loading.get_model', 'get_model', (['"""order"""', '"""ShippingAddress"""'], {}), "('order', '... |
# Python routines which don't really belong anywhere else.
import logging
import math
import os
from multiprocessing import Lock, Value
logger = logging.getLogger("xia2.lib.bits")
def is_mtz_file(filename):
"""Check if a file is MTZ format - at least according to the
magic number."""
with open(filena... | [
"logging.getLogger",
"math.sqrt",
"multiprocessing.Value",
"os.path.join",
"multiprocessing.Lock"
] | [((149, 183), 'logging.getLogger', 'logging.getLogger', (['"""xia2.lib.bits"""'], {}), "('xia2.lib.bits')\n", (166, 183), False, 'import logging\n'), ((776, 789), 'math.sqrt', 'math.sqrt', (['sd'], {}), '(sd)\n', (785, 789), False, 'import math\n'), ((1025, 1044), 'multiprocessing.Value', 'Value', (['"""i"""', 'initval... |
#!/usr/bin/python3
import sys
sys.path.append('cpp')
import pyattyscomm
print("Searching for Attys")
s = pyattyscomm.AttysScan()
s.scan()
c = s.getAttysComm(0)
if (c == None):
print("No Attys found")
quit()
c.start()
while True:
while (not c.hasSampleAvailable()):
pass
sample = c.getSampleFromB... | [
"sys.path.append",
"pyattyscomm.AttysScan"
] | [((30, 52), 'sys.path.append', 'sys.path.append', (['"""cpp"""'], {}), "('cpp')\n", (45, 52), False, 'import sys\n'), ((106, 129), 'pyattyscomm.AttysScan', 'pyattyscomm.AttysScan', ([], {}), '()\n', (127, 129), False, 'import pyattyscomm\n')] |
# Copyright 2021 Google LLC
#
# 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
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writin... | [
"tensorflow.data.TFRecordDataset",
"collections.OrderedDict",
"tensorflow.io.gfile.GFile",
"tensorflow.train.Example",
"absl.flags.mark_flags_as_required",
"tensorflow.data.experimental.TFRecordWriter",
"tensorflow.io.parse_single_example",
"os.path.join",
"tensorflow.data.Dataset.from_generator",
... | [((706, 784), 'absl.flags.DEFINE_string', 'flags.DEFINE_string', (['"""input_files"""'], {'default': 'None', 'help': '"""Input tfrecord files."""'}), "('input_files', default=None, help='Input tfrecord files.')\n", (725, 784), False, 'from absl import flags\n'), ((799, 904), 'absl.flags.DEFINE_string', 'flags.DEFINE_st... |
from ml_sl.knn.distance_pack.distance_measures import distance_measure_0
import heapq
class KNN():
def __init__(self, K, unlabeled_dataset_list, labeled_dataset_list, distance_mode, label_list):
"""
:param
K:
K nearest neighbors
K >= the classification ki... | [
"ml_sl.knn.distance_pack.distance_measures.distance_measure_0"
] | [((3829, 3948), 'ml_sl.knn.distance_pack.distance_measures.distance_measure_0', 'distance_measure_0', ([], {'x_list': 'unlabeled_data_list', 'data_list': 'self.labeled_dataset_list', 'd_type_str': 'self.distance_mode'}), '(x_list=unlabeled_data_list, data_list=self.\n labeled_dataset_list, d_type_str=self.distance_m... |
from . import common
from .common import db_connect, db_execute
import hashlib
import hmac
import math
import sqlalchemy
from flask import jsonify
from base64 import b64encode, b64decode
from binascii import Error as BinasciiError
PREIMAGE_BYTES = 32
TOKEN_VALUE_BYTES = 32
MAX_TOKENS_PER_REPORT = 12 * 24... | [
"hashlib.sha256",
"math.ceil",
"sqlalchemy.text",
"base64.b64encode",
"base64.b64decode"
] | [((524, 540), 'hashlib.sha256', 'hashlib.sha256', ([], {}), '()\n', (538, 540), False, 'import hashlib\n'), ((921, 1145), 'sqlalchemy.text', 'sqlalchemy.text', (["('INSERT INTO token (token_value, report_type, report_result) VALUES (:value, :type, :result) ON CONFLICT (token_value) DO UPDATE SET report_type = :type, re... |
import random
import sc2
from sc2 import run_game, maps, Race, Difficulty
from sc2.player import Bot, Computer
from sc2.constants import NEXUS, PROBE, PYLON, ASSIMILATOR, GATEWAY, \
CYBERNETICSCORE, STALKER, STARGATE, VOIDRAY, FORGE, PHOTONCANNON
class FiliBot(sc2.BotAI):
def __init__(self):
self.MAX_WORKE... | [
"random.choice",
"sc2.maps.get",
"sc2.player.Computer"
] | [((9962, 9987), 'sc2.maps.get', 'maps.get', (['"""AbyssalReefLE"""'], {}), "('AbyssalReefLE')\n", (9970, 9987), False, 'from sc2 import run_game, maps, Race, Difficulty\n'), ((10029, 10067), 'sc2.player.Computer', 'Computer', (['Race.Terran', 'Difficulty.Hard'], {}), '(Race.Terran, Difficulty.Hard)\n', (10037, 10067), ... |
# Generated by Django 3.0.3 on 2021-12-01 07:38
import apps.workspaces.models
import django.contrib.postgres.fields
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('workspaces', '0017_workspace_cluster_domain'),
]
operations = [
migratio... | [
"django.db.models.CharField"
] | [((494, 526), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(100)'}), '(max_length=100)\n', (510, 526), False, 'from django.db import migrations, models\n')] |
from django import template
from django.conf import settings
register = template.Library()
@register.filter(name="pieces")
def pieces(string):
return f"{string} шт."
@register.filter(name="rubles")
def rubles(string):
return f"{string} руб."
| [
"django.template.Library"
] | [((73, 91), 'django.template.Library', 'template.Library', ([], {}), '()\n', (89, 91), False, 'from django import template\n')] |
import csv
import pandas as pd
# # from sqlalchemy import create_engine
from com_blacktensor.ext.db import db, openSession, engine
from sqlalchemy import func
# from com_blacktensor.ext.routes import Resource
from com_blacktensor.cop.sto.model.stock_kdd import StockKdd
from com_blacktensor.cop.sto.model.stock_dto impo... | [
"com_blacktensor.cop.sto.model.stock_dfo.StockDfo",
"com_blacktensor.ext.db.openSession",
"sqlalchemy.func.count"
] | [((466, 479), 'com_blacktensor.ext.db.openSession', 'openSession', ([], {}), '()\n', (477, 479), False, 'from com_blacktensor.ext.db import db, openSession, engine\n'), ((581, 591), 'com_blacktensor.cop.sto.model.stock_dfo.StockDfo', 'StockDfo', ([], {}), '()\n', (589, 591), False, 'from com_blacktensor.cop.sto.model.s... |
import cv2
import numpy as np
def nothing(x):
pass
cap = cv2.VideoCapture(0)
cv2.namedWindow("Settings")
cv2.createTrackbar("Lower-Hue", "Settings", 0, 180, nothing)
cv2.createTrackbar("Lower-Saturation", "Settings", 0, 255, nothing)
cv2.createTrackbar("Lower-Value", "Settings", 0, 255, nothing)
cv2.createTrac... | [
"cv2.imshow",
"numpy.array",
"cv2.destroyAllWindows",
"cv2.approxPolyDP",
"cv2.erode",
"cv2.arcLength",
"cv2.contourArea",
"cv2.waitKey",
"cv2.drawContours",
"numpy.ones",
"cv2.putText",
"cv2.cvtColor",
"cv2.createTrackbar",
"cv2.namedWindow",
"cv2.flip",
"cv2.inRange",
"cv2.VideoCap... | [((65, 84), 'cv2.VideoCapture', 'cv2.VideoCapture', (['(0)'], {}), '(0)\n', (81, 84), False, 'import cv2\n'), ((86, 113), 'cv2.namedWindow', 'cv2.namedWindow', (['"""Settings"""'], {}), "('Settings')\n", (101, 113), False, 'import cv2\n'), ((114, 174), 'cv2.createTrackbar', 'cv2.createTrackbar', (['"""Lower-Hue"""', '"... |
# -*- coding: utf-8 -*-
import re
from ..base.downloader import BaseDownloader
class YesPornPleaseCom(BaseDownloader):
__name__ = "YesPornPleaseCom"
__type__ = "downloader"
__version__ = "0.02"
__status__ = "testing"
__pyload_version__ = "0.5"
__pattern__ = r"https?://(?:www\.)?yespornpleas... | [
"re.findall"
] | [((842, 882), 're.findall', 're.findall', (['"""<iframe src="([^"]+)"""', 'resp'], {}), '(\'<iframe src="([^"]+)\', resp)\n', (852, 882), False, 'import re\n'), ((1044, 1091), 're.findall', 're.findall', (['"""<source src="([^"]+)"""', 'iframe_resp'], {}), '(\'<source src="([^"]+)\', iframe_resp)\n', (1054, 1091), Fals... |
import torch
import torch.nn as nn
import torch.nn.functional as F
from .fixed_point_solver import NeuralFixedPoint
from .root_find_solver import NeuralRootFind
from .diffeq_solver import DiffeqSolver
class SPDEFunc0d(torch.nn.Module):
""" Modelling local operators F and G in (latent) SPDE (d_t - L)u = F(u)dt + G... | [
"torch.nn.BatchNorm2d",
"torch.nn.ReLU",
"torch.nn.Tanh",
"torch.nn.Sequential",
"torch.nn.Conv2d",
"torch.nn.BatchNorm1d",
"torch.nn.Linear",
"torch.nn.BatchNorm3d",
"torch.nn.Conv1d",
"torch.nn.Conv3d"
] | [((784, 807), 'torch.nn.Sequential', 'nn.Sequential', (['*model_F'], {}), '(*model_F)\n', (797, 807), True, 'import torch.nn as nn\n'), ((1003, 1026), 'torch.nn.Sequential', 'nn.Sequential', (['*model_G'], {}), '(*model_G)\n', (1016, 1026), True, 'import torch.nn as nn\n'), ((1862, 1885), 'torch.nn.Sequential', 'nn.Seq... |
from datetime import datetime
from packages.play_text import play_text
def get_time():
time = datetime.now()
play_text('The time is ' + str(time))
| [
"datetime.datetime.now"
] | [((99, 113), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (111, 113), False, 'from datetime import datetime\n')] |
from pandas import read_table, concat
from config import DATA_DIR
from data_sources.data_source import DataSource
from data_sources.sra import SRAExpressionLayer
from layers import ExpressionLayer
class Recount2(DataSource):
def __init__(self, meta_sra, *args, **kwargs):
# if not meta_sra:
super... | [
"data_sources.sra.SRAExpressionLayer",
"pandas.read_table"
] | [((716, 787), 'data_sources.sra.SRAExpressionLayer', 'SRAExpressionLayer', (['df'], {'run_to_study': '{run: study for run in df.columns}'}), '(df, run_to_study={run: study for run in df.columns})\n', (734, 787), False, 'from data_sources.sra import SRAExpressionLayer\n'), ((506, 556), 'pandas.read_table', 'read_table',... |
# Copyright 2013 University of Maryland. All rights reserved.
# Use of this source code is governed by a BSD-style
# license that can be found in the LICENSE.TXT file.
import sys
import os
import time
import selenium.common.exceptions
from selenium.common.exceptions import NoAlertPresentException
import framework... | [
"framework.Exploit.__init__",
"time.sleep"
] | [((932, 973), 'framework.Exploit.__init__', 'framework.Exploit.__init__', (['self', 'visible'], {}), '(self, visible)\n', (958, 973), False, 'import framework\n'), ((1610, 1624), 'time.sleep', 'time.sleep', (['(10)'], {}), '(10)\n', (1620, 1624), False, 'import time\n'), ((1558, 1571), 'time.sleep', 'time.sleep', (['(1... |
from office365.entity import Entity
from office365.entity_collection import EntityCollection
from office365.planner.plans.plan import PlannerPlan
from office365.planner.tasks.task import PlannerTask
from office365.runtime.paths.resource_path import ResourcePath
class PlannerUser(Entity):
"""The plannerUser resour... | [
"office365.runtime.paths.resource_path.ResourcePath"
] | [((750, 791), 'office365.runtime.paths.resource_path.ResourcePath', 'ResourcePath', (['"""plans"""', 'self.resource_path'], {}), "('plans', self.resource_path)\n", (762, 791), False, 'from office365.runtime.paths.resource_path import ResourcePath\n'), ((1124, 1165), 'office365.runtime.paths.resource_path.ResourcePath',... |
##########################################################################
#
# Copyright (c) 2015, Image Engine Design Inc. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# * Redistrib... | [
"GafferUI.PlugValueWidget.__init__",
"GafferUI.ListContainer",
"GafferUI.PlugLayout",
"GafferScene.Instancer.ContextVariablePlug",
"GafferUI.PlugValueWidget.setPlugs",
"imath.V2i",
"Gaffer.WeakMethod",
"inspect.cleandoc",
"GafferUI.Label",
"GafferUI.ListContainer.__init__",
"GafferUI.BusyWidget"... | [((5338, 5447), 'GafferUI.PlugValueWidget.registerType', 'GafferUI.PlugValueWidget.registerType', (['GafferScene.Instancer.ContextVariablePlug', '_ContextVariableWidget'], {}), '(GafferScene.Instancer.\n ContextVariablePlug, _ContextVariableWidget)\n', (5375, 5447), False, 'import GafferUI\n'), ((7751, 7772), 'Gaffe... |
import functools
import hashlib
import hmac
import json
import jsonschema
import requests
import uuid
from girder import events
from girder.exceptions import ValidationException
from girder.models.setting import Setting
from girder.plugin import GirderPlugin
from girder.api.rest import getApiUrl
from girder.utility imp... | [
"requests.post",
"girder.models.setting.Setting",
"uuid.uuid4",
"girder.exceptions.ValidationException",
"jsonschema.validate",
"functools.partial",
"girder.utility.setting_utilities.validator",
"girder.api.rest.getApiUrl"
] | [((755, 790), 'girder.utility.setting_utilities.validator', 'setting_utilities.validator', (['_HOOKS'], {}), '(_HOOKS)\n', (782, 790), False, 'from girder.utility import setting_utilities, JsonEncoder\n'), ((1495, 1549), 'requests.post', 'requests.post', (["hook['url']"], {'data': 'body', 'headers': 'headers'}), "(hook... |
import pandas as pd
import os
import re
import numpy as np
from datetime import datetime
from sklearn.decomposition import PCA
# Plotting Packages
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
import matplotlib.cbook as cbook
import numpy as np
from mpl_toolkits.axes_grid1.inset_locator import inse... | [
"datetime.datetime",
"numpy.mean",
"matplotlib.pyplot.savefig",
"pandas.read_csv",
"matplotlib.dates.MonthLocator",
"sklearn.decomposition.PCA",
"mpl_toolkits.axes_grid1.inset_locator.inset_axes",
"matplotlib.dates.DateFormatter",
"numpy.std",
"numpy.arange",
"numpy.datetime64",
"pandas.DataFr... | [((1111, 1177), 'pandas.read_csv', 'pd.read_csv', (['"""Data\\\\RegRelevant_MonthlySentimentIndex_Jan2021.csv"""'], {}), "('Data\\\\RegRelevant_MonthlySentimentIndex_Jan2021.csv')\n", (1122, 1177), True, 'import pandas as pd\n'), ((1848, 1867), 'sklearn.decomposition.PCA', 'PCA', ([], {'n_components': '(2)'}), '(n_comp... |
import time
import math
class Timer:
timers = []
def __init__(self, name):
print (name + " (done)")
Timer.timers.append((name, time.time()))
def print_timings(self):
timers = Timer.timers
print ("{0} : {1} ".format("Start time", timers[0][1]))
for idx in range(1,... | [
"time.time"
] | [((743, 754), 'time.time', 'time.time', ([], {}), '()\n', (752, 754), False, 'import time\n'), ((153, 164), 'time.time', 'time.time', ([], {}), '()\n', (162, 164), False, 'import time\n')] |
import unittest
import numpy as np
import torch
from torch.autograd import Variable
import torch.nn
from pyoptmat import models, flowrules, utility, hardening, damage
from pyoptmat.temperature import ConstantParameter as CP
torch.set_default_dtype(torch.float64)
class CommonModel:
def test_derivs_strain(self)... | [
"numpy.allclose",
"pyoptmat.models.StrainBasedModel",
"torch.set_default_dtype",
"pyoptmat.models.StressBasedModel",
"torch.tensor",
"numpy.linspace",
"pyoptmat.utility.CheaterBatchTimeSeriesInterpolator",
"torch.zeros_like",
"torch.isnan",
"torch.zeros",
"pyoptmat.temperature.ConstantParameter"... | [((228, 266), 'torch.set_default_dtype', 'torch.set_default_dtype', (['torch.float64'], {}), '(torch.float64)\n', (251, 266), False, 'import torch\n'), ((640, 708), 'pyoptmat.utility.CheaterBatchTimeSeriesInterpolator', 'utility.CheaterBatchTimeSeriesInterpolator', (['self.times', 'strain_rates'], {}), '(self.times, st... |
"""
the code is adapted from:
https://github.com/ibab/tensorflow-wavenet/blob/master/wavenet/model.py (base model)
https://github.com/twidddj/vqvae/blob/master/wavenet/model.py
"""
import numpy as np
import tensorflow as tf
from .ops import causal_conv, mu_law_encode
from .mixture import discretized_mix_logistic_loss... | [
"tensorflow.shape",
"tensorflow.get_variable",
"tensorflow.scatter_update",
"tensorflow.tanh",
"tensorflow.nn.conv1d",
"tensorflow.reduce_mean",
"tensorflow.cast",
"tensorflow.slice",
"tensorflow.nn.embedding_lookup",
"tensorflow.histogram_summary",
"tensorflow.matmul",
"tensorflow.nn.softmax_... | [((569, 607), 'tensorflow.contrib.layers.xavier_initializer', 'tf.contrib.layers.xavier_initializer', ([], {}), '()\n', (605, 607), True, 'import tensorflow as tf\n'), ((623, 676), 'tensorflow.get_variable', 'tf.get_variable', (['name', 'shape'], {'initializer': 'initializer'}), '(name, shape, initializer=initializer)\... |
#!/usr/bin/env python
from setuptools import setup, find_packages
import sys
# quick hack, will probably do something better later.
requirements = [
"configobj",
"byteplay==0.2",
"ducktypes>0.2.0, <0.3.0dev"
]
if sys.version_info[1] < 7:
requirements.append("importlib")
setup(name=... | [
"setuptools.find_packages"
] | [((709, 724), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (722, 724), False, 'from setuptools import setup, find_packages\n')] |
from django.contrib import messages
from django.contrib.auth.decorators import login_required
from django.contrib.auth.models import User
from django.http import HttpResponse
from django.shortcuts import get_object_or_404, redirect, render
from django.utils.dateparse import parse_date
from applications.academ... | [
"django.http.HttpResponse",
"django.shortcuts.get_object_or_404",
"django.shortcuts.redirect",
"django.contrib.messages.success",
"django.core.serializers.serialize"
] | [((3599, 3621), 'django.shortcuts.redirect', 'redirect', (['"""/gymkhana/"""'], {}), "('/gymkhana/')\n", (3607, 3621), False, 'from django.shortcuts import get_object_or_404, redirect, render\n'), ((4384, 4406), 'django.shortcuts.redirect', 'redirect', (['"""/gymkhana/"""'], {}), "('/gymkhana/')\n", (4392, 4406), False... |
# VERSION: 0.02
# AUTHORS: nindogo (<EMAIL>)
# LICENSING INFORMATION
import re
import time
import threading
try:
# Python 3
from html.parser import HTMLParser
except ImportError:
# Python 2
from HTMLParser import HTMLParser
from helpers import retrieve_url
from novaprinter import prettyPrinter
clas... | [
"novaprinter.prettyPrinter",
"time.sleep",
"threading.Thread",
"re.findall",
"helpers.retrieve_url"
] | [((2911, 2928), 'helpers.retrieve_url', 'retrieve_url', (['url'], {}), '(url)\n', (2923, 2928), False, 'from helpers import retrieve_url\n'), ((3257, 3281), 'helpers.retrieve_url', 'retrieve_url', (['search_url'], {}), '(search_url)\n', (3269, 3281), False, 'from helpers import retrieve_url\n'), ((3654, 3711), 'threadi... |
from collections import namedtuple
from enum import Enum
constants = [
"STATES", "STATE_LABELS", "ACTIONS", "REWARDS", "QS", "NEXT_STATES", "NEXT_STATE_LABELS",
"COMMAND", "NUM_EXP", "TIMESTAMP", "INPUT_SIZE", "NEURONS", "USE_BATCH_NORM", "USE_LAYER_NORM",
"ACTIVATION_LAST", "NUM_COMPONENTS", "NUM_ACTIONS... | [
"enum.Enum"
] | [((3379, 3423), 'enum.Enum', 'Enum', (['"""Constants"""', '{c: c for c in constants}'], {}), "('Constants', {c: c for c in constants})\n", (3383, 3423), False, 'from enum import Enum\n')] |
"""
Good place to read about packaging:
https://python-packaging-user-guide.readthedocs.org/en/latest/distributing.html
"""
from setuptools import setup, find_packages
setup(name='ODIN',
version='1.0',
packages=find_packages(),
install_requires=['numpy==1.11.1']
) | [
"setuptools.find_packages"
] | [((225, 240), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (238, 240), False, 'from setuptools import setup, find_packages\n')] |
##########################################################################
# Autor: WizIO 2021 <NAME>
# http://www.wizio.eu/
# https://github.com/Wiz-IO/wizio-gsm
#
# Support: Comet Electronics
# https://www.comet.bg/en
##########################################################################
from os... | [
"SCons.Script.AlwaysBuild",
"click.style",
"os.path.join",
"SCons.Script.Default",
"SCons.Script.DefaultEnvironment"
] | [((488, 508), 'SCons.Script.DefaultEnvironment', 'DefaultEnvironment', ([], {}), '()\n', (506, 508), False, 'from SCons.Script import AlwaysBuild, Builder, COMMAND_LINE_TARGETS, Default, DefaultEnvironment\n'), ((808, 824), 'SCons.Script.AlwaysBuild', 'AlwaysBuild', (['src'], {}), '(src)\n', (819, 824), False, 'from SC... |
from django.contrib import admin
from .models import Project
# Register your models here.
#mostrar los campos que son solo de lectura en admin al crear un proyecto
class ProjectAdmin(admin.ModelAdmin):
readonly_fields = ("created", "updated")
admin.site.register(Project, ProjectAdmin) | [
"django.contrib.admin.site.register"
] | [((259, 301), 'django.contrib.admin.site.register', 'admin.site.register', (['Project', 'ProjectAdmin'], {}), '(Project, ProjectAdmin)\n', (278, 301), False, 'from django.contrib import admin\n')] |
"""
This module contains the structs necessary to represent an automata.
"""
from __future__ import annotations
import logging
from typing import Any, Dict, Iterable, List, Set, Tuple, Union
from numlab.automata.state import State
from numlab.automata.transition import Transition
_ATMT_COUNT = 0
class Automata:
... | [
"numlab.automata.transition.Transition",
"numlab.automata.state.State",
"logging.debug"
] | [((6717, 6777), 'numlab.automata.transition.Transition', 'Transition', (['from_state', 'to_state', 'condition', 'action', 'negated'], {}), '(from_state, to_state, condition, action, negated)\n', (6727, 6777), False, 'from numlab.automata.transition import Transition\n'), ((17466, 17529), 'logging.debug', 'logging.debug... |
# Generated by Django 2.2.4 on 2019-09-26 05:47
import django.db.models.deletion
from django.db import migrations, models
class Migration(migrations.Migration):
initial = True
dependencies = [("account", "0033_serviceaccount")]
operations = [
migrations.CreateModel(
name="Webhook",... | [
"django.db.models.ForeignKey",
"django.db.models.BooleanField",
"django.db.models.AutoField",
"django.db.models.URLField",
"django.db.models.CharField"
] | [((406, 499), 'django.db.models.AutoField', 'models.AutoField', ([], {'auto_created': '(True)', 'primary_key': '(True)', 'serialize': '(False)', 'verbose_name': '"""ID"""'}), "(auto_created=True, primary_key=True, serialize=False,\n verbose_name='ID')\n", (422, 499), False, 'from django.db import migrations, models\... |
# #####################################################################################################################
# Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. #
# ... | [
"re.match",
"aws_solutions.cdk.aws_lambda.cfn_custom_resources.resource_name.src.custom_resources.name.get_property",
"pytest.raises",
"pytest.fixture",
"aws_solutions.cdk.aws_lambda.cfn_custom_resources.resource_name.src.custom_resources.name.generate_name"
] | [((1626, 1642), 'pytest.fixture', 'pytest.fixture', ([], {}), '()\n', (1640, 1642), False, 'import pytest\n'), ((1916, 1949), 'aws_solutions.cdk.aws_lambda.cfn_custom_resources.resource_name.src.custom_resources.name.generate_name', 'generate_name', (['lambda_event', 'None'], {}), '(lambda_event, None)\n', (1929, 1949)... |
# -*- coding: utf-8 -*-
"""
Created on Fri Aug 16 14:50:14 2018
@author: Kaushik
"""
'''
# Known symmatric distances
locations = ["New York", "Los Angeles", "Chicago", "Minneapolis", "Denver", "Dallas", "Seattle",
"Boston", "San Francisco", "St. Louis", "Houston", "Phoenix", "Salt Lake City"]
dist_ma... | [
"ortools.constraint_solver.pywrapcp.RoutingModel.DefaultSearchParameters",
"numpy.sqrt",
"ortools.constraint_solver.pywrapcp.RoutingModel"
] | [((5085, 5125), 'numpy.sqrt', 'np.sqrt', (['((x1 - x2) ** 2 + (y1 - y2) ** 2)'], {}), '((x1 - x2) ** 2 + (y1 - y2) ** 2)\n', (5092, 5125), True, 'import numpy as np\n'), ((6160, 6207), 'ortools.constraint_solver.pywrapcp.RoutingModel.DefaultSearchParameters', 'pywrapcp.RoutingModel.DefaultSearchParameters', ([], {}), '... |
import os
from dvc.cli import main
from tests.basic_env import TestDvc
class TestUnprotect(TestDvc):
def test(self):
ret = main(["config", "cache.type", "hardlink"])
self.assertEqual(ret, 0)
ret = main(["add", self.FOO])
self.assertEqual(ret, 0)
cache = os.path.join(
... | [
"dvc.cli.main",
"os.access",
"os.path.join"
] | [((138, 180), 'dvc.cli.main', 'main', (["['config', 'cache.type', 'hardlink']"], {}), "(['config', 'cache.type', 'hardlink'])\n", (142, 180), False, 'from dvc.cli import main\n'), ((229, 252), 'dvc.cli.main', 'main', (["['add', self.FOO]"], {}), "(['add', self.FOO])\n", (233, 252), False, 'from dvc.cli import main\n'),... |
# Copyright 2021-2022 NVIDIA Corporation
#
# 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 ... | [
"numpy.array",
"numpy.array_equal",
"numpy.vstack",
"cunumeric.vstack",
"cunumeric.array"
] | [((656, 676), 'cunumeric.array', 'num.array', (['[1, 2, 3]'], {}), '([1, 2, 3])\n', (665, 676), True, 'import cunumeric as num\n'), ((685, 705), 'cunumeric.array', 'num.array', (['[4, 5, 6]'], {}), '([4, 5, 6])\n', (694, 705), True, 'import cunumeric as num\n'), ((714, 732), 'cunumeric.vstack', 'num.vstack', (['(x, y)'... |
from deidentify.surrogates.generators import AgeSurrogates
def test_replace_one():
annotations = [
'88 jarige',
'24/25e',
'2',
'60',
'patient is 92',
'91 age',
'90 jaar oud',
'89 years',
'101'
]
age_surrogates = AgeSurrogates(annotati... | [
"deidentify.surrogates.generators.AgeSurrogates"
] | [((298, 336), 'deidentify.surrogates.generators.AgeSurrogates', 'AgeSurrogates', ([], {'annotations': 'annotations'}), '(annotations=annotations)\n', (311, 336), False, 'from deidentify.surrogates.generators import AgeSurrogates\n')] |
# Copyright 2018 <NAME>
# SPDX-License-Identiter: MIT
import imaplib
import contextlib
import re
from lib.mail import Mail
from lib import gpgmessage
from lib.consolecolor import color, COLOR
# imap session context
@contextlib.contextmanager
def session(server, username, password):
with imaplib.IMAP4_SSL(server) ... | [
"lib.gpgmessage.repack",
"lib.mail.Mail",
"lib.consolecolor.color",
"imaplib.IMAP4_SSL"
] | [((294, 319), 'imaplib.IMAP4_SSL', 'imaplib.IMAP4_SSL', (['server'], {}), '(server)\n', (311, 319), False, 'import imaplib\n'), ((2047, 2134), 'lib.gpgmessage.repack', 'gpgmessage.repack', (['gpg', 'payload', 'delkeys', 'addkeys', 'del_all_keys', 'only', 'always_trust'], {}), '(gpg, payload, delkeys, addkeys, del_all_k... |
import abc
from lbann import optimizers_pb2
import lbann.core.util
class Optimizer(abc.ABC):
"""Optimization algorithm for a neural network's parameters."""
def export_proto(self):
"""Construct and return a protobuf message."""
return optimizers_pb2.Optimizer()
# Generate Optimizer sub-classes... | [
"lbann.optimizers_pb2.Optimizer"
] | [((260, 286), 'lbann.optimizers_pb2.Optimizer', 'optimizers_pb2.Optimizer', ([], {}), '()\n', (284, 286), False, 'from lbann import optimizers_pb2\n')] |
import os
import re
import itertools
import bs4
from bs4 import BeautifulSoup, NavigableString
from typing import List, Dict, Tuple, Optional
import copy
import latex2mathml.converter
from doc2json.grobid2json.grobid.grobid_client import GrobidClient
from doc2json.utils.grobid_util import parse_bib_entry, get_author_d... | [
"os.path.exists",
"doc2json.s2orc.Paper",
"doc2json.utils.grobid_util.parse_bib_entry",
"os.path.join",
"re.match",
"os.path.splitext",
"bs4.BeautifulSoup",
"doc2json.s2orc.Paragraph",
"doc2json.grobid2json.grobid.grobid_client.GrobidClient",
"re.finditer",
"doc2json.utils.grobid_util.get_author... | [((7056, 7083), 're.sub', 're.sub', (['"""\\\\s+"""', '""" """', 'str_el'], {}), "('\\\\s+', ' ', str_el)\n", (7062, 7083), False, 'import re\n'), ((7095, 7119), 're.sub', 're.sub', (['"""\\\\s"""', '""" """', 'text'], {}), "('\\\\s', ' ', text)\n", (7101, 7119), False, 'import re\n'), ((7186, 7219), 're.finditer', 're... |
import numpy as np
from sklearn.metrics import roc_auc_score
def compute_auc(y_true, y_pred):
try:
return roc_auc_score(y_true, y_pred)
except ValueError:
return np.nan
def compute_subgroup_auc(df, subgroup, label, model_name):
subgroup_examples = df[df[subgroup]]
return compute_auc(... | [
"sklearn.metrics.roc_auc_score"
] | [((120, 149), 'sklearn.metrics.roc_auc_score', 'roc_auc_score', (['y_true', 'y_pred'], {}), '(y_true, y_pred)\n', (133, 149), False, 'from sklearn.metrics import roc_auc_score\n')] |
from plotly.basedatatypes import BaseTraceHierarchyType as _BaseTraceHierarchyType
import copy as _copy
class Title(_BaseTraceHierarchyType):
# align
# -----
@property
def align(self):
"""
Sets the horizontal alignment of the title. It defaults to
`center` except for bullet ch... | [
"plotly.validators.indicator.gauge.BgcolorValidator",
"plotly.validators.indicator.domain.ColumnValidator",
"plotly.validators.indicator.delta.PositionValidator",
"plotly.validators.indicator.title.TextValidator",
"plotly.validators.indicator.title.AlignValidator",
"plotly.validators.indicator.domain.YVal... | [((4929, 4953), 'plotly.validators.indicator.title.AlignValidator', 'v_title.AlignValidator', ([], {}), '()\n', (4951, 4953), True, 'from plotly.validators.indicator import title as v_title\n'), ((4989, 5012), 'plotly.validators.indicator.title.FontValidator', 'v_title.FontValidator', ([], {}), '()\n', (5010, 5012), Tr... |
# -*- coding: utf-8 -*-
"""
# @file name : camvid_train.py
# @author : JLChen
# @date : 2021-05
# @brief : 模型训练主代码
"""
import matplotlib
# matplotlib.use('agg')
import os
import sys
BASE_DIR = os.path.dirname(os.path.abspath(__file__))
print("BASE_DIR:{}".format(BASE_DIR))
sys.path.append(os.path.join(B... | [
"matplotlib.pyplot.hist",
"datasets.camvid_dataset.CamvidDataset",
"argparse.ArgumentParser",
"torch.optim.lr_scheduler.MultiStepLR",
"tools.model_trainer.ModelTrainer.train",
"matplotlib.pyplot.savefig",
"models.segnet.SegResNet",
"torch.nn.CrossEntropyLoss",
"os.path.join",
"torch.nn.DataParalle... | [((925, 972), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Training"""'}), "(description='Training')\n", (948, 972), False, 'import argparse\n'), ((225, 250), 'os.path.abspath', 'os.path.abspath', (['__file__'], {}), '(__file__)\n', (240, 250), False, 'import os\n'), ((306, 334), 'os.p... |
import sys
print(1)
sys.exit(0)
print(2)
| [
"sys.exit"
] | [((21, 32), 'sys.exit', 'sys.exit', (['(0)'], {}), '(0)\n', (29, 32), False, 'import sys\n')] |
# -*- coding: utf-8 -*-
import os
import tempfile
import shutil
import subprocess
import itertools
import sys
from .helpers import sh
from . import Task
try:
import cPickle as pickle
except ImportError:
import pickle
try:
from StringIO import StringIO
except ImportError:
from io import StringIO
... | [
"matplotlib.pyplot.ylabel",
"numpy.polyfit",
"matplotlib.table.Table",
"numpy.array",
"matplotlib.cm.tab10",
"sys.exit",
"numpy.poly1d",
"matplotlib.pyplot.subplot2grid",
"os.remove",
"matplotlib.pyplot.imshow",
"re.split",
"os.listdir",
"matplotlib.cm.tab20c",
"matplotlib.ticker.FuncForma... | [((5670, 5703), 'os.path.splitext', 'os.path.splitext', (['self.targets[0]'], {}), '(self.targets[0])\n', (5686, 5703), False, 'import os\n'), ((8888, 8899), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (8897, 8899), False, 'import os\n'), ((8908, 8932), 'os.chdir', 'os.chdir', (['temp_directory'], {}), '(temp_directory... |
import os
import time
import z3
from z3 import Optimize, And, Or, Implies, Bool, Int
from copy import copy
def solve_sat(data, timeuout=60*5, rotation=False):
plate_width, circuits = data
circuits_num = len(circuits)
w, h = ([ i for i, _ in circuits ], [ j for _, j in circuits ])
max_y = z3.Int('max_... | [
"lib.utils.load_instance",
"z3.And",
"z3.Bool",
"os.listdir",
"lib.utils.write_solution",
"os.path.join",
"z3.Or",
"z3.Optimize",
"os.path.basename",
"time.time",
"os.path.abspath",
"sys.path.append",
"z3.Int"
] | [((308, 323), 'z3.Int', 'z3.Int', (['"""max_y"""'], {}), "('max_y')\n", (314, 323), False, 'import z3\n'), ((456, 466), 'z3.Optimize', 'Optimize', ([], {}), '()\n', (464, 466), False, 'from z3 import Optimize, And, Or, Implies, Bool, Int\n'), ((1731, 1744), 'z3.Optimize', 'z3.Optimize', ([], {}), '()\n', (1742, 1744), ... |
from neo4j import GraphDatabase
import spacy
import re
from spacy import displacy
import networkx as nx
# def NER(text,link):
# nlp = spacy.load("en_core_web_sm")
# doc = nlp(text)
# driver = GraphDatabase.driver(link,auth=("neo4j","password"))
# def addEntity(tx,entity1,entity2):
# tx.run("M... | [
"spacy.load",
"spacy.explain"
] | [((1000, 1028), 'spacy.load', 'spacy.load', (['"""en_core_web_sm"""'], {}), "('en_core_web_sm')\n", (1010, 1028), False, 'import spacy\n'), ((1947, 1966), 'spacy.explain', 'spacy.explain', (['prev'], {}), '(prev)\n', (1960, 1966), False, 'import spacy\n'), ((1991, 2010), 'spacy.explain', 'spacy.explain', (['prev'], {})... |
import numpy as np
from collections import defaultdict
import matplotlib.pyplot as plt
import matplotlib.animation as animations
import pickle
import random
import math
from celluloid import Camera
class World():
def __init__(self,x,y,o):
self.l=10
self.x=x
self.y=y
self.o=o
self.orad=self.o*3.1... | [
"math.cos",
"math.sin",
"math.tan"
] | [((904, 923), 'math.tan', 'math.tan', (['self.orad'], {}), '(self.orad)\n', (912, 923), False, 'import math\n'), ((1124, 1143), 'math.tan', 'math.tan', (['self.orad'], {}), '(self.orad)\n', (1132, 1143), False, 'import math\n'), ((1623, 1642), 'math.tan', 'math.tan', (['self.orad'], {}), '(self.orad)\n', (1631, 1642), ... |
#!/usr/bin/env python3
""" Bootloader for AVR-Boards connected via CAN bus
Format:
11-Bit Identifier
1. Board Identifier
2. Message Type
3. Message Number
4. Message Data Counter
5.-8. Data
"""
import time
import math
import Queue
import threading
import can
import message_filter as filter
from util import inte... | [
"util.intelhex.IntelHexParser",
"util.progressbar.ProgressBar",
"can.Message",
"optparse.OptionParser",
"time.sleep",
"threading.Event",
"time.time",
"Queue.Queue"
] | [((15013, 15116), 'optparse.OptionParser', 'OptionParser', ([], {'usage': '"""%prog [options] -i BOARD_ID -f FILE"""', 'version': "('%prog version: ' + __version__)"}), "(usage='%prog [options] -i BOARD_ID -f FILE', version=\n '%prog version: ' + __version__)\n", (15025, 15116), False, 'from optparse import OptionPa... |
######################################################################################################################
# Copyright 2020-2021 Amazon.com, Inc. or its affiliates. All Rights Reserved. #
# ... | [
"aws_cdk.aws_iam.PolicyStatement.from_json",
"os.path.split"
] | [((1778, 1818), 'os.path.split', 'os.path.split', (["os.environ['VIRTUAL_ENV']"], {}), "(os.environ['VIRTUAL_ENV'])\n", (1791, 1818), False, 'import os\n'), ((2621, 2658), 'aws_cdk.aws_iam.PolicyStatement.from_json', 'iam.PolicyStatement.from_json', (['statmt'], {}), '(statmt)\n', (2650, 2658), True, 'from aws_cdk impo... |
# -*- coding:utf-8 -*-
import argparse
import elasticsearch
from elasticsearch.exceptions import TransportError
import json
from similarity.get_score import GetScore
from similarity.build_index import IndexData
def parse_args():
parser = argparse.ArgumentParser(
description='remove similarity score that ... | [
"similarity.build_index.IndexData.index_data",
"argparse.ArgumentParser",
"elasticsearch.Elasticsearch",
"json.dumps",
"similarity.get_score.GetScore.get_similarity"
] | [((245, 343), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""remove similarity score that below a certain valueData"""'}), "(description=\n 'remove similarity score that below a certain valueData')\n", (268, 343), False, 'import argparse\n'), ((1603, 1672), 'similarity.build_index.Ind... |
import soundset
# create random score for C3~C5note == 130.8~523.3hz
#-> score object
s1 = soundset.score.random(length=32,tempo=120,beat=16,chord=3,pitch=3,register=25,random_state=None)
# create score piano roll
#-> 2-dim binaly numpy array, size of (length, 128)
roll = s1.to_roll(ignore_out_of_range=False)
assert... | [
"soundset.score.random"
] | [((93, 199), 'soundset.score.random', 'soundset.score.random', ([], {'length': '(32)', 'tempo': '(120)', 'beat': '(16)', 'chord': '(3)', 'pitch': '(3)', 'register': '(25)', 'random_state': 'None'}), '(length=32, tempo=120, beat=16, chord=3, pitch=3,\n register=25, random_state=None)\n', (114, 199), False, 'import so... |
# Copyright 2015 Internap.
#
# 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, so... | [
"hamcrest.has_length",
"hamcrest.is_",
"hamcrest.none",
"netaddr.IPAddress",
"tests.adapters.configured_test_case.skip_on_switches",
"hamcrest.assert_that",
"hamcrest.equal_to",
"netaddr.IPNetwork"
] | [((1106, 1225), 'tests.adapters.configured_test_case.skip_on_switches', 'skip_on_switches', (['"""juniper"""', '"""juniper_qfx_copper"""', '"""dell"""', '"""dell_telnet"""', '"""dell10g"""', '"""dell10g_telnet"""', '"""juniper_mx"""'], {}), "('juniper', 'juniper_qfx_copper', 'dell', 'dell_telnet',\n 'dell10g', 'dell... |
"""
hyperparams.py
====================================
It provides configuration for the tunable hyper-parameter ranges for all the algorithms.
"""
from argparse import ArgumentParser
from hyperopt import hp
from hyperopt.pyll.base import scope
import numpy as np
class HyperparamterLoader:
def __init__(self):
... | [
"hyperopt.hp.choice",
"numpy.log",
"hyperopt.hp.uniform",
"argparse.ArgumentParser"
] | [((4484, 4556), 'argparse.ArgumentParser', 'ArgumentParser', ([], {'description': '"""Knowledge Graph Embedding tunable configs."""'}), "(description='Knowledge Graph Embedding tunable configs.')\n", (4498, 4556), False, 'from argparse import ArgumentParser\n'), ((6437, 6472), 'hyperopt.hp.choice', 'hp.choice', (['"""L... |
import atexit
import collections
import datetime
import glob
import logging
import os
import signal
import threading
import time
from enum import Enum
from subprocess import Popen, PIPE
import requests
from mcadmin.config import CONFIG
from mcadmin.io.files.server_list import SERVER_LIST
_EULA_TXT = 'eula.txt'
_LOGG... | [
"logging.getLogger",
"time.sleep",
"mcadmin.io.files.server_list.SERVER_LIST.versions",
"os.path.exists",
"collections.deque",
"mcadmin.config.CONFIG.get_use_jar",
"mcadmin.io.files.server_list.SERVER_LIST.latest_stable_version",
"subprocess.Popen",
"threading.RLock",
"os.mkdir",
"threading.Cond... | [((325, 352), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (342, 352), False, 'import logging\n'), ((13819, 13859), 'atexit.register', 'atexit.register', (['SERVER._on_program_exit'], {}), '(SERVER._on_program_exit)\n', (13834, 13859), False, 'import atexit\n'), ((13613, 13640), 'os.pat... |
import sys
import pytoulbar2
Lines = open(sys.argv[1], 'r').readlines()
N = len(Lines)
Matrix = [[int(e) for e in l.split(' ')] for l in Lines]
Top = 1 + N*N
K = int(sys.argv[2])
Var = [(chr(65 + i) if N < 28 else "x" + str(i)) for i in range(N)] # Political actor or any instance
# Var = ["ron","tom","frank","boy... | [
"pytoulbar2.CFN"
] | [((786, 805), 'pytoulbar2.CFN', 'pytoulbar2.CFN', (['Top'], {}), '(Top)\n', (800, 805), False, 'import pytoulbar2\n')] |
"""
algorithms
Created by: <NAME>
On: 1/26/20, 5:43 PM
"""
from abc import ABC
import torch
import pandas as pd
from drugex.api.agent.agents import DrugExAgent as DrugExAgentTrainer
from drugex.api.agent.policy import PG
from drugex.api.corpus import Corpus, DataProvidingCorpus
from drugex.api.environ.models import ... | [
"drugex.api.pretrain.generators.BasicGenerator",
"drugex.api.agent.policy.PG",
"genui.models.models.ModelFileFormat.objects.get_or_create",
"torch.cuda.is_available",
"genui.qsar.genuimodels.bases.QSARModelBuilder",
"torch.save",
"torch.cuda.current_device",
"torch.device"
] | [((1015, 1127), 'drugex.api.pretrain.generators.BasicGenerator', 'BasicGenerator', ([], {'monitor': 'self.monitor', 'initial_state': 'self', 'corpus': 'self.corpus', 'train_params': 'self.train_params'}), '(monitor=self.monitor, initial_state=self, corpus=self.corpus,\n train_params=self.train_params)\n', (1029, 112... |
# python peripherals
import random
import os
import sys
import math
sys.path.insert(1, os.path.join(sys.path[0], '../..'))
# numpy
import numpy
# pandas
import pandas
# ipython
from IPython.display import display, HTML
# matplotlib
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
import matplotlib... | [
"common.utils.get_latest_subdirectory",
"numpy.random.shuffle",
"notebooks.utils.utils.plot_curve_signature_comparisons",
"deep_signature.nn.networks.DeepSignatureArcLengthNet",
"deep_signature.data_generation.curve_generation.LevelCurvesGenerator.load_curves",
"torch.load",
"notebooks.utils.utils.plot_... | [((3022, 3055), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (3045, 3055), False, 'import warnings\n'), ((3553, 3573), 'torch.device', 'torch.device', (['"""cuda"""'], {}), "('cuda')\n", (3565, 3573), False, 'import torch\n'), ((3763, 3801), 'torch.set_default_dtype', 't... |
##import all packages needed
import RPi.GPIO as GPIO
import time
LedPin = 17
def setup():
# Set the GPIO modes to BCM Numbering
GPIO.setmode(GPIO.BCM)
# Set LedPin's mode to output,and initial level to High(3.3v)
GPIO.setup(LedPin, GPIO.OUT, initial=GPIO.HIGH)
# Define a main function for main... | [
"RPi.GPIO.cleanup",
"RPi.GPIO.setup",
"RPi.GPIO.output",
"time.sleep",
"RPi.GPIO.setmode"
] | [((143, 165), 'RPi.GPIO.setmode', 'GPIO.setmode', (['GPIO.BCM'], {}), '(GPIO.BCM)\n', (155, 165), True, 'import RPi.GPIO as GPIO\n'), ((238, 285), 'RPi.GPIO.setup', 'GPIO.setup', (['LedPin', 'GPIO.OUT'], {'initial': 'GPIO.HIGH'}), '(LedPin, GPIO.OUT, initial=GPIO.HIGH)\n', (248, 285), True, 'import RPi.GPIO as GPIO\n')... |
"""Test-Enviroment for finance_collector.py"""
import pandas as pd
from ai2business.kpi_collector import finance_collector as fnc
ticker = fnc.FinanceCollector()
builder = fnc.DesignerFinanceCollector(["SPY", "AAPL", "MSFT"])
ticker.builder = builder
def test_find_chart_history():
ticker.find_chart_histogram()
... | [
"pandas.DataFrame",
"ai2business.kpi_collector.finance_collector.FinanceCollector",
"ai2business.kpi_collector.finance_collector.DesignerFinanceCollector"
] | [((141, 163), 'ai2business.kpi_collector.finance_collector.FinanceCollector', 'fnc.FinanceCollector', ([], {}), '()\n', (161, 163), True, 'from ai2business.kpi_collector import finance_collector as fnc\n'), ((174, 227), 'ai2business.kpi_collector.finance_collector.DesignerFinanceCollector', 'fnc.DesignerFinanceCollecto... |
from datetime import datetime
import requests
import pandas as pd
import os
date = datetime.strptime("1-5-2020", "%d-%m-%Y")
print(datetime.fromtimestamp(1451442397))
print(datetime.timestamp(date))
# r = requests.get("https://api.opendota.com/api/proMatches")
# print(len(r.json()))
| [
"datetime.datetime.strptime",
"datetime.datetime.fromtimestamp",
"datetime.datetime.timestamp"
] | [((85, 126), 'datetime.datetime.strptime', 'datetime.strptime', (['"""1-5-2020"""', '"""%d-%m-%Y"""'], {}), "('1-5-2020', '%d-%m-%Y')\n", (102, 126), False, 'from datetime import datetime\n'), ((133, 167), 'datetime.datetime.fromtimestamp', 'datetime.fromtimestamp', (['(1451442397)'], {}), '(1451442397)\n', (155, 167),... |
import os
import pandas as pd
from github import Github
github = Github(os.environ["GITHUB_TOKEN"])
repo = github.get_repo("bioconda/bioconda-recipes")
prs = []
titles = []
files = []
spans = []
for pr in repo.get_pulls(state="closed"):
print(pr)
if pr.merged:
prs.append(pr.id)
titles.append(... | [
"pandas.DataFrame",
"github.Github"
] | [((66, 100), 'github.Github', 'Github', (["os.environ['GITHUB_TOKEN']"], {}), "(os.environ['GITHUB_TOKEN'])\n", (72, 100), False, 'from github import Github\n'), ((427, 512), 'pandas.DataFrame', 'pd.DataFrame', (["{'id': prs, 'title': titles, 'changed_files': files, 'span': spans}"], {}), "({'id': prs, 'title': titles,... |
import datetime
from os import startfile, system
from pathlib import Path
from random import randint
from sys import exit as sysend
class Functions:
def __init__(self):
self.log_prefix = self.log_dated_names()
self.home_path = Path.home()
self.taskymain_path = self.home_path / "Tasky"
... | [
"pathlib.Path.home",
"datetime.datetime.now",
"sys.exit",
"os.startfile",
"os.system",
"random.randint"
] | [((249, 260), 'pathlib.Path.home', 'Path.home', ([], {}), '()\n', (258, 260), False, 'from pathlib import Path\n'), ((1550, 1573), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (1571, 1573), False, 'import datetime\n'), ((3567, 3580), 'os.system', 'system', (['"""cls"""'], {}), "('cls')\n", (3573,... |
#coding:utf-8
from flask import *
import pymysql
import db,modules
# 返回 is_success, id, message
def Submit(req):
is_public = 1 if req.get('is_public') != None else 0
id = req['id']
if req['id'] != '':
if int(req['id']) <= 0:
flash(r'编号必须为正','error')
return render_template("problemadd.html")
count = int(db... | [
"db.Execute",
"db.Fetchone",
"modules.Current_User_Privilege",
"modules.Page_Back"
] | [((497, 765), 'db.Execute', 'db.Execute', (['"""INSERT INTO problems VALUES(%s,%s,%s,%s,%s,%s,%s,%s,%s,%s);"""', "(req['id'], req['title'], req['description'], req['input_format'], req[\n 'output_format'], req['example'], req['limit_and_hint'], req[\n 'time_limit'], req['memory_limit'], is_public)"], {}), "('INSE... |
# LocalMktdataSubscriptionExample.py
from __future__ import print_function
from __future__ import absolute_import
from optparse import OptionParser, OptionValueError
import os
import platform as plat
import sys
if sys.version_info >= (3, 8) and plat.system().lower() == "windows":
# pylint: disable=no-member
w... | [
"blpapi.TlsOptions.createFromBlobs",
"blpapi.AuthOptions.createWithApp",
"blpapi.SubscriptionList",
"os.getenv",
"blpapi.AuthUser.createWithLogonName",
"blpapi.AuthOptions.createWithUser",
"optparse.OptionParser",
"blpapi.AuthOptions.createWithUserAndApp",
"blpapi.Name",
"blpapi.AuthUser.createWit... | [((444, 478), 'blpapi.Name', 'blpapi.Name', (['"""SubscriptionFailure"""'], {}), "('SubscriptionFailure')\n", (455, 478), False, 'import blpapi\n'), ((505, 542), 'blpapi.Name', 'blpapi.Name', (['"""SubscriptionTerminated"""'], {}), "('SubscriptionTerminated')\n", (516, 542), False, 'import blpapi\n'), ((569, 605), 'blp... |
# 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
# d... | [
"oslo_config.cfg.ConfigOpts",
"oslo_config.fixture.Config",
"karbor.common.karbor_keystone_plugin.KarborKeystonePlugin",
"oslo_config.cfg.CONF.set_default",
"mock.MagicMock"
] | [((876, 892), 'oslo_config.cfg.ConfigOpts', 'cfg.ConfigOpts', ([], {}), '()\n', (890, 892), False, 'from oslo_config import cfg\n'), ((1095, 1154), 'oslo_config.cfg.CONF.set_default', 'cfg.CONF.set_default', (['"""project_name"""', '"""services"""', '"""trustee"""'], {}), "('project_name', 'services', 'trustee')\n", (1... |
# Function to mock numba and let the code work on any system
from warnings import warn
try:
import numba as nb
except ImportError as _:
warn('Numba not found. Your code will be slower.')
class Bunch(dict):
"""Dictionnary-like object that exposes its keys as attributes."""
def __init__(se... | [
"warnings.warn"
] | [((146, 196), 'warnings.warn', 'warn', (['"""Numba not found. Your code will be slower."""'], {}), "('Numba not found. Your code will be slower.')\n", (150, 196), False, 'from warnings import warn\n')] |
from django.shortcuts import render, redirect, get_object_or_404
from django.contrib.auth import login, logout, update_session_auth_hash
from django.contrib.auth.decorators import login_required
from shareandcare.account.forms import *
from django.contrib.auth.models import User
def home_view(request):
return re... | [
"django.shortcuts.render",
"django.contrib.auth.login",
"django.shortcuts.redirect",
"django.contrib.auth.decorators.login_required",
"django.contrib.auth.logout"
] | [((1467, 1508), 'django.contrib.auth.decorators.login_required', 'login_required', ([], {'login_url': '"""account:login"""'}), "(login_url='account:login')\n", (1481, 1508), False, 'from django.contrib.auth.decorators import login_required\n'), ((1647, 1688), 'django.contrib.auth.decorators.login_required', 'login_requ... |
import numpy as np
def random_vec(length):
if type(length) is not int:
raise ValueError("length should be int.")
elif length <= 0:
raise ValueError("length should be a positive number.")
return np.random.rand(length)
def normalize_vec(vector):
return vector / np.linalg.norm(vector... | [
"numpy.random.rand",
"numpy.linalg.norm"
] | [((228, 250), 'numpy.random.rand', 'np.random.rand', (['length'], {}), '(length)\n', (242, 250), True, 'import numpy as np\n'), ((299, 321), 'numpy.linalg.norm', 'np.linalg.norm', (['vector'], {}), '(vector)\n', (313, 321), True, 'import numpy as np\n')] |
# coding=utf-8
# Copyright 2019 The Tensor2Tensor Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable... | [
"tensor2tensor.trax.layers.combinators.Serial",
"absl.testing.absltest.main",
"tensor2tensor.trax.layers.base.check_shape_agreement",
"tensor2tensor.trax.backend.random.get_prng",
"numpy.array",
"numpy.sum",
"tensor2tensor.trax.layers.core.Flatten",
"tensor2tensor.trax.layers.core.Dropout",
"tensor2... | [((3850, 3865), 'absl.testing.absltest.main', 'absltest.main', ([], {}), '()\n', (3863, 3865), False, 'from absl.testing import absltest\n'), ((1097, 1111), 'tensor2tensor.trax.layers.core.Flatten', 'core.Flatten', ([], {}), '()\n', (1109, 1111), False, 'from tensor2tensor.trax.layers import core\n'), ((1176, 1222), 't... |
from setuptools import setup
setup(
name="bizzfuzz",
author="<NAME>",
author_email="<EMAIL>",
)
| [
"setuptools.setup"
] | [((30, 93), 'setuptools.setup', 'setup', ([], {'name': '"""bizzfuzz"""', 'author': '"""<NAME>"""', 'author_email': '"""<EMAIL>"""'}), "(name='bizzfuzz', author='<NAME>', author_email='<EMAIL>')\n", (35, 93), False, 'from setuptools import setup\n')] |
"""Module for start_entries service."""
import logging
from typing import Any, List, Optional
import uuid
from race_service.adapters import StartEntriesAdapter
from race_service.models import StartEntry
from .exceptions import IllegalValueException
def create_id() -> str: # pragma: no cover
"""Creates an uuid."... | [
"race_service.adapters.StartEntriesAdapter.update_start_entry",
"logging.debug",
"race_service.adapters.StartEntriesAdapter.get_start_entries_by_race_id_and_startlist_id",
"race_service.adapters.StartEntriesAdapter.create_start_entry",
"race_service.adapters.StartEntriesAdapter.get_start_entries_by_race_id"... | [((338, 350), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (348, 350), False, 'import uuid\n'), ((2695, 2756), 'logging.debug', 'logging.debug', (['f"""trying to insert start_entry: {start_entry}"""'], {}), "(f'trying to insert start_entry: {start_entry}')\n", (2708, 2756), False, 'import logging\n'), ((3106, 3158), '... |
import pandas as pd
import matplotlib.pyplot as plt
import pylab
def getObs(myfile, name):
obs = pd.read_csv(myfile,
sep=',',
parse_dates=[0]).drop('date_received',1);
obs['value'] = obs['value'].apply(pd.to_numeric, errors='coerce')
obs2 = obs.drop_duplicates('ti... | [
"pandas.read_csv",
"pandas.merge",
"pandas.to_datetime",
"pylab.show"
] | [((2786, 2798), 'pylab.show', 'pylab.show', ([], {}), '()\n', (2796, 2798), False, 'import pylab\n'), ((382, 440), 'pandas.to_datetime', 'pd.to_datetime', (['obs2.index'], {'format': '"""%Y-%m-%dT%H:%M:%S.%fZ"""'}), "(obs2.index, format='%Y-%m-%dT%H:%M:%S.%fZ')\n", (396, 440), True, 'import pandas as pd\n'), ((1016, 10... |
bl_info = {
"name": "New Object",
"author": "YourNameHere",
"version": (1, 0),
"blender": (2, 5, 5),
"api": 33333,
"location": "View3D > Add > Mesh > New Object",
"description": "Adds a new Mesh Object",
"warning": "",
"wiki_url": "",
"tracker_url": "",
"category": "Add Mesh"... | [
"bpy.utils.unregister_class",
"mathutils.Vector",
"bpy.types.INFO_MT_mesh_add.append",
"bpy.types.INFO_MT_mesh_add.remove",
"bpy.data.meshes.new",
"add_utils.add_object_data",
"bpy.props.FloatVectorProperty",
"bpy.utils.register_class"
] | [((830, 873), 'bpy.data.meshes.new', 'bpy.data.meshes.new', ([], {'name': '"""New Object Mesh"""'}), "(name='New Object Mesh')\n", (849, 873), False, 'import bpy\n'), ((1013, 1058), 'add_utils.add_object_data', 'add_object_data', (['context', 'mesh'], {'operator': 'self'}), '(context, mesh, operator=self)\n', (1028, 10... |
# Generated by Django 2.1.2 on 2018-11-13 21:17
import django.db.models.deletion
import i18nfield.fields
from django.db import migrations, models
from prtx_faq.prtx import PRTX
class Migration(migrations.Migration):
initial = True
dependencies = [
(('event', '0017_auto_20180922_0511') if PRTX == 'p... | [
"django.db.models.PositiveIntegerField",
"django.db.models.AutoField",
"django.db.models.CharField",
"django.db.models.ForeignKey"
] | [((1968, 2113), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'on_delete': 'django.db.models.deletion.CASCADE', 'related_name': '"""questions"""', 'to': '"""prtx_faq.FAQCategory"""', 'verbose_name': '"""Category"""'}), "(on_delete=django.db.models.deletion.CASCADE, related_name\n ='questions', to='prtx_f... |
import pytest
from qa327.models import db, User
from werkzeug.security import generate_password_hash, check_password_hash
from qa327.backend import login_user
from qa327.backend import register_user
from qa327.backend import get_user
from qa327.backend import get_ticket
from qa327.backend import add_ticket
def test_lo... | [
"qa327.backend.get_ticket",
"qa327.backend.register_user",
"qa327.backend.add_ticket",
"qa327.backend.login_user",
"qa327.backend.get_user"
] | [((351, 376), 'qa327.backend.get_user', 'get_user', (['"""correct_email"""'], {}), "('correct_email')\n", (359, 376), False, 'from qa327.backend import get_user\n'), ((780, 808), 'qa327.backend.get_ticket', 'get_ticket', (['"""Correct Ticket"""'], {}), "('Correct Ticket')\n", (790, 808), False, 'from qa327.backend impo... |
from typing import Dict, List
from sqlalchemy.orm import Session
from src.db import models, schemas
def select_prediction_log_all(db: Session) -> List[schemas.PredictionLog]:
return db.query(models.PredictionLog).all()
def select_prediction_log_between(
db: Session,
time_before: str,
time_later: st... | [
"src.db.models.PredictionLog",
"src.db.models.OutlierLog"
] | [((1152, 1196), 'src.db.models.PredictionLog', 'models.PredictionLog', ([], {'log_id': 'log_id', 'log': 'log'}), '(log_id=log_id, log=log)\n', (1172, 1196), False, 'from src.db import models, schemas\n'), ((1446, 1487), 'src.db.models.OutlierLog', 'models.OutlierLog', ([], {'log_id': 'log_id', 'log': 'log'}), '(log_id=... |
from proxany.decode.tls import parse
from proxany.server import create_socket
sock = create_socket('0.0.0.0', 443)
while True:
(clientsocket, address) = sock.accept()
parse(clientsocket)
# ct = client_thread(clientsocket)
# ct.run() | [
"proxany.decode.tls.parse",
"proxany.server.create_socket"
] | [((86, 115), 'proxany.server.create_socket', 'create_socket', (['"""0.0.0.0"""', '(443)'], {}), "('0.0.0.0', 443)\n", (99, 115), False, 'from proxany.server import create_socket\n'), ((177, 196), 'proxany.decode.tls.parse', 'parse', (['clientsocket'], {}), '(clientsocket)\n', (182, 196), False, 'from proxany.decode.tls... |
from raptiformica.distributed.exec import try_machine_command
def try_issue_shutdown(host_and_port_pairs):
"""
Iterate over host and port pairs and try to issue a shutdown on all nodes until
one returns a nonzero exit code. At that point return the standard out output.
If we ran out of host and port p... | [
"raptiformica.distributed.exec.try_machine_command"
] | [((793, 940), 'raptiformica.distributed.exec.try_machine_command', 'try_machine_command', (['host_and_port_pairs', 'issue_global_shutdown_command'], {'attempt_message': 'attempt_message', 'all_failed_message': 'all_failed_message'}), '(host_and_port_pairs, issue_global_shutdown_command,\n attempt_message=attempt_mes... |
"""
Necessary utilities of the project.
Version: 0.1
Author: <NAME>
"""
from os.path import isfile
import requests
from toolz import *
from toolz.curried import *
import sqlite3
from collections import namedtuple
USER_FIELDS = ("UserID", "Login", "Type", "Created_at", "OrganisationsURL", "FollowingURL", "UserURL")
U... | [
"os.path.isfile",
"collections.namedtuple",
"sqlite3.connect",
"requests.get"
] | [((426, 462), 'collections.namedtuple', 'namedtuple', (['"""User_repr"""', 'USER_FIELDS'], {}), "('User_repr', USER_FIELDS)\n", (436, 462), False, 'from collections import namedtuple\n'), ((2658, 2670), 'os.path.isfile', 'isfile', (['path'], {}), '(path)\n', (2664, 2670), False, 'from os.path import isfile\n'), ((2682,... |
import cv2 as cv
import sys
class CameraRenderingSystem:
def __init__(self, camera_service):
if 'headless' in sys.argv:
print("Running in headless mode", flush=True)
self._is_headless = True
else:
self._is_headless = False
self._camera_service = camera_s... | [
"cv2.namedWindow",
"cv2.destroyAllWindows",
"cv2.startWindowThread",
"cv2.imshow"
] | [((741, 772), 'cv2.imshow', 'cv.imshow', (['"""video frame"""', 'frame'], {}), "('video frame', frame)\n", (750, 772), True, 'import cv2 as cv\n'), ((842, 864), 'cv2.destroyAllWindows', 'cv.destroyAllWindows', ([], {}), '()\n', (862, 864), True, 'import cv2 as cv\n'), ((407, 429), 'cv2.startWindowThread', 'cv.startWind... |
import numpy as np
from typing import Tuple, Iterable, Dict, Hashable, List
import importlib.util
from types import MethodType
try:
import torch # type: ignore
import torchvision.models as models # type: ignore
from torchvision import transforms # type: ignore
from torchvision.ops import boxes as bo... | [
"torchvision.transforms.ToPILImage",
"torchvision.ops.boxes.batched_nms",
"torchvision.ops.boxes.remove_small_boxes",
"torchvision.models.detection.fasterrcnn_resnet50_fpn",
"torch.cuda.is_available",
"torch.arange",
"smqtk_detection.utils.bbox.AxisAlignedBoundingBox",
"torch.no_grad",
"torchvision.... | [((1498, 1637), 'torchvision.models.detection.fasterrcnn_resnet50_fpn', 'models.detection.fasterrcnn_resnet50_fpn', ([], {'pretrained': '(True)', 'progress': '(False)', 'box_detections_per_img': 'num_dets', 'box_score_thresh': 'box_thresh'}), '(pretrained=True, progress=False,\n box_detections_per_img=num_dets, box_... |
from todclean import repo_manager as manager
class TaskCheck:
def __init__(self):
self.repository = manager('task')
def check_task(self, task_id):
return self.repository.check(task_id)
| [
"todclean.repo_manager"
] | [((115, 130), 'todclean.repo_manager', 'manager', (['"""task"""'], {}), "('task')\n", (122, 130), True, 'from todclean import repo_manager as manager\n')] |
from typing import List, Tuple
import helper
import inputHelper
from puzzleBase import PuzzleBase
CardList = List[int]
Const_Player1: str = "Player 1"
Const_Player2: str = "Player 2"
class InputData:
expectedAnswer: int
player1Deck: CardList
player2Deck: CardList
def __init__(self, name: str... | [
"inputHelper.load_file",
"helper.validate_result",
"helper.dprint"
] | [((733, 783), 'inputHelper.load_file', 'inputHelper.load_file', (['day', 'f"""{name}-answer{part}"""'], {}), "(day, f'{name}-answer{part}')\n", (754, 783), False, 'import inputHelper\n'), ((1985, 2025), 'helper.dprint', 'helper.dprint', (['"""== Post-game results =="""'], {}), "('== Post-game results ==')\n", (1998, 20... |
#!python3
import numpy as np
from magLabUtilities.signalutilities.signals import SignalThread, Signal, SignalBundle
from magLabUtilities.signalutilities.hysteresis import HysteresisSignalBundle, XExpGendey101620
from magLabUtilities.uiutilities.plotting.hysteresis import MofHXofMPlotter
if __name__=='__main__'... | [
"numpy.amin",
"magLabUtilities.uiutilities.plotting.hysteresis.MofHXofMPlotter",
"magLabUtilities.signalutilities.hysteresis.XExpGendey101620",
"numpy.linspace",
"magLabUtilities.signalutilities.signals.Signal.fromThreadPair",
"numpy.amax"
] | [((766, 817), 'magLabUtilities.signalutilities.signals.Signal.fromThreadPair', 'Signal.fromThreadPair', (['mVirginThread', 'tVirginThread'], {}), '(mVirginThread, tVirginThread)\n', (787, 817), False, 'from magLabUtilities.signalutilities.signals import SignalThread, Signal, SignalBundle\n'), ((1002, 1045), 'magLabUtil... |
from oarepo_oai_pmh_harvester.decorators import rule
from oarepo_oai_pmh_harvester.transformer import OAITransformer
from oarepo_taxonomies.utils import get_taxonomy_json
@rule("nusl", "marcxml", "/998__/a", phase="pre")
def call_provider(el, **kwargs):
return provider(el, **kwargs) # pragma: no cover
def prov... | [
"oarepo_oai_pmh_harvester.decorators.rule",
"oarepo_taxonomies.utils.get_taxonomy_json"
] | [((174, 222), 'oarepo_oai_pmh_harvester.decorators.rule', 'rule', (['"""nusl"""', '"""marcxml"""', '"""/998__/a"""'], {'phase': '"""pre"""'}), "('nusl', 'marcxml', '/998__/a', phase='pre')\n", (178, 222), False, 'from oarepo_oai_pmh_harvester.decorators import rule\n'), ((624, 673), 'oarepo_taxonomies.utils.get_taxonom... |
#Python 2.7.9 (default, Apr 5 2015, 22:21:35)
# full env in environment.yml
import sys, os
'''
This is a full aggregation of the Pulsar Hunters project, including user weighting.
Note it's quite a simple project - basically one Yes/No question - and there is gold-standard data, so the weighting is relatively straig... | [
"pandas.Series",
"numpy.mean",
"json.loads",
"numpy.median",
"pandas.isnull",
"numpy.log10",
"pandas.read_csv",
"pandas.merge",
"numpy.invert",
"numpy.sum",
"numpy.percentile",
"sys.exit",
"pandas.DataFrame",
"os.system"
] | [((14656, 14681), 'pandas.read_csv', 'pd.read_csv', (['classfile_in'], {}), '(classfile_in)\n', (14667, 14681), True, 'import pandas as pd\n'), ((14950, 14972), 'pandas.DataFrame', 'pd.DataFrame', (['talkjson'], {}), '(talkjson)\n', (14962, 14972), True, 'import pandas as pd\n'), ((16050, 16092), 'pandas.read_csv', 'pd... |
import numpy as np
import torch
import torch.nn.functional as F
import torch.nn as nn
from pytorch.utils import flip, _ntuple, HardSigmoid, StochasticDropout, LayerNorm
class ST_round(torch.autograd.Function):
def __init__(self, gradient_factor=1.0):
super(ST_round, self).__init__()
self.gradien... | [
"numpy.prod",
"numpy.sqrt",
"torch.nn.init.constant_",
"numpy.log",
"torch.sqrt",
"torch.nn.functional.linear",
"pytorch.utils._ntuple",
"torch.nn.init.uniform_",
"numpy.abs",
"torch.Tensor",
"torch.ceil",
"torch.nn.init._calculate_fan_in_and_fan_out",
"torch.round",
"torch.nn.functional.r... | [((388, 402), 'torch.round', 'torch.round', (['x'], {}), '(x)\n', (399, 402), False, 'import torch\n'), ((704, 717), 'torch.ceil', 'torch.ceil', (['x'], {}), '(x)\n', (714, 717), False, 'import torch\n'), ((6631, 6664), 'torch.nn.init.constant_', 'nn.init.constant_', (['self.beta', '(0.0)'], {}), '(self.beta, 0.0)\n', ... |
from simlady.simlady import calculate_cigar_operations_lady
MATCH, DELETION, INSERTION, SUBST = (7, 2, 1, 8) # PySam CIGAR Operation Codes
def test_all_matches():
result = calculate_cigar_operations_lady(100, [], [], [])
assert result == [(MATCH, 100)]
def test_all_inserts():
result = calculate_cigar_... | [
"simlady.simlady.calculate_cigar_operations_lady"
] | [((180, 228), 'simlady.simlady.calculate_cigar_operations_lady', 'calculate_cigar_operations_lady', (['(100)', '[]', '[]', '[]'], {}), '(100, [], [], [])\n', (211, 228), False, 'from simlady.simlady import calculate_cigar_operations_lady\n'), ((799, 854), 'simlady.simlady.calculate_cigar_operations_lady', 'calculate_ci... |
# Copyright 2014 ARM Limited
#
# Licensed under the Apache License, Version 2.0
# See LICENSE file for details.
# standard library modules, , ,
import os
import logging
from collections import OrderedDict
# access, , get components, internal
from yotta.lib import access
from yotta.lib import access_common
# pool, , s... | [
"logging.getLogger",
"collections.OrderedDict",
"yotta.lib.fsutils.isLink",
"yotta.lib.pack.tryReadJSON",
"os.path.join",
"yotta.lib.target.getSimilarTo_Deprecated",
"yotta.lib.access.satisfyFromAvailable",
"os.path.realpath",
"os.path.isfile",
"os.path.normpath",
"yotta.lib.target.getConfigValu... | [((1245, 1276), 'logging.getLogger', 'logging.getLogger', (['"""components"""'], {}), "('components')\n", (1262, 1276), False, 'import logging\n'), ((1181, 1207), 'os.path.realpath', 'os.path.realpath', (['__file__'], {}), '(__file__)\n', (1197, 1207), False, 'import os\n'), ((3256, 3269), 'collections.OrderedDict', 'O... |
# -*- coding: utf-8 -*-
from json import loads
from dnslib import *
from dnslib import server
def load_json():
with open('dns.conf', 'rt') as f:
conf = loads(f.read())
return conf
# download the configuration file
conf = load_json()
#local_dns = conf['loc_dns'] # local address dns server ... | [
"dnslib.server.DNSLogger",
"dnslib.server.DNSServer"
] | [((1618, 1636), 'dnslib.server.DNSLogger', 'server.DNSLogger', ([], {}), '()\n', (1634, 1636), False, 'from dnslib import server\n'), ((1641, 1718), 'dnslib.server.DNSServer', 'server.DNSServer', (['resolver'], {'port': 'local_port', 'address': 'local_dns', 'logger': 'logger'}), '(resolver, port=local_port, address=loc... |
from petisco.events.event import Event
def redis_based_event_handler(func):
def wrapper(message):
json_data = message["data"].decode("utf-8")
event = Event.from_json(json_data)
return func(event)
return wrapper
| [
"petisco.events.event.Event.from_json"
] | [((172, 198), 'petisco.events.event.Event.from_json', 'Event.from_json', (['json_data'], {}), '(json_data)\n', (187, 198), False, 'from petisco.events.event import Event\n')] |
from typing import List
from volatility import framework
from volatility.framework import interfaces, renderers
from volatility.framework.interfaces import plugins
class FrameworkInfo(plugins.PluginInterface):
"""Plugin to list the various modular components of Volatility"""
@classmethod
def get_require... | [
"volatility.framework.class_subclasses"
] | [((1030, 1074), 'volatility.framework.class_subclasses', 'framework.class_subclasses', (['module_interface'], {}), '(module_interface)\n', (1056, 1074), False, 'from volatility import framework\n')] |
#!/usr/bin/env python
from setuptools import find_packages
from setuptools import setup
packages = find_packages(exclude=('tests', 'doc'))
provides = ['taurex', ]
requires = []
install_requires = ['numpy',
'configobj',
'scipy',
'numba',
... | [
"setuptools.find_packages",
"setuptools.setup"
] | [((100, 139), 'setuptools.find_packages', 'find_packages', ([], {'exclude': "('tests', 'doc')"}), "(exclude=('tests', 'doc'))\n", (113, 139), False, 'from setuptools import find_packages\n'), ((1313, 1895), 'setuptools.setup', 'setup', ([], {'name': '"""taurex"""', 'author': '"""<NAME>"""', 'author_email': '"""<EMAIL>"... |
from collections import defaultdict
from dae.person_sets import PersonSetCollection
def get_family_pedigree(family, person_set_collection):
return [
(
p.family_id,
p.person_id,
p.mom_id if p.mom_id else "0",
p.dad_id if p.dad_id else "0",
p.sex.... | [
"collections.defaultdict",
"dae.person_sets.PersonSetCollection.get_person_color"
] | [((366, 428), 'dae.person_sets.PersonSetCollection.get_person_color', 'PersonSetCollection.get_person_color', (['p', 'person_set_collection'], {}), '(p, person_set_collection)\n', (402, 428), False, 'from dae.person_sets import PersonSetCollection\n'), ((2449, 2466), 'collections.defaultdict', 'defaultdict', (['list'],... |
"""
One-element fields
======================
"""
import numpy as np
from bfieldtools.mesh_magnetics import (
scalar_potential_coupling,
vector_potential_coupling,
)
from bfieldtools.mesh_magnetics import (
magnetic_field_coupling,
magnetic_field_coupling_analytic,
)
import trimesh
from mayavi impo... | [
"numpy.linalg.norm",
"mayavi.mlab.figure",
"bfieldtools.mesh_magnetics.magnetic_field_coupling_analytic",
"numpy.array",
"numpy.zeros",
"mayavi.mlab.quiver3d",
"numpy.cos",
"trimesh.Trimesh",
"bfieldtools.mesh_magnetics.scalar_potential_coupling",
"numpy.sin",
"bfieldtools.mesh_magnetics.vector_... | [((354, 371), 'numpy.sin', 'np.sin', (['(np.pi / 6)'], {}), '(np.pi / 6)\n', (360, 371), True, 'import numpy as np\n'), ((376, 393), 'numpy.cos', 'np.cos', (['(np.pi / 6)'], {}), '(np.pi / 6)\n', (382, 393), True, 'import numpy as np\n'), ((404, 500), 'numpy.array', 'np.array', (['[[0, 0, 0], [1, 0, 0], [x, y, 0], [-x,... |
from flask import Blueprint, current_app, jsonify
from typing import Any
hello_world = Blueprint('hello_world', __name__)
@hello_world.route("/helloworld")
def reply() -> Any:
return jsonify({"text": current_app.config['HELLO_WORLD']})
| [
"flask.Blueprint",
"flask.jsonify"
] | [((88, 122), 'flask.Blueprint', 'Blueprint', (['"""hello_world"""', '__name__'], {}), "('hello_world', __name__)\n", (97, 122), False, 'from flask import Blueprint, current_app, jsonify\n'), ((190, 242), 'flask.jsonify', 'jsonify', (["{'text': current_app.config['HELLO_WORLD']}"], {}), "({'text': current_app.config['HE... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Copyright (c) 2013 <NAME>
#
# Everyone is permitted to copy and distribute verbatim or modified
# copies of this license document, and changing it is allowed as long
# as the name is changed.
#
# DO WHAT THE FUCK YOU WANT TO PUBLIC LICENSE
# TERMS AND CONDITI... | [
"logging.getLogger",
"logging.basicConfig",
"argparse.ArgumentParser",
"matplotlib.animation.FuncAnimation",
"mpl_toolkits.mplot3d.Axes3D",
"matplotlib.pyplot.figure",
"threading.Thread",
"time.time",
"numpy.random.RandomState",
"matplotlib.pyplot.show"
] | [((723, 750), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (740, 750), False, 'import logging\n'), ((1160, 1190), 'numpy.random.RandomState', 'numpy.random.RandomState', (['seed'], {}), '(seed)\n', (1184, 1190), False, 'import numpy\n'), ((7389, 7482), 'argparse.ArgumentParser', 'argpar... |
# Copyright 2012 OpenStack LLC.
# 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 b... | [
"tests.utils.FakeAPI"
] | [((3321, 3344), 'tests.utils.FakeAPI', 'utils.FakeAPI', (['fixtures'], {}), '(fixtures)\n', (3334, 3344), False, 'from tests import utils\n')] |