code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
"""Day 18: snailfish math"""
import json
from typing import Iterable, Literal
from itertools import permutations
class Snailfish:
def __init__(self, raw_data: list | str, depth: int = 0) -> None:
if isinstance(raw_data, str):
raw_data = json.loads(raw_data)
assert len(raw_data) == 2, ... | [
"json.loads"
] | [((5485, 5536), 'json.loads', 'json.loads', (['"""[[[[[4,3],4],4],[7,[[8,4],9]]],[1,1]]"""'], {}), "('[[[[[4,3],4],4],[7,[[8,4],9]]],[1,1]]')\n", (5495, 5536), False, 'import json\n'), ((263, 283), 'json.loads', 'json.loads', (['raw_data'], {}), '(raw_data)\n', (273, 283), False, 'import json\n'), ((5043, 5059), 'json.... |
import string
import logging, sys
from random import randint
from Evaluator import MatchWordsFromLetters, CalculateWholeScore
def shuffle(sequence, shakes):
for x in range(shakes):
fromIndex, toIndex = randint(0,25), randint(0,25)
while(toIndex == fromIndex):
toIndex = randint(0,25)
... | [
"logging.info",
"random.randint",
"logging.basicConfig",
"Evaluator.CalculateWholeScore"
] | [((3489, 3548), 'logging.basicConfig', 'logging.basicConfig', ([], {'stream': 'sys.stderr', 'level': 'logging.DEBUG'}), '(stream=sys.stderr, level=logging.DEBUG)\n', (3508, 3548), False, 'import logging, sys\n'), ((3645, 3669), 'logging.info', 'logging.info', (['"""Starting"""'], {}), "('Starting')\n", (3657, 3669), Fa... |
import xml.etree.ElementTree as ET
def insert_new_shape(x, y, shape_index, world):
# get the handler of tag model in newshape file
if shape_index == 0:
newshapefile = ET.parse('/home/hiwi03/Roomgenerator/auto_gazebo/shapes/shape0.sdf')
elif shape_index == 1:
newshapefile = ET.parse('/h... | [
"xml.etree.ElementTree.parse"
] | [((2440, 2503), 'xml.etree.ElementTree.parse', 'ET.parse', (['"""/home/hiwi03/Roomgenerator/auto_gazebo/init80.world"""'], {}), "('/home/hiwi03/Roomgenerator/auto_gazebo/init80.world')\n", (2448, 2503), True, 'import xml.etree.ElementTree as ET\n'), ((189, 257), 'xml.etree.ElementTree.parse', 'ET.parse', (['"""/home/hi... |
import sys
import os
sys.path.append(os.getcwd().replace("/examples", ""))
#sys.path.append("/home/siyuchen/Hiwi/spr/build/python/sprpy")
import spr_py
init_paras = {
"beta" : 0.1,
"lambda0" : 100,
"tau0" : 500,
"nMaxIterations" : 30,
"tolerance" : 1e-5,
"kNN" : 30,
"wOutliers" : 0.1,
... | [
"os.getcwd",
"spr_py.SPRPython"
] | [((382, 410), 'spr_py.SPRPython', 'spr_py.SPRPython', (['init_paras'], {}), '(init_paras)\n', (398, 410), False, 'import spr_py\n'), ((37, 48), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (46, 48), False, 'import os\n')] |
import unittest
import numpy as np
from data_structure_collection.matrix import product
class TestProduct(unittest.TestCase):
def test_product(self):
mat1 = [[2, 4], [3, 4]]
mat2 = [[1, 2], [1, 3]]
m1, m2, n1, n2 = 2, 2, 2, 2
res = product(m1, m2, mat1, n1, n2, mat2)
self... | [
"numpy.dot",
"data_structure_collection.matrix.product",
"numpy.array"
] | [((272, 307), 'data_structure_collection.matrix.product', 'product', (['m1', 'm2', 'mat1', 'n1', 'n2', 'mat2'], {}), '(m1, m2, mat1, n1, n2, mat2)\n', (279, 307), False, 'from data_structure_collection.matrix import product\n'), ((347, 360), 'numpy.array', 'np.array', (['res'], {}), '(res)\n', (355, 360), True, 'import... |
import sys
import os
import webbrowser
from pathlib import Path
from jina import Document, Flow
def config():
os.environ.setdefault('JINA_USE_CUDA', 'False')
os.environ.setdefault('JINA_PORT_EXPOSE', '8886')
os.environ.setdefault('JINA_WORKSPACE', './workspace')
def index(file_name):
def load_marco(... | [
"webbrowser.open",
"os.environ.setdefault",
"os.environ.get",
"jina.Flow",
"pathlib.Path",
"jina.Document",
"distutils.dir_util.copy_tree"
] | [((116, 163), 'os.environ.setdefault', 'os.environ.setdefault', (['"""JINA_USE_CUDA"""', '"""False"""'], {}), "('JINA_USE_CUDA', 'False')\n", (137, 163), False, 'import os\n'), ((168, 217), 'os.environ.setdefault', 'os.environ.setdefault', (['"""JINA_PORT_EXPOSE"""', '"""8886"""'], {}), "('JINA_PORT_EXPOSE', '8886')\n"... |
"""This module contains the GeneFlow Workflow installer class."""
import shutil
from pathlib import Path
import pprint
import yaml
from git import Repo
from git.exc import GitError
import requests
from slugify import slugify
from geneflow.app_installer import AppInstaller
from geneflow.data_manager import DataManag... | [
"requests.packages.urllib3.disable_warnings",
"slugify.slugify",
"geneflow.log.Log.some",
"geneflow.definition.Definition",
"pathlib.Path",
"yaml.safe_load",
"git.Repo.clone_from",
"shutil.rmtree",
"geneflow.log.Log.an"
] | [((495, 603), 'requests.packages.urllib3.disable_warnings', 'requests.packages.urllib3.disable_warnings', (['requests.packages.urllib3.exceptions.InsecureRequestWarning'], {}), '(requests.packages.urllib3.\n exceptions.InsecureRequestWarning)\n', (537, 603), False, 'import requests\n'), ((2871, 2887), 'pathlib.Path'... |
# From pip >= 21.1, setup.cfg suffices: setup.py is not mandatory https://pip.pypa.io/en/stable/news/#v21-1
# For pip < 21.1, here is a shim that makes an editable install possible:
# pip install -e .
import setuptools
if __name__ == "__main__":
setuptools.setup()
| [
"setuptools.setup"
] | [((252, 270), 'setuptools.setup', 'setuptools.setup', ([], {}), '()\n', (268, 270), False, 'import setuptools\n')] |
from rply import LexerGenerator
import tokenize
lg = LexerGenerator()
reserved = {v.lower(): v for v in [
# 'IMPORT', 'PUTS', 'AND', 'OR', 'NOT', 'IF', 'ELIF', 'ELSE', 'END',
'PUTS', 'AND', 'OR', 'NOT', 'IF', 'ELIF', 'ELSE', 'END',
'WHILE', 'FOR', 'IN', 'DEF', 'RETURN']}
rules = [
['NUMBER', tokeniz... | [
"rply.LexerGenerator",
"tokenize.group"
] | [((55, 71), 'rply.LexerGenerator', 'LexerGenerator', ([], {}), '()\n', (69, 71), False, 'from rply import LexerGenerator\n'), ((927, 988), 'tokenize.group', 'tokenize.group', (['"""\\\\\\\\\\\\r?\\\\n"""', '"""[ \\\\f\\\\t]+"""', 'tokenize.Comment'], {}), "('\\\\\\\\\\\\r?\\\\n', '[ \\\\f\\\\t]+', tokenize.Comment)\n",... |
#!/usb/bin/python
import datetime
import pickle
def test_teams(nhl_scraper):
df = nhl_scraper.teams()
print(df)
assert(len(df.index) == 31)
assert(df[df.abbrev == 'TOR'].iloc(0)[0]['name'] == '<NAME>')
assert(df[df.city == 'San Jose'].iloc(0)[0]['name'] == 'Sharks')
assert(df[df.city == 'Vega... | [
"pickle.loads",
"datetime.datetime",
"pickle.dumps"
] | [((1208, 1224), 'pickle.dumps', 'pickle.dumps', (['dc'], {}), '(dc)\n', (1220, 1224), False, 'import pickle\n'), ((1238, 1255), 'pickle.loads', 'pickle.loads', (['tmp'], {}), '(tmp)\n', (1250, 1255), False, 'import pickle\n'), ((423, 453), 'datetime.datetime', 'datetime.datetime', (['(2018)', '(1)', '(14)'], {}), '(201... |
from LinkedList import LinkedList
def is_palindrome(ll):
fast = slow = ll.head
stack = []
while fast and fast.next:
stack.append(slow.value)
slow = slow.next
fast = fast.next.next
if fast:
slow = slow.next
while slow:
top = stack.pop()
if top != ... | [
"LinkedList.LinkedList"
] | [((412, 451), 'LinkedList.LinkedList', 'LinkedList', (['[1, 2, 3, 4, 5, 4, 3, 2, 1]'], {}), '([1, 2, 3, 4, 5, 4, 3, 2, 1])\n', (422, 451), False, 'from LinkedList import LinkedList\n'), ((493, 532), 'LinkedList.LinkedList', 'LinkedList', (['[1, 2, 3, 4, 5, 6, 7, 8, 9]'], {}), '([1, 2, 3, 4, 5, 6, 7, 8, 9])\n', (503, 53... |
"""
Django settings for leg_tracker project.
Generated by 'django-admin startproject' using Django 1.8.4.
For more information on this file, see
https://docs.djangoproject.com/en/1.8/topics/settings/
For the full list of settings and their values, see
https://docs.djangoproject.com/en/1.8/ref/settings/
"""
# Build ... | [
"os.path.dirname",
"os.path.join"
] | [((3860, 3893), 'os.path.join', 'os.path.join', (['BASE_DIR', '"""static/"""'], {}), "(BASE_DIR, 'static/')\n", (3872, 3893), False, 'import os\n'), ((524, 549), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (539, 549), False, 'import os\n'), ((3488, 3524), 'os.path.join', 'os.path.join', ([... |
# Copyright 2016 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 in wri... | [
"bitcoin.hash_to_int",
"bitcoin.decode_sig",
"bitcoin.ecdsa_verify",
"bitcoin.pubtoaddr",
"bitcoin.encode_pubkey",
"bitcoin.ecdsa_sign",
"bitcoin.electrum_sig_hash",
"bitcoin.decode_privkey",
"bitcoin.encode_privkey",
"bitcoin.decode_pubkey",
"bitcoin.compress",
"bitcoin.random_key",
"loggin... | [((877, 904), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (894, 904), False, 'import logging\n'), ((942, 969), 'bitcoin.random_key', 'pybitcointools.random_key', ([], {}), '()\n', (967, 969), True, 'import bitcoin as pybitcointools\n'), ((1035, 1090), 'bitcoin.encode_privkey', 'pybitco... |
# encoding: utf8
from __future__ import unicode_literals
from django.db import models, migrations
import django.utils.timezone
class Migration(migrations.Migration):
dependencies = [
('pieces', '0005_add_initial_tag'),
]
operations = [
migrations.AlterField(
model_name='piec... | [
"django.db.models.CharField",
"django.db.models.DateTimeField"
] | [((392, 447), 'django.db.models.DateTimeField', 'models.DateTimeField', ([], {'default': 'django.utils.timezone.now'}), '(default=django.utils.timezone.now)\n', (412, 447), False, 'from django.db import models, migrations\n'), ((569, 703), 'django.db.models.CharField', 'models.CharField', ([], {'help_text': "b'Recommen... |
import codecs
import numpy as np
import re
from typing import Tuple, List, Dict
import model
import utils
def load_sentences(path: str) -> List[List[List[str]]]:
sentences = []
sentence = []
for line in codecs.open(path, 'r', 'utf-8'):
line = re.sub(r'[0-9]', '0', line.rstrip())
if not li... | [
"codecs.open",
"utils.update_tag_scheme",
"utils.create_dico",
"utils.create_desc_mapping",
"model.cap_feature",
"utils.align_char_lists",
"utils.get_words_affix_ids",
"numpy.sqrt",
"utils.get_affix_dict_list"
] | [((218, 249), 'codecs.open', 'codecs.open', (['path', '"""r"""', '"""utf-8"""'], {}), "(path, 'r', 'utf-8')\n", (229, 249), False, 'import codecs\n'), ((774, 817), 'utils.update_tag_scheme', 'utils.update_tag_scheme', (['sentences', '"""iobes"""'], {}), "(sentences, 'iobes')\n", (797, 817), False, 'import utils\n'), ((... |
from peewee import ExtQueryResultWrapper, Field
try:
import pyodbc
PYODBC_AVAILABLE = True
except ImportError:
PYODBC_AVAILABLE = False
class DrillQueryResultWrapper(ExtQueryResultWrapper):
def initialize(self, description):
model = self.model
conv = []
i = 0
for value... | [
"peewee.Field"
] | [((452, 459), 'peewee.Field', 'Field', ([], {}), '()\n', (457, 459), False, 'from peewee import ExtQueryResultWrapper, Field\n')] |
import sys
from os.path import abspath
sys.path.append(abspath('../'))
from collections import OrderedDict
# helper for creating timestamps for time fields second = hhmmss(22, 30, 0)
from surveyh.serialiser import hhmmss
"""
server configuration
"""
config = {
'uri': 'http://localhost:8099/surveyapi',
'surv... | [
"collections.OrderedDict",
"os.path.abspath"
] | [((446, 556), 'collections.OrderedDict', 'OrderedDict', (["{'question0': 'yes', 'question1': 'Answer 1', 'question2': 'Answer 2',\n 'question3': 'foobar'}"], {}), "({'question0': 'yes', 'question1': 'Answer 1', 'question2':\n 'Answer 2', 'question3': 'foobar'})\n", (457, 556), False, 'from collections import Orde... |
from DataSets.DS.fashion_mnist import FashionMnist
from DataSets.DS.svhn_cropped import SVHN
from DataSets.DS.cifar10 import Cifar10
from DataSets.DS.mnist import MNIST
import numpy as np
class GetData:
@staticmethod
def get_ds(name):
"""
Get Dataset from DS folder
:param name: Name d... | [
"DataSets.DS.svhn_cropped.SVHN",
"numpy.nonzero",
"DataSets.DS.fashion_mnist.FashionMnist",
"DataSets.DS.cifar10.Cifar10",
"DataSets.DS.mnist.MNIST"
] | [((416, 423), 'DataSets.DS.mnist.MNIST', 'MNIST', ([], {}), '()\n', (421, 423), False, 'from DataSets.DS.mnist import MNIST\n'), ((1725, 1749), 'numpy.nonzero', 'np.nonzero', (['x_data_index'], {}), '(x_data_index)\n', (1735, 1749), True, 'import numpy as np\n'), ((501, 508), 'DataSets.DS.mnist.MNIST', 'MNIST', ([], {}... |
# HASPR - High-Altitude Solar Power Research
# Script to calculate aggregate lower bounds and historic variance given a directory of individual expected output
# Version 0.1
# Author: neyring
import numpy as np
from numpy import genfromtxt
from os import walk
import haspr
from haspr import Result
# Paramet... | [
"os.walk",
"numpy.zeros",
"numpy.genfromtxt",
"haspr.Result",
"numpy.add"
] | [((747, 767), 'os.walk', 'walk', (['inputDirectory'], {}), '(inputDirectory)\n', (751, 767), False, 'from os import walk\n'), ((878, 893), 'numpy.zeros', 'np.zeros', (['(17520)'], {}), '(17520)\n', (886, 893), True, 'import numpy as np\n'), ((915, 930), 'numpy.zeros', 'np.zeros', (['(17520)'], {}), '(17520)\n', (923, 9... |
#!/usr/bin/env python3
""" Scrape bike information from API. """
# %%
import math
import time
import pandas as pd
from bikeindex.api import search_all
MAX_ID: int = 6059692
PATH_DOWNLOAD: str = "data/download/"
PER_PAGE = 100
# %% Scrape all bikes
response = search_all(page=1, per_page=PER_PAGE)
total: int = int(r... | [
"bikeindex.api.search_all",
"time.sleep",
"pandas.DataFrame",
"math.ceil"
] | [((264, 301), 'bikeindex.api.search_all', 'search_all', ([], {'page': '(1)', 'per_page': 'PER_PAGE'}), '(page=1, per_page=PER_PAGE)\n', (274, 301), False, 'from bikeindex.api import search_all\n'), ((357, 384), 'math.ceil', 'math.ceil', (['(total / PER_PAGE)'], {}), '(total / PER_PAGE)\n', (366, 384), False, 'import ma... |
""" module containing command line interface implementation
and utilities.
"""
import argparse
from subprocess import call
import os
import json
from clamm import config, get_config_path, config_template
from clamm import util
def create_library_parsers(subps):
"""creates library sub-parsers
"""
lib_p =... | [
"json.load",
"argparse.ArgumentParser",
"json.dumps",
"subprocess.call",
"clamm.get_config_path",
"clamm.util.printr"
] | [((7320, 7431), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'prog': '"""CLAMM"""', 'description': '"""\n CLAssical Music Manager\n """'}), '(prog=\'CLAMM\', description=\n """\n CLAssical Music Manager\n """)\n', (7343, 7431), False, 'import argparse\n'), (... |
# Generated by Django 2.1.2 on 2018-10-07 05:32
from django.db import migrations, models
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
migrations.CreateModel(
name='ViralVideo',
fields=[
('id', models.AutoFie... | [
"django.db.models.TextField",
"django.db.models.CharField",
"django.db.models.PositiveIntegerField",
"django.db.models.AutoField",
"django.db.models.DateTimeField"
] | [((306, 399), 'django.db.models.AutoField', 'models.AutoField', ([], {'auto_created': '(True)', 'primary_key': '(True)', 'serialize': '(False)', 'verbose_name': '"""ID"""'}), "(auto_created=True, primary_key=True, serialize=False,\n verbose_name='ID')\n", (322, 399), False, 'from django.db import migrations, models\... |
import subprocess
#current_machine_id está recebendo o get uuid da máquina
current_machine_id = str(subprocess.check_output('wmic csproduct get uuid'), 'utf-8').split('\n')[1].strip()
#current_machine_bios está recebendo o get serialnumber da bios
current_machine_bios = str(subprocess.check_output('wmic bios ge... | [
"subprocess.check_output"
] | [((104, 154), 'subprocess.check_output', 'subprocess.check_output', (['"""wmic csproduct get uuid"""'], {}), "('wmic csproduct get uuid')\n", (127, 154), False, 'import subprocess\n'), ((283, 336), 'subprocess.check_output', 'subprocess.check_output', (['"""wmic bios get serialnumber"""'], {}), "('wmic bios get serialn... |
from django.core.cache import caches
from django.core.serializers.json import DjangoJSONEncoder
from django.db.models.manager import ManagerDescriptor
from django.db import models
from django.conf import settings
import json
import logging
class CacheController(object):
def __init__(self,
field... | [
"django.db.models.signals.post_delete.connect",
"django.db.models.manager.ManagerDescriptor",
"json.loads",
"json.dumps",
"django.db.models.signals.post_save.connect"
] | [((3192, 3255), 'django.db.models.signals.post_save.connect', 'models.signals.post_save.connect', (['self._post_save'], {'sender': 'model'}), '(self._post_save, sender=model)\n', (3224, 3255), False, 'from django.db import models\n'), ((3264, 3331), 'django.db.models.signals.post_delete.connect', 'models.signals.post_d... |
#
# Copyright (c) 2020 IBM Corp.
# 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 writi... | [
"pyarrow.ExtensionArray.from_storage",
"pyarrow.concat_arrays",
"pyarrow.ListArray.from_arrays",
"pyarrow.types.is_struct",
"text_extensions_for_pandas.array.tensor.TensorArray",
"numpy.ndarray",
"numpy.prod",
"numpy.zeros_like",
"pyarrow.from_numpy_dtype",
"text_extensions_for_pandas.array.token_... | [((4249, 4274), 'pyarrow.array', 'pa.array', (['char_span.begin'], {}), '(char_span.begin)\n', (4257, 4274), True, 'import pyarrow as pa\n'), ((4292, 4315), 'pyarrow.array', 'pa.array', (['char_span.end'], {}), '(char_span.end)\n', (4300, 4315), True, 'import pyarrow as pa\n'), ((4542, 4605), 'pyarrow.DictionaryArray.f... |
# Copyright (C) 2019 New York University.
#
# This file is part of REANA Templates. REANA Templates is free software; you
# can redistribute it and/or modify it under the terms of the MIT License; see
# LICENSE file for more details.
"""Test loading REANA templates from file."""
import os
import shutil
from unittest... | [
"os.mkdir",
"os.path.isdir",
"shutil.rmtree",
"os.path.join",
"os.listdir"
] | [((543, 565), 'os.path.isdir', 'os.path.isdir', (['TMP_DIR'], {}), '(TMP_DIR)\n', (556, 565), False, 'import os\n'), ((610, 627), 'os.mkdir', 'os.mkdir', (['TMP_DIR'], {}), '(TMP_DIR)\n', (618, 627), False, 'import os\n'), ((715, 737), 'os.path.isdir', 'os.path.isdir', (['TMP_DIR'], {}), '(TMP_DIR)\n', (728, 737), Fals... |
import time
from pytcp_message import TcpServer, TcpClient
from datetime import datetime
from threading import Thread
ADDR = "127.0.0.1"
PORT = 8080
def log_request(req, _):
now = datetime.now().strftime("%F %T")
print(
"[{}] {} <-- {}".format(
now,
req.get_client_address()[0... | [
"threading.Thread",
"pytcp_message.TcpClient",
"time.sleep",
"pytcp_message.TcpServer",
"datetime.datetime.now"
] | [((827, 872), 'pytcp_message.TcpServer', 'TcpServer', ([], {'address': 'ADDR', 'port': 'PORT', 'timeout': '(5)'}), '(address=ADDR, port=PORT, timeout=5)\n', (836, 872), False, 'from pytcp_message import TcpServer, TcpClient\n'), ((1097, 1120), 'pytcp_message.TcpClient', 'TcpClient', (['(ADDR, PORT)'], {}), '((ADDR, POR... |
import itertools
from typing import List, Tuple, Union
import numpy as np
from quara.objects.state import State
from quara.objects.povm import Povm
from quara.objects.qoperation import QOperation
from quara.objects.qoperations import SetQOperations
from quara.protocol.qtomography.standard.standard_qtomography import ... | [
"numpy.zeros",
"quara.utils.number_util.to_stream",
"quara.qcircuit.experiment.Experiment",
"itertools.chain.from_iterable",
"quara.objects.qoperations.SetQOperations",
"numpy.sqrt"
] | [((2227, 2321), 'quara.qcircuit.experiment.Experiment', 'Experiment', ([], {'states': '[None]', 'gates': '[]', 'povms': 'povms', 'schedules': 'schedules', 'seed_data': 'seed_data'}), '(states=[None], gates=[], povms=povms, schedules=schedules,\n seed_data=seed_data)\n', (2237, 2321), False, 'from quara.qcircuit.expe... |
#!/usr/bin/env python3
import logging
import os
from argparse import ArgumentParser
# from sbws.lib.resultdump import load_recent_results_in_datadir
from sbws.lib.v3bwfile import V3BWFile
from .plotxys import plot_xys, combine_bwfiles
log = logging.getLogger(__name__)
OUT_DNAME = 'bw_graphs_data'
OUT_DPATH = os.path... | [
"os.path.abspath",
"os.makedirs",
"argparse.ArgumentParser",
"sbws.lib.v3bwfile.V3BWFile.from_v110_fpath",
"sbws.lib.v3bwfile.V3BWFile.from_v100_fpath",
"sbws.lib.v3bwfile.V3BWFile.from_v100_lines",
"logging.getLogger"
] | [((244, 271), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (261, 271), False, 'import logging\n'), ((430, 469), 'argparse.ArgumentParser', 'ArgumentParser', ([], {'description': '"""Bw stats."""'}), "(description='Bw stats.')\n", (444, 469), False, 'from argparse import ArgumentParser\n... |
"""
spotilyzer test mock describe_spot_price_history paginator
"""
# system
import os
import pickle
# test imports
from .base import MockPaginatorsBase
class MockDescribeSpotPriceHistoryPaginator(MockPaginatorsBase):
def paginate(self, **kwargs):
spot_price_dir = os.path.join(self.data_dir, 'spot-price... | [
"pickle.load",
"os.path.join",
"os.listdir"
] | [((281, 358), 'os.path.join', 'os.path.join', (['self.data_dir', '"""spot-price-history"""', "kwargs['AvailabilityZone']"], {}), "(self.data_dir, 'spot-price-history', kwargs['AvailabilityZone'])\n", (293, 358), False, 'import os\n'), ((425, 451), 'os.listdir', 'os.listdir', (['spot_price_dir'], {}), '(spot_price_dir)\... |
# (C) Datadog, Inc. 2022-present
# All rights reserved
# Licensed under a 3-clause BSD style license (see LICENSE)
from datadog_checks.base.utils.common import total_time_to_temporal_percent
from datadog_checks.base.utils.constants import SECOND
class Resource:
def __init__(self, name):
self.name = name.r... | [
"datadog_checks.base.utils.common.total_time_to_temporal_percent"
] | [((3207, 3258), 'datadog_checks.base.utils.common.total_time_to_temporal_percent', 'total_time_to_temporal_percent', (['value'], {'scale': 'SECOND'}), '(value, scale=SECOND)\n', (3237, 3258), False, 'from datadog_checks.base.utils.common import total_time_to_temporal_percent\n')] |
"""Sanic REST interface for Redis."""
import json
import os
import aioredis
from sanic import Sanic, response
from redis_rest.apidocs import bp as apidocs_blueprint
app = Sanic()
app.config.ACCESS_LOG = False
app.blueprint(apidocs_blueprint)
redis_host = os.environ.get('REDIS_HOST', 'localhost')
redis_port = os.env... | [
"json.loads",
"json.dumps",
"aioredis.create_redis_pool",
"os.environ.get",
"sanic.Sanic",
"sanic.response.json"
] | [((174, 181), 'sanic.Sanic', 'Sanic', ([], {}), '()\n', (179, 181), False, 'from sanic import Sanic, response\n'), ((259, 300), 'os.environ.get', 'os.environ.get', (['"""REDIS_HOST"""', '"""localhost"""'], {}), "('REDIS_HOST', 'localhost')\n", (273, 300), False, 'import os\n'), ((314, 348), 'os.environ.get', 'os.enviro... |
from django.db import models
from .GradeCurricular import GradeCurricular
class Periodo(models.Model):
gradeCurricular = models.ForeignKey(to='GradeCurricular', related_name="periodos", null=False, blank=False) #onetomany
numero = models.SmallIntegerField(null=False) #tinyint
disciplinas = models.ManyToMa... | [
"django.db.models.ForeignKey",
"django.db.models.SmallIntegerField",
"django.db.models.ManyToManyField"
] | [((127, 220), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'to': '"""GradeCurricular"""', 'related_name': '"""periodos"""', 'null': '(False)', 'blank': '(False)'}), "(to='GradeCurricular', related_name='periodos', null=False,\n blank=False)\n", (144, 220), False, 'from django.db import models\n'), ((241... |
import gc
import random
import weakref
from ..linalg import Vector3, Matrix4, Quaternion
from ..resources import Resource, Buffer
from ..utils import array_from_shadertype
# Keep track of id's. About the max:
# * 2_147_483_647 (2**31 -1) max number for signed i32.
# * 16_777_216 max integer that can be stored exa... | [
"gc.collect",
"random.randint",
"weakref.WeakKeyDictionary",
"weakref.WeakSet"
] | [((425, 452), 'weakref.WeakKeyDictionary', 'weakref.WeakKeyDictionary', ([], {}), '()\n', (450, 452), False, 'import weakref\n'), ((636, 653), 'weakref.WeakSet', 'weakref.WeakSet', ([], {}), '()\n', (651, 653), False, 'import weakref\n'), ((3979, 4008), 'random.randint', 'random.randint', (['(1)', '(_idmax - 1)'], {}),... |
from collections import deque
from pathlib import Path
from typing import List
import logging
def round_file_size_to_human_friendly_units(num_bytes):
units = ["bytes", "KiB", "MiB", "GiB", "TiB"]
multiplier = 1024
ans, i = num_bytes, 0
while ans > multiplier and i < len(units) - 1:
ans /= mult... | [
"logging.error",
"collections.deque"
] | [((1749, 1756), 'collections.deque', 'deque', ([], {}), '()\n', (1754, 1756), False, 'from collections import deque\n'), ((1381, 1472), 'logging.error', 'logging.error', (['f"""Error while listing directory contents of \'{dir_path}\'"""'], {'exc_info': '(True)'}), '(f"Error while listing directory contents of \'{dir_pa... |
import sys ; sys.path.append('../osbot_browser')
from unittest import TestCase
from osbot_browser.browser.Web_Server import Web_Server
class Test_Web_Server(TestCase):
def setUp(self):
self.web_server = Web_Server()
self.web_server.start()
def tearDown(self):
self.web_serve... | [
"sys.path.append",
"osbot_browser.browser.Web_Server.Web_Server"
] | [((13, 48), 'sys.path.append', 'sys.path.append', (['"""../osbot_browser"""'], {}), "('../osbot_browser')\n", (28, 48), False, 'import sys\n'), ((228, 240), 'osbot_browser.browser.Web_Server.Web_Server', 'Web_Server', ([], {}), '()\n', (238, 240), False, 'from osbot_browser.browser.Web_Server import Web_Server\n')] |
# -*- coding: utf-8 -*-
from django.shortcuts import render
from django.contrib.auth.decorators import login_required
# this login required decorator is to not allow to any view without authenticating
@login_required(login_url="login/")
def home(request):
return render(request, "home.html")
| [
"django.contrib.auth.decorators.login_required",
"django.shortcuts.render"
] | [((205, 239), 'django.contrib.auth.decorators.login_required', 'login_required', ([], {'login_url': '"""login/"""'}), "(login_url='login/')\n", (219, 239), False, 'from django.contrib.auth.decorators import login_required\n'), ((270, 298), 'django.shortcuts.render', 'render', (['request', '"""home.html"""'], {}), "(req... |
# pyOCD debugger
# Copyright (c) 2015-2020 Arm Limited
# Copyright (c) 2021 <NAME>
# SPDX-License-Identifier: Apache-2.0
#
# 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.apa... | [
"typing.cast",
"logging.getLogger"
] | [((889, 916), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (906, 916), False, 'import logging\n'), ((5536, 5558), 'typing.cast', 'cast', (['tuple', 'info.type'], {}), '(tuple, info.type)\n', (5540, 5558), False, 'from typing import Any, Dict, Iterable, List, Optional, Tuple, Union, cast... |
#!/usr/bin/env python
"""
ENCODE QC log parser wrapper which converts a log file into a dict
Author: <NAME> (<EMAIL>)
"""
from collections import OrderedDict
MAP_KEY_DESC_FRAC_MITO_QC = {
'non_mito_reads': 'Rn = Number of Non-mitochondrial Reads',
'mito_reads': 'Rm = Number of Mitochondrial Reads',
'fra... | [
"collections.OrderedDict"
] | [((425, 438), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (436, 438), False, 'from collections import OrderedDict\n'), ((1836, 1849), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (1847, 1849), False, 'from collections import OrderedDict\n'), ((9276, 9289), 'collections.OrderedDict', 'Orde... |
import json
import os
import random
import unittest
import life
class TestGameOfLife(unittest.TestCase):
def setUp(self):
self.grid = [
[1, 1, 0, 0, 1, 1, 1, 1],
[0, 1, 1, 1, 1, 1, 1, 0],
[1, 0, 1, 1, 0, 0, 0, 0],
[1, 0, 0, 0, 0, 0, 0, 1],
[1, 0... | [
"json.load",
"os.path.dirname",
"life.GameOfLife",
"random.seed",
"os.path.join"
] | [((528, 551), 'life.GameOfLife', 'life.GameOfLife', (['(3, 3)'], {}), '((3, 3))\n', (543, 551), False, 'import life\n'), ((728, 751), 'life.GameOfLife', 'life.GameOfLife', (['(3, 3)'], {}), '((3, 3))\n', (743, 751), False, 'import life\n'), ((760, 778), 'random.seed', 'random.seed', (['(12345)'], {}), '(12345)\n', (771... |
from __future__ import division
from __future__ import print_function
from pylab import *
import pandas as pd
from numba import jit, jitclass
from numba import int64, int32, int16, float64, float32, int16
from EMestimation import *
Salmonella_dtype = [('dim', int64),
('Nh', int64),
... | [
"numba.jitclass"
] | [((389, 415), 'numba.jitclass', 'jitclass', (['Salmonella_dtype'], {}), '(Salmonella_dtype)\n', (397, 415), False, 'from numba import jit, jitclass\n'), ((5401, 5426), 'numba.jitclass', 'jitclass', (['fourState_dtype'], {}), '(fourState_dtype)\n', (5409, 5426), False, 'from numba import jit, jitclass\n')] |
import json
from .models import *
from users.models import User
def guestcart(request):
try:
cart = json.loads(request.COOKIES['cart'])
except:
cart={}
print("cart: ", cart)
items = []
order={'total_bill':0,'total_quantity':0}
cart_quantity = order['total_quantity']
for i... | [
"users.models.User.objects.get_or_create",
"json.loads"
] | [((1823, 1862), 'users.models.User.objects.get_or_create', 'User.objects.get_or_create', ([], {'email': 'email'}), '(email=email)\n', (1849, 1862), False, 'from users.models import User\n'), ((113, 148), 'json.loads', 'json.loads', (["request.COOKIES['cart']"], {}), "(request.COOKIES['cart'])\n", (123, 148), False, 'im... |
#!/usr/bin/env python
import vtk
# Sphere
sphereSource = vtk.vtkSphereSource()
sphereSource.SetCenter(-4.0, 0.0, 0.0)
sphereSource.SetRadius(4.0)
sphereMapper = vtk.vtkPolyDataMapper()
sphereMapper.SetInputConnection(sphereSource.GetOutputPort())
sphereActor = vtk.vtkActor()
sphereActor.SetMapper(sphereMapper)
# Re... | [
"vtk.vtkRenderer",
"vtk.vtkRenderWindow",
"vtk.vtkSphereSource",
"vtk.vtkBalloonRepresentation",
"vtk.vtkActor",
"vtk.vtkBalloonWidget",
"vtk.vtkRenderWindowInteractor",
"vtk.vtkRegularPolygonSource",
"vtk.vtkPolyDataMapper"
] | [((58, 79), 'vtk.vtkSphereSource', 'vtk.vtkSphereSource', ([], {}), '()\n', (77, 79), False, 'import vtk\n'), ((163, 186), 'vtk.vtkPolyDataMapper', 'vtk.vtkPolyDataMapper', ([], {}), '()\n', (184, 186), False, 'import vtk\n'), ((264, 278), 'vtk.vtkActor', 'vtk.vtkActor', ([], {}), '()\n', (276, 278), False, 'import vtk... |
import numpy as np
from sys import platform
import os
def get_slash():
if platform == 'win32':
return '\\'
else:
return '/'
def kpoint_segment(first, second, pps):
"""
:param first: first k-point
:param second: second k-point
:param pps: points per segment
:return: normal... | [
"numpy.zeros",
"numpy.linalg.norm",
"numpy.array",
"numpy.linspace",
"numpy.linalg.solve"
] | [((390, 405), 'numpy.array', 'np.array', (['first'], {}), '(first)\n', (398, 405), True, 'import numpy as np\n'), ((419, 435), 'numpy.array', 'np.array', (['second'], {}), '(second)\n', (427, 435), True, 'import numpy as np\n'), ((447, 477), 'numpy.linalg.norm', 'np.linalg.norm', (['(second - first)'], {}), '(second - ... |
# coding: utf-8
import mxnet as mx
@mx.init.register
class MyConstant(mx.init.Initializer):
def __init__(self, value):
super(MyConstant, self).__init__(value=value)
self.value = value
def _init_weight(self, _, arr):
arr[:] = mx.nd.array(self.value)
def get_shape(x):
if isinstance... | [
"mxnet.nd.array"
] | [((260, 283), 'mxnet.nd.array', 'mx.nd.array', (['self.value'], {}), '(self.value)\n', (271, 283), True, 'import mxnet as mx\n')] |
import numpy as np
from pyglib.model import circauxi
import shutil,subprocess
cmd = ['/home/ykent/WIEN_GUTZ/bin2/CyGutz', '-r', '-1']
for i,u in enumerate(np.arange(1.0,0.9,-10)):
print(' Running with u = {}'.format(u))
circauxi.gutz_model_setup(u=u, nmesh=5000, norb=3, tiny=0.0, mu=0.0)
subprocess.call(c... | [
"pyglib.model.circauxi.gutz_model_setup",
"shutil.copyfile",
"subprocess.call",
"numpy.arange"
] | [((157, 181), 'numpy.arange', 'np.arange', (['(1.0)', '(0.9)', '(-10)'], {}), '(1.0, 0.9, -10)\n', (166, 181), True, 'import numpy as np\n'), ((230, 298), 'pyglib.model.circauxi.gutz_model_setup', 'circauxi.gutz_model_setup', ([], {'u': 'u', 'nmesh': '(5000)', 'norb': '(3)', 'tiny': '(0.0)', 'mu': '(0.0)'}), '(u=u, nme... |
#This is the builder from symbol
from __future__ import print_function
import mxnet as mx
import mxnext as X
from utils.patch_config import patch_config_as_nothrow
class RPN(object):
_rpn_output = None
def __init__(self):
pass
@classmethod
def get_train_symbol(cls, backbone, neck, rpn_head)... | [
"mxnet.viz.print_summary",
"mxnext.block_grad",
"mxnext.convrelu",
"mxnext.gauss",
"mxnext.to_fp32",
"mxnext.relu",
"mxnext.softmax_output",
"mxnext.decode_bbox",
"mxnext.group",
"mxnext.smooth_l1",
"mxnext.proposal_target",
"mxnext.convnormrelu",
"mxnext.loss",
"mxnext.var",
"mxnext.roi... | [((346, 368), 'mxnext.var', 'X.var', (['"""rpn_cls_label"""'], {}), "('rpn_cls_label')\n", (351, 368), True, 'import mxnext as X\n'), ((394, 417), 'mxnext.var', 'X.var', (['"""rpn_reg_target"""'], {}), "('rpn_reg_target')\n", (399, 417), True, 'import mxnext as X\n'), ((443, 466), 'mxnext.var', 'X.var', (['"""rpn_reg_w... |
# coding:utf-8
from bokeh.charts import TimeSeries, show, output_file
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib
import json
from itertools import cycle
## 在这里设置好字体等因素
from pylab import mpl
mpl.rcParams['font.sans-serif'] = ['Adobe Heiti Std'] # 指定默认字体
mpl.rcParams['a... | [
"pandas.DataFrame",
"matplotlib.pyplot.show",
"matplotlib.pyplot.legend",
"bokeh.charts.show",
"numpy.random.random",
"matplotlib.ticker.OldScalarFormatter",
"itertools.cycle",
"matplotlib.pyplot.subplots",
"pandas.concat"
] | [((1024, 1038), 'matplotlib.pyplot.subplots', 'plt.subplots', ([], {}), '()\n', (1036, 1038), True, 'import matplotlib.pyplot as plt\n'), ((2288, 2298), 'matplotlib.pyplot.show', 'plt.show', ([], {}), '()\n', (2296, 2298), True, 'import matplotlib.pyplot as plt\n'), ((2611, 2764), 'itertools.cycle', 'cycle', (["['-', '... |
# Generated by Django 3.0.7 on 2020-06-15 19:20
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('backend', '0006_auto_20200614_1241'),
]
operations = [
migrations.AddField(
model_name='project',
name='created_at',... | [
"django.db.models.DateTimeField"
] | [((339, 374), 'django.db.models.DateTimeField', 'models.DateTimeField', ([], {'auto_now': '(True)'}), '(auto_now=True)\n', (359, 374), False, 'from django.db import migrations, models\n')] |
from setuptools import setup, find_packages
setup(
name='ecobee-exporter',
version='1.0.0',
description='Ecobee Exporter',
author='<NAME>',
author_email='<EMAIL>',
url='https://github.com/burnison/ecobee-exporter',
packages=find_packages(),
include_pack... | [
"setuptools.find_packages"
] | [((283, 298), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (296, 298), False, 'from setuptools import setup, find_packages\n')] |
"""
SPDX-FileCopyrightText: 2019 oemof developer group <<EMAIL>>
SPDX-License-Identifier: MIT
"""
import pandas as pd
import numpy as np
import pytest
from pandas.util.testing import assert_frame_equal
from windpowerlib.power_curves import (smooth_power_curve,
wake_losses_to_pow... | [
"windpowerlib.power_curves.smooth_power_curve",
"windpowerlib.wind_turbine.WindTurbine",
"windpowerlib.power_curves.wake_losses_to_power_curve",
"pytest.raises",
"numpy.arange",
"pandas.Series",
"pandas.concat"
] | [((1218, 1274), 'pandas.Series', 'pd.Series', (['[6.0, 7.0, 8.0, 9.0, 10.0]'], {'name': '"""wind_speed"""'}), "([6.0, 7.0, 8.0, 9.0, 10.0], name='wind_speed')\n", (1227, 1274), True, 'import pandas as pd\n'), ((1344, 1473), 'pandas.Series', 'pd.Series', (['[1141906.9806766496, 1577536.8085282773, 1975480.993355767, \n ... |
import pytest
import re
@pytest.mark.parametrize("running_clients_num", [0, 1, 2])
def test_single_frame_layout(hlwm, running_clients, running_clients_num):
assert hlwm.get_attr('tags.0.curframe_windex') == '0'
assert int(hlwm.get_attr('tags.0.client_count')) == running_clients_num
assert int(hlwm.get_att... | [
"pytest.mark.parametrize",
"re.sub"
] | [((27, 84), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""running_clients_num"""', '[0, 1, 2]'], {}), "('running_clients_num', [0, 1, 2])\n", (50, 84), False, 'import pytest\n'), ((623, 677), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""running_clients_num"""', '[2, 3]'], {}), "('running_cl... |
#!/usr/bin/python
"""
__version__ = "$Revision: 1.3 $"
__date__ = "$Date: 2004/04/14 02:38:47 $"
"""
import nID
import plugin
import os
repository_nid="all_url:https://www.dropbox.com/s/tvyxx5iidodidz2/nid_sample_list.txt?dl=1@name:Sample Repo Name@owner:myselfminer"
from PythonCard import model
class MyBackground... | [
"nID.parse",
"plugin.get_nid_by_name",
"plugin.get_local_nids",
"PythonCard.model.Application",
"plugin.listall"
] | [((1550, 1581), 'PythonCard.model.Application', 'model.Application', (['MyBackground'], {}), '(MyBackground)\n', (1567, 1581), False, 'from PythonCard import model\n'), ((535, 565), 'plugin.listall', 'plugin.listall', (['repository_nid'], {}), '(repository_nid)\n', (549, 565), False, 'import plugin\n'), ((843, 907), 'p... |
import numpy as np
# Was told built-in libraries are acceptable.
from collections import Counter
class Node:
def __init__(self, left=None, right=None,
best_feature=None, threshold=None, value=None):
self.left = left
self.right = right
self.best_feature = best_feature
... | [
"numpy.log2",
"numpy.random.choice",
"numpy.argwhere",
"collections.Counter",
"numpy.bincount",
"numpy.unique"
] | [((1449, 1508), 'numpy.random.choice', 'np.random.choice', (['num_features', 'num_features'], {'replace': '(False)'}), '(num_features, num_features, replace=False)\n', (1465, 1508), True, 'import numpy as np\n'), ((3475, 3489), 'numpy.bincount', 'np.bincount', (['y'], {}), '(y)\n', (3486, 3489), True, 'import numpy as ... |
"""
Communicate between Python and Javascript asynchronously using
inter-process messaging with the use of Javascript Bindings.
"""
from cefpython3 import cefpython as cef
import os
import json
import csv
from ase import Atoms
from ase.io.trajectory import TrajectoryReader
from sklearn.preprocessing import normalize
... | [
"json.dump",
"csv.writer",
"cefpython3.cefpython.Initialize",
"os.getcwd",
"os.path.dirname",
"cefpython3.cefpython.CreateBrowserSync",
"cefpython3.cefpython.Shutdown",
"cefpython3.cefpython.JavascriptBindings",
"sklearn.preprocessing.normalize",
"cefpython3.cefpython.MessageLoop",
"os.path.join... | [((2027, 2060), 'cefpython3.cefpython.Initialize', 'cef.Initialize', ([], {'settings': 'settings'}), '(settings=settings)\n', (2041, 2060), True, 'from cefpython3 import cefpython as cef\n'), ((2071, 2082), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (2080, 2082), False, 'import os\n'), ((2367, 2392), 'os.path.dirname'... |
from django.conf.urls import url
from .views import *
urlpatterns = [
url(r'^RTF$',index),
url(r'^home$',home),
url(r'^ys$',ys_cache),
url(r'^send$',send_my_email),
url(r'^email$',sendmail),
url(r'^send_v2$',send_email_v2),
url(r'^huohuo$',send_many_email),
url(r'^send_v3$',create_confi... | [
"django.conf.urls.url"
] | [((75, 94), 'django.conf.urls.url', 'url', (['"""^RTF$"""', 'index'], {}), "('^RTF$', index)\n", (78, 94), False, 'from django.conf.urls import url\n'), ((100, 119), 'django.conf.urls.url', 'url', (['"""^home$"""', 'home'], {}), "('^home$', home)\n", (103, 119), False, 'from django.conf.urls import url\n'), ((125, 146)... |
import traceback
from js_ast import *
from js_global import glob, Glob
from js_typespace import *
from js_cc import *
from js_process_ast import *
import os, os.path
import ctypes, struct
class TypeEmitVisit(NodeVisit):
def __init__(self):
super(TypeEmitVisit, self).__init__()
self.required_nodes = node... | [
"os.path.split",
"traceback.format_exc"
] | [((14557, 14579), 'traceback.format_exc', 'traceback.format_exc', ([], {}), '()\n', (14577, 14579), False, 'import traceback\n'), ((15081, 15100), 'os.path.split', 'os.path.split', (['part'], {}), '(part)\n', (15094, 15100), False, 'import os, os.path\n')] |
import nso_ds_classes.nso_tif_kernel as nso_tif_kernel
import nso_ds_classes.nso_ds_models as nso_ds_models
import nso_ds_classes.nso_tif_sampler as nso_tif_sampler
import nso_ds_classes.nso_ds_cluster as nso_ds_cluster
from yellowbrick.cluster import KElbowVisualizer
from sklearn.cluster import KMeans
from sklearn.dat... | [
"nso_ds_classes.nso_ds_cluster.nso_cluster_break",
"nso_ds_classes.nso_tif_kernel.nso_tif_kernel_generator"
] | [((577, 671), 'nso_ds_classes.nso_tif_kernel.nso_tif_kernel_generator', 'nso_tif_kernel.nso_tif_kernel_generator', (['path_to_tif_file', 'x_kernel_width', 'y_kernel_height'], {}), '(path_to_tif_file, x_kernel_width,\n y_kernel_height)\n', (616, 671), True, 'import nso_ds_classes.nso_tif_kernel as nso_tif_kernel\n'),... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import MeCab
# from pyknp import Jumanpp
class MecabSplitter:
"""
Mecabを使って単語列(原形)を取得する
https://github.com/katryo/tfidf_with_sklearn/blob/master/utils.py
"""
def __init__(self):
self.m = MeCab.Tagger("mecabrc")
def split(self, sentence)... | [
"MeCab.Tagger"
] | [((266, 289), 'MeCab.Tagger', 'MeCab.Tagger', (['"""mecabrc"""'], {}), "('mecabrc')\n", (278, 289), False, 'import MeCab\n')] |
# *****************************************************************
# Copyright 2013 MIT Lincoln Laboratory
# Project: SPAR
# Authors: MZ
# Description: Class for testing ta1_graphing
#
#
# Modifications:
# Date Name Mo... | [
"spar_python.report_generation.common.graphing.graph2d",
"spar_python.report_generation.common.graphing.box_plot",
"spar_python.report_generation.common.graphing.comparison_percentile_graph",
"unittest.skip",
"spar_python.report_generation.common.graphing.graph3d",
"spar_python.report_generation.common.re... | [((803, 867), 'spar_python.report_generation.common.regression.Function', 'regression.Function', (['ARBITRARY_FUNC_3D', 'ARBITRARY_FUNC_STRING_3D'], {}), '(ARBITRARY_FUNC_3D, ARBITRARY_FUNC_STRING_3D)\n', (822, 867), True, 'import spar_python.report_generation.common.regression as regression\n'), ((962, 1030), 'spar_py... |
import os
import sys
from unity_config import *
# private config options
LOG_DEV = False
class InlineException(Exception):
def __init__(self, message):
self.message = message
def utf8_file_readlines(file):
try:
return file.readlines()
except UnicodeDecodeError:
raise InlineExcepti... | [
"os.remove",
"os.path.abspath",
"os.path.basename",
"os.path.relpath",
"sys.stderr.write"
] | [((742, 761), 'os.remove', 'os.remove', (['filePath'], {}), '(filePath)\n', (751, 761), False, 'import os\n'), ((945, 986), 'sys.stderr.write', 'sys.stderr.write', (["('debug - ' + msg + '\\n')"], {}), "('debug - ' + msg + '\\n')\n", (961, 986), False, 'import sys\n'), ((1977, 2015), 'os.path.basename', 'os.path.basena... |
# -*- coding: utf-8 -*-
"""hipchat signal definitions."""
from django.dispatch import Signal
# Signal sent when the app receives a data request from HipChat. The signal
# is fired from within the view function (so inside an HTTP request/response)
# so this *is* performance-bound. The signal is used as a mechanism for
... | [
"django.dispatch.Signal"
] | [((505, 538), 'django.dispatch.Signal', 'Signal', ([], {'providing_args': "['glance']"}), "(providing_args=['glance'])\n", (511, 538), False, 'from django.dispatch import Signal\n')] |
# -*- coding: UTF-8 -*-
# **********************************************************************************#
# File: PMS entity file.
# Author: Myron
# **********************************************************************************#
import pandas as pd
from copy import copy
from .. base import *
from .. pms_b... | [
"lib.gateway.subscriber.MarketQuote.get_instance",
"pandas.to_datetime",
"copy.copy"
] | [((6848, 6874), 'lib.gateway.subscriber.MarketQuote.get_instance', 'MarketQuote.get_instance', ([], {}), '()\n', (6872, 6874), False, 'from lib.gateway.subscriber import MarketQuote\n'), ((10070, 10094), 'copy.copy', 'copy', (['self.position_info'], {}), '(self.position_info)\n', (10074, 10094), False, 'from copy impor... |
import cls_for_reading_tif as clsrt
import create_data_bunch as dataFuncs
import fastai
from fastai.vision import *
from fastai.callbacks import *
from fastai.utils.mem import *
from pathlib import Path
import torch
import torchvision
from torch import nn
import models as mymodels
def createLearner(data,model_choice=... | [
"models.myDnCNN",
"models.DnCNN"
] | [((366, 382), 'models.DnCNN', 'mymodels.DnCNN', ([], {}), '()\n', (380, 382), True, 'import models as mymodels\n'), ((409, 427), 'models.myDnCNN', 'mymodels.myDnCNN', ([], {}), '()\n', (425, 427), True, 'import models as mymodels\n')] |
# ------------------------------------------------------------------------------------------------------------------------
# -*- coding: utf-8 -*-
# ------------------------------------------------------------------------------------------------------------------------
import dash_core_components as dcc
import dash_h... | [
"dash_core_components.Markdown",
"dash_html_components.H3",
"dash_html_components.Sub",
"dash_html_components.Div",
"dash_html_components.A",
"dash_html_components.Li",
"dash_html_components.Span"
] | [((974, 1024), 'dash_html_components.Div', 'html.Div', ([], {'className': '"""aboutMain"""', 'children': 'children'}), "(className='aboutMain', children=children)\n", (982, 1024), True, 'import dash_html_components as html\n'), ((1091, 1125), 'dash_html_components.H3', 'html.H3', (['"""SLEXIL basics"""'], {'id': '"""to... |
"""
Permutations without reps - no duplicates sol I
O(n!)
elements:
string || char list || int list
"""
def permute_without_reps(elements):
if len(elements) == 1:
return elements
permutation_opts = []
recursive_permutations = permute_without_reps(elements[1:])
first_opt ... | [
"itertools.permutations"
] | [((1081, 1111), 'itertools.permutations', 'itertools.permutations', (['string'], {}), '(string)\n', (1103, 1111), False, 'import itertools\n')] |
import asyncio
from unittest import mock
import pytest
from redical import create_pool, PoolClosedError, PoolClosingError, WatchError
pytestmark = [pytest.mark.asyncio]
@pytest.fixture
async def pool(redis_uri):
pool = await create_pool(redis_uri, max_size=4, min_size=2)
await pool.execute('flushdb')
yield pool... | [
"asyncio.get_event_loop",
"redical.create_pool",
"asyncio.Event",
"unittest.mock.AsyncMock",
"asyncio.get_running_loop",
"pytest.raises"
] | [((3880, 3895), 'asyncio.Event', 'asyncio.Event', ([], {}), '()\n', (3893, 3895), False, 'import asyncio\n'), ((4969, 4984), 'asyncio.Event', 'asyncio.Event', ([], {}), '()\n', (4982, 4984), False, 'import asyncio\n'), ((6672, 6687), 'asyncio.Event', 'asyncio.Event', ([], {}), '()\n', (6685, 6687), False, 'import async... |
from ConfigParser import ConfigParser
import os
__author__ = 'irvan'
def load(config_file="config.ini"):
config_path = "{}/{}".format(os.getcwd(), config_file)
config = ConfigParser()
config.read(config_path)
return config
| [
"os.getcwd",
"ConfigParser.ConfigParser"
] | [((188, 202), 'ConfigParser.ConfigParser', 'ConfigParser', ([], {}), '()\n', (200, 202), False, 'from ConfigParser import ConfigParser\n'), ((148, 159), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (157, 159), False, 'import os\n')] |
from dateutil import parser
import datetime
import pandas as pd
import json
from matplotlib.dates import DateFormatter
def fridge_plot(directory, variable, start_date, end_date = None):
begin = parser.parse(start_date)
if end_date is None:
end = begin
else:
end = parser.parse(end... | [
"dateutil.parser.parse",
"pandas.DataFrame.from_dict",
"json.loads",
"matplotlib.dates.DateFormatter",
"pandas.to_datetime",
"datetime.timedelta"
] | [((206, 230), 'dateutil.parser.parse', 'parser.parse', (['start_date'], {}), '(start_date)\n', (218, 230), False, 'from dateutil import parser\n'), ((804, 837), 'pandas.DataFrame.from_dict', 'pd.DataFrame.from_dict', (['data_dict'], {}), '(data_dict)\n', (826, 837), True, 'import pandas as pd\n'), ((935, 961), 'pandas.... |
from copy import deepcopy
from uuid import UUID
import pytest
from hetdesrun.backend.models.io import ConnectorFrontendDto
from hetdesrun.backend.models.workflow import (
WorkflowIoFrontendDto,
WorkflowOperatorFrontendDto,
WorkflowLinkFrontendDto,
WorkflowRevisionFrontendDto,
position_from_input_co... | [
"hetdesrun.backend.models.wiring.WiringFrontendDto.from_wiring",
"copy.deepcopy",
"hetdesrun.backend.models.workflow.WorkflowRevisionFrontendDto",
"hetdesrun.backend.models.io.ConnectorFrontendDto",
"hetdesrun.backend.models.workflow.WorkflowOperatorFrontendDto",
"hetdesrun.backend.models.io.ConnectorFron... | [((31383, 31429), 'hetdesrun.backend.models.workflow.WorkflowIoFrontendDto', 'WorkflowIoFrontendDto', ([], {}), '(**valid_input_with_name)\n', (31404, 31429), False, 'from hetdesrun.backend.models.workflow import WorkflowIoFrontendDto, WorkflowOperatorFrontendDto, WorkflowLinkFrontendDto, WorkflowRevisionFrontendDto, p... |
# (C) Copyright 2005-2021 Enthought, Inc., Austin, TX
# All rights reserved.
#
# This software is provided without warranty under the terms of the BSD
# license included in LICENSE.txt and may be redistributed only under
# the conditions described in the aforementioned license. The license
# is also available online at... | [
"copy.deepcopy",
"weakref.ref",
"itertools.chain.from_iterable"
] | [((13048, 13059), 'weakref.ref', 'ref', (['object'], {}), '(object)\n', (13051, 13059), False, 'from weakref import ref\n'), ((10533, 10558), 'itertools.chain.from_iterable', 'chain.from_iterable', (['args'], {}), '(args)\n', (10552, 10558), False, 'from itertools import chain\n'), ((11034, 11056), 'copy.deepcopy', 'co... |
import pytest
from import_me import Column
from import_me.constants import COLUMN_NAME_PATTERN
from import_me.exceptions import ParserError
@pytest.mark.parametrize(
'column_name',
('a', 'name', 'column_name', 'column_name1'),
)
def test_column_valid_name(column_name):
Column(name=column_name, index=0)
... | [
"import_me.Column",
"pytest.mark.parametrize",
"pytest.raises"
] | [((144, 232), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""column_name"""', "('a', 'name', 'column_name', 'column_name1')"], {}), "('column_name', ('a', 'name', 'column_name',\n 'column_name1'))\n", (167, 232), False, 'import pytest\n'), ((322, 397), 'pytest.mark.parametrize', 'pytest.mark.parametrize... |
from rest_framework.decorators import api_view, permission_classes
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response
from apps.tweets.models import Tweet
from apps.tweets.serializers import TweetSerializer
@api_view(["GET"])
def global_feed(request):
tweets = Twe... | [
"apps.tweets.models.Tweet.objects.all",
"apps.tweets.serializers.TweetSerializer",
"apps.tweets.models.Tweet.objects.following_feed",
"rest_framework.response.Response",
"rest_framework.decorators.permission_classes",
"rest_framework.decorators.api_view"
] | [((260, 277), 'rest_framework.decorators.api_view', 'api_view', (["['GET']"], {}), "(['GET'])\n", (268, 277), False, 'from rest_framework.decorators import api_view, permission_classes\n'), ((441, 458), 'rest_framework.decorators.api_view', 'api_view', (["['GET']"], {}), "(['GET'])\n", (449, 458), False, 'from rest_fra... |
#!/usr/bin/env python
"""
CREATED AT: 2022/1/5
Des:
https://leetcode.com/problems/palindrome-partitioning/
GITHUB: https://github.com/Jiezhi/myleetcode
Difficulty: Medium
Tag: DFS
See:
Time Spent: 20 min
"""
from functools import lru_cache
from typing import List
class Solution:
def partition(self, s: str) ... | [
"functools.lru_cache"
] | [((596, 611), 'functools.lru_cache', 'lru_cache', (['None'], {}), '(None)\n', (605, 611), False, 'from functools import lru_cache\n')] |
import shlex, argparse
from discord.ext.commands import MemberConverter, RoleConverter, MemberNotFound, RoleNotFound, Converter
from plugins.standard.discord_utils.polls.errors import PollCommandError
from plugins.standard.discord_utils.polls.poll_preset_model import PollPreset
ORDINAL_A = 127462
class Poll(Convert... | [
"argparse.ArgumentParser",
"discord.ext.commands.RoleConverter",
"plugins.standard.discord_utils.polls.errors.PollCommandError",
"shlex.split",
"discord.ext.commands.MemberConverter"
] | [((679, 718), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'add_help': '(False)'}), '(add_help=False)\n', (702, 718), False, 'import shlex, argparse\n'), ((1621, 1660), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'add_help': '(False)'}), '(add_help=False)\n', (1644, 1660), False, 'import ... |
import bpy
import datetime
from . properties import *
from . sun_calc import Move_sun
from . north import *
from . map import Map
from . hdr import Hdr
# ---------------------------------------------------------------------------
class ControlClass:
region = None
handler = None
def callback(self, os, ... | [
"bpy.context.scene.objects.get",
"bpy.types.SpaceView3D.draw_handler_remove",
"bpy.data.objects.get",
"bpy.app.handlers.load_pre.remove",
"bpy.ops.mesh.primitive_ico_sphere_add",
"bmesh.update_edit_mesh",
"bpy.types.SpaceView3D.draw_handler_add",
"bpy.ops.object.delete",
"datetime.date",
"bpy.app.... | [((1164, 1262), 'bpy.types.SpaceView3D.draw_handler_add', 'bpy.types.SpaceView3D.draw_handler_add', (['self.callback', '(self, context)', '"""WINDOW"""', '"""POST_PIXEL"""'], {}), "(self.callback, (self, context),\n 'WINDOW', 'POST_PIXEL')\n", (1202, 1262), False, 'import bpy\n'), ((8810, 8864), 'bpy.app.handlers.lo... |
# Generated by Django 3.2.6 on 2021-08-13 23:00
from django.db import migrations, models
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
migrations.CreateModel(
name='RandomCombination',
fields=[
('id', models.... | [
"django.db.models.BigAutoField",
"django.db.models.CharField",
"django.db.models.DateField"
] | [((313, 409), '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", (332, 409), False, 'from django.db import migrations, m... |
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under t... | [
"structurizr.model.Model",
"pytest.fixture",
"pytest.raises",
"structurizr.view.dynamic_view.DynamicView.hydrate",
"structurizr.view.dynamic_view.DynamicView",
"structurizr.model.SoftwareSystem",
"structurizr.view.dynamic_view.DynamicViewIO.from_orm",
"structurizr.model.Container"
] | [((749, 781), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""function"""'}), "(scope='function')\n", (763, 781), False, 'import pytest\n'), ((897, 929), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""function"""'}), "(scope='function')\n", (911, 929), False, 'import pytest\n'), ((1057, 1108), 'structuri... |
from rest_framework import viewsets
from rest_framework.authentication import TokenAuthentication
from django.contrib.auth.models import User
from rest_framework.permissions import IsAuthenticated
from rest_framework.authtoken.models import Token
from rest_framework.views import APIView
from rest_framework.response im... | [
"rest_framework.authtoken.models.Token.objects.create"
] | [((716, 747), 'rest_framework.authtoken.models.Token.objects.create', 'Token.objects.create', ([], {'user': 'user'}), '(user=user)\n', (736, 747), False, 'from rest_framework.authtoken.models import Token\n')] |
# coding=UTF-8
import datetime
import requests
from firebase import Firebase
f = Firebase('https://oildata2.firebaseio.com/datas')
file = open('output.txt', 'w')
now = datetime.datetime.now()
d1 = datetime.datetime(2015, 10, 12)
while (now-d1).days > 1 :
dayOfWeek = d1.weekday()
if dayOfWeek > 4 :
d1=d1+datetime.ti... | [
"datetime.datetime",
"datetime.timedelta",
"requests.post",
"datetime.datetime.now",
"firebase.Firebase"
] | [((81, 130), 'firebase.Firebase', 'Firebase', (['"""https://oildata2.firebaseio.com/datas"""'], {}), "('https://oildata2.firebaseio.com/datas')\n", (89, 130), False, 'from firebase import Firebase\n'), ((168, 191), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (189, 191), False, 'import datetime\n... |
import pytest
from datetime import datetime
from sqlalchemy.orm import Session
from candy.db.models import Courier, Order
@pytest.mark.asyncio
async def test_bad_req(api_client, migrated_postgres_connection):
response = await api_client.post("/orders/complete", json={
"courier_id": 0,
"order_id":... | [
"sqlalchemy.orm.Session",
"datetime.datetime.strptime",
"candy.db.models.Order",
"candy.db.models.Courier"
] | [((431, 468), 'sqlalchemy.orm.Session', 'Session', (['migrated_postgres_connection'], {}), '(migrated_postgres_connection)\n', (438, 468), False, 'from sqlalchemy.orm import Session\n'), ((484, 547), 'candy.db.models.Order', 'Order', ([], {'id': '(1)', 'weight': '(1)', 'region': '(1)', 'delivery_hours': "['15:30-20:30'... |
"""
Classes and code with MultiPLIER related functionality.
"""
import conf
import numpy as np
import pandas as pd
class MultiplierProjection(object):
"""Projects new data into the MultiPLIER latent space."""
def __init__(self):
pass
def transform(
self,
y: pd.DataFrame,
... | [
"pandas.read_pickle",
"warnings.warn",
"numpy.identity"
] | [((3704, 3758), 'pandas.read_pickle', 'pd.read_pickle', (["conf.MULTIPLIER['MODEL_Z_MATRIX_FILE']"], {}), "(conf.MULTIPLIER['MODEL_Z_MATRIX_FILE'])\n", (3718, 3758), True, 'import pandas as pd\n'), ((3881, 3935), 'pandas.read_pickle', 'pd.read_pickle', (["conf.MULTIPLIER['MODEL_METADATA_FILE']"], {}), "(conf.MULTIPLIER... |
import configparser
import os
import time
from neomodel import config as neomodel_conf
from praw import Reddit
from redis import Redis
from rq import Queue
def test():
return None
class Singleton:
_instance = None
def __new__(cls, *args, **kwargs):
if cls._instance is None:
cls._i... | [
"redis.Redis",
"os.path.dirname",
"rq.Queue",
"praw.Reddit",
"configparser.ConfigParser",
"os.getenv"
] | [((818, 845), 'configparser.ConfigParser', 'configparser.ConfigParser', ([], {}), '()\n', (843, 845), False, 'import configparser\n'), ((1149, 1157), 'praw.Reddit', 'Reddit', ([], {}), '()\n', (1155, 1157), False, 'from praw import Reddit\n'), ((1588, 1611), 'redis.Redis', 'Redis', ([], {'host': '"""127.0.0.1"""'}), "(... |
import sqlite3 as sql
import random
from datetime import datetime as dt
from flask import Flask, render_template, \
request, redirect, url_for
DATABASE_PATH = 'todo_app.db'
app = Flask(__name__)
def query_run(statement, flag=False):
out = []
try:
conn = sql.connect(DATABASE_PATH)
cursor ... | [
"random.randint",
"datetime.datetime.today",
"flask.Flask",
"flask.url_for",
"sqlite3.connect",
"flask.render_template"
] | [((185, 200), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (190, 200), False, 'from flask import Flask, render_template, request, redirect, url_for\n'), ((729, 779), 'flask.render_template', 'render_template', (['"""index.html"""'], {'todo_list': 'todo_list'}), "('index.html', todo_list=todo_list)\n", (7... |
import socket
from _thread import *
import sys
class Server:
def __init__(self, ip, port):
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
server = ip
port = port
self.server_ip = socket.gethostbyname(server)
try:
self.socket.bind((server, port))
... | [
"socket.socket",
"socket.gethostbyname"
] | [((118, 167), 'socket.socket', 'socket.socket', (['socket.AF_INET', 'socket.SOCK_STREAM'], {}), '(socket.AF_INET, socket.SOCK_STREAM)\n', (131, 167), False, 'import socket\n'), ((233, 261), 'socket.gethostbyname', 'socket.gethostbyname', (['server'], {}), '(server)\n', (253, 261), False, 'import socket\n')] |
# !/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import re
import ast
from setuptools import setup
_version_re = re.compile(r'__version__\s+=\s+(.*)')
with open('gogo/__init__.py', 'rb') as f:
version = str(ast.literal_eval(_version_re.search(
f.read().decode('utf-8')).group(1)))
setup(
name... | [
"setuptools.setup",
"re.compile"
] | [((122, 160), 're.compile', 're.compile', (['"""__version__\\\\s+=\\\\s+(.*)"""'], {}), "('__version__\\\\s+=\\\\s+(.*)')\n", (132, 160), False, 'import re\n'), ((305, 1132), 'setuptools.setup', 'setup', ([], {'name': '"""gogo"""', 'version': 'version', 'url': '"""http://github.com/v1c77/gogo"""', 'license': '"""WTFPL"... |
from MinStack import MinStack
minStack = MinStack();
minStack.push(-2);
minStack.push(0);
minStack.push(-3);
print(minStack.getMin()); # --> Returns -3.
minStack.pop();
print(minStack.top()); # --> Returns 0.
print(minStack.getMin()); # --> Returns -2.
| [
"MinStack.MinStack"
] | [((41, 51), 'MinStack.MinStack', 'MinStack', ([], {}), '()\n', (49, 51), False, 'from MinStack import MinStack\n')] |
import numpy as np
def softmax(a):
return np.exp(a) / np.sum(np.exp(a))
input_a = np.array([-3, -1.5, 0.3, 0.6, 1, 1.8, 3])
print(np.round(softmax(input_a), 3)) | [
"numpy.array",
"numpy.exp"
] | [((88, 129), 'numpy.array', 'np.array', (['[-3, -1.5, 0.3, 0.6, 1, 1.8, 3]'], {}), '([-3, -1.5, 0.3, 0.6, 1, 1.8, 3])\n', (96, 129), True, 'import numpy as np\n'), ((47, 56), 'numpy.exp', 'np.exp', (['a'], {}), '(a)\n', (53, 56), True, 'import numpy as np\n'), ((66, 75), 'numpy.exp', 'np.exp', (['a'], {}), '(a)\n', (72... |
import unittest
from katas.kyu_8.sum_of_positive import positive_sum
class PositiveSumTestCases(unittest.TestCase):
def test_equals(self):
self.assertEqual(positive_sum([1, 2, 3, 4, 5]), 15)
def test_equals_2(self):
self.assertEqual(positive_sum([1, -2, 3, 4, 5]), 13)
def test_equals_3... | [
"katas.kyu_8.sum_of_positive.positive_sum"
] | [((172, 201), 'katas.kyu_8.sum_of_positive.positive_sum', 'positive_sum', (['[1, 2, 3, 4, 5]'], {}), '([1, 2, 3, 4, 5])\n', (184, 201), False, 'from katas.kyu_8.sum_of_positive import positive_sum\n'), ((262, 292), 'katas.kyu_8.sum_of_positive.positive_sum', 'positive_sum', (['[1, -2, 3, 4, 5]'], {}), '([1, -2, 3, 4, 5... |
from dsmr_parser import telegram_specifications
from dsmr_parser.objects import Telegram
from dsmr_parser.parsers import TelegramParser
from example_telegrams import TELEGRAM_V4_2
parser = TelegramParser(telegram_specifications.V4)
telegram = Telegram(TELEGRAM_V4_2, parser, telegram_specifications.V4)
print(telegram)
| [
"dsmr_parser.objects.Telegram",
"dsmr_parser.parsers.TelegramParser"
] | [((189, 231), 'dsmr_parser.parsers.TelegramParser', 'TelegramParser', (['telegram_specifications.V4'], {}), '(telegram_specifications.V4)\n', (203, 231), False, 'from dsmr_parser.parsers import TelegramParser\n'), ((243, 302), 'dsmr_parser.objects.Telegram', 'Telegram', (['TELEGRAM_V4_2', 'parser', 'telegram_specificat... |
# 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
# distrib... | [
"eclcli.orchestration.heatclient.openstack.common._i18n._",
"time.sleep",
"eclcli.common.utils.get_item_properties",
"eclcli.orchestration.heatclient.common.utils.event_log_formatter",
"eclcli.orchestration.heatclient.exc.CommandError",
"eclcli.orchestration.heatclient.common.event_utils.get_events",
"l... | [((1029, 1071), 'logging.getLogger', 'logging.getLogger', (["(__name__ + '.ShowEvent')"], {}), "(__name__ + '.ShowEvent')\n", (1046, 1071), False, 'import logging\n'), ((2679, 2721), 'logging.getLogger', 'logging.getLogger', (["(__name__ + '.ListEvent')"], {}), "(__name__ + '.ListEvent')\n", (2696, 2721), False, 'impor... |
import sys
import os
import argparse
import cv2
#import dlib
import face_landmark_detect
def face_landmark_detect_batch(input_dir, output_dir, blend, *args):
print("Start Batch Processing.\n")
#iterate through directory
for f in os.listdir(input_dir):
input_file = os.path.join(in... | [
"face_landmark_detect.face_landmark_detect",
"argparse.ArgumentParser",
"face_landmark_detect.create_bg",
"cv2.imwrite",
"cv2.imread",
"os.path.join",
"os.listdir"
] | [((260, 281), 'os.listdir', 'os.listdir', (['input_dir'], {}), '(input_dir)\n', (270, 281), False, 'import os\n'), ((1026, 1094), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Batch Face Landmark Detection"""'}), "(description='Batch Face Landmark Detection')\n", (1049, 1094), False, 'i... |
import tensorflow as tf
import numpy as np
import scipy.io as scio
import os
import sys
import random
import network
import math
CATEGORY_NAME = ['Backpack', 'Basket', 'Bathtub', 'Bed', 'Bench', 'Bicycle', 'Bowl', 'Chair', 'Cup', 'Desk', 'DryingRack', 'Handcart',
'Hanger', 'Hook', 'Lamp', 'Laptop', 'Shelf', 'S... | [
"numpy.sum",
"os.makedirs",
"tensorflow.train.Saver",
"scipy.io.loadmat",
"numpy.random.rand",
"numpy.argmax",
"network.iSEG",
"tensorflow.global_variables_initializer",
"os.path.exists",
"numpy.zeros",
"numpy.amax",
"os.path.isfile",
"numpy.reshape",
"numpy.squeeze",
"tensorflow.GPUOpti... | [((725, 778), 'scipy.io.loadmat', 'scio.loadmat', (['"""../../DATA/label/interactionLabel.mat"""'], {}), "('../../DATA/label/interactionLabel.mat')\n", (737, 778), True, 'import scipy.io as scio\n'), ((801, 852), 'numpy.squeeze', 'np.squeeze', (["cate_label_idx_list['categoryLabelIdx']"], {}), "(cate_label_idx_list['ca... |
"""add gender
Revision ID: fdaaf2cff4bc
Revises: d00680ae0042
Create Date: 2019-03-18 10:23:42.498440
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision = 'fdaaf2cff4bc'
down_revision = 'd00680ae0042'
branch_labels = None
depends_on = None
def upgrade():
# ###... | [
"sqlalchemy.String",
"alembic.op.drop_column"
] | [((674, 709), 'alembic.op.drop_column', 'op.drop_column', (['"""user"""', '"""signature"""'], {}), "('user', 'signature')\n", (688, 709), False, 'from alembic import op\n'), ((714, 746), 'alembic.op.drop_column', 'op.drop_column', (['"""user"""', '"""gender"""'], {}), "('user', 'gender')\n", (728, 746), False, 'from al... |
import abc
import math
class Property(abc.ABC):
"""A processor class with a unified interface on the different data properties and their generation"""
def __init__(self):
self.name = ""
"""ID of the processor"""
self.provides = None
"""List of the IDs of any other sub-properties that this may provide"""
... | [
"math.log"
] | [((2099, 2116), 'math.log', 'math.log', (['x', 'base'], {}), '(x, base)\n', (2107, 2116), False, 'import math\n')] |
import enum
from random import randint
from bos_consensus.common import Node
class FaultyNodeKind(enum.Enum):
# failed to connect to the node or failed to get the proper response from
# the node.
NodeUnreachable = enum.auto()
# in single phase of consensus, the node does not send voting messages.
... | [
"enum.auto",
"random.randint"
] | [((229, 240), 'enum.auto', 'enum.auto', ([], {}), '()\n', (238, 240), False, 'import enum\n'), ((333, 344), 'enum.auto', 'enum.auto', ([], {}), '()\n', (342, 344), False, 'import enum\n'), ((430, 441), 'enum.auto', 'enum.auto', ([], {}), '()\n', (439, 441), False, 'import enum\n'), ((581, 592), 'enum.auto', 'enum.auto'... |
from django.contrib import admin
from picostack.vms.models import Flavour, VmImage, VmInstance
class VmInstanceAdmin(admin.ModelAdmin):
pass
admin.site.register(Flavour)
admin.site.register(VmImage)
admin.site.register(VmInstance, VmInstanceAdmin)
| [
"django.contrib.admin.site.register"
] | [((149, 177), 'django.contrib.admin.site.register', 'admin.site.register', (['Flavour'], {}), '(Flavour)\n', (168, 177), False, 'from django.contrib import admin\n'), ((178, 206), 'django.contrib.admin.site.register', 'admin.site.register', (['VmImage'], {}), '(VmImage)\n', (197, 206), False, 'from django.contrib impor... |
__author__ = 'prism'
from twilio.rest import TwilioRestClient
from django.conf import settings
def twilio():
"""
Send SMS
"""
account_sid = settings.JSON_DATA['account_sid']
auth_token = settings.JSON_DATA['auth_token']
client = TwilioRestClient(account_sid, auth_token)
message = client.me... | [
"twilio.rest.TwilioRestClient"
] | [((255, 296), 'twilio.rest.TwilioRestClient', 'TwilioRestClient', (['account_sid', 'auth_token'], {}), '(account_sid, auth_token)\n', (271, 296), False, 'from twilio.rest import TwilioRestClient\n')] |
# Generated by Django 2.0.5 on 2018-06-21 09:13
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('company', '0015_brand'),
]
operations = [
migrations.AddField(
model_name='company',
name='is_friend',
f... | [
"django.db.models.BooleanField"
] | [((325, 427), 'django.db.models.BooleanField', 'models.BooleanField', ([], {'choices': "[(True, 'Tak'), (False, 'Nie')]", 'default': '(False)', 'verbose_name': '"""<NAME>"""'}), "(choices=[(True, 'Tak'), (False, 'Nie')], default=False,\n verbose_name='<NAME>')\n", (344, 427), False, 'from django.db import migrations... |
from collections import deque
import operator
intro = """
Program using Stack structure for sorting integers
Author: <NAME>
Date: 2 November 2019
Instruction: Algorithm course of Master 1 Bordeaux
"""
sorting_order_guide = """
Sorting selection use:
[ 1 ] => INCREASE ordering
[ 2 ] => DECREASE ordering
"""
# Use DE... | [
"operator.lt",
"operator.gt",
"collections.deque"
] | [((392, 399), 'collections.deque', 'deque', ([], {}), '()\n', (397, 399), False, 'from collections import deque\n'), ((863, 884), 'operator.gt', 'operator.gt', (['one', 'two'], {}), '(one, two)\n', (874, 884), False, 'import operator\n'), ((920, 941), 'operator.lt', 'operator.lt', (['one', 'two'], {}), '(one, two)\n', ... |