code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
# Copyright 2018 TNG Technology Consulting GmbH, Unterföhring, Germany
# Licensed under the Apache License, Version 2.0 - see LICENSE.md in project root directory
import logging
from xml.sax.saxutils import escape
log = logging.getLogger()
class Todo:
def __init__(self, file_path, line_number, content):
... | [
"logging.getLogger",
"xml.sax.saxutils.escape"
] | [((223, 242), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (240, 242), False, 'import logging\n'), ((1538, 1558), 'xml.sax.saxutils.escape', 'escape', (['self.content'], {}), '(self.content)\n', (1544, 1558), False, 'from xml.sax.saxutils import escape\n')] |
import dash_core_components as dcc
import dash_html_components as html
import plotly.graph_objs as go
import plotly.express as px
from plotly.subplots import make_subplots
import pandas as pd
import math
from datetime import datetime, time
from utils import MONTH_NAMES, month_range
def section(title, content, gray=Fa... | [
"dash_html_components.Br",
"dash_html_components.Li",
"plotly.graph_objs.Scatter",
"datetime.datetime.now",
"plotly.graph_objs.Pie",
"plotly.graph_objs.Bar",
"dash_html_components.H2",
"dash_html_components.H1",
"pandas.DataFrame",
"plotly.graph_objs.Figure",
"dash_html_components.Img",
"utils... | [((3295, 3314), 'utils.month_range', 'month_range', (['months'], {}), '(months)\n', (3306, 3314), False, 'from utils import MONTH_NAMES, month_range\n'), ((3645, 3656), 'plotly.graph_objs.Figure', 'go.Figure', ([], {}), '()\n', (3654, 3656), True, 'import plotly.graph_objs as go\n'), ((4455, 4474), 'utils.month_range',... |
# -*- coding: utf-8 -*-
from gengine.app.tests.base import BaseDBTest
from gengine.app.tests.helpers import create_user, update_user, delete_user, get_or_create_language
from gengine.metadata import DBSession
from gengine.app.model import AuthUser
class TestUserCreation(BaseDBTest):
def test_user_creation(self):... | [
"gengine.app.tests.helpers.create_user",
"gengine.metadata.DBSession.add",
"gengine.app.tests.helpers.delete_user",
"gengine.app.tests.helpers.update_user",
"gengine.app.tests.helpers.get_or_create_language",
"gengine.app.model.AuthUser"
] | [((337, 365), 'gengine.app.tests.helpers.get_or_create_language', 'get_or_create_language', (['"""en"""'], {}), "('en')\n", (359, 365), False, 'from gengine.app.tests.helpers import create_user, update_user, delete_user, get_or_create_language\n'), ((381, 531), 'gengine.app.tests.helpers.create_user', 'create_user', ([... |
from __future__ import annotations
import collections
import copy
import itertools
import math
import os
import posixpath
from io import BytesIO, StringIO
from textwrap import indent
from typing import Any, Dict, List, MutableMapping, Optional, Tuple, Union
from fontTools.misc import etree as ET
from fontTools.misc i... | [
"collections.OrderedDict",
"fontTools.misc.textTools.tobytes",
"fontTools.varLib.models.normalizeValue",
"copy.deepcopy",
"fontTools.misc.textTools.tostr",
"itertools.product",
"fontTools.misc.etree.parse",
"io.BytesIO",
"os.path.splitext",
"fontTools.misc.etree.Element",
"fontTools.misc.plistli... | [((8905, 8922), 'fontTools.misc.textTools.tostr', 'tostr', (['familyName'], {}), '(familyName)\n', (8910, 8922), False, 'from fontTools.misc.textTools import tobytes, tostr\n'), ((20148, 20164), 'fontTools.misc.textTools.tostr', 'tostr', (['styleName'], {}), '(styleName)\n', (20153, 20164), False, 'from fontTools.misc.... |
#!/usr/bin/env python3
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
from typing import Any, Optional, Tuple
import torch
from botorch.acquisition.acquisition import AcquisitionFunction
... | [
"botorch.acquisition.objective.GenericMCObjective",
"botorch.acquisition.monte_carlo.qSimpleRegret",
"botorch.utils.get_outcome_constraint_transforms",
"botorch.acquisition.utils.get_infeasible_cost",
"botorch.utils.get_objective_weights_transform",
"botorch.acquisition.objective.ConstrainedMCObjective"
] | [((3168, 3209), 'botorch.acquisition.monte_carlo.qSimpleRegret', 'qSimpleRegret', (['model'], {'objective': 'objective'}), '(model, objective=objective)\n', (3181, 3209), False, 'from botorch.acquisition.monte_carlo import qSimpleRegret\n'), ((2622, 2672), 'botorch.utils.get_objective_weights_transform', 'get_objective... |
# Copyright 2018 the Autoware Foundation
#
# 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 ... | [
"lidar_integration.make_post_shutdown_tests",
"ament_index_python.get_package_share_directory",
"lidar_integration.make_pcl_checker",
"lidar_integration.make_active_tests",
"lidar_integration.get_open_port"
] | [((2139, 2176), 'lidar_integration.make_active_tests', 'lidar_integration.make_active_tests', ([], {}), '()\n', (2174, 2176), False, 'import lidar_integration\n'), ((2195, 2239), 'lidar_integration.make_post_shutdown_tests', 'lidar_integration.make_post_shutdown_tests', ([], {}), '()\n', (2237, 2239), False, 'import li... |
# USAGE
# python example.py --source images/ocean_sunset.jpg --target images/ocean_day.jpg
# import the necessary packages
from color_transfer import color_transfer
import numpy as np
import argparse
import cv2
def show_image(title, image, width = 300):
# resize the image to have a constant width, just to
# make di... | [
"cv2.imwrite",
"cv2.resize",
"argparse.ArgumentParser",
"cv2.imshow",
"color_transfer.color_transfer",
"cv2.waitKey",
"cv2.imread"
] | [((633, 658), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (656, 658), False, 'import argparse\n'), ((970, 996), 'cv2.imread', 'cv2.imread', (["args['source']"], {}), "(args['source'])\n", (980, 996), False, 'import cv2\n'), ((1006, 1032), 'cv2.imread', 'cv2.imread', (["args['target']"], {}),... |
import copy
import numpy as np
import open3d as o3d
from tqdm import tqdm
from scipy import stats
import utils_o3d as utils
def remove_ground_plane(pcd, z_thresh=-2.7):
cropped = copy.deepcopy(pcd)
cropped_points = np.array(cropped.points)
cropped_points = cropped_points[cropped_points[:, -1] > z_thresh... | [
"open3d.registration.TransformationEstimationPointToPlane",
"numpy.array",
"copy.deepcopy",
"numpy.linalg.norm",
"numpy.mean",
"numpy.where",
"numpy.asarray",
"numpy.max",
"open3d.registration.RANSACConvergenceCriteria",
"numpy.min",
"open3d.geometry.KDTreeFlann",
"open3d.registration.Correspo... | [((187, 205), 'copy.deepcopy', 'copy.deepcopy', (['pcd'], {}), '(pcd)\n', (200, 205), False, 'import copy\n'), ((227, 251), 'numpy.array', 'np.array', (['cropped.points'], {}), '(cropped.points)\n', (235, 251), True, 'import numpy as np\n'), ((338, 363), 'open3d.geometry.PointCloud', 'o3d.geometry.PointCloud', ([], {})... |
import os
import imp
from setuptools import setup, find_packages
__version__ = imp.load_source(
"hsfs.version", os.path.join("hsfs", "version.py")
).__version__
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
setup(
name="hsfs",
version=__version__,
install_... | [
"os.path.dirname",
"setuptools.find_packages",
"os.path.join"
] | [((118, 152), 'os.path.join', 'os.path.join', (['"""hsfs"""', '"""version.py"""'], {}), "('hsfs', 'version.py')\n", (130, 152), False, 'import os\n'), ((1439, 1454), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (1452, 1454), False, 'from setuptools import setup, find_packages\n'), ((215, 240), 'os.pat... |
# Code Taken from https://github.com/LYH-YF/MWPToolkit
# -*- encoding: utf-8 -*-
# @Author: <NAME>
# @Time: 2021/08/21 04:59:55
# @File: sausolver.py
import random
import torch
from torch import nn
import copy
from module.Encoder.rnn_encoder import BasicRNNEncoder
from module.Embedder.basic_embedder import BasicEmbed... | [
"module.Layer.tree_layers.TreeEmbedding",
"torch.LongTensor",
"torch.square",
"torch.nn.MSELoss",
"torch.sum",
"loss.masked_cross_entropy_loss.MaskedCrossEntropyLoss",
"copy.deepcopy",
"torch.ByteTensor",
"utils.utils.copy_list",
"module.Encoder.rnn_encoder.BasicRNNEncoder",
"module.Strategy.bea... | [((2639, 2710), 'module.Embedder.basic_embedder.BasicEmbedder', 'BasicEmbedder', (['self.vocab_size', 'self.embedding_size', 'self.dropout_ratio'], {}), '(self.vocab_size, self.embedding_size, self.dropout_ratio)\n', (2652, 2710), False, 'from module.Embedder.basic_embedder import BasicEmbedder\n'), ((2873, 3007), 'mod... |
import time
import srt
import re
import datetime
from mqtthandler import MQTTHandler
INIT_STATUS={
"video": {
"title": None,
"series_title": None,
"season": None,
"episode": None
},
"time": None,
"events": None
}
class SubtitleHandler:
subtitles = []
phrases = ... | [
"mqtthandler.MQTTHandler",
"datetime.timedelta.total_seconds",
"re.search"
] | [((380, 399), 'mqtthandler.MQTTHandler', 'MQTTHandler', (['broker'], {}), '(broker)\n', (391, 399), False, 'from mqtthandler import MQTTHandler\n'), ((1112, 1139), 're.search', 're.search', (['phrase', 'sub_line'], {}), '(phrase, sub_line)\n', (1121, 1139), False, 'import re\n'), ((1333, 1373), 'datetime.timedelta.tota... |
#!/usr/bin/env python
import os
import numpy as np
import pandas as pd
os.getcwd()
# Request for the filename
# Current version of this script works only with TSV type files
mainFilename = input('Input your file name (diabetes.tab.txt or housing.data.txt): ')
print()
# To create proper dataframe, transforming it wi... | [
"pandas.DataFrame",
"numpy.genfromtxt",
"pandas.to_numeric",
"os.getcwd"
] | [((73, 84), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (82, 84), False, 'import os\n'), ((375, 415), 'numpy.genfromtxt', 'np.genfromtxt', (['mainFilename'], {'dtype': '"""str"""'}), "(mainFilename, dtype='str')\n", (388, 415), True, 'import numpy as np\n'), ((432, 458), 'pandas.DataFrame', 'pd.DataFrame', (['filenameD... |
from donkeycar.parts.web_controller.web import WebSocketCalibrateAPI
from functools import partial
from tornado import testing
import tornado.websocket
import tornado.web
import tornado.ioloop
import json
from unittest.mock import Mock
from donkeycar.parts.actuator import PWMSteering, PWMThrottle
class WebSocketCal... | [
"json.dumps",
"unittest.mock.Mock"
] | [((978, 984), 'unittest.mock.Mock', 'Mock', ([], {}), '()\n', (982, 984), False, 'from unittest.mock import Mock\n'), ((1607, 1613), 'unittest.mock.Mock', 'Mock', ([], {}), '()\n', (1611, 1613), False, 'from unittest.mock import Mock\n'), ((2237, 2243), 'unittest.mock.Mock', 'Mock', ([], {}), '()\n', (2241, 2243), Fals... |
# Copyright 2016 Google Inc.
#
# 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, ... | [
"google.cloud.logging._gax._MetricsAPI",
"google.cloud.gapic.logging.v2.config_service_v2_api.ConfigServiceV2Api",
"os.getenv",
"google.cloud.logging.entries.TextEntry.from_api_repr",
"google.cloud.logging.connection._LoggingAPI",
"google.cloud.logging.connection._SinksAPI",
"google.cloud.logging.connec... | [((2148, 2178), 'os.getenv', 'os.getenv', (['DISABLE_GRPC', '(False)'], {}), '(DISABLE_GRPC, False)\n', (2157, 2178), False, 'import os\n'), ((5172, 5197), 'google.cloud.logging.logger.Logger', 'Logger', (['name'], {'client': 'self'}), '(name, client=self)\n', (5178, 5197), False, 'from google.cloud.logging.logger impo... |
from __future__ import absolute_import
from unittest import TestCase
import os
import importlib
import inspect
from plotly.basedatatypes import BasePlotlyType, BaseFigure
datatypes_root = "new_plotly/graph_objs"
datatype_modules = [
dirpath.replace("/", ".")
for dirpath, _, _ in os.walk(datatypes_root)
if... | [
"importlib.import_module",
"os.walk"
] | [((290, 313), 'os.walk', 'os.walk', (['datatypes_root'], {}), '(datatypes_root)\n', (297, 313), False, 'import os\n'), ((503, 544), 'importlib.import_module', 'importlib.import_module', (['datatypes_module'], {}), '(datatypes_module)\n', (526, 544), False, 'import importlib\n')] |
"""The Wolf SmartSet Service integration."""
from datetime import timedelta
import logging
from httpx import ConnectError, ConnectTimeout
from wolf_smartset.token_auth import InvalidAuth
from wolf_smartset.wolf_client import FetchFailed, ParameterReadError, WolfClient
from homeassistant.config_entries import ConfigEn... | [
"logging.getLogger",
"wolf_smartset.wolf_client.WolfClient",
"homeassistant.exceptions.ConfigEntryNotReady",
"homeassistant.helpers.update_coordinator.UpdateFailed",
"datetime.timedelta"
] | [((708, 735), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (725, 735), False, 'import logging\n'), ((1321, 1351), 'wolf_smartset.wolf_client.WolfClient', 'WolfClient', (['username', 'password'], {}), '(username, password)\n', (1331, 1351), False, 'from wolf_smartset.wolf_client import F... |
import torch
from torch import nn
from torch.nn import functional as F
from torchdrug import layers
class ConditionalFlow(nn.Module):
"""
Conditional flow transformation from `Masked Autoregressive Flow for Density Estimation`_.
.. _Masked Autoregressive Flow for Density Estimation:
https://arxi... | [
"torch.nn.functional.tanh",
"torch.zeros"
] | [((999, 1013), 'torch.zeros', 'torch.zeros', (['(1)'], {}), '(1)\n', (1010, 1013), False, 'import torch\n'), ((1449, 1462), 'torch.nn.functional.tanh', 'F.tanh', (['scale'], {}), '(scale)\n', (1455, 1462), True, 'from torch.nn import functional as F\n'), ((2016, 2029), 'torch.nn.functional.tanh', 'F.tanh', (['scale'], ... |
import numpy as np
from sklearn.utils.multiclass import type_of_target
from mindware.base_estimator import BaseEstimator
from mindware.components.utils.constants import type_dict, MULTILABEL_CLS, IMG_CLS, TEXT_CLS, OBJECT_DET
from mindware.components.feature_engineering.transformation_graph import DataNode
class Clas... | [
"numpy.mean",
"numpy.ones_like",
"lightgbm.LGBMClassifier",
"lightgbm.LGBMRegressor",
"sklearn.linear_model.LogisticRegression",
"numpy.sum",
"sklearn.utils.multiclass.type_of_target",
"numpy.std",
"pandas.DataFrame",
"sklearn.linear_model.LinearRegression"
] | [((591, 619), 'sklearn.utils.multiclass.type_of_target', 'type_of_target', (['data.data[1]'], {}), '(data.data[1])\n', (605, 619), False, 'from sklearn.utils.multiclass import type_of_target\n'), ((2957, 2987), 'lightgbm.LGBMClassifier', 'LGBMClassifier', ([], {'random_state': '(1)'}), '(random_state=1)\n', (2971, 2987... |
# -*- coding: utf-8 -*-
import scrapy
import json
import os
import codecs
from AnimeSpider.items import AnimespiderItem
class AinmelinklistSpider(scrapy.Spider):
name = 'AinmeLinkList'
allowed_domains = ['bilibili.com']
start_urls = ['http://bilibili.com/']
def start_requests(self):
jsonpath ... | [
"json.loads",
"os.path.dirname",
"scrapy.Request",
"codecs.open",
"AnimeSpider.items.AnimespiderItem"
] | [((379, 451), 'codecs.open', 'codecs.open', (["('%s/AinmeList_items.json' % jsonpath)", '"""r"""'], {'encoding': '"""utf-8"""'}), "('%s/AinmeList_items.json' % jsonpath, 'r', encoding='utf-8')\n", (390, 451), False, 'import codecs\n'), ((756, 773), 'AnimeSpider.items.AnimespiderItem', 'AnimespiderItem', ([], {}), '()\n... |
"""Setup for pytest-testplan plugin."""
from setuptools import setup
setup(
name='pytest-testplan',
version='0.1.0',
description='A pytest plugin to generate a CSV test report.',
author='<NAME>',
author_email='<EMAIL>',
license='MIT',
py_modules=['pytest_testplan'],
install_requires=['... | [
"setuptools.setup"
] | [((71, 373), 'setuptools.setup', 'setup', ([], {'name': '"""pytest-testplan"""', 'version': '"""0.1.0"""', 'description': '"""A pytest plugin to generate a CSV test report."""', 'author': '"""<NAME>"""', 'author_email': '"""<EMAIL>"""', 'license': '"""MIT"""', 'py_modules': "['pytest_testplan']", 'install_requires': "[... |
# Generated by Django 3.1.4 on 2021-01-07 19:32
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('api', '0003_auto_20210107_2010'),
]
operations = [
migrations.AlterField(
model_name='extrainfo... | [
"django.db.models.ForeignKey",
"django.db.models.AutoField",
"django.db.models.TextField",
"django.db.models.IntegerField"
] | [((368, 490), 'django.db.models.IntegerField', 'models.IntegerField', ([], {'choices': "[(2, 'Sci-Fi'), (0, 'Nieznany'), (5, 'Komedia'), (3, 'Dramat'), (1, 'Horror')]", 'default': '(0)'}), "(choices=[(2, 'Sci-Fi'), (0, 'Nieznany'), (5, 'Komedia'),\n (3, 'Dramat'), (1, 'Horror')], default=0)\n", (387, 490), False, 'f... |
import time
import warnings
import matplotlib.pyplot as plt
import numpy as np
import sympy as sp
from .global_qbx import global_qbx_self
from .mesh import apply_interp_mat, gauss_rule, panelize_symbolic_surface, upsample
def find_dcutoff_refine(kernel, src, tol, plot=False):
# prep step 1: find d_cutoff and d_... | [
"sympy.cos",
"numpy.log10",
"matplotlib.pyplot.ylabel",
"numpy.array",
"sympy.var",
"numpy.linalg.norm",
"numpy.arange",
"numpy.repeat",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"numpy.max",
"numpy.stack",
"numpy.linspace",
"numpy.min",
"warnings.simplefilter",
"numpy.argm... | [((951, 978), 'numpy.ones_like', 'np.ones_like', (['src.pts[:, 0]'], {}), '(src.pts[:, 0])\n', (963, 978), True, 'import numpy as np\n'), ((1130, 1149), 'numpy.arange', 'np.arange', (['(1)', '(55)', '(3)'], {}), '(1, 55, 3)\n', (1139, 1149), True, 'import numpy as np\n'), ((6070, 6091), 'numpy.argmin', 'np.argmin', (['... |
import logging as log
class Log:
def __init__(self, level):
self.level = level
log.basicConfig(format='%(asctime)s - %(pathname)s[line:%(lineno)d] - %(levelname)s: %(message)s',
level=level)
self.log = log
def info(self, msg):
self.log.info(msg)
de... | [
"logging.basicConfig"
] | [((101, 221), 'logging.basicConfig', 'log.basicConfig', ([], {'format': '"""%(asctime)s - %(pathname)s[line:%(lineno)d] - %(levelname)s: %(message)s"""', 'level': 'level'}), "(format=\n '%(asctime)s - %(pathname)s[line:%(lineno)d] - %(levelname)s: %(message)s',\n level=level)\n", (116, 221), True, 'import logging... |
import aspose.email
from aspose.email.clients.imap import ImapClient
from aspose.email.clients import SecurityOptions
from aspose.email.clients.imap import ImapQueryBuilder
import datetime as dt
def run():
dataDir = ""
#ExStart: FetchEmailMessageFromServer
client = ImapClient("imap.gmail.com", 993, "user... | [
"datetime.datetime.now",
"aspose.email.clients.imap.ImapQueryBuilder",
"aspose.email.clients.imap.ImapClient"
] | [((281, 338), 'aspose.email.clients.imap.ImapClient', 'ImapClient', (['"""imap.gmail.com"""', '(993)', '"""username"""', '"""password"""'], {}), "('imap.gmail.com', 993, 'username', 'password')\n", (291, 338), False, 'from aspose.email.clients.imap import ImapClient\n'), ((387, 405), 'aspose.email.clients.imap.ImapQuer... |
import subprocess
def run(cmd):
subprocess.run(cmd.split(' '))
def ls():
subprocess.call(["ls", "-l"]) | [
"subprocess.call"
] | [((82, 111), 'subprocess.call', 'subprocess.call', (["['ls', '-l']"], {}), "(['ls', '-l'])\n", (97, 111), False, 'import subprocess\n')] |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
'''
~Gros
'''
from hashlib import sha256
import random
def add_padding(data, block_size=16):
"""add PKCS#7 padding"""
size = block_size - (len(data)%block_size)
return data+chr(size)*size
def strip_padding(data, block_size=16):
"""strip PKCS#7 padding"... | [
"random.randint"
] | [((563, 585), 'random.randint', 'random.randint', (['(0)', '(255)'], {}), '(0, 255)\n', (577, 585), False, 'import random\n')] |
#
# Copyright (c) 2019 Intel 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... | [
"cli_text_consts.ModelExportCmdTexts.MISSING_EXPORT_FORMAT.format",
"platform_resources.workflow.ArgoWorkflow",
"commands.model.common.workflow_description",
"click.testing.CliRunner"
] | [((1034, 1147), 'platform_resources.workflow.ArgoWorkflow', 'ArgoWorkflow', ([], {'name': 'FEM_NAME', 'started_at': 'FEM_START_DATE', 'finished_at': 'None', 'namespace': 'FEM_NAMESPACE', 'phase': 'None'}), '(name=FEM_NAME, started_at=FEM_START_DATE, finished_at=None,\n namespace=FEM_NAMESPACE, phase=None)\n', (1046,... |
from requests import get
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import datetime as dt
from bme280 import BME280
try:
from smbus2 import SMBus
except ImportError:
from smbus import SMBus
fig = plt.figure()
ax = fig.add_subplot(1, 1, 1)
xs = []
ys =[]
bus = SMBus(1)
bme280 = ... | [
"bme280.BME280",
"smbus.SMBus",
"matplotlib.pyplot.xticks",
"matplotlib.pyplot.ylabel",
"matplotlib.animation.FuncAnimation",
"datetime.datetime.now",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.title",
"matplotlib.pyplot.subplots_adjust",
"matplotlib.pyplot.show"
] | [((237, 249), 'matplotlib.pyplot.figure', 'plt.figure', ([], {}), '()\n', (247, 249), True, 'import matplotlib.pyplot as plt\n'), ((302, 310), 'smbus.SMBus', 'SMBus', (['(1)'], {}), '(1)\n', (307, 310), False, 'from smbus import SMBus\n'), ((320, 339), 'bme280.BME280', 'BME280', ([], {'i2c_dev': 'bus'}), '(i2c_dev=bus)... |
import torch
import torch.nn as nn
import torch.nn.functional as F
from models.misc import modules
constrain_path = {
('threeD', 'normal'): (True, True, ''),
('threeD', 'depth'): (True, True, ''),
('normal', 'depth'): (True, True, ''),
('depth', 'normal'): (True, True, ''),
}
class UnwarpNet(nn.Modu... | [
"torch.nn.functional.tanh",
"models.misc.modules.Encoder",
"torch.nn.functional.sigmoid",
"models.misc.modules.Decoder",
"torch.cat"
] | [((680, 724), 'models.misc.modules.Encoder', 'modules.Encoder', ([], {'downsample': '(6)', 'in_channels': '(3)'}), '(downsample=6, in_channels=3)\n', (695, 724), False, 'from models.misc import modules\n'), ((755, 830), 'models.misc.modules.Decoder', 'modules.Decoder', ([], {'downsample': '(6)', 'out_channels': '(3)', ... |
#!/usr/bin/env python
from typing import List
import aoc
from collections import defaultdict
@aoc.timing
def solve(inp: str, part2=False):
def find_path(current: str, path: List[str] = []):
if current == 'end':
yield path
return
for nxt in caves[current]:
if n... | [
"collections.defaultdict"
] | [((634, 651), 'collections.defaultdict', 'defaultdict', (['list'], {}), '(list)\n', (645, 651), False, 'from collections import defaultdict\n')] |
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License.
from typing import List, Pattern
from recognizers_text.utilities import RegExpUtility
from recognizers_text.extractor import Extractor
from recognizers_number.number.italian.extractors import ItalianIntegerExtractor
from .... | [
"recognizers_number.number.italian.extractors.ItalianIntegerExtractor",
"recognizers_text.utilities.RegExpUtility.get_safe_reg_exp"
] | [((2169, 2194), 'recognizers_number.number.italian.extractors.ItalianIntegerExtractor', 'ItalianIntegerExtractor', ([], {}), '()\n', (2192, 2194), False, 'from recognizers_number.number.italian.extractors import ItalianIntegerExtractor\n'), ((2661, 2718), 'recognizers_text.utilities.RegExpUtility.get_safe_reg_exp', 'Re... |
from pathlib import Path
import pytest
from oval_graph.arf_xml_parser.arf_xml_parser import ARFXMLParser
def get_arf_report_path(src="global_test_data/ssg-fedora-ds-arf.xml"):
return str(Path(__file__).parent.parent / src)
@pytest.mark.parametrize("rule_id, result", [
(
"xccdf_org.ssgproject.conte... | [
"oval_graph.arf_xml_parser.arf_xml_parser.ARFXMLParser",
"pytest.mark.parametrize",
"pytest.raises",
"pathlib.Path"
] | [((234, 897), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""rule_id, result"""', "[('xccdf_org.ssgproject.content_rule_accounts_passwords_pam_faillock_deny',\n 'false'), ('xccdf_org.ssgproject.content_rule_sshd_disable_gssapi_auth',\n 'false'), (\n 'xccdf_org.ssgproject.content_rule_service_debug... |
import os
import logging
import argparse
import sys
import signal
import subprocess
from functools import wraps
from dotenv import load_dotenv
load_dotenv(verbose=True)
from app.config import configure_app
from app.bot import TrumpBotScheduler
from app.sentimentbot import SentimentBot
parser = argparse.ArgumentParse... | [
"app.app.run",
"app.config.configure_app",
"sys.exit",
"app.sentimentbot.SentimentBot",
"logging.info",
"logging.error",
"os.remove",
"os.path.exists",
"argparse.ArgumentParser",
"app.app.config.get",
"subprocess.Popen",
"functools.wraps",
"dotenv.load_dotenv",
"os.setpgrp",
"signal.paus... | [((144, 169), 'dotenv.load_dotenv', 'load_dotenv', ([], {'verbose': '(True)'}), '(verbose=True)\n', (155, 169), False, 'from dotenv import load_dotenv\n'), ((298, 339), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""\n"""'}), "(description='\\n')\n", (321, 339), False, 'import argparse\n... |
from setuptools import setup, Extension, find_packages
import subprocess
import errno
import re
import os
import shutil
import sys
import zipfile
from urllib.request import urlretrieve
import numpy
from Cython.Build import cythonize
isWindows = os.name == 'nt'
isMac = sys.platform == 'darwin'
is64Bit = sys.maxsize... | [
"zipfile.ZipFile",
"sys.exit",
"os.path.exists",
"urllib.request.urlretrieve",
"subprocess.Popen",
"setuptools.find_packages",
"os.mkdir",
"numpy.get_include",
"glob.glob",
"shutil.copyfile",
"os.makedirs",
"os.environ.get",
"os.path.join",
"os.getcwd",
"os.chdir",
"os.path.basename",
... | [((9442, 9476), 'os.environ.get', 'os.environ.get', (['"""LINETRACE"""', '(False)'], {}), "('LINETRACE', False)\n", (9456, 9476), False, 'import os\n'), ((613, 655), 'os.environ.get', 'os.environ.get', (['"""PKG_CONFIG"""', '"""pkg-config"""'], {}), "('PKG_CONFIG', 'pkg-config')\n", (627, 655), False, 'import os\n'), (... |
"""
Post processing on detected objects
"""
import pymongo
from pymongo import MongoClient
import time
import logging
logging.basicConfig(format='%(levelname)s :: %(asctime)s :: %(message)s', level=logging.DEBUG)
from joblib import Parallel, delayed
import click
from xgboost_model.inference import run_inference, Postpr... | [
"logging.basicConfig",
"click.argument",
"click.option",
"joblib.delayed",
"joblib.Parallel",
"time.time",
"pymongo.MongoClient",
"click.command",
"logging.info",
"logging.error"
] | [((118, 216), 'logging.basicConfig', 'logging.basicConfig', ([], {'format': '"""%(levelname)s :: %(asctime)s :: %(message)s"""', 'level': 'logging.DEBUG'}), "(format='%(levelname)s :: %(asctime)s :: %(message)s',\n level=logging.DEBUG)\n", (137, 216), False, 'import logging\n'), ((2490, 2505), 'click.command', 'clic... |
#
# Copyright (c) 2018-2019 Wind River Systems, Inc.
#
# SPDX-License-Identifier: Apache-2.0
#
from sysinv.common import constants
from sysinv.common import exception
from sysinv.common import utils
from sysinv.helm import common
from sysinv.helm import base
class GarbdHelm(base.BaseHelm):
"""Class to encapsulat... | [
"sysinv.common.utils.is_aio_duplex_system",
"sysinv.common.exception.InvalidHelmNamespace"
] | [((1437, 1475), 'sysinv.common.utils.is_aio_duplex_system', 'utils.is_aio_duplex_system', (['self.dbapi'], {}), '(self.dbapi)\n', (1463, 1475), False, 'from sysinv.common import utils\n'), ((2331, 2400), 'sysinv.common.exception.InvalidHelmNamespace', 'exception.InvalidHelmNamespace', ([], {'chart': 'self.CHART', 'name... |
#!/usr/bin/env python
"""Generate frame counts dict for a dataset.
Usage:
frame_counter.py [options]
Options:
-h, --help Print help message
--root=<str> Path to root of dataset (should contain video folders that contain images)
[default: /vision/vision_users/azou/data/hmdb5... | [
"os.path.normpath",
"pickle.dump",
"docopt.docopt",
"os.walk"
] | [((552, 567), 'docopt.docopt', 'docopt', (['__doc__'], {}), '(__doc__)\n', (558, 567), False, 'from docopt import docopt\n'), ((714, 737), 'os.walk', 'os.walk', (["args['--root']"], {}), "(args['--root'])\n", (721, 737), False, 'import os\n'), ((1196, 1222), 'pickle.dump', 'pickle.dump', (['counts', 'ofile'], {}), '(co... |
#!/usr/bin/env python
# Copyright (c) 2016 The Johns Hopkins University/Applied Physics Laboratory
# 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.ap... | [
"logging.basicConfig",
"kmip.services.server.server.main"
] | [((699, 739), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.DEBUG'}), '(level=logging.DEBUG)\n', (718, 739), False, 'import logging\n'), ((879, 892), 'kmip.services.server.server.main', 'server.main', ([], {}), '()\n', (890, 892), False, 'from kmip.services.server import server\n')] |
#
# test_tempo_event.py
# crest-python
#
# Copyright (C) 2017 <NAME>
# Distributed under the MIT License.
#
import crest_loader
import unittest
from crest.events.meta import TempoEvent
class TestTempoEvent(unittest.TestCase):
def test_ctor(self):
TempoEvent()
TempoEvent(120)
def test_... | [
"unittest.main",
"crest.events.meta.TempoEvent"
] | [((869, 884), 'unittest.main', 'unittest.main', ([], {}), '()\n', (882, 884), False, 'import unittest\n'), ((269, 281), 'crest.events.meta.TempoEvent', 'TempoEvent', ([], {}), '()\n', (279, 281), False, 'from crest.events.meta import TempoEvent\n'), ((290, 305), 'crest.events.meta.TempoEvent', 'TempoEvent', (['(120)'],... |
# Copyright (c) 2008,2015,2016,2017,2018,2019 MetPy Developers.
# Distributed under the terms of the BSD 3-Clause License.
# SPDX-License-Identifier: BSD-3-Clause
"""Contains a collection of basic calculations.
These include:
* wind components
* heat index
* windchill
"""
import warnings
import numpy as np
from scip... | [
"numpy.abs",
"numpy.sqrt",
"numpy.asarray",
"numpy.any",
"numpy.exp",
"numpy.array",
"numpy.arctan2",
"numpy.isnan",
"numpy.cos",
"numpy.sin",
"numpy.shape"
] | [((1176, 1198), 'numpy.sqrt', 'np.sqrt', (['(u * u + v * v)'], {}), '(u * u + v * v)\n', (1183, 1198), True, 'import numpy as np\n'), ((2865, 2882), 'numpy.any', 'np.any', (['calm_mask'], {}), '(calm_mask)\n', (2871, 2882), True, 'import numpy as np\n'), ((8772, 8783), 'numpy.any', 'np.any', (['sel'], {}), '(sel)\n', (... |
from rest_framework.response import Response
from rest_framework.decorators import api_view
from rest_framework.reverse import reverse
from rest_framework_simplejwt.tokens import RefreshToken
@api_view(['GET'])
def root(request, fmt=None):
return Response({
'v1': reverse('api_v1:root', request=request, fo... | [
"rest_framework.response.Response",
"rest_framework.decorators.api_view",
"rest_framework.reverse.reverse"
] | [((195, 212), 'rest_framework.decorators.api_view', 'api_view', (["['GET']"], {}), "(['GET'])\n", (203, 212), False, 'from rest_framework.decorators import api_view\n'), ((341, 358), 'rest_framework.decorators.api_view', 'api_view', (["['GET']"], {}), "(['GET'])\n", (349, 358), False, 'from rest_framework.decorators im... |
#!/usr/bin/python3
"""
Author: <NAME>
Date: 20181013
Purpose: Send a Tweet with IP and MAC address of a Raspberry Pi
Install:
pip3 install tweepy
Usage:
python3 startuptweet.py 'this is my tweet'
"""
import tweepy
import sys
import socket
import subprocess
from uuid import getnode as get_mac
from datetime import da... | [
"subprocess.check_output",
"uuid.getnode",
"datetime.datetime.now",
"tweepy.API",
"socket.gethostname",
"tweepy.OAuthHandler"
] | [((667, 717), 'tweepy.OAuthHandler', 'tweepy.OAuthHandler', (['consumer_key', 'consumer_secret'], {}), '(consumer_key, consumer_secret)\n', (686, 717), False, 'import tweepy\n'), ((781, 797), 'tweepy.API', 'tweepy.API', (['auth'], {}), '(auth)\n', (791, 797), False, 'import tweepy\n'), ((861, 920), 'subprocess.check_ou... |
#!/usr/bin/python
from bs4 import BeautifulSoup
import sqlite3
class DB:
"""
Abstraction for the profile database
"""
def __init__(self, filename):
"""
Creates a new connection to the database
filename - The name of the database file to use
"""
self.Filename = ... | [
"sqlite3.connect"
] | [((355, 380), 'sqlite3.connect', 'sqlite3.connect', (['filename'], {}), '(filename)\n', (370, 380), False, 'import sqlite3\n')] |
"""Objects representing regions in space."""
import math
import random
import itertools
import numpy
import scipy.spatial
import shapely.geometry
import shapely.ops
from scenic.core.distributions import Samplable, RejectionException, needsSampling
from scenic.core.lazy_eval import valueInContext
from scenic.core.vec... | [
"random.triangular",
"scenic.core.vectors.OrientedVector",
"numpy.array",
"random.choices",
"scenic.core.lazy_eval.valueInContext",
"math.hypot",
"scenic.core.geometry.findMinMax",
"scenic.core.geometry.triangulatePolygon",
"scenic.core.type_support.toVector",
"scenic.core.geometry.hypot",
"scen... | [((739, 759), 'scenic.core.distributions.needsSampling', 'needsSampling', (['thing'], {}), '(thing)\n', (752, 759), False, 'from scenic.core.distributions import Samplable, RejectionException, needsSampling\n'), ((3511, 3571), 'scenic.core.type_support.toVector', 'toVector', (['thing', '""""X in Y" with X not an Object... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
import logging
import time
import json
import click
import matplotlib.pyplot as plt
import orangery as o
from orangery.cli import defaults, util
from orangery.tools.plotting import get_scale_factor
@click.command(options_metavar='<options>')
@click.argument(... | [
"click.Choice",
"matplotlib.rc",
"orangery.cli.defaults.codes.copy",
"orangery.group",
"orangery.Survey",
"orangery.Change",
"click.option",
"orangery.endpoints",
"orangery.Section",
"click.command",
"click.argument",
"click.Tuple",
"orangery.tools.plotting.get_scale_factor",
"matplotlib.p... | [((261, 303), 'click.command', 'click.command', ([], {'options_metavar': '"""<options>"""'}), "(options_metavar='<options>')\n", (274, 303), False, 'import click\n'), ((575, 628), 'click.argument', 'click.argument', (['"""fields"""'], {'nargs': '(1)', 'metavar': '"""<fields>"""'}), "('fields', nargs=1, metavar='<fields... |
import os, sys
DICTIONARY_FILE = os.path.join(sys.prefix, 'dictionaries/ice_pron_dict_standard_clear.csv')
HEAD_FILE = os.path.join(sys.prefix, 'data/head_map.csv')
MODIFIER_FILE = os.path.join(sys.prefix, 'data/modifier_map.csv')
VOWELS_FILE = os.path.join(sys.prefix, 'data/vowels_sampa.txt')
CONS_CLUSTERS_FILE = os.p... | [
"os.path.join"
] | [((33, 106), 'os.path.join', 'os.path.join', (['sys.prefix', '"""dictionaries/ice_pron_dict_standard_clear.csv"""'], {}), "(sys.prefix, 'dictionaries/ice_pron_dict_standard_clear.csv')\n", (45, 106), False, 'import os, sys\n'), ((119, 164), 'os.path.join', 'os.path.join', (['sys.prefix', '"""data/head_map.csv"""'], {})... |
from pylabelbuddy import _annotations_notebook
def test_annotations_notebook(root, annotations_mock, dataset_mock):
nb = _annotations_notebook.AnnotationsNotebook(
root, annotations_mock, dataset_mock
)
nb.change_database()
assert nb.notebook.index(nb.notebook.select()) == 2
nb.go_to_annot... | [
"pylabelbuddy._annotations_notebook.AnnotationsNotebook"
] | [((127, 206), 'pylabelbuddy._annotations_notebook.AnnotationsNotebook', '_annotations_notebook.AnnotationsNotebook', (['root', 'annotations_mock', 'dataset_mock'], {}), '(root, annotations_mock, dataset_mock)\n', (168, 206), False, 'from pylabelbuddy import _annotations_notebook\n')] |
# (C) Datadog, Inc. 2019-present
# All rights reserved
# Licensed under a 3-clause BSD style license (see LICENSE)
import pytest
from mock import MagicMock
from requests import HTTPError
from datadog_checks.base import AgentCheck
from datadog_checks.dev.http import MockResponse
from .common import HARBOR_COMPONENTS, ... | [
"datadog_checks.dev.http.MockResponse",
"pytest.raises",
"pytest.mark.usefixtures",
"pytest.mark.skipif",
"mock.MagicMock"
] | [((377, 418), 'pytest.mark.usefixtures', 'pytest.mark.usefixtures', (['"""patch_requests"""'], {}), "('patch_requests')\n", (400, 418), False, 'import pytest\n'), ((1311, 1352), 'pytest.mark.usefixtures', 'pytest.mark.usefixtures', (['"""patch_requests"""'], {}), "('patch_requests')\n", (1334, 1352), False, 'import pyt... |
# Copyright 2012 Nebula, Inc.
#
# 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 agree... | [
"vsm_dashboard.api.swift.StorageObject"
] | [((1295, 1357), 'vsm_dashboard.api.swift.StorageObject', 'swift.StorageObject', (['obj_dict', 'container_1.name'], {'data': 'obj_data'}), '(obj_dict, container_1.name, data=obj_data)\n', (1314, 1357), False, 'from vsm_dashboard.api import swift\n')] |
# Copyright (C) 2013 Deutsche Telekom AG
# 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 r... | [
"cinder.exception.EncryptedBackupOperationFailed",
"six.add_metaclass",
"oslo_config.cfg.IntOpt",
"cinder.i18n._",
"cinder.exception.BackupMetadataUnsupportedVersion",
"oslo_serialization.jsonutils.dumps",
"cinder.keymgr.API",
"oslo_serialization.jsonutils.loads",
"oslo_log.log.getLogger"
] | [((1707, 1734), 'oslo_log.log.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1724, 1734), True, 'from oslo_log import log as logging\n'), ((14479, 14509), 'six.add_metaclass', 'six.add_metaclass', (['abc.ABCMeta'], {}), '(abc.ABCMeta)\n', (14496, 14509), False, 'import six\n'), ((17554, 17584), '... |
import unittest
from QuerySciGraph import QuerySciGraph
class QuerySciGraphTestCase(unittest.TestCase):
def test_get_disont_ids_for_mesh_id(self):
disont_ids = QuerySciGraph.get_disont_ids_for_mesh_id('MESH:D005199')
known_ids = {'DOID:13636'}
self.assertSetEqual(disont_ids, known_ids)
... | [
"unittest.main",
"QuerySciGraph.QuerySciGraph.query_sub_phenotypes_for_phenotype",
"QuerySciGraph.QuerySciGraph.get_disont_ids_for_mesh_id"
] | [((1130, 1145), 'unittest.main', 'unittest.main', ([], {}), '()\n', (1143, 1145), False, 'import unittest\n'), ((174, 230), 'QuerySciGraph.QuerySciGraph.get_disont_ids_for_mesh_id', 'QuerySciGraph.get_disont_ids_for_mesh_id', (['"""MESH:D005199"""'], {}), "('MESH:D005199')\n", (214, 230), False, 'from QuerySciGraph imp... |
from typing import Any
from ledis import Ledis
from ledis.exceptions import InvalidUsage
class CLI:
__slots__ = {"ledis", "commands"}
def __init__(self):
self.ledis = Ledis()
self.commands = {
"set": self.ledis.set,
"get": self.ledis.get,
"sadd": self.ledi... | [
"ledis.Ledis",
"ledis.exceptions.InvalidUsage"
] | [((187, 194), 'ledis.Ledis', 'Ledis', ([], {}), '()\n', (192, 194), False, 'from ledis import Ledis\n'), ((1048, 1147), 'ledis.exceptions.InvalidUsage', 'InvalidUsage', (['f"""Command \'{command}\' is invalid. Allowed commands are {allowed_commands}."""'], {}), '(\n f"Command \'{command}\' is invalid. Allowed comman... |
#group 1: Question 1(b)
# A control system for positioning the head of a laser printer has the closed loop transfer function:
# !pip install control
import matplotlib.pyplot as plt
import control
a=10 #Value for a
b=50 #value for b
sys1 = control.tf(20*b,[1,20+a,b+20*a,20*b])
print('3rd order system transfer funct... | [
"matplotlib.pyplot.grid",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.title",
"control.tf",
"control.step_response",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.show"
] | [((244, 295), 'control.tf', 'control.tf', (['(20 * b)', '[1, 20 + a, b + 20 * a, 20 * b]'], {}), '(20 * b, [1, 20 + a, b + 20 * a, 20 * b])\n', (254, 295), False, 'import control\n'), ((343, 367), 'control.tf', 'control.tf', (['b', '[1, a, b]'], {}), '(b, [1, a, b])\n', (353, 367), False, 'import control\n'), ((523, 55... |
import re
from precise_bbcode.bbcode.tag import BBCodeTag
from precise_bbcode.tag_pool import tag_pool
color_re = re.compile(r'^([a-z]+|#[0-9abcdefABCDEF]{3,6})$')
class SubTag(BBCodeTag):
name = 'sub'
def render(self, value, option=None, parent=None):
return '<sub>%s</sub>' % value
class PreTag... | [
"precise_bbcode.tag_pool.tag_pool.register_tag",
"re.search",
"re.compile"
] | [((117, 165), 're.compile', 're.compile', (['"""^([a-z]+|#[0-9abcdefABCDEF]{3,6})$"""'], {}), "('^([a-z]+|#[0-9abcdefABCDEF]{3,6})$')\n", (127, 165), False, 'import re\n'), ((1716, 1745), 'precise_bbcode.tag_pool.tag_pool.register_tag', 'tag_pool.register_tag', (['SubTag'], {}), '(SubTag)\n', (1737, 1745), False, 'from... |
## Program: VMTK
## Language: Python
## Date: January 10, 2018
## Version: 1.4
## Copyright (c) <NAME>, <NAME>, All rights reserved.
## See LICENSE file for details.
## This software is distributed WITHOUT ANY WARRANTY; without even
## the implied warranty of MERCHANTABILITY or FITNESS FOR A PAR... | [
"pytest.mark.parametrize",
"vmtk.vmtksurfacescaling.vmtkSurfaceScaling"
] | [((873, 1064), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""xfactor,yfactor,zfactor,paramid"""', "[(2, None, None, '0'), (None, 2, None, '1'), (None, None, 2, '2'), (2, 2,\n None, '3'), (2, None, 2, '4'), (None, 2, 2, '5')]"], {}), "('xfactor,yfactor,zfactor,paramid', [(2, None, None,\n '0'), (None... |
#!/usr/bin/env python
"""Distribution functions
This module provides functions for dealing with normal distributions
and generating error maps.
When called directly as main, it allows for converting a threshold map
into an error map.
```
$ python -m mlcsim.dist --help
usage: dist.py [-h] [-b {1,2,3,4}] -f F [-o O]... | [
"numpy.ma.masked_outside",
"argparse.ArgumentParser",
"scipy.stats.norm",
"numpy.log",
"numpy.roots",
"json.load",
"pprint.pprint",
"json.dump"
] | [((1404, 1423), 'numpy.roots', 'np.roots', (['[a, b, c]'], {}), '([a, b, c])\n', (1412, 1423), True, 'import numpy as np\n'), ((1437, 1480), 'numpy.ma.masked_outside', 'np.ma.masked_outside', (['roots', 'mean_a', 'mean_b'], {}), '(roots, mean_a, mean_b)\n', (1457, 1480), True, 'import numpy as np\n'), ((3098, 3123), 'a... |
import pytest
from playhouse.test_utils import assert_query_count
from data.registry_model import registry_model
from data.database import Manifest
from endpoints.api.test.shared import conduct_api_call
from endpoints.test.shared import client_with_identity
from endpoints.api.tag import RepositoryTag, RestoreTag, Li... | [
"data.registry_model.registry_model.list_repository_tag_history",
"playhouse.test_utils.assert_query_count",
"data.registry_model.registry_model.get_repo_tag",
"data.registry_model.registry_model.lookup_repository",
"pytest.mark.parametrize",
"endpoints.test.shared.client_with_identity",
"pytest.raises"... | [((369, 468), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""expiration_time, expected_status"""', "[(None, 201), ('aksdjhasd', 400)]"], {}), "('expiration_time, expected_status', [(None, 201), (\n 'aksdjhasd', 400)])\n", (392, 468), False, 'import pytest\n'), ((1609, 2020), 'pytest.mark.parametrize', '... |
import json
import os
import random
import requests
from passlib.hash import pbkdf2_sha256 as pbk
from PyQt5.QtSql import QSqlDatabase, QSqlQuery
from pprint import pprint
ENCODING = 'utf-8'
DB_PATH = os.path.join(os.path.curdir, 'inventory.db')
def scrambleWord(word):
"""Randomize the letters in word and retur... | [
"PyQt5.QtSql.QSqlQuery",
"random.choice",
"passlib.hash.pbkdf2_sha256.hash",
"random.shuffle",
"passlib.hash.pbkdf2_sha256.verify",
"json.dumps",
"os.path.join",
"requests.get",
"random.seed",
"PyQt5.QtSql.QSqlDatabase.lastError",
"PyQt5.QtSql.QSqlDatabase.addDatabase",
"json.load",
"random.... | [((203, 247), 'os.path.join', 'os.path.join', (['os.path.curdir', '"""inventory.db"""'], {}), "(os.path.curdir, 'inventory.db')\n", (215, 247), False, 'import os\n'), ((378, 403), 'random.shuffle', 'random.shuffle', (['word_list'], {}), '(word_list)\n', (392, 403), False, 'import random\n'), ((768, 828), 'requests.get'... |
import requests
from flask import abort, redirect, request, url_for
from lnurl import LnurlWithdrawResponse, handle as handle_lnurl
from lnurl.exceptions import LnurlException
from time import sleep
from lnbits.core import core_app
from lnbits.helpers import Status
from lnbits.settings import WALLET
from ..crud impo... | [
"flask.request.args.get",
"lnbits.settings.WALLET.get_invoice_status",
"requests.get",
"time.sleep",
"flask.url_for",
"flask.abort",
"lnbits.core.core_app.route",
"lnbits.settings.WALLET.create_invoice"
] | [((382, 412), 'lnbits.core.core_app.route', 'core_app.route', (['"""/lnurlwallet"""'], {}), "('/lnurlwallet')\n", (396, 412), False, 'from lnbits.core import core_app\n'), ((961, 1103), 'requests.get', 'requests.get', (['withdraw_res.callback.base'], {'params': "{**withdraw_res.callback.query_params, **{'k1': withdraw_... |
# Import libraries
import argparse
from azureml.core import Run
import joblib
import json
import os
import pandas as pd
import shutil
# Import functions from train.py
from train import split_data, train_model, get_model_metrics
# Get the output folder for the model from the '--output_folder' parameter
parser = argpar... | [
"train.train_model",
"train.split_data",
"argparse.ArgumentParser",
"pandas.read_csv",
"os.makedirs",
"azureml.core.Run.get_context",
"train.get_model_metrics",
"json.load",
"joblib.dump"
] | [((314, 339), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (337, 339), False, 'import argparse\n'), ((546, 563), 'azureml.core.Run.get_context', 'Run.get_context', ([], {}), '()\n', (561, 563), False, 'from azureml.core import Run\n'), ((618, 678), 'pandas.read_csv', 'pd.read_csv', (['"""port... |
from lua_imports import lua_importer
lua_importer.register()
| [
"lua_imports.lua_importer.register"
] | [((38, 61), 'lua_imports.lua_importer.register', 'lua_importer.register', ([], {}), '()\n', (59, 61), False, 'from lua_imports import lua_importer\n')] |
from mock_gripper_op import MockGripType
from std_msgs.msg import Bool
from erdos.op import Op
from erdos.data_stream import DataStream
from erdos.message import Message
class MockGraspObjectOperator(Op):
"""
Sends a "close" action to the gripper.
"""
gripper_stream = "gripper-output-stream"
acti... | [
"erdos.message.Message",
"erdos.data_stream.DataStream",
"mock_gripper_op.MockGripType"
] | [((1648, 1669), 'mock_gripper_op.MockGripType', 'MockGripType', (['"""close"""'], {}), "('close')\n", (1660, 1669), False, 'from mock_gripper_op import MockGripType\n'), ((1695, 1736), 'erdos.message.Message', 'Message', (['mock_grasp_object', 'msg.timestamp'], {}), '(mock_grasp_object, msg.timestamp)\n', (1702, 1736),... |
import torch
import sys
import os
sys.path.append(os.getcwd())
from utils.helper_modules import Sequential2
from unimodals.common_models import Linear, MLP, MaxOut_MLP
from datasets.imdb.get_data import get_dataloader
from fusions.common_fusions import Concat
from objective_functions.objectives_for_supervised_learnin... | [
"unimodals.common_models.MaxOut_MLP",
"fusions.common_fusions.Concat",
"torch.load",
"os.getcwd",
"unimodals.common_models.Linear",
"training_structures.Supervised_Learning.train",
"datasets.imdb.get_data.get_dataloader",
"torch.nn.BCEWithLogitsLoss",
"unimodals.common_models.MLP"
] | [((515, 611), 'datasets.imdb.get_data.get_dataloader', 'get_dataloader', (['"""../video/multimodal_imdb.hdf5"""', '"""../video/mmimdb"""'], {'vgg': '(True)', 'batch_size': '(128)'}), "('../video/multimodal_imdb.hdf5', '../video/mmimdb', vgg=True,\n batch_size=128)\n", (529, 611), False, 'from datasets.imdb.get_data ... |
# Generated by Django 4.0.2 on 2022-06-01 04:43
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
migrations.CreateModel(
name='Channel',
fields=[
... | [
"django.db.models.ForeignKey",
"django.db.models.CharField",
"django.db.models.BigAutoField",
"django.db.models.BooleanField"
] | [((336, 432), 'django.db.models.BigAutoField', 'models.BigAutoField', ([], {'auto_created': '(True)', 'primary_key': '(True)', 'serialize': '(False)', 'verbose_name': '"""ID"""'}), "(auto_created=True, primary_key=True, serialize=False,\n verbose_name='ID')\n", (355, 432), False, 'from django.db import migrations, m... |
import matplotlib.pyplot as plt
import math
xtab = []
ytab = []
for i in range(0, 628):
# Calculate polar coordinates for provided equation
phi = float(i) / 100.0
r = 4 * math.cos(2 * phi)
# Convert to Cartesian and store in lists
x = r * math.cos(phi)
y = r * math.sin(phi)
xtab.append(x)... | [
"math.cos",
"math.sin",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.show"
] | [((341, 361), 'matplotlib.pyplot.plot', 'plt.plot', (['xtab', 'ytab'], {}), '(xtab, ytab)\n', (349, 361), True, 'import matplotlib.pyplot as plt\n'), ((362, 372), 'matplotlib.pyplot.show', 'plt.show', ([], {}), '()\n', (370, 372), True, 'import matplotlib.pyplot as plt\n'), ((186, 203), 'math.cos', 'math.cos', (['(2 * ... |
# Copyright (c) 2003-2010 LOGILAB S.A. (Paris, FRANCE).
# http://www.logilab.fr/ -- mailto:<EMAIL>
#
# This program is free software; you can redistribute it and/or modify it under
# the terms of the GNU Lesser General Public License as published by the Free Software
# Foundation; either version 2 of the License, or (a... | [
"os.path.join"
] | [((2947, 2976), 'os.path.join', 'join', (['"""test"""', '"""regrtest_data"""'], {}), "('test', 'regrtest_data')\n", (2951, 2976), False, 'from os.path import join\n'), ((2994, 3014), 'os.path.join', 'join', (['"""test"""', '"""data"""'], {}), "('test', 'data')\n", (2998, 3014), False, 'from os.path import join\n'), ((3... |
import fire
import gtfparse
from pathlib import Path
GENCODE_CATEGORY_MAP = {
'IG_C_gene': 'protein_coding',
'IG_D_gene': 'protein_coding',
'IG_J_gene': 'protein_coding',
'IG_V_gene': 'protein_coding',
'IG_LV_gene': 'protein_coding',
'TR_C_gene': 'protein_coding',
'TR_J_gene': 'protein_cod... | [
"gtfparse.read_gtf",
"fire.Fire",
"pathlib.Path"
] | [((3371, 3393), 'gtfparse.read_gtf', 'gtfparse.read_gtf', (['gtf'], {}), '(gtf)\n', (3388, 3393), False, 'import gtfparse\n'), ((3969, 3981), 'pathlib.Path', 'Path', (['outdir'], {}), '(outdir)\n', (3973, 3981), False, 'from pathlib import Path\n'), ((4318, 4338), 'fire.Fire', 'fire.Fire', (['split_gtf'], {}), '(split_... |
import math
class Q(object):
def __init__(self,a,b=1):
gcd=math.gcd(a,b)
self.a=a//gcd
self.b=b//gcd
def __repr__(self):
if self.b==1:
return str(self.a)
return f'{self.a}/{self.b}'
def __add__(self,q):
a=self.a
b=self.b... | [
"math.gcd"
] | [((76, 90), 'math.gcd', 'math.gcd', (['a', 'b'], {}), '(a, b)\n', (84, 90), False, 'import math\n')] |
from __future__ import unicode_literals
import glob
import os
from dbdiff.fixture import Fixture
from .base import TestImportBase, FixtureDir
from ..settings import DATA_DIR
class TestImport(TestImportBase):
"""Load test."""
def test_single_city(self):
"""Load single city."""
fixture_dir = ... | [
"os.path.join",
"os.remove"
] | [((743, 784), 'os.path.join', 'os.path.join', (['DATA_DIR', '"""angouleme_*.txt"""'], {}), "(DATA_DIR, 'angouleme_*.txt')\n", (755, 784), False, 'import os\n'), ((825, 837), 'os.remove', 'os.remove', (['f'], {}), '(f)\n', (834, 837), False, 'import os\n')] |
from sklearn.mixture import GaussianMixture
import operator
import numpy as np
import math
class GMMSet:
def __init__(self, gmm_order = 32):
self.gmms = []
self.gmm_order = gmm_order
self.y = []
def fit_new(self, x, label):
self.y.append(label)
gmm = GaussianM... | [
"operator.itemgetter",
"math.exp",
"sklearn.mixture.GaussianMixture"
] | [((311, 342), 'sklearn.mixture.GaussianMixture', 'GaussianMixture', (['self.gmm_order'], {}), '(self.gmm_order)\n', (326, 342), False, 'from sklearn.mixture import GaussianMixture\n'), ((532, 543), 'math.exp', 'math.exp', (['i'], {}), '(i)\n', (540, 543), False, 'import math\n'), ((798, 820), 'operator.itemgetter', 'op... |
from typing import Sequence
from eth.constants import ZERO_HASH32
from eth_typing import Hash32
import ssz
from ssz.sedes import Vector, bytes32
from eth2.configs import Eth2Config
from .defaults import default_tuple, default_tuple_of_size
class HistoricalBatch(ssz.Serializable):
fields = [("block_roots", Vec... | [
"ssz.sedes.Vector"
] | [((317, 335), 'ssz.sedes.Vector', 'Vector', (['bytes32', '(1)'], {}), '(bytes32, 1)\n', (323, 335), False, 'from ssz.sedes import Vector, bytes32\n'), ((354, 372), 'ssz.sedes.Vector', 'Vector', (['bytes32', '(1)'], {}), '(bytes32, 1)\n', (360, 372), False, 'from ssz.sedes import Vector, bytes32\n')] |
import os
from pydantic import BaseSettings
class Settings(BaseSettings):
DEBUG: bool
DATABASE_URL: str
class Config:
env_file = os.getenv("CONFIG_FILE", ".env")
| [
"os.getenv"
] | [((153, 185), 'os.getenv', 'os.getenv', (['"""CONFIG_FILE"""', '""".env"""'], {}), "('CONFIG_FILE', '.env')\n", (162, 185), False, 'import os\n')] |
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import itertools as it
from django.db import models, migrations
def convert_status(apps, schema_editor):
''' Migrate Visit.skipped and ScheduledPhoneCall.skipped -> status
(pending,missed,deleted,attended)
'''
Visit = apps.get_model(... | [
"django.db.migrations.RunPython"
] | [((1395, 1449), 'django.db.migrations.RunPython', 'migrations.RunPython', (['convert_status', 'unconvert_status'], {}), '(convert_status, unconvert_status)\n', (1415, 1449), False, 'from django.db import models, migrations\n')] |
import os
import sys
from datetime import time
import unittest
sys.path.append(
os.path.dirname(
os.path.dirname(os.path.join("..", "..", "..", os.path.dirname("__file__")))
)
)
from core.controller import BaseTimeRangeController
class TestTimeRangeController(unittest.TestCase):
def test_time_ran... | [
"unittest.main",
"core.controller.BaseTimeRangeController",
"os.path.dirname",
"datetime.time"
] | [((797, 812), 'unittest.main', 'unittest.main', ([], {}), '()\n', (810, 812), False, 'import unittest\n'), ((349, 363), 'datetime.time', 'time', (['(10)', '(0)', '(0)'], {}), '(10, 0, 0)\n', (353, 363), False, 'from datetime import time\n'), ((381, 395), 'datetime.time', 'time', (['(12)', '(0)', '(0)'], {}), '(12, 0, 0... |
# -*- coding: utf-8 -*-
import json
import os
import pyminifier
try:
import io as StringIO
except ImportError:
import cStringIO as StringIO # lint:ok
# Check to see if slimit or some other minification library is installed and
# Set minify equal to slimit's minify function.
try:
import slimit
js_mi... | [
"json.dumps",
"os.path.splitext",
"os.path.join",
"pyminifier.remove_comments_and_docstrings",
"os.getcwd",
"os.path.dirname",
"pyminifier.dedent"
] | [((665, 690), 'os.path.dirname', 'os.path.dirname', (['filename'], {}), '(filename)\n', (680, 690), False, 'import os\n'), ((3962, 3987), 'os.path.dirname', 'os.path.dirname', (['filename'], {}), '(filename)\n', (3977, 3987), False, 'import os\n'), ((6872, 6883), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (6881, 6883)... |
#
import os
TEST_DIR = os.path.abspath(os.path.dirname(__file__))
| [
"os.path.dirname"
] | [((40, 65), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (55, 65), False, 'import os\n')] |
from __future__ import print_function
import argparse
import os
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.autograd import Variable
from torchvision import datasets, transforms
from tqdm import tqdm
from pyromancy import pyromq
from pyromancy.losses import LossGroup, NegativeLogLik... | [
"torch.cuda.is_available",
"pyromancy.pyromq.TrainingEventPublisher",
"pyromancy.losses.LossGroup",
"argparse.ArgumentParser",
"torchvision.transforms.ToTensor",
"torch.autograd.Variable",
"torch.nn.Dropout2d",
"torch.nn.functional.dropout",
"pyromancy.metrics.Accuracy",
"torch.nn.functional.log_s... | [((485, 545), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""PyTorch MNIST Example"""'}), "(description='PyTorch MNIST Example')\n", (508, 545), False, 'import argparse\n'), ((2616, 2631), 'pyromancy.pyromq.Broker', 'pyromq.Broker', ([], {}), '()\n', (2629, 2631), False, 'from pyromancy ... |
import argparse
import copy
import logging
import sys
from dataclasses import dataclass
from datetime import datetime, timedelta
from slack_sdk import WebClient
from typing import Dict, Optional, List
import pytz
from hunter import config
from hunter.attributes import get_back_links
from hunter.config import ConfigEr... | [
"slack_sdk.WebClient",
"hunter.attributes.get_back_links",
"hunter.util.interpolate",
"copy.deepcopy",
"hunter.grafana.GrafanaError",
"datetime.timedelta",
"logging.error",
"logging.info",
"hunter.report.Report",
"argparse.ArgumentParser",
"hunter.util.parse_datetime",
"logging.warning",
"hu... | [((14875, 14889), 'hunter.data_selector.DataSelector', 'DataSelector', ([], {}), '()\n', (14887, 14889), False, 'from hunter.data_selector import DataSelector\n'), ((17254, 17271), 'hunter.series.AnalysisOptions', 'AnalysisOptions', ([], {}), '()\n', (17269, 17271), False, 'from hunter.series import AnalysisOptions, Ch... |
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License.
# -*- coding: utf-8 -*-
#
# Configuration file for the Sphinx documentation builder.
import os
import sys
import shutil
# Check these extensions were installed.
import sphinx_gallery.gen_gallery
# The package should be insta... | [
"os.path.exists",
"os.path.join",
"os.path.split",
"os.path.dirname",
"shutil.copy",
"sphinx_modern_theme.get_html_theme_path"
] | [((1554, 1595), 'sphinx_modern_theme.get_html_theme_path', 'sphinx_modern_theme.get_html_theme_path', ([], {}), '()\n', (1593, 1595), False, 'import sphinx_modern_theme\n'), ((2640, 2672), 'os.path.join', 'os.path.join', (['this', '"""model.onnx"""'], {}), "(this, 'model.onnx')\n", (2652, 2672), False, 'import os\n'), ... |
"""Traffic simulator code."""
import sys
from os import path
from traffic_sim.analysis import TrafficExperiment
from traffic_sim.console import console
if not __package__:
_path = path.realpath(path.abspath(__file__))
sys.path.insert(0, path.dirname(path.dirname(_path)))
def main():
"""Run code from CL... | [
"traffic_sim.analysis.TrafficExperiment",
"os.path.dirname",
"os.path.abspath",
"traffic_sim.console.console.log"
] | [((330, 356), 'traffic_sim.console.console.log', 'console.log', (['"""traffic sim"""'], {}), "('traffic sim')\n", (341, 356), False, 'from traffic_sim.console import console\n'), ((386, 472), 'traffic_sim.analysis.TrafficExperiment', 'TrafficExperiment', ([], {'experiments': '(100)', 'trials': 'num_trials', 'rows': '(1... |
#! /usr/bin/env python
# -*- coding: UTF-8 -*-
from __future__ import division,print_function,absolute_import,unicode_literals
import sys
import os
os.chdir(sys.path[0])
sys.path.append('/mnt/sda2/github/TSF1KEV/TSFpy')
from TSF_io import *
#from TSF_Forth import *
from TSF_shuffle import *
from TSF_match import *
fro... | [
"os.chdir",
"sys.path.append"
] | [((149, 170), 'os.chdir', 'os.chdir', (['sys.path[0]'], {}), '(sys.path[0])\n', (157, 170), False, 'import os\n'), ((171, 220), 'sys.path.append', 'sys.path.append', (['"""/mnt/sda2/github/TSF1KEV/TSFpy"""'], {}), "('/mnt/sda2/github/TSF1KEV/TSFpy')\n", (186, 220), False, 'import sys\n')] |
from pyatool import PYAToolkit
# 个性化的函数需要toolkit形参，即使不需要使用
def test_b(toolkit):
return 'i am test_b, running on {}'.format(toolkit.device_id)
# 封装adb命令成为方法
PYAToolkit.bind_cmd(func_name='test_a', command='shell pm list package | grep google')
# 或者绑定个性化的函数
PYAToolkit.bind_func(real_func=test_b)
# 是否需要log
PYAToo... | [
"pyatool.PYAToolkit.bind_func",
"pyatool.PYAToolkit",
"pyatool.PYAToolkit.switch_logger",
"pyatool.PYAToolkit.bind_cmd"
] | [((164, 255), 'pyatool.PYAToolkit.bind_cmd', 'PYAToolkit.bind_cmd', ([], {'func_name': '"""test_a"""', 'command': '"""shell pm list package | grep google"""'}), "(func_name='test_a', command=\n 'shell pm list package | grep google')\n", (183, 255), False, 'from pyatool import PYAToolkit\n'), ((264, 302), 'pyatool.PY... |
import random
import argparse
import numpy as np
import pandas as pd
import os
import time
import string
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.utils.data import DataLoader
from tqdm import tqdm
from model import WideResnet
from cifar import get_train_loader, get_val_loader
from ... | [
"torch.nn.CrossEntropyLoss",
"torch.max",
"numpy.argsort",
"lr_scheduler.WarmupCosineLrScheduler",
"torch.softmax",
"torch.sum",
"utils.CIFAR10Pair",
"numpy.save",
"os.path.exists",
"numpy.mean",
"argparse.ArgumentParser",
"torch.mean",
"torch.eye",
"os.mkdir",
"numpy.concatenate",
"pa... | [((454, 511), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '""" FixMatch Training"""'}), "(description=' FixMatch Training')\n", (477, 511), False, 'import argparse\n'), ((3352, 3363), 'time.time', 'time.time', ([], {}), '()\n', (3361, 3363), False, 'import time\n'), ((3430, 3456), 'os.pat... |
import pandas as pd
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
data = pd.read_csv("data.csv")
data.info()
"""
Data columns (total 33 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 id 569 no... | [
"numpy.abs",
"pandas.read_csv",
"matplotlib.pyplot.xticks",
"sklearn.model_selection.train_test_split",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"numpy.log",
"sklearn.linear_model.LogisticRegression",
"numpy.max",
"numpy.sum",
"numpy.zeros",
"numpy.do... | [((101, 124), 'pandas.read_csv', 'pd.read_csv', (['"""data.csv"""'], {}), "('data.csv')\n", (112, 124), True, 'import pandas as pd\n'), ((1836, 1902), 'sklearn.model_selection.train_test_split', 'train_test_split', (['x_normalized', 'y'], {'test_size': '(0.25)', 'random_state': '(42)'}), '(x_normalized, y, test_size=0.... |
import os
import numpy as np
import torch
import argparse
from hparams import create_hparams
from model import lcm
from train import load_model
from torch.utils.data import DataLoader
from reader import TextMelIDLoader, TextMelIDCollate, id2sp
from inference_utils import plot_data
parser = argparse.ArgumentParser()
p... | [
"os.path.exists",
"argparse.ArgumentParser",
"os.makedirs",
"train.load_model",
"torch.load",
"model.lcm",
"hparams.create_hparams",
"numpy.vstack",
"torch.utils.data.DataLoader",
"torch.no_grad",
"reader.TextMelIDLoader",
"inference_utils.plot_data",
"numpy.save"
] | [((293, 318), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (316, 318), False, 'import argparse\n'), ((638, 666), 'hparams.create_hparams', 'create_hparams', (['args.hparams'], {}), '(args.hparams)\n', (652, 666), False, 'from hparams import create_hparams\n'), ((676, 695), 'train.load_model',... |
import re
import math
class KVPart():
"""docstring for KVPart"""
def __init__(self, name, tab_count = 0):
#super(KVPart, self).__init__()
self.name = name
self.values = []
self.tab_count = tab_count
self.parent = None
self.master = False
def add_simple_value(self, value):
self.values.append(value)
... | [
"re.search",
"math.floor"
] | [((2506, 2541), 'math.floor', 'math.floor', (['((40 - new_position) / 5)'], {}), '((40 - new_position) / 5)\n', (2516, 2541), False, 'import math\n'), ((3583, 3613), 're.search', 're.search', (['quote_pattern', 'text'], {}), '(quote_pattern, text)\n', (3592, 3613), False, 'import re\n'), ((3629, 3658), 're.search', 're... |
#!/usr/bin/python
#
# This source file is part of appleseed.
# Visit http://appleseedhq.net/ for additional information and resources.
#
# This software is released under the MIT license.
#
# Copyright (c) 2014-2016 <NAME>, The appleseedhq Organization
#
# Permission is hereby granted, free of charge, to any person ob... | [
"os.path.exists",
"os.listdir",
"argparse.ArgumentParser",
"os.path.join",
"os.path.splitext",
"shutil.copyfile",
"os.mkdir",
"os.walk"
] | [((2218, 2253), 'os.path.join', 'os.path.join', (['parent_dir', '"""renders"""'], {}), "(parent_dir, 'renders')\n", (2230, 2253), False, 'import os\n'), ((2268, 2299), 'os.path.join', 'os.path.join', (['parent_dir', '"""ref"""'], {}), "(parent_dir, 'ref')\n", (2280, 2299), False, 'import os\n'), ((2346, 2369), 'os.list... |
from typing import List, Any
import time
from discord import Embed, Reaction
from utils import uniquify
# EMOJIS regional_indicator_A to regional_indicator_T
reaction_emojies = ['\U0001F1E6',
'\U0001F1E7',
'\U0001F1E8',
'\U0001F1E9',
'\U00... | [
"utils.uniquify",
"discord.Embed",
"time.time"
] | [((1275, 1286), 'time.time', 'time.time', ([], {}), '()\n', (1284, 1286), False, 'import time\n'), ((1314, 1325), 'time.time', 'time.time', ([], {}), '()\n', (1323, 1325), False, 'import time\n'), ((1386, 1403), 'utils.uniquify', 'uniquify', (['options'], {}), '(options)\n', (1394, 1403), False, 'from utils import uniq... |
import email.utils as em
import re
class Main():
def __init__(self):
self.n = int(input())
for i in range(self.n):
self.s = em.parseaddr(input())
if re.match(r'^[a-zA-Z](\w|-|\.|_)+@[a-zA-Z]+\.[a-zA-Z]{0,3}$', self.s[1]):
print(em.format... | [
"re.match",
"email.utils.formataddr"
] | [((216, 289), 're.match', 're.match', (['"""^[a-zA-Z](\\\\w|-|\\\\.|_)+@[a-zA-Z]+\\\\.[a-zA-Z]{0,3}$"""', 'self.s[1]'], {}), "('^[a-zA-Z](\\\\w|-|\\\\.|_)+@[a-zA-Z]+\\\\.[a-zA-Z]{0,3}$', self.s[1])\n", (224, 289), False, 'import re\n'), ((311, 332), 'email.utils.formataddr', 'em.formataddr', (['self.s'], {}), '(self.s)... |
# Author: <NAME> <<EMAIL>>
import numpy as np
from bolero.representation import BlackBoxBehavior
from bolero.representation import DMPBehavior as DMPBehaviorImpl
class DMPBehavior(BlackBoxBehavior):
"""Dynamical Movement Primitive.
Parameters
----------
execution_time : float, optional (default: 1)
... | [
"numpy.copy",
"numpy.empty",
"bolero.representation.DMPBehavior"
] | [((900, 967), 'bolero.representation.DMPBehavior', 'DMPBehaviorImpl', (['execution_time', 'dt', 'n_features', 'configuration_file'], {}), '(execution_time, dt, n_features, configuration_file)\n', (915, 967), True, 'from bolero.representation import DMPBehavior as DMPBehaviorImpl\n'), ((1340, 1367), 'numpy.empty', 'np.e... |
import logging.config
import tornado
from bitstampws import Client as Websocket
import lib.configs.logging
from lib.subscribers import SimpleLoggerSubscriber
logging.config.dictConfig(lib.configs.logging.d)
if __name__ == '__main__':
with Websocket() as client:
with SimpleLoggerSubscriber(client):
... | [
"bitstampws.Client",
"lib.subscribers.SimpleLoggerSubscriber",
"tornado.ioloop.IOLoop.instance"
] | [((248, 259), 'bitstampws.Client', 'Websocket', ([], {}), '()\n', (257, 259), True, 'from bitstampws import Client as Websocket\n'), ((284, 314), 'lib.subscribers.SimpleLoggerSubscriber', 'SimpleLoggerSubscriber', (['client'], {}), '(client)\n', (306, 314), False, 'from lib.subscribers import SimpleLoggerSubscriber\n')... |
"""Generated client library for serviceuser version v1."""
# NOTE: This file is autogenerated and should not be edited by hand.
from apitools.base.py import base_api
from googlecloudsdk.third_party.apis.serviceuser.v1 import serviceuser_v1_messages as messages
class ServiceuserV1(base_api.BaseApiClient):
"""Generat... | [
"apitools.base.py.base_api.ApiMethodInfo"
] | [((2818, 3288), 'apitools.base.py.base_api.ApiMethodInfo', 'base_api.ApiMethodInfo', ([], {'http_method': 'u"""POST"""', 'method_id': 'u"""serviceuser.projects.services.disable"""', 'ordered_params': "[u'projectsId', u'servicesId']", 'path_params': "[u'projectsId', u'servicesId']", 'query_params': '[]', 'relative_path'... |
#!/usr/bin/env python3
# adapted from wav2letter/src/feature/test/MfccTest.cpp
import itertools as it
import os
import sys
from wav2letter.feature import FeatureParams, Mfcc
def load_data(filename):
path = os.path.join(data_path, filename)
path = os.path.abspath(path)
with open(path) as f:
retu... | [
"os.path.join",
"wav2letter.feature.FeatureParams",
"sys.exit",
"os.path.abspath",
"wav2letter.feature.Mfcc"
] | [((215, 248), 'os.path.join', 'os.path.join', (['data_path', 'filename'], {}), '(data_path, filename)\n', (227, 248), False, 'import os\n'), ((260, 281), 'os.path.abspath', 'os.path.abspath', (['path'], {}), '(path)\n', (275, 281), False, 'import os\n'), ((855, 870), 'wav2letter.feature.FeatureParams', 'FeatureParams',... |
#!/usr/bin/env python3
from urdf2optcontrol import optimizer
from matplotlib import pyplot as plt
import pathlib
# URDF options
urdf_path = pathlib.Path(__file__).parent.joinpath('urdf', 'rrbot.urdf').absolute()
root = "link1"
end = "link3"
in_cond = [0] * 4
def my_cost_func(q, qd, qdd, ee_pos, u, t):
return u.... | [
"urdf2optcontrol.optimizer.solve",
"urdf2optcontrol.optimizer.load_robot",
"pathlib.Path",
"urdf2optcontrol.optimizer.plot_result",
"urdf2optcontrol.optimizer.load_problem"
] | [((875, 917), 'urdf2optcontrol.optimizer.load_robot', 'optimizer.load_robot', (['urdf_path', 'root', 'end'], {}), '(urdf_path, root, end)\n', (895, 917), False, 'from urdf2optcontrol import optimizer\n'), ((952, 1123), 'urdf2optcontrol.optimizer.load_problem', 'optimizer.load_problem', (['my_cost_func', 'steps', 'in_co... |
# Copyright 2017 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... | [
"object_detection.core.box_list.BoxList"
] | [((2403, 2432), 'object_detection.core.box_list.BoxList', 'box_list.BoxList', (['box_corners'], {}), '(box_corners)\n', (2419, 2432), False, 'from object_detection.core import box_list\n')] |
from django.http import Http404
from django.shortcuts import render, redirect, reverse
from django.views.generic import ListView
from django.contrib.auth.decorators import login_required
from django.contrib.auth.mixins import LoginRequiredMixin
from django.contrib.auth.models import User
from rest_framework import st... | [
"django.shortcuts.render",
"pytz.timezone",
"rest_framework.response.Response",
"django.shortcuts.reverse",
"django.contrib.auth.models.User.objects.get"
] | [((1493, 1602), 'django.shortcuts.render', 'render', (['request', 'f"""dynamic_schemas/create-form.html"""', "{'form': form, 'schema': schema, 'help_urls': urls}"], {}), "(request, f'dynamic_schemas/create-form.html', {'form': form,\n 'schema': schema, 'help_urls': urls})\n", (1499, 1602), False, 'from django.shortc... |
from selenium import webdriver
from time import sleep
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.common.by import By
from selenium.webdriver.support.wait import WebDriverWait
def Dm(driver,user,message):
''' This functio... | [
"selenium.webdriver.support.wait.WebDriverWait",
"selenium.webdriver.support.expected_conditions.element_to_be_clickable"
] | [((678, 780), 'selenium.webdriver.support.expected_conditions.element_to_be_clickable', 'EC.element_to_be_clickable', (["(By.XPATH, '/html/body/div[5]/div/div/div[2]/div[1]/div/div[2]/input')"], {}), "((By.XPATH,\n '/html/body/div[5]/div/div/div[2]/div[1]/div/div[2]/input'))\n", (704, 780), True, 'from selenium.webd... |
# Script for data augmentation functions
import numpy as np
from collections import deque
from PIL import Image
import cv2
from data.config import *
def imread_cv2(image_path):
"""
Read image_path with cv2 format (H, W, C)
if image is '.gif' outputs is a numpy array of {0,1}
"""
image_format = ima... | [
"numpy.clip",
"PIL.Image.open",
"numpy.roll",
"numpy.flipud",
"numpy.random.random",
"numpy.fliplr",
"numpy.where",
"cv2.cvtColor",
"numpy.percentile",
"cv2.resize",
"cv2.imread",
"numpy.arange"
] | [((538, 589), 'cv2.resize', 'cv2.resize', (['image', '(width, heigh)', 'cv2.INTER_LINEAR'], {}), '(image, (width, heigh), cv2.INTER_LINEAR)\n', (548, 589), False, 'import cv2\n'), ((379, 401), 'cv2.imread', 'cv2.imread', (['image_path'], {}), '(image_path)\n', (389, 401), False, 'import cv2\n'), ((1257, 1275), 'numpy.r... |
### Load necessary libraries ###
import numpy as np
from sklearn.model_selection import KFold
from sklearn.metrics import accuracy_score
import tensorflow as tf
from tensorflow import keras
from sklearn.metrics import ConfusionMatrixDisplay
model = get_network()
model.summary()
### Train and evaluate via 10-Folds ... | [
"numpy.mean",
"sklearn.metrics.ConfusionMatrixDisplay.from_predictions",
"tensorflow.keras.callbacks.TensorBoard",
"numpy.unique",
"numpy.array",
"numpy.concatenate",
"sklearn.model_selection.KFold",
"sklearn.metrics.accuracy_score"
] | [((365, 470), 'numpy.array', 'np.array', (["['fold1', 'fold2', 'fold3', 'fold4', 'fold5', 'fold6', 'fold7', 'fold8',\n 'fold9', 'fold10']"], {}), "(['fold1', 'fold2', 'fold3', 'fold4', 'fold5', 'fold6', 'fold7',\n 'fold8', 'fold9', 'fold10'])\n", (373, 470), True, 'import numpy as np\n'), ((539, 557), 'sklearn.mo... |
import os
import pprint
import subprocess
import time
from typing import Dict, List
from kubernetes.client import (
V1EnvVar,
V1EnvVarSource,
V1ObjectFieldSelector,
V1ResourceFieldSelector,
)
from metaflow import FlowSpec, step, environment, resources, current
def get_env_vars(env_resources: Dict[st... | [
"subprocess.check_output",
"os.path.exists",
"os.environ.get",
"time.sleep",
"kubernetes.client.V1ObjectFieldSelector",
"metaflow.resources",
"kubernetes.client.V1ResourceFieldSelector",
"metaflow.environment"
] | [((2696, 2750), 'metaflow.resources', 'resources', ([], {'local_storage': '"""242"""', 'cpu': '"""0.6"""', 'memory': '"""1G"""'}), "(local_storage='242', cpu='0.6', memory='1G')\n", (2705, 2750), False, 'from metaflow import FlowSpec, step, environment, resources, current\n'), ((2787, 2857), 'metaflow.environment', 'en... |