code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
from hpc.autoscale.job.nodequeue import NodeQueue
from hpc.autoscale.job.schedulernode import SchedulerNode
from hpc.autoscale.node.node import Node
from hpc.autoscale.results import EarlyBailoutResult
class HostnameNodeQueue(NodeQueue):
def node_priority(self, node: Node) -> int:
return ord(node.hostname... | [
"hpc.autoscale.results.EarlyBailoutResult",
"hpc.autoscale.job.schedulernode.SchedulerNode",
"hpc.autoscale.job.nodequeue.NodeQueue"
] | [((979, 990), 'hpc.autoscale.job.nodequeue.NodeQueue', 'NodeQueue', ([], {}), '()\n', (988, 990), False, 'from hpc.autoscale.job.nodequeue import NodeQueue\n'), ((1543, 1575), 'hpc.autoscale.job.schedulernode.SchedulerNode', 'SchedulerNode', (['"""a"""', "{'ncpus': 4}"], {}), "('a', {'ncpus': 4})\n", (1556, 1575), Fals... |
import numpy as np
def minmax(it):
min = max = None
for val in it:
if min is None or val < min:
min = val
if max is None or val > max:
max = val
return min, max
def NGaussFunc(x, *params): # x0 pk width
y = np.zeros_like(x)
for i in range(0, len(params) -... | [
"numpy.exp",
"numpy.zeros_like"
] | [((268, 284), 'numpy.zeros_like', 'np.zeros_like', (['x'], {}), '(x)\n', (281, 284), True, 'import numpy as np\n'), ((430, 461), 'numpy.exp', 'np.exp', (['(-((x - ctr) / wid) ** 2)'], {}), '(-((x - ctr) / wid) ** 2)\n', (436, 461), True, 'import numpy as np\n')] |
# -*- coding: utf-8 -*-
"""SSO Common operations."""
import logging
from directory_tests_shared.clients import BASIC_AUTHENTICATOR, SSO_TEST_API_CLIENT
def verify_account(email: str):
response = SSO_TEST_API_CLIENT.flag_user_email_as_verified_or_not(
email, verified=True, authenticator=BASIC_AUTHENTICATO... | [
"directory_tests_shared.clients.SSO_TEST_API_CLIENT.flag_user_email_as_verified_or_not",
"directory_tests_shared.clients.SSO_TEST_API_CLIENT.delete_user_by_email",
"logging.warning",
"logging.debug"
] | [((202, 317), 'directory_tests_shared.clients.SSO_TEST_API_CLIENT.flag_user_email_as_verified_or_not', 'SSO_TEST_API_CLIENT.flag_user_email_as_verified_or_not', (['email'], {'verified': '(True)', 'authenticator': 'BASIC_AUTHENTICATOR'}), '(email, verified=True,\n authenticator=BASIC_AUTHENTICATOR)\n', (256, 317), Fa... |
# Response messages.
import random
from discord.ext import commands
SUCCESSES = (
"Success",
"Done",
":100:",
":ok:",
":smile::+1:",
)
FAILS = (
"Fail",
"Bump",
"Poop",
":poop:",
":frowning::-1:",
)
JEALOUS = (
"Who's this?",
"Who is that?",
"What are they doing ... | [
"random.choice"
] | [((689, 709), 'random.choice', 'random.choice', (['FAILS'], {}), '(FAILS)\n', (702, 709), False, 'import random\n'), ((819, 843), 'random.choice', 'random.choice', (['SUCCESSES'], {}), '(SUCCESSES)\n', (832, 843), False, 'import random\n')] |
# -*- coding:utf-8 -*-
# =========================================================================== #
# Project : MLStudio #
# File : \test_optimizers copy.py #
# Python : 3.8.3 ... | [
"numpy.allclose",
"pathlib.Path",
"mlstudio.supervised.algorithms.optimization.services.optimizers.Nesterov",
"os.path.join",
"mlstudio.supervised.algorithms.optimization.services.optimizers.Adagrad",
"mlstudio.supervised.algorithms.optimization.services.optimizers.Momentum",
"sys.path.append"
] | [((1738, 1779), 'os.path.join', 'os.path.join', (['homedir', '"""tests\\\\test_data"""'], {}), "(homedir, 'tests\\\\test_data')\n", (1750, 1779), False, 'import os\n'), ((1780, 1804), 'sys.path.append', 'sys.path.append', (['homedir'], {}), '(homedir)\n', (1795, 1804), False, 'import sys\n'), ((1805, 1829), 'sys.path.a... |
# -*- coding:utf-8 -*-
import requests
import os
import openpyxl
from rrunner.common.handle_config import config
from rrunner.common.handle_path import DATA_DIR, CASE_DIR
def getByPath(path, obj):
paths = path.split(".")
for path in paths:
obj = obj.get(path, None)
if obj == None:
... | [
"os.path.join",
"openpyxl.Workbook",
"rrunner.common.handle_config.config.get"
] | [((3611, 3630), 'openpyxl.Workbook', 'openpyxl.Workbook', ([], {}), '()\n', (3628, 3630), False, 'import openpyxl\n'), ((2056, 2103), 'os.path.join', 'os.path.join', (["(CASE_DIR + '\\\\InnerApi')", 'caseName'], {}), "(CASE_DIR + '\\\\InnerApi', caseName)\n", (2068, 2103), False, 'import os\n'), ((2149, 2196), 'os.path... |
from __future__ import absolute_import
from django.conf import settings
from sentry.utils.imports import import_submodules
import_submodules(globals(), __name__, __path__)
if 'south' in settings.INSTALLED_APPS:
from south.modelsinspector import add_introspection_rules
add_introspection_rules([], ["^social_... | [
"south.modelsinspector.add_introspection_rules"
] | [((282, 348), 'south.modelsinspector.add_introspection_rules', 'add_introspection_rules', (['[]', "['^social_auth\\\\.fields\\\\.JSONField']"], {}), "([], ['^social_auth\\\\.fields\\\\.JSONField'])\n", (305, 348), False, 'from south.modelsinspector import add_introspection_rules\n')] |
import numpy as np
import pandas as pd
from datetime import datetime, timedelta
import calendar
import re
from tqdm import tqdm
import requests
from bs4 import BeautifulSoup
def get_uwyo_sounding(year, month, FROM, TO, stnm, save_csv = False ):
url = f'http://weather.uwyo.edu/cgi-bin/sounding?region=europe&T... | [
"datetime.datetime",
"re.split",
"datetime.datetime.strptime",
"requests.get",
"bs4.BeautifulSoup",
"calendar.monthrange",
"pandas.DataFrame",
"datetime.timedelta",
"pandas.concat"
] | [((465, 482), 'requests.get', 'requests.get', (['url'], {}), '(url)\n', (477, 482), False, 'import requests\n'), ((499, 538), 'bs4.BeautifulSoup', 'BeautifulSoup', (['uwyo.text', '"""html.parser"""'], {}), "(uwyo.text, 'html.parser')\n", (512, 538), False, 'from bs4 import BeautifulSoup\n'), ((1100, 1114), 'pandas.Data... |
#PLAYER MODULE
import pygame
import sys
import random
import math
import os
from pygame.locals import *
#these are RGB values (in that order)
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
BLUE = (0, 0, 204)
GREEN = (0, 204, 0)
RED = (255, 0, 0)
PURPLE = (204, 0, 204)
GOLD = (255, 215, 0)
class Player(p... | [
"pygame.sprite.spritecollide",
"pygame.Surface"
] | [((667, 691), 'pygame.Surface', 'pygame.Surface', (['[17, 17]'], {}), '([17, 17])\n', (681, 691), False, 'import pygame\n'), ((1365, 1412), 'pygame.sprite.spritecollide', 'pygame.sprite.spritecollide', (['self', 'coins', '(False)'], {}), '(self, coins, False)\n', (1392, 1412), False, 'import pygame\n'), ((1654, 1701), ... |
#
# Copyright (c) 2021 salesforce.com, inc.
# All rights reserved.
# SPDX-License-Identifier: BSD-3-Clause
# For full license text, see the LICENSE file in the repo root or https://opensource.org/licenses/BSD-3-Clause
#
import os
import sys
import csv
import ast
import logging
import pickle
import numpy as np
import pa... | [
"logging.getLogger",
"logging.StreamHandler",
"pickle.dump",
"numpy.asarray",
"ts_datasets.anomaly.smd.download",
"pickle.load",
"os.path.join",
"ast.literal_eval",
"os.path.abspath",
"numpy.zeros",
"pandas.DataFrame",
"csv.reader"
] | [((469, 496), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (486, 496), False, 'import logging\n'), ((540, 573), 'logging.StreamHandler', 'logging.StreamHandler', (['sys.stdout'], {}), '(sys.stdout)\n', (561, 573), False, 'import logging\n'), ((2680, 2698), 'numpy.asarray', 'np.asarray',... |
from hub import battery
# Returns:
# - temperature: The current temperature of the battery in degree Celsius.
# - charge_voltage: The voltage being used for charging.
# - charge_current: The current being used for charging.
# - charge_voltage_filtered: The battery voltage after filtering ... | [
"hub.battery.info"
] | [((523, 537), 'hub.battery.info', 'battery.info', ([], {}), '()\n', (535, 537), False, 'from hub import battery\n')] |
from flask import render_template
from . import main
@main.route('/')
def index():
'''
view root page function that returns the index page
'''
title = 'Home - Welcome to The Best Blog Site Worldwide You Think of It We help share It.'
return render_template('index.html',title = title)
| [
"flask.render_template"
] | [((261, 303), 'flask.render_template', 'render_template', (['"""index.html"""'], {'title': 'title'}), "('index.html', title=title)\n", (276, 303), False, 'from flask import render_template\n')] |
'''
Convert ENAMEX Named-Entity annotated file to Stanford NLP format (token-based)
@Author <EMAIL>
ENAMEX example (2 sentences):
Sementara itu Pengamat Pasar Modal <ENAMEX TYPE="PERSON"><NAME></ENAMEX> mengatakan, sulit bagi sebuah <ENAMEX TYPE="ORGANIZATION">kantor akuntan publik</ENAMEX> (<ENAMEX TYPE="ORGANIZATION... | [
"re.match",
"re.compile"
] | [((706, 740), 're.compile', 're.compile', (['"""^(.*?)<ENAMEX$"""', 're.I'], {}), "('^(.*?)<ENAMEX$', re.I)\n", (716, 740), False, 'import re\n'), ((763, 817), 're.compile', 're.compile', (['"""^TYPE="(.*?)">(.*?)</ENAMEX>(.*?)$"""', 're.I'], {}), '(\'^TYPE="(.*?)">(.*?)</ENAMEX>(.*?)$\', re.I)\n', (773, 817), False, '... |
import json
import requests
import os
import time
from enum import Enum
from config import Config as cfg
import mod_gamesense_logger as logger
class Mode(Enum):
COUNT = "count"
PERCENT = "percent"
COLOR = "color"
CONTEXTCOLOR = "context-color"
class JsonBase():
de... | [
"requests.post",
"os.getenv",
"json.dumps",
"os.path.join",
"time.sleep",
"mod_gamesense_logger.logDebug",
"os.path.isfile",
"json.load",
"mod_gamesense_logger.logTrace"
] | [((7727, 7812), 'mod_gamesense_logger.logDebug', 'logger.logDebug', (['"""bindGameEvent called. | event: """', 'event', '"""Response: """', 'response'], {}), "('bindGameEvent called. | event: ', event, 'Response: ',\n response)\n", (7742, 7812), True, 'import mod_gamesense_logger as logger\n'), ((8098, 8116), 'json.... |
import torch
from torch.utils.data import Dataset, DataLoader
import numpy as np
import glob
import matplotlib.pyplot as plt
from PIL import Image
class customDataset(Dataset):
def __init__(self, data, targets, transform=None):
self.data = data
self.targets = torch.Tensor(targets)
self.tran... | [
"torch.Tensor",
"numpy.array",
"torch.utils.data.DataLoader",
"numpy.load",
"glob.glob"
] | [((749, 773), 'numpy.array', 'np.array', (["data['images']"], {}), "(data['images'])\n", (757, 773), True, 'import numpy as np\n'), ((787, 811), 'numpy.array', 'np.array', (["data['labels']"], {}), "(data['labels'])\n", (795, 811), True, 'import numpy as np\n'), ((873, 923), 'glob.glob', 'glob.glob', (['"""../../../dat... |
import unittest
import parameterized
import numpy as np
from rlutil.envs.tabular_cy import q_iteration, tabular_env
from rlutil.envs.tabular import q_iteration as q_iteration_py
class QIterationTest(unittest.TestCase):
def setUp(self):
self.env = tabular_env.CliffwalkEnv(num_states=3, transition_noise=0.01)
... | [
"numpy.allclose",
"rlutil.envs.tabular_cy.q_iteration.softq_iteration",
"rlutil.envs.tabular_cy.tabular_env.CliffwalkEnv",
"rlutil.envs.tabular_cy.q_iteration.softq_evaluation",
"numpy.sum",
"numpy.zeros",
"rlutil.envs.tabular.q_iteration.softq_iteration",
"rlutil.envs.tabular.q_iteration.compute_visi... | [((2468, 2483), 'unittest.main', 'unittest.main', ([], {}), '()\n', (2481, 2483), False, 'import unittest\n'), ((256, 317), 'rlutil.envs.tabular_cy.tabular_env.CliffwalkEnv', 'tabular_env.CliffwalkEnv', ([], {'num_states': '(3)', 'transition_noise': '(0.01)'}), '(num_states=3, transition_noise=0.01)\n', (280, 317), Fal... |
"""
Module contains text tokenizers.
"""
from podium.utils.general_utils import load_spacy_model_or_raise
def get_tokenizer(tokenizer):
"""
Returns a tokenizer according to the parameters given.
Parameters
----------
tokenizer : str | callable
If a callable object is given, it will just ... | [
"podium.utils.general_utils.load_spacy_model_or_raise",
"sacremoses.MosesTokenizer",
"nltk.tokenize.toktok.ToktokTokenizer"
] | [((2402, 2464), 'podium.utils.general_utils.load_spacy_model_or_raise', 'load_spacy_model_or_raise', (['language'], {'disable': "['parser', 'ner']"}), "(language, disable=['parser', 'ner'])\n", (2427, 2464), False, 'from podium.utils.general_utils import load_spacy_model_or_raise\n'), ((2986, 3003), 'nltk.tokenize.tokt... |
import subprocess
import shutil
import os
import zipfile
import threading
print('Cleaning build directory')
shutil.rmtree('Builds', ignore_errors=True)
print('Starting build process')
UNITY = '"C:\\Program Files\\Unity\\Hub\\Editor\\2020.2.7f1\\Editor\\Unity.exe"'
subprocess.run(
f'{UNITY} -quit -projectPath -... | [
"os.path.join",
"os.getcwd",
"os.path.basename",
"shutil.rmtree",
"os.walk"
] | [((110, 153), 'shutil.rmtree', 'shutil.rmtree', (['"""Builds"""'], {'ignore_errors': '(True)'}), "('Builds', ignore_errors=True)\n", (123, 153), False, 'import shutil\n'), ((533, 546), 'os.walk', 'os.walk', (['path'], {}), '(path)\n', (540, 546), False, 'import os\n'), ((331, 342), 'os.getcwd', 'os.getcwd', ([], {}), '... |
import numpy as np
import cv2
# Load an color image in grayscale
img = cv2.imread('/home/pankaj/Downloads/home.jpg',0)
WINDOW_NAME = 'Image'
cv2.namedWindow(WINDOW_NAME)
cv2.startWindowThread()
# Display an image
cv2.imshow(WINDOW_NAME,img)
cv2.waitKey(0)
cv2.destroyWindow(WINDOW_NAME)
| [
"cv2.destroyWindow",
"cv2.imshow",
"cv2.startWindowThread",
"cv2.waitKey",
"cv2.namedWindow",
"cv2.imread"
] | [((72, 120), 'cv2.imread', 'cv2.imread', (['"""/home/pankaj/Downloads/home.jpg"""', '(0)'], {}), "('/home/pankaj/Downloads/home.jpg', 0)\n", (82, 120), False, 'import cv2\n'), ((142, 170), 'cv2.namedWindow', 'cv2.namedWindow', (['WINDOW_NAME'], {}), '(WINDOW_NAME)\n', (157, 170), False, 'import cv2\n'), ((171, 194), 'c... |
import unittest
import unittest.mock as mock
import os
from strategies.balance import Balance
from strategies.balance import Analysis
from strategies.trader import Trader
from strategies.analyser import Analyser
from strategies.reporter import Reporter
from strategies.helper import Helper
from database.database import ... | [
"strategies.balance.Balance",
"unittest.mock.Mock",
"strategies.trader.Trader.fill_fetch_order",
"unittest.mock.create_autospec",
"strategies.helper.Helper.round_down",
"strategies.balance.Analysis",
"os.path.realpath",
"database.models.trade.Trade",
"unittest.mock.patch"
] | [((3982, 4053), 'unittest.mock.patch', 'mock.patch', (['"""strategies.analyser.Analyser.is_filled"""'], {'return_value': '(True)'}), "('strategies.analyser.Analyser.is_filled', return_value=True)\n", (3992, 4053), True, 'import unittest.mock as mock\n'), ((4710, 4782), 'unittest.mock.patch', 'mock.patch', (['"""strateg... |
import dateutil.parser
import datetime
import urllib.request
#Spaltennamen:
IdBundesland = 0
Bundesland = 1
Landkreis = 2
Altersgruppe = 3
Geschlecht = 4
AnzahlFall = 5
AnzahlTodesfall = 6
ObjectId = 7
Meldedatum = 8
LandkreisID = 9
print("Lade neue Tabelle herunter...")
try:
urllib.request.urlretrieve("https://o... | [
"datetime.timedelta"
] | [((1696, 1722), 'datetime.timedelta', 'datetime.timedelta', ([], {'days': '(1)'}), '(days=1)\n', (1714, 1722), False, 'import datetime\n')] |
# Copyright 2014 Cloudera Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing... | [
"llvm.core.Type.int",
"numba.cgutils.alloca_once",
"numba.types.CPointer",
"pkgutil.get_data"
] | [((853, 908), 'pkgutil.get_data', 'pkgutil.get_data', (['"""impala.udf"""', '"""precompiled/impyla.bc"""'], {}), "('impala.udf', 'precompiled/impyla.bc')\n", (869, 908), False, 'import pkgutil\n'), ((3130, 3174), 'numba.cgutils.alloca_once', 'cgutils.alloca_once', (['builder', 'numba_arg.type'], {}), '(builder, numba_a... |
#!/usr/bin/env python3.6
# Collect image and proximity data from Vector.
import anki_vector
import logging
import pickle
import random
import sqlite3
import sys
import time
import traceback
SCHEMA = r"""CREATE TABLE IF NOT EXISTS vector_data (
id INTEGER PRIMARY KEY AUTOINCREMENT,
timestamp TIMEST... | [
"logging.basicConfig",
"logging.getLogger",
"traceback.format_exc",
"logging.StreamHandler",
"sqlite3.connect",
"time.strftime",
"time.sleep",
"anki_vector.Robot",
"sys.exit",
"random.random",
"logging.info"
] | [((472, 500), 'sqlite3.connect', 'sqlite3.connect', (['"""vector.db"""'], {}), "('vector.db')\n", (487, 500), False, 'import sqlite3\n'), ((1767, 1803), 'logging.info', 'logging.info', (['"""connecting to vector"""'], {}), "('connecting to vector')\n", (1779, 1803), False, 'import logging\n'), ((1980, 1997), 'time.slee... |
#!/usr/bin/env python3
import os
import json
import base64
import lzma
import black
import dis
from flask import (
Flask,
render_template,
request,
send_from_directory,
render_template_string,
redirect,
url_for,
)
app = Flask(__name__)
def compress_state(data):
compressed = lzma.comp... | [
"flask.render_template",
"flask.request.args.get",
"black.format_str",
"base64.urlsafe_b64decode",
"flask.Flask",
"base64.urlsafe_b64encode",
"json.dumps",
"os.path.join",
"dis.code_info",
"flask.request.form.get",
"black.FileMode.from_configuration",
"flask.url_for",
"lzma.decompress",
"d... | [((250, 265), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (255, 265), False, 'from flask import Flask, render_template, request, send_from_directory, render_template_string, redirect, url_for\n'), ((471, 502), 'base64.urlsafe_b64decode', 'base64.urlsafe_b64decode', (['state'], {}), '(state)\n', (495, 50... |
import json,urllib.request, csv, pandas, time, argparse
parser = argparse.ArgumentParser()
parser.add_argument('-i', dest='website')
parser.add_argument('-o', dest='output_directory')
parser.add_argument('-a', dest='api_key')
parser.add_argument('-d', dest='directory')
# Primary Variables
args = parser.parse_args()
... | [
"time.sleep",
"pandas.read_json",
"argparse.ArgumentParser"
] | [((66, 91), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (89, 91), False, 'import json, urllib.request, csv, pandas, time, argparse\n'), ((795, 817), 'pandas.read_json', 'pandas.read_json', (['data'], {}), '(data)\n', (811, 817), False, 'import json, urllib.request, csv, pandas, time, argpars... |
# 5 Using concurrent future threading in python
# Import Threading & Time
import concurrent.futures
import time
# Start counting
start = time.perf_counter()
# Create simple function that sleep in 'seconds' time
def do_something(seconds):
print(f'Sleeping {seconds} second(s)..')
time.sleep(seconds)
retur... | [
"time.perf_counter",
"time.sleep"
] | [((139, 158), 'time.perf_counter', 'time.perf_counter', ([], {}), '()\n', (156, 158), False, 'import time\n'), ((588, 607), 'time.perf_counter', 'time.perf_counter', ([], {}), '()\n', (605, 607), False, 'import time\n'), ((291, 310), 'time.sleep', 'time.sleep', (['seconds'], {}), '(seconds)\n', (301, 310), False, 'impo... |
#!/usr/bin/python
import os
PARENT_PATH = os.path.abspath(os.path.dirname(__file__))
# Make every directory within this directory a sub-package of this package
__all__ = [x for x in os.listdir(PARENT_PATH) if
os.path.isdir(os.path.join(PARENT_PATH, x))]
| [
"os.path.dirname",
"os.listdir",
"os.path.join"
] | [((60, 85), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (75, 85), False, 'import os\n'), ((185, 208), 'os.listdir', 'os.listdir', (['PARENT_PATH'], {}), '(PARENT_PATH)\n', (195, 208), False, 'import os\n'), ((237, 265), 'os.path.join', 'os.path.join', (['PARENT_PATH', 'x'], {}), '(PARENT_P... |
from __future__ import absolute_import
from __future__ import unicode_literals
import datetime
from corehq.apps.locations.models import SQLLocation
from corehq.apps.reports.filters.base import BaseSingleOptionFilter, BaseDrilldownOptionFilter
from custom.pnlppgi.utils import users_locations
from memoized import memoiz... | [
"custom.pnlppgi.utils.users_locations",
"six.moves.range",
"corehq.apps.locations.models.SQLLocation.objects.filter",
"datetime.datetime.utcnow"
] | [((1116, 1133), 'custom.pnlppgi.utils.users_locations', 'users_locations', ([], {}), '()\n', (1131, 1133), False, 'from custom.pnlppgi.utils import users_locations\n'), ((644, 656), 'six.moves.range', 'range', (['(1)', '(53)'], {}), '(1, 53)\n', (649, 656), False, 'from six.moves import range\n'), ((1154, 1251), 'coreh... |
'''
Created on Jun 9, 2014
@author: dbhage
English Celex Test Class
'''
import unittest
from celex.phonology.english_celex import EnglishCelex
from test import TEST_CELEX_PATH
class EnglishCelexTest(unittest.TestCase):
def setUp(self):
'''
Set values for tests.
'''
self.expec... | [
"unittest.main",
"celex.phonology.english_celex.EnglishCelex"
] | [((24326, 24341), 'unittest.main', 'unittest.main', ([], {}), '()\n', (24339, 24341), False, 'import unittest\n'), ((19110, 19124), 'celex.phonology.english_celex.EnglishCelex', 'EnglishCelex', ([], {}), '()\n', (19122, 19124), False, 'from celex.phonology.english_celex import EnglishCelex\n')] |
import json
import matplotlib.pyplot as plt
import numpy as np
from mpl_toolkits.mplot3d import Axes3D
from tqdm import tqdm_notebook
def load_data(file):
"""Загрузка входных данных из файла"""
with open(file, 'r') as f:
input_data = json.load(f)
couriers = {}
orders = {}
points = {}
fo... | [
"json.load",
"json.dumps",
"tqdm.tqdm_notebook",
"json.dump"
] | [((3136, 3174), 'tqdm.tqdm_notebook', 'tqdm_notebook', (['couriers_start_position'], {}), '(couriers_start_position)\n', (3149, 3174), False, 'from tqdm import tqdm_notebook\n'), ((6620, 6643), 'json.dumps', 'json.dumps', (['routes_dict'], {}), '(routes_dict)\n', (6630, 6643), False, 'import json\n'), ((251, 263), 'jso... |
from rest_framework import status
from test_utils import serialized_time
def test_delete_profile_topic(
api_client, enable_premium_requirement, profile_topic_factory, user_factory
):
"""
Premium users should be able to delete their own profile topics.
"""
password = "password"
user = user_fac... | [
"test_utils.serialized_time"
] | [((1322, 1355), 'test_utils.serialized_time', 'serialized_time', (['topic.created_at'], {}), '(topic.created_at)\n', (1337, 1355), False, 'from test_utils import serialized_time\n'), ((1379, 1412), 'test_utils.serialized_time', 'serialized_time', (['topic.updated_at'], {}), '(topic.updated_at)\n', (1394, 1412), False, ... |
from django.test import TestCase
from django.template import Template, Context
class TemplateTagTest(TestCase):
def setUp(self):
pass
def test_tag(self):
content = (
"{% load logical_rules_tags %}"
"This is a {% testrule test_is_pizza 'pizza' %}test{% e... | [
"django.template.Template",
"django.template.Context"
] | [((517, 528), 'django.template.Context', 'Context', (['{}'], {}), '({})\n', (524, 528), False, 'from django.template import Template, Context\n'), ((492, 509), 'django.template.Template', 'Template', (['content'], {}), '(content)\n', (500, 509), False, 'from django.template import Template, Context\n')] |
import unittest
from mycode import *
class MyFirstTests(unittest.TestCase):
def test_hello(self):
self.assertEqual(hello_world(), 'hello_world')
def test_custom_num_list(self):
self.assertEqual(len(create_num_list(10)), 10)
def test_custom_func_x(self):
self.assertEqual(custom_func_x(3, 2, 3), 54)... | [
"unittest.main"
] | [((518, 533), 'unittest.main', 'unittest.main', ([], {}), '()\n', (531, 533), False, 'import unittest\n')] |
# -*- coding: UTF-8 -*-
import numpy as np
import pandas as pd
import itertools
import csv
import gensim
import re
import nltk.data
import tensorflow
from nltk.tokenize import WordPunctTokenizer
from collections import Counter
from keras.models import Sequential, Graph
from keras.layers.core import Dense, Dropout, Acti... | [
"itertools.chain",
"keras.layers.core.Flatten",
"keras.layers.Merge",
"keras.layers.core.Activation",
"pandas.read_csv",
"keras.models.Graph",
"nltk.tokenize.WordPunctTokenizer",
"gensim.models.Word2Vec.load",
"keras.models.Sequential",
"keras.utils.visualize_util.to_graph",
"numpy.array",
"ke... | [((6080, 6097), 'numpy.random.seed', 'np.random.seed', (['(2)'], {}), '(2)\n', (6094, 6097), True, 'import numpy as np\n'), ((7765, 7772), 'keras.models.Graph', 'Graph', ([], {}), '()\n', (7770, 7772), False, 'from keras.models import Sequential, Graph\n'), ((8664, 8676), 'keras.models.Sequential', 'Sequential', ([], {... |
import discord
from discord.ext import commands
import os
class GetMembersProjects(commands.Cog):
def __init__(self, bot):
self.bot = bot
@commands.command(pass_context=True, name='listaCzlonkow')
async def get_members_projects(self, ctx):
"""
Gets actual list of members and send... | [
"discord.ext.commands.command",
"discord.File",
"os.remove"
] | [((159, 216), 'discord.ext.commands.command', 'commands.command', ([], {'pass_context': '(True)', 'name': '"""listaCzlonkow"""'}), "(pass_context=True, name='listaCzlonkow')\n", (175, 216), False, 'from discord.ext import commands\n'), ((1845, 1875), 'os.remove', 'os.remove', (['"""listaCzlonkow.txt"""'], {}), "('lista... |
import os
import torch
import numpy as np
from mpi_utils.mpi_utils import sync_networks
from rl_modules.buffer import ReplayBuffer
from networks import LanguageCritic, LanguageActor
from mpi_utils.normalizer import Normalizer
from her_modules.her import HerSampler
from updates import update_language
from utils import h... | [
"numpy.clip",
"rl_modules.buffer.ReplayBuffer",
"utils.available_device",
"os.path.islink",
"utils.soft_update",
"os.readlink",
"mpi_utils.mpi_utils.sync_networks",
"numpy.asarray",
"networks.LanguageCritic",
"utils.hard_update",
"networks.LanguageActor",
"torch.Tensor",
"her_modules.her.Her... | [((2412, 2427), 'torch.no_grad', 'torch.no_grad', ([], {}), '()\n', (2425, 2427), False, 'import torch\n'), ((702, 732), 'networks.LanguageActor', 'LanguageActor', (['cfg', 'env_params'], {}), '(cfg, env_params)\n', (715, 732), False, 'from networks import LanguageCritic, LanguageActor\n'), ((763, 794), 'networks.Langu... |
import unittest
from src.statistics import *
from src.exampleData import Data
class StatisticsParameterizedFile(unittest.TestCase):
def test_average_subject_from_file(self):
fileTest = open("data/test_statistics_subject.txt")
tmp = Statistics(Data().example)
for line in fileTest:
... | [
"unittest.main",
"src.exampleData.Data"
] | [((2495, 2510), 'unittest.main', 'unittest.main', ([], {}), '()\n', (2508, 2510), False, 'import unittest\n'), ((265, 271), 'src.exampleData.Data', 'Data', ([], {}), '()\n', (269, 271), False, 'from src.exampleData import Data\n'), ((847, 853), 'src.exampleData.Data', 'Data', ([], {}), '()\n', (851, 853), False, 'from ... |
## coding=utf-8
from sqlalchemy import create_engine
from sqlalchemy.orm import scoped_session, sessionmaker
from sqlalchemy.ext.declarative import declarative_base
import json
"""
Ce script se permet d'établir une connexion à la base de données.
Il est utilisé les infos de connexion enregistré dans ... | [
"sqlalchemy.orm.sessionmaker",
"json.load",
"sqlalchemy.create_engine",
"sqlalchemy.ext.declarative.declarative_base"
] | [((794, 848), 'sqlalchemy.create_engine', 'create_engine', (['db_info_connect'], {'echo': '(True)', 'future': '(True)'}), '(db_info_connect, echo=True, future=True)\n', (807, 848), False, 'from sqlalchemy import create_engine\n'), ((862, 922), 'sqlalchemy.orm.sessionmaker', 'sessionmaker', ([], {'autocommit': '(False)'... |
# -*- coding: utf-8 -*-
# Define your item pipelines here
#
# Don't forget to add your pipeline to the ITEM_PIPELINES setting
# See: http://doc.scrapy.org/en/latest/topics/item-pipeline.html
import pymysql
from scrapy import signals
from scrapy.contrib.exporter import XmlItemExporter
class ArticlePipeline(object):... | [
"pymysql.connect"
] | [((368, 494), 'pymysql.connect', 'pymysql.connect', ([], {'host': '"""localhost"""', 'user': '"""root"""', 'password': '"""<PASSWORD>"""', 'db': '"""papermedia"""', 'use_unicode': '(False)', 'charset': '"""utf8"""'}), "(host='localhost', user='root', password='<PASSWORD>', db=\n 'papermedia', use_unicode=False, char... |
from mdMarkov import gen_msg
from brainInfo import sentences_per_request, keyword_retry
try:
from localDB import chat
except ImportError:
from emptyLocalDB import chat
def generate(data):
"""
data = {
'chat_id': chat_id,
'user_id': user_id,
'keyword': keyword,
}
"""
... | [
"mdMarkov.gen_msg"
] | [((931, 947), 'mdMarkov.gen_msg', 'gen_msg', (['chat_id'], {}), '(chat_id)\n', (938, 947), False, 'from mdMarkov import gen_msg\n'), ((688, 704), 'mdMarkov.gen_msg', 'gen_msg', (['chat_id'], {}), '(chat_id)\n', (695, 704), False, 'from mdMarkov import gen_msg\n'), ((1057, 1073), 'mdMarkov.gen_msg', 'gen_msg', (['chat_i... |
import discord
from discord.ext import commands
from bot import Bot, CustomContext
from utils.errors import ProcessError
import pathlib
import inspect
from utils.constants import General
import typing
import importlib
class Limit(commands.Converter):
def __init__(self, char_limit: int = None):
self.char_l... | [
"inspect.getsourcelines",
"utils.errors.ProcessError",
"inspect.getmembers",
"pathlib.Path",
"inspect.unwrap"
] | [((866, 932), 'utils.errors.ProcessError', 'ProcessError', (['"""Time must have one time extension: (s, m, h, d, w)"""'], {}), "('Time must have one time extension: (s, m, h, d, w)')\n", (878, 932), False, 'from utils.errors import ProcessError\n'), ((1651, 1707), 'utils.errors.ProcessError', 'ProcessError', (['"""Your... |
# -*- coding: utf-8 -*-
def main():
from datetime import datetime
from datetime import timedelta
ymd = input()
fmt = '%Y/%m/%d'
current_date = datetime.strptime(ymd, fmt)
# See:
# https://atcoder.jp/contests/arc002/submissions/4809566
while True:
year = current_... | [
"datetime.datetime.strptime",
"datetime.timedelta",
"datetime.datetime.strftime"
] | [((175, 202), 'datetime.datetime.strptime', 'datetime.strptime', (['ymd', 'fmt'], {}), '(ymd, fmt)\n', (192, 202), False, 'from datetime import datetime\n'), ((419, 455), 'datetime.datetime.strftime', 'datetime.strftime', (['current_date', 'fmt'], {}), '(current_date, fmt)\n', (436, 455), False, 'from datetime import d... |
import adafruit_max31865
import busio
import digitalio
from titration.utils import constants
class Temperature_Probe:
def __init__(self, sck, mosi, miso, cs, wires=2):
self.spi = busio.SPI(sck, MOSI=mosi, MISO=miso)
self.cs = digitalio.DigitalInOut(cs)
self.sensor = adafruit_max31865.MAX3... | [
"busio.SPI",
"digitalio.DigitalInOut",
"adafruit_max31865.MAX31865"
] | [((194, 230), 'busio.SPI', 'busio.SPI', (['sck'], {'MOSI': 'mosi', 'MISO': 'miso'}), '(sck, MOSI=mosi, MISO=miso)\n', (203, 230), False, 'import busio\n'), ((249, 275), 'digitalio.DigitalInOut', 'digitalio.DigitalInOut', (['cs'], {}), '(cs)\n', (271, 275), False, 'import digitalio\n'), ((298, 471), 'adafruit_max31865.M... |
# To import required modules:
import numpy as np
import time
import os
import sys
import matplotlib
import matplotlib.cm as cm #for color maps
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec #for specifying plot attributes
from matplotlib import ticker #for setting contour plots to log scale
im... | [
"numpy.log10",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.fill_between",
"numpy.array",
"matplotlib.ticker.ScalarFormatter",
"numpy.genfromtxt",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.axhline",
"matplotlib.pyplot.close",
"matplotlib.gridspec.GridSpec",
"ma... | [((2221, 2297), 'numpy.genfromtxt', 'np.genfromtxt', (['"""../../data/MR_earthlike_rocky.txt"""'], {'names': "['mass', 'radius']"}), "('../../data/MR_earthlike_rocky.txt', names=['mass', 'radius'])\n", (2234, 2297), True, 'import numpy as np\n'), ((2349, 2419), 'numpy.genfromtxt', 'np.genfromtxt', (['"""../../data/MR_p... |
import cv2 as cv
import numpy as np
img = cv.imread("D:/Programming/Python_Projects/Computer_Vision/Resources/Image/park.jfif")
cv.imshow('Park', img)
blank = np.zeros(img.shape[:2], dtype='uint8')
# cv.imshow('Blank Image', blank)
circle = cv.circle(blank.copy(), (img.shape[1]//2 + 45,img.shape[0]//2), 100... | [
"cv2.bitwise_and",
"cv2.imshow",
"numpy.zeros",
"cv2.waitKey",
"cv2.bitwise_or",
"cv2.imread"
] | [((46, 136), 'cv2.imread', 'cv.imread', (['"""D:/Programming/Python_Projects/Computer_Vision/Resources/Image/park.jfif"""'], {}), "(\n 'D:/Programming/Python_Projects/Computer_Vision/Resources/Image/park.jfif')\n", (55, 136), True, 'import cv2 as cv\n'), ((133, 155), 'cv2.imshow', 'cv.imshow', (['"""Park"""', 'img']... |
import argparse
import yaml
from dotmap import DotMap
from os import path
import numpy as np
import torch
from torch.utils.data import DataLoader
import pytorch_lightning as pl
from pytorch_lightning.callbacks import ModelCheckpoint, EarlyStopping
from pytorch_lightning.loggers import TensorBoardLogger
from pytorch_lig... | [
"argparse.ArgumentParser",
"pytorch_lightning.plugins.DDPPlugin",
"models.naml.NAML.load_from_checkpoint",
"pytorch_lightning.seed_everything",
"dotmap.DotMap",
"models.lstur.LSTUR.load_from_checkpoint",
"os.path.join",
"yaml.load",
"models.nrms.NRMS.load_from_checkpoint",
"models.sentirec.SENTIRE... | [((684, 709), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (707, 709), False, 'import argparse\n'), ((1261, 1285), 'pytorch_lightning.seed_everything', 'pl.seed_everything', (['(1234)'], {}), '(1234)\n', (1279, 1285), True, 'import pytorch_lightning as pl\n'), ((1356, 1390), 'pytorch_lightnin... |
#!/usr/bin/env python3
import os
import csv
from itertools import dropwhile, takewhile
import re
# https://pricing.us-east-1.amazonaws.com/offers/v1.0/aws/index.json
# /offers/v1.0/aws/AmazonEC2/current/index.json
# /offers/v1.0/aws/AmazonEC2/current/region_index.json
# /offers/v1.0/aws/AmazonEC2/20190612230233/ap-sou... | [
"os.system",
"csv.DictReader",
"itertools.dropwhile",
"re.match"
] | [((981, 995), 'os.system', 'os.system', (['cmd'], {}), '(cmd)\n', (990, 995), False, 'import os\n'), ((1070, 1093), 'csv.DictReader', 'csv.DictReader', (['csvfile'], {}), '(csvfile)\n', (1084, 1093), False, 'import csv\n'), ((5847, 5873), 'itertools.dropwhile', 'dropwhile', (['is_x', 'ec2TypeHs'], {}), '(is_x, ec2TypeH... |
# Generated by Django 2.2.24 on 2021-11-01 03:46
from django.db import migrations, models
class Migration(migrations.Migration):
initial = True
dependencies = []
operations = [
migrations.CreateModel(
name="TaskflowExecutedNodeStatistics",
fields=[
("id"... | [
"django.db.models.TextField",
"django.db.models.IntegerField",
"django.db.models.BooleanField",
"django.db.models.BigIntegerField",
"django.db.models.BigAutoField",
"django.db.models.DateTimeField",
"django.db.models.CharField"
] | [((322, 395), 'django.db.models.BigAutoField', 'models.BigAutoField', ([], {'primary_key': '(True)', 'serialize': '(False)', 'verbose_name': '"""id"""'}), "(primary_key=True, serialize=False, verbose_name='id')\n", (341, 395), False, 'from django.db import migrations, models\n'), ((433, 501), 'django.db.models.CharFiel... |
#!/usr/bin/env python
#
# A library that provides a Python interface to the Telegram Bot API
# Copyright (C) 2015-2017
# <NAME> <<EMAIL>>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser Public License as published by
# the Free Software Foundation, either ... | [
"re.sub"
] | [((1095, 1143), 're.sub', 're.sub', (["('([%s])' % escape_chars)", '"""\\\\\\\\\\\\1"""', 'text'], {}), "('([%s])' % escape_chars, '\\\\\\\\\\\\1', text)\n", (1101, 1143), False, 'import re\n')] |
# -*- coding:utf-8 -*-
from django.contrib import admin
from .models import News
# admin.site.register(News)
class NewsAdmin(admin.ModelAdmin):
list_display = ('title',)
admin.site.register(News, NewsAdmin) | [
"django.contrib.admin.site.register"
] | [((179, 215), 'django.contrib.admin.site.register', 'admin.site.register', (['News', 'NewsAdmin'], {}), '(News, NewsAdmin)\n', (198, 215), False, 'from django.contrib import admin\n')] |
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT license.
"""
tf2onnx.schema
"""
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
from collections import defaultdict, OrderedDict
from onnx import defs
from . import cons... | [
"onnx.defs.get_all_schemas_with_history",
"collections.defaultdict"
] | [((1619, 1654), 'onnx.defs.get_all_schemas_with_history', 'defs.get_all_schemas_with_history', ([], {}), '()\n', (1652, 1654), False, 'from onnx import defs\n'), ((1712, 1729), 'collections.defaultdict', 'defaultdict', (['dict'], {}), '(dict)\n', (1723, 1729), False, 'from collections import defaultdict, OrderedDict\n'... |
###################################################################################
#
# Copyright (c) 2017-2019 MuK IT GmbH.
#
# This file is part of MuK Security
# (see https://mukit.at).
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser Gen... | [
"logging.getLogger",
"odoo.tools.ormcache_context"
] | [((1173, 1200), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1190, 1200), False, 'import logging\n'), ((1300, 1391), 'odoo.tools.ormcache_context', 'tools.ormcache_context', (['"""self._uid"""', '"""model"""', '"""mode"""', '"""raise_exception"""'], {'keys': "('lang',)"}), "('self._uid... |
from cartoframes.viz import popup_element
from cartoframes.viz.popup import Popup
from cartoframes.viz.popup_list import PopupList
popup_list = PopupList({
'click': [popup_element('value_1'), popup_element('value_2')],
'hover': [popup_element('value_1'), popup_element('value_3')]
})
class TestPopupList(object):
... | [
"cartoframes.viz.popup_element"
] | [((169, 193), 'cartoframes.viz.popup_element', 'popup_element', (['"""value_1"""'], {}), "('value_1')\n", (182, 193), False, 'from cartoframes.viz import popup_element\n'), ((195, 219), 'cartoframes.viz.popup_element', 'popup_element', (['"""value_2"""'], {}), "('value_2')\n", (208, 219), False, 'from cartoframes.viz i... |
import pygame
import UI
#setup pygame
pygame.init()
screen = UI.Window(500,500) #creates a window 500x500
#this function will run when button1 is clicked
def button_clicked(btn):
print("button clicked")
#create our textBoxes and Buttons
InputBox = UI.TextBox(
x = 100,
y = 100,
w = 300,
h = 30,
... | [
"pygame.init",
"UI.TextBox",
"pygame.Surface",
"pygame.event.get",
"pygame.quit",
"UI.Button",
"UI.Window",
"UI.CheckBox",
"UI.curve_square",
"pygame.display.update"
] | [((40, 53), 'pygame.init', 'pygame.init', ([], {}), '()\n', (51, 53), False, 'import pygame\n'), ((63, 82), 'UI.Window', 'UI.Window', (['(500)', '(500)'], {}), '(500, 500)\n', (72, 82), False, 'import UI\n'), ((256, 373), 'UI.TextBox', 'UI.TextBox', ([], {'x': '(100)', 'y': '(100)', 'w': '(300)', 'h': '(30)', 'param_op... |
# pylint: disable=E0401,C0411
import os
from os.path import expanduser
import re
from ..base import Base
from ...kind.npm import Kind as BaseKind
splitRe = re.compile(r"\s+")
def _find_root(path):
while True:
if path == '/' or os.path.ismount(path):
return None
p = os.path.join(path, '... | [
"re.compile",
"os.path.ismount",
"os.access",
"os.path.join",
"os.path.dirname",
"os.path.expanduser"
] | [((157, 175), 're.compile', 're.compile', (['"""\\\\s+"""'], {}), "('\\\\s+')\n", (167, 175), False, 'import re\n'), ((300, 334), 'os.path.join', 'os.path.join', (['path', '"""package.json"""'], {}), "(path, 'package.json')\n", (312, 334), False, 'import os\n'), ((346, 367), 'os.access', 'os.access', (['p', 'os.R_OK'],... |
import numpy as np
import math
from numpy import *
import copy
from MST_Direction import *
def CalM(CtgDirection,DFlag,weight_mat):
M = 0
D = 1
ContigCount = len(CtgDirection)
for n1 in range(ContigCount-1):
for n2 in range(n1,ContigCount):
if DFlag[n1][n2]!=0:
D +=weight_mat[n1][n2]
M +... | [
"numpy.abs",
"numpy.ones",
"numpy.argmax",
"numpy.diag",
"numpy.array",
"numpy.dot",
"numpy.zeros",
"numpy.sign",
"copy.deepcopy"
] | [((495, 516), 'numpy.zeros', 'np.zeros', (['ContigCount'], {}), '(ContigCount)\n', (503, 516), True, 'import numpy as np\n'), ((524, 544), 'numpy.ones', 'np.ones', (['ContigCount'], {}), '(ContigCount)\n', (531, 544), True, 'import numpy as np\n'), ((1096, 1118), 'numpy.array', 'np.array', (['CtgDirection'], {}), '(Ctg... |
"""
Self-serve Discord roles for users.
Dependencies:
:class:`.DiscordPlug`
Config:
roles ((str, int) dict):
Mapping from user-facing role names to Discord role IDs.
Commands:
role <name>:
Claim a role of this name.
unrole <name>:
Drop the role of this name.
"""
import immp
f... | [
"immp.hook.command.command",
"immp.Schema",
"immp.Message"
] | [((600, 634), 'immp.Schema', 'immp.Schema', (["{'roles': {str: int}}"], {}), "({'roles': {str: int}})\n", (611, 634), False, 'import immp\n'), ((1180, 1283), 'immp.hook.command.command', 'command', (['"""role"""'], {'scope': 'CommandScope.shared', 'parser': 'CommandParser.none', 'test': '_test', 'sync_aware': '(True)'}... |
import cv2
img = cv2.imread("face.jpg")
cv2.imshow("ORIGINAL",img)
scl_img = cv2.resize(img,None , fx = 1 ,fy = 1/2)
cv2.imshow("SCALED",scl_img)
cv2.waitKey(0)
cv2.destroyAllWindows()
| [
"cv2.imshow",
"cv2.destroyAllWindows",
"cv2.resize",
"cv2.waitKey",
"cv2.imread"
] | [((18, 40), 'cv2.imread', 'cv2.imread', (['"""face.jpg"""'], {}), "('face.jpg')\n", (28, 40), False, 'import cv2\n'), ((42, 69), 'cv2.imshow', 'cv2.imshow', (['"""ORIGINAL"""', 'img'], {}), "('ORIGINAL', img)\n", (52, 69), False, 'import cv2\n'), ((80, 117), 'cv2.resize', 'cv2.resize', (['img', 'None'], {'fx': '(1)', '... |
import torch
from e2cnn import gspaces
from e2cnn import nn
from networks.sac_net import SACGaussianPolicyBase
LOG_SIG_MAX = 2
LOG_SIG_MIN = -20
epsilon = 1e-6
class EquivariantEncoder128(torch.nn.Module):
"""
Equivariant Encoder. The input is a trivial representation with obs_channel channels.
The outp... | [
"e2cnn.gspaces.Rot2dOnR2",
"torch.clamp",
"torch.cat",
"e2cnn.nn.FieldType"
] | [((539, 559), 'e2cnn.gspaces.Rot2dOnR2', 'gspaces.Rot2dOnR2', (['N'], {}), '(N)\n', (556, 559), False, 'from e2cnn import gspaces\n'), ((4180, 4200), 'e2cnn.gspaces.Rot2dOnR2', 'gspaces.Rot2dOnR2', (['N'], {}), '(N)\n', (4197, 4200), False, 'from e2cnn import gspaces\n'), ((6520, 6563), 'torch.cat', 'torch.cat', (['(ac... |
#Создайте игру, в которой компьютер выбирает какое-либо слово, а игрок должен его отгадать.
#Компьютер сообщает игроку, сколько букв в слове, и дает пять попыток узнать,
#есть ли какая-либо буква в слове, причем программа может отвечать только "Да" и "Нет".
#Вслед за тем игрок должен попробовать отгадать слово.
# <... | [
"random.choice",
"random.randrange"
] | [((444, 464), 'random.choice', 'random.choice', (['slova'], {}), '(slova)\n', (457, 464), False, 'import random\n'), ((510, 534), 'random.randrange', 'random.randrange', (['chislo'], {}), '(chislo)\n', (526, 534), False, 'import random\n')] |
from input import parameters as para
from lib.glob import *
import h5py as hp
def writeSoln_RBC(Vx, Vy, Vz, Press, Temp, time, dtchange):
if para.Target=="GPU": Vx, Vy, Vz, Press, Temp = Vx.get(), Vy.get(), Vz.get(), Press.get(), Temp.get()
timewr = time
if (dtchange==1 or para.restart) and para.Targe... | [
"h5py.File"
] | [((472, 491), 'h5py.File', 'hp.File', (['fName', '"""w"""'], {}), "(fName, 'w')\n", (479, 491), True, 'import h5py as hp\n'), ((1171, 1190), 'h5py.File', 'hp.File', (['fName', '"""w"""'], {}), "(fName, 'w')\n", (1178, 1190), True, 'import h5py as hp\n'), ((1916, 1935), 'h5py.File', 'hp.File', (['fName', '"""w"""'], {})... |
# Data loading based on https://github.com/NVIDIA/flownet2-pytorch
from ast import NotEq
import numpy as np
import torch
import torch.utils.data as data
from torch.utils.data import DistributedSampler
import torch.nn.functional as F
import os
import math
import random
from glob import glob
import os.path as osp
impor... | [
"torch.utils.data.DistributedSampler",
"utils.augmentor.FlowAugmentor",
"torch.from_numpy",
"utils.frame_utils.read_gen",
"numpy.array",
"utils.utils.print0",
"os.listdir",
"numpy.random.seed",
"utils.augmentor.SparseFlowAugmentor",
"numpy.tile",
"sklearn.model_selection.train_test_split",
"to... | [((26076, 26247), 'torch.utils.data.DataLoader', 'data.DataLoader', (['train_dataset'], {'batch_size': 'args.batch_size', 'sampler': 'train_sampler', 'pin_memory': '(True)', 'shuffle': 'shuffle', 'num_workers': 'args.num_workers', 'drop_last': '(True)'}), '(train_dataset, batch_size=args.batch_size, sampler=\n train... |
import json
import matplotlib.pyplot as plt
from imantics import Dataset
if __name__ == '__main__':
with open('composition_dataset_2/train/annotations/annotations.json') as f:
data = json.load(f)
dataset = Dataset.from_coco(data)
for image in dataset.iter_images():
draw = image.draw(bbox=T... | [
"json.load",
"matplotlib.pyplot.imshow",
"imantics.Dataset.from_coco",
"matplotlib.pyplot.show"
] | [((224, 247), 'imantics.Dataset.from_coco', 'Dataset.from_coco', (['data'], {}), '(data)\n', (241, 247), False, 'from imantics import Dataset\n'), ((196, 208), 'json.load', 'json.load', (['f'], {}), '(f)\n', (205, 208), False, 'import json\n'), ((333, 349), 'matplotlib.pyplot.imshow', 'plt.imshow', (['draw'], {}), '(dr... |
import pandas as pd
from sklearn import preprocessing
from sklearn.feature_extraction.text import ENGLISH_STOP_WORDS
from sklearn.feature_extraction.text import TfidfVectorizer
import os
from sklearn.decomposition import TruncatedSVD
from sklearn.metrics import f1_score
from sklearn.metrics import accuracy_score
from s... | [
"numpy.mean",
"matplotlib.pyplot.grid",
"pandas.read_csv",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.show",
"matplotlib.pyplot.xlabel",
"sklearn.tree.DecisionTreeClassifier",
"sklearn.neighbors.KNeighborsClassifier",
"sklearn.ensemble.RandomForestClassifier",
"sklearn.decomposition.TruncatedS... | [((730, 774), 'pandas.read_csv', 'pd.read_csv', (['"""train_gossipcop_vol2.csv"""', '""","""'], {}), "('train_gossipcop_vol2.csv', ',')\n", (741, 774), True, 'import pandas as pd\n'), ((995, 1064), 'sklearn.feature_extraction.text.TfidfVectorizer', 'TfidfVectorizer', ([], {'sublinear_tf': '(True)', 'max_df': '(0.29)', ... |
### socket library ----> provides access to low-level netowkring interface
### BSD socket interface (Berkeleys Sockets)
### socket library ----> It allows you to send sockets on most of the platforms
import socket
# define the target host and port for later uses
# Or from user prompts
target_host = "www.infopro.com... | [
"socket.socket"
] | [((885, 934), 'socket.socket', 'socket.socket', (['socket.AF_INET', 'socket.SOCK_STREAM'], {}), '(socket.AF_INET, socket.SOCK_STREAM)\n', (898, 934), False, 'import socket\n')] |
"""
Opening x-callback URLs
This module is used to interact with other apps with `x-callback URLs <http://x-callback-url.com>`__.
"""
import webbrowser
from pyto import PyCallbackHelper
from _add_url_params import add_url_params
from urllib.parse import urlparse, parse_qs
from time import sleep
def open_url(url: st... | [
"_add_url_params.add_url_params",
"urllib.parse.parse_qs",
"urllib.parse.urlparse",
"time.sleep"
] | [((993, 1020), '_add_url_params.add_url_params', 'add_url_params', (['url', 'params'], {}), '(url, params)\n', (1007, 1020), False, 'from _add_url_params import add_url_params\n'), ((1682, 1692), 'time.sleep', 'sleep', (['(0.2)'], {}), '(0.2)\n', (1687, 1692), False, 'from time import sleep\n'), ((1190, 1203), 'urllib.... |
import time
import csv
from reviews import StoreReviews
def get_store_id(start, num):
f = open("./data/store food.csv", "r+")
csv.reader(f)
fieldnames = [
"store_id",
"store_name",
"city",
"industry",
"store_score",
]
reader = csv.DictReader(f, fieldnames=fi... | [
"reviews.StoreReviews",
"csv.DictReader",
"csv.reader",
"time.time"
] | [((136, 149), 'csv.reader', 'csv.reader', (['f'], {}), '(f)\n', (146, 149), False, 'import csv\n'), ((289, 329), 'csv.DictReader', 'csv.DictReader', (['f'], {'fieldnames': 'fieldnames'}), '(f, fieldnames=fieldnames)\n', (303, 329), False, 'import csv\n'), ((716, 727), 'time.time', 'time.time', ([], {}), '()\n', (725, 7... |
"""Example to run CNN naive Audio Classifier
To run:
$ python src/main/python/shabda/examples/cnn_naive_ccd /roor/of/shabda/lassifier/run.py --mode=train
"""
import importlib
import sys
import os
import tensorflow as tf
sys.path.append("src/main/python/")
sys.path.append("../..")
from shabda.run.experiments import ... | [
"shabda.run.experiments.Experiments",
"sys.path.append",
"importlib.import_module"
] | [((223, 258), 'sys.path.append', 'sys.path.append', (['"""src/main/python/"""'], {}), "('src/main/python/')\n", (238, 258), False, 'import sys\n'), ((259, 283), 'sys.path.append', 'sys.path.append', (['"""../.."""'], {}), "('../..')\n", (274, 283), False, 'import sys\n'), ((503, 540), 'importlib.import_module', 'import... |
from setuptools import find_packages, setup
__author__ = 'deresmos'
setup(
name='customlogger',
version='0.3.1',
description='custom logger class.',
author='deresmos',
author_email='<EMAIL>',
packages=find_packages(),
include_package_data=False,
keywords=['logging', 'Logger', 'custom']... | [
"setuptools.find_packages"
] | [((227, 242), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (240, 242), False, 'from setuptools import find_packages, setup\n')] |
import setuptools
setuptools.setup(name='GustelDDNS',
version='0.1.0',
description='',
author='krippix',
author_email='<EMAIL>',
license='GPL-3',
url="https://github.com/krippix/GustelDDNS",
install_requires=[],
packages=setuptools.find_packages()
)
| [
"setuptools.find_packages"
] | [((270, 296), 'setuptools.find_packages', 'setuptools.find_packages', ([], {}), '()\n', (294, 296), False, 'import setuptools\n')] |
# This file is part of Buildbot. Buildbot is free software: you can
# redistribute it and/or modify it under the terms of the GNU General Public
# License as published by the Free Software Foundation, version 2.
#
# This program is distributed in the hope that it will be useful, but WITHOUT
# ANY WARRANTY; without eve... | [
"buildbot.status.web.base.Box",
"twisted.web.error.NoResource",
"twisted.python.components.registerAdapter",
"buildbot.status.web.base.unicodify",
"zope.interface.implements"
] | [((2665, 2716), 'twisted.python.components.registerAdapter', 'components.registerAdapter', (['ChangeBox', 'Change', 'IBox'], {}), '(ChangeBox, Change, IBox)\n', (2691, 2716), False, 'from twisted.python import components\n'), ((2115, 2131), 'zope.interface.implements', 'implements', (['IBox'], {}), '(IBox)\n', (2125, 2... |
#!/usr/bin/env python
#
# Copyright 2010 <NAME>, <NAME>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable la... | [
"models.Shard.get_by_id",
"models.human_uuid",
"models.Shard",
"models.LoginRecord._get_kind",
"ndb.transaction",
"json.dumps",
"ndb.Rollback",
"models.LoginRecord.get_by_id"
] | [((2605, 2637), 'models.Shard.get_by_id', 'models.Shard.get_by_id', (['shard_id'], {}), '(shard_id)\n', (2627, 2637), False, 'import models\n'), ((5479, 5498), 'json.dumps', 'json.dumps', (['context'], {}), '(context)\n', (5489, 5498), False, 'import json\n'), ((1997, 2017), 'ndb.transaction', 'ndb.transaction', (['txn... |
import os
import pandas as pd
import numpy as np
import plotly.graph_objects as go
class MinorContamination():
"""
Minor contamination.
"""
def __init__(self, threshold):
self.threshold = threshold
def to_dataframe(self, samples):
data = pd.DataFrame(
columns=['samp... | [
"os.path.join",
"plotly.graph_objects.Figure",
"plotly.graph_objects.Scatter",
"pandas.DataFrame",
"pandas.isna"
] | [((280, 443), 'pandas.DataFrame', 'pd.DataFrame', ([], {'columns': "['sample_name', 'sample_group', 'sample_sex', 'sample_type',\n 'total_homozygous_sites', 'n_contributing_sites', 'minor_contamination']"}), "(columns=['sample_name', 'sample_group', 'sample_sex',\n 'sample_type', 'total_homozygous_sites', 'n_cont... |
'''
File name: tyche_db.py
Author: <NAME>.
'''
import os
import sys
import json
import csv
from sqlalchemy import create_engine
from sqlalchemy import Column, String, Float, DateTime
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import sessionmaker
# How to load config from ... | [
"sqlalchemy.orm.sessionmaker",
"sqlalchemy.create_engine",
"csv.writer",
"sqlalchemy.ext.declarative.declarative_base",
"sys.exit",
"json.load",
"sqlalchemy.Column"
] | [((630, 654), 'sqlalchemy.create_engine', 'create_engine', (['db_string'], {}), '(db_string)\n', (643, 654), False, 'from sqlalchemy import create_engine\n'), ((664, 682), 'sqlalchemy.ext.declarative.declarative_base', 'declarative_base', ([], {}), '()\n', (680, 682), False, 'from sqlalchemy.ext.declarative import decl... |
# Implementation of various helper functions
import matplotlib.pyplot as plt
import numpy as np
from numpy import pi
from scipy.integrate import quad
from scipy.special import kve
import sys
# Electron rest energy in eV
mc2 = 0.51099895000e6
def averagedIonizationCrossSection(T, C, DI_eV, betaStar):
"""
""... | [
"matplotlib.pyplot.semilogy",
"numpy.sqrt",
"numpy.isscalar",
"numpy.where",
"numpy.log",
"numpy.exp",
"numpy.zeros",
"numpy.linspace",
"scipy.special.kve",
"matplotlib.pyplot.show"
] | [((368, 380), 'numpy.zeros', 'np.zeros', (['nT'], {}), '(nT)\n', (376, 380), True, 'import numpy as np\n'), ((1537, 1556), 'numpy.sqrt', 'np.sqrt', (['(1 + p ** 2)'], {}), '(1 + p ** 2)\n', (1544, 1556), True, 'import numpy as np\n'), ((2157, 2176), 'numpy.sqrt', 'np.sqrt', (['(1 + p ** 2)'], {}), '(1 + p ** 2)\n', (21... |
from flask import Flask, jsonify
app = Flask(__name__)
app.config.from_object('config')
from .routes import routes
if __name__ == '__main__':
app.run() | [
"flask.Flask"
] | [((40, 55), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (45, 55), False, 'from flask import Flask, jsonify\n')] |
import numpy as np
raw = np.load('data/training_data_bounty_attack_mobilenet.npy')
converted_data = []
for data in raw:
# data[0]
if data[1] == [0,0,0,0]:
data[1] = [0,0,0,0,1]
else:
data[1].append(0)
if data[2] == [0,0]:
data[2] = [0,0,1]
else:
data[2].append(0)
... | [
"numpy.load",
"numpy.save"
] | [((27, 84), 'numpy.load', 'np.load', (['"""data/training_data_bounty_attack_mobilenet.npy"""'], {}), "('data/training_data_bounty_attack_mobilenet.npy')\n", (34, 84), True, 'import numpy as np\n'), ((379, 425), 'numpy.save', 'np.save', (['"""data/converted2.npy"""', 'converted_data'], {}), "('data/converted2.npy', conv... |
from django.urls import path
from .views import homepage
urlpatterns = [
path('', homepage, name='homepage'),
]
| [
"django.urls.path"
] | [((79, 114), 'django.urls.path', 'path', (['""""""', 'homepage'], {'name': '"""homepage"""'}), "('', homepage, name='homepage')\n", (83, 114), False, 'from django.urls import path\n')] |
import configparser
import sys
# sys.path.append('../option')
# print(sys.path)
from option.dgc import config_dgc
class config_bcfl:
def __init__(self, config):
self.config = dict(config._sections["bcfl"])
def get_sender(self):
return self.config["sender"]
def get_db(self):
retu... | [
"option.dgc.config_dgc",
"configparser.ConfigParser"
] | [((2437, 2464), 'configparser.ConfigParser', 'configparser.ConfigParser', ([], {}), '()\n', (2462, 2464), False, 'import configparser\n'), ((2707, 2730), 'option.dgc.config_dgc', 'config_dgc', (['self.config'], {}), '(self.config)\n', (2717, 2730), False, 'from option.dgc import config_dgc\n')] |
from direct.distributed.DistributedCartesianGridAI import DistributedCartesianGridAI
from direct.directnotify import DirectNotifyGlobal
from pirates.world.DistributedGameAreaAI import DistributedGameAreaAI
from pirates.world.InteriorAreaBuilderAI import InteriorAreaBuilderAI
from pirates.world.WorldGlobals import *
cl... | [
"pirates.world.DistributedGameAreaAI.DistributedGameAreaAI.__init__",
"pirates.world.InteriorAreaBuilderAI.InteriorAreaBuilderAI",
"direct.distributed.DistributedCartesianGridAI.DistributedCartesianGridAI.__init__",
"direct.distributed.DistributedCartesianGridAI.DistributedCartesianGridAI.delete",
"direct.d... | [((413, 483), 'direct.directnotify.DirectNotifyGlobal.directNotify.newCategory', 'DirectNotifyGlobal.directNotify.newCategory', (['"""DistributedGAInteriorAI"""'], {}), "('DistributedGAInteriorAI')\n", (456, 483), False, 'from direct.directnotify import DirectNotifyGlobal\n'), ((522, 702), 'direct.distributed.Distribut... |
from utils import log
from utils import template
from models import Todo
from . import response_with_headers
def redirect(location):
headers = {
'Content-Type': 'text/html',
}
headers['Location'] = location
# 301 永久重定向 302 普通定向
# 302 状态码的含义, Location 的作用
header = response_with_header... | [
"utils.log",
"models.Todo.all",
"utils.template",
"models.Todo.new",
"models.Todo.find",
"models.Todo.update",
"models.Todo.delete"
] | [((560, 570), 'models.Todo.all', 'Todo.all', ([], {}), '()\n', (568, 570), False, 'from models import Todo\n'), ((582, 633), 'utils.template', 'template', (['"""simple_todo_index.html"""'], {'todos': 'todo_list'}), "('simple_todo_index.html', todos=todo_list)\n", (590, 633), False, 'from utils import template\n'), ((87... |
test_data = {
(('super','bow','bowl','tar','get','book','let'), "superbowl") : ['super','bowl', [0,2]],
(('bow','crystal','organic','ally','rain','line'), "crystalline") : ['crystal','line', [1,5]],
(('bow','crystal','organic','ally','rain','line'), "rainbow") : ['bow','rain', [4,0... | [
"debugy.analysis.print_reports",
"unit_test.unit_test"
] | [((719, 763), 'unit_test.unit_test', 'unit_test.unit_test', (['test_data', 'input_format'], {}), '(test_data, input_format)\n', (738, 763), False, 'import unit_test, debugy\n'), ((1267, 1311), 'unit_test.unit_test', 'unit_test.unit_test', (['test_data', 'input_format'], {}), '(test_data, input_format)\n', (1286, 1311),... |
# Generated by Django 3.2.9 on 2021-12-20 02:24
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('mysite', '0007_auto_20211219_2215'),
]
operations = [
migrations.AlterModelOptions(
name='course',
options={'verbose_name': ... | [
"django.db.migrations.AlterModelOptions",
"django.db.migrations.AlterModelTable"
] | [((226, 343), 'django.db.migrations.AlterModelOptions', 'migrations.AlterModelOptions', ([], {'name': '"""course"""', 'options': "{'verbose_name': 'Course', 'verbose_name_plural': 'Courses'}"}), "(name='course', options={'verbose_name':\n 'Course', 'verbose_name_plural': 'Courses'})\n", (254, 343), False, 'from djan... |
import streamlit as st
import streamlit.components.v1 as components
import pandas as pd
import requests
from PIL import Image
import plotly.graph_objects as go
from plotly.subplots import make_subplots
import plotly.express as px
import matplotlib.pyplot as plt
import seaborn as sns
sns.set()
import ... | [
"streamlit.image",
"pandas.read_csv",
"streamlit.title",
"plotly.express.pie",
"plotly.graph_objects.Bar",
"seaborn.set",
"streamlit.cache",
"geopandas.read_file",
"plotly.express.choropleth",
"pandas.DataFrame",
"streamlit.components.v1.iframe",
"plotly.subplots.make_subplots",
"pandas.merg... | [((300, 309), 'seaborn.set', 'sns.set', ([], {}), '()\n', (307, 309), True, 'import seaborn as sns\n'), ((424, 580), 'streamlit.sidebar.selectbox', 'st.sidebar.selectbox', (['"""Change View"""', "('Local COVID-19 Cases Analysis', 'Risk Profile Dashboard',\n 'Risk Profile Survey', 'Daily Risk Profile Survey')"], {}),... |
# cython
from distutils.core import setup
from Cython.Build import cythonize
# run:
# python compile_cython.py build_ext --inplace
if __name__ == '__main__':
setup(name='PBAS', ext_modules=cythonize('pbas.pyx', annotate=True))
| [
"Cython.Build.cythonize"
] | [((195, 231), 'Cython.Build.cythonize', 'cythonize', (['"""pbas.pyx"""'], {'annotate': '(True)'}), "('pbas.pyx', annotate=True)\n", (204, 231), False, 'from Cython.Build import cythonize\n')] |
import logging
import sys
import textwrap
import unittest
from io import StringIO
try:
from unittest.mock import MagicMock, mock_open, patch
except ImportError:
from mock import MagicMock, mock_open, patch
try:
from importlib import reload
except ImportError:
from imp import reload
import sleuth.inje... | [
"logging.basicConfig",
"sleuth.inject._Print",
"textwrap.dedent",
"mock.patch",
"imp.reload",
"sleuth.inject.call_at",
"sys._getframe",
"sleuth.inject._Log",
"sleuth.inject._Break",
"sleuth.inject.print_at",
"sleuth.inject._Inject",
"unittest.main",
"io.StringIO",
"sleuth.inject._Call",
... | [((6412, 6427), 'unittest.main', 'unittest.main', ([], {}), '()\n', (6425, 6427), False, 'import unittest\n'), ((576, 591), 'imp.reload', 'reload', (['logging'], {}), '(logging)\n', (582, 591), False, 'from imp import reload\n'), ((780, 790), 'io.StringIO', 'StringIO', ([], {}), '()\n', (788, 790), False, 'from io impo... |
import matplotlib.pyplot as plt
import pandas as pd
from config import token
import pyEX as p
import os
ticker = 'AMD'
timeframe = '6m'
if os.path.exists("input.csv"):
df = pd.read_csv("input.csv")
print("Loaded from CSV")
else:
c = p.Client(api_token=token)
df = c.chartDF(ticker, timeframe)
d... | [
"os.path.exists",
"pandas.read_csv",
"matplotlib.pyplot.plot",
"pyEX.Client",
"pandas.DataFrame",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.show"
] | [((145, 172), 'os.path.exists', 'os.path.exists', (['"""input.csv"""'], {}), "('input.csv')\n", (159, 172), False, 'import os\n'), ((586, 642), 'matplotlib.pyplot.plot', 'plt.plot', (['df.ds', 'macd'], {'label': '"""AMD MACD"""', 'color': '"""#EBD2BE"""'}), "(df.ds, macd, label='AMD MACD', color='#EBD2BE')\n", (594, 64... |
#Copyright (c) 2022 <NAME>
import os
import yaml
import psutil
import platform
import socket
DEFAULTCONFIG="""
update_time: 2
loop_objects: ["general","cpu","ram","disks"]"""
class InvalidSettings(Exception):
def __init__(self) -> None:
super().__init__()
def __str__(self) -> str:
return "Inva... | [
"psutil.cpu_percent",
"psutil.disk_usage",
"yaml.dump",
"platform.platform",
"psutil.virtual_memory",
"psutil.disk_partitions",
"psutil.cpu_freq",
"psutil.cpu_count",
"socket.gethostname"
] | [((2571, 2590), 'platform.platform', 'platform.platform', ([], {}), '()\n', (2588, 2590), False, 'import platform\n'), ((2613, 2633), 'socket.gethostname', 'socket.gethostname', ([], {}), '()\n', (2631, 2633), False, 'import socket\n'), ((3526, 3556), 'psutil.cpu_count', 'psutil.cpu_count', ([], {'logical': '(True)'}),... |
# 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.getter",
"pulumi.set",
"pulumi.ResourceOptions",
"pulumi.get"
] | [((2022, 2054), 'pulumi.getter', 'pulumi.getter', ([], {'name': '"""instanceId"""'}), "(name='instanceId')\n", (2035, 2054), False, 'import pulumi\n'), ((2777, 2807), 'pulumi.getter', 'pulumi.getter', ([], {'name': '"""repoType"""'}), "(name='repoType')\n", (2790, 2807), False, 'import pulumi\n'), ((6658, 6690), 'pulum... |
from dash.dependencies import Input, Output, State
import dash_bootstrap_components as dbc
import dash_core_components as dcc
import dash_html_components as html
# main dash instance
from app import app
# call modules needed for callbacks
from apps.pages import map, photos, eda, map_overlay, model_results, progressba... | [
"dash.dependencies.Output",
"dash_html_components.H1",
"dash.dependencies.Input",
"dash_html_components.Hr",
"dash_html_components.P"
] | [((408, 442), 'dash.dependencies.Output', 'Output', (['"""page-content"""', '"""children"""'], {}), "('page-content', 'children')\n", (414, 442), False, 'from dash.dependencies import Input, Output, State\n'), ((445, 469), 'dash.dependencies.Input', 'Input', (['"""url"""', '"""pathname"""'], {}), "('url', 'pathname')\n... |
from dataclasses import dataclass, InitVar
from typing import Any
@dataclass(unsafe_hash=True)
class CoaxialControlIOStatus:
speaker: bool = False
white_light: bool = False
api_response: InitVar[Any] = None
def __post_init__(self, api_response):
if api_response is not None:
self.s... | [
"dataclasses.dataclass"
] | [((69, 96), 'dataclasses.dataclass', 'dataclass', ([], {'unsafe_hash': '(True)'}), '(unsafe_hash=True)\n', (78, 96), False, 'from dataclasses import dataclass, InitVar\n')] |
import random
import torch
import os
import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
from torch.utils.data import RandomSampler, BatchSampler
from .utils import calculate_accuracy, Cutout, calculate_accuracy_by_labels, calculate_FP, calculate_FP_Max
from .newtrainer import Trainer... | [
"torch.nn.Dropout",
"torch.optim.lr_scheduler.ReduceLROnPlateau",
"torch.abs",
"torch.LongTensor",
"torch.nn.Bilinear",
"csv.writer",
"os.path.join",
"torch.stack",
"src.utils.EarlyStopping",
"torch.softmax",
"torch.nn.functional.cross_entropy",
"time.time"
] | [((662, 702), 'torch.nn.Bilinear', 'nn.Bilinear', (['num_inputs1', 'num_inputs2', '(1)'], {}), '(num_inputs1, num_inputs2, 1)\n', (673, 702), True, 'import torch.nn as nn\n'), ((3025, 3171), 'src.utils.EarlyStopping', 'EarlyStopping', (['"""self.model_backup"""'], {'patience': 'self.patience', 'verbose': '(False)', 'wa... |
from flask import Flask, request, url_for, redirect, render_template, jsonify, abort
import pandas as pd
import pickle
import numpy as np
import json
from sklearn.preprocessing import StandardScaler
app = Flask(__name__)
model = pickle.load(open('model.pkl', 'rb'))
cols = ['ph', 'Hardness', 'Solids', 'Chloramines', '... | [
"flask.render_template",
"pandas.read_csv",
"flask.Flask",
"json.dumps",
"sklearn.preprocessing.StandardScaler",
"numpy.array",
"flask.request.form.values",
"pandas.DataFrame"
] | [((206, 221), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (211, 221), False, 'from flask import Flask, request, url_for, redirect, render_template, jsonify, abort\n'), ((436, 465), 'flask.render_template', 'render_template', (['"""index.html"""'], {}), "('index.html')\n", (451, 465), False, 'from flask ... |
import os
import sys
import os.path as op
import random
import torch
import torch.nn as nn
import six
import torch.optim as optim
from torch.autograd import Variable
import pandas as pd
import numpy as np
import pickle
import csv
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
import filena... | [
"torch.cuda.is_available",
"sys.exit",
"os.listdir",
"numpy.asarray",
"numpy.max",
"numpy.issubdtype",
"os.mkdir",
"torch.optim.lr_scheduler.ReduceLROnPlateau",
"numpy.full",
"csv.writer",
"torch.save",
"time.time",
"torch.cat",
"utils.deps_from_tsv",
"pickle.dump",
"torch.load",
"os... | [((1572, 1637), 'numpy.full', 'np.full', (['((num_samples, maxlen) + sample_shape)', 'value'], {'dtype': 'dtype'}), '((num_samples, maxlen) + sample_shape, value, dtype=dtype)\n', (1579, 1637), True, 'import numpy as np\n'), ((488, 513), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {}), '()\n', (511, 513)... |
import unittest
from unittest.mock import MagicMock, patch
from collections import Counter, deque
from PyQt5.QtWidgets import QMainWindow
from extra_foam.logger import logger
from extra_foam.gui import mkQApp
from extra_foam.gui.windows import (
BinningWindow, CorrelationWindow, HistogramWindow, PumpProbeWindow, ... | [
"extra_foam.logger.logger.setLevel",
"extra_foam.gui.windows.binning_w.Bin2dHeatmap",
"extra_foam.pipeline.data_model.ProcessedData",
"extra_foam.gui.windows.pump_probe_w.PumpProbeVFomPlot",
"extra_foam.gui.windows.pulse_of_interest_w.PoiFomHist",
"extra_foam.gui.windows.pump_probe_w.PumpProbeFomPlot",
... | [((502, 510), 'extra_foam.gui.mkQApp', 'mkQApp', ([], {}), '()\n', (508, 510), False, 'from extra_foam.gui import mkQApp\n'), ((512, 539), 'extra_foam.logger.logger.setLevel', 'logger.setLevel', (['"""CRITICAL"""'], {}), "('CRITICAL')\n", (527, 539), False, 'from extra_foam.logger import logger\n'), ((644, 657), 'PyQt5... |
# Generated by Django 2.2.12 on 2020-05-13 18:25
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('accounts', '0118_remove_userpermission_role'),
('plans', '0007_auto_20200512_0536'),
]
operations = [
... | [
"django.db.models.OneToOneField",
"django.db.models.ForeignKey"
] | [((419, 537), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'blank': '(True)', 'null': '(True)', 'on_delete': 'django.db.models.deletion.SET_NULL', 'to': '"""accounts.CompanyRole"""'}), "(blank=True, null=True, on_delete=django.db.models.\n deletion.SET_NULL, to='accounts.CompanyRole')\n", (436, 537), Fa... |
from abc import ABC
from typing import Optional
from flowchem.components.properties import ActiveComponent
from flowchem.units import flowchem_ureg
class Pump(ActiveComponent, ABC):
"""
A generic pumping device whose primary feature is that it moves fluid.
Arguments:
- `name`: The name of the pump.
... | [
"flowchem.units.flowchem_ureg.parse_expression"
] | [((598, 640), 'flowchem.units.flowchem_ureg.parse_expression', 'flowchem_ureg.parse_expression', (['"""0 ml/min"""'], {}), "('0 ml/min')\n", (628, 640), False, 'from flowchem.units import flowchem_ureg\n')] |
import numpy as np
class Gene:
""" Gene class
Attributes:
-----------
CITY_NUM {int} -- the number of cities
GENE_SIZE {int} -- gene size
gene {np.ndarray} -- gene representation
route {list[int]} -- route converted from gene
"""
def __init__(self, gene_size, city... | [
"numpy.zeros",
"numpy.random.randint"
] | [((680, 720), 'numpy.zeros', 'np.zeros', (['self.GENE_SIZE'], {'dtype': 'np.int32'}), '(self.GENE_SIZE, dtype=np.int32)\n', (688, 720), True, 'import numpy as np\n'), ((781, 824), 'numpy.random.randint', 'np.random.randint', (['(0)', '(self.GENE_SIZE - i)', '(1)'], {}), '(0, self.GENE_SIZE - i, 1)\n', (798, 824), True,... |
# *****************************************************************
# Copyright 2013 MIT Lincoln Laboratory
# Project: SPAR
# Authors: ni24039
# Description: Config file to be used with remote_runner.py
#
# Modifications:
# Date Name Modification
# ---- ... | [
"copy.deepcopy"
] | [((2151, 2180), 'copy.deepcopy', 'copy.deepcopy', (['base_component'], {}), '(base_component)\n', (2164, 2180), False, 'import copy\n'), ((2423, 2452), 'copy.deepcopy', 'copy.deepcopy', (['base_component'], {}), '(base_component)\n', (2436, 2452), False, 'import copy\n'), ((2695, 2724), 'copy.deepcopy', 'copy.deepcopy'... |
import unittest
from typing import TypeVar, List, Type
from xrpc.abstract import BinaryQueue, Queue, HeapQueue, KeyedQueue
A1 = [1, 2, 2, 3, 3, 3]
A2 = [1, 2, 3, 3, 3]
A3 = []
A4 = [1]
T = TypeVar('T')
def ex(q: Queue[T]) -> List[T]:
r = []
while True:
try:
r.append(q.pop())
ex... | [
"typing.TypeVar"
] | [((193, 205), 'typing.TypeVar', 'TypeVar', (['"""T"""'], {}), "('T')\n", (200, 205), False, 'from typing import TypeVar, List, Type\n')] |