code stringlengths 20 1.04M | apis list | extract_api stringlengths 75 9.94M |
|---|---|---|
import pytest
from challenge02 import doesPathExist
print("Graph Used:\n")
print("0---1 5---6---7\n| | | | |\n3---2---4 8---9---10")
linkedPairs = [[1, 3], [0, 2], [1, 3, 4], [0, 2], [2], [6, 8],
[5, 7, 9], [6, 10], [5, 9], [6, 8, 10], [7, 9]]
def test_0_to_1():
visitedNodes =... | [
"challenge02.doesPathExist"
] | [((335, 381), 'challenge02.doesPathExist', 'doesPathExist', (['(0)', '(1)', 'linkedPairs', 'visitedNodes'], {}), '(0, 1, linkedPairs, visitedNodes)\n', (348, 381), False, 'from challenge02 import doesPathExist\n'), ((447, 493), 'challenge02.doesPathExist', 'doesPathExist', (['(0)', '(2)', 'linkedPairs', 'visitedNodes']... |
import sqlite3
import os
class DB:
def __init__(self):
self.conn = sqlite3.connect(os.path.join(os.path.dirname(__file__), '..', "messages.db"))
# exit()
def create_db(self):
curs = self.cursor()
curs.execute(
"create table if not exists users(u_id bigint, g_id bigi... | [
"os.path.dirname"
] | [((109, 134), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (124, 134), False, 'import os\n')] |
import datetime as pythonDateTime
from nepali.char import NepaliChar
from nepali.timezone import now
from nepali.exceptions import InvalidNepaliDateTimeObjectException
from nepali.utils import to_nepali_timezone
from ._datetime import nepalidate, nepalidatetime
class HumanizeDateTime:
"""
HumanizeDate converts Nep... | [
"nepali.exceptions.InvalidNepaliDateTimeObjectException",
"nepali.char.NepaliChar.number",
"nepali.utils.to_nepali_timezone",
"nepali.timezone.now"
] | [((1677, 1682), 'nepali.timezone.now', 'now', ([], {}), '()\n', (1680, 1682), False, 'from nepali.timezone import now\n'), ((3131, 3164), 'nepali.char.NepaliChar.number', 'NepaliChar.number', (['interval_value'], {}), '(interval_value)\n', (3148, 3164), False, 'from nepali.char import NepaliChar\n'), ((1247, 1279), 'ne... |
import json
from unittest import TestCase
from squad_data_set import SquadSetSchema, Answers, Qas, Paragraphs, Data, SquadDataSet
class TestSquadDataSet(TestCase):
def test_deserialization(self): # JSON to Object
with open("data\\train-v1.1_mock.json", 'r', encoding='utf-8') as f:
incoming_... | [
"squad_data_set.Data",
"squad_data_set.SquadSetSchema",
"squad_data_set.Qas",
"squad_data_set.Answers",
"squad_data_set.Paragraphs",
"squad_data_set.SquadDataSet"
] | [((376, 392), 'squad_data_set.SquadSetSchema', 'SquadSetSchema', ([], {}), '()\n', (390, 392), False, 'from squad_data_set import SquadSetSchema, Answers, Qas, Paragraphs, Data, SquadDataSet\n'), ((2152, 2204), 'squad_data_set.Answers', 'Answers', ([], {'answer_start': 'answer_start', 'text': 'answer_text'}), '(answer_... |
from zope.testbrowser.browser import HTTPError
import pytest
def test_rootfolder__NotFound__1(address_book, browser):
"""There is no edit view for the root folder."""
browser.login('mgr')
with pytest.raises(HTTPError) as err:
browser.open(browser.ROOT_FOLDER_EDIT_URL)
assert 'HTTP Error 404: N... | [
"pytest.raises"
] | [((207, 231), 'pytest.raises', 'pytest.raises', (['HTTPError'], {}), '(HTTPError)\n', (220, 231), False, 'import pytest\n'), ((496, 520), 'pytest.raises', 'pytest.raises', (['HTTPError'], {}), '(HTTPError)\n', (509, 520), False, 'import pytest\n')] |
from __future__ import absolute_import
from __future__ import print_function
import os
def get_rule_dir_yaml(dir_path):
"""
Returns the path to the yaml metadata for a rule directory,
regardless of if it exists.
"""
return os.path.join(dir_path, "rule.yml")
def get_rule_dir_id(path):
"""
... | [
"os.path.basename",
"os.path.isdir",
"os.path.dirname",
"os.walk",
"os.path.exists",
"os.path.splitext",
"os.path.join",
"os.listdir"
] | [((246, 280), 'os.path.join', 'os.path.join', (['dir_path', '"""rule.yml"""'], {}), "(dir_path, 'rule.yml')\n", (258, 280), False, 'import os\n'), ((562, 588), 'os.path.basename', 'os.path.basename', (['dir_path'], {}), '(dir_path)\n', (578, 588), False, 'import os\n'), ((887, 910), 'os.path.isdir', 'os.path.isdir', ([... |
# !/usr/bin/env python3
# -*- coding: utf-8 -*-
# @Time : 2021/3/22 19:38
# @Author : <NAME>
# @File : toutiao_example.py
# @Description:
import toutiao_dmp_pb2
import time
import base64
def generate_valid_file():
dmp_data = toutiao_dmp_pb2.DmpData()
id_item1 = dmp_data.idList.add()
id_item1.dat... | [
"time.time",
"base64.b64encode",
"toutiao_dmp_pb2.DmpData"
] | [((240, 265), 'toutiao_dmp_pb2.DmpData', 'toutiao_dmp_pb2.DmpData', ([], {}), '()\n', (263, 265), False, 'import toutiao_dmp_pb2\n'), ((777, 808), 'base64.b64encode', 'base64.b64encode', (['binary_string'], {}), '(binary_string)\n', (793, 808), False, 'import base64\n'), ((826, 851), 'toutiao_dmp_pb2.DmpData', 'toutiao... |
from django_cron import CronJobBase, Schedule
from django.shortcuts import get_object_or_404
from django.template.loader import render_to_string
from django.core.mail import send_mail
from .models import *
from core.mocfunctions import *
TAG_ID = settings.TAG_ID_LIST
class CreatePlotPreview(CronJobBase):
RUN_EVER... | [
"django.core.mail.send_mail",
"django.template.loader.render_to_string",
"json.dumps",
"django.shortcuts.get_object_or_404",
"django_cron.Schedule",
"pyzotero.zotero.Zotero"
] | [((347, 386), 'django_cron.Schedule', 'Schedule', ([], {'run_every_mins': 'RUN_EVERY_MINS'}), '(run_every_mins=RUN_EVERY_MINS)\n', (355, 386), False, 'from django_cron import CronJobBase, Schedule\n'), ((793, 832), 'django_cron.Schedule', 'Schedule', ([], {'run_every_mins': 'RUN_EVERY_MINS'}), '(run_every_mins=RUN_EVER... |
#Topology Substation 13-10-11
#!/usr/bin/python
from mininet.net import Mininet
from mininet.node import Node, Controller, RemoteController, OVSSwitch, OVSKernelSwitch, Host
from mininet.cli import CLI
from mininet.link import Intf, TCLink
from mininet.log import setLogLevel, info
from mininet.node import Node... | [
"mininet.net.Mininet",
"os.system",
"mininet.log.setLogLevel",
"mininet.cli.CLI",
"time.sleep"
] | [((900, 931), 'mininet.net.Mininet', 'Mininet', ([], {'topo': 'None', 'build': '(False)'}), '(topo=None, build=False)\n', (907, 931), False, 'from mininet.net import Mininet\n'), ((16742, 16755), 'time.sleep', 'time.sleep', (['(2)'], {}), '(2)\n', (16752, 16755), False, 'import time\n'), ((17887, 17900), 'time.sleep', ... |
from bfio import BioReader, BioWriter
from pathlib import Path
import requests
import numpy as np
""" Get an example image """
# Set up the directories
PATH = Path("data")
PATH.mkdir(parents=True, exist_ok=True)
# Download the data if it doesn't exist
URL = "https://github.com/usnistgov/WIPP/raw/master/data/PyramidBu... | [
"bfio.BioWriter",
"bfio.BioReader",
"pathlib.Path",
"requests.get",
"numpy.array_equal"
] | [((160, 172), 'pathlib.Path', 'Path', (['"""data"""'], {}), "('data')\n", (164, 172), False, 'from pathlib import Path\n'), ((581, 623), 'bfio.BioReader', 'BioReader', (['(PATH / FILENAME)'], {'backend': '"""java"""'}), "(PATH / FILENAME, backend='java')\n", (590, 623), False, 'from bfio import BioReader, BioWriter\n')... |
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import tensorflow as tf
import keras
dataset = pd.read_csv("train.csv")
test =pd.read_csv("test.csv")
dataset.loc[dataset['Cabin'].notnull(), 'Cabin'] = 1
dataset.loc[dataset['Cabin'].isnull(), 'Cabin'] = 0
dataset.loc[dataset['Embarked']... | [
"sklearn.impute.SimpleImputer",
"sklearn.preprocessing.StandardScaler",
"tensorflow.keras.layers.Dense",
"pandas.read_csv",
"sklearn.preprocessing.OneHotEncoder",
"tensorflow.keras.layers.Input",
"numpy.round"
] | [((125, 149), 'pandas.read_csv', 'pd.read_csv', (['"""train.csv"""'], {}), "('train.csv')\n", (136, 149), True, 'import pandas as pd\n'), ((157, 180), 'pandas.read_csv', 'pd.read_csv', (['"""test.csv"""'], {}), "('test.csv')\n", (168, 180), True, 'import pandas as pd\n'), ((1819, 1872), 'sklearn.impute.SimpleImputer', ... |
import heapq as hp
class MaxHeap:
def __init__(self):
self._heap = list()
def push(self, item):
if isinstance(item, tuple):
item = list(item)
item[0] = -item[0]
hp.heappush(self._heap, tuple(item))
else:
hp.heappush(self._heap, -item)
... | [
"heapq.heappush",
"heapq.heappop"
] | [((349, 371), 'heapq.heappop', 'hp.heappop', (['self._heap'], {}), '(self._heap)\n', (359, 371), True, 'import heapq as hp\n'), ((815, 844), 'heapq.heappush', 'hp.heappush', (['self._heap', 'item'], {}), '(self._heap, item)\n', (826, 844), True, 'import heapq as hp\n'), ((877, 899), 'heapq.heappop', 'hp.heappop', (['se... |
# pylint: disable=missing-module-docstring,invalid-name
import time
from util.logger import get_logger
logger = get_logger()
def _line_segments_intersect(line1, line2):
'''
See: https://www.geeksforgeeks.org/check-if-two-given-line-segments-intersect/
'''
def get_orientation(p, q, r):
val = ... | [
"time.time",
"util.logger.get_logger"
] | [((115, 127), 'util.logger.get_logger', 'get_logger', ([], {}), '()\n', (125, 127), False, 'from util.logger import get_logger\n'), ((2777, 2788), 'time.time', 'time.time', ([], {}), '()\n', (2786, 2788), False, 'import time\n')] |
import pytest
from tests.utils import setup_kubernetes_version
@pytest.mark.disruptive
def test_upgrade_plan_all_fine(provision, skuba, kubectl, platform):
"""
Starting from a up-to-date cluster, check what cluster/node plan report.
"""
setup_kubernetes_version(skuba, kubectl)
out = skuba.cluste... | [
"tests.utils.setup_kubernetes_version"
] | [((257, 297), 'tests.utils.setup_kubernetes_version', 'setup_kubernetes_version', (['skuba', 'kubectl'], {}), '(skuba, kubectl)\n', (281, 297), False, 'from tests.utils import setup_kubernetes_version\n')] |
# -*- coding: utf-8 -*- #
# Copyright 2019 Google LLC. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless requir... | [
"googlecloudsdk.core.properties.VALUES.core.project.Get"
] | [((1290, 1339), 'googlecloudsdk.core.properties.VALUES.core.project.Get', 'properties.VALUES.core.project.Get', ([], {'required': '(True)'}), '(required=True)\n', (1324, 1339), False, 'from googlecloudsdk.core import properties\n'), ((1625, 1674), 'googlecloudsdk.core.properties.VALUES.core.project.Get', 'properties.VA... |
# -*- coding: utf-8 -*-
# Generated by Django 1.11.6 on 2018-06-27 14:46
from __future__ import unicode_literals
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
import uuid
class Migration(migrations.Migration):
dependencies = [
migrations.swapp... | [
"django.db.migrations.swappable_dependency",
"django.db.models.CharField",
"django.db.models.DateTimeField",
"django.db.models.ForeignKey",
"django.db.models.UUIDField"
] | [((304, 361), 'django.db.migrations.swappable_dependency', 'migrations.swappable_dependency', (['settings.AUTH_USER_MODEL'], {}), '(settings.AUTH_USER_MODEL)\n', (335, 361), False, 'from django.db import migrations, models\n'), ((563, 667), 'django.db.models.UUIDField', 'models.UUIDField', ([], {'default': 'uuid.uuid4'... |
#!/usr/bin/env python
# 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... | [
"ros_cross_compile.docker_client.DockerClient",
"ros_cross_compile.builders.run_emulated_docker_build",
"ros_cross_compile.sysroot_creator.create_workspace_sysroot_image",
"argparse.ArgumentParser",
"logging.basicConfig",
"ros_cross_compile.dependencies.gather_rosdeps",
"pathlib.Path",
"ros_cross_comp... | [((1470, 1509), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (1489, 1509), False, 'import logging\n'), ((1519, 1546), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1536, 1546), False, 'import logging\n'), ((1759, 1877), 'argpar... |
# Copyright 2020 Google
#
# 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, soft... | [
"scipy.linalg.expm",
"scipy.optimize.minimize",
"numpy.zeros",
"numpy.diag",
"numpy.conjugate"
] | [((2999, 3099), 'scipy.optimize.minimize', 'sp.optimize.minimize', (['energy', 'init_guess'], {'jac': 'gradient', 'method': 'method', 'options': "{'disp': verbose}"}), "(energy, init_guess, jac=gradient, method=method,\n options={'disp': verbose})\n", (3019, 3099), True, 'import scipy as sp\n'), ((1491, 1552), 'nump... |
from typing import Union
import numpy as np
import yaml
from amuse.lab import units, ScalarQuantity, VectorQuantity
from amuse.units.core import named_unit
def str_to_unit(s: str) -> named_unit:
unit_names = ['Myr', 'kpc', 'kms', 'MSun']
actual_units = [units.Myr, units.kpc, units.kms, units.MSun]
index =... | [
"numpy.array"
] | [((818, 835), 'numpy.array', 'np.array', (['data[0]'], {}), '(data[0])\n', (826, 835), True, 'import numpy as np\n')] |
#!/usr/bin/python
# -*- coding: utf-8 -*-
# stop_and_restart.py
"""
Kill running process after given time and reply message
author: <NAME>, <EMAIL>
"""
from __future__ import absolute_import
from telegram import (ReplyKeyboardRemove, ParseMode)
import time
import conf.lib_ext_greenhouse as lib
import conf.greenhouse_c... | [
"peripherals.four_digit.display.show_standby",
"telegram.ReplyKeyboardRemove",
"time.sleep",
"peripherals.four_digit.display.show_stop",
"logger.logger.get_logger",
"utils.utils.read_cmd"
] | [((450, 466), 'logger.logger.get_logger', 'log.get_logger', ([], {}), '()\n', (464, 466), True, 'import logger.logger as log\n'), ((624, 673), 'utils.utils.read_cmd', 'utils.read_cmd', (['conf.disable_camera', 'lib.tmp_file'], {}), '(conf.disable_camera, lib.tmp_file)\n', (638, 673), True, 'import utils.utils as utils\... |
# Copyright 2004-2010 <NAME>.
# See license.txt for terms.
import unittest
"""
Quick and dirty way to run all tests. Should probably use introspection
in the future.
"""
from rawHelloWorld import *
from disasmHelloWorld import *
from test_x86asm import *
from test_bugs import *
from test_directives import *
#from t... | [
"unittest.main"
] | [((604, 619), 'unittest.main', 'unittest.main', ([], {}), '()\n', (617, 619), False, 'import unittest\n')] |
import logging
from iptv_proxy.providers.helix.constants import HelixConstants
from iptv_proxy.providers.iptv_provider.validations import ProviderValidations
logger = logging.getLogger(__name__)
class HelixValidations(ProviderValidations):
__slots__ = []
_provider_name = HelixConstants.PROVIDER_NAME.lower(... | [
"iptv_proxy.providers.helix.constants.HelixConstants.PROVIDER_NAME.lower",
"logging.getLogger"
] | [((169, 196), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (186, 196), False, 'import logging\n'), ((285, 321), 'iptv_proxy.providers.helix.constants.HelixConstants.PROVIDER_NAME.lower', 'HelixConstants.PROVIDER_NAME.lower', ([], {}), '()\n', (319, 321), False, 'from iptv_proxy.provider... |
#!/usr/bin/env python3
from main import analyze
from os import listdir
from os.path import isfile, join
import sys
imagesPath = ''
imagePath = ''
for i in range(len(sys.argv)):
if sys.argv[i] == '--images-path':
i += 1
imagesPath = sys.argv[i]
if sys.argv[i] == '--image-path':
i += 1
imagePath = sys.argv[i]... | [
"main.analyze",
"os.path.join",
"os.listdir"
] | [((608, 639), 'main.analyze', 'analyze', (['[imagePath, imagePath]'], {}), '([imagePath, imagePath])\n', (615, 639), False, 'from main import analyze\n'), ((587, 600), 'main.analyze', 'analyze', (['file'], {}), '(file)\n', (594, 600), False, 'from main import analyze\n'), ((450, 469), 'os.path.join', 'join', (['imagesP... |
#Import Packages
from tkinter import *
import os
import tkinter.messagebox
import sqlite3
import pyttsx3
# init function is used to get an engine instance for the speech synthesis
engine = pyttsx3.init()
def testVal1(inStr,i,acttyp):
ind=int(i)
if acttyp == '1': #insert validation
if no... | [
"sqlite3.connect",
"os.system",
"pyttsx3.init"
] | [((200, 214), 'pyttsx3.init', 'pyttsx3.init', ([], {}), '()\n', (212, 214), False, 'import pyttsx3\n'), ((659, 790), 'sqlite3.connect', 'sqlite3.connect', (['"""C:/Users/ACER/Desktop/PROJECT ALL RESOURCE/PROJECT ALL RESOURCE/Face recognition/sqlite3/Teachersdb.db"""'], {}), "(\n 'C:/Users/ACER/Desktop/PROJECT ALL RE... |
import torch
class TFMSGaussianNoise(torch.nn.Module):
def __init__(self, level=0.01):
super(TFMSGaussianNoise, self).__init__()
self.level = level
def forward(self, img):
return img + self.level * torch.randn_like(img)
| [
"torch.randn_like"
] | [((233, 254), 'torch.randn_like', 'torch.randn_like', (['img'], {}), '(img)\n', (249, 254), False, 'import torch\n')] |
from discord.ext import commands
from datetime import datetime
import json
import discord
with open("package.json", "r") as f:
data = json.load(f)
PREFIX = data["prefix"]
TOKEN = data["token"]
f.close()
bot = commands.Bot(command_prefix=commands.when_mentioned_or(f"{PREFIX}"))
bot.launch_time = datetime... | [
"json.load",
"discord.ext.commands.when_mentioned_or",
"discord.ext.commands.has_permissions",
"discord.Color.red",
"discord.Colour.blue",
"datetime.datetime.utcnow",
"discord.ext.commands.bot_has_guild_permissions",
"discord.ext.commands.guild_only"
] | [((312, 329), 'datetime.datetime.utcnow', 'datetime.utcnow', ([], {}), '()\n', (327, 329), False, 'from datetime import datetime\n'), ((553, 605), 'discord.ext.commands.bot_has_guild_permissions', 'commands.bot_has_guild_permissions', ([], {'ban_members': '(True)'}), '(ban_members=True)\n', (587, 605), False, 'from dis... |
import torch
import numpy as np
import json
import torchvision.transforms as transforms
import skimage.transform
import argparse
from PIL import Image, ImageDraw, ImageFont
from utils import image_rescale, image_resize
from metric import format_html
import os
from glob import glob
from tqdm import tqdm
import shutil
im... | [
"argparse.ArgumentParser",
"textwrap.wrap",
"utils.image_resize",
"os.path.isfile",
"numpy.mean",
"PIL.Image.blend",
"shutil.rmtree",
"torchvision.transforms.Normalize",
"os.path.join",
"utils.image_rescale",
"torch.load",
"torch.FloatTensor",
"os.path.exists",
"numpy.max",
"torchvision.... | [((962, 1006), 'utils.image_rescale', 'image_rescale', (['image_path', 'image_size', '(False)'], {}), '(image_path, image_size, False)\n', (975, 1006), False, 'from utils import image_rescale, image_resize\n'), ((1038, 1060), 'torch.FloatTensor', 'torch.FloatTensor', (['img'], {}), '(img)\n', (1055, 1060), False, 'impo... |
import types
from typing import Iterable
from unittest import TestCase
from parameterized import parameterized
from kg_covid_19.transform_utils.sars_cov_2_gene_annot import SARSCoV2GeneAnnot
from kg_covid_19.transform_utils.sars_cov_2_gene_annot.sars_cov_2_gene_annot import \
_gpi12iterator, _gpa11iterator
clas... | [
"kg_covid_19.transform_utils.sars_cov_2_gene_annot.SARSCoV2GeneAnnot",
"parameterized.parameterized.expand",
"kg_covid_19.transform_utils.sars_cov_2_gene_annot.sars_cov_2_gene_annot._gpi12iterator",
"kg_covid_19.transform_utils.sars_cov_2_gene_annot.sars_cov_2_gene_annot._gpa11iterator"
] | [((874, 1186), 'parameterized.parameterized.expand', 'parameterized.expand', (["[('DB', 'UniProtKB'), ('DB_Object_ID', 'P0DTD2'), ('DB_Object_Symbol', [\n 'P0DTD2']), ('DB_Object_Name', ['Protein 9b']), ('DB_Object_Synonym',\n ''), ('DB_Object_Type', 'protein'), ('DB_Xref', ['PR:000050272',\n 'UniProtKB:P0DTD1... |
"""app/admin/views.py"""
import app
from flask import flash, redirect, render_template, url_for
from flask_login import current_user,login_required
from app.firestore_service import import__export_data,backend_only_create_tenant
from . import admin
@admin.route('/admin/import', methods=... | [
"app.firestore_service.backend_only_create_tenant"
] | [((950, 987), 'app.firestore_service.backend_only_create_tenant', 'backend_only_create_tenant', (['newTenant'], {}), '(newTenant)\n', (976, 987), False, 'from app.firestore_service import import__export_data, backend_only_create_tenant\n')] |
import argparse
import boto3
import jellyfish
import numpy as np
import os
import pandas as pd
import pickle
import re
import shlex
import sqlite3
import tablib
import tempfile
from collections import defaultdict
from functools import partial
from mygene import MyGeneInfo
from pyspark import SparkContext, SparkConf
fr... | [
"argparse.ArgumentParser",
"pyspark.SparkContext",
"sklearn.feature_extraction.text.TfidfVectorizer",
"pyspark.SparkConf",
"collections.defaultdict",
"boto3.resource",
"tablib.Dataset",
"sklearn.cluster.DBSCAN",
"urllib.parse.urlparse",
"tempfile.TemporaryDirectory",
"mygene.MyGeneInfo",
"shle... | [((1576, 1599), 'pyspark.SparkContext', 'SparkContext', ([], {'conf': 'conf'}), '(conf=conf)\n', (1588, 1599), False, 'from pyspark import SparkContext, SparkConf\n'), ((4402, 4425), 'sqlite3.connect', 'sqlite3.connect', (['db_loc'], {}), '(db_loc)\n', (4417, 4425), False, 'import sqlite3\n'), ((5734, 5757), 'sqlite3.c... |
#!/usr/bin/env python
# python2 or python3 compatible
import os
import sys
import yaml
import signal
import logging
import logging.config
import runner_service.configuration as configuration
from runner_service.utils import (fread,
create_self_signed_cert,
... | [
"runner_service.utils.create_self_signed_cert",
"os.mkdir",
"runner_service.utils.ssh_create_key",
"runner_service.utils.setup_svc_token",
"logging.critical",
"runner_service.app.create_app",
"os.path.join",
"runner_service.configuration.init",
"os.path.dirname",
"os.path.exists",
"runner_servic... | [((664, 675), 'sys.exit', 'sys.exit', (['(0)'], {}), '(0)\n', (672, 675), False, 'import sys\n'), ((854, 953), 'runner_service.utils.create_self_signed_cert', 'create_self_signed_cert', ([], {'cert_dir': 'configuration.settings.config_dir', 'cert_pfx': 'cert_filename_pfx'}), '(cert_dir=configuration.settings.config_dir... |
# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import... | [
"pulumi.get",
"pulumi.getter",
"pulumi.set"
] | [((1266, 1316), 'pulumi.getter', 'pulumi.getter', ([], {'name': '"""retainStacksOnAccountRemoval"""'}), "(name='retainStacksOnAccountRemoval')\n", (1279, 1316), False, 'import pulumi\n'), ((1218, 1245), 'pulumi.get', 'pulumi.get', (['self', '"""enabled"""'], {}), "(self, 'enabled')\n", (1228, 1245), False, 'import pulu... |
# -*- coding: utf-8 -*-
# Generated by Django 1.10.5 on 2017-08-31 18:55
from __future__ import unicode_literals
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('checkout', '0012_auto_20170831_1642'),
]
operation... | [
"django.db.models.ForeignKey"
] | [((437, 547), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'on_delete': 'django.db.models.deletion.CASCADE', 'related_name': '"""items"""', 'to': '"""checkout.Order"""'}), "(on_delete=django.db.models.deletion.CASCADE, related_name\n ='items', to='checkout.Order')\n", (454, 547), False, 'from django.db ... |
import os
import time
import pyqtgraph
from PyQt5 import QtCore, QtGui, QtWidgets
from base import BaseWidgetView
from divide_and_conquer.controller import DCController
from divide_and_conquer.ui_dc_view import Ui_DCWidget
class DCView(BaseWidgetView):
def __init__(self, parent, *args, **kwargs):
super(... | [
"divide_and_conquer.controller.DCController",
"os.path.basename",
"divide_and_conquer.ui_dc_view.Ui_DCWidget",
"PyQt5.QtWidgets.QFileDialog",
"pyqtgraph.mkPen"
] | [((531, 568), 'divide_and_conquer.controller.DCController', 'DCController', (['self', 'self._max_samples'], {}), '(self, self._max_samples)\n', (543, 568), False, 'from divide_and_conquer.controller import DCController\n'), ((749, 762), 'divide_and_conquer.ui_dc_view.Ui_DCWidget', 'Ui_DCWidget', ([], {}), '()\n', (760,... |
# Copyright Contributors to the Pyro project.
# SPDX-License-Identifier: Apache-2.0
from collections import namedtuple
from contextlib import ExitStack, contextmanager
import functools
import warnings
from jax import lax, ops, random
from jax.lib import xla_bridge
import jax.numpy as jnp
import numpyro
from numpyro.... | [
"functools.partial",
"jax.numpy.reshape",
"jax.numpy.where",
"jax.lib.xla_bridge.get_backend",
"jax.numpy.arange",
"jax.numpy.shape",
"jax.numpy.take",
"contextlib.ExitStack",
"functools.update_wrapper",
"jax.random.choice",
"jax.random.randint",
"collections.namedtuple",
"jax.ops.index_upda... | [((382, 440), 'collections.namedtuple', 'namedtuple', (['"""CondIndepStackFrame"""', "['name', 'dim', 'size']"], {}), "('CondIndepStackFrame', ['name', 'dim', 'size'])\n", (392, 440), False, 'from collections import namedtuple\n'), ((3223, 3251), 'jax.numpy.reshape', 'jnp.reshape', (['obs_mask', 'shape'], {}), '(obs_ma... |
import glob
import os
import ssl
import argparse
import urllib3
import json
import logging
import urllib.request
import base64
import pandas as pd
import numpy as np
from pathlib import Path
from datetime import datetime
urllib3.disable_warnings(urllib3.exceptions.InsecureRequestWarning)
urllib3.disable_warnings(urlli... | [
"argparse.ArgumentParser",
"pandas.read_csv",
"logging.StreamHandler",
"json.dumps",
"logging.Formatter",
"datetime.datetime.utcfromtimestamp",
"pathlib.Path",
"glob.glob",
"pandas.concat",
"datetime.datetime.now",
"urllib3.disable_warnings",
"logging.getLogger"
] | [((222, 289), 'urllib3.disable_warnings', 'urllib3.disable_warnings', (['urllib3.exceptions.InsecureRequestWarning'], {}), '(urllib3.exceptions.InsecureRequestWarning)\n', (246, 289), False, 'import urllib3\n'), ((290, 336), 'urllib3.disable_warnings', 'urllib3.disable_warnings', (['urllib3.HTTPResponse'], {}), '(urlli... |
from collections import OrderedDict
import tldextract
import re
import requests
from . import helpers
from . import helpdesk_helper
from urllib.parse import urlparse
from scrapy.selector import Selector
def get_sitemap_if_available(url):
if not url.endswith("sitemap.xml"):
reMatch = re.search(".+?([^/]/(?... | [
"tldextract.extract",
"scrapy.selector.Selector",
"re.match",
"requests.get",
"collections.OrderedDict",
"re.search",
"urllib.parse.urlparse"
] | [((822, 863), 're.match', 're.match', (['""".+?([^/]/(?!/))"""', 'input_string'], {}), "('.+?([^/]/(?!/))', input_string)\n", (830, 863), False, 'import re\n'), ((1848, 1869), 'requests.get', 'requests.get', (['urls[0]'], {}), '(urls[0])\n', (1860, 1869), False, 'import requests\n'), ((1885, 1916), 'scrapy.selector.Sel... |
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
import autoslug.fields
from django.conf import settings
class Migration(migrations.Migration):
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
operations = [
... | [
"django.db.models.TextField",
"django.db.migrations.swappable_dependency",
"django.db.models.BigIntegerField",
"django.db.models.ForeignKey",
"django.db.models.CharField",
"django.db.models.AutoField",
"django.db.models.IntegerField",
"django.db.models.DateTimeField"
] | [((233, 290), 'django.db.migrations.swappable_dependency', 'migrations.swappable_dependency', (['settings.AUTH_USER_MODEL'], {}), '(settings.AUTH_USER_MODEL)\n', (264, 290), False, 'from django.db import models, migrations\n'), ((2635, 2694), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'to': '"""boards.Th... |
from flask import Flask, render_template, redirect, jsonify
from flask_pymongo import PyMongo
import scrape_mars
app = Flask(__name__)
app.config["MONGO_URI"] = "mongodb://localhost:27017/space-facts.com/mars/"
mongo = PyMongo(app)
@app.route("/")
def index():
mars = mongo.db.mars.find_one()
return render_templ... | [
"flask.redirect",
"scrape_mars.scrape",
"flask.Flask",
"flask.render_template",
"flask_pymongo.PyMongo"
] | [((123, 138), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (128, 138), False, 'from flask import Flask, render_template, redirect, jsonify\n'), ((224, 236), 'flask_pymongo.PyMongo', 'PyMongo', (['app'], {}), '(app)\n', (231, 236), False, 'from flask_pymongo import PyMongo\n'), ((308, 348), 'flask.render_... |
import logging
import os
import sys
import time
from unittest import TestCase
sys.path.append(os.path.dirname(os.path.realpath(__file__)) + "/../src")
from store import Store
from store_warmup_okex import StoreWarpupOkex
class TestStoreWarpupOkex(TestCase):
def test_loop_smoke(self):
logger = logging.getL... | [
"os.path.realpath",
"logging.StreamHandler",
"store_warmup_okex.StoreWarpupOkex",
"time.time",
"logging.Formatter",
"logging.getLogger"
] | [((308, 335), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (325, 335), False, 'import logging\n'), ((400, 433), 'logging.StreamHandler', 'logging.StreamHandler', (['sys.stderr'], {}), '(sys.stderr)\n', (421, 433), False, 'import logging\n'), ((494, 567), 'logging.Formatter', 'logging.Fo... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Wed May 9 02:35:02 2018
@author: elvex
"""
"""Boite à outils de manipulation des base de données de tweets. """
#import json
import pandas as pd
import txt_analysis as TA
from math import log10
from glob import glob
from os.path import abspath
from re im... | [
"pandas.DataFrame",
"os.path.abspath",
"datetime.date",
"pandas.read_json",
"numpy.sin",
"numpy.cos",
"glob.glob",
"pandas.concat"
] | [((1619, 1652), 'pandas.concat', 'pd.concat', (['[bdd21, bdd22]'], {'axis': '(1)'}), '([bdd21, bdd22], axis=1)\n', (1628, 1652), True, 'import pandas as pd\n'), ((1707, 1723), 'os.path.abspath', 'abspath', (['dirname'], {}), '(dirname)\n', (1714, 1723), False, 'from os.path import abspath\n'), ((1734, 1756), 'glob.glob... |
import re
from .. utils import TranspileTestCase, BuiltinFunctionTestCase
class HashTests(TranspileTestCase):
pass
class BuiltinHashFunctionTests(BuiltinFunctionTestCase, TranspileTestCase):
functions = ["hash"]
substitutions = {
'0': [re.compile(r'^-?\d+$'),],
}
not_implemented = [
... | [
"re.compile"
] | [((261, 283), 're.compile', 're.compile', (['"""^-?\\\\d+$"""'], {}), "('^-?\\\\d+$')\n", (271, 283), False, 'import re\n')] |
import os
import tempfile
import time
import unittest
import kubernetes
import pytest
import yaml
from ray.autoscaler._private._kubernetes.node_provider import KubernetesNodeProvider
from ray.autoscaler import sdk
IMAGE_ENV = "KUBERNETES_CLUSTER_LAUNCHER_TEST_IMAGE"
def fill_image_field(pod_config):
image = os... | [
"tempfile.NamedTemporaryFile",
"ray.autoscaler._private._kubernetes.node_provider.KubernetesNodeProvider",
"ray.autoscaler.sdk.create_or_update_cluster",
"os.path.realpath",
"os.path.dirname",
"ray.autoscaler.sdk.teardown_cluster",
"kubernetes.client.CoreV1Api",
"kubernetes.config.load_kube_config",
... | [((318, 364), 'os.getenv', 'os.getenv', (['IMAGE_ENV', '"""rayproject/ray:nightly"""'], {}), "(IMAGE_ENV, 'rayproject/ray:nightly')\n", (327, 364), False, 'import os\n'), ((584, 610), 'os.path.realpath', 'os.path.realpath', (['__file__'], {}), '(__file__)\n', (600, 610), False, 'import os\n'), ((624, 645), 'os.path.dir... |
# -*- coding:utf-8 -*-
"""
获取双流机场进出港航班信息
http://www.cdairport.com/flightInfor.aspx?t=4
Reference:
1.https://zhuanlan.zhihu.com/p/394268763
2.https://www.cnblogs.com/sanduzxcvbnm/p/10250222.html
"""
import requests
from bs4 import BeautifulSoup
import pandas as pd
from datetime import datetime
clas... | [
"pandas.DataFrame",
"requests.get",
"bs4.BeautifulSoup",
"datetime.datetime.now",
"pandas.concat"
] | [((1642, 1656), 'pandas.DataFrame', 'pd.DataFrame', ([], {}), '()\n', (1654, 1656), True, 'import pandas as pd\n'), ((1732, 1749), 'requests.get', 'requests.get', (['url'], {}), '(url)\n', (1744, 1749), False, 'import requests\n'), ((1851, 1883), 'bs4.BeautifulSoup', 'BeautifulSoup', (['html.text', '"""lxml"""'], {}), ... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import csv
import os
import random
import spacy
import dill as pkl
import torch
from dataloaders.text import torchtext
import torchvision.transforms as transforms
from... | [
"dataloaders.gif_transforms.Scale",
"csv.reader",
"random.randint",
"dataloaders.text.torchtext.data.Field",
"torch.autograd.Variable",
"dataloaders.gif_transforms.ToTensor",
"os.path.exists",
"dataloaders.gif_transforms.load_frames",
"dill.load",
"torch.cat",
"torch.nn.utils.rnn.PackedSequence"... | [((778, 842), 'dataloaders.gif_transforms.Normalize', 'Normalize', ([], {'mean': '[0.485, 0.456, 0.406]', 'std': '[0.229, 0.224, 0.225]'}), '(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n', (787, 842), False, 'from dataloaders.gif_transforms import load_frames, RandomCrop, CenterCrop, ToTensor, Normalize, Sc... |
import multiprocessing
from multiprocessing.context import Process
import time
def print_array_contents(array):
while True:
print(*array, sep = ", ")
time.sleep(1)
if __name__ == '__main__':
multiprocessing.set_start_method('spawn')
# arr = [1] * 10
arr = multiprocessing.Array('i', [... | [
"time.sleep",
"multiprocessing.set_start_method",
"multiprocessing.Array",
"multiprocessing.context.Process"
] | [((220, 261), 'multiprocessing.set_start_method', 'multiprocessing.set_start_method', (['"""spawn"""'], {}), "('spawn')\n", (252, 261), False, 'import multiprocessing\n'), ((292, 329), 'multiprocessing.Array', 'multiprocessing.Array', (['"""i"""', '([-1] * 10)'], {}), "('i', [-1] * 10)\n", (313, 329), False, 'import mu... |
import sys
import os
import io
import subprocess
import time
import datetime
import numpy as np
import math
import shutil
import argparse
#############################################################
def remove_redundant(prj_dir, prj_name):
os.system('cp {a}/{b}/prj.runs/impl_exe/wrapper.bit {a}/{b}/bitstream.bi... | [
"os.getcwd",
"os.path.exists",
"argparse.ArgumentParser"
] | [((3004, 3102), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""automatic Vivado designs compression script"""', 'epilog': '""""""'}), "(description=\n 'automatic Vivado designs compression script', epilog='')\n", (3027, 3102), False, 'import argparse\n'), ((3339, 3367), 'os.path.exist... |
from collections import OrderedDict, defaultdict
import logging
from HintList import goalTable, getHintGroup, hintExclusions
from Search import Search
validColors = [
'White',
'Red',
'Green',
'Blue',
'Light Blue',
'Pink',
'Yellow',
'Black'
]
class Goal(object):
def __init__(sel... | [
"Search.Search",
"collections.defaultdict",
"HintList.getHintGroup",
"HintList.hintExclusions",
"logging.getLogger"
] | [((8660, 8701), 'Search.Search', 'Search', (['[world.state for world in worlds]'], {}), '([world.state for world in worlds])\n', (8666, 8701), False, 'from Search import Search\n'), ((6357, 6396), 'HintList.hintExclusions', 'hintExclusions', (['world'], {'clear_cache': '(True)'}), '(world, clear_cache=True)\n', (6371, ... |
# Copyright (c) 2019 Horizon Robotics. 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 applicab... | [
"tensorflow.test.main",
"tensorflow.python.framework.test_util.run_in_graph_and_eager_modes",
"alf.utils.common.set_per_process_memory_growth",
"absl.testing.parameterized.parameters",
"tf_agents.specs.tensor_spec.sample_spec_nest",
"tf_agents.specs.tensor_spec.BoundedTensorSpec",
"tf_agents.trajectorie... | [((958, 1028), 'absl.testing.parameterized.parameters', 'parameterized.parameters', (["{'outer_dims': (3,)}", "{'outer_dims': (3, 5)}"], {}), "({'outer_dims': (3,)}, {'outer_dims': (3, 5)})\n", (982, 1028), False, 'from absl.testing import parameterized\n'), ((1035, 1075), 'tensorflow.python.framework.test_util.run_in_... |
##########################################################################
#
# Copyright (c) 2011-2012, <NAME>. All rights reserved.
# Copyright (c) 2011-2013, Image Engine Design Inc. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provi... | [
"GafferUI.PlugValueWidget.setPlug",
"GafferUI.PlugValueWidget.__init__",
"Gaffer.BlockedConnection",
"GafferUI.PlugValueWidget.setHighlighted",
"GafferUI.PlugValueWidget.getToolTip",
"GafferUI.NumericWidget",
"GafferUI.PlugValueWidget.registerType",
"Gaffer.WeakMethod"
] | [((5717, 5796), 'GafferUI.PlugValueWidget.registerType', 'GafferUI.PlugValueWidget.registerType', (['Gaffer.FloatPlug', 'NumericPlugValueWidget'], {}), '(Gaffer.FloatPlug, NumericPlugValueWidget)\n', (5754, 5796), False, 'import GafferUI\n'), ((5799, 5876), 'GafferUI.PlugValueWidget.registerType', 'GafferUI.PlugValueWi... |
import os
import time
import argparse
import numpy as np
import torch
import torch.optim as optim
from sklearn.manifold import TSNE
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
import seaborn as sns
import umap
from model import DarnMLP, DarnConv, MdmnMLP, MdmnConv, MsdaMLP, MsdaConv, MSDi... | [
"load_data.load_numpy_data",
"numpy.random.seed",
"argparse.ArgumentParser",
"model.DarnMLP",
"torch.optim.Adadelta",
"model.DIALInsertion",
"torch.cat",
"model.MSDialMLP",
"os.path.isfile",
"matplotlib.pyplot.figure",
"model.MSDialConv",
"model.MdmnConv",
"torch.no_grad",
"os.path.join",
... | [((584, 609), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (607, 609), False, 'import argparse\n'), ((2766, 2831), 'os.path.join', 'os.path.join', (['args.result_path', 'args.name', 'args.method', 'args.mode'], {}), '(args.result_path, args.name, args.method, args.mode)\n', (2778, 2831), Fals... |
import random
import redis
from cookiespool.config import *
from flask import Flask, g
class RedisClient(object):
def __init__(self, type, website, host=REDIS_HOST, port=REDIS_PORT, password=REDIS_PASSWORD):
"""
初始化Redis连接
:param host: 地址
:param port: 端口
:param password: 密码... | [
"redis.StrictRedis"
] | [((351, 443), 'redis.StrictRedis', 'redis.StrictRedis', ([], {'host': 'host', 'port': 'port', 'password': 'password', 'decode_responses': '(True)', 'db': '(2)'}), '(host=host, port=port, password=password, decode_responses\n =True, db=2)\n', (368, 443), False, 'import redis\n')] |
"""
Created by <NAME>
<EMAIL>
Aug 4, 2020
"""
import project_config
import os
import random
from pathlib import Path
root = project_config.dataset_paths['djpeg']
imlist = [] # format: im.jpg,0 (0 for single, 1 for double)
train = []
val = []
val_ratio = 0.02
for file in os.listdir(root / 'single'):
if not file.... | [
"os.listdir"
] | [((275, 302), 'os.listdir', 'os.listdir', (["(root / 'single')"], {}), "(root / 'single')\n", (285, 302), False, 'import os\n'), ((624, 651), 'os.listdir', 'os.listdir', (["(root / 'double')"], {}), "(root / 'double')\n", (634, 651), False, 'import os\n')] |
import unittest
import cli.scripts.exceptions as exceptions
import test
class ExceptionHandlerTest(test.DeleteResourceTest):
def setUp(self):
return super().setUp()
def test_default_handler(self):
@exceptions.exception_handler()
def some_function():
raise FileNotFoundErro... | [
"cli.scripts.exceptions.exception_handler",
"cli.scripts.exceptions.cli.logger_.close"
] | [((226, 256), 'cli.scripts.exceptions.exception_handler', 'exceptions.exception_handler', ([], {}), '()\n', (254, 256), True, 'import cli.scripts.exceptions as exceptions\n'), ((696, 793), 'cli.scripts.exceptions.exception_handler', 'exceptions.exception_handler', ([], {'target': 'FileNotFoundError', 'handler': 'file_n... |
#!/usr/bin/env python
import argparse
import signal
from . import __version__
from . import slack_app
def append_subparser(subparser, cmd, func):
assert func.__doc__, "empty docstring: {}".format(func)
help_ = func.__doc__.split("\n")[0].lower().strip(".")
desc = func.__doc__.strip()
parser = subp... | [
"signal.signal",
"argparse.ArgumentParser"
] | [((616, 657), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'prog': '"""hop-slack"""'}), "(prog='hop-slack')\n", (639, 657), False, 'import argparse\n'), ((1229, 1273), 'signal.signal', 'signal.signal', (['signal.SIGINT', 'signal.SIG_DFL'], {}), '(signal.SIGINT, signal.SIG_DFL)\n', (1242, 1273), False, 'i... |
"""
Scaling workers example.
Connect to Unmanic instance and increase worker count by 1.
"""
import asyncio
from unmanic_api import Unmanic
async def main():
async with Unmanic('localhost') as unmanic:
workers_count = await unmanic.get_workers_count()
print(f"Workers count: {workers_count}")
... | [
"unmanic_api.Unmanic",
"asyncio.get_event_loop"
] | [((565, 589), 'asyncio.get_event_loop', 'asyncio.get_event_loop', ([], {}), '()\n', (587, 589), False, 'import asyncio\n'), ((176, 196), 'unmanic_api.Unmanic', 'Unmanic', (['"""localhost"""'], {}), "('localhost')\n", (183, 196), False, 'from unmanic_api import Unmanic\n')] |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Copyright (c) 2014-17 <NAME> and contributors
# See LICENSE.rst for details.
# PYTHON_ARGCOMPLETE_OK
"""
Example image-blitting.
"""
import struct
import random
from demo_opts import device
from luma.core.render import canvas
from PIL import Image, ImageDraw
size = (60... | [
"demo_opts.device.display",
"random.randint",
"random.shuffle",
"luma.core.render.canvas",
"PIL.ImageDraw.Draw",
"PIL.Image.frombytes"
] | [((681, 725), 'PIL.Image.frombytes', 'Image.frombytes', (['"""RGBA"""', 'device.size', 'packed'], {}), "('RGBA', device.size, packed)\n", (696, 725), False, 'from PIL import Image, ImageDraw\n'), ((738, 764), 'PIL.ImageDraw.Draw', 'ImageDraw.Draw', (['background'], {}), '(background)\n', (752, 764), False, 'from PIL im... |
"""Simple constructor to create single variables to create polynomials."""
from typing import Optional
import numpy.typing
import numpoly
from ..baseclass import ndpoly
def variable(
dimensions: int = 1,
asarray: bool = False,
dtype: numpy.typing.DTypeLike = "i8",
allocation: Optiona... | [
"numpoly.get_options"
] | [((1207, 1228), 'numpoly.get_options', 'numpoly.get_options', ([], {}), '()\n', (1226, 1228), False, 'import numpoly\n')] |
"""
测试文件
"""
import dao
dao.update_china_history()
dao.update_china_details()
dao.update_middlerisk()
dao.update_highrisk()
| [
"dao.update_china_details",
"dao.update_china_history",
"dao.update_highrisk",
"dao.update_middlerisk"
] | [((32, 58), 'dao.update_china_history', 'dao.update_china_history', ([], {}), '()\n', (56, 58), False, 'import dao\n'), ((60, 86), 'dao.update_china_details', 'dao.update_china_details', ([], {}), '()\n', (84, 86), False, 'import dao\n'), ((88, 111), 'dao.update_middlerisk', 'dao.update_middlerisk', ([], {}), '()\n', (... |
from django.utils.six.moves.urllib import parse as urlparse
def replace_query_param(url, key, val):
"""
Given a URL and a key/val pair, set or replace an item in the query
parameters of the URL, and return the new URL.
"""
(scheme, netloc, path, query, fragment) = urlparse.urlsplit(url)
query_... | [
"django.utils.six.moves.urllib.parse.urlsplit",
"django.utils.six.moves.urllib.parse.parse_qs",
"django.utils.six.moves.urllib.parse.urlunsplit"
] | [((287, 309), 'django.utils.six.moves.urllib.parse.urlsplit', 'urlparse.urlsplit', (['url'], {}), '(url)\n', (304, 309), True, 'from django.utils.six.moves.urllib import parse as urlparse\n'), ((327, 351), 'django.utils.six.moves.urllib.parse.parse_qs', 'urlparse.parse_qs', (['query'], {}), '(query)\n', (344, 351), Tru... |
from collections import deque
from functools import lru_cache
import numpy as np
import torch
from common.collector import EpisodeCollector
from common.network import cat_hidden
from .network import StateEncoderWrapper
from ..model import Trainer as OriginalTrainer, Tester as OriginalTester
__all__ = ['Trainer', 'T... | [
"numpy.zeros_like",
"torch.stack",
"torch.FloatTensor",
"common.network.cat_hidden",
"functools.lru_cache",
"torch.no_grad",
"collections.deque"
] | [((4123, 4146), 'functools.lru_cache', 'lru_cache', ([], {'maxsize': 'None'}), '(maxsize=None)\n', (4132, 4146), False, 'from functools import lru_cache\n'), ((4191, 4209), 'collections.deque', 'deque', ([], {'maxlen': 'None'}), '(maxlen=None)\n', (4196, 4209), False, 'from collections import deque\n'), ((2854, 2869), ... |
import json
import os
import cv2
import numpy as np
import numpy.matlib
import matplotlib.pyplot as plt
import matplotlib.patches as patches
# change IDs to your IDs.
ID1 = "302828991"
ID2 = "316524800"
ID = "HW3_{0}_{1}".format(ID1, ID2)
RESULTS = 'results'
os.makedirs(RESULTS, exist_ok=True)
IMAGE_DIR_PATH = "Image... | [
"numpy.sum",
"numpy.argmax",
"numpy.floor",
"numpy.random.normal",
"numpy.conjugate",
"os.path.join",
"matplotlib.patches.Rectangle",
"matplotlib.pyplot.imshow",
"numpy.reshape",
"numpy.matlib.repmat",
"matplotlib.pyplot.subplots",
"json.dump",
"matplotlib.pyplot.show",
"numpy.average",
... | [((261, 296), 'os.makedirs', 'os.makedirs', (['RESULTS'], {'exist_ok': '(True)'}), '(RESULTS, exist_ok=True)\n', (272, 296), False, 'import os\n'), ((2157, 2172), 'numpy.floor', 'np.floor', (['state'], {}), '(state)\n', (2165, 2172), True, 'import numpy as np\n'), ((2214, 2236), 'numpy.zeros', 'np.zeros', (['(16, 16, 1... |
##########################################################################################################################################
## License: Apache 2.0. See LICENSE file in root directory. ##
#############################################... | [
"numpy.zeros_like",
"sklearn.cluster.DBSCAN",
"numpy.empty",
"cv2.threshold",
"cv2.moments",
"numpy.asanyarray",
"numpy.append",
"numpy.vstack",
"numpy.mean",
"numpy.array",
"numpy.matmul",
"sys.exit",
"cv2.findContours"
] | [((1708, 1724), 'numpy.empty', 'np.empty', (['(0, 3)'], {}), '((0, 3))\n', (1716, 1724), True, 'import numpy as np\n'), ((1749, 1785), 'cv2.threshold', 'cv2.threshold', (['infrared', '(150)', '(255)', '(0)'], {}), '(infrared, 150, 255, 0)\n', (1762, 1785), False, 'import cv2\n'), ((1852, 1924), 'cv2.findContours', 'cv2... |
# -*-: coding: utf-8 -*-
# Copyright 2019 Euclidr. All rights reserved.
# Use of this source code is governed by a MIT style
# license that can be found in the LICENSE file.
import os
from datetime import datetime, timedelta
from flask import Flask, request, flash, redirect, abort,\
render_template, url_for
impo... | [
"flask.flash",
"route53.change_a_record_set",
"flask.Flask",
"flask.abort",
"os.path.isfile",
"datetime.datetime.strptime",
"datetime.timedelta",
"flask.url_for",
"flask.render_template",
"lightsail.change_public_ip",
"datetime.datetime.now"
] | [((378, 393), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (383, 393), False, 'from flask import Flask, request, flash, redirect, abort, render_template, url_for\n'), ((1811, 1901), 'lightsail.change_public_ip', 'lightsail.change_public_ip', (["app.config['INSTANCE_NAME']", "app.config['IP_NAME_PREFIX']"... |
"""Remote player
================
This class plays video from the network. E.g. a
:class:`cpl_media.remote.server.RemoteData` can be configured
to broadcast video from a FFmpeg camera. This client plays the video from
the server.
"""
from threading import Thread
from time import perf_counter as clock
import socket
im... | [
"threading.Thread",
"kivy.clock.Clock.create_trigger",
"cpl_media.player.VideoMetadata",
"ffpyplayer.pic.Image",
"os.path.dirname",
"socket.socket",
"kivy.properties.BooleanProperty",
"kivy.properties.StringProperty",
"time.perf_counter",
"select.select",
"kivy.logger.Logger.info",
"cpl_media.... | [((1178, 1196), 'kivy.properties.StringProperty', 'StringProperty', (['""""""'], {}), "('')\n", (1192, 1196), False, 'from kivy.properties import StringProperty, NumericProperty, BooleanProperty\n'), ((1269, 1287), 'kivy.properties.NumericProperty', 'NumericProperty', (['(0)'], {}), '(0)\n', (1284, 1287), False, 'from ... |
from DateStruct import DateStruct
from Controller import Controller
print("Digite 0 para finalizar o programa.")
print("Digite 1 para verificar se o ano é Bissexto.")
print("Digite 2 para verificar se a data é valida.")
print("Digite 3 para verificar a data da Páscoa.")
print("Digite 4 para verificar se as datas são i... | [
"Controller.Controller"
] | [((653, 670), 'Controller.Controller', 'Controller', (['date1'], {}), '(date1)\n', (663, 670), False, 'from Controller import Controller\n')] |
'''
Pyg's own HelpFormatter for argparse.
The standard help would be like this:
usage: pyg [-h] [-d] [--verbose] [-v]
{search,shell,help,list,update,remove,freeze,link,bundle,install,
download,unlink,check}
...
positional arguments:
{search,shell,help,list,update,remo... | [
"re.compile"
] | [((2871, 2889), 're.compile', 're.compile', (['"""[ ]+"""'], {}), "('[ ]+')\n", (2881, 2889), False, 'import re\n')] |
import os
import zipfile
import torch
from io import BytesIO
from torchvision.utils import save_image
from ts.torch_handler.base_handler import BaseHandler
MODELSZIP = "models.zip"
CHECKPOINT = "DCGAN_fashionGen.pth"
class ModelHandler(BaseHandler):
def __init__(self):
self.initialized = False
s... | [
"io.BytesIO",
"zipfile.ZipFile",
"models.DCGAN.DCGAN",
"torch.load",
"os.path.exists",
"torchvision.utils.save_image",
"torch.cuda.is_available",
"torch.device",
"torch.no_grad"
] | [((1310, 1361), 'models.DCGAN.DCGAN', 'DCGAN', ([], {'useGPU': 'self.use_gpu', 'storeAVG': 'self.store_avg'}), '(useGPU=self.use_gpu, storeAVG=self.store_avg)\n', (1315, 1361), False, 'from models.DCGAN import DCGAN\n'), ((1383, 1455), 'torch.load', 'torch.load', (["(model_dir + '/' + CHECKPOINT)"], {'map_location': 's... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""This is a minimalist frameless QDialog."""
__author__ = ["<NAME>", "<NAME>", "<NAME>", "<NAME>"]
__copyright__ = "Copyright 2022, SimpleDigitalAssistant"
__credits__ = ["<NAME>", "<NAME>", "<NAME>", "<NAME>"]
__license__ = "MIT"
import os
from PyQt5 import QtGui, QtW... | [
"PyQt5.QtWidgets.QLabel",
"PyQt5.QtWidgets.QFrame",
"dynamicPyQt5Labels.CustomButton",
"PyQt5.QtWidgets.QHBoxLayout",
"os.system",
"dynamicPyQt5Labels.ScrollableLabel",
"PyQt5.QtWidgets.QVBoxLayout",
"dynamicPyQt5Labels.ColorChangingLabel"
] | [((575, 620), 'os.system', 'os.system', (['"""cmd /c "start ms-settings:sound\\""""'], {}), '(\'cmd /c "start ms-settings:sound"\')\n', (584, 620), False, 'import os\n'), ((2506, 2529), 'PyQt5.QtWidgets.QVBoxLayout', 'QtWidgets.QVBoxLayout', ([], {}), '()\n', (2527, 2529), False, 'from PyQt5 import QtGui, QtWidgets, Qt... |
from flask import Flask, jsonify, request
from app import health, image
# from app.setting import *
# TODO: setup flask config using environ
app = Flask(__name__)
app.register_blueprint(health.views.blueprint)
app.register_blueprint(image.views.blueprint)
if __name__ == "__main__":
app.run(debug=True, host="0.... | [
"flask.Flask"
] | [((150, 165), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (155, 165), False, 'from flask import Flask, jsonify, request\n')] |
import aspose.words as aw
from docs_examples_base import DocsExamplesBase, MY_DIR, ARTIFACTS_DIR
class DocumentProtection(DocsExamplesBase):
def test_protect(self):
#ExStart:ProtectDocument
doc = aw.Document(MY_DIR + "Document.docx")
doc.protect(aw.ProtectionType.ALLOW_ONLY_FORM_... | [
"aspose.words.Document",
"aspose.words.DocumentBuilder"
] | [((227, 264), 'aspose.words.Document', 'aw.Document', (["(MY_DIR + 'Document.docx')"], {}), "(MY_DIR + 'Document.docx')\n", (238, 264), True, 'import aspose.words as aw\n'), ((458, 495), 'aspose.words.Document', 'aw.Document', (["(MY_DIR + 'Document.docx')"], {}), "(MY_DIR + 'Document.docx')\n", (469, 495), True, 'impo... |
import os
import re
import glob
import socket
import os.path
from EventWriter import EventWriter
class FrontendEventWriter(EventWriter):
def __init__(self, fname, title, ws_port):
super().__init__()
ws_marker = 'undefined'
new_data_marker = '⚗'
included_css_files = ''.join(
... | [
"os.path.isfile",
"socket.socket",
"os.path.dirname"
] | [((1446, 1467), 'os.path.isfile', 'os.path.isfile', (['fname'], {}), '(fname)\n', (1460, 1467), False, 'import os\n'), ((3139, 3187), 'socket.socket', 'socket.socket', (['socket.AF_INET', 'socket.SOCK_DGRAM'], {}), '(socket.AF_INET, socket.SOCK_DGRAM)\n', (3152, 3187), False, 'import socket\n'), ((428, 453), 'os.path.d... |
from models.config import db
from marshmallow import Schema, fields
from .Media import MediaSchema
from .Auction import AuctionSchema
class Ownership(db.Model):
id = db.Column(db.Integer, primary_key=True)
uid = db.Column(db.Integer, db.ForeignKey('user.id'), nullable=False)
aid = db.Column(db.Integer, db.... | [
"marshmallow.fields.Int",
"models.config.db.backref",
"models.config.db.ForeignKey",
"models.config.db.Column",
"marshmallow.fields.Nested"
] | [((171, 210), 'models.config.db.Column', 'db.Column', (['db.Integer'], {'primary_key': '(True)'}), '(db.Integer, primary_key=True)\n', (180, 210), False, 'from models.config import db\n'), ((832, 857), 'marshmallow.fields.Int', 'fields.Int', ([], {'required': '(True)'}), '(required=True)\n', (842, 857), False, 'from ma... |
# encoding: utf-8
from itertools import izip
import logging
import numpy as np
random_seed = 42
logger = logging.getLogger(__name__)
class H5EmbeddingManager(object):
def __init__(self, h5_path):
import h5py
f = h5py.File(h5_path, 'r')
self.W = np.array(f['embedding'])
logger.inf... | [
"numpy.random.uniform",
"h5py.File",
"numpy.random.seed",
"numpy.zeros",
"numpy.ones",
"numpy.array",
"logging.getLogger"
] | [((107, 134), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (124, 134), False, 'import logging\n'), ((236, 259), 'h5py.File', 'h5py.File', (['h5_path', '"""r"""'], {}), "(h5_path, 'r')\n", (245, 259), False, 'import h5py\n'), ((277, 301), 'numpy.array', 'np.array', (["f['embedding']"], {... |
#!/usr/bin/python
import os
import sys
import time
import struct
import json
import queue
if sys.version_info[0] < 3:
import _thread
else:
import _thread
import threading
from mksdk import MkSUSBAdaptor
from mksdk import MkSProtocol
from mksdk import MkSAbstractConnector
class Connector (MkSAbstrac... | [
"os.listdir",
"mksdk.MkSUSBAdaptor.Adaptor",
"_thread.start_new_thread",
"mksdk.MkSProtocol.Protocol",
"threading.Lock",
"queue.Queue",
"mksdk.MkSAbstractConnector.AbstractConnector.__init__"
] | [((377, 430), 'mksdk.MkSAbstractConnector.AbstractConnector.__init__', 'MkSAbstractConnector.AbstractConnector.__init__', (['self'], {}), '(self)\n', (424, 430), False, 'from mksdk import MkSAbstractConnector\n'), ((548, 570), 'mksdk.MkSProtocol.Protocol', 'MkSProtocol.Protocol', ([], {}), '()\n', (568, 570), False, 'f... |
from twisted.internet import reactor, threads
#import httplib
import itertools
from newspaper import Article
concurrent = 500
finished=itertools.count(1)
reactor.suggestThreadPoolSize(concurrent)
def getStatus(ourl):
article = Article(ourl)
article.download()
# print(article.html)
article.parse()
... | [
"itertools.count",
"twisted.internet.threads.deferToThread",
"twisted.internet.reactor.run",
"twisted.internet.reactor.stop",
"twisted.internet.reactor.suggestThreadPoolSize",
"newspaper.Article"
] | [((138, 156), 'itertools.count', 'itertools.count', (['(1)'], {}), '(1)\n', (153, 156), False, 'import itertools\n'), ((157, 198), 'twisted.internet.reactor.suggestThreadPoolSize', 'reactor.suggestThreadPoolSize', (['concurrent'], {}), '(concurrent)\n', (186, 198), False, 'from twisted.internet import reactor, threads\... |
from click.testing import CliRunner
from dfainductor import cli
def test_basic_minDFA_ig_BFS_5(dfa_5_states):
basic_minDFA_ig_BFS(dfa_5_states, 5)
def test_basic_minDFA_ig_BFS_10(dfa_10_states):
basic_minDFA_ig_BFS(dfa_10_states, 10)
def basic_minDFA_ig_BFS(input_, size):
runner = CliRunner()
res... | [
"click.testing.CliRunner"
] | [((301, 312), 'click.testing.CliRunner', 'CliRunner', ([], {}), '()\n', (310, 312), False, 'from click.testing import CliRunner\n')] |
"""
Unitary tests for hana.py.
:author: xarbulu
:organization: SUSE LLC
:contact: <EMAIL>
:since: 2018-11-16
"""
# pylint:disable=C0103,C0111,W0212,W0611
import os
import sys
sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
import logging
import unittest
import filecmp
import shut... | [
"shaptools.hana.HanaInstance.get_platform",
"shaptools.hana.HanaInstance.update_conf_file",
"os.path.abspath",
"logging.basicConfig",
"mock.call",
"os.path.dirname",
"shaptools.hana.HanaInstance",
"mock.patch",
"shaptools.hana.HanaInstance.install",
"mock.Mock",
"shutil.copyfile",
"shaptools.h... | [((1710, 1740), 'mock.patch', 'mock.patch', (['"""platform.machine"""'], {}), "('platform.machine')\n", (1720, 1740), False, 'import mock\n'), ((2205, 2235), 'mock.patch', 'mock.patch', (['"""platform.machine"""'], {}), "('platform.machine')\n", (2215, 2235), False, 'import mock\n'), ((2574, 2615), 'mock.patch', 'mock.... |
import pandas as pd
import numpy as np
import random as rd
from sklearn.manifold import TSNE
class Data:
def __init__(self,path='',header=None,indexCol=None,nbSample = 10,artificial=False,nbRow=2000,nbItem=50,separator=','):
self.artificial = artificial
self.nbRow=nbRow
self.nbItem = nbIte... | [
"pandas.DataFrame",
"random.randint",
"sklearn.manifold.TSNE",
"pandas.read_csv",
"numpy.asarray",
"numpy.where",
"numpy.arange",
"numpy.array"
] | [((2401, 2447), 'pandas.DataFrame', 'pd.DataFrame', (['transformed'], {'columns': 'self.labels'}), '(transformed, columns=self.labels)\n', (2413, 2447), True, 'import pandas as pd\n'), ((2925, 2949), 'numpy.arange', 'np.arange', (['self.nbSample'], {}), '(self.nbSample)\n', (2934, 2949), True, 'import numpy as np\n'), ... |
# SPDX-FileCopyrightText: <NAME>. <<EMAIL>>
# SPDX-License-Identifier: MIT
"""
Channel module
------------------------------
"""
import os
from .metadata import MetaData, MetaDataChannel
from ._utils import read_raster, write_raster, write_metadata, data_type_dict_aresys, \
byte_order_dict_aresys, EOpenMode, get_... | [
"os.path.isfile"
] | [((711, 736), 'os.path.isfile', 'os.path.isfile', (['file_name'], {}), '(file_name)\n', (725, 736), False, 'import os\n')] |
# -*- coding: utf-8 -*-
"""
http://matplotlib.org/examples/user_interfaces/embedding_in_qt4.html
"""
# import utool as ut
# import sys
# import os
# import random
import time
from wbia.guitool.__PYQT__ import QtCore
from wbia.guitool.__PYQT__ import QtGui as QtWidgets
from matplotlib.backends.backend_qt4agg import Fig... | [
"matplotlib.figure.Figure",
"wbia.guitool.__PYQT__.QtGui.qApp.processEvents",
"time.sleep",
"wbia.guitool.__PYQT__.QtCore.pyqtSlot"
] | [((2384, 2401), 'wbia.guitool.__PYQT__.QtCore.pyqtSlot', 'QtCore.pyqtSlot', ([], {}), '()\n', (2399, 2401), False, 'from wbia.guitool.__PYQT__ import QtCore\n'), ((2659, 2676), 'wbia.guitool.__PYQT__.QtCore.pyqtSlot', 'QtCore.pyqtSlot', ([], {}), '()\n', (2674, 2676), False, 'from wbia.guitool.__PYQT__ import QtCore\n'... |
# Generated by Django 3.0.10 on 2020-11-27 06:49
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('home', '0005_dictricstatictisinfo'),
]
operations = [
migrations.RenameField(
model_name='dictricstatictisinfo',
old_name='... | [
"django.db.migrations.RenameField"
] | [((227, 330), 'django.db.migrations.RenameField', 'migrations.RenameField', ([], {'model_name': '"""dictricstatictisinfo"""', 'old_name': '"""dictrict"""', 'new_name': '"""address"""'}), "(model_name='dictricstatictisinfo', old_name=\n 'dictrict', new_name='address')\n", (249, 330), False, 'from django.db import mig... |
#!/usr/bin/env python
# _*_ coding:utf-8_*_
# author:<EMAIL>
# create by thomas on 2019/8/24.
import time
from .Base import db
class Language(db.Model):
id = db.Column(db.Integer, primary_key=True)
name = db.Column(db.String(64), unique=True, comment="语言名称")
code = db.Column(db.String(12), comment="国家简码")... | [
"time.time"
] | [((427, 438), 'time.time', 'time.time', ([], {}), '()\n', (436, 438), False, 'import time\n'), ((509, 520), 'time.time', 'time.time', ([], {}), '()\n', (518, 520), False, 'import time\n')] |
# coding: utf-8
# Copyright (c) 2016, 2022, Oracle and/or its affiliates. All rights reserved.
# This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may c... | [
"oci.util.formatted_flat_dict"
] | [((8962, 8987), 'oci.util.formatted_flat_dict', 'formatted_flat_dict', (['self'], {}), '(self)\n', (8981, 8987), False, 'from oci.util import formatted_flat_dict, NONE_SENTINEL, value_allowed_none_or_none_sentinel\n')] |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sat May 18 16:07:01 2019
@author: <NAME>
"""
import numpy as np
import RydbergFunctions as Rydberg
atom = '87Rb'
nnc6 = np.arange(35,83)
c6S1_2 = np.zeros(np.shape(nnc6))
c6D3_2 = np.zeros(np.shape(nnc6))
c6D5_2 = np.zeros(np.shape(nnc6))
for kk in ran... | [
"numpy.shape",
"RydbergFunctions.BlockadeShift",
"numpy.arange",
"numpy.array"
] | [((186, 203), 'numpy.arange', 'np.arange', (['(35)', '(83)'], {}), '(35, 83)\n', (195, 203), True, 'import numpy as np\n'), ((222, 236), 'numpy.shape', 'np.shape', (['nnc6'], {}), '(nnc6)\n', (230, 236), True, 'import numpy as np\n'), ((256, 270), 'numpy.shape', 'np.shape', (['nnc6'], {}), '(nnc6)\n', (264, 270), True,... |
# -*- coding: utf-8 -*-
import os
import re
from datetime import datetime
from catsup.options import g
from catsup.utils import html_to_raw_text
from .utils import Pagination
class CatsupPage(object):
@property
def class_name(self):
return self.__class__.__name__.lower()
def get_permalink_args... | [
"os.stat",
"os.path.basename",
"catsup.utils.html_to_raw_text",
"datetime.datetime.strptime",
"datetime.datetime.fromtimestamp",
"catsup.options.g.archives.get",
"catsup.options.g.tags.get",
"re.compile"
] | [((3005, 3043), 're.compile', 're.compile', (['"""\\\\d{4}\\\\-\\\\d{2}\\\\-\\\\d{2}"""'], {}), "('\\\\d{4}\\\\-\\\\d{2}\\\\-\\\\d{2}')\n", (3015, 3043), False, 'import re\n'), ((4658, 4690), 'datetime.datetime.fromtimestamp', 'datetime.fromtimestamp', (['st_ctime'], {}), '(st_ctime)\n', (4680, 4690), False, 'from date... |
""" Command-group: voithos migrate ubuntu """
import click
# from voithos.lib.migrate.ubuntu import UbuntuWorker
from voithos.lib.migrate.ubuntu import UbuntuWorker
from voithos.lib.system import error
@click.argument("devices", nargs=-1)
@click.command(name="get-boot-mode")
def get_boot_mode(devices):
""" Print... | [
"click.argument",
"click.option",
"click.command",
"voithos.lib.system.error",
"voithos.lib.migrate.ubuntu.UbuntuWorker",
"click.group"
] | [((206, 241), 'click.argument', 'click.argument', (['"""devices"""'], {'nargs': '(-1)'}), "('devices', nargs=-1)\n", (220, 241), False, 'import click\n'), ((243, 278), 'click.command', 'click.command', ([], {'name': '"""get-boot-mode"""'}), "(name='get-boot-mode')\n", (256, 278), False, 'import click\n'), ((412, 447), ... |
from torch.utils.data import Dataset
import os
import torch
from PIL import Image
from torchvision import transforms
import numpy as np
import glob
def oversample(imgs, labels, rep=2):
covid_idxs = np.where(labels == 0)[0]
covid_imgs = imgs[covid_idxs]
covid_labels = labels[covid_idxs]
covid_imgs_rep ... | [
"torchvision.transforms.RandomHorizontalFlip",
"torchvision.transforms.Normalize",
"PIL.Image.open",
"torchvision.transforms.ToTensor",
"numpy.append",
"numpy.where",
"numpy.array",
"glob.glob",
"torchvision.transforms.Resize",
"os.path.join",
"torchvision.transforms.RandomCrop",
"numpy.repeat... | [((322, 348), 'numpy.repeat', 'np.repeat', (['covid_imgs', 'rep'], {}), '(covid_imgs, rep)\n', (331, 348), True, 'import numpy as np\n'), ((372, 400), 'numpy.repeat', 'np.repeat', (['covid_labels', 'rep'], {}), '(covid_labels, rep)\n', (381, 400), True, 'import numpy as np\n'), ((416, 447), 'numpy.append', 'np.append',... |
from PIL import Image,ImageEnhance
import os.path,cv2,random,math
def tile2long(x,z) :
#return min longtitude of a tile x
return (x/math.pow(2,z)*360-180)
def tile2lat(y,z) :
#return min latitude of a tile y
n=math.pi-2*math.pi*y/math.pow(2,z);
return (180/math.pi*math.atan(0.5*(math.exp... | [
"PIL.Image.new",
"math.exp",
"PIL.ImageEnhance.Brightness",
"math.pow",
"math.tan",
"PIL.ImageEnhance.Color",
"math.floor",
"PIL.ImageEnhance.Contrast",
"PIL.Image.open",
"PIL.ImageEnhance.Sharpness",
"math.log"
] | [((413, 465), 'math.floor', 'math.floor', (['(807815 / 2 ** (minZoomRange - zoomRange))'], {}), '(807815 / 2 ** (minZoomRange - zoomRange))\n', (423, 465), False, 'import os.path, cv2, random, math\n'), ((474, 526), 'math.floor', 'math.floor', (['(831941 / 2 ** (minZoomRange - zoomRange))'], {}), '(831941 / 2 ** (minZo... |
"""
Matrix utilities.
"""
from __future__ import unicode_literals
from itertools import product
from jinja2 import (
Environment,
meta,
)
from .exceptions import UnknownKeys
def find_required_keys(*commands):
"""
Parse a command and get a set of all referenced context keys it contains.
:param... | [
"jinja2.Environment"
] | [((513, 526), 'jinja2.Environment', 'Environment', ([], {}), '()\n', (524, 526), False, 'from jinja2 import Environment, meta\n')] |
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
from hermes_python.hermes import Hermes
import datetime
import pytz
INTENT_HOW_ARE_YOU = "hobil:how_are_you"
INTENT_COLOR = "hobil:color"
INTENT_TIME = "hobil:time"
def main():
with Hermes("localhost:1883") as h:
h.subscribe_intent(INTENT_HOW_ARE_YOU, how_a... | [
"hermes_python.hermes.Hermes",
"pytz.timezone"
] | [((237, 261), 'hermes_python.hermes.Hermes', 'Hermes', (['"""localhost:1883"""'], {}), "('localhost:1883')\n", (243, 261), False, 'from hermes_python.hermes import Hermes\n'), ((1142, 1163), 'pytz.timezone', 'pytz.timezone', (['tzname'], {}), '(tzname)\n', (1155, 1163), False, 'import pytz\n')] |
from unittest import TestCase
from piccolo.apps.user.tables import BaseUser
from piccolo.conf.apps import AppConfig, AppRegistry, Finder, table_finder
from tests.example_apps.mega.tables import MegaTable, SmallTable
from tests.example_apps.music.tables import (
Band,
Concert,
Manager,
Poster,
Recor... | [
"piccolo.conf.apps.AppConfig",
"piccolo.conf.apps.Finder",
"piccolo.conf.apps.AppRegistry",
"piccolo.conf.apps.table_finder"
] | [((461, 512), 'piccolo.conf.apps.AppRegistry', 'AppRegistry', ([], {'apps': "['piccolo.apps.user.piccolo_app']"}), "(apps=['piccolo.apps.user.piccolo_app'])\n", (472, 512), False, 'from piccolo.conf.apps import AppConfig, AppRegistry, Finder, table_finder\n'), ((694, 745), 'piccolo.conf.apps.AppRegistry', 'AppRegistry'... |
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Copyright: (c) 2021, Ansible Project
# Copyright: (c) 2021, VMware, Inc. All Rights Reserved.
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
from __future__ import absolute_import, division, print_function
__metaclass__ = type
... | [
"ansible.module_utils._text.to_native",
"ansible_collections.community.vmware.plugins.module_utils.vm_device_helper.PyVmomiDeviceHelper",
"ansible_collections.community.vmware.plugins.module_utils.vmware.vmware_argument_spec",
"ansible_collections.community.vmware.plugins.module_utils.vmware.find_obj",
"ans... | [((12816, 12838), 'ansible_collections.community.vmware.plugins.module_utils.vmware.vmware_argument_spec', 'vmware_argument_spec', ([], {}), '()\n', (12836, 12838), False, 'from ansible_collections.community.vmware.plugins.module_utils.vmware import find_obj, vmware_argument_spec, PyVmomi\n'), ((13287, 13412), 'ansible... |
import json
import logging
import urllib.parse
from flask import request, jsonify
from flask_restplus import Resource, Namespace, fields
from ..job.jobquery import JobQuery
from ..job.job import Job
log = logging.getLogger(__name__)
jobapi = Namespace("Jobs", description="Jobs Api")
jobs = jobapi.model(
"Jobs",... | [
"flask.request.args.to_dict",
"flask.jsonify",
"flask_restplus.fields.String",
"flask_restplus.Namespace",
"logging.getLogger"
] | [((206, 233), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (223, 233), False, 'import logging\n'), ((245, 286), 'flask_restplus.Namespace', 'Namespace', (['"""Jobs"""'], {'description': '"""Jobs Api"""'}), "('Jobs', description='Jobs Api')\n", (254, 286), False, 'from flask_restplus imp... |
import os
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import tensorflow as tf
from model.datapipe import getDataset
from model.capsule import TextCaps
import argparse
import json
import time
parser = argparse.ArgumentParser(description='TextCapsV2')
parser.add_argument('config', type=str, help='Configuration file path')
... | [
"model.capsule.TextCaps",
"json.load",
"tensorflow.keras.losses.MeanSquaredError",
"argparse.ArgumentParser",
"tensorflow.summary.text",
"tensorflow.argmax",
"tensorflow.maximum",
"tensorflow.data.Dataset.from_tensor_slices",
"time.time",
"tensorflow.keras.optimizers.Adam",
"tensorflow.squeeze",... | [((198, 247), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""TextCapsV2"""'}), "(description='TextCapsV2')\n", (221, 247), False, 'import argparse\n'), ((562, 574), 'json.load', 'json.load', (['f'], {}), '(f)\n', (571, 574), False, 'import json\n'), ((4952, 4979), 'model.capsule.TextCaps... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Tests for the encryption manager."""
import unittest
from dfvfs.encryption import decrypter
from dfvfs.encryption import manager
from dfvfs.encryption import rc4_decrypter
from dfvfs.lib import definitions
from tests import test_lib as shared_test_lib
class TestDecr... | [
"unittest.main",
"dfvfs.encryption.manager.EncryptionManager.GetDecrypter",
"dfvfs.encryption.manager.EncryptionManager.RegisterDecrypter",
"dfvfs.encryption.manager.EncryptionManager.DeregisterDecrypter"
] | [((2146, 2161), 'unittest.main', 'unittest.main', ([], {}), '()\n', (2159, 2161), False, 'import unittest\n'), ((1187, 1245), 'dfvfs.encryption.manager.EncryptionManager.RegisterDecrypter', 'manager.EncryptionManager.RegisterDecrypter', (['TestDecrypter'], {}), '(TestDecrypter)\n', (1230, 1245), False, 'from dfvfs.encr... |
from robber import expect
from robber.explanation import Explanation
from robber.matchers.base import Base
class RespondTo(Base):
"""
expect(obj).to.respond_to('method')
"""
def matches(self):
return hasattr(self.actual, self.expected) and callable(getattr(self.actual, self.expected))
@p... | [
"robber.expect.register",
"robber.explanation.Explanation"
] | [((444, 484), 'robber.expect.register', 'expect.register', (['"""respond_to"""', 'RespondTo'], {}), "('respond_to', RespondTo)\n", (459, 484), False, 'from robber import expect\n'), ((370, 441), 'robber.explanation.Explanation', 'Explanation', (['self.actual', 'self.is_negative', '"""respond to"""', 'self.expected'], {... |
import sys
import operator
import itertools
from datetime import datetime
from pymongo.errors import DuplicateKeyError
from easydict import EasyDict as edict
from bson.objectid import ObjectId
from jetengine import ASCENDING
from jetengine.aggregation.base import Aggregation
from jetengine.connection import get_conne... | [
"jetengine.connection.get_connection",
"bson.objectid.ObjectId",
"jetengine.query_builder.node.QNot",
"datetime.datetime.now",
"jetengine.query_builder.transform.validate_fields",
"jetengine.aggregation.base.Aggregation",
"sys.exc_info",
"itertools.groupby",
"operator.itemgetter",
"jetengine.query... | [((720, 736), 'jetengine.query_builder.field_list.QueryFieldList', 'QueryFieldList', ([], {}), '()\n', (734, 736), False, 'from jetengine.query_builder.field_list import QueryFieldList\n'), ((18878, 18919), 'itertools.groupby', 'itertools.groupby', (['fields', '(lambda x: x[1])'], {}), '(fields, lambda x: x[1])\n', (18... |
# -*- coding: utf-8 -*-
import functools
import logging
import random
import time
from collections import namedtuple
from py_zipkin import Encoding
from py_zipkin import Kind
from py_zipkin import storage
from py_zipkin.encoding._helpers import create_endpoint
from py_zipkin.encoding._helpers import SpanBuilder
from p... | [
"py_zipkin.logging_helper.ZipkinLoggingContext",
"py_zipkin.storage.default_span_storage",
"py_zipkin.exception.ZipkinError",
"time.time",
"random.random",
"collections.namedtuple",
"functools.wraps",
"py_zipkin.util.generate_random_128bit_string",
"py_zipkin.util.generate_random_64bit_string",
"p... | [((935, 1030), 'collections.namedtuple', 'namedtuple', (['"""ZipkinAttrs"""', "['trace_id', 'span_id', 'parent_span_id', 'flags', 'is_sampled']"], {}), "('ZipkinAttrs', ['trace_id', 'span_id', 'parent_span_id', 'flags',\n 'is_sampled'])\n", (945, 1030), False, 'from collections import namedtuple\n'), ((1066, 1103), ... |
#!/usr/bin/env python3
# coding: utf-8
from state import Piece, Board, GameMove, GameState, ROLL_DICE, MOVE_PIECE, PIECE_OUT
from util import roll as roll_dice
from typing import List, Sequence
class Dice:
def roll(self) -> int:
return roll_dice()
class GameEngine:
def __init__(self, board: Board, ... | [
"state.GameMove.roll_dice",
"game.is_valid_move",
"util.roll",
"state.GameMove.piece_out",
"state.GameState.create",
"state.GameMove.move_piece"
] | [((251, 262), 'util.roll', 'roll_dice', ([], {}), '()\n', (260, 262), True, 'from util import roll as roll_dice\n'), ((363, 386), 'state.GameState.create', 'GameState.create', (['board'], {}), '(board)\n', (379, 386), False, 'from state import Piece, Board, GameMove, GameState, ROLL_DICE, MOVE_PIECE, PIECE_OUT\n'), ((9... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.