code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
__author__ = 'kq4hy'
import csv
import sqlite3
def load_course_database(db_name, csv_filename):
conn = sqlite3.connect(db_name)
with conn:
curs = conn.cursor()
with open(csv_filename, 'rU') as csvfile:
reader = csv.reader(csvfile)
for row in reader:
sql... | [
"csv.reader",
"sqlite3.connect"
] | [((110, 134), 'sqlite3.connect', 'sqlite3.connect', (['db_name'], {}), '(db_name)\n', (125, 134), False, 'import sqlite3\n'), ((250, 269), 'csv.reader', 'csv.reader', (['csvfile'], {}), '(csvfile)\n', (260, 269), False, 'import csv\n')] |
#!/usr/bin/python
# -*- coding: utf-8 -*-
import time
from page_objects import PageObject, PageElement
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support.ui import WebDriverWait
from selenium.webdriver.support import expected_conditions
from selenium.webdriver.common.by import By
delay_mi... | [
"selenium.webdriver.support.expected_conditions.visibility_of",
"selenium.webdriver.support.ui.WebDriverWait",
"page_objects.PageElement"
] | [((439, 476), 'page_objects.PageElement', 'PageElement', ([], {'id_': '"""customer.firstName"""'}), "(id_='customer.firstName')\n", (450, 476), False, 'from page_objects import PageObject, PageElement\n'), ((502, 544), 'page_objects.PageElement', 'PageElement', ([], {'css': '"""input[value=\'Register\']"""'}), '(css="i... |
import torch
import torch.nn as nn
import numpy as np
from enum import Enum
from typing import List, Callable, Any
from tqdm import tqdm
from .model import Model
from .dataset import Dataset
from .experiment import Experiment
from .callback import Callback
class TrainingEvents(Enum):
START = 'on_start'
FINIS... | [
"torch.no_grad"
] | [((4372, 4387), 'torch.no_grad', 'torch.no_grad', ([], {}), '()\n', (4385, 4387), False, 'import torch\n'), ((5280, 5295), 'torch.no_grad', 'torch.no_grad', ([], {}), '()\n', (5293, 5295), False, 'import torch\n')] |
import unittest
from pystac.utils import (make_relative_href, make_absolute_href,
is_absolute_href)
class UtilsTest(unittest.TestCase):
def test_make_relative_href(self):
# Test cases of (source_href, start_href, expected)
test_cases = [
('/a/b/c/d/catalog.js... | [
"pystac.utils.make_absolute_href",
"pystac.utils.is_absolute_href",
"pystac.utils.make_relative_href"
] | [((1333, 1376), 'pystac.utils.make_relative_href', 'make_relative_href', (['source_href', 'start_href'], {}), '(source_href, start_href)\n', (1351, 1376), False, 'from pystac.utils import make_relative_href, make_absolute_href, is_absolute_href\n'), ((2421, 2464), 'pystac.utils.make_absolute_href', 'make_absolute_href'... |
from PyQt5.QtWidgets import QDialog, QPushButton, QVBoxLayout, QComboBox, QGroupBox, QCheckBox, QGridLayout, QMessageBox, QRadioButton
from GUI.CustomWidgets.PathFileLineEdit import PathFileLineEdit
from GUI.CustomWidgets.InputField import InputField
class ExportPopUp(QDialog):
def __init__(self, parent):
... | [
"PyQt5.QtWidgets.QComboBox",
"PyQt5.QtWidgets.QRadioButton",
"PyQt5.QtWidgets.QGridLayout",
"GUI.CustomWidgets.PathFileLineEdit.PathFileLineEdit",
"PyQt5.QtWidgets.QGroupBox",
"PyQt5.QtWidgets.QVBoxLayout",
"PyQt5.QtWidgets.QCheckBox",
"PyQt5.QtWidgets.QPushButton",
"PyQt5.QtWidgets.QMessageBox.warn... | [((627, 642), 'PyQt5.QtWidgets.QGroupBox', 'QGroupBox', (['self'], {}), '(self)\n', (636, 642), False, 'from PyQt5.QtWidgets import QDialog, QPushButton, QVBoxLayout, QComboBox, QGroupBox, QCheckBox, QGridLayout, QMessageBox, QRadioButton\n'), ((961, 987), 'PyQt5.QtWidgets.QComboBox', 'QComboBox', (['self.axis_group'],... |
import matplotlib.pyplot as plt
from matplotlib import collections
from matplotlib.lines import Line2D
def autosize(fig=None, figsize=None):
## Take current figure if no figure provided
if fig is None:
fig = plt.gcf()
if figsize is None:
## Get size of figure
figsize = fig.get_s... | [
"numpy.random.normal",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.gcf",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.tight_layout",
"numpy.random.uniform",
"matplotlib.pyplot.scatter",
"matplotlib.pyplot.title",
"plottify.autosize",
"matplotlib.pyplot.show"
] | [((1442, 1460), 'matplotlib.pyplot.tight_layout', 'plt.tight_layout', ([], {}), '()\n', (1458, 1460), True, 'import matplotlib.pyplot as plt\n'), ((1603, 1644), 'numpy.random.uniform', 'np.random.uniform', ([], {'low': '(-5)', 'high': '(5)', 'size': 'n'}), '(low=-5, high=5, size=n)\n', (1620, 1644), True, 'import numpy... |
from re import S
from manimlib import *
import sys
import os
from tqdm.std import tqdm
sys.path.append(os.getcwd())
from utils.imports import *
class Opening(Scene):
def construct(self):
title = Text("基础递推递归", font='msyh')
self.play(Write(title), run_time=2)
self.wait()
self.pla... | [
"os.getcwd"
] | [((106, 117), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (115, 117), False, 'import os\n')] |
import numpy as np
from time import time
import matplotlib.pyplot as plt
measure2index={"y-coordinate":0,"x-coordinate":1,"timestamp":2, "button_status":3,"tilt":4, "elevation":5,"pressure":6}
index2measure=list(measure2index.keys())
task2index={"spiral":0,"l":1,"le":2 ,"les":3,"lektorka" :4,"porovnat":5,"nepopadnout... | [
"numpy.identity",
"numpy.mean",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"numpy.floor",
"numpy.max",
"matplotlib.pyplot.subplot",
"numpy.array",
"matplotlib.pyplot.figure",
"numpy.around",
"numpy.min",
"time.time",
"matplotlib.pyplot.legend"
] | [((938, 952), 'numpy.identity', 'np.identity', (['(8)'], {}), '(8)\n', (949, 952), True, 'import numpy as np\n'), ((1071, 1092), 'numpy.array', 'np.array', (['downsampled'], {}), '(downsampled)\n', (1079, 1092), True, 'import numpy as np\n'), ((1295, 1314), 'numpy.array', 'np.array', (['upsampled'], {}), '(upsampled)\n... |
import datetime
datenasc = int(input(f'insert you date of bit '))
atualdate = str(datetime.date.today())[0:4]
datestr = int(atualdate)
datefinal = datestr - datenasc
print(datefinal)
if datefinal < 18:
print(f'voce esta com {datefinal}Faltam {18-datefinal} pra você se alistar ao exercito hahahah' )
elif datefinal =... | [
"datetime.date.today"
] | [((82, 103), 'datetime.date.today', 'datetime.date.today', ([], {}), '()\n', (101, 103), False, 'import datetime\n')] |
# Copyright 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless require... | [
"cross_compile.sysroot_compiler.SysrootCompiler",
"cross_compile.sysroot_compiler.DockerConfig",
"pytest.raises",
"cross_compile.sysroot_compiler.Platform",
"getpass.getuser"
] | [((1545, 1619), 'cross_compile.sysroot_compiler.Platform', 'Platform', ([], {'arch': '"""aarch64"""', 'os': '"""ubuntu"""', 'rosdistro': '"""dashing"""', 'rmw': '"""fastrtps"""'}), "(arch='aarch64', os='ubuntu', rosdistro='dashing', rmw='fastrtps')\n", (1553, 1619), False, 'from cross_compile.sysroot_compiler import Pl... |
import cx_Oracle
from oracledb import OracleJSONDatabaseConnection
import json
jsondb = OracleJSONDatabaseConnection()
connection = jsondb.get_connection()
connection.autocommit = True
soda = connection.getSodaDatabase()
x_collection = soda.createCollection('f1_2021_weather')
all_data = list()
for doc in x_collect... | [
"json.dumps",
"oracledb.OracleJSONDatabaseConnection"
] | [((90, 120), 'oracledb.OracleJSONDatabaseConnection', 'OracleJSONDatabaseConnection', ([], {}), '()\n', (118, 120), False, 'from oracledb import OracleJSONDatabaseConnection\n'), ((514, 544), 'json.dumps', 'json.dumps', (['all_data'], {'indent': '(4)'}), '(all_data, indent=4)\n', (524, 544), False, 'import json\n')] |
from Tkinter import *
import ttk
import BuyBook
import BookInformationPage
import Message
class UserPage(object):
def __init__(self, root, color, font, dbConnection, userInfo):
for child in root.winfo_children():
child.destroy()
self.root = root
self.color = color
sel... | [
"ttk.Treeview",
"BookInformationPage.BookInformation",
"BuyBook.BuyBook",
"ttk.Style"
] | [((5261, 5382), 'ttk.Treeview', 'ttk.Treeview', (['frame_middle'], {'columns': "('#1', '#2', '#3', '#4', '#5')", 'height': '(20)', 'show': '"""headings"""', 'padding': '(1, 1, 1, 1)'}), "(frame_middle, columns=('#1', '#2', '#3', '#4', '#5'), height=\n 20, show='headings', padding=(1, 1, 1, 1))\n", (5273, 5382), Fals... |
import os
import simplejson as json
def readJson(fileName):
test_filename = os.path.join(os.path.dirname(__file__), fileName)
with open(test_filename, mode='rb') as json_file:
return json.load(json_file)
| [
"simplejson.load",
"os.path.dirname"
] | [((95, 120), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (110, 120), False, 'import os\n'), ((201, 221), 'simplejson.load', 'json.load', (['json_file'], {}), '(json_file)\n', (210, 221), True, 'import simplejson as json\n')] |
#! /usr/bin/env python
# -*- coding: utf-8 -*-
import daiquiri
from time import time
import warp10client
LOG = daiquiri.getLogger(__name__)
warp10_api_url = '' # Add here backend url where metrics are stored
read_token = '' # Add here your metrics read token
write_token = '' # Add here your metrics write token
#... | [
"warp10client.Metric",
"daiquiri.getLogger",
"time.time",
"warp10client.Warp10Client"
] | [((113, 141), 'daiquiri.getLogger', 'daiquiri.getLogger', (['__name__'], {}), '(__name__)\n', (131, 141), False, 'import daiquiri\n'), ((1600, 1635), 'warp10client.Warp10Client', 'warp10client.Warp10Client', ([], {}), '(**kwargs)\n', (1625, 1635), False, 'import warp10client\n'), ((1839, 1874), 'warp10client.Metric', '... |
# -*- coding: utf-8 -*-
import logging
if __name__ == '__main__':
logging.basicConfig()
_log = logging.getLogger(__name__)
import pyxb.binding.generate
import pyxb.binding.datatypes as xs
import pyxb.binding.basis
import pyxb.utils.domutils
import os.path
xsd='''<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xm... | [
"logging.getLogger",
"unittest.main",
"logging.basicConfig"
] | [((99, 126), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (116, 126), False, 'import logging\n'), ((70, 91), 'logging.basicConfig', 'logging.basicConfig', ([], {}), '()\n', (89, 91), False, 'import logging\n'), ((677, 692), 'unittest.main', 'unittest.main', ([], {}), '()\n', (690, 692),... |
import sys
ii = int(sys.argv[1])
env = sys.argv[2]
# python3 print_data_structure.py 22 MD10
import glob
import os
import numpy as n
import EmergeIterate
iterate = EmergeIterate.EmergeIterate(ii, env)
iterate.open_snapshots()
def print_attr(h5item):
for attr in h5item:
print(attr, h5item[attr])
def print... | [
"EmergeIterate.EmergeIterate"
] | [((165, 201), 'EmergeIterate.EmergeIterate', 'EmergeIterate.EmergeIterate', (['ii', 'env'], {}), '(ii, env)\n', (192, 201), False, 'import EmergeIterate\n')] |
import pytest
import six
import ujson
import apache_beam as beam
from apache_beam.testing.test_pipeline import TestPipeline as _TestPipeline
from apache_beam.testing.util import assert_that
from apache_beam.testing.util import equal_to
from apache_beam.coders import typecoders
from apache_beam.typehints import Dict, U... | [
"pytest.mark.filterwarnings",
"pipe_tools.generator.MessageGenerator",
"apache_beam.Create",
"apache_beam.testing.test_pipeline.TestPipeline",
"pipe_tools.coders.JSONDictCoder"
] | [((491, 560), 'pytest.mark.filterwarnings', 'pytest.mark.filterwarnings', (['"""ignore:Using fallback coder:UserWarning"""'], {}), "('ignore:Using fallback coder:UserWarning')\n", (517, 560), False, 'import pytest\n'), ((562, 689), 'pytest.mark.filterwarnings', 'pytest.mark.filterwarnings', (['"""ignore:The compiler pa... |
#!/usr/bin/env python
"""Creates the JADE configuration for stage 2 of the demo pipeline."""
import os
import sys
from jade.models import PipelineConfig
from jade.utils.subprocess_manager import run_command
from jade.utils.utils import load_data
PRED_GDP_COMMANDS_FILE = "pred_gdp_commands.txt"
def main():
con... | [
"jade.utils.subprocess_manager.run_command",
"jade.utils.utils.load_data"
] | [((863, 879), 'jade.utils.subprocess_manager.run_command', 'run_command', (['cmd'], {}), '(cmd)\n', (874, 879), False, 'from jade.utils.subprocess_manager import run_command\n'), ((343, 393), 'jade.utils.utils.load_data', 'load_data', (["os.environ['JADE_PIPELINE_STATUS_FILE']"], {}), "(os.environ['JADE_PIPELINE_STATUS... |
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under t... | [
"hamal.conf.utils.fmt"
] | [((756, 927), 'hamal.conf.utils.fmt', 'utils.fmt', (['"""\nMaximum allowed length for user passwords. Decrease this value to improve\nperformance. Changing this value does not effect existing passwords.\n"""'], {}), '(\n """\nMaximum allowed length for user passwords. Decrease this value to improve\nperformance. Cha... |
# -*- coding: utf-8 -*-
# This code is licensed under the MIT License (see LICENSE file for details)
import platform
import datetime
import sys
import pathlib
import subprocess
import time
from .. import scope_job_runner
from ..config import scope_configuration
def main():
if len(sys.argv) == 2 and sys.argv[1] =... | [
"platform.node",
"pathlib.Path",
"subprocess.run",
"datetime.datetime.now",
"time.time"
] | [((761, 813), 'pathlib.Path', 'pathlib.Path', (['"""/etc/systemd/system/job_runner_check"""'], {}), "('/etc/systemd/system/job_runner_check')\n", (773, 813), False, 'import pathlib\n'), ((1089, 1157), 'subprocess.run', 'subprocess.run', (["['systemctl', 'enable', timer_file.name]"], {'check': '(True)'}), "(['systemctl'... |
from systems.plugins.index import BaseProvider
import os
class Provider(BaseProvider('task', 'upload')):
def execute(self, results, params):
file_path = self.get_path(self.field_file)
if not os.path.exists(file_path):
self.command.error("Upload task provider file {} does not exist".... | [
"os.path.exists",
"systems.plugins.index.BaseProvider"
] | [((75, 105), 'systems.plugins.index.BaseProvider', 'BaseProvider', (['"""task"""', '"""upload"""'], {}), "('task', 'upload')\n", (87, 105), False, 'from systems.plugins.index import BaseProvider\n'), ((216, 241), 'os.path.exists', 'os.path.exists', (['file_path'], {}), '(file_path)\n', (230, 241), False, 'import os\n')... |
# ============================================================================
# FILE: outline.py
# AUTHOR: <NAME> (tamura.yasumasa _at_ gmail.com)
# License: MIT license
# ============================================================================
from .base import Base
from subprocess import check_output, CalledPro... | [
"subprocess.check_output",
"re.match",
"tempfile.NamedTemporaryFile"
] | [((1558, 1627), 'tempfile.NamedTemporaryFile', 'tempfile.NamedTemporaryFile', ([], {'mode': '"""w"""', 'encoding': "self.vars['encoding']"}), "(mode='w', encoding=self.vars['encoding'])\n", (1585, 1627), False, 'import tempfile\n'), ((1952, 1970), 'subprocess.check_output', 'check_output', (['args'], {}), '(args)\n', (... |
from bs4 import BeautifulSoup
from django.db import models
from django.utils.translation import ugettext_lazy as _
from taggit.managers import TaggableManager
class Post(models.Model):
title = models.CharField(_('post_title'), max_length=100)
body = models.TextField(_('post_body'))
tags = TaggableManager(... | [
"bs4.BeautifulSoup",
"django.utils.translation.ugettext_lazy"
] | [((216, 231), 'django.utils.translation.ugettext_lazy', '_', (['"""post_title"""'], {}), "('post_title')\n", (217, 231), True, 'from django.utils.translation import ugettext_lazy as _\n'), ((277, 291), 'django.utils.translation.ugettext_lazy', '_', (['"""post_body"""'], {}), "('post_body')\n", (278, 291), True, 'from d... |
import os
from ..utils import add_jobs_argument
from ..utils import add_no_ccache_argument
from ..utils import add_optimize_argument
from ..utils import add_verbose_argument
from ..utils import build_prepare
from ..utils import run
def do_test(_parser, args, _mys_config):
build_prepare(args.verbose, args.optimiz... | [
"os.getenv"
] | [((429, 451), 'os.getenv', 'os.getenv', (['"""MAKEFLAGS"""'], {}), "('MAKEFLAGS')\n", (438, 451), False, 'import os\n')] |
import numpy as np
import torch
from torch_utils import training_stats
from torch_utils import misc
from torch_utils.ops import conv2d_gradfix
import torch.nn.functional as F
import torchvision.transforms as T
import clip
import dnnlib
import random
#--------------------------------------------------------------------... | [
"numpy.sqrt",
"torch.exp",
"torch.full_like",
"torch.autograd.profiler.record_function",
"torch.nn.functional.interpolate",
"torch.distributed.get_rank",
"torch_utils.training_stats.report",
"torch.nn.functional.softmax",
"torch.randint",
"torch.zeros_like",
"torch.randn",
"torch.distributed.a... | [((635, 661), 'torch.nn.Linear', 'torch.nn.Linear', (['(512)', '(1024)'], {}), '(512, 1024)\n', (650, 661), False, 'import torch\n'), ((685, 712), 'torch.nn.Linear', 'torch.nn.Linear', (['(1024)', '(1024)'], {}), '(1024, 1024)\n', (700, 712), False, 'import torch\n'), ((736, 763), 'torch.nn.Linear', 'torch.nn.Linear', ... |
from sklearn.model_selection import train_test_split
from sklearn import metrics
from sklearn.metrics import accuracy_score
from sklearn.metrics import roc_auc_score
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
def do_ml(merged_df, test_size, ml_model, **kwargs):
train_data = merged_df.d... | [
"matplotlib.pyplot.xticks",
"matplotlib.pyplot.show",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.rcParams.update",
"matplotlib.pyplot.figure",
"numpy.array",
"pandas.DataFrame",
"numpy.ravel",
"sklearn.metrics.accuracy_score",
"sklearn.metrics.confusion_matrix"
] | [((992, 1037), 'sklearn.metrics.confusion_matrix', 'metrics.confusion_matrix', (['y_test', 'predictions'], {}), '(y_test, predictions)\n', (1016, 1037), False, 'from sklearn import metrics\n'), ((1059, 1102), 'sklearn.metrics.accuracy_score', 'metrics.accuracy_score', (['y_test', 'predictions'], {}), '(y_test, predicti... |
# Copyright 2017 The Bazel 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 applicable la... | [
"os.path.exists",
"os.makedirs",
"re.compile",
"subprocess.Popen",
"os.access",
"os.path.join",
"os.getcwd",
"os.chdir",
"os.path.isfile",
"os.path.dirname",
"tempfile.mkdtemp",
"os.path.basename",
"shutil.copy",
"shutil.rmtree",
"fileinput.input",
"os.path.expanduser",
"third_party.... | [((985, 1061), 'third_party.py.gflags.DEFINE_string', 'gflags.DEFINE_string', (['"""name"""', '""""""', '"""The name of the software being packaged."""'], {}), "('name', '', 'The name of the software being packaged.')\n", (1005, 1061), False, 'from third_party.py import gflags\n'), ((1062, 1148), 'third_party.py.gflags... |
#!/usr/bin/env python
#
# Copyright (c) Microsoft Corporation.
# Licensed under the MIT License.
#
# Re-analyze all images that don't have latest version of the analysis available
from freta.api import Freta
def main():
freta = Freta()
versions = freta.versions()
for image in freta.image.list():
... | [
"freta.api.Freta"
] | [((235, 242), 'freta.api.Freta', 'Freta', ([], {}), '()\n', (240, 242), False, 'from freta.api import Freta\n')] |
import numpy as np
import tensorflow as tf
from keras import backend as K
from tqdm import tqdm
def write_log(callback, names, logs, batch_no):
for name, value in zip(names, logs):
summary = tf.Summary()
summary_value = summary.value.add()
summary_value.simple_value = value
... | [
"numpy.array",
"tqdm.tqdm",
"tensorflow.Summary",
"keras.backend.get_value"
] | [((211, 223), 'tensorflow.Summary', 'tf.Summary', ([], {}), '()\n', (221, 223), True, 'import tensorflow as tf\n'), ((730, 822), 'tqdm.tqdm', 'tqdm', ([], {'total': 'epoch_step', 'desc': 'f"""Epoch {epoch + 1}/{Epoch}"""', 'postfix': 'dict', 'mininterval': '(0.3)'}), "(total=epoch_step, desc=f'Epoch {epoch + 1}/{Epoch}... |
from mopidy_vfd import Extension
def test_get_default_config():
ext = Extension()
config = ext.get_default_config()
assert "[vfd]" in config
assert "enabled = true" in config
def test_get_config_schema():
ext = Extension()
schema = ext.get_config_schema()
assert "display" in schema
| [
"mopidy_vfd.Extension"
] | [((76, 87), 'mopidy_vfd.Extension', 'Extension', ([], {}), '()\n', (85, 87), False, 'from mopidy_vfd import Extension\n'), ((237, 248), 'mopidy_vfd.Extension', 'Extension', ([], {}), '()\n', (246, 248), False, 'from mopidy_vfd import Extension\n')] |
from http import HTTPStatus
import time
import logging
import pytest
import grequests
from flask import url_for
from eth_utils import (
to_checksum_address,
to_canonical_address,
is_checksum_address,
)
from raiden_contracts.constants import (
CONTRACT_HUMAN_STANDARD_TOKEN,
MAX_TOKENS_DEPLOY,
TE... | [
"raiden.tests.utils.smartcontracts.deploy_contract_web3",
"raiden.api.v1.encoding.HexAddressConverter",
"logging.debug",
"raiden.tests.utils.assert_dicts_are_equal",
"eth_utils.to_checksum_address",
"time.sleep",
"pytest.mark.parametrize",
"pytest.raises",
"raiden.api.v1.encoding.AddressField",
"r... | [((3759, 3806), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""number_of_nodes"""', '[1]'], {}), "('number_of_nodes', [1])\n", (3782, 3806), False, 'import pytest\n'), ((3808, 3857), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""channels_per_node"""', '[0]'], {}), "('channels_per_node', [0])\... |
import os
import argparse
from . import common
argparser = argparse.ArgumentParser(add_help=False)
graph_group = argparser.add_argument_group('graphtool arguments')
graph_group.add_argument('--graph-jar', metavar='<graphtool-jar>',
action='store',default=None, dest='graph_jar',
... | [
"os.makedirs",
"argparse.ArgumentParser",
"os.path.join",
"os.getcwd",
"os.path.isdir"
] | [((60, 99), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'add_help': '(False)'}), '(add_help=False)\n', (83, 99), False, 'import argparse\n'), ((579, 621), 'os.path.join', 'os.path.join', (['args.output_directory', '"""dot"""'], {}), "(args.output_directory, 'dot')\n", (591, 621), False, 'import os\n'), ... |
from django.urls import path
from .views import *
from django_filters.views import FilterView
app_name = 'jobs'
urlpatterns = [
path('', FilterView.as_view(filterset_class=JobFilter,
template_name='jobs/job_list.html'), name='index'),
path('companies/', CompanyListView.as_view(... | [
"django_filters.views.FilterView.as_view"
] | [((143, 229), 'django_filters.views.FilterView.as_view', 'FilterView.as_view', ([], {'filterset_class': 'JobFilter', 'template_name': '"""jobs/job_list.html"""'}), "(filterset_class=JobFilter, template_name=\n 'jobs/job_list.html')\n", (161, 229), False, 'from django_filters.views import FilterView\n')] |
from __future__ import print_function
from __future__ import absolute_import
from __future__ import division
from compas.geometry import transform_points_numpy
__all__ = [
'mesh_transform_numpy',
'mesh_transformed_numpy',
]
def mesh_transform_numpy(mesh, transformation):
"""Transform a mesh.
Param... | [
"compas.geometry.transform_points_numpy"
] | [((858, 901), 'compas.geometry.transform_points_numpy', 'transform_points_numpy', (['xyz', 'transformation'], {}), '(xyz, transformation)\n', (880, 901), False, 'from compas.geometry import transform_points_numpy\n')] |
from cereal import car
from common.realtime import DT_CTRL
from common.numpy_fast import interp
from common.realtime import sec_since_boot
from selfdrive.config import Conversions as CV
from selfdrive.car import apply_std_steer_torque_limits
from selfdrive.car.gm import gmcan
from selfdrive.car.gm.values import DBC, Ac... | [
"selfdrive.car.gm.values.CarControllerParams",
"selfdrive.car.gm.gmcan.create_steering_control",
"selfdrive.car.gm.gmcan.create_acc_dashboard_command",
"selfdrive.car.gm.gmcan.create_adas_steering_status",
"selfdrive.car.gm.gmcan.create_lka_icon_command",
"selfdrive.car.gm.gmcan.create_gas_regen_command",... | [((739, 760), 'selfdrive.car.gm.values.CarControllerParams', 'CarControllerParams', ([], {}), '()\n', (758, 760), False, 'from selfdrive.car.gm.values import DBC, AccState, CanBus, CarControllerParams\n'), ((783, 822), 'opendbc.can.packer.CANPacker', 'CANPacker', (["DBC[CP.carFingerprint]['pt']"], {}), "(DBC[CP.carFing... |
# Program name: atomic1D/reference/build_json.py
# Author: <NAME>
# Author email: <EMAIL>
# Date of creation: 14 July 2017
#
#
# Makes data_dict and copies it into a .json file 'sd1d-case-05.json'
filename = 'sd1d-case-05'
from boutdata.collect import collect
data_dict = {}
# Normalisation factor for temperature ... | [
"boutdata.collect.collect",
"json.dump",
"copy.deepcopy"
] | [((367, 383), 'boutdata.collect.collect', 'collect', (['"""Tnorm"""'], {}), "('Tnorm')\n", (374, 383), False, 'from boutdata.collect import collect\n'), ((468, 484), 'boutdata.collect.collect', 'collect', (['"""Nnorm"""'], {}), "('Nnorm')\n", (475, 484), False, 'from boutdata.collect import collect\n'), ((579, 591), 'b... |
# -*- coding: utf-8 -*-
"""
Created on Wed Sep 15 08:32:03 2021
@author: User
"""
import numpy as np
import matplotlib.pyplot as plt
a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print(a)
print(a[0])
print(a.ndim) #te dice la cantidad de ejes (o dimensiones) del arreglo
print(a.shape) #Te va a dar una t... | [
"numpy.random.random",
"numpy.array"
] | [((138, 193), 'numpy.array', 'np.array', (['[[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]'], {}), '([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])\n', (146, 193), True, 'import numpy as np\n'), ((577, 596), 'numpy.random.random', 'np.random.random', (['(3)'], {}), '(3)\n', (593, 596), True, 'import numpy as np\n')] |
''' Handles calibration library and calibration of subs.
'''
import os.path
import numpy as np
from scipy.stats import trimboth
from kivy.app import App
from loguru import logger
from kivy.properties import BooleanProperty, DictProperty, NumericProperty
from kivy.core.window import Window
from jocular.table import T... | [
"jocular.table.Table",
"kivy.properties.NumericProperty",
"loguru.logger.debug",
"jocular.image.fits_in_dir",
"jocular.image.save_image",
"jocular.component.Component.get",
"jocular.image.Image",
"kivy.properties.BooleanProperty",
"kivy.properties.DictProperty",
"kivy.app.App.get_running_app"
] | [((670, 686), 'kivy.properties.DictProperty', 'DictProperty', (['{}'], {}), '({})\n', (682, 686), False, 'from kivy.properties import BooleanProperty, DictProperty, NumericProperty\n'), ((704, 726), 'kivy.properties.BooleanProperty', 'BooleanProperty', (['(False)'], {}), '(False)\n', (719, 726), False, 'from kivy.prope... |
from typing import Tuple
import torch
class RunningMeanStd:
"""
Utility Function to compute a running mean and variance calculator
:param epsilon: Small number to prevent division by zero for calculations
:param shape: Shape of the RMS object
:type epsilon: float
:type shape: Tuple
"""
... | [
"torch.mean",
"torch.zeros",
"torch.var",
"torch.ones"
] | [((574, 599), 'torch.mean', 'torch.mean', (['batch'], {'axis': '(0)'}), '(batch, axis=0)\n', (584, 599), False, 'import torch\n'), ((620, 644), 'torch.var', 'torch.var', (['batch'], {'axis': '(0)'}), '(batch, axis=0)\n', (629, 644), False, 'import torch\n'), ((406, 424), 'torch.zeros', 'torch.zeros', (['shape'], {}), '... |
import mtoa.ui.ae.templates as templates
import pymel.core as pm
import maya.cmds as cmds
import mtoa.ui.ae.utils as aeUtils
class aiPotaTemplate(templates.AttributeTemplate):
"""
def filenameEditBokeh(self, mData) :
attr = self.nodeAttr('aiBokehEXRPath')
cmds.setAttr(attr,mData,type="string")
... | [
"mtoa.ui.ae.templates.registerTranslatorUI"
] | [((2688, 2752), 'mtoa.ui.ae.templates.registerTranslatorUI', 'templates.registerTranslatorUI', (['aiPotaTemplate', '"""camera"""', '"""pota"""'], {}), "(aiPotaTemplate, 'camera', 'pota')\n", (2718, 2752), True, 'import mtoa.ui.ae.templates as templates\n')] |
import base64
import json
from webhook import post_webhook
from datetime import datetime
def hello_pubsub(event, context):
"""Triggered from a message on a Cloud Pub/Sub topic.
Args:
event (dict): Event payload.
context (google.cloud.functions.Context): Metadata for the event.
"""
pubs... | [
"datetime.datetime.utcfromtimestamp",
"json.loads",
"webhook.post_webhook",
"base64.b64decode"
] | [((491, 517), 'json.loads', 'json.loads', (['pubsub_message'], {}), '(pubsub_message)\n', (501, 517), False, 'import json\n'), ((1226, 1326), 'webhook.post_webhook', 'post_webhook', ([], {'message': 'log_message', 'timestamp': 'timestamp', 'status': 'status', 'title': 'title', 'color': 'color'}), '(message=log_message,... |
import argparse, os, fnmatch, json, joblib
import pandas as pd
from sklearn.mixture import GaussianMixture
from sklearn.metrics import adjusted_rand_score
# Reference paper - https://arxiv.org/abs/1906.11373
# "Unsupervised Methods for Identifying Pass Coverage Among Defensive Backs with NFL Player Tracking Data"
STA... | [
"os.listdir",
"sklearn.mixture.GaussianMixture",
"argparse.ArgumentParser",
"pandas.read_csv",
"json.dumps",
"sklearn.metrics.adjusted_rand_score",
"os.path.join",
"os.path.abspath",
"json.load",
"pandas.DataFrame",
"joblib.dump"
] | [((654, 668), 'pandas.DataFrame', 'pd.DataFrame', ([], {}), '()\n', (666, 668), True, 'import pandas as pd\n'), ((1026, 1096), 'sklearn.mixture.GaussianMixture', 'GaussianMixture', ([], {'n_components': 'g', 'covariance_type': '"""full"""', 'max_iter': '(1000)'}), "(n_components=g, covariance_type='full', max_iter=1000... |
# Copyright 2016 The Johns Hopkins University Applied Physics Laboratory
#
# 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 ... | [
"bosscore.test.setup_db.SetupTestDB",
"bossingest.test.setup.SetupTests",
"bossingest.ingest_manager.IngestManager"
] | [((1262, 1275), 'bosscore.test.setup_db.SetupTestDB', 'SetupTestDB', ([], {}), '()\n', (1273, 1275), False, 'from bosscore.test.setup_db import SetupTestDB\n'), ((1522, 1534), 'bossingest.test.setup.SetupTests', 'SetupTests', ([], {}), '()\n', (1532, 1534), False, 'from bossingest.test.setup import SetupTests\n'), ((18... |
import calendar
from typing import Union
import dateutil.parser
from rest_framework import status
from rest_framework.response import Response
from django.utils.cache import get_conditional_response
from django.utils.http import http_date
from ..models import Resource, ResourceVersion
FhirResource = Union[Resource,... | [
"django.utils.cache.get_conditional_response",
"rest_framework.response.Response",
"django.utils.http.http_date"
] | [((751, 805), 'django.utils.cache.get_conditional_response', 'get_conditional_response', (['request', 'etag', 'last_modified'], {}), '(request, etag, last_modified)\n', (775, 805), False, 'from django.utils.cache import get_conditional_response\n'), ((1013, 1080), 'rest_framework.response.Response', 'Response', ([], {'... |
#!/usr/bin/env python
import json
from support import parse_states
import sys
import xapian
def index(datapath, dbpath):
# Create or open the database we're going to be writing to.
db = xapian.WritableDatabase(dbpath, xapian.DB_CREATE_OR_OPEN)
# Set up a TermGenerator that we'll use in indexing.
term... | [
"xapian.Stem",
"support.parse_states",
"json.dumps",
"xapian.WritableDatabase",
"sys.exit",
"xapian.TermGenerator",
"xapian.Document"
] | [((196, 253), 'xapian.WritableDatabase', 'xapian.WritableDatabase', (['dbpath', 'xapian.DB_CREATE_OR_OPEN'], {}), '(dbpath, xapian.DB_CREATE_OR_OPEN)\n', (219, 253), False, 'import xapian\n'), ((332, 354), 'xapian.TermGenerator', 'xapian.TermGenerator', ([], {}), '()\n', (352, 354), False, 'import xapian\n'), ((423, 44... |
import logging
import time
from selenium.common import exceptions
from selenium.webdriver.remote.webdriver import WebDriver
from selenium.webdriver.common import action_chains
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.support.ui import WebDriverWait
from selenium_utils i... | [
"logging.getLogger",
"selenium.webdriver.support.ui.WebDriverWait",
"selenium.webdriver.support.expected_conditions.invisibility_of_element_located",
"selenium.webdriver.support.expected_conditions.text_to_be_present_in_element",
"time.sleep",
"selenium.webdriver.support.expected_conditions.visibility_of_... | [((346, 373), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (363, 373), False, 'import logging\n'), ((780, 791), 'time.time', 'time.time', ([], {}), '()\n', (789, 791), False, 'import time\n'), ((3827, 3838), 'time.time', 'time.time', ([], {}), '()\n', (3836, 3838), False, 'import time\n... |
import os
import requests
import psycopg2
import db_lib as db
from app import send_message, log
from apscheduler.schedulers.blocking import BlockingScheduler
DATABASE_URL = os.environ['DATABASE_URL']
conn = psycopg2.connect(DATABASE_URL, sslmode='require')
def kitchen_reminder():
# fetch current status
status = d... | [
"psycopg2.connect",
"db_lib.getBoy",
"db_lib.changeDay",
"db_lib.getBoyNum",
"db_lib.getNextBoy",
"db_lib.updateBoy",
"db_lib.getNickname",
"db_lib.getStatus",
"apscheduler.schedulers.blocking.BlockingScheduler",
"app.send_message",
"app.log",
"db_lib.getAll"
] | [((209, 258), 'psycopg2.connect', 'psycopg2.connect', (['DATABASE_URL'], {'sslmode': '"""require"""'}), "(DATABASE_URL, sslmode='require')\n", (225, 258), False, 'import psycopg2\n'), ((1230, 1249), 'apscheduler.schedulers.blocking.BlockingScheduler', 'BlockingScheduler', ([], {}), '()\n', (1247, 1249), False, 'from ap... |
# -*- coding: utf-8 -*-
# Module: default
# Author: asciidisco
# Created on: 24.07.2017
# License: MIT https://goo.gl/WA1kby
"""Setup"""
from __future__ import unicode_literals
from os.path import abspath, dirname, join
from re import search
from sys import exit, version, version_info
from setuptools import find_pack... | [
"os.path.abspath",
"setuptools.find_packages",
"os.path.join",
"re.search"
] | [((377, 392), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (390, 392), False, 'from setuptools import find_packages, setup\n'), ((1193, 1220), 'os.path.join', 'join', (['root_dir', '"""addon.xml"""'], {}), "(root_dir, 'addon.xml')\n", (1197, 1220), False, 'from os.path import abspath, dirname, join\n'... |
import numpy as np
import os, sys
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
from tensorflow.keras.models import Model
import tensorflow as tf
from PIL import Image
from utils_rtp import ProMP
class Predictor:
def __init__(self, encoder_model_path, predictor_model_path):
self.all_phi = self.promp_train(... | [
"tensorflow.cast",
"numpy.transpose",
"utils_rtp.ProMP",
"numpy.hstack",
"numpy.zeros",
"tensorflow.keras.models.load_model",
"numpy.vstack",
"numpy.load",
"numpy.save"
] | [((2017, 2067), 'numpy.load', 'np.load', (['"""/home/arshad/catkin_ws/image_xy_rtp.npy"""'], {}), "('/home/arshad/catkin_ws/image_xy_rtp.npy')\n", (2024, 2067), True, 'import numpy as np\n'), ((2175, 2246), 'numpy.save', 'np.save', (['"""/home/arshad/catkin_ws/predicted_joints_values_rtp.npy"""', 'traj'], {}), "('/home... |
#
# Общие функции для всех парсеров
#
# Автор: <NAME>
# Лицензия: MIT License
#
from time import sleep
import requests
def get_htmls(urls):
"""
Получает список URL-адресов
Возвращает список из всех полученных HTML документов
:param urls: Список URL-адресов
:type urls: list
... | [
"time.sleep",
"requests.get"
] | [((990, 1041), 'requests.get', 'requests.get', (['url'], {'headers': "{'User-Agent': 'Custom'}"}), "(url, headers={'User-Agent': 'Custom'})\n", (1002, 1041), False, 'import requests\n'), ((654, 662), 'time.sleep', 'sleep', (['(1)'], {}), '(1)\n', (659, 662), False, 'from time import sleep\n')] |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import mxnet as mx
import numpy as np
from config import config
def Conv(**kwargs):
body = mx.sym.Convolution(**kwargs)
return body
def Act(data, act_type, name):
if act_type=='prelu':
body... | [
"mxnet.sym.QActivation",
"mxnet.sym.concat",
"mxnet.contrib.symbol.DeformableConvolution",
"mxnet.sym.Convolution",
"mxnet.symbol.Convolution",
"mxnet.sym.add_n",
"mxnet.sym.QConvolution_v1",
"mxnet.symbol.Activation",
"mxnet.sym.QConvolution",
"mxnet.symbol.BatchNorm",
"mxnet.sym.LeakyReLU",
... | [((207, 235), 'mxnet.sym.Convolution', 'mx.sym.Convolution', ([], {}), '(**kwargs)\n', (225, 235), True, 'import mxnet as mx\n'), ((1287, 1385), 'mxnet.symbol.BatchNorm', 'mx.symbol.BatchNorm', ([], {'data': 'conv', 'fix_gamma': '(False)', 'momentum': 'bn_mom', 'eps': '(2e-05)', 'name': "(name + '_bn')"}), "(data=conv,... |
'''
--- I M P O R T S T A T E M E N T S ---
'''
import coloredlogs, logging
coloredlogs.install()
import numpy as np
'''
=== S T A R T O F C L A S S E V A L M E T R I C ===
[About]
Object class for calculating average values.
[Init Args]
- name: String for the variable name to calc... | [
"logging.getLogger",
"coloredlogs.install",
"logging.warning",
"numpy.array",
"logging.info"
] | [((79, 100), 'coloredlogs.install', 'coloredlogs.install', ([], {}), '()\n', (98, 100), False, 'import coloredlogs, logging\n'), ((9112, 9140), 'logging.info', 'logging.info', (['"""------------"""'], {}), "('------------')\n", (9124, 9140), False, 'import coloredlogs, logging\n'), ((3791, 3828), 'logging.warning', 'lo... |
import sys
from string import whitespace
from clint.textui import puts, indent, colored
from poly.common import *
from poly.node import *
def repl_main(args):
repl = Repl("repl")
repl.run()
class UndefinedCommandError(PolyError):
def __init__(self, command):
self.message = "Undefined command '{}... | [
"clint.textui.colored.blue",
"clint.textui.colored.red",
"clint.textui.puts",
"clint.textui.colored.yellow"
] | [((2381, 2391), 'clint.textui.puts', 'puts', (['line'], {}), '(line)\n', (2385, 2391), False, 'from clint.textui import puts, indent, colored\n'), ((2400, 2407), 'clint.textui.puts', 'puts', (['s'], {}), '(s)\n', (2404, 2407), False, 'from clint.textui import puts, indent, colored\n'), ((2416, 2433), 'clint.textui.puts... |
import torch
import torch.nn as nn
import torch.nn.functional as F
import math
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
import numpy as np
from masked_cross_entropy import *
from preprocess import *
from parameter import *
import time
# # Training
def train(input_batches,... | [
"matplotlib.ticker.MultipleLocator",
"torch.LongTensor",
"matplotlib.pyplot.figure",
"torch.no_grad",
"torch.zeros"
] | [((839, 881), 'torch.LongTensor', 'torch.LongTensor', (['([SOS_index] * batch_size)'], {}), '([SOS_index] * batch_size)\n', (855, 881), False, 'import torch\n'), ((1267, 1330), 'torch.zeros', 'torch.zeros', (['max_target_length', 'batch_size', 'decoder.output_size'], {}), '(max_target_length, batch_size, decoder.output... |
import unittest
import pycqed as pq
import os
import matplotlib.pyplot as plt
from pycqed.analysis_v2 import measurement_analysis as ma
class Test_SimpleAnalysis(unittest.TestCase):
@classmethod
def tearDownClass(self):
plt.close('all')
@classmethod
def setUpClass(self):
self.datadir... | [
"pycqed.analysis_v2.measurement_analysis.Basic1DAnalysis",
"pycqed.analysis_v2.measurement_analysis.Basic2DAnalysis",
"os.path.join",
"matplotlib.pyplot.close",
"pycqed.analysis_v2.measurement_analysis.Basic1DBinnedAnalysis",
"pycqed.analysis_v2.measurement_analysis.Basic2DInterpolatedAnalysis",
"unitte... | [((1725, 1770), 'unittest.skip', 'unittest.skip', (['"""FIXME: disabled, see PR #643"""'], {}), "('FIXME: disabled, see PR #643')\n", (1738, 1770), False, 'import unittest\n'), ((239, 255), 'matplotlib.pyplot.close', 'plt.close', (['"""all"""'], {}), "('all')\n", (248, 255), True, 'import matplotlib.pyplot as plt\n'), ... |
import turtle
'''http://www.algorithm.co.il/blogs/computer-science/fractals-in-10-minutes-no-6-turtle-snowflake/
This would be a good introduction to recursion. I don't see how students
would invent this on their own, but they could modify it and see what
other fractals they could generate.
'''
pen = turtle.Turtle()
p... | [
"turtle.done",
"turtle.Turtle"
] | [((303, 318), 'turtle.Turtle', 'turtle.Turtle', ([], {}), '()\n', (316, 318), False, 'import turtle\n'), ((767, 780), 'turtle.done', 'turtle.done', ([], {}), '()\n', (778, 780), False, 'import turtle\n')] |
from django.urls import re_path
from user_queries.views import UserQuerySaveView, UserQueryCollectView
urlpatterns = [
re_path(r"^/save/?$", UserQuerySaveView.as_view(), name="user-save-query"),
re_path(
r"^/collect/?$",
UserQueryCollectView.as_view(),
name="user-collect-queries",
)... | [
"user_queries.views.UserQuerySaveView.as_view",
"user_queries.views.UserQueryCollectView.as_view"
] | [((146, 173), 'user_queries.views.UserQuerySaveView.as_view', 'UserQuerySaveView.as_view', ([], {}), '()\n', (171, 173), False, 'from user_queries.views import UserQuerySaveView, UserQueryCollectView\n'), ((246, 276), 'user_queries.views.UserQueryCollectView.as_view', 'UserQueryCollectView.as_view', ([], {}), '()\n', (... |
import pandas as pd
from math import log
class InfoGain():
def __init__(self, path):
self._path=path
def extractVariables(self):
self._df = pd.read_csv(self._path + ".csv");
# put the original column names in a python list
'''if 'Unnamed: 0' in self._df.columns:
... | [
"pandas.read_csv",
"math.log"
] | [((170, 202), 'pandas.read_csv', 'pd.read_csv', (["(self._path + '.csv')"], {}), "(self._path + '.csv')\n", (181, 202), True, 'import pandas as pd\n'), ((1438, 1447), 'math.log', 'log', (['p', '(2)'], {}), '(p, 2)\n', (1441, 1447), False, 'from math import log\n')] |
# coding: utf-8
from __future__ import absolute_import
from datetime import date, datetime # noqa: F401
from typing import List, Dict # noqa: F401
from swagger_server.models.base_model_ import Model
from swagger_server.models.impedance import Impedance # noqa: F401,E501
from swagger_server import util
class Lin... | [
"swagger_server.util.deserialize_model"
] | [((1651, 1684), 'swagger_server.util.deserialize_model', 'util.deserialize_model', (['dikt', 'cls'], {}), '(dikt, cls)\n', (1673, 1684), False, 'from swagger_server import util\n')] |
# Created by Hansi at 3/16/2020
import os
from algo.data_process.data_preprocessor import data_cleaning_flow
from algo.utils.file_utils import delete_create_folder
def extract_gt_tokens(text):
"""
Given GT string, method to extract GT labels.
GT string should be formatted as Twitter-Event-Data-2019.
... | [
"algo.data_process.data_preprocessor.data_cleaning_flow",
"algo.utils.file_utils.delete_create_folder",
"os.path.splitext",
"os.path.join",
"os.walk"
] | [((1333, 1353), 'os.walk', 'os.walk', (['folder_path'], {}), '(folder_path)\n', (1340, 1353), False, 'import os\n'), ((4983, 5023), 'algo.utils.file_utils.delete_create_folder', 'delete_create_folder', (['output_folder_path'], {}), '(output_folder_path)\n', (5003, 5023), False, 'from algo.utils.file_utils import delete... |
import logging
from queue import Queue
from threading import Thread
from time import time
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)
class Worker(Thread):
def __init__(self, queue, out_que):
Thread.__init__... | [
"logging.basicConfig",
"threading.Thread.__init__",
"logging.getLogger",
"queue.Queue",
"time.time"
] | [((91, 198), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO', 'format': '"""%(asctime)s - %(name)s - %(levelname)s - %(message)s"""'}), "(level=logging.INFO, format=\n '%(asctime)s - %(name)s - %(levelname)s - %(message)s')\n", (110, 198), False, 'import logging\n'), ((204, 231), 'logging... |
#!/usr/bin/env python
import saml2
from saml2 import SamlBase
from saml2.xmldsig import KeyInfo
NAMESPACE = 'urn:net:eustix:names:tc:PEFIM:0.0:assertion'
class SPCertEncType_(SamlBase):
"""The urn:net:eustix:names:tc:PEFIM:0.0:assertion:SPCertEncType element """
c_tag = 'SPCertEncType'
c_namespace = NA... | [
"saml2.SamlBase.c_children.copy",
"saml2.xmldsig.KeyInfo",
"saml2.SamlBase.__init__",
"saml2.SamlBase.c_cardinality.copy",
"saml2.SamlBase.c_attributes.copy",
"saml2.create_class_from_xml_string"
] | [((345, 371), 'saml2.SamlBase.c_children.copy', 'SamlBase.c_children.copy', ([], {}), '()\n', (369, 371), False, 'from saml2 import SamlBase\n'), ((391, 419), 'saml2.SamlBase.c_attributes.copy', 'SamlBase.c_attributes.copy', ([], {}), '()\n', (417, 419), False, 'from saml2 import SamlBase\n'), ((486, 515), 'saml2.SamlB... |
# Generated by Django 2.2.4 on 2019-08-24 06:02
from django.db import connection as con, migrations
from psycopg2 import sql
def remove_old_migration_refs(apps, schema_editor):
__sql_delete_migration_ref = 'DELETE FROM django_migrations WHERE app={0}'
old_apps = [
'action', 'core', 'dataops', 'logs'... | [
"psycopg2.sql.Literal",
"django.db.connection.cursor",
"django.db.migrations.RunPython",
"psycopg2.sql.SQL"
] | [((411, 423), 'django.db.connection.cursor', 'con.cursor', ([], {}), '()\n', (421, 423), True, 'from django.db import connection as con, migrations\n'), ((745, 797), 'django.db.migrations.RunPython', 'migrations.RunPython', ([], {'code': 'remove_old_migration_refs'}), '(code=remove_old_migration_refs)\n', (765, 797), F... |
# Copyright (c) 2016, NVIDIA CORPORATION. All rights reserved.
import os
from digits.utils import subclass, override, constants
from digits.extensions.data.interface import DataIngestionInterface
from .forms import DatasetForm, InferenceForm
from . import utils
from flask_babel import lazy_gettext as _
DATASET_TE... | [
"flask_babel.lazy_gettext",
"os.path.abspath",
"os.path.join"
] | [((2972, 2981), 'flask_babel.lazy_gettext', '_', (['"""bAbI"""'], {}), "('bAbI')\n", (2973, 2981), True, 'from flask_babel import lazy_gettext as _\n'), ((2354, 2379), 'os.path.abspath', 'os.path.abspath', (['__file__'], {}), '(__file__)\n', (2369, 2379), False, 'import os\n'), ((2723, 2748), 'os.path.abspath', 'os.pat... |
import os,sys
import pandas as pd
import numpy as np
import subprocess
from tqdm import tqdm
from ras_method import ras_method
import warnings
warnings.filterwarnings('ignore')
def est_trade_value(x,output_new,sector):
"""
Function to estimate the trade value between two sectors
"""
if (sector is not ... | [
"pandas.MultiIndex.from_product",
"pandas.MultiIndex.from_arrays",
"os.path.join",
"ras_method.ras_method",
"numpy.array",
"pandas.DataFrame",
"pandas.concat",
"warnings.filterwarnings"
] | [((144, 177), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (167, 177), False, 'import warnings\n'), ((986, 1012), 'os.path.join', 'os.path.join', (['""".."""', '"""data"""'], {}), "('..', 'data')\n", (998, 1012), False, 'import os, sys\n'), ((3994, 4163), 'pandas.MultiIn... |
from django import forms
from django.contrib.auth import get_user_model
from django.contrib.auth.forms import (
AuthenticationForm,
UserCreationForm,
UsernameField,
)
User = get_user_model()
class UserLoginForm(AuthenticationForm):
def __init__(self, *args, **kwargs):
super(UserLoginForm, sel... | [
"django.contrib.auth.get_user_model",
"django.forms.PasswordInput",
"django.forms.TextInput"
] | [((187, 203), 'django.contrib.auth.get_user_model', 'get_user_model', ([], {}), '()\n', (201, 203), False, 'from django.contrib.auth import get_user_model\n'), ((386, 448), 'django.forms.TextInput', 'forms.TextInput', ([], {'attrs': "{'class': 'bg-gray-100 rounded-lg p-2'}"}), "(attrs={'class': 'bg-gray-100 rounded-lg ... |
from __future__ import annotations
from typing import Any, Dict, Optional
from boa3.model.method import Method
from boa3.model.property import Property
from boa3.model.type.classes.classarraytype import ClassArrayType
from boa3.model.variable import Variable
class OracleType(ClassArrayType):
"""
A class use... | [
"boa3.model.builtin.interop.oracle.oraclegetpricemethod.OracleGetPriceMethod",
"boa3.model.builtin.interop.oracle.oraclerequestmethod.OracleRequestMethod"
] | [((1319, 1341), 'boa3.model.builtin.interop.oracle.oraclegetpricemethod.OracleGetPriceMethod', 'OracleGetPriceMethod', ([], {}), '()\n', (1339, 1341), False, 'from boa3.model.builtin.interop.oracle.oraclegetpricemethod import OracleGetPriceMethod\n'), ((1370, 1391), 'boa3.model.builtin.interop.oracle.oraclerequestmetho... |
import os, glob
try:
os.mkdir("output")
except:
pass
wiiudir="input/wiiu"
try:
os.makedirs(wiiudir)
print('The directories have been made.')
input('Insert your textures in input/wiiu and then run the tool again to convert it.')
except:
pass
dir = 'input/temp'
t... | [
"os.listdir",
"os.makedirs",
"os.path.join",
"os.rmdir",
"os.mkdir",
"os.remove"
] | [((1008, 1021), 'os.rmdir', 'os.rmdir', (['dir'], {}), '(dir)\n', (1016, 1021), False, 'import os, glob\n'), ((29, 47), 'os.mkdir', 'os.mkdir', (['"""output"""'], {}), "('output')\n", (37, 47), False, 'import os, glob\n'), ((106, 126), 'os.makedirs', 'os.makedirs', (['wiiudir'], {}), '(wiiudir)\n', (117, 126), False, '... |
import sys
n = int(sys.stdin.readline().rstrip())
ab = map(int, sys.stdin.read().split())
ab = list(zip(ab, ab))
def main():
c_a = ab[0][0]
c_b = ab[0][1]
for a, b in ab[1:]:
ratio = a / b
while c_a / c_b != ratio:
if c_a / c_b < ratio:
c_a += 1
... | [
"sys.stdin.readline",
"sys.stdin.read"
] | [((22, 42), 'sys.stdin.readline', 'sys.stdin.readline', ([], {}), '()\n', (40, 42), False, 'import sys\n'), ((68, 84), 'sys.stdin.read', 'sys.stdin.read', ([], {}), '()\n', (82, 84), False, 'import sys\n')] |
# -*- coding: utf-8 -*-
# =================================================================
#
# Authors: <NAME> <<EMAIL>>
# <NAME> <<EMAIL>>
#
# Copyright (c) 2015 <NAME>
# Copyright (c) 2015 <NAME>
#
# Permission is hereby granted, free of charge, to any person
# obtaining a copy of this software and associat... | [
"warnings.warn"
] | [((4782, 4937), 'warnings.warn', 'warnings.warn', (["('%s is now a core module, and does not need to be specified explicitly. So you can remove %s from server.profiles'\n % (prof, prof))"], {}), "(\n '%s is now a core module, and does not need to be specified explicitly. So you can remove %s from server.profil... |
# source http://itasuke.hatenablog.com/entry/2018/01/08/133510
import winreg
newkey = winreg.CreateKeyEx(winreg.HKEY_CURRENT_USER, r'Software\__javacommons__\abc')
newkey.Close()
winreg.DeleteKeyEx(winreg.HKEY_CURRENT_USER, r'Software\__javacommons__\abc')
| [
"winreg.CreateKeyEx",
"winreg.DeleteKeyEx"
] | [((88, 166), 'winreg.CreateKeyEx', 'winreg.CreateKeyEx', (['winreg.HKEY_CURRENT_USER', '"""Software\\\\__javacommons__\\\\abc"""'], {}), "(winreg.HKEY_CURRENT_USER, 'Software\\\\__javacommons__\\\\abc')\n", (106, 166), False, 'import winreg\n'), ((183, 261), 'winreg.DeleteKeyEx', 'winreg.DeleteKeyEx', (['winreg.HKEY_CU... |
import inspect
import re
import textwrap
import pytest
import pkg_resources
from .test_resources import Metadata
def strip_comments(s):
return '\n'.join(
l for l in s.split('\n')
if l.strip() and not l.strip().startswith('#')
)
def parse_distributions(s):
'''
Parse a series of dist... | [
"re.split",
"textwrap.dedent",
"pkg_resources.Distribution",
"re.match",
"pytest.param",
"pytest.mark.parametrize",
"pkg_resources.parse_requirements",
"pytest.raises",
"pkg_resources.WorkingSet",
"inspect.isclass"
] | [((730, 757), 're.split', 're.split', (['"""\n(?=[^\\\\s])"""', 's'], {}), "('\\n(?=[^\\\\s])', s)\n", (738, 757), False, 'import re\n'), ((2899, 3053), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""installed_dists,installable_dists,requirements,replace_conflicting,resolved_dists_or_exception"""', 'argval... |
from setuptools import find_packages, setup
install_requires = [dep.strip() for dep in open('requirements.txt')]
setup(
name='yolo_tf2',
version='1.5',
packages=find_packages(),
url='https://github.com/schissmantics/yolo-tf2',
license='MIT',
author='schismantics',
author_email='<EMAIL>',
... | [
"setuptools.find_packages"
] | [((175, 190), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (188, 190), False, 'from setuptools import find_packages, setup\n')] |
import networkx as nx
import numpy as np
import matplotlib.pyplot as plt
def node_match(n1, n2):
if n1['op'] == n2['op']:
return True
else:
return False
def edge_match(e1, e2):
return True
def gen_graph(adj, ops):
G = nx.DiGraph()
for k, op in enumerate(ops):
G.add_node(k,... | [
"networkx.DiGraph",
"numpy.array",
"networkx.graph_edit_distance",
"matplotlib.pyplot.subplot",
"networkx.draw"
] | [((253, 265), 'networkx.DiGraph', 'nx.DiGraph', ([], {}), '()\n', (263, 265), True, 'import networkx as nx\n'), ((1623, 1723), 'numpy.array', 'np.array', (['[[0, 1, 1, 1, 0], [0, 0, 1, 0, 0], [0, 0, 0, 0, 1], [0, 0, 0, 0, 1], [0, 0,\n 0, 0, 0]]'], {}), '([[0, 1, 1, 1, 0], [0, 0, 1, 0, 0], [0, 0, 0, 0, 1], [0, 0, 0, ... |
import bitmath
class V2RegistryException(Exception):
def __init__(
self,
error_code_str,
message,
detail,
http_status_code=400,
repository=None,
scopes=None,
is_read_only=False,
):
super(V2RegistryException, self).__init__(message)
... | [
"bitmath.Byte"
] | [((4295, 4317), 'bitmath.Byte', 'bitmath.Byte', (['uploaded'], {}), '(uploaded)\n', (4307, 4317), False, 'import bitmath\n'), ((4383, 4408), 'bitmath.Byte', 'bitmath.Byte', (['max_allowed'], {}), '(max_allowed)\n', (4395, 4408), False, 'import bitmath\n')] |
'''
LICENSE: MIT license
This module can help us know about who can ask when
we have troubles in some buggy codes while solving problems.
'''
from asyncio import gather, get_event_loop
from pandas import DataFrame, set_option
from online_judge import Online_Judge
loop = get_event_loop()
set_option('display.max_col... | [
"pandas.DataFrame.from_dict",
"pandas.set_option",
"asyncio.gather",
"pandas.DataFrame",
"asyncio.get_event_loop",
"online_judge.Online_Judge"
] | [((276, 292), 'asyncio.get_event_loop', 'get_event_loop', ([], {}), '()\n', (290, 292), False, 'from asyncio import gather, get_event_loop\n'), ((293, 331), 'pandas.set_option', 'set_option', (['"""display.max_colwidth"""', '(-1)'], {}), "('display.max_colwidth', -1)\n", (303, 331), False, 'from pandas import DataFrame... |
import os
import pickle
import numpy as np
from PIL import Image
import torch
from torch.utils.data import Dataset
from torchvision import transforms
import h5py
from transforms import Scale
class CLEVR(Dataset):
def __init__(self, root, split='train', transform=None):
features_path = os.path.join(root, ... | [
"transforms.Scale",
"torch.LongTensor",
"torch.stack",
"os.path.join",
"pickle.load",
"torch.from_numpy",
"torchvision.transforms.RandomCrop",
"numpy.zeros",
"torchvision.transforms.Normalize",
"torchvision.transforms.Pad",
"torchvision.transforms.ToTensor"
] | [((1611, 1658), 'numpy.zeros', 'np.zeros', (['(batch_size, max_len)'], {'dtype': 'np.int64'}), '((batch_size, max_len), dtype=np.int64)\n', (1619, 1658), True, 'import numpy as np\n'), ((301, 331), 'os.path.join', 'os.path.join', (['root', '"""features"""'], {}), "(root, 'features')\n", (313, 331), False, 'import os\n'... |
import pytest
import numpy as np
import pandas as pd
from xgboost_distribution.distributions import LogNormal
@pytest.fixture
def lognormal():
return LogNormal()
def test_target_validation(lognormal):
valid_target = np.array([0.5, 1, 4, 5, 10])
lognormal.check_target(valid_target)
@pytest.mark.param... | [
"pandas.Series",
"numpy.log",
"xgboost_distribution.distributions.LogNormal",
"numpy.array",
"pytest.raises",
"numpy.testing.assert_array_equal"
] | [((158, 169), 'xgboost_distribution.distributions.LogNormal', 'LogNormal', ([], {}), '()\n', (167, 169), False, 'from xgboost_distribution.distributions import LogNormal\n'), ((230, 258), 'numpy.array', 'np.array', (['[0.5, 1, 4, 5, 10]'], {}), '([0.5, 1, 4, 5, 10])\n', (238, 258), True, 'import numpy as np\n'), ((1160... |
#!/usr/bin/env python3
"""
Main script for workload forecasting.
Example usage:
- Generate data (runs OLTP benchmark on the built database) and perform training, and save the trained model
./forecaster --gen_data --models=LSTM --model_save_path=model.pickle
- Use the trained models (LSTM) to generate predictions.
... | [
"pickle.dump",
"argparse.ArgumentParser",
"pickle.load",
"numpy.array",
"json.load",
"functools.lru_cache"
] | [((1707, 1767), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Query Load Forecaster"""'}), "(description='Query Load Forecaster')\n", (1730, 1767), False, 'import argparse\n'), ((8504, 8525), 'functools.lru_cache', 'lru_cache', ([], {'maxsize': '(32)'}), '(maxsize=32)\n', (8513, 8525), ... |
from copy import copy
from hashlib import md5
from pickle import Pickler, MARK, DICT
from types import DictionaryType
from .lib import StringIO
class CanonicalizingPickler(Pickler):
dispatch = copy(Pickler.dispatch)
def save_set(self, obj):
rv = obj.__reduce_ex__(0)
rv = (rv[0], (sorted(rv[1]... | [
"copy.copy"
] | [((199, 221), 'copy.copy', 'copy', (['Pickler.dispatch'], {}), '(Pickler.dispatch)\n', (203, 221), False, 'from copy import copy\n')] |
'''Meeus: Astronomical Algorithms (2nd ed.), chapter 25'''
import math
from nutation_ecliptic import ecliptic
from constants import AU
def coordinates(jd):
'''equatorial coordinates of Sun'''
lon=math.radians(longitude(jd))
eps=math.radians(ecliptic(jd))
ra=math.degrees(math.atan2(math.c... | [
"math.degrees",
"math.radians",
"math.cos",
"math.sin",
"nutation_ecliptic.ecliptic"
] | [((535, 597), 'math.radians', 'math.radians', (['(280.46646 + 36000.76983 * T + 0.0003032 * T ** 2)'], {}), '(280.46646 + 36000.76983 * T + 0.0003032 * T ** 2)\n', (547, 597), False, 'import math\n'), ((594, 656), 'math.radians', 'math.radians', (['(357.52911 + 35999.05029 * T - 0.0001537 * T ** 2)'], {}), '(357.52911 ... |
from django.contrib import admin
# Register your models here.
from apps.weapons.models import Weapon
admin.site.register(Weapon)
| [
"django.contrib.admin.site.register"
] | [((103, 130), 'django.contrib.admin.site.register', 'admin.site.register', (['Weapon'], {}), '(Weapon)\n', (122, 130), False, 'from django.contrib import admin\n')] |
from django.db import models
class Nominee(models.Model):
name = models.TextField()
picture_url = models.ImageField(upload_to="nominees/")
description = models.TextField(max_length=350)
class Meta:
verbose_name_plural = "nominees"
def __str__(self):
return self.name
class Categ... | [
"django.db.models.TextField",
"django.db.models.ForeignKey",
"django.db.models.IntegerField",
"django.db.models.BooleanField",
"django.db.models.ImageField",
"django.db.models.CharField"
] | [((71, 89), 'django.db.models.TextField', 'models.TextField', ([], {}), '()\n', (87, 89), False, 'from django.db import models\n'), ((108, 148), 'django.db.models.ImageField', 'models.ImageField', ([], {'upload_to': '"""nominees/"""'}), "(upload_to='nominees/')\n", (125, 148), False, 'from django.db import models\n'), ... |
#!/usr/bin/python
# -*- coding: utf-8 -*-
import logging
from datetime import datetime
from scholarly_citation_finder import config
from scholarly_citation_finder.apps.parser.Parser import Parser
from scholarly_citation_finder.apps.core.models import PublicationUrl
from scholarly_citation_finder.tools.extractor.grobid... | [
"logging.getLogger",
"scholarly_citation_finder.tools.extractor.grobid.GrobidExtractor.GrobidExtractor",
"scholarly_citation_finder.apps.parser.Parser.Parser",
"datetime.datetime.now",
"scholarly_citation_finder.tools.nameparser.StringMatching.nearly_match",
"scholarly_citation_finder.lib.string.normalize... | [((913, 940), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (930, 940), False, 'import logging\n'), ((1229, 1246), 'scholarly_citation_finder.tools.extractor.grobid.GrobidExtractor.GrobidExtractor', 'GrobidExtractor', ([], {}), '()\n', (1244, 1246), False, 'from scholarly_citation_finder... |
import sys
import os
import json
import urllib
from PIL import Image
from flask import Flask, request, redirect, url_for
from flask import send_from_directory, render_template
from werkzeug.utils import secure_filename
from datetime import datetime
from caption_service import CaptionService
from translation_service imp... | [
"translation_service.TranslationService",
"flask.send_from_directory",
"caption_service.CaptionService",
"flask.request.files.getlist",
"os.makedirs",
"flask.Flask",
"json.dumps",
"os.path.join",
"os.environ.get",
"os.path.dirname",
"datetime.datetime.now",
"os.path.basename",
"werkzeug.util... | [((344, 370), 'sys.path.append', 'sys.path.append', (['os.curdir'], {}), '(os.curdir)\n', (359, 370), False, 'import sys\n'), ((428, 469), 'os.makedirs', 'os.makedirs', (['UPLOAD_FOLDER'], {'exist_ok': '(True)'}), '(UPLOAD_FOLDER, exist_ok=True)\n', (439, 469), False, 'import os\n'), ((533, 606), 'flask.Flask', 'Flask'... |
import geopandas as gpd
from shapely.geometry import LineString, Polygon,MultiLineString
import os.path
from map2loop import m2l_utils
import warnings
import numpy as np
import pandas as pd
#explodes polylines and modifies objectid for exploded parts
def explode_polylines(indf,c_l,dst_crs): ... | [
"map2loop.m2l_utils.clip_shp",
"geopandas.read_file",
"pandas.to_numeric",
"geopandas.overlay",
"warnings.warn",
"geopandas.GeoDataFrame"
] | [((420, 471), 'geopandas.GeoDataFrame', 'gpd.GeoDataFrame', ([], {'columns': 'indf.columns', 'crs': 'dst_crs'}), '(columns=indf.columns, crs=dst_crs)\n', (436, 471), True, 'import geopandas as gpd\n'), ((2255, 2295), 'geopandas.read_file', 'gpd.read_file', (['structure_file'], {'bbox': 'bbox'}), '(structure_file, bbox=... |
import os
import tensorflow as tf
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
x1 = tf.constant(5)
x2 = tf.constant(6)
result = tf.multiply(x1, x2)
print(result)
sess = tf.Session()
with tf.Session() as sess:
output = sess.run(result)
print(output)
| [
"tensorflow.Session",
"tensorflow.constant",
"tensorflow.multiply"
] | [((83, 97), 'tensorflow.constant', 'tf.constant', (['(5)'], {}), '(5)\n', (94, 97), True, 'import tensorflow as tf\n'), ((103, 117), 'tensorflow.constant', 'tf.constant', (['(6)'], {}), '(6)\n', (114, 117), True, 'import tensorflow as tf\n'), ((128, 147), 'tensorflow.multiply', 'tf.multiply', (['x1', 'x2'], {}), '(x1, ... |
import auth_key
import tweepy
import time
auth = tweepy.OAuthHandler(auth_key.API_key, auth_key.API_secret_key)
auth.set_access_token(auth_key.Access_token, auth_key.Access_token_secret)
api = tweepy.API(auth, wait_on_rate_limit=True, wait_on_rate_limit_notify=True)
user = api.me()
indId = 2282863
india... | [
"tweepy.Cursor",
"tweepy.API",
"time.sleep",
"tweepy.OAuthHandler"
] | [((54, 116), 'tweepy.OAuthHandler', 'tweepy.OAuthHandler', (['auth_key.API_key', 'auth_key.API_secret_key'], {}), '(auth_key.API_key, auth_key.API_secret_key)\n', (73, 116), False, 'import tweepy\n'), ((202, 275), 'tweepy.API', 'tweepy.API', (['auth'], {'wait_on_rate_limit': '(True)', 'wait_on_rate_limit_notify': '(Tru... |
from ds_discovery import Controller
import os
import warnings
warnings.simplefilter(action='ignore', category=FutureWarning)
warnings.simplefilter(action='ignore', category=DeprecationWarning)
__author__ = '<NAME>'
def domain_controller():
# Controller
uri_pm_repo = os.environ.get('HADRON_PM_REPO', None)
... | [
"warnings.simplefilter",
"ds_discovery.Controller.from_env",
"os.environ.get"
] | [((63, 125), 'warnings.simplefilter', 'warnings.simplefilter', ([], {'action': '"""ignore"""', 'category': 'FutureWarning'}), "(action='ignore', category=FutureWarning)\n", (84, 125), False, 'import warnings\n'), ((126, 193), 'warnings.simplefilter', 'warnings.simplefilter', ([], {'action': '"""ignore"""', 'category': ... |
import json
import unittest
from utils import CustomEncoder, Paging, ValidationError, generate_uuid, Validator
class UtilsTest(unittest.TestCase):
def test_uuid(self):
print(generate_uuid())
self.assertEqual(len(generate_uuid()), 32)
def test_valiate(self):
form = dict(
... | [
"utils.generate_uuid",
"json.dumps",
"utils.Validator",
"utils.CustomEncoder",
"utils.Paging"
] | [((1317, 1335), 'utils.Paging', 'Paging', (['(101)', '(1)', '(10)'], {}), '(101, 1, 10)\n', (1323, 1335), False, 'from utils import CustomEncoder, Paging, ValidationError, generate_uuid, Validator\n'), ((1423, 1441), 'utils.Paging', 'Paging', (['(101)', '(1)', '(10)'], {}), '(101, 1, 10)\n', (1429, 1441), False, 'from ... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import argparse
import logging
import os
import sys
from . import entries, meta
logger = logging.getLogger(__name__)
def build_parser():
prog = os.path.basename(sys.argv[0])
if prog not in ("pyclean", "pyclean.py"):
prog = "pyclean"
parser = argpar... | [
"logging.getLogger",
"logging.basicConfig",
"argparse.ArgumentParser",
"logging.root.setLevel",
"os.path.basename"
] | [((139, 166), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (156, 166), False, 'import logging\n'), ((200, 229), 'os.path.basename', 'os.path.basename', (['sys.argv[0]'], {}), '(sys.argv[0])\n', (216, 229), False, 'import os\n'), ((314, 348), 'argparse.ArgumentParser', 'argparse.Argument... |
from flask import Flask, render_template, url_for, redirect, request
from flask_sqlalchemy import SQLAlchemy
from datetime import datetime
from dateutil.relativedelta import relativedelta
from demail import demail
__author__ = '<NAME>'
__doc__ = 'Never Forget online remainder'
app = Flask(__name__)
app.config['SQLALC... | [
"flask.render_template",
"dateutil.relativedelta.relativedelta",
"flask.Flask",
"datetime.datetime.strptime",
"flask.redirect",
"datetime.datetime.now",
"flask_sqlalchemy.SQLAlchemy"
] | [((286, 301), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (291, 301), False, 'from flask import Flask, render_template, url_for, redirect, request\n'), ((602, 617), 'flask_sqlalchemy.SQLAlchemy', 'SQLAlchemy', (['app'], {}), '(app)\n', (612, 617), False, 'from flask_sqlalchemy import SQLAlchemy\n'), ((5... |
"""The solaredge integration."""
from __future__ import annotations
from homeassistant.config_entries import ConfigEntry
from homeassistant.core import HomeAssistant
import homeassistant.helpers.config_validation as cv
from .const import DOMAIN
CONFIG_SCHEMA = cv.deprecated(DOMAIN)
async def async_setup_entry(hass... | [
"homeassistant.helpers.config_validation.deprecated"
] | [((264, 285), 'homeassistant.helpers.config_validation.deprecated', 'cv.deprecated', (['DOMAIN'], {}), '(DOMAIN)\n', (277, 285), True, 'import homeassistant.helpers.config_validation as cv\n')] |
import os, sys
from distutils.util import strtobool
import numpy as np
import tensorflow as tf
import tensorflow.keras.backend as K
from tensorflow.python.util import nest, tf_inspect
from tensorflow.python.eager import tape
# from tensorflow.python.ops.custom_gradient import graph_mode_decorator
# 是否使用重计... | [
"tensorflow.python.eager.tape.stop_recording",
"numpy.sqrt",
"os.environ.get",
"tensorflow.python.util.nest.flatten",
"tensorflow.keras.backend.ndim",
"tensorflow.python.util.tf_inspect.getfullargspec",
"tensorflow.GradientTape",
"tensorflow.keras.backend.pow",
"tensorflow.keras.backend.dtype",
"t... | [((348, 380), 'os.environ.get', 'os.environ.get', (['"""RECOMPUTE"""', '"""0"""'], {}), "('RECOMPUTE', '0')\n", (362, 380), False, 'import os, sys\n'), ((2470, 2480), 'tensorflow.keras.backend.dtype', 'K.dtype', (['x'], {}), '(x)\n', (2477, 2480), True, 'import tensorflow.keras.backend as K\n'), ((6013, 6030), 'doctest... |
import datetime
import os
import requests
import tweepy
from PIL import Image
# Get your own keys from developer.twitter.com
# You can find a detailed tutorial about authenticating accounts from github.com/gultugaydemir/Twitter_OAuth1.0a
consumer_key = ''
consumer_secret = ''
access_token = ''
access_token_secret = '... | [
"PIL.Image.open",
"requests.get",
"datetime.datetime.now",
"tweepy.API",
"tweepy.OAuthHandler"
] | [((330, 380), 'tweepy.OAuthHandler', 'tweepy.OAuthHandler', (['consumer_key', 'consumer_secret'], {}), '(consumer_key, consumer_secret)\n', (349, 380), False, 'import tweepy\n'), ((444, 460), 'tweepy.API', 'tweepy.API', (['auth'], {}), '(auth)\n', (454, 460), False, 'import tweepy\n'), ((604, 672), 'requests.get', 'req... |
import pickle
import os
import tensorflow as tf
from glob import glob
import utils.DataLoaderUtils as dlu
from utils.AnnotationUtils import write_dad_masks
# Static Dataset Config Options
TAG_NAMES = {'highlights',
'urls_to_supplementary',
'abbreviation',
'abstract',
... | [
"os.path.exists",
"utils.DataLoaderUtils.parse_image",
"utils.DataLoaderUtils.load_image_test",
"tensorflow.data.Dataset.from_tensor_slices",
"os.path.join",
"utils.DataLoaderUtils.stratify_train_test_split",
"utils.DataLoaderUtils.load_image_train",
"utils.AnnotationUtils.write_dad_masks",
"glob.gl... | [((2610, 2652), 'os.path.join', 'os.path.join', (['dataset_dir', 'ANNOTATIONS_DIR'], {}), '(dataset_dir, ANNOTATIONS_DIR)\n', (2622, 2652), False, 'import os\n'), ((2670, 2697), 'glob.glob', 'glob', (["(anno_dir + '/*/*json')"], {}), "(anno_dir + '/*/*json')\n", (2674, 2697), False, 'from glob import glob\n'), ((2705, ... |
import time
import queue
import threading
def aaa(i):
while True:
item = q.get()
if item is None:
print("线程%s发现了一个None,可以休息了^-^" % i)
break
time.sleep(0.01)
print('aaaaa -> ' + str(i) + " ---> " + str(item))
q.task_done()
if __name__ == '__main__':... | [
"threading.Thread",
"queue.Queue",
"time.sleep"
] | [((391, 404), 'queue.Queue', 'queue.Queue', ([], {}), '()\n', (402, 404), False, 'import queue\n'), ((194, 210), 'time.sleep', 'time.sleep', (['(0.01)'], {}), '(0.01)\n', (204, 210), False, 'import time\n'), ((477, 516), 'threading.Thread', 'threading.Thread', ([], {'target': 'aaa', 'args': '(i,)'}), '(target=aaa, args... |
# Generated by Django 3.2.5 on 2021-07-06 14:18
import uuid
from django.db import migrations, models
class Migration(migrations.Migration):
initial = True
dependencies = []
operations = [
migrations.CreateModel(
name="Bailleur",
fields=[
("id", models.Au... | [
"django.db.models.DateField",
"django.db.models.TextField",
"django.db.models.AutoField",
"django.db.models.CharField",
"django.db.models.DateTimeField",
"django.db.models.UUIDField"
] | [((311, 362), 'django.db.models.AutoField', 'models.AutoField', ([], {'primary_key': '(True)', 'serialize': '(False)'}), '(primary_key=True, serialize=False)\n', (327, 362), False, 'from django.db import migrations, models\n'), ((390, 442), 'django.db.models.UUIDField', 'models.UUIDField', ([], {'default': 'uuid.uuid4'... |
import time
import mysql.connector
from optionstrader.customlogging import CustomLog
from optionstrader.parser import Parser
MYSQL_IP_ADDR = '192.168.1.10'
# Used to debug via logs
DEBUG = False
class Database:
def __init__(self):
"""
There's some confusion with database vs table.
We wil... | [
"optionstrader.customlogging.CustomLog",
"optionstrader.parser.Parser",
"time.time"
] | [((1046, 1057), 'optionstrader.customlogging.CustomLog', 'CustomLog', ([], {}), '()\n', (1055, 1057), False, 'from optionstrader.customlogging import CustomLog\n'), ((1080, 1088), 'optionstrader.parser.Parser', 'Parser', ([], {}), '()\n', (1086, 1088), False, 'from optionstrader.parser import Parser\n'), ((9871, 9882),... |
# Generated by Django 3.2.9 on 2021-11-24 02:52
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
migrations.CreateModel(
name='Symbol',
fields=[
... | [
"django.db.models.FloatField",
"django.db.models.TextField",
"django.db.models.IntegerField",
"django.db.models.ForeignKey",
"django.db.models.AutoField",
"django.db.models.DateTimeField",
"django.db.models.CharField"
] | [((342, 393), 'django.db.models.AutoField', 'models.AutoField', ([], {'primary_key': '(True)', 'serialize': '(False)'}), '(primary_key=True, serialize=False)\n', (358, 393), False, 'from django.db import migrations, models\n'), ((421, 453), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(200)'})... |