code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
"""
This file contains test for Bus class
"""
import sys
import pytest
from simulation import Bus
from simulation.line import Line, LineStop
from simulation.passenger_group import PassengersGroup
from utils.TestsBase import TestBase
from utils.helpers import get_full_class_name
if sys.version_info[0] >= 3:
impor... | [
"mock.patch",
"utils.helpers.get_full_class_name",
"simulation.line.LineStop",
"simulation.passenger_group.PassengersGroup",
"pytest.mark.parametrize",
"simulation.Bus"
] | [((1313, 1338), 'utils.helpers.get_full_class_name', 'get_full_class_name', (['Line'], {}), '(Line)\n', (1332, 1338), False, 'from utils.helpers import get_full_class_name\n'), ((2358, 2413), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (["('steps', 'stops')", 'TEST_ARRAY'], {}), "(('steps', 'stops'), TEST_ARR... |
# -*- coding:utf-8 -*-
# @author :adolf
import json
from mmdet.datasets.builder import DATASETS
from mmdet.datasets.custom import CustomDataset
@DATASETS.register_module()
class OcrTextDataset(CustomDataset):
CLASSES = ('text',)
def load_annotations(self, ann_file):
data_infos = list()
with ... | [
"json.loads",
"mmdet.datasets.builder.DATASETS.register_module"
] | [((148, 174), 'mmdet.datasets.builder.DATASETS.register_module', 'DATASETS.register_module', ([], {}), '()\n', (172, 174), False, 'from mmdet.datasets.builder import DATASETS\n'), ((468, 489), 'json.loads', 'json.loads', (['img_info_'], {}), '(img_info_)\n', (478, 489), False, 'import json\n')] |
from boundlexx.api.common.views import ExportedFileViewSet, GameFileViewSet
from boundlexx.api.routers import APIDocsRouter
from boundlexx.api.v2 import views
API_DESCRIPTION = """
Boundless Lexicon API v2. Everything about the game Boundless.
Disclaimer: Boundlexx is an unoffical API for the game Boundless. There is... | [
"boundlexx.api.routers.APIDocsRouter"
] | [((1052, 1088), 'boundlexx.api.routers.APIDocsRouter', 'APIDocsRouter', (['API_DESCRIPTION', '"""v2"""'], {}), "(API_DESCRIPTION, 'v2')\n", (1065, 1088), False, 'from boundlexx.api.routers import APIDocsRouter\n')] |
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License.
import os
import sysconfig
import shutil
from setuptools import setup, Extension
from setuptools.command.build_ext import build_ext
ext_path_rel = os.path.join('confonnx', 'confonnx_py' + sysconfig.get_config_var('EXT_SUFFIX... | [
"setuptools.Extension",
"os.path.dirname",
"shutil.copyfile",
"sysconfig.get_config_var"
] | [((348, 373), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (363, 373), False, 'import os\n'), ((284, 322), 'sysconfig.get_config_var', 'sysconfig.get_config_var', (['"""EXT_SUFFIX"""'], {}), "('EXT_SUFFIX')\n", (308, 322), False, 'import sysconfig\n'), ((678, 720), 'shutil.copyfile', 'shuti... |
import torch
import numpy as np
class FFNet(torch.nn.Module):
"""Simple class to implement a feed-forward neural network in PyTorch.
Attributes:
layers: list of torch.nn.Linear layers to be applied in forward pass.
activation: activation function to be applied between layers.
"""
... | [
"torch.nn.ModuleList",
"torch.flatten",
"torch.nn.Conv2d",
"torch.nn.MaxPool2d",
"torch.nn.Linear",
"numpy.concatenate",
"torch.cat"
] | [((946, 978), 'torch.nn.ModuleList', 'torch.nn.ModuleList', (['self.layers'], {}), '(self.layers)\n', (965, 978), False, 'import torch\n'), ((4672, 4717), 'numpy.concatenate', 'np.concatenate', (['([cnn_output_size], ff_shape)'], {}), '(([cnn_output_size], ff_shape))\n', (4686, 4717), True, 'import numpy as np\n'), ((4... |
# 780. Reaching Points
import collections
class Solution:
# brute force: MLE
def reachingPoints(self, sx: int, sy: int, tx: int, ty: int) -> bool:
if sx > tx or sy > ty: return False
q = collections.deque([(sx, sy)])
while q:
cx, cy = q.popleft()
if cx ==... | [
"collections.deque"
] | [((220, 249), 'collections.deque', 'collections.deque', (['[(sx, sy)]'], {}), '([(sx, sy)])\n', (237, 249), False, 'import collections\n')] |
from django.urls import reverse
from rest_framework.test import APITestCase
from rest_framework import status
from main import factories
class TestDebitLogUpdateAPIView(APITestCase):
def setUp(self):
self.user = factories.UserFactory(username = 'atom', password = '<PASSWORD>')
self.client.force_l... | [
"main.factories.DebitFactory",
"main.factories.DebitLogFactory",
"django.urls.reverse",
"main.factories.CustomerFactory",
"main.factories.UserFactory"
] | [((227, 288), 'main.factories.UserFactory', 'factories.UserFactory', ([], {'username': '"""atom"""', 'password': '"""<PASSWORD>"""'}), "(username='atom', password='<PASSWORD>')\n", (248, 288), False, 'from main import factories\n'), ((385, 423), 'main.factories.DebitFactory', 'factories.DebitFactory', ([], {'user': 'se... |
import threading
import os
import sys
import time
from netaddr import IPNetwork, core
from functools import wraps
ip_list = []
class MyPing(threading.Thread):
def __init__(self, func, args, name=''):
super(MyPing, self).__init__()
self.name = name
self.func = func
self.args = args... | [
"functools.wraps",
"sys.exit",
"os.system",
"time.time",
"netaddr.IPNetwork"
] | [((639, 687), 'os.system', 'os.system', (["('ping -c 1 %s 2>&1 >> /dev/null' % ip)"], {}), "('ping -c 1 %s 2>&1 >> /dev/null' % ip)\n", (648, 687), False, 'import os\n'), ((770, 781), 'functools.wraps', 'wraps', (['func'], {}), '(func)\n', (775, 781), False, 'from functools import wraps\n'), ((837, 848), 'time.time', '... |
import analytics
from django.db import InterfaceError, OperationalError, ProgrammingError
from tracker.service import TrackerService
class PublishTrackerService(TrackerService):
def __init__(self, key=''):
self.cluster_id = None
self.analytics = analytics
self.analytics.write_key = key
... | [
"db.models.clusters.Cluster.load"
] | [((501, 515), 'db.models.clusters.Cluster.load', 'Cluster.load', ([], {}), '()\n', (513, 515), False, 'from db.models.clusters import Cluster\n')] |
import os
import re
import collections
import shutil
import traceback
from os.path import join
from xml.dom import minidom
print("Start")
a = []
rpt = []
Folders = []
Address = []
def list_duplicates(seq):
global t
t = False
seen = set()
seen_add = seen.add
seen_twice = set( x for x in seq if x in... | [
"os.path.exists",
"traceback.format_exc",
"os.listdir",
"xml.dom.minidom.parse",
"os.path.join",
"re.match",
"shutil.rmtree",
"os.walk"
] | [((607, 626), 'os.listdir', 'os.listdir', (['address'], {}), '(address)\n', (617, 626), False, 'import os\n'), ((1311, 1332), 'os.path.exists', 'os.path.exists', (['path1'], {}), '(path1)\n', (1325, 1332), False, 'import os\n'), ((1355, 1376), 'os.path.exists', 'os.path.exists', (['path2'], {}), '(path2)\n', (1369, 137... |
from flask import Flask, jsonify, request
from flask_cors import CORS
import models.persona
# configuraciones
persona = models.persona
app= Flask(__name__)
CORS(app)
# rutas de la api
@app.route('/')
def index():
try:
datos = persona.listadoPersona()
list=[]
for i in datos:
f... | [
"flask.jsonify",
"flask_cors.CORS",
"flask.Flask"
] | [((143, 158), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (148, 158), False, 'from flask import Flask, jsonify, request\n'), ((159, 168), 'flask_cors.CORS', 'CORS', (['app'], {}), '(app)\n', (163, 168), False, 'from flask_cors import CORS\n'), ((535, 559), 'flask.jsonify', 'jsonify', (["{'datos': list}"... |
"""
Cross driver wrapper for SQLAlchemy db types
"""
import json
import uuid
import datetime
from enum import Enum
from typing import Any, Dict
import sqlalchemy as sa
from sqlalchemy.types import TypeDecorator, CHAR
from sqlalchemy.dialects.postgresql import UUID, JSONB as _JSONB
from sqlalchemy.dialects.sqlite import... | [
"json.loads",
"uuid.UUID",
"sqlalchemy.types.CHAR",
"sqlalchemy.dialects.postgresql.UUID",
"woolgatherer.db.utils.has_postgres"
] | [((438, 452), 'woolgatherer.db.utils.has_postgres', 'has_postgres', ([], {}), '()\n', (450, 452), False, 'from woolgatherer.db.utils import has_postgres\n'), ((1002, 1010), 'sqlalchemy.types.CHAR', 'CHAR', (['(32)'], {}), '(32)\n', (1006, 1010), False, 'from sqlalchemy.types import TypeDecorator, CHAR\n'), ((1508, 1524... |
# Copyright (c) 2020 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by appl... | [
"paddle.static.Executor",
"paddle.CPUPlace",
"numpy.random.random",
"paddle.CUDAPlace",
"paddle.enable_static",
"paddle.fluid.data_feeder.convert_dtype",
"paddle.empty_like",
"paddle.disable_static",
"paddle.static.program_guard",
"numpy.nanmax",
"paddle.static.data",
"numpy.sum",
"unittest.... | [((6230, 6245), 'unittest.main', 'unittest.main', ([], {}), '()\n', (6243, 6245), False, 'import unittest\n'), ((967, 991), 'paddle.fluid.data_feeder.convert_dtype', 'convert_dtype', (['out.dtype'], {}), '(out.dtype)\n', (980, 991), False, 'from paddle.fluid.data_feeder import convert_dtype\n'), ((2279, 2302), 'paddle.... |
import asyncio
async def request(url):
if url == 'a':
print('request a')
raise Exception('request a fail')
elif url == 'b':
print('request b')
return 'b response'
elif url == 'c':
print('request c')
return 'c response'
async def main(return_exceptions=Fals... | [
"asyncio.get_event_loop",
"asyncio.gather"
] | [((573, 597), 'asyncio.get_event_loop', 'asyncio.get_event_loop', ([], {}), '()\n', (595, 597), False, 'import asyncio\n'), ((408, 467), 'asyncio.gather', 'asyncio.gather', (['*tasks'], {'return_exceptions': 'return_exceptions'}), '(*tasks, return_exceptions=return_exceptions)\n', (422, 467), False, 'import asyncio\n')... |
# coding: utf-8
import os
import numpy as np
from fireworks import Workflow, Firework
from atomate.vasp.fireworks.core import StaticFW
from atomate.vasp.powerups import (
add_tags,
add_modify_incar,
add_additional_fields_to_taskdocs,
add_wf_metadata,
add_common_powerups,
)
from atomate.vasp.workfl... | [
"uuid.uuid4",
"atomate.vasp.fireworks.exchange.VampireCallerFW",
"atomate.utils.utils.get_logger",
"fireworks.Workflow",
"atomate.vasp.fireworks.exchange.HeisenbergModelFW",
"atomate.vasp.powerups.add_additional_fields_to_taskdocs"
] | [((728, 748), 'atomate.utils.utils.get_logger', 'get_logger', (['__name__'], {}), '(__name__)\n', (738, 748), False, 'from atomate.utils.utils import get_logger\n'), ((4587, 4798), 'atomate.vasp.fireworks.exchange.HeisenbergModelFW', 'HeisenbergModelFW', ([], {'wf_uuid': 'self.uuid', 'parent_structure': 'self.structure... |
import numpy as np
import spenc as spenc
import pysal as ps
import geopandas as gpd
import os
SEED = 1901
dir_self = os.path.dirname(__file__)
datadir = os.path.join(dir_self, 'spenc/tests/data')
if __name__ == "__main__":
nat = gpd.read_file(ps.examples.get_path("NAT.shp"))
natR = ps.weights.Rook.from_datafra... | [
"spenc.SPENC",
"os.path.join",
"os.path.dirname",
"pysal.weights.Rook.from_dataframe",
"numpy.random.seed",
"pysal.examples.get_path"
] | [((117, 142), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (132, 142), False, 'import os\n'), ((153, 195), 'os.path.join', 'os.path.join', (['dir_self', '"""spenc/tests/data"""'], {}), "(dir_self, 'spenc/tests/data')\n", (165, 195), False, 'import os\n'), ((292, 327), 'pysal.weights.Rook.fr... |
from mycroft import MycroftSkill, intent_file_handler
class DragonMaid(MycroftSkill):
def __init__(self):
MycroftSkill.__init__(self)
@intent_file_handler('maid.dragon.intent')
def handle_maid_dragon(self, message):
self.speak_dialog("playing it")
def create_skill():
return DragonMai... | [
"mycroft.intent_file_handler",
"mycroft.MycroftSkill.__init__"
] | [((153, 194), 'mycroft.intent_file_handler', 'intent_file_handler', (['"""maid.dragon.intent"""'], {}), "('maid.dragon.intent')\n", (172, 194), False, 'from mycroft import MycroftSkill, intent_file_handler\n'), ((119, 146), 'mycroft.MycroftSkill.__init__', 'MycroftSkill.__init__', (['self'], {}), '(self)\n', (140, 146)... |
try:
from http.server import SimpleHTTPRequestHandler
import socketserver
except:
from SimpleHTTPServer import SimpleHTTPRequestHandler
import SocketServer as socketserver
import matplotlib as mpl
mpl.use('agg')
from PIL import Image
import sys, os, inspect
current_dir = os.path.dirname(inspect.getfile(inspect.cur... | [
"io.BytesIO",
"math.sqrt",
"math.cos",
"urllib.parse.parse_qs",
"tensorflow.reduce_mean",
"tensorflow.cast",
"tensorflow.GPUOptions",
"os.path.exists",
"os.path.splitdrive",
"argparse.ArgumentParser",
"tensorflow.placeholder",
"os.path.split",
"os.path.isdir",
"pylab.subplots",
"tensorfl... | [((201, 215), 'matplotlib.use', 'mpl.use', (['"""agg"""'], {}), "('agg')\n", (208, 215), True, 'import matplotlib as mpl\n'), ((350, 388), 'os.path.join', 'os.path.join', (['current_dir', '""".."""', '"""src"""'], {}), "(current_dir, '..', 'src')\n", (362, 388), False, 'import sys, os, inspect\n'), ((7000, 7016), 'argp... |
# -*- coding: utf-8 -*-
"""
Created on 2018-05-18 18:12:12
@Author: <NAME>
@Version : 0.0.1
"""
import time
import os
import numpy as np
import cv2
import stitch
show_image = stitch.show_image
os.chdir(os.path.dirname(__file__))
def work():
os.chdir(os.path.dirname(__file__))
base_path = "../../论文/md/img/c... | [
"os.path.dirname",
"time.time",
"cv2.imencode",
"stitch.Stitcher"
] | [((205, 230), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (220, 230), False, 'import os\n'), ((259, 284), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (274, 284), False, 'import os\n'), ((2756, 2781), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(... |
# Copyright 2012 OpenStack Foundation
# 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 requ... | [
"clictestclient.common.utils.make_size_human_readable",
"functools.partial",
"clictestclient.common.utils.print_dict",
"copy.deepcopy"
] | [((1204, 1261), 'functools.partial', 'functools.partial', (['strutils.bool_from_string'], {'strict': '(True)'}), '(strutils.bool_from_string, strict=True)\n', (1221, 1261), False, 'import functools\n'), ((1392, 1417), 'copy.deepcopy', 'copy.deepcopy', (['test._info'], {}), '(test._info)\n', (1405, 1417), False, 'import... |
import os
import time
import gym
from gym.spaces import Discrete
import haiku as hk
import jax
import jax.numpy as jnp
import jax.random as random
from jax.experimental.optimizers import adam
import numpy as np
from rlax import huber_loss
from jax_baselines import logger
from jax_baselines.common.critic import Discre... | [
"jax_baselines.common.util.make_preprocessor",
"jax_baselines.logger.dumpkvs",
"jax_baselines.common.critic.DiscreteActionCritic",
"jax.numpy.max",
"numpy.array",
"gym.make",
"jax.random.split",
"jax_baselines.dqn.replay.PrioritizedReplayBuffer",
"jax.random.PRNGKey",
"argparse.ArgumentParser",
... | [((1106, 1168), 'jax_baselines.logger.configure', 'logger.configure', ([], {'dir': 'save_dir', 'format_strs': 'logger_format_strs'}), '(dir=save_dir, format_strs=logger_format_strs)\n', (1122, 1168), False, 'from jax_baselines import logger\n'), ((1173, 1202), 'jax_baselines.logger.set_level', 'logger.set_level', (['lo... |
import win32com.client
from easygraphics import dialog as dlg
import os
from pathlib import Path
app = win32com.client.gencache.EnsureDispatch('Powerpoint.Application')
pp_constants = win32com.client.constants
dir_path = dlg.get_directory_name("请选择要转换的目录")
path = Path(dir_path)
for entry in path.iterdir():
i... | [
"easygraphics.dialog.get_directory_name",
"pathlib.Path"
] | [((226, 261), 'easygraphics.dialog.get_directory_name', 'dlg.get_directory_name', (['"""请选择要转换的目录"""'], {}), "('请选择要转换的目录')\n", (248, 261), True, 'from easygraphics import dialog as dlg\n'), ((270, 284), 'pathlib.Path', 'Path', (['dir_path'], {}), '(dir_path)\n', (274, 284), False, 'from pathlib import Path\n')] |
#!/usr/local/bin/python3
import random
import ipaddress
from randmac import RandMac
from urllib.parse import urlparse
import dns.resolver
import re
import hashlib
import time
import json
from kafka import KafkaProducer
import user_profile_hash_maker as uphm
import argparse
import configparser
# Parse configs
cfg = co... | [
"user_profile_hash_maker.make_hash.make_profile_hash",
"json.loads",
"random.choice",
"user_profile_hash_maker.make_hash.make_username_useragent_lists",
"configparser.ConfigParser",
"argparse.ArgumentParser",
"urllib.parse.urlparse",
"kafka.KafkaProducer",
"random.randrange",
"random.uniform",
"... | [((318, 345), 'configparser.ConfigParser', 'configparser.ConfigParser', ([], {}), '()\n', (343, 345), False, 'import configparser\n'), ((413, 548), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""This script generates a real-looking fake IDS event and sends it to your Kafka cluster"""'}),... |
from sqlalchemy.orm.session import sessionmaker
from tools.DataBase.Connect import conection
from tools.EndPoints.HotelPro import HotelPro
class EndPointHandle:
endpoints={2:HotelPro}
def __init__(self, inputs):
self.connODM = conection().conODM()
self.connORM = conection().conORM()
s... | [
"sqlalchemy.orm.session.sessionmaker",
"tools.DataBase.Connect.conection"
] | [((411, 442), 'sqlalchemy.orm.session.sessionmaker', 'sessionmaker', ([], {'bind': 'self.connORM'}), '(bind=self.connORM)\n', (423, 442), False, 'from sqlalchemy.orm.session import sessionmaker\n'), ((245, 256), 'tools.DataBase.Connect.conection', 'conection', ([], {}), '()\n', (254, 256), False, 'from tools.DataBase.C... |
import pandas as pd
from nltk.corpus import stopwords
import numpy as np
import nltk
import re
from bs4 import BeautifulSoup
from nltk.corpus import stopwords
import pprint
train = pd.read_csv("labeledTweet.csv",header=0,\
delimiter="\t", quoting=3)
test = pd.read_csv("testTweet.csv",header=0,\
... | [
"logging.basicConfig",
"nltk.corpus.stopwords.words",
"pandas.read_csv",
"numpy.add",
"gensim.models.word2vec.Word2VecKeyedVectors.load",
"sklearn.ensemble.RandomForestClassifier",
"bs4.BeautifulSoup",
"numpy.zeros",
"nltk.data.load",
"pandas.DataFrame",
"re.sub",
"numpy.divide"
] | [((183, 251), 'pandas.read_csv', 'pd.read_csv', (['"""labeledTweet.csv"""'], {'header': '(0)', 'delimiter': '"""\t"""', 'quoting': '(3)'}), "('labeledTweet.csv', header=0, delimiter='\\t', quoting=3)\n", (194, 251), True, 'import pandas as pd\n'), ((280, 345), 'pandas.read_csv', 'pd.read_csv', (['"""testTweet.csv"""'],... |
import html
with open("templates/template.html", 'r', encoding="utf-8") as f:
TEMPLATE_HTML = f.read()
# Minified form containing a textarea for user input
FORM = ('<form action="/paste" id="paste" method="POST" onsubmit="return '
'validatePaste()";><textarea name="new_paste_content" spellcheck="fals'
... | [
"html.escape"
] | [((1070, 1090), 'html.escape', 'html.escape', (['content'], {}), '(content)\n', (1081, 1090), False, 'import html\n')] |
from library.api.db import EntityModel, db
class JobsRecord(EntityModel):
ACTIVE = 0
DISABLE = 1
job_id = db.Column(db.String(100)) # Job id
result = db.Column(db.String(1000)) # Job 结果
log = db.Column(db.Text) # Job log
| [
"library.api.db.db.String",
"library.api.db.db.Column"
] | [((217, 235), 'library.api.db.db.Column', 'db.Column', (['db.Text'], {}), '(db.Text)\n', (226, 235), False, 'from library.api.db import EntityModel, db\n'), ((131, 145), 'library.api.db.db.String', 'db.String', (['(100)'], {}), '(100)\n', (140, 145), False, 'from library.api.db import EntityModel, db\n'), ((180, 195), ... |
# -*- coding: utf-8 -*-
"""
Created on Fri Jul 2 12:09:14 2021
@author: vohuynhq
"""
import numpy as np
import pandas as pd
from sympy import symbols, init_printing, pi, sqrt, diff, sin, cos, exp
def example(A):
A_true = np.array([[3, 4, 5], [3, 4, 5]])
np.testing.assert_equal(A, A_true)
r... | [
"sympy.sin",
"numpy.mean",
"sympy.cos",
"numpy.testing.assert_equal",
"pandas.read_csv",
"sympy.sqrt",
"sympy.init_printing",
"sympy.symbols",
"numpy.array",
"sympy.diff",
"sympy.exp"
] | [((241, 273), 'numpy.array', 'np.array', (['[[3, 4, 5], [3, 4, 5]]'], {}), '([[3, 4, 5], [3, 4, 5]])\n', (249, 273), True, 'import numpy as np\n'), ((279, 313), 'numpy.testing.assert_equal', 'np.testing.assert_equal', (['A', 'A_true'], {}), '(A, A_true)\n', (302, 313), True, 'import numpy as np\n'), ((390, 421), 'sympy... |
import unittest
from telegramaccountingbot.bot.text_generator import balance_dict_to_message
class TestDictToMessage(unittest.TestCase):
def test_dict_to_message(self):
dict_id_to_name = {"0": "Hugo",
"1": "Ilyas"}
balance_dict = {"1": 1280,
"0"... | [
"telegramaccountingbot.bot.text_generator.balance_dict_to_message"
] | [((386, 440), 'telegramaccountingbot.bot.text_generator.balance_dict_to_message', 'balance_dict_to_message', (['dict_id_to_name', 'balance_dict'], {}), '(dict_id_to_name, balance_dict)\n', (409, 440), False, 'from telegramaccountingbot.bot.text_generator import balance_dict_to_message\n')] |
import torch.nn as nn
import torch
from torch import optim
class Down(nn.Module):
def __init__(self, in_channels, kernel_size=2, stride=2):
super(Down, self).__init__()
out_channels = in_channels * 2
self.conv = nn.Conv3d(in_channels, out_channels, kernel_size=kernel_size, stride=stride, gr... | [
"torch.nn.ReLU",
"torch.nn.CrossEntropyLoss",
"torch.nn.ConvTranspose3d",
"torch.nn.Softmax",
"torch.randint",
"torch.nn.BatchNorm3d",
"torch.randn",
"torch.cat",
"torch.nn.Conv3d"
] | [((2829, 2869), 'torch.randint', 'torch.randint', (['(0)', '(3)', '(10, 1, 32, 32, 32)'], {}), '(0, 3, (10, 1, 32, 32, 32))\n', (2842, 2869), False, 'import torch\n'), ((2904, 2925), 'torch.nn.CrossEntropyLoss', 'nn.CrossEntropyLoss', ([], {}), '()\n', (2923, 2925), True, 'import torch.nn as nn\n'), ((241, 331), 'torch... |
"""Validation function"""
import time
import logging
import numpy as np
import torch
from torch import nn
from helpers.miou_utils import compute_iu, compute_ius_accs, fast_cm
from helpers.utils import ctime, try_except
import pdb
import matplotlib.pyplot as plt
logger = logging.getLogger(__name__)
import pylab
cma... | [
"logging.getLogger",
"numpy.mean",
"numpy.prod",
"torch.autograd.Variable",
"helpers.utils.ctime",
"helpers.miou_utils.compute_iu",
"numpy.sum",
"numpy.zeros",
"helpers.miou_utils.compute_ius_accs",
"torch.no_grad",
"numpy.load",
"helpers.miou_utils.fast_cm"
] | [((274, 301), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (291, 301), False, 'import logging\n'), ((324, 351), 'numpy.load', 'np.load', (['"""./utils/cmap.npy"""'], {}), "('./utils/cmap.npy')\n", (331, 351), True, 'import numpy as np\n'), ((1022, 1069), 'numpy.zeros', 'np.zeros', (['(n... |
# -*- coding: utf-8 -*- #
# Copyright 2020 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.command_lib.domains.resource_args.AddLocationResourceArg",
"googlecloudsdk.calliope.base.Argument",
"googlecloudsdk.command_lib.domains.util.PunycodeToUnicode",
"googlecloudsdk.api_lib.domains.registrations.GetApiVersionFromArgs",
"googlecloudsdk.api_lib.domains.registrations.RegistrationsCl... | [((1763, 1831), 'googlecloudsdk.command_lib.domains.resource_args.AddLocationResourceArg', 'resource_args.AddLocationResourceArg', (['parser', '"""to search domains in"""'], {}), "(parser, 'to search domains in')\n", (1799, 1831), False, 'from googlecloudsdk.command_lib.domains import resource_args\n'), ((2206, 2247), ... |
# Add some text to your game
# This problem builds off of bouncingrect.py
# Add some text to the screen. You can either:
# - draw the text to a specified coordinate OR
# - blit the text onto the bouncing rectangle.
import pygame
import time # not necessary, but used for frame cap
pygame.init() # initialize pygame... | [
"pygame.init",
"pygame.quit",
"pygame.event.get",
"pygame.display.set_mode",
"time.sleep",
"pygame.draw.rect",
"pygame.display.update",
"pygame.font.SysFont"
] | [((286, 299), 'pygame.init', 'pygame.init', ([], {}), '()\n', (297, 299), False, 'import pygame\n'), ((485, 521), 'pygame.display.set_mode', 'pygame.display.set_mode', (['SCREEN_SIZE'], {}), '(SCREEN_SIZE)\n', (508, 521), False, 'import pygame\n'), ((1732, 1745), 'pygame.quit', 'pygame.quit', ([], {}), '()\n', (1743, 1... |
# -*- coding: utf-8 -*-
__author__ = 'Администратор'
from model.contact import Contact
from model.group import Group
from fixture.orm import ORMFixture
import random
def test_add_contact_in_group(app, db):
db = ORMFixture(host="127.0.0.1", name = "addressbook", user="root", password="")
if len(db.get_contact_l... | [
"model.group.Group",
"random.choice",
"fixture.orm.ORMFixture",
"model.contact.Contact"
] | [((216, 290), 'fixture.orm.ORMFixture', 'ORMFixture', ([], {'host': '"""127.0.0.1"""', 'name': '"""addressbook"""', 'user': '"""root"""', 'password': '""""""'}), "(host='127.0.0.1', name='addressbook', user='root', password='')\n", (226, 290), False, 'from fixture.orm import ORMFixture\n'), ((520, 547), 'random.choice'... |
import json
import logging
import os
import unittest
from dcm_spec_tools.spec_reader.edition_reader import EditionReader
from pydicom.dataset import Dataset
from dcm_spec_tools.tests.test_utils import json_fixture_path
from dcm_spec_tools.validator.iod_validator import IODValidator
class IODValidatorTest(unittest.... | [
"dcm_spec_tools.tests.test_utils.json_fixture_path",
"json.load",
"unittest.main",
"logging.disable",
"pydicom.dataset.Dataset",
"dcm_spec_tools.validator.iod_validator.IODValidator"
] | [((16402, 16417), 'unittest.main', 'unittest.main', ([], {}), '()\n', (16415, 16417), False, 'import unittest\n'), ((967, 1000), 'logging.disable', 'logging.disable', (['logging.CRITICAL'], {}), '(logging.CRITICAL)\n', (982, 1000), False, 'import logging\n'), ((1052, 1130), 'dcm_spec_tools.validator.iod_validator.IODVa... |
# tests/test_rms.py
import numpy as np
from kallisto.rmsd import rmsd
from tests.store import propanolIntermediate, propanolLowest
def test_rms():
mol1 = propanolLowest()
nat1 = mol1.get_number_of_atoms()
coord1 = mol1.get_positions()
mol2 = propanolIntermediate()
coord2 = mol2.get_positions()
... | [
"tests.store.propanolLowest",
"numpy.isclose",
"tests.store.propanolIntermediate",
"kallisto.rmsd.rmsd"
] | [((162, 178), 'tests.store.propanolLowest', 'propanolLowest', ([], {}), '()\n', (176, 178), False, 'from tests.store import propanolIntermediate, propanolLowest\n'), ((262, 284), 'tests.store.propanolIntermediate', 'propanolIntermediate', ([], {}), '()\n', (282, 284), False, 'from tests.store import propanolIntermediat... |
# -*- coding: utf-8 -*-
"""
Random forest modeling for radiomics feature selection and
for classification of high-risk histopathological markers of endometrial carcinoma
Not for clinical use.
SPDX-FileCopyrightText: 2021 Medical Physics Unit, McGill University, Montreal, CAN
SPDX-FileCopyrightText: 2021 <NAME>
... | [
"pandas.read_csv",
"matplotlib.pyplot.ylabel",
"sklearn.metrics.auc",
"sklearn.metrics.precision_score",
"numpy.argsort",
"numpy.array",
"sklearn.metrics.recall_score",
"sklearn.metrics.roc_auc_score",
"sklearn.metrics.roc_curve",
"sklearn.model_selection.StratifiedKFold",
"numpy.count_nonzero",... | [((1190, 1223), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (1213, 1223), False, 'import warnings\n'), ((1256, 1307), 'h5py.File', 'h5py.File', (['"""MYPROJECTFILEPATH/OUTPUT/label.h5"""', '"""r"""'], {}), "('MYPROJECTFILEPATH/OUTPUT/label.h5', 'r')\n", (1265, 1307), Fa... |
import os
import pathlib
default_configuration_path = os.path.join(os.path.dirname(os.path.dirname(__file__)), '.config.yaml')
custom_configuration_path = os.path.join(pathlib.Path.home(), '.jmm.cfg')
| [
"os.path.dirname",
"pathlib.Path.home"
] | [((169, 188), 'pathlib.Path.home', 'pathlib.Path.home', ([], {}), '()\n', (186, 188), False, 'import pathlib\n'), ((84, 109), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (99, 109), False, 'import os\n')] |
# coding: utf-8
"""
Thingsboard REST API
For instructions how to authorize requests please visit <a href='http://thingsboard.io/docs/reference/rest-api/'>REST API documentation page</a>.
OpenAPI spec version: 2.0
Contact: <EMAIL>
Generated by: https://github.com/swagger-api/swagger-codegen.git
""... | [
"unittest.main",
"swagger_client.apis.plugin_controller_api.PluginControllerApi"
] | [((2427, 2442), 'unittest.main', 'unittest.main', ([], {}), '()\n', (2440, 2442), False, 'import unittest\n'), ((684, 747), 'swagger_client.apis.plugin_controller_api.PluginControllerApi', 'swagger_client.apis.plugin_controller_api.PluginControllerApi', ([], {}), '()\n', (745, 747), False, 'import swagger_client\n')] |
#! /usr/bin/env python
import numpy as np
def runningMeanFast(x, N):
'''
Calculate the running mean of an array given a window.
Ref: http://stackoverflow.com/questions/13728392/moving-average-or-running-mean
Args:
x (array-like): Data array
N (int): Window width
Returns:
... | [
"numpy.ones"
] | [((411, 424), 'numpy.ones', 'np.ones', (['(N,)'], {}), '((N,))\n', (418, 424), True, 'import numpy as np\n')] |
import vim
from typing import Dict
from contextlib import contextmanager
# Conversion to the number or id.
from pytoy.ui_utils._converter import to_buffer_number, to_window_number, to_tabpage_number, to_window_id
def init_buffer(arg):
""" Empty the buffer.
"""
bufnum = to_buffer_number(arg)
if 0 < b... | [
"vim.eval",
"pytoy.ui_utils._converter.to_buffer_number",
"pytoy.ui_utils._converter.to_window_id",
"pytoy.ui_utils._converter.to_window_number",
"vim.command",
"pytoy.ui_utils._converter.to_tabpage_number"
] | [((286, 307), 'pytoy.ui_utils._converter.to_buffer_number', 'to_buffer_number', (['arg'], {}), '(arg)\n', (302, 307), False, 'from pytoy.ui_utils._converter import to_buffer_number, to_window_number, to_tabpage_number, to_window_id\n'), ((2085, 2109), 'pytoy.ui_utils._converter.to_tabpage_number', 'to_tabpage_number', ... |
from flask import render_template
from flask_login import login_required, current_user
from flask import request, jsonify
from werkzeug.exceptions import BadRequest
from app import db
from app.models.users import Queue, QueueMember, User
from app.routes.queue import bp
@bp.route('/queues', methods=['GET'])
@login_re... | [
"flask.render_template",
"app.db.session.commit",
"app.models.users.Queue",
"app.routes.queue.bp.route",
"app.models.users.QueueMember",
"app.models.users.User.query.filter_by",
"app.db.session.add",
"werkzeug.exceptions.BadRequest",
"app.models.users.QueueMember.query.filter_by",
"app.models.user... | [((274, 310), 'app.routes.queue.bp.route', 'bp.route', (['"""/queues"""'], {'methods': "['GET']"}), "('/queues', methods=['GET'])\n", (282, 310), False, 'from app.routes.queue import bp\n'), ((482, 533), 'app.routes.queue.bp.route', 'bp.route', (['"""/queues/<int:queue_id>"""'], {'methods': "['GET']"}), "('/queues/<int... |
# Generated by Django 2.0.6 on 2018-06-16 11:05
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('pylightcommon', '0002_load_fixtures'),
]
operations = [
migrations.AlterField(
model_name='connectedsystem',
name='l... | [
"django.db.models.GenericIPAddressField",
"django.db.models.CharField"
] | [((346, 431), 'django.db.models.GenericIPAddressField', 'models.GenericIPAddressField', ([], {'verbose_name': '"""Last known IP address of Connection"""'}), "(verbose_name='Last known IP address of Connection'\n )\n", (374, 431), False, 'from django.db import migrations, models\n'), ((565, 639), 'django.db.models.Ch... |
# Generated by Django 2.2.9 on 2020-01-19 17:08
from django.db import migrations, models
import django.db.models.deletion
import modelcluster.fields
class Migration(migrations.Migration):
dependencies = [
('wagtailimages', '0001_squashed_0021'),
('blog', '0005_blogtagindexpage'),
]
oper... | [
"django.db.models.AutoField",
"django.db.models.CharField",
"django.db.models.ForeignKey"
] | [((440, 533), 'django.db.models.AutoField', 'models.AutoField', ([], {'auto_created': '(True)', 'primary_key': '(True)', 'serialize': '(False)', 'verbose_name': '"""ID"""'}), "(auto_created=True, primary_key=True, serialize=False,\n verbose_name='ID')\n", (456, 533), False, 'from django.db import migrations, models\... |
import numpy as np
import matplotlib.pyplot as plt
# activate function
def step_func(y):
if y>0:
return 1
return 0
# loss function
def loss(y, t):
#return 0.5 * (np.sum(y-t)**2)
return 0.5*(y-t)
class Neuron :
def __init__(self, input_len):
#self.x = np.zeros(input_len) # input_v... | [
"numpy.random.rand",
"matplotlib.pyplot.plot",
"numpy.dot",
"numpy.random.randint",
"matplotlib.pyplot.show"
] | [((385, 410), 'numpy.random.rand', 'np.random.rand', (['input_len'], {}), '(input_len)\n', (399, 410), True, 'import numpy as np\n'), ((1327, 1389), 'numpy.random.randint', 'np.random.randint', (['max_purchase_num'], {'size': 'self.sweets_type_num'}), '(max_purchase_num, size=self.sweets_type_num)\n', (1344, 1389), Tru... |
import os
from os import system
import sys
import time
def has_root():
return os.geteuid() == 0
if not has_root():
print("[-] Please run as Root... Quitting!!")
sys.exit(1)
else:
print("[+] Running as Root")
print("[+] Installing Dependencies....")
time.sleep(2)
system("apt-get update")
system("apt... | [
"os.system",
"os.geteuid",
"time.sleep",
"sys.exit"
] | [((172, 183), 'sys.exit', 'sys.exit', (['(1)'], {}), '(1)\n', (180, 183), False, 'import sys\n'), ((266, 279), 'time.sleep', 'time.sleep', (['(2)'], {}), '(2)\n', (276, 279), False, 'import time\n'), ((282, 306), 'os.system', 'system', (['"""apt-get update"""'], {}), "('apt-get update')\n", (288, 306), False, 'from os ... |
import sys
import numpy as np
import pandas as pd
import dataset
import inflacao
import reports
def median_pivot_table_by_dttm(df):
return pd.pivot_table(df, index=['DTTM'], values=['TARIFA'], aggfunc=np.median)
def adjust_for_inflation(df, df_inflacao):
df['TARIFA_CORRIGIDA'] = df['TARIFA'] / df_inflacao[... | [
"pandas.Series",
"inflacao.load_dataset",
"pandas.pivot_table",
"sys.exit",
"dataset.load",
"dataset.filter_popular_seats"
] | [((146, 218), 'pandas.pivot_table', 'pd.pivot_table', (['df'], {'index': "['DTTM']", 'values': "['TARIFA']", 'aggfunc': 'np.median'}), "(df, index=['DTTM'], values=['TARIFA'], aggfunc=np.median)\n", (160, 218), True, 'import pandas as pd\n'), ((814, 863), 'pandas.Series', 'pd.Series', ([], {'index': 'years_list', 'data... |
import uuid
"""Class to create the cases s3 bucket for asset storage"""
class CaseBucket(object):
def __init__(self, case_number, region, client, resource):
self.region = region
self.case_number = case_number
self.client = client
self.s3 = resource.connect()
self.bucket = ... | [
"uuid.uuid4"
] | [((1226, 1238), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (1236, 1238), False, 'import uuid\n')] |
# Protean
from protean.core.command import BaseCommand
from protean.core.field.basic import String
class UserRegistrationCommand(BaseCommand):
email = String(required=True, max_length=250)
username = String(required=True, max_length=50)
password = String(required=True, max_length=255)
| [
"protean.core.field.basic.String"
] | [((157, 194), 'protean.core.field.basic.String', 'String', ([], {'required': '(True)', 'max_length': '(250)'}), '(required=True, max_length=250)\n', (163, 194), False, 'from protean.core.field.basic import String\n'), ((210, 246), 'protean.core.field.basic.String', 'String', ([], {'required': '(True)', 'max_length': '(... |
import logging
from django.apps import AppConfig
import large_image
logger = logging.getLogger(__name__)
class DjangoLargeImageConfig(AppConfig):
name = 'django_large_image'
verbose_name = 'Django Large Image'
default_auto_field = 'django.db.models.BigAutoField'
def ready(self):
# Set up ca... | [
"logging.getLogger",
"large_image.config.setConfig"
] | [((79, 106), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (96, 106), False, 'import logging\n'), ((472, 527), 'large_image.config.setConfig', 'large_image.config.setConfig', (['"""cache_backend"""', '"""django"""'], {}), "('cache_backend', 'django')\n", (500, 527), False, 'import large_... |
import tensorflow as tf
import numpy as np
import argparse
ap = argparse.ArgumentParser()
ap.add_argument("-m", "--model_path", type=str, default='model.tflite', help="path to tflite model")
args = ap.parse_args()
# Load MNIST dataset
mnist = tf.keras.datasets.mnist
(train_images, train_labels), (test_images, test_la... | [
"numpy.sum",
"numpy.expand_dims",
"argparse.ArgumentParser"
] | [((65, 90), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (88, 90), False, 'import argparse\n'), ((543, 575), 'numpy.expand_dims', 'np.expand_dims', (['train_images', '(-1)'], {}), '(train_images, -1)\n', (557, 575), True, 'import numpy as np\n'), ((590, 621), 'numpy.expand_dims', 'np.expand_d... |
"""Estimation of lambdaN"""
import matplotlib.pyplot as plt
import networkx as nx
from numpy import *
import scipy
def maximum_eigen():
list1 = []
list2 = []
for i in range(10, 31):
for j in range(0, 10):
G1 = nx.barabasi_albert_graph(500, i, seed=j)
degree_sequence = [d f... | [
"matplotlib.pyplot.savefig",
"networkx.barabasi_albert_graph",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"scipy.linalg.eig",
"networkx.laplacian_matrix",
"matplotlib.pyplot.scatter",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.show"
] | [((777, 869), 'matplotlib.pyplot.scatter', 'plt.scatter', (['maxeigen', 'estimation'], {'c': '"""b"""', 's': '(6.0)', 'label': '"""Estimation of $\\\\lambda^{(N)}$"""'}), "(maxeigen, estimation, c='b', s=6.0, label=\n 'Estimation of $\\\\lambda^{(N)}$')\n", (788, 869), True, 'import matplotlib.pyplot as plt\n'), ((8... |
import os
from .settings import *
BASE_DIR = os.path.dirname(os.path.dirname(__file__))
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'db.sqlite3'),
}
}
AUTH_PASSWORD_VALIDATORS = []
#can use simple passwords. do not carry over production
... | [
"os.path.dirname",
"os.path.join"
] | [((62, 87), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (77, 87), False, 'import os\n'), ((185, 221), 'os.path.join', 'os.path.join', (['BASE_DIR', '"""db.sqlite3"""'], {}), "(BASE_DIR, 'db.sqlite3')\n", (197, 221), False, 'import os\n')] |
# description: scan motifs and get motif sets (co-occurring motifs) back
import os
import json
import h5py
import glob
import logging
from tronn.datalayer import H5DataLoader
from tronn.interpretation.inference import run_inference
from tronn.util.h5_utils import add_pwm_names_to_h5
from tronn.util.h5_utils import co... | [
"logging.getLogger",
"tronn.interpretation.inference.run_inference",
"tronn.datalayer.H5DataLoader",
"tronn.util.formats.write_to_json",
"tronn.util.h5_utils.add_pwm_names_to_h5"
] | [((503, 530), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (520, 530), False, 'import logging\n'), ((883, 902), 'tronn.interpretation.inference.run_inference', 'run_inference', (['args'], {}), '(args)\n', (896, 902), False, 'from tronn.interpretation.inference import run_inference\n'), ... |
import torch
import numpy as np
from PIL import Image
from torchvision import transforms
import h5py
import matplotlib.pyplot as plt
import random
from torch.utils.data import Dataset, DataLoader, random_split
import torch.nn as nn
import torch.optim as optim
import os
from tqdm import tqdm
import time
import pickle
i... | [
"torch.nn.CrossEntropyLoss",
"torch.nn.MSELoss",
"matplotlib.pyplot.imshow",
"numpy.mean",
"os.path.isdir",
"umetrics.calculate",
"os.mkdir",
"torch.split",
"numpy.argmax",
"numpy.squeeze",
"matplotlib.pyplot.title",
"time.time",
"torch.cuda.empty_cache",
"matplotlib.pyplot.show",
"torch... | [((565, 577), 'torch.nn.MSELoss', 'nn.MSELoss', ([], {}), '()\n', (575, 577), True, 'import torch.nn as nn\n'), ((1041, 1133), 'torch.utils.data.DataLoader', 'DataLoader', (['train_set'], {'batch_size': 'self.batch_size', 'num_workers': 'num_workers', 'shuffle': '(True)'}), '(train_set, batch_size=self.batch_size, num_... |
#!/usr/bin/env python
#
# Author: <NAME> <<EMAIL>>
#
'''
This example shows how to save the DF integrals in one calculation and use the
integrals in another one. This can be particularly useful in all-electron PBC
calculations. The time-consuming DF integral generation can be done once and
reused many times.
'''
im... | [
"pyscf.df.incore.cholesky_eri",
"pyscf.scf.RHF",
"pyscf.gto.M",
"pyscf.pbc.dft.RKS",
"tempfile.NamedTemporaryFile",
"pyscf.pbc.gto.Cell"
] | [((441, 470), 'tempfile.NamedTemporaryFile', 'tempfile.NamedTemporaryFile', ([], {}), '()\n', (468, 470), False, 'import tempfile\n'), ((823, 871), 'pyscf.gto.M', 'gto.M', ([], {'atom': '"""N 0 0 0; N 0 0 1.2"""', 'basis': '"""ccpvdz"""'}), "(atom='N 0 0 0; N 0 0 1.2', basis='ccpvdz')\n", (828, 871), False, 'from pyscf... |
from typing import Any, List, Optional, Dict
from pydantic import BaseModel, validator
from .container_log_wait_parameters import LogWaitParameter
from .volume import VolumeMapping
from .container_http_wait_parameter import HttpWaitParameter
class Service(BaseModel):
name: str
image: str
exposed_ports: Li... | [
"pydantic.validator"
] | [((705, 722), 'pydantic.validator', 'validator', (['"""name"""'], {}), "('name')\n", (714, 722), False, 'from pydantic import BaseModel, validator\n'), ((864, 882), 'pydantic.validator', 'validator', (['"""image"""'], {}), "('image')\n", (873, 882), False, 'from pydantic import BaseModel, validator\n')] |
import os
import setuptools
with open("README.md", "r") as f:
long_description = f.read()
lib_path = os.path.dirname(os.path.realpath(__file__))
requirements_path = os.path.join(lib_path, 'requirements.txt')
install_requires = []
if os.path.isfile(requirements_path):
with open(requirements_path) as f:
... | [
"os.path.isfile",
"os.path.realpath",
"setuptools.find_packages",
"os.path.join"
] | [((171, 213), 'os.path.join', 'os.path.join', (['lib_path', '"""requirements.txt"""'], {}), "(lib_path, 'requirements.txt')\n", (183, 213), False, 'import os\n'), ((240, 273), 'os.path.isfile', 'os.path.isfile', (['requirements_path'], {}), '(requirements_path)\n', (254, 273), False, 'import os\n'), ((123, 149), 'os.pa... |
import matplotlib.pyplot as plt
from matplotlib.lines import Line2D
import numpy as np
from ahfhalotools.objects import Cluster
import ahfhalotools.filetools as ft
import ahfhalotools.analysis as analysis
## -----------Load Cluster Instances--------------##
#define base file name (these are for full files)
fileNameBa... | [
"ahfhalotools.filetools.getMusZs",
"ahfhalotools.filetools.getSnapNumToZMapGiz",
"ahfhalotools.objects.Cluster",
"numpy.array",
"matplotlib.pyplot.tight_layout",
"ahfhalotools.analysis.tfromz",
"ahfhalotools.filetools.getSnapNumToZMapGX",
"matplotlib.pyplot.subplots",
"numpy.arange",
"matplotlib.p... | [((643, 661), 'numpy.arange', 'np.arange', (['(97)', '(129)'], {}), '(97, 129)\n', (652, 661), True, 'import numpy as np\n'), ((674, 692), 'numpy.arange', 'np.arange', (['(97)', '(129)'], {}), '(97, 129)\n', (683, 692), True, 'import numpy as np\n'), ((779, 798), 'ahfhalotools.filetools.getMusZs', 'ft.getMusZs', (['mus... |
import logging
import os
import requests
from typing import Any, List, Optional, Text, Dict
import rasa.utils.endpoints as endpoints_utils
from rasa.shared.nlu.constants import ENTITIES, TEXT
from rasa.nlu.config import RasaNLUModelConfig
from rasa.nlu.extractors.extractor import EntityExtractor
from rasa.nlu.model im... | [
"logging.getLogger",
"os.environ.get"
] | [((430, 457), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (447, 457), False, 'import logging\n'), ((2606, 2647), 'os.environ.get', 'os.environ.get', (['"""RECOGNIZERS_SERVICE_URL"""'], {}), "('RECOGNIZERS_SERVICE_URL')\n", (2620, 2647), False, 'import os\n')] |
import geopandas as gpd
import pandas as pd
import xarray as xr
import numpy as np
from pathlib import Path
import sys
import netCDF4
import datetime
import metpy.calc as mpcalc
from metpy.units import units
# prsr = 101.3 * (((293.0-0.0065*Hru_elev_meters(i))/293.0)**5.26)
def std_pres(elev):
return 101.325 * ((... | [
"numpy.ma.average",
"metpy.calc.relative_humidity_from_specific_humidity",
"geopandas.read_file",
"pathlib.Path",
"numpy.average",
"pandas.read_csv",
"numpy.asarray",
"datetime.datetime.now",
"numpy.zeros",
"numpy.isnan",
"metpy.units.units",
"sys.exit",
"metpy.units.units.Quantity",
"nump... | [((1163, 1198), 'numpy.ma.average', 'np.ma.average', (['mdata'], {'weights': 'wghts'}), '(mdata, weights=wghts)\n', (1176, 1198), True, 'import numpy as np\n'), ((410, 441), 'numpy.average', 'np.average', (['data'], {'weights': 'wghts'}), '(data, weights=wghts)\n', (420, 441), True, 'import numpy as np\n'), ((1136, 115... |
#!/usr/bin/python3
# -*- coding: utf-8 -*-
## Autor: <NAME>
import numpy as np
from bubble2 import Bubble2
from bworld import Bworld
n = 1000
bubbles = []
bubbles.append(Bubble2(np.random.rand(n, 3) * 10, np.zeros((n, 3)),
radius = (np.random.rand(n) / 6), color = (0.5, 0.8, 1.0, 0.8)))
testworld = B... | [
"numpy.zeros",
"numpy.asarray",
"numpy.random.rand"
] | [((207, 223), 'numpy.zeros', 'np.zeros', (['(n, 3)'], {}), '((n, 3))\n', (215, 223), True, 'import numpy as np\n'), ((348, 387), 'numpy.asarray', 'np.asarray', (['[[0, 20], [0, 10], [0, 10]]'], {}), '([[0, 20], [0, 10], [0, 10]])\n', (358, 387), True, 'import numpy as np\n'), ((180, 200), 'numpy.random.rand', 'np.rando... |
"""
This module provides helpers that describe some aspect of a layout.
The two public classes are:
* BasisBladeOrder
* BasisVectorIds
"""
from typing import TypeVar, Generic, Sequence, Tuple, List, Optional
import numpy as np
import functools
import operator
from . import _numba_utils
from ._bit_helpers import co... | [
"functools.reduce",
"numpy.array",
"numpy.empty",
"numpy.array_equal",
"numpy.bitwise_or.reduce",
"numpy.full",
"typing.TypeVar"
] | [((4666, 4680), 'typing.TypeVar', 'TypeVar', (['"""IdT"""'], {}), "('IdT')\n", (4673, 4680), False, 'from typing import TypeVar, Generic, Sequence, Tuple, List, Optional\n'), ((1879, 1907), 'numpy.array', 'np.array', (['bitmaps'], {'dtype': 'int'}), '(bitmaps, dtype=int)\n', (1887, 1907), True, 'import numpy as np\n'),... |
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not u... | [
"pytest.mark.parametrize",
"tests.comparison.db_connection.PostgresqlConnection",
"pytest.raises",
"fake_query.FakeColumn"
] | [((2367, 3216), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""unittest_cursor_map"""', '[{\'class\': ImpalaCursor, \'sql\': {\'two_cols\':\n \'CREATE TABLE two_cols (col1 INT, col2 INT)\', \'one_pk\':\n """CREATE TABLE one_pk (col1 INT, col2 INT, PRIMARY KEY (col1))\nPARTITION BY HASH (col1) PARTITI... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Fri Mar 27 02:08:15 2020
@author: sss
Naive Bayes Algorithm
Given a review is positive what is the probability an individual word is positive
P(class|data) = (P(data|class) * P(class)) / P(data)
P(class|data) = probability of class given the provided data... | [
"nltk.corpus.stopwords.words",
"nltk.word_tokenize",
"sklearn.model_selection.train_test_split",
"collections.Counter",
"tensorflow.keras.layers.Dense",
"tensorflow.keras.models.Sequential"
] | [((2227, 2251), 'nltk.word_tokenize', 'nltk.word_tokenize', (['text'], {}), '(text)\n', (2245, 2251), False, 'import nltk\n'), ((3254, 3263), 'collections.Counter', 'Counter', ([], {}), '()\n', (3261, 3263), False, 'from collections import Counter\n'), ((3276, 3285), 'collections.Counter', 'Counter', ([], {}), '()\n', ... |
#!/usr/bin/python
# Telnet handler concrete class using green threads with eventlet
import eventlet
from telnetsrvlib import TelnetHandlerBase, command
class TelnetHandler(TelnetHandlerBase):
"A telnet server handler using Gevent"
def __init__(self, request, client_address, server):
# Create a green ... | [
"eventlet.sleep",
"eventlet.spawn",
"telnetsrvlib.TelnetHandlerBase.setup",
"telnetsrvlib.TelnetHandlerBase.__init__",
"eventlet.queue.Queue",
"telnetsrvlib.TelnetHandlerBase.finish"
] | [((368, 390), 'eventlet.queue.Queue', 'eventlet.queue.Queue', ([], {}), '()\n', (388, 390), False, 'import eventlet\n'), ((441, 506), 'telnetsrvlib.TelnetHandlerBase.__init__', 'TelnetHandlerBase.__init__', (['self', 'request', 'client_address', 'server'], {}), '(self, request, client_address, server)\n', (467, 506), F... |
from __future__ import print_function
""" Demonstrates data-dependent color """
import os.path
from bokeh.objects import (Plot, DataRange1d, LinearAxis,
ColumnDataSource, Glyph, PanTool, WheelZoomTool)
from bokeh.glyphs import Circle
from bokeh import session
source = ColumnDataSource(
data = dict(
x... | [
"bokeh.session.HTMLFileSession",
"bokeh.objects.Glyph",
"bokeh.objects.WheelZoomTool",
"bokeh.objects.LinearAxis",
"bokeh.objects.PanTool",
"bokeh.glyphs.Circle",
"bokeh.objects.Plot"
] | [((571, 640), 'bokeh.glyphs.Circle', 'Circle', ([], {'x': '"""x"""', 'y': '"""y"""', 'size': '(15)', 'fill_color': '"""color"""', 'line_color': '"""black"""'}), "(x='x', y='y', size=15, fill_color='color', line_color='black')\n", (577, 640), False, 'from bokeh.glyphs import Circle\n'), ((1330, 1403), 'bokeh.objects.Gly... |
import csv
time_data_list = []
ipc_data_list = []
start = 2
end = 40
tests_per_run = end - start + 1
number_of_runs = 20
filename = 'pstr_perf_analysis/pstr-data2.trace'
time_csv = 'pstr_perf_analysis/time_plot_data2.csv'
ipc_csv = 'pstr_perf_analysis/ipc_plot_data2.csv'
with open(filename, 'r') as file:
for x ... | [
"csv.writer"
] | [((3083, 3100), 'csv.writer', 'csv.writer', (['file1'], {}), '(file1)\n', (3093, 3100), False, 'import csv\n'), ((3200, 3217), 'csv.writer', 'csv.writer', (['file2'], {}), '(file2)\n', (3210, 3217), False, 'import csv\n')] |
from django.http import JsonResponse
from django.utils.decorators import method_decorator
from django.contrib.auth.decorators import login_required
from mighty.views import DetailView, ListView
from mighty.applications.tenant.views.tenant.base import TenantBase
@method_decorator(login_required, name='dispatch')
class ... | [
"django.utils.decorators.method_decorator",
"django.http.JsonResponse"
] | [((264, 313), 'django.utils.decorators.method_decorator', 'method_decorator', (['login_required'], {'name': '"""dispatch"""'}), "(login_required, name='dispatch')\n", (280, 313), False, 'from django.utils.decorators import method_decorator\n'), ((563, 612), 'django.utils.decorators.method_decorator', 'method_decorator'... |
from django.contrib import admin
from .models import ProjectSubmission, LeaderboardSettings
import logging
logger = logging.getLogger(__name__)
def recompute_mean_average_precision(modeladmin, request, queryset):
if not ProjectSubmission.objects.filter(is_solution=True).exists():
return
for submissi... | [
"logging.getLogger",
"django.contrib.admin.site.register"
] | [((119, 146), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (136, 146), False, 'import logging\n'), ((1580, 1642), 'django.contrib.admin.site.register', 'admin.site.register', (['ProjectSubmission', 'ProjectSubmissionAdmin'], {}), '(ProjectSubmission, ProjectSubmissionAdmin)\n', (1599, 1... |
""" tkVideo: Python module for playing videos (without sound) inside tkinter Label widget using Pillow and imageio
Copyright © 2020 <NAME> <<EMAIL>>
Released under the terms of the MIT license (https://opensource.org/licenses/MIT) as described in LICENSE.md
"""
try:
import Tkinter as tk # for Python2 (although ... | [
"threading.Thread",
"PIL.Image.fromarray",
"imageio.get_reader"
] | [((1464, 1488), 'imageio.get_reader', 'imageio.get_reader', (['path'], {}), '(path)\n', (1482, 1488), False, 'import imageio\n'), ((2230, 2305), 'threading.Thread', 'threading.Thread', ([], {'target': 'self.load', 'args': '(self.path, self.label, self.loop)'}), '(target=self.load, args=(self.path, self.label, self.loop... |
from __future__ import absolute_import
from builtins import next
from builtins import range
import os
import math
import os.path as op
import re
import shutil
from nipype.interfaces.base import (
TraitedSpec, traits, BaseInterface, File,
Directory, CommandLineInputSpec, CommandLine, DynamicTraitedSpec,
Base... | [
"nipype.interfaces.base.OutputMultiPath",
"itertools.chain",
"nipype.interfaces.base.InputMultiPath",
"re.compile",
"nipype.interfaces.base.traits.Bool",
"numpy.array",
"arcana.exceptions.ArcanaUsageError",
"math.log10",
"nipype.interfaces.base.Directory",
"os.listdir",
"nipype.interfaces.base.t... | [((935, 968), 'os.path.join', 'op.join', (['bash_resources', '"""zip.sh"""'], {}), "(bash_resources, 'zip.sh')\n", (942, 968), True, 'import os.path as op\n'), ((982, 1017), 'os.path.join', 'op.join', (['bash_resources', '"""targz.sh"""'], {}), "(bash_resources, 'targz.sh')\n", (989, 1017), True, 'import os.path as op\... |
from typing import Tuple, Optional
import numpy as np
import scipy.stats
import matplotlib.pyplot as plt
def beta_a_b_from_mode_concentration(mode: float, concentration: float) -> Tuple[float, float]:
"""
Computes the shape parameters, alpha and beta, of a beta distribution given its mode and concentration.
Para... | [
"matplotlib.pyplot.figure",
"numpy.sqrt"
] | [((1699, 1711), 'matplotlib.pyplot.figure', 'plt.figure', ([], {}), '()\n', (1709, 1711), True, 'import matplotlib.pyplot as plt\n'), ((2621, 2633), 'matplotlib.pyplot.figure', 'plt.figure', ([], {}), '()\n', (2631, 2633), True, 'import matplotlib.pyplot as plt\n'), ((2995, 3007), 'matplotlib.pyplot.figure', 'plt.figur... |
import re
EMAIL_REGEX = re.compile('(?:[a-z0-9!#$%&\'*+\\/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&\'*+\\/=?^_`{|}~-]+)*|"(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21\\x23-\\x5b\\x5d-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\\[(?:(?:(2(5[0-5]|[0-4][0... | [
"re.compile"
] | [((25, 543), 're.compile', 're.compile', (['"""(?:[a-z0-9!#$%&\'*+\\\\/=?^_`{|}~-]+(?:\\\\.[a-z0-9!#$%&\'*+\\\\/=?^_`{|}~-]+)*|"(?:[\\\\x01-\\\\x08\\\\x0b\\\\x0c\\\\x0e-\\\\x1f\\\\x21\\\\x23-\\\\x5b\\\\x5d-\\\\x7f]|\\\\\\\\[\\\\x01-\\\\x09\\\\x0b\\\\x0c\\\\x0e-\\\\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\\\.)+[a... |
import os
from myhdl import *
#from _hdmi_ref_filelist import filelist
filist = []
def prep_cosim(
clock,
reset,
hdmi_src=None,
hdmi_snk=None,
args=None):
"""
"""
global filelist
files = filelist + ['tb_hdmi.v']
print("compiling")
cmd = "iverilog -o hdm... | [
"os.system",
"os.path.exists",
"os.makedirs"
] | [((360, 374), 'os.system', 'os.system', (['cmd'], {}), '(cmd)\n', (369, 374), False, 'import os\n'), ((387, 408), 'os.path.exists', 'os.path.exists', (['"""vcd"""'], {}), "('vcd')\n", (401, 408), False, 'import os\n'), ((418, 436), 'os.makedirs', 'os.makedirs', (['"""vcd"""'], {}), "('vcd')\n", (429, 436), False, 'impo... |
from django.conf import settings
from django.core.exceptions import ImproperlyConfigured
class Configuration(object):
def __init__(self, **kwargs):
self.defaults = kwargs
def __getattr__(self, k):
try:
return getattr(settings, k)
except AttributeError:
if k i... | [
"django.core.exceptions.ImproperlyConfigured"
] | [((395, 457), 'django.core.exceptions.ImproperlyConfigured', 'ImproperlyConfigured', (["('django-secure requires %s setting.' % k)"], {}), "('django-secure requires %s setting.' % k)\n", (415, 457), False, 'from django.core.exceptions import ImproperlyConfigured\n')] |
import os
import os.path as op
import sys
import json
import string
import numpy as np
import PropertySI as ps
#import tk
thispath = op.abspath(op.dirname(__file__))
datapath = op.join(thispath, 'PropData')
suffix = '.json'
pun = string.punctuation
current = ps.prop_names()
#Takes the dict and makes it key value pai... | [
"os.listdir",
"os.path.join",
"os.path.dirname",
"PropertySI.prop_names",
"numpy.vstack",
"numpy.genfromtxt",
"json.dump"
] | [((178, 207), 'os.path.join', 'op.join', (['thispath', '"""PropData"""'], {}), "(thispath, 'PropData')\n", (185, 207), True, 'import os.path as op\n'), ((260, 275), 'PropertySI.prop_names', 'ps.prop_names', ([], {}), '()\n', (273, 275), True, 'import PropertySI as ps\n'), ((145, 165), 'os.path.dirname', 'op.dirname', (... |
import logging
from spaceone.inventory.libs.connector import GoogleCloudConnector
from spaceone.inventory.error import *
from pprint import pprint
__all__ = ['CloudSQLConnector']
_LOGGER = logging.getLogger(__name__)
class CloudSQLConnector(GoogleCloudConnector):
google_client_service = 'sqladmin'
version ... | [
"logging.getLogger"
] | [((191, 218), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (208, 218), False, 'import logging\n')] |
import logging
from tracker.common import settings
MSG_FMT = "{levelname:<8} [{asctime},{msecs:3.0f}] [PID:{process}] " \
"[{filename}:{funcName}():{lineno}] {message}"
DATE_FMT = "%d.%m.%Y %H:%M:%S"
formatter = logging.Formatter(
fmt=MSG_FMT, datefmt=DATE_FMT, style='{'
)
stream_handler = logging.St... | [
"logging.getLogger",
"logging.Formatter",
"logging.StreamHandler"
] | [((226, 285), 'logging.Formatter', 'logging.Formatter', ([], {'fmt': 'MSG_FMT', 'datefmt': 'DATE_FMT', 'style': '"""{"""'}), "(fmt=MSG_FMT, datefmt=DATE_FMT, style='{')\n", (243, 285), False, 'import logging\n'), ((310, 333), 'logging.StreamHandler', 'logging.StreamHandler', ([], {}), '()\n', (331, 333), False, 'import... |
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.test import TestCase
from .factories import ProxyGrantingTicketFactory
from .factories import ProxyTicketFactory
from .factories import ServiceTicketFactory
from .utils import parse
from mama_cas.exceptions import InvalidTicket
from mama_cas... | [
"mama_cas.exceptions.InvalidTicket",
"mama_cas.response.ProxyResponse",
"mama_cas.response.ValidationResponse",
"mama_cas.response.SamlValidationResponse"
] | [((784, 876), 'mama_cas.response.ValidationResponse', 'ValidationResponse', ([], {'context': "{'ticket': self.st, 'error': None}", 'content_type': '"""text/xml"""'}), "(context={'ticket': self.st, 'error': None}, content_type\n ='text/xml')\n", (802, 876), False, 'from mama_cas.response import ValidationResponse\n')... |
import socket
from collections import defaultdict
from threading import Thread
from time import time, sleep
from typing import Union, List
from netaddr import IPNetwork
from lib.core.tello_stats import TelloStats
from lib.networking.subnet import get_subnets
class TelloKernel(object):
# TODO: Use logging, not a... | [
"lib.core.tello_device.Tello",
"socket.socket",
"time.sleep",
"collections.defaultdict",
"threading.Thread",
"lib.networking.subnet.get_subnets",
"time.time",
"netaddr.IPNetwork"
] | [((553, 601), 'socket.socket', 'socket.socket', (['socket.AF_INET', 'socket.SOCK_DGRAM'], {}), '(socket.AF_INET, socket.SOCK_DGRAM)\n', (566, 601), False, 'import socket\n'), ((776, 811), 'threading.Thread', 'Thread', ([], {'target': 'self._receive_thread'}), '(target=self._receive_thread)\n', (782, 811), False, 'from ... |
import gc
import os
import logging
import numpy as np
import tensorflow as tf
from nlp_toolkit.classifier import Classifier
from nlp_toolkit.labeler import Labeler
from nlp_toolkit.data import Dataset
from nlp_toolkit.config import YParams
logging.basicConfig(level=logging.INFO)
try:
import GPUtil
from keras.... | [
"logging.basicConfig",
"GPUtil.getGPUs",
"gc.disable",
"tensorflow.Session",
"GPUtil.getAvailable",
"tensorflow.ConfigProto",
"logging.info"
] | [((241, 280), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (260, 280), False, 'import logging\n'), ((982, 994), 'gc.disable', 'gc.disable', ([], {}), '()\n', (992, 994), False, 'import gc\n'), ((423, 458), 'GPUtil.getAvailable', 'GPUtil.getAvailable', ([], {'o... |
"""Tasks for mail app"""
import textwrap
from django.conf import settings
from celery import shared_task
from mail import api
from mail.api import render_email_templates, context_for_video
from mail.constants import STATUS_TO_NOTIFICATION, STATUSES_THAT_TRIGGER_DEBUG_EMAIL
from ui.utils import has_common_lists, get_m... | [
"ui.utils.get_moira_client",
"textwrap.dedent",
"odl_video.logging.getLogger",
"mail.api.context_for_video",
"mail.api.MailgunClient.send_batch",
"celery.shared_task",
"ui.models.Video.objects.get",
"mail.constants.STATUS_TO_NOTIFICATION.keys",
"mail.api.MailgunClient.send_individual_email",
"ui.u... | [((369, 396), 'odl_video.logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (386, 396), False, 'from odl_video import logging\n'), ((2868, 2890), 'celery.shared_task', 'shared_task', ([], {'bind': '(True)'}), '(bind=True)\n', (2879, 2890), False, 'from celery import shared_task\n'), ((696, 714... |
"""
Class :py:class:`CGWMain` is a QWidget for interactive image
============================================================
Usage ::
import sys
from PyQt5.QtWidgets import QApplication
from psdaq.control_gui.CGWMain import CGWMain
app = QApplication(sys.argv)
w = CGWMain(None, app)
w.show()
... | [
"logging.getLogger",
"psdaq.control_gui.CGConfigParameters.cp.saveParametersInFile",
"PyQt5.QtCore.QSize",
"PyQt5.QtWidgets.QApplication",
"psdaq.control_gui.CGWMainTabs.CGWMainTabs",
"psdaq.control_gui.QWIcons.icon.set_icons",
"psdaq.control_gui.CGWMainConfiguration.CGWMainConfiguration",
"zmq.utils.... | [((578, 605), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (595, 605), False, 'import logging\n'), ((15832, 15854), 'PyQt5.QtWidgets.QApplication', 'QApplication', (['sys.argv'], {}), '(sys.argv)\n', (15844, 15854), False, 'from PyQt5.QtWidgets import QApplication\n'), ((2073, 2179), 'p... |
# -*- coding: utf-8 -*-
import unittest
from unittest import mock
from thumbnails import get_thumbnail
from thumbnails.conf import settings
from thumbnails.images import Thumbnail
from .utils import override_settings
class GetThumbnailTestCase(unittest.TestCase):
@mock.patch('{}.get'.format(settings.THUMBNAIL_... | [
"unittest.mock.call",
"unittest.mock.patch",
"thumbnails.get_thumbnail"
] | [((590, 661), 'unittest.mock.patch', 'mock.patch', (['"""thumbnails.engines.base.BaseThumbnailEngine.get_thumbnail"""'], {}), "('thumbnails.engines.base.BaseThumbnailEngine.get_thumbnail')\n", (600, 661), False, 'from unittest import mock\n'), ((1402, 1473), 'unittest.mock.patch', 'mock.patch', (['"""thumbnails.engines... |
from Spellscore import score
from nltk.corpus import words
def embed(word):
"""
return similarity encoding across the vocabulary
"""
word_array = words.words()
embedding = [0]*len(word_array)
for i in range(len(word_array)):
embedding[i] = score(word, word_array[i])
return embeddi... | [
"nltk.corpus.words.words",
"Spellscore.score"
] | [((165, 178), 'nltk.corpus.words.words', 'words.words', ([], {}), '()\n', (176, 178), False, 'from nltk.corpus import words\n'), ((275, 301), 'Spellscore.score', 'score', (['word', 'word_array[i]'], {}), '(word, word_array[i])\n', (280, 301), False, 'from Spellscore import score\n')] |
from django.conf.urls import url
import api.views
urlpatterns = [
url(r'^series/detail', api.views.series_detail, name="api_series_detail"),
url(r'^series/find', api.views.series_find, name="api_series_find"),
url(r'^timeseries', api.views.time_series, name="api_time_series"),
]
| [
"django.conf.urls.url"
] | [((72, 144), 'django.conf.urls.url', 'url', (['"""^series/detail"""', 'api.views.series_detail'], {'name': '"""api_series_detail"""'}), "('^series/detail', api.views.series_detail, name='api_series_detail')\n", (75, 144), False, 'from django.conf.urls import url\n'), ((151, 217), 'django.conf.urls.url', 'url', (['"""^s... |
# -*- coding: utf-8 -*-
"""\
ExaWind Command Line Interface (CLI)
------------------------------------
"""
import logging
import argparse
import shlex
from ..config.config import config_manager, ExawindConfig
from ..version import full_version
_lgr = logging.getLogger(__name__)
def get_epilog():
"""Return the e... | [
"logging.getLogger",
"shlex.split",
"argparse.ArgumentParser"
] | [((254, 281), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (271, 281), False, 'import logging\n'), ((1322, 1410), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': 'self.description', 'epilog': 'self.epilog', 'prog': 'name'}), '(description=self.description, epi... |
import os
import re
import glob
import numpy as np
import matplotlib.pylab as plt
import matplotlib
from scipy.spatial import ConvexHull
from scipy.interpolate import interp1d
from itertools import chain, count
from collections import defaultdict
from os import makedirs
from os.path import isdir, isfile,... | [
"itertools.chain",
"matplotlib.pylab.xlim",
"re.compile",
"scipy.interpolate.interp1d",
"numpy.array",
"matplotlib.pylab.show",
"numpy.arange",
"matplotlib.pylab.figure",
"matplotlib.pylab.legend",
"matplotlib.pylab.title",
"numpy.max",
"matplotlib.pylab.rcParams.update",
"numpy.min",
"num... | [((3885, 3912), 're.compile', 're.compile', (['"""\\\\S+\\\\s+.*=.*"""'], {}), "('\\\\S+\\\\s+.*=.*')\n", (3895, 3912), False, 'import re\n'), ((3931, 3959), 're.compile', 're.compile', (['""".*(m)=(\\\\d+).*"""'], {}), "('.*(m)=(\\\\d+).*')\n", (3941, 3959), False, 'import re\n'), ((3977, 4005), 're.compile', 're.comp... |
#! /usr/bin/python
# -*- coding: utf-8 -*-
#
# gdbm_create.py
#
# Jul/13/2010
import sys
import string
import anydbm
#
sys.path.append ('/var/www/uchida/data_base/common/python_common')
#
from dbm_manipulate import dbm_disp_proc,dbm_update_proc
# -------------------------------------------------------------
print (... | [
"dbm_manipulate.dbm_disp_proc",
"sys.path.append",
"anydbm.open"
] | [((123, 188), 'sys.path.append', 'sys.path.append', (['"""/var/www/uchida/data_base/common/python_common"""'], {}), "('/var/www/uchida/data_base/common/python_common')\n", (138, 188), False, 'import sys\n'), ((381, 406), 'anydbm.open', 'anydbm.open', (['db_name', '"""c"""'], {}), "(db_name, 'c')\n", (392, 406), False, ... |
# -*- coding: utf-8 -*-
# Time : 2021/7/30 4:01
# Author : QIN2DIM
# Github : https://github.com/QIN2DIM
# Description: Adaptive acquisition framework
import csv
import json
import os
import time
from datetime import datetime
from selenium.common.exceptions import (
ElementClickInterceptedException,
... | [
"os.path.exists",
"json.loads",
"BusinessCentralLayer.setting.logger.error",
"csv.writer",
"BusinessCentralLayer.setting.logger.catch",
"os.path.join",
"time.sleep",
"datetime.datetime.now",
"time.time"
] | [((5191, 5205), 'BusinessCentralLayer.setting.logger.catch', 'logger.catch', ([], {}), '()\n', (5203, 5205), False, 'from BusinessCentralLayer.setting import logger, SERVER_DIR_DATABASE_CACHE\n'), ((4710, 4766), 'os.path.join', 'os.path.join', (['SERVER_DIR_DATABASE_CACHE', 'output_path_csv'], {}), '(SERVER_DIR_DATABAS... |
__all__ = ['GeneratorContentStyle']
from collections import defaultdict
import torch
from hidt.networks.generators import GeneratorBase
class GeneratorContentStyle(GeneratorBase):
# AdaIN auto-encoder architecture
def __init__(self, params):
super().__init__(params)
self.style_dim = self.d... | [
"collections.defaultdict",
"torch.cat"
] | [((1931, 1948), 'collections.defaultdict', 'defaultdict', (['list'], {}), '(list)\n', (1942, 1948), False, 'from collections import defaultdict\n'), ((2400, 2420), 'torch.cat', 'torch.cat', (['map_value'], {}), '(map_value)\n', (2409, 2420), False, 'import torch\n'), ((743, 760), 'torch.cat', 'torch.cat', (['styles'], ... |
# Generated by Django 3.2.6 on 2021-08-14 00:36
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
('cars... | [
"django.db.models.EmailField",
"django.db.models.DateField",
"django.db.models.TextField",
"django.db.models.ForeignKey",
"django.db.models.BigAutoField",
"django.db.migrations.swappable_dependency",
"django.db.models.CharField"
] | [((247, 304), 'django.db.migrations.swappable_dependency', 'migrations.swappable_dependency', (['settings.AUTH_USER_MODEL'], {}), '(settings.AUTH_USER_MODEL)\n', (278, 304), False, 'from django.db import migrations, models\n'), ((470, 566), 'django.db.models.BigAutoField', 'models.BigAutoField', ([], {'auto_created': '... |
'''
This script will sort and move the files in the directory
(the alphabetical order).
'apple.txt' --> 'A'
'ryan.txt' --> 'R'
'01010.txt' --> 'Misc'
'''
import os
import shutil
filenames = []
def getfoldername(filename):
'''
'Test.txt' --> 't'
'010.txt' --> 'misc'
'zebra.txt' --> 'z'
'Alpha@@.... | [
"shutil.move",
"os.getcwd"
] | [((624, 635), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (633, 635), False, 'import os\n'), ((1583, 1615), 'shutil.move', 'shutil.move', (['source', 'destination'], {}), '(source, destination)\n', (1594, 1615), False, 'import shutil\n'), ((1447, 1458), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (1456, 1458), False, '... |
ONTOLOGY_MINABLE = True
try:
import classifier.classifier as CSO
except:
ONTOLOGY_MINABLE = False
print("No CSO Classifier Present")
from typing import List
from .record import ArxivIdentity,Ontology,ArxivSematicParsedResearch
class OntologyMiner:
is_minable = ONTOLOGY_MINABLE
@staticmethod
... | [
"classifier.classifier.run_cso_classifier",
"classifier.classifier.run_cso_classifier_batch_model_single_worker",
"classifier.classifier.run_cso_classifier_batch_mode"
] | [((425, 501), 'classifier.classifier.run_cso_classifier', 'CSO.run_cso_classifier', (["{'title': record.title, 'abstract': record.abstract}"], {}), "({'title': record.title, 'abstract': record.abstract})\n", (447, 501), True, 'import classifier.classifier as CSO\n'), ((1113, 1172), 'classifier.classifier.run_cso_classi... |
import os
import threading
import time
import requests
from altfe.interface.root import interRoot
from app.lib.core.dl.model.dler import Dler
requests.packages.urllib3.disable_warnings()
class DlDler(Dler):
def __init__(self, url, folder="./downloads/", name=None, dlArgs=Dler.TEMP_dlArgs, dlCacheDir=None, dlRe... | [
"altfe.interface.root.interRoot.STATIC.file.rm",
"os.path.exists",
"os.path.getsize",
"requests.packages.urllib3.disable_warnings",
"os.path.join",
"time.sleep",
"altfe.interface.root.interRoot.STATIC.file.clearDIR",
"altfe.interface.root.interRoot.STATIC.file.mkdir",
"requests.get",
"requests.hea... | [((145, 189), 'requests.packages.urllib3.disable_warnings', 'requests.packages.urllib3.disable_warnings', ([], {}), '()\n', (187, 189), False, 'import requests\n'), ((735, 782), 'os.path.join', 'os.path.join', (['self._dlSaveDir', 'self._dlSaveName'], {}), '(self._dlSaveDir, self._dlSaveName)\n', (747, 782), False, 'im... |
# Made by disKret
# Rate Fix by Gnat
import sys
from ru.catssoftware import Config
from ru.catssoftware.gameserver.model.quest import State
from ru.catssoftware.gameserver.model.quest import QuestState
from ru.catssoftware.gameserver.network.serverpackets import SocialAction
from ru.catssoftware.gameserver.model.quest.... | [
"ru.catssoftware.gameserver.network.serverpackets.SocialAction",
"ru.catssoftware.gameserver.model.quest.jython.QuestJython.__init__"
] | [((552, 590), 'ru.catssoftware.gameserver.model.quest.jython.QuestJython.__init__', 'JQuest.__init__', (['self', 'id', 'name', 'descr'], {}), '(self, id, name, descr)\n', (567, 590), True, 'from ru.catssoftware.gameserver.model.quest.jython import QuestJython as JQuest\n'), ((1174, 1199), 'ru.catssoftware.gameserver.ne... |
# -*- coding: utf-8 -*-
"""
Encounters database models
--------------------
"""
import uuid
import logging
from app.extensions import db, FeatherModel
from app.modules import is_module_enabled
from app.modules.individuals.models import Individual
import app.extensions.logging as AuditLog
log = logging.getLogger(__na... | [
"logging.getLogger",
"app.extensions.logging.delete_object",
"app.extensions.db.backref",
"app.extensions.db.session.begin",
"app.extensions.db.session.delete",
"app.extensions.db.relationship",
"app.extensions.db.Column",
"app.modules.is_module_enabled",
"app.extensions.db.ForeignKey",
"app.modul... | [((298, 325), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (315, 325), False, 'import logging\n'), ((530, 586), 'app.extensions.db.Column', 'db.Column', (['db.GUID'], {'default': 'uuid.uuid4', 'primary_key': '(True)'}), '(db.GUID, default=uuid.uuid4, primary_key=True)\n', (539, 586), Fa... |
import csv
import sys
from . import scrape_sites
from .data import BLOOD_TYPES, SITE_STATUS_FIELDS, site_status_to_fields
if __name__ == "__main__":
site_statuses = scrape_sites()
writer = csv.DictWriter(sys.stdout, fieldnames=SITE_STATUS_FIELDS)
writer.writeheader()
for s in site_statuses:
wr... | [
"csv.DictWriter"
] | [((199, 256), 'csv.DictWriter', 'csv.DictWriter', (['sys.stdout'], {'fieldnames': 'SITE_STATUS_FIELDS'}), '(sys.stdout, fieldnames=SITE_STATUS_FIELDS)\n', (213, 256), False, 'import csv\n')] |
"""Audio queue management."""
import asyncio
import atexit
import collections
import copy
import discord
import enum
import json
import os
import queue
import subprocess
import threading
import time
import uuid
from typing import cast, Any, Awaitable, Callable, Deque, List, Optional
import uita.exceptions
import uita.... | [
"logging.getLogger",
"copy.copy",
"collections.deque",
"subprocess.Popen",
"subprocess.run",
"time.perf_counter",
"discord.PCMVolumeTransformer",
"asyncio.sleep",
"asyncio.get_event_loop",
"atexit.register",
"discord.opus.Encoder",
"asyncio.Lock",
"uuid.uuid4",
"os.path.isfile",
"atexit.... | [((354, 381), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (371, 381), False, 'import logging\n'), ((3777, 3796), 'collections.deque', 'collections.deque', ([], {}), '()\n', (3794, 3796), False, 'import collections\n'), ((3824, 3852), 'asyncio.Lock', 'asyncio.Lock', ([], {'loop': 'self.... |