code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
"""Adds a unique constraint to name and url_name on bets.
Revision ID: 7e15c6b3d73b
Revises: <PASSWORD>
Create Date: 2016-08-27 18:15:32.180825
"""
# revision identifiers, used by Alembic.
revision = '<KEY>'
down_revision = '<KEY>7'
from alembic import op
import sqlalchemy as sa
def upgrade():
### commands au... | [
"alembic.op.drop_constraint",
"alembic.op.create_unique_constraint"
] | [((369, 423), 'alembic.op.create_unique_constraint', 'op.create_unique_constraint', (['None', '"""bet"""', "['url_name']"], {}), "(None, 'bet', ['url_name'])\n", (396, 423), False, 'from alembic import op\n'), ((428, 478), 'alembic.op.create_unique_constraint', 'op.create_unique_constraint', (['None', '"""bet"""', "['n... |
import click
def error(msg, logger=False):
"""Prints an error message to stderr and logs."""
click.secho(msg, fg='red', err=True)
if logger:
logger.error(msg)
def warn(msg, logger=False):
'''Prints a warning message to stderr.'''
click.secho(msg, fg='yellow')
if logger:
logger... | [
"click.secho"
] | [((102, 138), 'click.secho', 'click.secho', (['msg'], {'fg': '"""red"""', 'err': '(True)'}), "(msg, fg='red', err=True)\n", (113, 138), False, 'import click\n'), ((261, 290), 'click.secho', 'click.secho', (['msg'], {'fg': '"""yellow"""'}), "(msg, fg='yellow')\n", (272, 290), False, 'import click\n'), ((374, 402), 'clic... |
# -*- coding: utf-8 -*-
if __name__ == "__main__":
# Spark Session and Spark Context
from pyspark.sql import SparkSession
spark = SparkSession.builder \
.appName("PySpark Plaso WebAPI Application") \
.getOrCreate()
sc = spark.sparkContext
from os import getenv
from plaso.tarz... | [
"cherrypy.engine.block",
"os.getenv",
"cherrypy.tree.graft",
"cherrypy.engine.start",
"paste.translogger.TransLogger",
"pyspark.sql.SparkSession.builder.appName"
] | [((568, 584), 'paste.translogger.TransLogger', 'TransLogger', (['app'], {}), '(app)\n', (579, 584), False, 'from paste.translogger import TransLogger\n'), ((675, 711), 'cherrypy.tree.graft', 'cherrypy.tree.graft', (['app_logged', '"""/"""'], {}), "(app_logged, '/')\n", (694, 711), False, 'import cherrypy\n'), ((1116, 1... |
# Copyright 2021 Huawei Technologies Co., Ltd
#
# 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... | [
"numpy.copy",
"numpy.shape",
"cv2.warpAffine",
"numpy.minimum",
"numpy.random.random",
"numpy.exp",
"numpy.array",
"numpy.zeros",
"numpy.random.randint",
"cv2.cvtColor",
"numpy.maximum",
"numpy.mod",
"numpy.arange"
] | [((1091, 1119), 'numpy.arange', 'np.arange', (['(0)', 'size', '(1)', 'float'], {}), '(0, size, 1, float)\n', (1100, 1119), True, 'import numpy as np\n'), ((1212, 1271), 'numpy.exp', 'np.exp', (['(-((x - x0) ** 2 + (y - y0) ** 2) / (2 * sigma ** 2))'], {}), '(-((x - x0) ** 2 + (y - y0) ** 2) / (2 * sigma ** 2))\n', (121... |
from aqt import mw
from .config import get, set
def prepare_deck_to_ease_range():
deck_to_ease_range = d if (d := get('deck_to_ease_range')) else {}
# for backwards compatibilty
deck_to_ease = d if (d := get('deck_to_ease')) else {}
deck_to_ease_range.update(**_to_deck_to_ease_range(deck_to_ease))
... | [
"aqt.mw.col.decks.allIds"
] | [((592, 613), 'aqt.mw.col.decks.allIds', 'mw.col.decks.allIds', ([], {}), '()\n', (611, 613), False, 'from aqt import mw\n')] |
import os
import nextcord as discord
from nextcord.ext import commands
import pytube
class Youtube(commands.Cog):
def __init__(self, client):
self.client = client
@commands.command(name = 'youtube', aliases = ['yt'])
async def youtube(self, context, url):
# Check if 20 intern... | [
"nextcord.File",
"os.listdir",
"nextcord.ext.commands.command",
"os.rename",
"pytube.YouTube",
"os.path.splitext",
"os.remove"
] | [((187, 235), 'nextcord.ext.commands.command', 'commands.command', ([], {'name': '"""youtube"""', 'aliases': "['yt']"}), "(name='youtube', aliases=['yt'])\n", (203, 235), False, 'from nextcord.ext import commands\n'), ((391, 415), 'os.listdir', 'os.listdir', (['"""data/music"""'], {}), "('data/music')\n", (401, 415), F... |
"""
"""
import re
from collections import namedtuple
from functools import lru_cache
from lexref.model import Value
__all__ = ['ListItemsAndPatterns']
romans_pattern = Value.tag_2_pattern('EN')['ROM_L'].pattern.strip('b\\()')
_eur_lex_item_patterns_en = { # key: (itemization-character-pattern, ordered [bool], fi... | [
"functools.lru_cache",
"lexref.model.Value.tag_2_pattern",
"collections.namedtuple",
"re.compile"
] | [((3319, 3330), 'functools.lru_cache', 'lru_cache', ([], {}), '()\n', (3328, 3330), False, 'from functools import lru_cache\n'), ((2611, 2657), 'collections.namedtuple', 'namedtuple', (['"""FirstSecond"""', "['first', 'second']"], {}), "('FirstSecond', ['first', 'second'])\n", (2621, 2657), False, 'from collections imp... |
# Copyright (c) 2018-2019 <NAME>
# Copyright (c) 2021 RACOM s.r.o.
# SPDX-License-Identifier: MIT
from contextlib import suppress
from typing import IO, Any, Dict, Iterator, Optional, Tuple, Union
from _libyang import ffi, lib
from .util import IOType, c2str, init_output, ly_array_iter, str2c
# --------------------... | [
"_libyang.lib.lyxp_get_expr",
"_libyang.ffi.new",
"_libyang.lib.lyd_value_get_canonical",
"_libyang.ffi.string",
"_libyang.ffi.typeof",
"_libyang.lib.free",
"_libyang.lib.lysc_node_when",
"_libyang.lib.lys_print_module",
"_libyang.lib.lys_set_implemented",
"_libyang.lib.ly_out_free",
"_libyang.f... | [((42292, 42342), '_libyang.lib.lys_getnext', 'lib.lys_getnext', (['ffi.NULL', 'parent', 'module', 'options'], {}), '(ffi.NULL, parent, module, options)\n', (42307, 42342), False, 'from _libyang import ffi, lib\n'), ((2088, 2123), '_libyang.ffi.new', 'ffi.new', (['"""char *[2]"""', '[p, ffi.NULL]'], {}), "('char *[2]',... |
"""Main vcf2maf logic for spec gdc-1.0.0-aliquot"""
import urllib.parse
from operator import itemgetter
import pysam
from maflib.header import MafHeader, MafHeaderRecord
from maflib.sort_order import BarcodesAndCoordinate
from maflib.sorter import MafSorter
from maflib.validation import ValidationStringency
from mafli... | [
"aliquotmaf.subcommands.vcf_to_aliquot.extractors.VariantAlleleIndexExtractor.extract",
"aliquotmaf.converters.formatters.format_vcf_columns",
"aliquotmaf.filters.ExAC.setup",
"maflib.sort_order.BarcodesAndCoordinate",
"aliquotmaf.converters.formatters.format_depths",
"aliquotmaf.converters.utils.get_colu... | [((1298, 1346), 'aliquotmaf.subcommands.utils.load_json', 'load_json', (["self.options['biotype_priority_file']"], {}), "(self.options['biotype_priority_file'])\n", (1307, 1346), False, 'from aliquotmaf.subcommands.utils import assert_sample_in_header, extract_annotation_from_header, load_enst, load_json\n'), ((1378, 1... |
# -*- coding: utf-8 -*-
"""
shortly.settings
~~~~~~~~~~~~~~~~
Shortly config.
:copyright: (c) 2014 by fsp.
:license: BSD.
"""
import os
DEBUG = False
# Detect environment by whether debug named file exists or not
if os.path.exists(os.path.join(os.path.dirname(__file__), 'debug')):
DEBUG = T... | [
"os.path.dirname"
] | [((269, 294), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (284, 294), False, 'import os\n')] |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
"""
import sys
import matplotlib.pyplot as plt
import numpy as np
# from tomo_encoders.misc_utils.feature_maps_vis import view_midplanes
import cupy as cp
import time
import h5py
#from recon_subvol import fbp_filter, recon_patch
# from tomo_encoders import ... | [
"numpy.random.normal",
"numpy.mean",
"numpy.ceil",
"cupy.cuda.Stream",
"cupy.get_array_module",
"time.time",
"cupy.zeros"
] | [((621, 646), 'cupy.get_array_module', 'cp.get_array_module', (['data'], {}), '(data)\n', (640, 646), True, 'import cupy as cp\n'), ((877, 913), 'cupy.get_array_module', 'cp.get_array_module', (['vol[ss, ss, ss]'], {}), '(vol[ss, ss, ss])\n', (896, 913), True, 'import cupy as cp\n'), ((1436, 1452), 'cupy.cuda.Stream', ... |
import random
from PIL import Image
from captcha.image import ImageCaptcha
from utils.dataset import CaptchaDataset
from utils.img_util import display_images
from torchvision import transforms
import numpy as np
img_width = 160
img_height = 60
n_chars = 7
chars = list('1234567890abcdefghijklmnopqrstuvwxyzABCDEFGHI... | [
"PIL.Image.open",
"torchvision.transforms.Grayscale",
"captcha.image.ImageCaptcha",
"torchvision.transforms.Normalize",
"torchvision.transforms.ToTensor"
] | [((346, 381), 'captcha.image.ImageCaptcha', 'ImageCaptcha', (['img_width', 'img_height'], {}), '(img_width, img_height)\n', (358, 381), False, 'from captcha.image import ImageCaptcha\n'), ((865, 878), 'PIL.Image.open', 'Image.open', (['d'], {}), '(d)\n', (875, 878), False, 'from PIL import Image\n'), ((588, 631), 'torc... |
#!/usr/bin/env python
"""
Extract MFCC and filterbank features for the Buckeye dataset.
Author: <NAME>
Contact: <EMAIL>
Date: 2019, 2021
"""
from datetime import datetime
from os import path
from tqdm import tqdm
import argparse
import numpy as np
import os
import sys
sys.path.append("..")
from paths import buckey... | [
"features.extract_vad",
"features.speaker_mvn",
"os.makedirs",
"os.path.join",
"utils.segments_from_npz",
"utils.read_vad_from_fa",
"datetime.datetime.now",
"os.path.isfile",
"os.path.isdir",
"utils.write_samediff_words",
"numpy.savez_compressed",
"sys.path.append"
] | [((273, 294), 'sys.path.append', 'sys.path.append', (['""".."""'], {}), "('..')\n", (288, 294), False, 'import sys\n'), ((586, 649), 'os.path.join', 'path.join', (['""".."""', '"""data"""', "('buckeye_' + subset + '_speakers.list')"], {}), "('..', 'data', 'buckeye_' + subset + '_speakers.list')\n", (595, 649), False, '... |
import os, json, subprocess
class Console():
"""Run PHP job"""
def get_interface_methods(namespace):
try:
output = Console.run_command('interface-methods', [namespace])
return json.loads(output)
except Exception as e:
return {}
def get_class_methods(n... | [
"subprocess.check_output",
"json.loads",
"os.path.abspath"
] | [((220, 238), 'json.loads', 'json.loads', (['output'], {}), '(output)\n', (230, 238), False, 'import os, json, subprocess\n'), ((435, 453), 'json.loads', 'json.loads', (['output'], {}), '(output)\n', (445, 453), False, 'import os, json, subprocess\n'), ((632, 650), 'json.loads', 'json.loads', (['output'], {}), '(output... |
from django.test import TestCase
from django.contrib.auth import get_user_model
class ModelTests(TestCase):
def test_create_user_with_email(self):
'''Tet creating a new user with an email is sucessfull'''
email = '<EMAIL>'
password = '<PASSWORD>'
user = get_user_model().objects.cre... | [
"django.contrib.auth.get_user_model"
] | [((292, 308), 'django.contrib.auth.get_user_model', 'get_user_model', ([], {}), '()\n', (306, 308), False, 'from django.contrib.auth import get_user_model\n'), ((583, 599), 'django.contrib.auth.get_user_model', 'get_user_model', ([], {}), '()\n', (597, 599), False, 'from django.contrib.auth import get_user_model\n'), (... |
#!/usr/bin/env python3
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved.
"""Add custom configs and default values"""
from fvcore.common.config import CfgNode
def add_custom_config(_C):
# Knowledge distillation
_C.KD = CfgNode()
# If True enable KD, else skip KD.
_C.KD.ENABLE = ... | [
"fvcore.common.config.CfgNode"
] | [((251, 260), 'fvcore.common.config.CfgNode', 'CfgNode', ([], {}), '()\n', (258, 260), False, 'from fvcore.common.config import CfgNode\n'), ((815, 824), 'fvcore.common.config.CfgNode', 'CfgNode', ([], {}), '()\n', (822, 824), False, 'from fvcore.common.config import CfgNode\n')] |
import dash
import dash_bio as dashbio
import dash_html_components as html
import dash_core_components as dcc
external_stylesheets = ['https://codepen.io/chriddyp/pen/bWLwgP.css']
app = dash.Dash(__name__, external_stylesheets=external_stylesheets)
app.layout = html.Div([
'Select which chromosomes to display on ... | [
"dash.dependencies.Output",
"dash.dependencies.Input",
"dash.Dash",
"dash_bio.Ideogram",
"dash_html_components.Div"
] | [((188, 250), 'dash.Dash', 'dash.Dash', (['__name__'], {'external_stylesheets': 'external_stylesheets'}), '(__name__, external_stylesheets=external_stylesheets)\n', (197, 250), False, 'import dash\n'), ((666, 728), 'dash.dependencies.Output', 'dash.dependencies.Output', (['"""my-dashbio-ideogram"""', '"""chromosomes"""... |
from blockchain import Blockchain, Transaction
from nacl.signing import SigningKey
from hashlib import sha256
from time import sleep
from threading import Thread
import random
class Node:
"""Represent a Node."""
def __init__(self, neighbours, unverified_transactions_pool):
"""
Initialize the ... | [
"nacl.signing.SigningKey.generate",
"threading.Thread.__init__",
"random.choice",
"blockchain.Transaction",
"time.sleep",
"blockchain.Blockchain",
"random.randint"
] | [((513, 534), 'nacl.signing.SigningKey.generate', 'SigningKey.generate', ([], {}), '()\n', (532, 534), False, 'from nacl.signing import SigningKey\n'), ((706, 718), 'blockchain.Blockchain', 'Blockchain', ([], {}), '()\n', (716, 718), False, 'from blockchain import Blockchain, Transaction\n'), ((2454, 2475), 'threading.... |
# -*- coding: utf-8 -*-
"""
Created on Sun Jan 29 16:13:48 2017
@author: laide
"""
"""prints a list of tuples (station name, town, distance) for the 10 closest
and the 10 furthest stations from the Cambridge city centre, (52.2053, 0.1218)."""
from floodsystem.geo import stations_by_distance
from floodsystem.stationda... | [
"floodsystem.stationdata.build_station_list"
] | [((543, 563), 'floodsystem.stationdata.build_station_list', 'build_station_list', ([], {}), '()\n', (561, 563), False, 'from floodsystem.stationdata import build_station_list\n')] |
#!/usr/bin/env python3
# Copyright 2018-2019 <NAME>
# Copyright 2020-2021 Google LLC
#
# 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
#
# Un... | [
"json.loads",
"os.makedirs",
"argparse.ArgumentParser",
"os.getenv",
"re.compile",
"difflib.SequenceMatcher",
"os.path.dirname",
"sys.stdout.isatty",
"os.path.basename",
"sys.exit"
] | [((789, 817), 're.compile', 're.compile', (['"""\\\\._[0-9A-F]+$"""'], {}), "('\\\\._[0-9A-F]+$')\n", (799, 817), False, 'import re\n'), ((843, 875), 're.compile', 're.compile', (['"""@-?[0-9]+,-?[0-9]+"""'], {}), "('@-?[0-9]+,-?[0-9]+')\n", (853, 875), False, 'import re\n'), ((894, 924), 're.compile', 're.compile', ([... |
import re
import os
from prob import trans_P, emit_P, start_P
from preprocess import preprocess, recov, UNK
DATAROOT = '/home/luod/class/nlp/HanTokenization/datasets'
RESULTROOT = '/home/luod/class/nlp/HanTokenization/results'
VOCAB_FILE = os.path.join(DATAROOT, 'training_vocab.txt')
VOCAB_FREQ = os.path.join(RESULTR... | [
"os.system",
"preprocess.preprocess",
"os.path.join",
"re.compile"
] | [((242, 286), 'os.path.join', 'os.path.join', (['DATAROOT', '"""training_vocab.txt"""'], {}), "(DATAROOT, 'training_vocab.txt')\n", (254, 286), False, 'import os\n'), ((300, 342), 'os.path.join', 'os.path.join', (['RESULTROOT', '"""vocab-freq.txt"""'], {}), "(RESULTROOT, 'vocab-freq.txt')\n", (312, 342), False, 'import... |
#!/usr/bin/env python
import pymongo
conn_string="mongodb://dbUser19:LSVyKnHW@cluster<EMAIL>-00-0<EMAIL>.mongodb.<EMAIL>:27017,cluster0-shard-00-01-nadgn.mongodb.net:27017,cluster0-shard-00-02-nadgn.mongodb.net:27017/test?ssl=true&replicaSet=Cluster0-shard-0&authSource=admin&retryWrites=true"
client=pymongo.MongoCli... | [
"pymongo.MongoClient"
] | [((304, 336), 'pymongo.MongoClient', 'pymongo.MongoClient', (['conn_string'], {}), '(conn_string)\n', (323, 336), False, 'import pymongo\n')] |
import pytest
from test_migrations import constants
from .fixtures import migrator # pylint: disable=W0611
pytest_plugins = ['pytest_django'] # pylint: disable=C0103
def pytest_load_initial_conftests(early_config):
# Register the marks
early_config.addinivalue_line(
'markers',
(
... | [
"pytest.fixture",
"pytest.mark.skip",
"pytest.skip"
] | [((2178, 2224), 'pytest.fixture', 'pytest.fixture', ([], {'autouse': '(True)', 'scope': '"""function"""'}), "(autouse=True, scope='function')\n", (2192, 2224), False, 'import pytest\n'), ((1490, 1591), 'pytest.mark.skip', 'pytest.mark.skip', ([], {'reason': '"""Migration tests not skipped, because`--test-migration` opt... |
import os
from django.contrib.gis.db import models
from hrp.ontologies import *
# from hrp.ontologies import ITEM_TYPE_VOCABULARY, HRP_COLLECTOR_CHOICES, \
# HRP_COLLECTING_METHOD_VOCABULARY, HRP_BASIS_OF_RECORD_VOCABULARY, HRP_COLLECTION_CODES
from django.contrib.gis.geos import Point
import projects.models
cl... | [
"django.contrib.gis.db.models.ForeignKey",
"django.contrib.gis.db.models.SmallIntegerField",
"django.contrib.gis.db.models.CharField",
"django.contrib.gis.db.models.ImageField",
"django.contrib.gis.db.models.FileField",
"django.contrib.gis.db.models.LineStringField",
"os.path.join",
"django.contrib.gi... | [((517, 565), 'django.contrib.gis.db.models.ForeignKey', 'models.ForeignKey', (['"""self"""'], {'null': '(True)', 'blank': '(True)'}), "('self', null=True, blank=True)\n", (534, 565), False, 'from django.contrib.gis.db import models\n'), ((577, 605), 'django.contrib.gis.db.models.ForeignKey', 'models.ForeignKey', (['Ta... |
import random
import math
listes = []
"""for i in range(3):
# listes.append(random.sample(range(5, 50), random.randint(5,1000)))
listes.append(random.sample(range(1, 100), 10))
"""
listes = [
[10,20,30,90,30,54,123,34,656,246,24,842,6784,2,56,4,5,7423,6,6,3,345,6,7,345,46],
[10,20,30,90],
[10,20,... | [
"math.sqrt"
] | [((2908, 2934), 'math.sqrt', 'math.sqrt', (['(S / (count - 1))'], {}), '(S / (count - 1))\n', (2917, 2934), False, 'import math\n')] |
# coding=utf-8
# Copyright 2014 Pants project contributors (see CONTRIBUTORS.md).
# Licensed under the Apache License, Version 2.0 (see LICENSE).
from __future__ import (absolute_import, division, generators, nested_scopes, print_function,
unicode_literals, with_statement)
import os
from pant... | [
"pants.backend.jvm.tasks.jvm_compile.resource_mapping.ResourceMapping"
] | [((631, 655), 'pants.backend.jvm.tasks.jvm_compile.resource_mapping.ResourceMapping', 'ResourceMapping', (['rel_dir'], {}), '(rel_dir)\n', (646, 655), False, 'from pants.backend.jvm.tasks.jvm_compile.resource_mapping import ResourceMapping\n'), ((889, 913), 'pants.backend.jvm.tasks.jvm_compile.resource_mapping.Resource... |
from dogey import Dogey
from dogey.classes import Message, User, Room, Context
from dogey.exceptions import DogeyCommandError
dogey = Dogey(token='your token', refresh_token='<PASSWORD> refresh token', prefix='.')
bot = dogey.bot
@dogey.event
async def on_ready():
print(f'{bot.name} is up! (prefix is {bot.prefix... | [
"dogey.Dogey"
] | [((135, 214), 'dogey.Dogey', 'Dogey', ([], {'token': '"""your token"""', 'refresh_token': '"""<PASSWORD> refresh token"""', 'prefix': '"""."""'}), "(token='your token', refresh_token='<PASSWORD> refresh token', prefix='.')\n", (140, 214), False, 'from dogey import Dogey\n')] |
#ミニバッチ学習
import numpy as np
from dataset.mnist import load_mnist
(x_train, t_train), (x_test, t_test) =\
load_mnist(normalize=True, one_hot_label=True)
print(x_train.shape)
print(t_train.shape)
train_size = x_train.shape[0]
batch_size = 10
batch_mask = np.random.choice(train_size, batch_size)
x_batch = x_train[b... | [
"numpy.random.choice",
"dataset.mnist.load_mnist"
] | [((110, 156), 'dataset.mnist.load_mnist', 'load_mnist', ([], {'normalize': '(True)', 'one_hot_label': '(True)'}), '(normalize=True, one_hot_label=True)\n', (120, 156), False, 'from dataset.mnist import load_mnist\n'), ((260, 300), 'numpy.random.choice', 'np.random.choice', (['train_size', 'batch_size'], {}), '(train_si... |
import socket
from multiprocessing import Pool, Queue, Manager, cpu_count
from ..protocol.methods import *
from ..protocol.models import *
from ..various.abc import CounterServer
MAX_WORKERS = cpu_count()
class UDPCounterServer(CounterServer):
def __init__(self, ip="0.0.0.0", port=0, max_workers=MAX_WORKERS):
... | [
"socket.socket",
"multiprocessing.cpu_count",
"multiprocessing.Pool",
"multiprocessing.Manager",
"multiprocessing.Queue"
] | [((195, 206), 'multiprocessing.cpu_count', 'cpu_count', ([], {}), '()\n', (204, 206), False, 'from multiprocessing import Pool, Queue, Manager, cpu_count\n'), ((463, 472), 'multiprocessing.Manager', 'Manager', ([], {}), '()\n', (470, 472), False, 'from multiprocessing import Pool, Queue, Manager, cpu_count\n'), ((554, ... |
# Copyright (c) 2019 Science and Technology Facilities Council
# All rights reserved.
# Modifications made as part of the fparser project are distributed
# under the following license:
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following condi... | [
"fparser.two.Fortran2003.Format_Item_C1002",
"pytest.raises"
] | [((3129, 3152), 'fparser.two.Fortran2003.Format_Item_C1002', 'Format_Item_C1002', (['line'], {}), '(line)\n', (3146, 3152), False, 'from fparser.two.Fortran2003 import Format_Item_C1002\n'), ((3577, 3600), 'fparser.two.Fortran2003.Format_Item_C1002', 'Format_Item_C1002', (['line'], {}), '(line)\n', (3594, 3600), False,... |
from django import template
from django.utils.http import urlquote
import re
register = template.Library()
@register.filter
def quote_filepath(url):
_, scheme, path = re.split(r'(https?://)', url)
return '{}{}'.format(scheme, urlquote(path))
| [
"re.split",
"django.template.Library",
"django.utils.http.urlquote"
] | [((89, 107), 'django.template.Library', 'template.Library', ([], {}), '()\n', (105, 107), False, 'from django import template\n'), ((173, 201), 're.split', 're.split', (['"""(https?://)"""', 'url'], {}), "('(https?://)', url)\n", (181, 201), False, 'import re\n'), ((236, 250), 'django.utils.http.urlquote', 'urlquote', ... |
from pydantic import BaseModel
from typing import Optional
class RequestDataModel(BaseModel):
loginToken: str
def login_with_google(data: dict):
request_data = RequestDataModel(**data)
from google.oauth2 import id_token
from google.auth.transport.requests import Request as GoogleRequest
user_info... | [
"google.auth.transport.requests.Request"
] | [((420, 435), 'google.auth.transport.requests.Request', 'GoogleRequest', ([], {}), '()\n', (433, 435), True, 'from google.auth.transport.requests import Request as GoogleRequest\n')] |
from PIL import Image, ImageEnhance
import os
import argparse
def change_brightness(source_dir, save_dir, brightness):
os.makedirs(save_dir, exist_ok=True)
image_pathes = [f for f in os.scandir(source_dir) if f.is_file()]
for image_path in image_pathes:
save_path = os.path.join(save_dir, image_path... | [
"os.scandir",
"argparse.ArgumentParser",
"os.makedirs",
"PIL.Image.open"
] | [((124, 160), 'os.makedirs', 'os.makedirs', (['save_dir'], {'exist_ok': '(True)'}), '(save_dir, exist_ok=True)\n', (135, 160), False, 'import os\n'), ((514, 539), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (537, 539), False, 'import argparse\n'), ((192, 214), 'os.scandir', 'os.scandir', (['... |
import json
import errno
import os
import ext_logging
from . import BaseTestCase, log
class TraceCase(BaseTestCase):
def test_multiple_handlers(self):
log_conf_sysl = {
'handler': 'ext_logging.handlers.StdOutExtendedSysLogHandler',
'level': 'DEBUG',
'json_serializer'... | [
"ext_logging.configure_logs"
] | [((562, 647), 'ext_logging.configure_logs', 'ext_logging.configure_logs', (["{'MODULES': {'test': [log_conf_sysl, log_conf_elk]}}"], {}), "({'MODULES': {'test': [log_conf_sysl, log_conf_elk]}}\n )\n", (588, 647), False, 'import ext_logging\n')] |
import FWCore.ParameterSet.Config as cms
from Configuration.Generator.Pythia8CommonSettings_cfi import *
from Configuration.Generator.Pythia8CUEP8M1Settings_cfi import *
generator = cms.EDFilter("Pythia8GeneratorFilter",
#pythiaHepMCVerbosity = cms.untracked.bool(False),
... | [
"FWCore.ParameterSet.Config.untracked.int32",
"FWCore.ParameterSet.Config.untracked.double",
"FWCore.ParameterSet.Config.vstring",
"FWCore.ParameterSet.Config.double"
] | [((335, 354), 'FWCore.ParameterSet.Config.double', 'cms.double', (['(13000.0)'], {}), '(13000.0)\n', (345, 354), True, 'import FWCore.ParameterSet.Config as cms\n'), ((400, 422), 'FWCore.ParameterSet.Config.untracked.int32', 'cms.untracked.int32', (['(0)'], {}), '(0)\n', (419, 422), True, 'import FWCore.ParameterSet.Co... |
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
# Copied from multihead_attention.py
# Change it for phrase level gaussian attention
# TODO:
# 1. Graph based function
# 2. Convlution based f... | [
"torch.nn.init.constant_",
"torch.max",
"math.sqrt",
"torch.exp",
"torch.nn.init.xavier_normal_",
"torch.nn.functional.pad",
"torch.bmm",
"torch.arange",
"torch.nn.init.xavier_uniform_",
"torch.mean",
"fairseq.utils.softmax",
"torch.zeros_like",
"torch.Tensor",
"torch.cat",
"math.ceil",
... | [((8686, 8728), 'torch.nn.Linear', 'nn.Linear', (['self.vdim', 'embed_dim'], {'bias': 'bias'}), '(self.vdim, embed_dim, bias=bias)\n', (8695, 8728), False, 'from torch import Tensor, nn\n'), ((8754, 8796), 'torch.nn.Linear', 'nn.Linear', (['embed_dim', 'embed_dim'], {'bias': 'bias'}), '(embed_dim, embed_dim, bias=bias)... |
# -*- coding: utf-8 -*-
# Fonte https://realpython.com/k-means-clustering-python/
# Clustering is a set of techniques used to partition data into groups, or clusters. Clusters are loosely defined as groups of data objects that are more similar to other objects in their cluster than they are to data objects in oth... | [
"sklearn.cluster.KMeans",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"sklearn.datasets.make_blobs",
"sklearn.metrics.adjusted_rand_score",
"matplotlib.pyplot.style.use",
"sklearn.preprocessing.StandardScaler",
"sklearn.datasets.make_moons",
"sklearn.metrics.silhouette_score",
"sklearn... | [((1483, 1554), 'sklearn.datasets.make_blobs', 'make_blobs', ([], {'n_samples': '(200)', 'centers': '(3)', 'cluster_std': '(2.75)', 'random_state': '(42)'}), '(n_samples=200, centers=3, cluster_std=2.75, random_state=42)\n', (1493, 1554), False, 'from sklearn.datasets import make_blobs\n'), ((1836, 1852), 'sklearn.prep... |
"""
Unit test script for pyeto.thornthwaite.py
"""
import unittest
import pyeto
class TestThornthwaite(unittest.TestCase):
def test_monthly_mean_daylight_hours(self):
# Test against values for latitude 20 deg N from Bautista et al (2009)
# Calibration of the equations of Hargreaves and Thornthw... | [
"unittest.main",
"pyeto.thornthwaite",
"pyeto.deg2rad",
"pyeto.monthly_mean_daylight_hours"
] | [((6601, 6616), 'unittest.main', 'unittest.main', ([], {}), '()\n', (6614, 6616), False, 'import unittest\n'), ((2299, 2324), 'pyeto.deg2rad', 'pyeto.deg2rad', (['(34.0833333)'], {}), '(34.0833333)\n', (2312, 2324), False, 'import pyeto\n'), ((2697, 2740), 'pyeto.monthly_mean_daylight_hours', 'pyeto.monthly_mean_daylig... |
import cv2
from ml.facial_expression_classification import predict_facial_expression_by_array, IMAGE_WIDTH, IMAGE_HEIGHT
from video.camera import Camera
OPENCV_HAARCASCADE_FRONTALFACE_FILE = 'trained_models/opencv/haarcascades/haarcascade_frontalface_alt.xml'
class EmotionDetectionCamera(Camera):
def __init__(s... | [
"cv2.rectangle",
"cv2.imencode",
"ml.facial_expression_classification.predict_facial_expression_by_array",
"cv2.putText",
"cv2.equalizeHist",
"cv2.cvtColor",
"cv2.CascadeClassifier",
"cv2.resize"
] | [((354, 412), 'cv2.CascadeClassifier', 'cv2.CascadeClassifier', (['OPENCV_HAARCASCADE_FRONTALFACE_FILE'], {}), '(OPENCV_HAARCASCADE_FRONTALFACE_FILE)\n', (375, 412), False, 'import cv2\n'), ((569, 608), 'cv2.cvtColor', 'cv2.cvtColor', (['frame', 'cv2.COLOR_BGR2GRAY'], {}), '(frame, cv2.COLOR_BGR2GRAY)\n', (581, 608), F... |
import unittest
from vb2py.test_at_scale import file_tester
class Test_heinsega(file_tester.FileTester):
def test0(self):
self._testFile('/Users/paul/Workspace/sandbox/vb2py-git-files/heinsega/OX163_VB6project_Win32/Module1.bas')
def test1(self):
self._testFile('/Users/paul/Workspace/sandbox/vb2py-git-files/... | [
"unittest.main"
] | [((3205, 3220), 'unittest.main', 'unittest.main', ([], {}), '()\n', (3218, 3220), False, 'import unittest\n')] |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Oct 17 10:23:50 2019
@author: chiara
"""
import os
import numpy as np # scientific calculation
import pandas as pd # data analysis
import itertools
import warnings
from statsmodels.tsa.arima_model import ARMA
ts1=list(range(0,500,2))
len(ts1)
mode... | [
"itertools.product",
"statsmodels.tsa.statespace.sarimax.SARIMAX",
"statsmodels.tsa.arima_model.ARMA",
"pandas.DataFrame",
"warnings.filterwarnings",
"statsmodels.tsa.vector_ar.var_model.VAR"
] | [((322, 345), 'statsmodels.tsa.arima_model.ARMA', 'ARMA', (['ts1'], {'order': '(0, 1)'}), '(ts1, order=(0, 1))\n', (326, 345), False, 'from statsmodels.tsa.arima_model import ARMA\n'), ((2634, 2672), 'pandas.DataFrame', 'pd.DataFrame', (["{'ts1': ts1, 'ts2': ts2}"], {}), "({'ts1': ts1, 'ts2': ts2})\n", (2646, 2672), Tr... |
# Future imports
from __future__ import (
annotations
)
# Standard imports
import argparse
from typing import (
Sequence
)
from pathlib import Path
# Local imports
import reddack
import reddack.config
import reddack.utils
def create_arg_parser() -> argparse.ArgumentParser:
"""Create the argument parser f... | [
"reddack.config.reddack_from_file",
"reddack.utils.sync",
"argparse.ArgumentParser",
"pathlib.Path"
] | [((348, 464), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Moderate Reddit communities via Slack"""', 'argument_default': 'argparse.SUPPRESS'}), "(description='Moderate Reddit communities via Slack',\n argument_default=argparse.SUPPRESS)\n", (371, 464), False, 'import argparse\n'), ... |
import tfcoreml as tf_converter
tf_converter.convert(tf_model_path = 'retrained_graph.pb',
mlmodel_path = 'converted.mlmodel',
output_feature_names = ['final_result:0'],
image_input_names = 'input:0',
class_labels = 'retrained_labels.tx... | [
"tfcoreml.convert"
] | [((32, 309), 'tfcoreml.convert', 'tf_converter.convert', ([], {'tf_model_path': '"""retrained_graph.pb"""', 'mlmodel_path': '"""converted.mlmodel"""', 'output_feature_names': "['final_result:0']", 'image_input_names': '"""input:0"""', 'class_labels': '"""retrained_labels.txt"""', 'red_bias': '(-1)', 'green_bias': '(-1)... |
from django.test import TestCase
from checkout_backend.entities.offer_entity import OfferEntity
from checkout_backend.entities.product_entity import ProductEntity
from checkout_backend.uses_cases.total_amount_processor import TotalAmountProcessor
class OffersTestCase(TestCase):
def setUp(self):
self.pro... | [
"checkout_backend.entities.product_entity.ProductEntity",
"checkout_backend.uses_cases.total_amount_processor.TotalAmountProcessor",
"checkout_backend.entities.offer_entity.OfferEntity"
] | [((331, 385), 'checkout_backend.entities.product_entity.ProductEntity', 'ProductEntity', ([], {'id': '(1)', 'code': '"""PEN"""', 'name': '"""PEN"""', 'price': '(500)'}), "(id=1, code='PEN', name='PEN', price=500)\n", (344, 385), False, 'from checkout_backend.entities.product_entity import ProductEntity\n'), ((475, 536)... |
# test_processor.py, Copyright (c) 2019, Phenome Project - <NAME> <<EMAIL>>
from phenome_core.core.base.base_processor import BaseProcessor
class TestProcessor(BaseProcessor):
__test__ = False
def __init__(self):
super(TestProcessor, self).__init__()
def process(self, results):
from p... | [
"phenome.test.supporting.test_mockobject.MockObject"
] | [((420, 432), 'phenome.test.supporting.test_mockobject.MockObject', 'MockObject', ([], {}), '()\n', (430, 432), False, 'from phenome.test.supporting.test_mockobject import MockObject\n')] |
import os
from cli.src.commands.BackupRecoveryBase import BackupRecoveryBase
from cli.src.helpers.doc_list_helpers import select_single
class Backup(BackupRecoveryBase):
"""Perform backup operations."""
def __init__(self, input_data):
super(BackupRecoveryBase, self).__init__(__name__) # late call o... | [
"cli.src.helpers.doc_list_helpers.select_single"
] | [((605, 691), 'cli.src.helpers.doc_list_helpers.select_single', 'select_single', (['self.configuration_docs', "(lambda x: x.kind == 'configuration/backup')"], {}), "(self.configuration_docs, lambda x: x.kind ==\n 'configuration/backup')\n", (618, 691), False, 'from cli.src.helpers.doc_list_helpers import select_sing... |
"""
Messages:
https://wiki.theory.org/BitTorrentSpecification#Messages
<length prefix><message ID><payload>
"""
from collections import namedtuple
from struct import pack
from struct import unpack
FORMAT = '>IB{}'
Message = namedtuple('Message', 'len id payload')
KEEP_ALIVE = -1
CHOKE = 0
UNCHOKE = 1
INTERESTED =... | [
"collections.namedtuple",
"struct.pack",
"struct.unpack"
] | [((229, 268), 'collections.namedtuple', 'namedtuple', (['"""Message"""', '"""len id payload"""'], {}), "('Message', 'len id payload')\n", (239, 268), False, 'from collections import namedtuple\n'), ((772, 798), 'struct.unpack', 'unpack', (['""">IB"""', 'message[:5]'], {}), "('>IB', message[:5])\n", (778, 798), False, '... |
import serial
import os
import json
from pprint import pprint
import mysql.connector
import time
import requests
mydb = mysql.connector.connect(
host="localhost",
user="max",
passwd="<PASSWORD>",
database="SmartKitchenDb"
)
com = serial.Serial('/dev/ttyUSB1', baudrate=9600, timeout=3.0)
com2 = serial.... | [
"json.loads",
"requests.post",
"requests.get",
"time.sleep",
"serial.Serial"
] | [((248, 305), 'serial.Serial', 'serial.Serial', (['"""/dev/ttyUSB1"""'], {'baudrate': '(9600)', 'timeout': '(3.0)'}), "('/dev/ttyUSB1', baudrate=9600, timeout=3.0)\n", (261, 305), False, 'import serial\n'), ((313, 370), 'serial.Serial', 'serial.Serial', (['"""/dev/ttyUSB0"""'], {'baudrate': '(9600)', 'timeout': '(3.0)'... |
import argparse, os
parser = argparse.ArgumentParser()
parser.add_argument('outdir', type=str, help='sphinx output directory')
args = parser.parse_args()
import re
duplicate_tag = '''(<script src="https://unpkg.com/@jupyter-widgets/html-manager@\^[0-9]*\.[0-9]*\.[0-9]*/dist/embed-amd.js"></script>)'''
bad1 = re.co... | [
"argparse.ArgumentParser",
"re.compile",
"os.path.join",
"os.path.abspath",
"os.walk"
] | [((31, 56), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (54, 56), False, 'import argparse, os\n'), ((315, 340), 're.compile', 're.compile', (['duplicate_tag'], {}), '(duplicate_tag)\n', (325, 340), False, 'import re\n'), ((348, 398), 're.compile', 're.compile', (["(duplicate_tag + '(.*)' + d... |
from finance_manager.database.replaceable import ReplaceableObject as o
from finance_manager.database.views import account_description, p_list_string, p_sum_string
def _view():
view = o("v_input_inc_other", f"""
SELECT i.inc_id, i.account, a.description as account_name, {account_description}, i.description, i... | [
"finance_manager.database.replaceable.ReplaceableObject"
] | [((190, 472), 'finance_manager.database.replaceable.ReplaceableObject', 'o', (['"""v_input_inc_other"""', 'f"""\n SELECT i.inc_id, i.account, a.description as account_name, {account_description}, i.description, i.set_id,\n {p_list_string}, {p_sum_string} as amount\n FROM input_inc_other i\n LEFT OUTER JOIN ... |
import re
import lxml.html
import click
import scrapelib
from common import Person
def elem_to_str(item, inside=False):
attribs = " ".join(f"{k}='{v}'" for k, v in item.attrib.items())
return f"<{item.tag} {attribs}> @ line {item.sourceline}"
class XPath:
def __init__(self, xpath, *, min_items=1, max_i... | [
"click.argument",
"click.group",
"click.option",
"common.Person",
"re.findall"
] | [((8317, 8330), 'click.group', 'click.group', ([], {}), '()\n', (8328, 8330), False, 'import click\n'), ((8369, 8397), 'click.argument', 'click.argument', (['"""class_name"""'], {}), "('class_name')\n", (8383, 8397), False, 'import click\n'), ((8399, 8420), 'click.argument', 'click.argument', (['"""url"""'], {}), "('ur... |
from flask import current_app
#This module is created for interaction with the Elasticsearch index
#Function that adds element to the index of Elasticsearch. Uses model as the SQLAlchemy model
def add_element_index(index,model):
#Check to see if Elasticsearch server is configured or not.
#The application runs ... | [
"flask.current_app.elasticsearch.search",
"flask.current_app.elasticsearch.delete",
"flask.current_app.elasticsearch.index"
] | [((531, 622), 'flask.current_app.elasticsearch.index', 'current_app.elasticsearch.index', ([], {'index': 'index', 'doc_type': 'index', 'id': 'model.id', 'body': 'payload'}), '(index=index, doc_type=index, id=model.id,\n body=payload)\n', (562, 622), False, 'from flask import current_app\n'), ((825, 899), 'flask.curr... |
#
# Copyright (c) 2020 Idiap Research Institute, http://www.idiap.ch/
# Written by <NAME> <<EMAIL>>,
# <NAME> <<EMAIL>>
#
import unittest
import torch
from fast_transformers.attention.attention_layer import AttentionLayer
class TestAttentionLayer(unittest.TestCase):
def _assert_sizes_attention(self, qshape, k... | [
"unittest.main",
"torch.rand"
] | [((1627, 1642), 'unittest.main', 'unittest.main', ([], {}), '()\n', (1640, 1642), False, 'import unittest\n'), ((927, 949), 'torch.rand', 'torch.rand', (['(10)', '(5)', '(100)'], {}), '(10, 5, 100)\n', (937, 949), False, 'import torch\n'), ((963, 985), 'torch.rand', 'torch.rand', (['(10)', '(8)', '(100)'], {}), '(10, 8... |
import numpy as np
import torch
import matplotlib.animation as animation
import matplotlib.pyplot as plt
from PIL import Image
import ThinPlateSpline as TPS
# 2048x2048.jpg size: 2048 x 2048
def on_press(event):
p = np.array([
[693.55, 531.26],
[1069.85, 1243.04],
[1243.74, 1238.69],
... | [
"matplotlib.pyplot.imshow",
"PIL.Image.open",
"numpy.array",
"matplotlib.pyplot.figure",
"ThinPlateSpline.solve_system",
"ThinPlateSpline.point_transform",
"matplotlib.pyplot.show"
] | [((224, 651), 'numpy.array', 'np.array', (['[[693.55, 531.26], [1069.85, 1243.04], [1243.74, 1238.69], [472.82, 664.85],\n [552.5, 1460.07], [1021.03, 368.02], [1260.78, 1571.9], [93.16, 911.26],\n [234.85, 914.14], [383.34, 1140.97], [375.46, 853.36], [256.73, 597.61],\n [338.32, 502.28], [754.67, 337.95], [1... |
# Generated by Django 3.2 on 2021-08-25 14:44
import django.contrib.gis.db.models.fields
from django.db import migrations, models
import django.db.models.deletion
import django.utils.timezone
import fontawesome_5.fields
class Migration(migrations.Migration):
initial = True
dependencies = [
]
opera... | [
"django.db.models.OneToOneField",
"django.db.models.FloatField",
"django.db.models.IntegerField",
"django.db.models.ForeignKey",
"django.db.models.AutoField",
"django.db.models.DateTimeField",
"django.db.models.DecimalField",
"django.db.models.CharField"
] | [((442, 493), 'django.db.models.AutoField', 'models.AutoField', ([], {'primary_key': '(True)', 'serialize': '(False)'}), '(primary_key=True, serialize=False)\n', (458, 493), False, 'from django.db import migrations, models\n'), ((527, 566), 'django.db.models.DateTimeField', 'models.DateTimeField', ([], {'auto_now_add':... |
from tlidb.examples.utils import move_to
from .algorithm import Algorithm
class DecoderAlgorithm(Algorithm):
def __init__(self, config, datasets):
super().__init__(config, datasets)
self.generation_config = config.generation_config
self.generate_during_training = config.generate_during_trai... | [
"tlidb.examples.utils.move_to"
] | [((1371, 1394), 'tlidb.examples.utils.move_to', 'move_to', (['X', 'self.device'], {}), '(X, self.device)\n', (1378, 1394), False, 'from tlidb.examples.utils import move_to\n'), ((1226, 1258), 'tlidb.examples.utils.move_to', 'move_to', (['X_generate', 'self.device'], {}), '(X_generate, self.device)\n', (1233, 1258), Fal... |
from typing import Tuple, Optional
import ray
from ray import workflow
@ray.remote
def intentional_fail() -> str:
raise RuntimeError("oops")
@ray.remote
def cry(error: Exception) -> None:
print("Sadly", error)
@ray.remote
def celebrate(result: str) -> None:
print("Success!", result)
@ray.remote
def... | [
"ray.workflow.options"
] | [((845, 884), 'ray.workflow.options', 'workflow.options', ([], {'catch_exceptions': '(True)'}), '(catch_exceptions=True)\n', (861, 884), False, 'from ray import workflow\n')] |
"""Convert the output format of fairseq.generate to the input format of the evaluation script."""
from argparse import ArgumentParser
from collections import defaultdict
def main():
parser = ArgumentParser()
parser.add_argument('src', help='path to source')
parser.add_argument('tgt', help='path to target... | [
"collections.defaultdict",
"argparse.ArgumentParser"
] | [((198, 214), 'argparse.ArgumentParser', 'ArgumentParser', ([], {}), '()\n', (212, 214), False, 'from argparse import ArgumentParser\n'), ((592, 609), 'collections.defaultdict', 'defaultdict', (['list'], {}), '(list)\n', (603, 609), False, 'from collections import defaultdict\n')] |
import json
import os
from bakker.storage import FileSystemStorage
class Config:
USER_DIR = os.path.expanduser('~')
CONFIG_FILE = os.path.join(USER_DIR, '.bakker/config.json')
def __init__(self):
if os.path.isfile(self.CONFIG_FILE):
with open(self.CONFIG_FILE, 'r') as f:
... | [
"os.path.expanduser",
"os.path.join",
"os.path.isfile",
"os.path.dirname",
"json.load",
"json.dump"
] | [((106, 129), 'os.path.expanduser', 'os.path.expanduser', (['"""~"""'], {}), "('~')\n", (124, 129), False, 'import os\n'), ((149, 194), 'os.path.join', 'os.path.join', (['USER_DIR', '""".bakker/config.json"""'], {}), "(USER_DIR, '.bakker/config.json')\n", (161, 194), False, 'import os\n'), ((234, 266), 'os.path.isfile'... |
import requests
url = "http://0.0.0.0:8017/sentrewrite"
data = {
"utterances_histories": [
[["do you know <NAME>?"], ["yes, he is a football player."], ["who is the best, he or c.ronaldo?"]]
],
"annotation_histories": [
[
{"ner": [[{"confidence": 1, "end_pos": 24, "start_pos": ... | [
"requests.post"
] | [((1532, 1561), 'requests.post', 'requests.post', (['url'], {'json': 'data'}), '(url, json=data)\n', (1545, 1561), False, 'import requests\n')] |
import collections
import os
from itertools import product
from pathlib import Path
from typing import Dict, Iterator, List, NamedTuple, Optional, OrderedDict, Sequence, Tuple, Union
import numpy as np
import xarray as xr
from tqdm import tqdm
from bioimageio.core import image_helper
from bioimageio.core import load_... | [
"bioimageio.core.load_resource_description",
"bioimageio.core.image_helper.load_tensors",
"bioimageio.core.prediction_pipeline.create_prediction_pipeline",
"itertools.product",
"tqdm.tqdm",
"bioimageio.core.image_helper.save_image",
"numpy.zeros",
"xarray.DataArray",
"bioimageio.core.image_helper.pa... | [((1538, 1554), 'itertools.product', 'product', (['*ranges'], {}), '(*ranges)\n', (1545, 1554), False, 'from itertools import product\n'), ((14736, 14802), 'bioimageio.core.image_helper.load_tensors', 'image_helper.load_tensors', (['inputs', 'prediction_pipeline.input_specs'], {}), '(inputs, prediction_pipeline.input_s... |
from app import db
def populate_mongo():
if 'expressions' in db.collection_names():
db.drop_collection('expressions')
expressions_entries = [
{
"name": "1",
"expression": "$A = \\begin{pmatrix}c_{11} & c_{12} & c_{13} & c_{14} & c_{15}\\\\ c_{21} & c_{22} & c_{23} & c_... | [
"app.db.drop_collection",
"app.db.collection_names",
"app.db.expressions.insert"
] | [((1791, 1833), 'app.db.expressions.insert', 'db.expressions.insert', (['expressions_entries'], {}), '(expressions_entries)\n', (1812, 1833), False, 'from app import db\n'), ((67, 88), 'app.db.collection_names', 'db.collection_names', ([], {}), '()\n', (86, 88), False, 'from app import db\n'), ((98, 131), 'app.db.drop_... |
import random
import numpy as np
def set_seed(random_state: int = 42) -> None:
"""Function fixes random state to ensure results are reproducible"""
np.random.seed(random_state)
random.seed(random_state)
| [
"numpy.random.seed",
"random.seed"
] | [((159, 187), 'numpy.random.seed', 'np.random.seed', (['random_state'], {}), '(random_state)\n', (173, 187), True, 'import numpy as np\n'), ((192, 217), 'random.seed', 'random.seed', (['random_state'], {}), '(random_state)\n', (203, 217), False, 'import random\n')] |
"""
Train a model on the Reddit dataset by Khodak.
"""
import functools
import time
import logging
import pickle
import os
import pandas as pd
from sklearn.model_selection import train_test_split
from simpletransformers.classification import ClassificationModel, ClassificationArgs
from utils import (
hour_min_se... | [
"logging.basicConfig",
"simpletransformers.classification.ClassificationArgs",
"pickle.dump",
"pandas.read_csv",
"sklearn.model_selection.train_test_split",
"pandas.StringDtype",
"utils.has_markdown",
"time.perf_counter",
"functools.wraps",
"utils.combine_with_context",
"simpletransformers.class... | [((525, 839), 'simpletransformers.classification.ClassificationArgs', 'ClassificationArgs', ([], {'eval_batch_size': 'BATCH_SIZE', 'train_batch_size': 'BATCH_SIZE', 'evaluate_during_training': '(True)', 'evaluate_during_training_verbose': '(True)', 'use_multiprocessing': '(False)', 'use_multiprocessing_for_evaluation':... |
from django.dispatch import Signal
# sent when a user creates their own Visitor - can
# be used to send the email with the token
# kwargs: visitor
self_service_visitor_created = Signal()
| [
"django.dispatch.Signal"
] | [((179, 187), 'django.dispatch.Signal', 'Signal', ([], {}), '()\n', (185, 187), False, 'from django.dispatch import Signal\n')] |
#python3
import os
import sys
import statistics as s
import pandas as pd
from find_loss import *
##########################
## statistics on orthogroups
##########################
"""if len(sys.argv) != 5:
print("Need 4 arguments: [Orthologous group input file] [LECA orthologous groups input list] [method name] [stat... | [
"statistics.mean",
"os.path.exists",
"os.path.getsize",
"statistics.stdev",
"pandas.read_csv",
"statistics.median",
"sys.exit",
"pandas.concat"
] | [((4851, 4875), 'os.path.exists', 'os.path.exists', (['out_file'], {}), '(out_file)\n', (4865, 4875), False, 'import os\n'), ((3052, 3072), 'statistics.median', 's.median', (['seq_counts'], {}), '(seq_counts)\n', (3060, 3072), True, 'import statistics as s\n'), ((4185, 4210), 'statistics.median', 's.median', (['seq_lec... |
# -*- coding: utf-8 -*-
# Generated by Django 1.11.5 on 2017-10-17 06:04
from __future__ import unicode_literals
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('api', '0007_auto_20171005_1713'),
]
operations = [... | [
"django.db.migrations.DeleteModel",
"django.db.models.ForeignKey",
"django.db.models.IntegerField",
"django.db.models.AutoField",
"django.db.migrations.RemoveField",
"django.db.models.CharField"
] | [((3922, 3981), 'django.db.migrations.RemoveField', 'migrations.RemoveField', ([], {'model_name': '"""skill"""', 'name': '"""category"""'}), "(model_name='skill', name='category')\n", (3944, 3981), False, 'from django.db import migrations, models\n'), ((4026, 4062), 'django.db.migrations.DeleteModel', 'migrations.Delet... |
# Copyright (C) 2020 Intel Corporation
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in wri... | [
"torch.tensor",
"torch.isinf",
"torch.stack",
"torch.arange"
] | [((1034, 1053), 'torch.tensor', 'torch.tensor', (['masks'], {}), '(masks)\n', (1046, 1053), False, 'import torch\n'), ((1071, 1091), 'torch.tensor', 'torch.tensor', (['bboxes'], {}), '(bboxes)\n', (1083, 1091), False, 'import torch\n'), ((1109, 1129), 'torch.tensor', 'torch.tensor', (['labels'], {}), '(labels)\n', (112... |
# 25 February 2019 - <NAME> <<EMAIL>>
import sys
from src.text_classifier_deprn_rates import DeprnPredictor
predict = DeprnPredictor()
print('Evaluate using user input.\n')
user_description = ['']
print('\"QQ\" to quit.')
print('\"CR\" to see classification report.')
print('Otherwise...')
while True:
user_desc... | [
"src.text_classifier_deprn_rates.DeprnPredictor",
"sys.exit"
] | [((122, 138), 'src.text_classifier_deprn_rates.DeprnPredictor', 'DeprnPredictor', ([], {}), '()\n', (136, 138), False, 'from src.text_classifier_deprn_rates import DeprnPredictor\n'), ((489, 499), 'sys.exit', 'sys.exit', ([], {}), '()\n', (497, 499), False, 'import sys\n')] |
#!/usr/bin/env python
#
# Copyright 2019 DFKI GmbH.
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the
# "Software"), to deal in the Software without restriction, including
# without limitation the rights to use, copy, modify, merg... | [
"numpy.eye",
"transformations.euler_from_matrix",
"transformations.euler_matrix",
"anim_utils.animation_data.SkeletonBuilder",
"numpy.asarray",
"anim_utils.utilities.custom_math.angle_between_vectors",
"numpy.array",
"numpy.zeros",
"numpy.dot",
"numpy.deg2rad",
"numpy.linalg.norm",
"numpy.rad2... | [((2074, 2083), 'numpy.eye', 'np.eye', (['(4)'], {}), '(4)\n', (2080, 2083), True, 'import numpy as np\n'), ((3114, 3149), 'numpy.zeros', 'np.zeros', (['(self.n_frames, LEN_ROOT)'], {}), '((self.n_frames, LEN_ROOT))\n', (3122, 3149), True, 'import numpy as np\n'), ((4780, 4797), 'numpy.asarray', 'np.asarray', (['speed'... |
# -*- coding: utf-8 -*-
'''
Copyright 2019, University of Freiburg.
Chair of Algorithms and Data Structures.
<NAME> <<EMAIL>>
'''
import argparse
import unittest
import torch
import tests.utils as test_utils
from fairseq.data.tokenizers.character_tokenizer import CharacterTokenizer
class TestCharacterTokenizer(uni... | [
"fairseq.data.tokenizers.character_tokenizer.CharacterTokenizer"
] | [((395, 480), 'fairseq.data.tokenizers.character_tokenizer.CharacterTokenizer', 'CharacterTokenizer', ([], {'start_tokens': "['<S1>', '<S2>']", 'end_tokens': "['</S2>', '</S1>']"}), "(start_tokens=['<S1>', '<S2>'], end_tokens=['</S2>', '</S1>']\n )\n", (413, 480), False, 'from fairseq.data.tokenizers.character_token... |
from faktura import app
from flask import request, render_template, send_file, redirect, make_response, jsonify
from faktura.breadcrumbs import breadcrumbs
from faktura.models import db, TemplateVariable, User
from flask.ext.login import login_required
from faktura.csrf import generate_csrf_token
@app.route('/setting... | [
"faktura.csrf.generate_csrf_token",
"faktura.models.TemplateVariable.query.all",
"faktura.models.TemplateVariable.query.filter",
"faktura.models.db.session.add",
"faktura.app.route",
"faktura.models.db.session.delete",
"faktura.breadcrumbs.breadcrumbs",
"faktura.models.db.session.commit",
"faktura.m... | [((301, 323), 'faktura.app.route', 'app.route', (['"""/settings"""'], {}), "('/settings')\n", (310, 323), False, 'from faktura import app\n'), ((549, 592), 'faktura.app.route', 'app.route', (['"""/vars/create"""'], {'methods': "['POST']"}), "('/vars/create', methods=['POST'])\n", (558, 592), False, 'from faktura import... |
from django.contrib import admin
from .models import Payload
class PayloadAdmin(admin.ModelAdmin):
list_display = ('method', 'path','get','post')
search_fields = ('get','post')
admin.site.register(Payload, PayloadAdmin) | [
"django.contrib.admin.site.register"
] | [((187, 229), 'django.contrib.admin.site.register', 'admin.site.register', (['Payload', 'PayloadAdmin'], {}), '(Payload, PayloadAdmin)\n', (206, 229), False, 'from django.contrib import admin\n')] |
import time
import GRBL
start_crdnts_up = {} #start coordinates
start_crdnts_dn = {} #start coordinates
pass_crdnts_up = {} #test pass stack
pass_crdnts_dn = {} #test pass stack
fail_crdnts_up = {} #test fail stack
fail_crdnts_dn = {} #test fail stack
camera_cordnts_up = {} #camera locations
camera_cordnts_dn = {} ... | [
"time.sleep"
] | [((505, 527), 'time.sleep', 'time.sleep', (['sleep_time'], {}), '(sleep_time)\n', (515, 527), False, 'import time\n'), ((660, 682), 'time.sleep', 'time.sleep', (['sleep_time'], {}), '(sleep_time)\n', (670, 682), False, 'import time\n'), ((753, 775), 'time.sleep', 'time.sleep', (['sleep_time'], {}), '(sleep_time)\n', (7... |
# -*- coding: utf-8 -*-
import os
import sys
__author__ = '<NAME>'
__version__ = '0.1'
__ppath__ = os.path.dirname(os.path.realpath(__file__))
if __ppath__ not in sys.path:
sys.path.append(os.path.dirname(__ppath__))
from flask import Flask
app = Flask(__name__)
from cp_validator import extractor
postals = extr... | [
"cp_validator.extractor.get_postal",
"os.path.dirname",
"os.path.realpath",
"flask.Flask"
] | [((254, 269), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (259, 269), False, 'from flask import Flask\n'), ((316, 338), 'cp_validator.extractor.get_postal', 'extractor.get_postal', ([], {}), '()\n', (336, 338), False, 'from cp_validator import extractor\n'), ((117, 143), 'os.path.realpath', 'os.path.rea... |
import random
import torch
import torch.nn as nn
from pathlib import Path
from torch.utils.data import Dataset, DataLoader
RAW_PATH = 'src/data/datasets/Stocks/raw'
APIKEY = 'A6YNKD8LYDFDEALD'
class Stocks (Dataset):
def __init__(self, seq_len: int = 20, split: str = 'train'):
self.seq_len = seq_len
... | [
"os.path.exists",
"pathlib.Path",
"torch.load",
"time.sleep",
"torch.tensor",
"rich.print",
"torch.save",
"torch.utils.data.DataLoader",
"alpha_vantage.timeseries.TimeSeries"
] | [((1784, 1827), 'alpha_vantage.timeseries.TimeSeries', 'TimeSeries', ([], {'key': 'APIKEY', 'output_format': '"""csv"""'}), "(key=APIKEY, output_format='csv')\n", (1794, 1827), False, 'from alpha_vantage.timeseries import TimeSeries\n'), ((3007, 3048), 'rich.print', 'print', (['"""Dataset Downloaded Successfully!"""'],... |
from datetime import datetime, timezone
from flask import abort
from flask_unchained import BundleConfig
from http import HTTPStatus
from .forms import (
LoginForm,
RegisterForm,
ForgotPasswordForm,
ResetPasswordForm,
ChangePasswordForm,
SendConfirmationForm,
)
from .models import AnonymousUser... | [
"flask.abort",
"datetime.datetime.now"
] | [((8358, 8388), 'flask.abort', 'abort', (['HTTPStatus.UNAUTHORIZED'], {}), '(HTTPStatus.UNAUTHORIZED)\n', (8363, 8388), False, 'from flask import abort\n'), ((8621, 8647), 'datetime.datetime.now', 'datetime.now', (['timezone.utc'], {}), '(timezone.utc)\n', (8633, 8647), False, 'from datetime import datetime, timezone\n... |
try:
from Cython.Build import cythonize
ext_modules = cythonize(['sic/core.py', 'sic/implicit.py'], compiler_directives={'language_level': '3'})
except:
pass
| [
"Cython.Build.cythonize"
] | [((62, 157), 'Cython.Build.cythonize', 'cythonize', (["['sic/core.py', 'sic/implicit.py']"], {'compiler_directives': "{'language_level': '3'}"}), "(['sic/core.py', 'sic/implicit.py'], compiler_directives={\n 'language_level': '3'})\n", (71, 157), False, 'from Cython.Build import cythonize\n')] |
from flask import request
from flask_restful import Resource, abort
from flask_jwt_extended import get_jwt_identity
from helpers import jwt_refresh_required
from helpers.genders import genders
from helpers.email import send_validation_email
from models.user import User, get_full_user
from models.validation import Val... | [
"helpers.Arguments",
"models.user.get_full_user",
"secrets.token_urlsafe",
"models.user.User.get",
"flask_jwt_extended.get_jwt_identity",
"helpers.email.send_validation_email"
] | [((532, 555), 'helpers.Arguments', 'Arguments', (['request.json'], {}), '(request.json)\n', (541, 555), False, 'from helpers import Arguments\n'), ((936, 968), 'models.user.User.get', 'User.get', ([], {'username': 'args.username'}), '(username=args.username)\n', (944, 968), False, 'from models.user import User, get_ful... |
import numpy as np
import pydensecrf.densecrf as dcrf
from pydensecrf.utils import compute_unary, create_pairwise_bilateral, create_pairwise_gaussian, unary_from_softmax
def dense_crf(img, prob):
'''
input:
img: numpy array of shape (num of channels, height, width)
prob: numpy array of shape (9, hei... | [
"pydensecrf.densecrf.DenseCRF2D",
"numpy.argmax",
"numpy.ascontiguousarray",
"numpy.swapaxes",
"pydensecrf.utils.unary_from_softmax"
] | [((733, 755), 'numpy.swapaxes', 'np.swapaxes', (['img', '(0)', '(2)'], {}), '(img, 0, 2)\n', (744, 755), True, 'import numpy as np\n'), ((848, 871), 'numpy.swapaxes', 'np.swapaxes', (['prob', '(1)', '(2)'], {}), '(prob, 1, 2)\n', (859, 871), True, 'import numpy as np\n'), ((945, 1001), 'pydensecrf.densecrf.DenseCRF2D',... |
import os
import numpy
import scipy
import scipy.optimize
from cryspy.A_functions_base.symmetry_elements import \
calc_asymmetric_unit_cell_indexes
from cryspy.A_functions_base.mempy import \
calc_mem_col, \
calc_mem_chi, \
calc_symm_elem_points_by_index_points, \
get_uniform_density_col, \
re... | [
"numpy.prod",
"cryspy.A_functions_base.orbital_functions.calc_density_spherical",
"cryspy.A_functions_base.flip_ratio.calc_flip_ratio_by_iint",
"numpy.sqrt",
"cryspy.A_functions_base.matrix_operations.calc_vv_as_v1_v2_v1",
"numpy.logical_not",
"numpy.array",
"cryspy.A_functions_base.flip_ratio.calc_as... | [((4346, 4403), 'cryspy.A_functions_base.symmetry_elements.calc_asymmetric_unit_cell_indexes', 'calc_asymmetric_unit_cell_indexes', (['n_abc', 'full_symm_elems'], {}), '(n_abc, full_symm_elems)\n', (4379, 4403), False, 'from cryspy.A_functions_base.symmetry_elements import calc_asymmetric_unit_cell_indexes\n'), ((4424,... |
# -*- coding: utf-8 -*-
"""
Map creation script
"""
import sys
import os
from configparser import ConfigParser
import math
from PIL import Image
import urllib.request, urllib.parse, urllib.error
# tile positions, see https://wiki.openstreetmap.org/wiki/Slippy_map_tilenames#Lon..2Flat._to_tile_numbers_2
def deg2num(l... | [
"os.path.exists",
"PIL.Image.open",
"configparser.ConfigParser",
"os.makedirs",
"math.tan",
"PIL.Image.new",
"os.path.join",
"math.radians",
"math.cos"
] | [((578, 592), 'configparser.ConfigParser', 'ConfigParser', ([], {}), '()\n', (590, 592), False, 'from configparser import ConfigParser\n'), ((1560, 1593), 'PIL.Image.new', 'Image.new', (['"""RGB"""', '(width, height)'], {}), "('RGB', (width, height))\n", (1569, 1593), False, 'from PIL import Image\n'), ((358, 379), 'ma... |
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.ticker import MultipleLocator
from tqdm import tqdm
import torch
from torch.utils.data import DataLoader
import torch.nn.functional as F
from model.model import BaseNet
from model.config import arguments
from dataset.dataset import FlowerData
def ge... | [
"torch.max",
"dataset.dataset.FlowerData",
"torch.cuda.is_available",
"matplotlib.pyplot.switch_backend",
"model.config.arguments",
"torch.nn.functional.softmax",
"numpy.save",
"matplotlib.pyplot.close",
"model.model.BaseNet",
"matplotlib.pyplot.savefig",
"numpy.ones",
"torch.device",
"matpl... | [((485, 518), 'model.model.BaseNet', 'BaseNet', ([], {'num_class': 'args.class_num'}), '(num_class=args.class_num)\n', (492, 518), False, 'from model.model import BaseNet\n'), ((820, 894), 'numpy.zeros', 'np.zeros', (['(args.class_num * args.num_image_per_class // 2, args.class_num)'], {}), '((args.class_num * args.num... |
import datetime as dt
from re import T
from sqlalchemy.schema import Column
from sqlalchemy.types import String, DateTime
from uuid import UUID, uuid4
import bigfastapi.db.database as database
class Role(database.Base):
__tablename__ = "roles"
id = Column(String(255), primary_key=True, index=True, default=uuid... | [
"sqlalchemy.types.String",
"uuid.uuid4"
] | [((265, 276), 'sqlalchemy.types.String', 'String', (['(255)'], {}), '(255)\n', (271, 276), False, 'from sqlalchemy.types import String, DateTime\n'), ((358, 369), 'sqlalchemy.types.String', 'String', (['(255)'], {}), '(255)\n', (364, 369), False, 'from sqlalchemy.types import String, DateTime\n'), ((406, 417), 'sqlalch... |
# Generated by Django 3.0.5 on 2020-04-20 15:21
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('api', '0001_initial'),
]
operations = [
migrations.AlterField(
model_name='domain',
name='client_ip',
fi... | [
"django.db.models.GenericIPAddressField"
] | [((324, 401), 'django.db.models.GenericIPAddressField', 'models.GenericIPAddressField', ([], {'blank': '(True)', 'null': '(True)', 'verbose_name': '"""Client IP"""'}), "(blank=True, null=True, verbose_name='Client IP')\n", (352, 401), False, 'from django.db import migrations, models\n')] |
import requests
import calendar
import keys
api_call = 'https://api.openweathermap.org/data/2.5/forecast?appid=' + keys.api_key
running = True
# Program loop
while running:
# Asks the user for the city or zip code to be queried
while True:
# Input validation
try:
print('\nThis a... | [
"requests.get"
] | [((1330, 1352), 'requests.get', 'requests.get', (['api_call'], {}), '(api_call)\n', (1342, 1352), False, 'import requests\n')] |
# -*- coding: utf-8 -*-
# Copyright Noronha Development Team
#
# 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 applica... | [
"mongoengine.fields.BooleanField",
"mongoengine.fields.ReferenceField",
"mongoengine.fields.StringField",
"mongoengine.fields.EmbeddedDocumentField",
"mongoengine.fields.DictField"
] | [((1437, 1481), 'mongoengine.fields.StringField', 'StringField', ([], {'max_length': 'DBConst.MAX_NAME_LEN'}), '(max_length=DBConst.MAX_NAME_LEN)\n', (1448, 1481), False, 'from mongoengine.fields import StringField, DictField, ReferenceField, EmbeddedDocumentField, BooleanField\n'), ((1494, 1544), 'mongoengine.fields.E... |
"""
Run code in background indefinitely
This module allows you to keep running a script in the background indefinitely.
A great usage of this is fetching data in background and sending notifications with :py:mod:`notifications`. You can also run a server or a Discord bot for example.
Note: Because of privacy, apps ca... | [
"sys.excepthook",
"threading.current_thread",
"time.sleep",
"datetime.datetime.now",
"pyto.__Class__",
"os.path.abspath"
] | [((2831, 2845), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (2843, 2845), False, 'from datetime import datetime\n'), ((3332, 3346), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (3344, 3346), False, 'from datetime import datetime\n'), ((3573, 3585), 'time.sleep', 'sleep', (['delay'], {}), '(... |
import socket
import re
def get_local_adr():
address_set = socket.getaddrinfo(socket.gethostname(), None, family=2)
for address in address_set:
if re.match("192.168.", address[4][0]):
local_network_addr = address[4][0]
return local_network_addr
return "ADDRESS_NOT_FOUND"
| [
"socket.gethostname",
"re.match"
] | [((84, 104), 'socket.gethostname', 'socket.gethostname', ([], {}), '()\n', (102, 104), False, 'import socket\n'), ((165, 200), 're.match', 're.match', (['"""192.168."""', 'address[4][0]'], {}), "('192.168.', address[4][0])\n", (173, 200), False, 'import re\n')] |
import unittest
import warnings
from parse_python_indentation import parse_indentation
good_output = [
{'key': 'green:',
'offspring': [
{'key': 'follow', 'offspring': []},
{'key': 'blue', 'offspring': []},
{'key': 'yellow', 'offspring': []},
{'key': 'fishing', 'offspring': []},
{'key': 'sn... | [
"unittest.main",
"warnings.simplefilter",
"warnings.catch_warnings",
"parse_python_indentation.parse_indentation"
] | [((1416, 1431), 'unittest.main', 'unittest.main', ([], {}), '()\n', (1429, 1431), False, 'import unittest\n'), ((869, 895), 'parse_python_indentation.parse_indentation', 'parse_indentation', (['rawdata'], {}), '(rawdata)\n', (886, 895), False, 'from parse_python_indentation import parse_indentation\n'), ((1063, 1099), ... |
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Copyright 2018 Red Hat, Inc. and/or its affiliates
# and other contributors as indicated by the @author tags.
#
# 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... | [
"ansible.module_utils.basic.AnsibleModule",
"shade.openstack_cloud"
] | [((5349, 5406), 'ansible.module_utils.basic.AnsibleModule', 'AnsibleModule', ([], {'argument_spec': '{}', 'supports_check_mode': '(True)'}), '(argument_spec={}, supports_check_mode=True)\n', (5362, 5406), False, 'from ansible.module_utils.basic import AnsibleModule\n'), ((5522, 5545), 'shade.openstack_cloud', 'shade.op... |
# Copyright 2021 The TensorFlow Probability Authors.
#
# 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 o... | [
"numpy.array"
] | [((1821, 2027), 'numpy.array', 'np.array', (['[1.4802036, 1.8915913, -0.011120212, 1.1328301, 1.2841645, 0.6033605, -\n 1.887041, -2.012894, 0.046582267, 1.5555662, 0.4305847, -1.7179363, -\n 1.1399889, -0.4432812, -1.4721184, 0.35457477]'], {}), '([1.4802036, 1.8915913, -0.011120212, 1.1328301, 1.2841645, \n ... |
from django.views.generic import TemplateView
from django.utils.decorators import method_decorator
from django.contrib.auth.decorators import login_required
from django.shortcuts import render
from rest_framework.views import APIView
from rest_framework.response import Response
from rest_framework.permissions import I... | [
"django.shortcuts.render",
"rest_framework.response.Response",
"django.utils.decorators.method_decorator"
] | [((415, 447), 'django.utils.decorators.method_decorator', 'method_decorator', (['login_required'], {}), '(login_required)\n', (431, 447), False, 'from django.utils.decorators import method_decorator\n'), ((508, 543), 'django.shortcuts.render', 'render', (['request', 'self.template_name'], {}), '(request, self.template_... |
import sys
sys.path.append("../src/")
from DEVS import CoupledDEVS, AtomicDEVS, RootDEVS, directConnect
from infinity import INFINITY
from collections import defaultdict
from util import allZeroDict, addDict
from statesavers import PickleHighestState as state_saver
from message import NetworkMessage
from messageSchedu... | [
"statesavers.PickleHighestState",
"DEVS.CoupledDEVS.__init__",
"DEVS.AtomicDEVS.__init__",
"manualRelocator.ManualRelocator",
"cPickle.dumps",
"collections.defaultdict",
"util.addDict",
"messageScheduler.MessageScheduler",
"util.allZeroDict",
"DEVS.directConnect",
"sys.path.append",
"DEVS.Root... | [((11, 37), 'sys.path.append', 'sys.path.append', (['"""../src/"""'], {}), "('../src/')\n", (26, 37), False, 'import sys\n'), ((417, 451), 'DEVS.CoupledDEVS.__init__', 'CoupledDEVS.__init__', (['self', '"""root"""'], {}), "(self, 'root')\n", (437, 451), False, 'from DEVS import CoupledDEVS, AtomicDEVS, RootDEVS, direct... |
import torch
import torch.nn as nn
class LinearRegressionModel(nn.Module):
def __init__(self, input_dim, output_dim):
super().__init__()
self.Linear = nn.Linear(input_dim, output_dim)
def forward(self, x):
out = self.Linear(x)
return out
| [
"torch.nn.Linear"
] | [((180, 212), 'torch.nn.Linear', 'nn.Linear', (['input_dim', 'output_dim'], {}), '(input_dim, output_dim)\n', (189, 212), True, 'import torch.nn as nn\n')] |
import logging
import uuid
from typing import Any
import pytest
import requests
import test_helpers
from dcos_test_utils import marathon
from dcos_test_utils.dcos_api import DcosApiSession
__maintainer__ = 'kensipe'
__contact__ = '<EMAIL>'
log = logging.getLogger(__name__)
def deploy_test_app_and_check(dcos_api_... | [
"logging.getLogger",
"test_helpers.marathon_test_app",
"uuid.uuid4",
"pytest.mark.parametrize",
"test_helpers.get_expanded_config",
"pytest.skip",
"test_helpers.docker_pull_image"
] | [((251, 278), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (268, 278), False, 'import logging\n'), ((3747, 3852), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""healthcheck"""', '[marathon.Healthcheck.HTTP, marathon.Healthcheck.MESOS_HTTP]'], {}), "('healthcheck', [marathon... |
import pytest
import numpy as np
import pandas as pd
import xarray as xr
import bmorph
from bmorph.util import mizuroute_utils as mizutil
reference = xr.open_dataset("./bmorph/tests/data/test_reference.nc")
routed = xr.open_dataset("./bmorph/tests/data/test_routed.nc")
topo = xr.open_dataset("./bmorph/tests/data/tes... | [
"bmorph.util.mizuroute_utils.find_up",
"bmorph.util.mizuroute_utils.find_max_kge",
"bmorph.util.mizuroute_utils.find_min_kldiv",
"bmorph.util.mizuroute_utils.map_headwater_sites",
"bmorph.util.mizuroute_utils.find_max_r2",
"numpy.isnan",
"bmorph.util.mizuroute_utils.map_ref_sites",
"xarray.open_datase... | [((153, 209), 'xarray.open_dataset', 'xr.open_dataset', (['"""./bmorph/tests/data/test_reference.nc"""'], {}), "('./bmorph/tests/data/test_reference.nc')\n", (168, 209), True, 'import xarray as xr\n'), ((219, 272), 'xarray.open_dataset', 'xr.open_dataset', (['"""./bmorph/tests/data/test_routed.nc"""'], {}), "('./bmorph... |
import asyncio
from types import TracebackType
from typing import Optional, Type, Any
class Wire:
def configure(self, value: Any) -> None:
pass
async def __aenter__(self) -> None:
pass
async def __aexit__(
self,
exc_type: Optional[Type[BaseException]],
exc_val: Op... | [
"asyncio.Event"
] | [((692, 707), 'asyncio.Event', 'asyncio.Event', ([], {}), '()\n', (705, 707), False, 'import asyncio\n'), ((842, 857), 'asyncio.Event', 'asyncio.Event', ([], {}), '()\n', (855, 857), False, 'import asyncio\n')] |
from typing import Tuple
import torch
from torch import nn
from torch.utils.tensorboard import SummaryWriter
from tensorboard_pytorch_examples.common.config import (
CPU_DEVICE,
DEFAULT_EPOCHS_COUNT,
DEVICE,
)
class ClassificationTrainer:
def __init__(
self,
trainloader: torch.utils.... | [
"torch.no_grad",
"torch.tensor"
] | [((5006, 5021), 'torch.no_grad', 'torch.no_grad', ([], {}), '()\n', (5019, 5021), False, 'import torch\n'), ((4795, 4812), 'torch.tensor', 'torch.tensor', (['(0.0)'], {}), '(0.0)\n', (4807, 4812), False, 'import torch\n'), ((4847, 4864), 'torch.tensor', 'torch.tensor', (['(0.0)'], {}), '(0.0)\n', (4859, 4864), False, '... |
from __future__ import absolute_import
from __future__ import unicode_literals
from django.utils.translation import ugettext_lazy as _
REMINDER_TRANS = _("Did you receive or transfer stock to another facility last month?"
" Please reply either 'trans no' or 'trans yes'")
TRANS_HELP = _("You can resp... | [
"django.utils.translation.ugettext_lazy"
] | [((153, 274), 'django.utils.translation.ugettext_lazy', '_', (['"""Did you receive or transfer stock to another facility last month? Please reply either \'trans no\' or \'trans yes\'"""'], {}), '("Did you receive or transfer stock to another facility last month? Please reply either \'trans no\' or \'trans yes\'"\n )... |