code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
"""Interface functions to automatically get descriptors."""
from mala.descriptors.snap import SNAP
def DescriptorInterface(params):
"""
Return a DescriptorBase object that adheres to the parameters provided.
Parameters
----------
params : mala.common.parameters.Parameters
Parameters for w... | [
"mala.descriptors.snap.SNAP"
] | [((437, 449), 'mala.descriptors.snap.SNAP', 'SNAP', (['params'], {}), '(params)\n', (441, 449), False, 'from mala.descriptors.snap import SNAP\n')] |
import logging
from flask import Blueprint, request
from itsdangerous import BadSignature
from flask.ext.babel import gettext
from aleph.core import db, settings
from aleph.search import QueryParser, DatabaseQueryResult
from aleph.model import Role, Permission, Audit
from aleph.logic.roles import check_visible, check_... | [
"logging.getLogger",
"aleph.views.util.serialize_data",
"aleph.logic.collections.update_collection_access.delay",
"aleph.model.Role.all_groups",
"aleph.logic.roles.check_editable",
"aleph.logic.roles.update_role",
"aleph.views.util.get_db_collection",
"aleph.logic.collections.update_collection",
"al... | [((845, 877), 'flask.Blueprint', 'Blueprint', (['"""roles_api"""', '__name__'], {}), "('roles_api', __name__)\n", (854, 877), False, 'from flask import Blueprint, request\n'), ((884, 911), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (901, 911), False, 'import logging\n'), ((992, 1024),... |
# PYTHON_ARGCOMPLETE_OK
import argcomplete
import argparse
from . import io
from . import cfg
from . import utils
@utils.logExceptionsAndRaise
def main():
# show startup message
io.startup()
# options used by multiple subparsers
def addVerboseArg(parser):
parser.add_argument('-v', '--verbose', action='... | [
"argcomplete.autocomplete",
"argparse.ArgumentParser"
] | [((594, 619), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (617, 619), False, 'import argparse\n'), ((8945, 8972), 'argcomplete.autocomplete', 'argcomplete.autocomplete', (['p'], {}), '(p)\n', (8969, 8972), False, 'import argcomplete\n')] |
from eylanglexer import reserved
from eylanglexer import rules as lex_rules
from eylanginterpreter import *
from rply import ParserGenerator
EYLANG_VARS = EylangVars()
pg = ParserGenerator(
list(reserved.values()) + [name for name, _ in lex_rules],
precedence=[
('left', ['AND', 'OR', 'NOT']),
... | [
"eylanglexer.reserved.values"
] | [((202, 219), 'eylanglexer.reserved.values', 'reserved.values', ([], {}), '()\n', (217, 219), False, 'from eylanglexer import reserved\n')] |
from rest_framework.viewsets import ModelViewSet
from orders.models import OrderInfo
from meiduo_admin.utils import PageNum
from meiduo_admin.serializers.order import OrderSeriazlier
from rest_framework.decorators import action
from rest_framework.response import Response
class OrdersView(ModelViewSet):
serializer... | [
"orders.models.OrderInfo.objects.all",
"rest_framework.response.Response",
"rest_framework.decorators.action"
] | [((360, 383), 'orders.models.OrderInfo.objects.all', 'OrderInfo.objects.all', ([], {}), '()\n', (381, 383), False, 'from orders.models import OrderInfo\n'), ((448, 484), 'rest_framework.decorators.action', 'action', ([], {'methods': "['put']", 'detail': '(True)'}), "(methods=['put'], detail=True)\n", (454, 484), False,... |
import unittest
from unittest import TestCase
from importCertificate import getCommandForImport
class TestImportCertificate(TestCase):
def test_getKeyStoreCommand(self):
command = getCommandForImport("certbotlocation", "location", "password")
self.assertEqual(command, "keytool -import -trustcacer... | [
"unittest.main",
"importCertificate.getCommandForImport"
] | [((195, 257), 'importCertificate.getCommandForImport', 'getCommandForImport', (['"""certbotlocation"""', '"""location"""', '"""password"""'], {}), "('certbotlocation', 'location', 'password')\n", (214, 257), False, 'from importCertificate import getCommandForImport\n'), ((465, 480), 'unittest.main', 'unittest.main', ([... |
#!/usr/bin/env python
# -*- coding: utf8 -*-
# *****************************************************************
# ** PTS -- Python Toolkit for working with SKIRT **
# ** © Astronomical Observatory, Ghent University **
# *****************************************************************
##... | [
"numpy.ma.max",
"astropy.stats.sigma_clip",
"numpy.log",
"numpy.array",
"copy.deepcopy",
"numpy.ma.masked_array",
"astropy.stats.sigma_clipped_stats",
"numpy.zeros_like"
] | [((1256, 1309), 'astropy.stats.sigma_clip', 'sigma_clip', (['data'], {'sigma': 'sigma', 'iters': 'None', 'copy': '(False)'}), '(data, sigma=sigma, iters=None, copy=False)\n', (1266, 1309), False, 'from astropy.stats import sigma_clip, sigma_clipped_stats\n'), ((1979, 2042), 'astropy.stats.sigma_clip', 'sigma_clip', (['... |
import unittest
b32 = 0xFFFFFFFF
def bitInsertionFor(N, M, i, j):
clearmask = 0
for b in range(i, j):
clearmask |= 1 << b
clearmask = ~clearmask
r = N & clearmask
return r | (M << i)
def bitInsertionBit(N, M, i, j):
clearmask = (~1 & b32) << j
clearmask |= (1 << i) - 1
R = N &... | [
"unittest.main"
] | [((1210, 1225), 'unittest.main', 'unittest.main', ([], {}), '()\n', (1223, 1225), False, 'import unittest\n')] |
#!/usr/bin/python3
import sys
import subprocess
import pathlib
BROKER = "ig.com"
BASE_PATH = "/mnt/storage/Data/market/ig.com/dumps"
PREFIX = "full"
MARKETS = {
"CS.D.AUDNZD.MINI.IP": "AUDNZD",
"CS.D.AUDUSD.MINI.IP": "AUDUSD",
"CS.D.EURCAD.MINI.IP": "EURCAD",
"CS.D.EURCHF.MINI.IP": "EURCHF",
"CS.D... | [
"subprocess.Popen",
"pathlib.Path"
] | [((1218, 1249), 'pathlib.Path', 'pathlib.Path', (['BASE_PATH', 'market'], {}), '(BASE_PATH, market)\n', (1230, 1249), False, 'import pathlib\n'), ((1419, 1549), 'subprocess.Popen', 'subprocess.Popen', (["['python', 'siis.py', 'real', '--import', \n '--filename=%s/full-%s-%s-any.siis' % (src_path, BROKER, market)]"],... |
from flask import Blueprint, render_template, redirect, url_for,request, flash
from . import db
from .models import User
from flask_login import login_user, logout_user, login_required
auth = Blueprint("auth", __name__)
@auth.route("/login", methods=['GET', 'POST'])
def login():
email = request.form.get("email")
... | [
"flask.render_template",
"flask.flash",
"flask.url_for",
"flask.request.form.get",
"flask.Blueprint"
] | [((192, 219), 'flask.Blueprint', 'Blueprint', (['"""auth"""', '__name__'], {}), "('auth', __name__)\n", (201, 219), False, 'from flask import Blueprint, render_template, redirect, url_for, request, flash\n'), ((294, 319), 'flask.request.form.get', 'request.form.get', (['"""email"""'], {}), "('email')\n", (310, 319), Fa... |
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from os import path
def plot(args, conn):
df = pd.read_sql_query("select * from SHOT;", conn)
plt.hist(df["LENGTH"], bins=args.bins)
plt.xlabel("Shot length / m")
plt.ylabel("Count")
if args.log:
plt.yscale("log")
... | [
"pandas.read_sql_query",
"matplotlib.pyplot.hist",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"os.path.join",
"matplotlib.pyplot.yscale",
"matplotlib.pyplot.show"
] | [((124, 170), 'pandas.read_sql_query', 'pd.read_sql_query', (['"""select * from SHOT;"""', 'conn'], {}), "('select * from SHOT;', conn)\n", (141, 170), True, 'import pandas as pd\n'), ((176, 214), 'matplotlib.pyplot.hist', 'plt.hist', (["df['LENGTH']"], {'bins': 'args.bins'}), "(df['LENGTH'], bins=args.bins)\n", (184, ... |
from botorch.models.gpytorch import GPyTorchModel
from gpytorch.distributions import MultivariateNormal
from gpytorch.kernels import MaternKernel, ScaleKernel
from gpytorch.likelihoods import GaussianLikelihood
from gpytorch.means import ConstantMean
from gpytorch.models import ExactGP
from greattunes.transformed_kern... | [
"gpytorch.kernels.MaternKernel",
"gpytorch.means.ConstantMean",
"greattunes.transformed_kernel_models.transformation.GP_kernel_transform",
"gpytorch.distributions.MultivariateNormal",
"gpytorch.likelihoods.GaussianLikelihood"
] | [((958, 972), 'gpytorch.means.ConstantMean', 'ConstantMean', ([], {}), '()\n', (970, 972), False, 'from gpytorch.means import ConstantMean\n'), ((1743, 1778), 'gpytorch.distributions.MultivariateNormal', 'MultivariateNormal', (['mean_x', 'covar_x'], {}), '(mean_x, covar_x)\n', (1761, 1778), False, 'from gpytorch.distri... |
# ---
# Module to read grenoble.inp agenda (edt) and filter keep only the groups I belong to
# Configuration is done into configPhelma.py
#
# example of configPhelma.py (not commited for security raison)
#
# ICAL_FEED = 'https://loggin:passwd@edt.grenoble-inp.fr/directCal/2020-2021/etudiant/phelma?resources=20868,557... | [
"ics.Calendar",
"requests.get"
] | [((872, 882), 'ics.Calendar', 'Calendar', ([], {}), '()\n', (880, 882), False, 'from ics import Calendar, Event\n'), ((924, 941), 'requests.get', 'requests.get', (['url'], {}), '(url)\n', (936, 941), False, 'import requests\n')] |
# Python Standard Library Imports
import re
from utils import (
InputConfig,
ingest,
)
INPUT_FILE = '01.in'
EXPECTED_ANSWERS = (271, 153, )
# INPUT_FILE = '01.test.in'
# EXPECTED_ANSWERS = (8, 4, )
def main():
solution = Solution()
answers = (solution.solve1(), solution.solve2(), )
print(answe... | [
"utils.InputConfig",
"re.compile"
] | [((2780, 2827), 're.compile', 're.compile', (['"""^(?P<turn>R|L)(?P<distance>\\\\d+)$"""'], {}), "('^(?P<turn>R|L)(?P<distance>\\\\d+)$')\n", (2790, 2827), False, 'import re\n'), ((440, 468), 'utils.InputConfig', 'InputConfig', ([], {'as_oneline': '(True)'}), '(as_oneline=True)\n', (451, 468), False, 'from utils import... |
# -*- coding: utf-8 -*-
#!/usr/bin/env python3
"""
Servidor de Conexao
<NAME>
UFSJ
"""
import sys
import socket
import _thread as thread
import getpass
import xmlrpc.client
import pickle
from Usuario import Usuario
import ssl
import socket
class ServidorConexao(object):
"""docstring for ServidorConexao."""
def ... | [
"socket.socket",
"_thread.exit",
"pickle.dumps",
"ssl.create_default_context",
"pickle.loads",
"Usuario.Usuario"
] | [((410, 459), 'socket.socket', 'socket.socket', (['socket.AF_INET', 'socket.SOCK_STREAM'], {}), '(socket.AF_INET, socket.SOCK_STREAM)\n', (423, 459), False, 'import socket\n'), ((483, 534), 'ssl.create_default_context', 'ssl.create_default_context', (['ssl.Purpose.CLIENT_AUTH'], {}), '(ssl.Purpose.CLIENT_AUTH)\n', (509... |
import unittest
from core.picture import Picture
from PIL import Image
from shutil import copyfile, rmtree
import os
class PictureTestCase(unittest.TestCase):
def setUp(self):
self.current_dir = os.path.dirname(os.path.abspath(__file__))
self.test_dir = "{}{}test_dir".format(self.current_dir, os.p... | [
"os.path.splitext",
"core.picture.Picture",
"os.mkdir",
"shutil.rmtree",
"os.path.abspath"
] | [((394, 417), 'os.mkdir', 'os.mkdir', (['self.test_dir'], {}), '(self.test_dir)\n', (402, 417), False, 'import os\n'), ((451, 472), 'shutil.rmtree', 'rmtree', (['self.test_dir'], {}), '(self.test_dir)\n', (457, 472), False, 'from shutil import copyfile, rmtree\n'), ((597, 615), 'core.picture.Picture', 'Picture', (['fak... |
import sys
import numpy as np
from skimage.measure import label
def getSegType(mid):
m_type = np.uint64
if mid<2**8:
m_type = np.uint8
elif mid<2**16:
m_type = np.uint16
elif mid<2**32:
m_type = np.uint32
return m_type
def seg2Count(seg,do_sort=True,rm_zero=False):
sm =... | [
"numpy.unique",
"numpy.minimum",
"numpy.hstack",
"numpy.where",
"numpy.in1d",
"numpy.argsort",
"numpy.array",
"numpy.zeros",
"numpy.count_nonzero",
"numpy.stack",
"numpy.vstack",
"skimage.measure.label",
"numpy.maximum",
"sys.stdout.flush",
"numpy.arange"
] | [((2022, 2049), 'numpy.zeros', 'np.zeros', (['mid'], {'dtype': 'm_type'}), '(mid, dtype=m_type)\n', (2030, 2049), True, 'import numpy as np\n'), ((2348, 2365), 'numpy.where', 'np.where', (['(seg > 0)'], {}), '(seg > 0)\n', (2356, 2365), True, 'import numpy as np\n'), ((6322, 6371), 'numpy.zeros', 'np.zeros', (['(1 + um... |
import torch
import torch.nn as nn
import torch.nn.functional as F
class AttentionXCosNet(nn.Module):
def __init__(self, conf):
super(AttentionXCosNet, self).__init__()
self.embedding_net = nn.Sequential(
nn.Conv2d(32, 16, 3, padding=1),
nn.BatchNorm2d(16),
... | [
"torch.nn.BatchNorm2d",
"torch.nn.Dropout",
"torch.nn.Conv2d",
"torch.nn.PReLU",
"torch.nn.MaxPool2d",
"torch.nn.Linear",
"torch.cat"
] | [((1664, 1696), 'torch.cat', 'torch.cat', (['(conv1, conv2)'], {'dim': '(1)'}), '((conv1, conv2), dim=1)\n', (1673, 1696), False, 'import torch\n'), ((3001, 3033), 'torch.cat', 'torch.cat', (['(conv1, conv2)'], {'dim': '(1)'}), '((conv1, conv2), dim=1)\n', (3010, 3033), False, 'import torch\n'), ((4779, 4789), 'torch.n... |
# Copyright 2018 HTCondor Team, Computer Sciences Department,
# University of Wisconsin-Madison, WI.
#
# 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/LICE... | [
"pytest.raises",
"htmap.mapping.maps_dir_path"
] | [((948, 969), 'pytest.raises', 'pytest.raises', (['Marker'], {}), '(Marker)\n', (961, 969), False, 'import pytest\n'), ((1032, 1055), 'htmap.mapping.maps_dir_path', 'mapping.maps_dir_path', ([], {}), '()\n', (1053, 1055), False, 'from htmap import mapping\n')] |
"""
LFW dataloading
"""
import argparse
import time
import numpy as np
import torch
from PIL import Image
from torch.utils.data import DataLoader, Dataset
from torchvision import transforms
import os
import glob
import matplotlib.pyplot as plt
class LFWDataset(Dataset):
def __init__(self, path_to_folder: str, tr... | [
"numpy.mean",
"PIL.Image.open",
"matplotlib.pyplot.savefig",
"torchvision.transforms.RandomAffine",
"argparse.ArgumentParser",
"numpy.std",
"matplotlib.pyplot.axis",
"numpy.array",
"matplotlib.pyplot.figure",
"torch.utils.data.DataLoader",
"matplotlib.pyplot.title",
"torchvision.transforms.ToT... | [((1044, 1069), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (1067, 1069), False, 'import argparse\n'), ((1762, 1859), 'torch.utils.data.DataLoader', 'DataLoader', (['dataset'], {'batch_size': 'args.batch_size', 'shuffle': '(False)', 'num_workers': 'args.num_workers'}), '(dataset, batch_size=... |
import requests
lis = [
{'http': '172.16.17.32:8888'},
{'http': '192.168.3.11:3129'},
{'http': '172.16.58.3:8181'},
{'http': '172.16.31.10:8010'},
{'http': '172.16.31.10:80'},
{'http': '192.168.3.11:31773'},
]
headers = {
'User-Agent': 'Mozilla/5.0 (Windows NT 6.1; Win64; x64) Ap... | [
"requests.get"
] | [((514, 567), 'requests.get', 'requests.get', ([], {'url': 'url', 'headers': 'headers', 'proxies': 'proxy'}), '(url=url, headers=headers, proxies=proxy)\n', (526, 567), False, 'import requests\n')] |
import os
from pandas import Timedelta
import requests
import time
from . import get_airport_code_source
from ..caada_errors import HTMLRequestError
from ..caada_typing import pathlike
from ..caada_logging import logger
def _download_airport_codes(source='openflights', update='never'):
"""Download geographic dat... | [
"os.path.getmtime",
"pandas.Timedelta",
"time.time",
"requests.get"
] | [((2816, 2840), 'requests.get', 'requests.get', (['remote_url'], {}), '(remote_url)\n', (2828, 2840), False, 'import requests\n'), ((2148, 2176), 'os.path.getmtime', 'os.path.getmtime', (['local_file'], {}), '(local_file)\n', (2164, 2176), False, 'import os\n'), ((2195, 2206), 'time.time', 'time.time', ([], {}), '()\n'... |
from django.contrib import admin
from .models import Group, Event, Market, Order, MarketPosition, Trade, Account
admin.site.register(Group)
admin.site.register(Event)
admin.site.register(Market)
admin.site.register(Order)
admin.site.register(MarketPosition)
admin.site.register(Trade)
admin.site.register(Account) | [
"django.contrib.admin.site.register"
] | [((114, 140), 'django.contrib.admin.site.register', 'admin.site.register', (['Group'], {}), '(Group)\n', (133, 140), False, 'from django.contrib import admin\n'), ((141, 167), 'django.contrib.admin.site.register', 'admin.site.register', (['Event'], {}), '(Event)\n', (160, 167), False, 'from django.contrib import admin\... |
# This file is part of the QuTIpy package.
# https://github.com/sumeetkhatri/QuTIpy
#
# Copyright (c) 2022 <NAME>.
# --.- ..- - .. .--. -.--
#
#
# SPDX-License-Identifier: AGPL-3.0
#
# This program is free software: you can redistribute it and/or mod... | [
"nox.session"
] | [((973, 1003), 'nox.session', 'nox.session', ([], {'python': 'PYTHON_ENV'}), '(python=PYTHON_ENV)\n', (984, 1003), False, 'import nox\n'), ((1167, 1197), 'nox.session', 'nox.session', ([], {'python': 'PYTHON_ENV'}), '(python=PYTHON_ENV)\n', (1178, 1197), False, 'import nox\n'), ((1550, 1580), 'nox.session', 'nox.sessio... |
import logging
import sys
import unittest
sys.path.insert(0, '..')
import expect
import time
# python 2 & 3 compatibility
try:
from StringIO import StringIO
except ImportError:
from io import StringIO
class StringIo(object):
INDATA = None
def __init__(self):
self.in_stream = StringIO(self.I... | [
"logging.basicConfig",
"sys.stdout.flush",
"sys.path.insert",
"time.sleep",
"unittest.main",
"io.StringIO",
"expect.Handler"
] | [((42, 66), 'sys.path.insert', 'sys.path.insert', (['(0)', '""".."""'], {}), "(0, '..')\n", (57, 66), False, 'import sys\n'), ((3575, 3615), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.DEBUG'}), '(level=logging.DEBUG)\n', (3594, 3615), False, 'import logging\n'), ((3620, 3635), 'unittest.main'... |
from rest_framework.serializers import HyperlinkedModelSerializer, ModelSerializer
from rest_framework import serializers
from .models import Blog, BlogCategory, Comments
class CategorySerializer(ModelSerializer):
class Meta:
model = BlogCategory
exclude = ['id']
class BlogListSerializer(Hyperl... | [
"rest_framework.serializers.StringRelatedField"
] | [((521, 553), 'rest_framework.serializers.StringRelatedField', 'serializers.StringRelatedField', ([], {}), '()\n', (551, 553), False, 'from rest_framework import serializers\n')] |
import hammer as h
signals = h.choice(
h.token("hmi.signal1"),
h.token("hmi.signal2"),
h.token("hmi.signal3"))
| [
"hammer.token"
] | [((39, 61), 'hammer.token', 'h.token', (['"""hmi.signal1"""'], {}), "('hmi.signal1')\n", (46, 61), True, 'import hammer as h\n'), ((63, 85), 'hammer.token', 'h.token', (['"""hmi.signal2"""'], {}), "('hmi.signal2')\n", (70, 85), True, 'import hammer as h\n'), ((87, 109), 'hammer.token', 'h.token', (['"""hmi.signal3"""']... |
"""Scrape the first ten pages of stackoverflow jobs for python jobs.
- The job title
- The company name
- The location
- The date posted (in whatever date format makes the most sense to you)
- The link to the actual job posting
"""
from bs4 import BeautifulSoup as bs
from datetime import datetime
import os
import requ... | [
"bs4.BeautifulSoup",
"datetime.datetime.now",
"os.path.realpath",
"os.path.join"
] | [((504, 539), 'bs4.BeautifulSoup', 'bs', (['response.content', '"""html.parser"""'], {}), "(response.content, 'html.parser')\n", (506, 539), True, 'from bs4 import BeautifulSoup as bs\n'), ((2209, 2244), 'os.path.join', 'os.path.join', (['dir_path', 'output_file'], {}), '(dir_path, output_file)\n', (2221, 2244), False,... |
from django.contrib.auth import get_user_model
from django.contrib.auth.hashers import check_password
from django.shortcuts import get_object_or_404
from rest_framework import viewsets, mixins, status
from rest_framework.decorators import action
from rest_framework.permissions import IsAdminUser, AllowAny
from rest_fra... | [
"django.contrib.auth.get_user_model",
"tasks.models.System.objects.get",
"tasks.models.Order.objects.get",
"tasks.models.Task.objects.filter",
"tasks.models.Status.objects.get",
"tasks.models.Status.objects.filter",
"tasks.models.Task.objects.get",
"tasks.models.System.objects.all",
"tasks.models.Or... | [((619, 635), 'django.contrib.auth.get_user_model', 'get_user_model', ([], {}), '()\n', (633, 635), False, 'from django.contrib.auth import get_user_model\n'), ((1519, 1606), 'rest_framework.decorators.action', 'action', ([], {'methods': "['post']", 'detail': '(True)', 'url_path': '"""execute"""', 'url_name': '"""execu... |
# -*- coding: utf-8 -*-
# Generated by Django 1.9.1 on 2016-01-28 23:51
from __future__ import unicode_literals
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('users', '0003_department'),
]
operations = [
... | [
"django.db.models.AutoField",
"django.db.models.CharField",
"django.db.models.ForeignKey"
] | [((417, 510), '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", (433, 510), False, 'from django.db import migrations, models\... |
import numpy as np
import pytest
from rsgeo.geometry import Polygon # noqa
class TestPolygon:
def setup_method(self):
self.p = Polygon([(0, 0), (1, 1), (1, 0), (0, 0)])
def test_repr(self):
str_repr = str(self.p)
exp = "Polygon([(0, 0), (1, 1), (1, 0), (0, 0)])"
assert str_r... | [
"numpy.testing.assert_array_equal",
"numpy.array",
"pytest.raises",
"rsgeo.geometry.Polygon"
] | [((143, 184), 'rsgeo.geometry.Polygon', 'Polygon', (['[(0, 0), (1, 1), (1, 0), (0, 0)]'], {}), '([(0, 0), (1, 1), (1, 0), (0, 0)])\n', (150, 184), False, 'from rsgeo.geometry import Polygon\n'), ((922, 969), 'numpy.testing.assert_array_equal', 'np.testing.assert_array_equal', (['result', 'expected'], {}), '(result, exp... |
import os
import json
raw_data = open("bitcoin-util-test.json").read()
input_data = json.loads(raw_data)
for testObj in input_data:
inp = ""
out = ""
args = " ".join(testObj['args'])
if 'input' in testObj:
inp = testObj['input']
if 'output_cmp' in testObj:
out = testObj['output_... | [
"json.loads"
] | [((85, 105), 'json.loads', 'json.loads', (['raw_data'], {}), '(raw_data)\n', (95, 105), False, 'import json\n')] |
"""Defines a command message that processes the input for a job"""
from __future__ import unicode_literals
import logging
from django.db import transaction
from data.data.exceptions import InvalidData
from job.models import Job
from messaging.messages.message import CommandMessage
logger = logging.getLogger(__name... | [
"logging.getLogger",
"job.models.Job.objects.set_job_input_data_v6",
"django.db.transaction.atomic",
"recipe.models.RecipeNode.objects.get_recipe_node_outputs",
"job.models.Job.objects.get_job_with_interfaces",
"queue.messages.queued_jobs.QueuedJob",
"job.models.Job.objects.process_job_input",
"job.mo... | [((296, 323), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (313, 323), False, 'import logging\n'), ((1587, 1635), 'job.models.Job.objects.get_job_with_interfaces', 'Job.objects.get_job_with_interfaces', (['self.job_id'], {}), '(self.job_id)\n', (1622, 1635), False, 'from job.models impo... |
from __future__ import unicode_literals
import os.path
from wand.image import Image as ImageHandler
from mock import patch, Mock, call
from nose.tools import eq_, nottest
from tests import TestCase
from tests.image_helper import SMALL_JPG, SOME_GIF, SOME_PNG
from catsnap import Client
from catsnap.image_truck import ... | [
"catsnap.resize_image.ResizeImage._resize_image",
"mock.patch",
"nose.tools.eq_",
"catsnap.image_truck.ImageTruck",
"catsnap.Client",
"mock.Mock",
"wand.image.Image",
"catsnap.table.image.Image",
"catsnap.image_truck.ImageTruck.new_from_file",
"mock.call",
"catsnap.resize_image.ResizeImage.make_... | [((1332, 1374), 'mock.patch', 'patch', (['"""catsnap.resize_image.ImageHandler"""'], {}), "('catsnap.resize_image.ImageHandler')\n", (1337, 1374), False, 'from mock import patch, Mock, call\n'), ((2143, 2185), 'mock.patch', 'patch', (['"""catsnap.resize_image.ImageHandler"""'], {}), "('catsnap.resize_image.ImageHandler... |
from os import path
dirname = path.dirname(__file__)
class Config:
# SQLALCHEMY_TRACK_MODIFICATIONS = False
SQLALCHEMY_DATABASE_URI = f'sqlite:///{dirname}/db.sqlite3'
BATATINHAS = 3
class development(Config):
DEBUG = True
SQLALCHEMY_ECHO = True
class production(Config):
DEBUG = False
| [
"os.path.dirname"
] | [((30, 52), 'os.path.dirname', 'path.dirname', (['__file__'], {}), '(__file__)\n', (42, 52), False, 'from os import path\n')] |
# Generate some graph to verify the quality of Metis' partitioning
# A graph with 300 vertices, vertices 0~99, 100~199, 200~299 form
# a complete graph respectively
# and add some random disturbing edges
import random
import os
os.environ["METIS_DLL"] = "/usr/local/lib/libmetis.so"
import metis
import networkx as nx
... | [
"networkx.MultiDiGraph",
"metis.part_graph",
"random.randint"
] | [((325, 342), 'networkx.MultiDiGraph', 'nx.MultiDiGraph', ([], {}), '()\n', (340, 342), True, 'import networkx as nx\n'), ((730, 753), 'metis.part_graph', 'metis.part_graph', (['dg', '(3)'], {}), '(dg, 3)\n', (746, 753), False, 'import metis\n'), ((633, 655), 'random.randint', 'random.randint', (['(0)', '(299)'], {}), ... |
"""
Manage Configuration AppMap recorder for Python.
"""
import inspect
import logging
from os.path import realpath
from pathlib import Path
import re
import sys
from textwrap import dedent
import importlib_metadata
import yaml
from yaml.parser import ParserError
from . import utils
from .env import Env
from .instru... | [
"logging.getLogger",
"textwrap.dedent",
"pathlib.Path",
"yaml.dump",
"inspect.getfile",
"os.path.realpath",
"re.sub",
"importlib_metadata.files",
"os.walk"
] | [((439, 466), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (456, 466), False, 'import logging\n'), ((694, 707), 'pathlib.Path', 'Path', (['rootdir'], {}), '(rootdir)\n', (698, 707), False, 'from pathlib import Path\n'), ((966, 986), 'os.path.realpath', 'realpath', (['sys.prefix'], {}), ... |
from django import forms
from django.contrib.auth.forms import UserCreationForm
from django.contrib.auth.models import User
from django.forms import ModelForm
from .models import Course, Submission, Assignment
class SignUpForm(UserCreationForm):
def clean_email(self):
email = self.cleaned_data.get('email')... | [
"django.contrib.auth.models.User.objects.filter",
"django.forms.TextInput",
"django.forms.EmailField",
"django.forms.ValidationError"
] | [((976, 994), 'django.forms.EmailField', 'forms.EmailField', ([], {}), '()\n', (992, 994), False, 'from django import forms\n'), ((483, 540), 'django.forms.ValidationError', 'forms.ValidationError', (['u"""Email addresses must be unique."""'], {}), "(u'Email addresses must be unique.')\n", (504, 540), False, 'from djan... |
# -*- coding: utf-8 -*-
"""
Created on Sun Oct 15 18:47:17 2017
@author: Khagendra
The following fills the missing data
"""
from sklearn.preprocessing import Imputer
from numba import jit
@jit
def MisDat(X):
#Filling the most frequent value in place of empty values
imputer=Imputer(missing_values="NaN",str... | [
"sklearn.preprocessing.Imputer"
] | [((288, 351), 'sklearn.preprocessing.Imputer', 'Imputer', ([], {'missing_values': '"""NaN"""', 'strategy': '"""most_frequent"""', 'axis': '(0)'}), "(missing_values='NaN', strategy='most_frequent', axis=0)\n", (295, 351), False, 'from sklearn.preprocessing import Imputer\n')] |
#!/usr/bin/env python
"""Test faster version of sematic similarity"""
from __future__ import print_function
# Computing basic semantic similarities between GO terms
# Adapted from book chapter written by _<NAME> and <NAME>_
# How to compute semantic similarity between GO terms.
# First we need to write a function ... | [
"tests.utils.get_godag",
"goatools.semantic.TermCounts",
"timeit.default_timer",
"collections.Counter",
"tests.utils.get_anno_fullname",
"os.path.abspath"
] | [((1240, 1265), 'tests.utils.get_godag', 'get_godag', (['"""go-basic.obo"""'], {}), "('go-basic.obo')\n", (1249, 1265), False, 'from tests.utils import get_godag\n'), ((1653, 1675), 'timeit.default_timer', 'timeit.default_timer', ([], {}), '()\n', (1673, 1675), False, 'import timeit\n'), ((1690, 1717), 'goatools.semant... |
#!/usr/bin/env python3
import sqlite3
import time
import smtplib
import sys
from email.mime.text import MIMEText
from email.header import Header
from email.utils import formataddr
import traceback
# -------------------请修改以下部分的配置-------------------
# QQ号
qq = 1840686745
# 检测间隔时间(秒)
sleep_time = 60
... | [
"traceback.format_exc",
"smtplib.SMTP",
"sqlite3.connect",
"smtplib.SMTP_SSL",
"time.sleep",
"sys.exit",
"email.header.Header"
] | [((1839, 1861), 'time.sleep', 'time.sleep', (['sleep_time'], {}), '(sleep_time)\n', (1849, 1861), False, 'import time\n'), ((1806, 1816), 'sys.exit', 'sys.exit', ([], {}), '()\n', (1814, 1816), False, 'import sys\n'), ((1905, 1930), 'sqlite3.connect', 'sqlite3.connect', (['file_loc'], {}), '(file_loc)\n', (1920, 1930),... |
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
import os
import re
import time
import json
from django.shortcuts import render, get_object_or_404, redirect, get_list_or_404
from django.contrib import messages
from django.core.urlresolvers import reverse
from django.contrib.auth.decorators import login_... | [
"django.db.models.Count",
"app.rpt.models.MailLog.objects.all",
"app.maintain.tools.LogFormat._make",
"django.db.models.Sum",
"django.shortcuts.render",
"os.path.exists",
"app.utils.domain_session.get_domainid_bysession",
"os.listdir",
"app.core.models.AuthLog.objects.filter",
"app.utils.MailboxSe... | [((45079, 45097), 'django.views.decorators.cache.cache_page', 'cache_page', (['(60 * 5)'], {}), '(60 * 5)\n', (45089, 45097), False, 'from django.views.decorators.cache import cache_page\n'), ((1830, 1889), 'django.shortcuts.render', 'render', (['request', '"""rpt/maillog.html"""'], {'context': "{'form': form}"}), "(re... |
"""
Conf Helper Bases
~~~~~~~~~~~~~~~~~
"""
import abc
import threading
from abc import ABCMeta
from typing import Any
from typing import Generic
from typing import TypeVar
class DefaultCache(dict):
"""
Very similar to :py:class:`collections.defaultdict` (using __missing__)
however passes the specified k... | [
"threading.local",
"threading.RLock",
"typing.TypeVar"
] | [((728, 741), 'typing.TypeVar', 'TypeVar', (['"""FT"""'], {}), "('FT')\n", (735, 741), False, 'from typing import TypeVar\n'), ((1631, 1648), 'threading.RLock', 'threading.RLock', ([], {}), '()\n', (1646, 1648), False, 'import threading\n'), ((2297, 2314), 'threading.local', 'threading.local', ([], {}), '()\n', (2312, ... |
#! /usr/bin/env python3
import json
import os
import sys
import re
import argparse
import time
from math import floor
from os.path import dirname
from subprocess import Popen, PIPE, STDOUT
from blessings import Terminal
class Heatmap(object):
coords = [
[
# Row 0
[ 4, 0], [ 4, 2]... | [
"os.path.exists",
"argparse.ArgumentParser",
"blessings.Terminal",
"os.makedirs",
"math.floor",
"sys.stdout.write",
"sys.stdin.readline",
"os.path.dirname",
"sys.exit",
"json.load",
"time.time",
"re.search"
] | [((6805, 6815), 'blessings.Terminal', 'Terminal', ([], {}), '()\n', (6813, 6815), False, 'from blessings import Terminal\n'), ((6834, 6867), 'sys.stdout.write', 'sys.stdout.write', (['"""\x1b[2J\x1b[H"""'], {}), "('\\x1b[2J\\x1b[H')\n", (6850, 6867), False, 'import sys\n'), ((8473, 8546), 're.search', 're.search', (['"... |
#!/usr/bin/python3
import argparse
import logging
import os
import re
import shlex
import sys
from subprocess import Popen, PIPE
# Main function
def build_index(parser_result):
aligner = parser_result.aligner.lower()
global quiet
quiet = parser_result.quiet
check_tools(aligner)
if not quiet:
... | [
"logging.getLogger",
"os.path.exists",
"logging.StreamHandler",
"argparse.ArgumentParser",
"shlex.split",
"logging.Formatter",
"re.match",
"argparse.ArgumentTypeError",
"logging.FileHandler",
"os.mkdir"
] | [((7602, 7662), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Aligner Index Builder"""'}), "(description='Aligner Index Builder')\n", (7625, 7662), False, 'import argparse\n'), ((342, 441), 'logging.Formatter', 'logging.Formatter', (['"""[%(asctime)s] [%(levelname)s] %(message)s"""'], {... |
from tempfile import mkstemp
import cProfile
import pstats
from artemis.general.display import surround_with_header
import os
def what_are_we_waiting_for(command, sort_by ='time', max_len = 20, print_here = True):
"""
An easy way to show what is taking all the time when you run something.
Taken from docs:... | [
"pstats.Stats",
"cProfile.run",
"tempfile.mkstemp",
"os.remove"
] | [((823, 832), 'tempfile.mkstemp', 'mkstemp', ([], {}), '()\n', (830, 832), False, 'from tempfile import mkstemp\n'), ((850, 881), 'cProfile.run', 'cProfile.run', (['command', 'filepath'], {}), '(command, filepath)\n', (862, 881), False, 'import cProfile\n'), ((908, 930), 'pstats.Stats', 'pstats.Stats', (['filepath'], {... |
import numpy as np
from sim.sim2d import sim_run
# Simulator options.
options = {}
options['FIG_SIZE'] = [8,8]
options['OBSTACLES'] = True
class ModelPredictiveControl:
def __init__(self):
self.horizon = 20
self.dt = 0.2
# Reference or set point the controller will achieve.
self.r... | [
"numpy.sqrt",
"numpy.tan",
"sim.sim2d.sim_run",
"numpy.cos",
"numpy.sin"
] | [((1671, 1711), 'sim.sim2d.sim_run', 'sim_run', (['options', 'ModelPredictiveControl'], {}), '(options, ModelPredictiveControl)\n', (1678, 1711), False, 'from sim.sim2d import sim_run\n'), ((1370, 1412), 'numpy.sqrt', 'np.sqrt', (['(obs_dist_x ** 2 + obs_dist_y ** 2)'], {}), '(obs_dist_x ** 2 + obs_dist_y ** 2)\n', (13... |
import matplotlib.pyplot as plt
import csv
import pandas as pd
desired_width = 320
pd.set_option('display.width', desired_width)
pd.set_option('display.max_columns', 10)
# Task 1 - Open and read a csv file
def openCSV():
csvfile = open("./csv/oscar_age_female.csv", newline='')
data = csv.reader(csvfile, del... | [
"pandas.read_csv",
"pandas.set_option",
"matplotlib.pyplot.scatter",
"matplotlib.pyplot.title",
"csv.reader",
"matplotlib.pyplot.show"
] | [((84, 129), 'pandas.set_option', 'pd.set_option', (['"""display.width"""', 'desired_width'], {}), "('display.width', desired_width)\n", (97, 129), True, 'import pandas as pd\n'), ((130, 170), 'pandas.set_option', 'pd.set_option', (['"""display.max_columns"""', '(10)'], {}), "('display.max_columns', 10)\n", (143, 170),... |
"""This module does the argument and config parsing, and contains the main
function (that is called when calling pep8radius from shell)."""
from __future__ import print_function
import os
import sys
try:
from configparser import ConfigParser as SafeConfigParser, NoSectionError
except ImportError: # py2, pragma:... | [
"signal.signal",
"argparse.FileType",
"argparse.ArgumentParser",
"ConfigParser.SafeConfigParser",
"os.getenv",
"os.path.join",
"pep8radius.vcs.VersionControl.which",
"autopep8.supported_fixes",
"pep8radius.radius.Radius",
"os.path.expanduser"
] | [((665, 695), 'os.path.expanduser', 'os.path.expanduser', (['"""~\\\\.pep8"""'], {}), "('~\\\\.pep8')\n", (683, 695), False, 'import os\n'), ((3343, 3416), 'argparse.ArgumentParser', 'ArgumentParser', ([], {'description': 'description', 'epilog': 'epilog', 'prog': '"""pep8radius"""'}), "(description=description, epilog... |
# -*- coding: utf-8 -*-
'''
Created on 2 mars 2017
@author: Jacky
'''
import logging
from discord.ext import commands
from ArkDiscordBot.apps import bot
from ArkDiscordBot.discord.utils import parse_context
logger = logging.getLogger('BOT.{}'.format(__name__))
class Commons:
@commands.command(pass_conte... | [
"ArkDiscordBot.apps.bot.logs_from",
"ArkDiscordBot.apps.bot.send_message",
"ArkDiscordBot.discord.utils.parse_context",
"discord.ext.commands.command",
"ArkDiscordBot.apps.bot.edit_message"
] | [((293, 365), 'discord.ext.commands.command', 'commands.command', ([], {'pass_context': '(True)', 'name': '"""test2"""', 'brief': '"""Test the bot."""'}), "(pass_context=True, name='test2', brief='Test the bot.')\n", (309, 365), False, 'from discord.ext import commands\n'), ((565, 583), 'ArkDiscordBot.discord.utils.par... |
# Copyright 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
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, ... | [
"threading.Lock",
"research.carls.dynamic_embedding_config_pb2.DynamicEmbeddingConfig"
] | [((839, 855), 'threading.Lock', 'threading.Lock', ([], {}), '()\n', (853, 855), False, 'import threading\n'), ((1832, 1870), 'research.carls.dynamic_embedding_config_pb2.DynamicEmbeddingConfig', 'de_config_pb2.DynamicEmbeddingConfig', ([], {}), '()\n', (1868, 1870), True, 'from research.carls import dynamic_embedding_c... |
#!/usr/bin/python
# Copyright: nbr23
# License: MIT
from __future__ import absolute_import, division, print_function
__metaclass__ = type
DOCUMENTATION = '''
---
module: fios_dhcp_static_lease
short_description: Manage Fios Verizon Router DHCP static leases
description:
- Manage Fios Verizon Router DHCP static ... | [
"ansible_collections.nbr23.fiosrouter.plugins.module_utils.verizon_fios.RouterSession"
] | [((2669, 2740), 'ansible_collections.nbr23.fiosrouter.plugins.module_utils.verizon_fios.RouterSession', 'RouterSession', (["module.params['router_ip']", "module.params['router_port']"], {}), "(module.params['router_ip'], module.params['router_port'])\n", (2682, 2740), False, 'from ansible_collections.nbr23.fiosrouter.p... |
# to test the gradient back-propagation
from __future__ import absolute_import, division, print_function
import torch
import pickle
import torch.nn as nn
import torch.nn.functional as F
import matplotlib.pyplot as plt
import numpy as np
import cv2
import torch.utils.data as data
from mesh.multiview_utility import Mutua... | [
"network.constants.Constant",
"pickle.load",
"dataset.nyu_dataset.create_nyu_dataset",
"matplotlib.pyplot.figure",
"dataset.joint_angle.JointAngleDataset",
"network.util_modules.HandSynthesizer",
"matplotlib.pyplot.show"
] | [((774, 784), 'network.constants.Constant', 'Constant', ([], {}), '()\n', (782, 784), False, 'from network.constants import Constant\n'), ((1315, 1346), 'dataset.nyu_dataset.create_nyu_dataset', 'create_nyu_dataset', (['dataset_dir'], {}), '(dataset_dir)\n', (1333, 1346), False, 'from dataset.nyu_dataset import create_... |
import io
import json
from typing import Iterable
from zipfile import ZipFile
import boto3
import pandas as pd
from tmdprimer.stop_classification.data_loaders import DataLoader
from tmdprimer.stop_classification.datasets.dvdt_dataset import DVDTFile, DVDTDataset
from tmdprimer.stop_classification.datasets.sensorlog_d... | [
"tmdprimer.stop_classification.datasets.sensorlog_dataset.SensorLogDataset",
"boto3.client",
"zipfile.ZipFile",
"pandas.read_csv",
"tmdprimer.stop_classification.datasets.dvdt_dataset.DVDTDataset"
] | [((518, 536), 'boto3.client', 'boto3.client', (['"""s3"""'], {}), "('s3')\n", (530, 536), False, 'import boto3\n'), ((970, 988), 'tmdprimer.stop_classification.datasets.dvdt_dataset.DVDTDataset', 'DVDTDataset', (['files'], {}), '(files)\n', (981, 988), False, 'from tmdprimer.stop_classification.datasets.dvdt_dataset im... |
import pytest
from django.db import transaction
from django.utils import timezone
from ..models import Message, FOIRequest, Esic, PublicBody
@pytest.fixture
def public_body(esic):
return PublicBody(
name='example',
esic=esic
)
@pytest.fixture
def esic():
return Esic(
url='http:/... | [
"django.utils.timezone.now",
"django.db.transaction.atomic"
] | [((602, 622), 'django.db.transaction.atomic', 'transaction.atomic', ([], {}), '()\n', (620, 622), False, 'from django.db import transaction\n'), ((748, 762), 'django.utils.timezone.now', 'timezone.now', ([], {}), '()\n', (760, 762), False, 'from django.utils import timezone\n'), ((1327, 1347), 'django.db.transaction.at... |
import numpy as np
import random
import cv2
import os
import json
from csv_utils import load_csv
import rect
import mask
def plot_one_box(x, img, color=None, label=None, line_thickness=None):
"""
description: Plots one bounding box on image img,
this function comes from YoLov5 project.
ar... | [
"cv2.rectangle",
"cv2.imwrite",
"argparse.ArgumentParser",
"os.makedirs",
"cv2.polylines",
"csv_utils.load_csv",
"os.path.join",
"cv2.putText",
"os.path.isfile",
"os.path.isdir",
"numpy.min",
"json.load",
"cv2.getTextSize",
"cv2.imread",
"random.randint"
] | [((882, 951), 'cv2.rectangle', 'cv2.rectangle', (['img', 'c1', 'c2', 'color'], {'thickness': 'tl', 'lineType': 'cv2.LINE_AA'}), '(img, c1, c2, color, thickness=tl, lineType=cv2.LINE_AA)\n', (895, 951), False, 'import cv2\n'), ((2169, 2236), 'cv2.polylines', 'cv2.polylines', (['img', '[pts]'], {'isClosed': '(True)', 'co... |
from collections import Counter
from .....core import BaseAnalyzer, Validator, Required
from .....taxonomies import Taxonomy
from .....config.consts import CONFIG_HEADER_FIELDS, CONFIG_TAXONOMY_ID
class TaxonomyGuesserAnalyzer(BaseAnalyzer):
REQUIRES = Validator(
Required(CONFIG_HEADER_FIELDS)
)
... | [
"collections.Counter"
] | [((460, 469), 'collections.Counter', 'Counter', ([], {}), '()\n', (467, 469), False, 'from collections import Counter\n')] |
import csv
"""Set of functions used to import from
csv into the FIDO model. The import is
specified as a dictionary, defining the
model, the name of the primary key and
the list of fields. Recursions are used
to defind foreign keys."""
IMPORT_CSV_MODEL_KEY = "model"
IMPORT_CSV_PK_NAME_KEY = "pk_name"
IMPORT_CSV_PK_KE... | [
"csv.reader"
] | [((5631, 5651), 'csv.reader', 'csv.reader', (['csv_file'], {}), '(csv_file)\n', (5641, 5651), False, 'import csv\n'), ((6430, 6450), 'csv.reader', 'csv.reader', (['csv_file'], {}), '(csv_file)\n', (6440, 6450), False, 'import csv\n'), ((6674, 6694), 'csv.reader', 'csv.reader', (['csv_file'], {}), '(csv_file)\n', (6684,... |
import os
# RESOURCES_PATH = 'resources/'
# UPDATE_FREQUENCY = 60 * 60 * 6 # deprecated. Controlled in Jenkins
MARIADB_CONFIG = {
"user": os.environ["MARIADB_USR"],
"psw": os.environ["MARIADB_PSW"],
"host": "cubus.cxxwabvgrdub.eu-central-1.rds.amazonaws.com",
"port": 3306,
"db": "input",
}
## GO... | [
"os.getenv"
] | [((408, 449), 'os.getenv', 'os.getenv', (['"""GOOGLE_ADS_LOGIN_CUSTOMER_ID"""'], {}), "('GOOGLE_ADS_LOGIN_CUSTOMER_ID')\n", (417, 449), False, 'import os\n')] |
from googletrans import Translator
translator = Translator()
print(translator.translate(' ' + '안녕하세요.', dest='pt')) | [
"googletrans.Translator"
] | [((48, 60), 'googletrans.Translator', 'Translator', ([], {}), '()\n', (58, 60), False, 'from googletrans import Translator\n')] |
import requests
import zipfile
import os
import errno
import nltk
from nltk.tokenize import sent_tokenize
ALICE_URL = 'https://ota.bodleian.ox.ac.uk/repository/xmlui/bitstream/handle/20.500.12024/1476/alice28-1476.txt'
WIZARD_URL = 'https://ota.bodleian.ox.ac.uk/repository/xmlui/bitstream/handle/20.500.12024/1740/wizo... | [
"os.path.exists",
"os.listdir",
"nltk.download",
"os.path.join",
"os.path.splitext",
"requests.get",
"os.path.split",
"os.path.isdir",
"os.mkdir",
"nltk.tokenize.sent_tokenize"
] | [((963, 985), 'nltk.download', 'nltk.download', (['"""punkt"""'], {}), "('punkt')\n", (976, 985), False, 'import nltk\n'), ((1114, 1135), 'os.path.isdir', 'os.path.isdir', (['source'], {}), '(source)\n', (1127, 1135), False, 'import os\n'), ((1535, 1568), 'os.path.join', 'os.path.join', (['source', '"""lines.cfg"""'], ... |
import sys
import click
from tabulate import tabulate
import textwrap
from . import admin
from ...helper import is_admin
from ...session import Session, is_legacy_server
from ...versioning import get_naming, apply_version_aware_fields
from ..pretty import print_error, print_fail
# Lets say formattable options are:
... | [
"click.Choice",
"click.argument",
"textwrap.dedent",
"click.option",
"sys.exit"
] | [((1752, 1899), 'click.option', 'click.option', (['"""--access-key"""'], {'type': 'str', 'default': 'None', 'help': '"""Get sessions for a specific access key (only works if you are a super-admin)"""'}), "('--access-key', type=str, default=None, help=\n 'Get sessions for a specific access key (only works if you are ... |
from django.urls import path
from dplhooks.deploys import views
urlpatterns = [
path('p/deploy', views.DeployView.as_view())
]
| [
"dplhooks.deploys.views.DeployView.as_view"
] | [((103, 129), 'dplhooks.deploys.views.DeployView.as_view', 'views.DeployView.as_view', ([], {}), '()\n', (127, 129), False, 'from dplhooks.deploys import views\n')] |
"""
Classes to handle logging
(c) 2015 Massachusetts Institute of Technology
"""
# Native
import time
import logging
logger = logging.getLogger(__name__)
# LO-PHI
import lophi.globals as G
class LogFile:
"""
This class will handle all of the writing to files for LO-PHI. Simply
initialize... | [
"logging.getLogger",
"traceback.format_exc",
"lophi.globals.ensure_dir_exists",
"time.time"
] | [((135, 162), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (152, 162), False, 'import logging\n'), ((758, 787), 'lophi.globals.ensure_dir_exists', 'G.ensure_dir_exists', (['filename'], {}), '(filename)\n', (777, 787), True, 'import lophi.globals as G\n'), ((1298, 1320), 'traceback.forma... |
import smbus2, time
address = 0x63 #Atlas PH Probe standard I2C address is 99 decimal.
class atlasPH(object):
def __init__(self):
self.bus = smbus2.SMBus(1)
def write(self, command):
self.bus.write_byte(address, ord(command))
def readBlock(self, numBytes):
retur... | [
"smbus2.SMBus",
"time.sleep"
] | [((173, 188), 'smbus2.SMBus', 'smbus2.SMBus', (['(1)'], {}), '(1)\n', (185, 188), False, 'import smbus2, time\n'), ((917, 932), 'time.sleep', 'time.sleep', (['(0.9)'], {}), '(0.9)\n', (927, 932), False, 'import smbus2, time\n')] |
""" This is a modified version of simple.py script bundled with Read Until API"""
import argparse
import logging
import sys
import traceback
import time
import numpy
import read_until
import cffi
import os
import h5py
import glob
import concurrent.futures
import dyss
def _get_parser():
parser = argparse.ArgumentPa... | [
"logging.getLogger",
"logging.basicConfig",
"argparse.ArgumentParser",
"dyss.Dyss",
"time.sleep",
"read_until.ReadUntilClient",
"numpy.fromstring",
"time.time"
] | [((301, 390), 'argparse.ArgumentParser', 'argparse.ArgumentParser', (['"""Dyss -- a tiny program for selective sequencing on MinION"""'], {}), "(\n 'Dyss -- a tiny program for selective sequencing on MinION')\n", (324, 390), False, 'import argparse\n'), ((3065, 3090), 'logging.getLogger', 'logging.getLogger', (['"""... |
# Copyright 2018 Twitter, Inc.
# Licensed under the Apache License, Version 2.0
# http://www.apache.org/licenses/LICENSE-2.0
""" This module contains classes and methods for extracting metrics from the
Heron Topology Master instance. """
import logging
import warnings
import datetime as dt
from typing import Dict, ... | [
"logging.getLogger",
"caladrius.common.heron.tracker.get_metrics_timeline",
"caladrius.common.heron.tracker.get_physical_plan",
"caladrius.common.heron.tracker.incoming_sources_and_streams",
"caladrius.common.heron.tracker.parse_instance_name",
"caladrius.common.heron.tracker.get_logical_plan",
"caladri... | [((600, 627), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (617, 627), False, 'import logging\n'), ((2081, 2113), 'datetime.datetime.now', 'dt.datetime.now', (['dt.timezone.utc'], {}), '(dt.timezone.utc)\n', (2096, 2113), True, 'import datetime as dt\n'), ((6259, 6279), 'pandas.DataFram... |
import numpy as np
import xarray as xr
from numpy import asarray
import scipy.sparse
from itertools import product
from .util import get_shape_of_data
from .grid_stretching_transforms import scs_transform
from .constants import R_EARTH_m
def get_troposphere_mask(ds):
"""
Returns a mask array for picking out t... | [
"numpy.sqrt",
"numpy.array",
"numpy.arctan2",
"numpy.sin",
"numpy.arange",
"numpy.flip",
"numpy.cross",
"numpy.sort",
"itertools.product",
"numpy.asarray",
"numpy.max",
"numpy.linspace",
"numpy.min",
"numpy.rad2deg",
"numpy.round",
"numpy.abs",
"numpy.size",
"numpy.squeeze",
"num... | [((13666, 14423), 'numpy.array', 'np.array', (['[0.0, 0.04804826, 6.593752, 13.1348, 19.61311, 26.09201, 32.57081, 38.98201,\n 45.33901, 51.69611, 58.05321, 64.36264, 70.62198, 78.83422, 89.09992, \n 99.36521, 109.1817, 118.9586, 128.6959, 142.91, 156.26, 169.609, \n 181.619, 193.097, 203.259, 212.15, 218.776,... |
# -*- coding: utf-8 -*-
# Generated by Django 1.11.14 on 2018-09-11 12:40
from __future__ import unicode_literals
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
import django.utils.timezone
import yats.models
class Migration(migrations.Migration):
depe... | [
"django.db.models.TextField",
"django.db.models.ForeignKey",
"django.db.models.BooleanField",
"django.db.models.DateTimeField",
"django.db.models.CharField"
] | [((520, 554), 'django.db.models.BooleanField', 'models.BooleanField', ([], {'default': '(False)'}), '(default=False)\n', (539, 554), False, 'from django.db import migrations, models\n'), ((676, 766), 'django.db.models.DateTimeField', 'models.DateTimeField', ([], {'default': 'django.utils.timezone.now', 'verbose_name': ... |
"""
.. function:: queryplan(query) -> Query plan
Returns the query plan of the input query.
Examples::
>>> sql("queryplan select 5")
operation | paramone | paramtwo | databasename | triggerorview
------------------------------------------------------------------
SQLITE_SELECT | None | None ... | [
"vtbase.VTGenerator",
"sys.setdefaultencoding",
"doctest.testmod"
] | [((1822, 1851), 'vtbase.VTGenerator', 'vtbase.VTGenerator', (['QueryPlan'], {}), '(QueryPlan)\n', (1840, 1851), False, 'import vtbase\n'), ((2142, 2173), 'sys.setdefaultencoding', 'sys.setdefaultencoding', (['"""utf-8"""'], {}), "('utf-8')\n", (2164, 2173), False, 'import sys\n'), ((2205, 2222), 'doctest.testmod', 'doc... |
"""Provide Session class."""
import logging
from time import sleep
from copy import deepcopy
from typing import TYPE_CHECKING, Dict, Optional, Tuple, Union
from urllib.parse import urljoin
from .authorizer import BaseAuthorizer
from .request_wrapper import RequestWrapper
from .retry import RetryPolicy, RateLimit
from... | [
"logging.getLogger",
"urllib.parse.urljoin",
"time.sleep",
"copy.deepcopy"
] | [((712, 739), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (729, 739), False, 'import logging\n'), ((1989, 2012), 'time.sleep', 'sleep', (['seconds_to_sleep'], {}), '(seconds_to_sleep)\n', (1994, 2012), False, 'from time import sleep\n'), ((4419, 4430), 'copy.deepcopy', 'deepcopy', (['d... |
# Copyright 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
#
# Unless required by applicable law or agreed to in writing, ... | [
"traceback.format_stack",
"threading.current_thread",
"threading.Lock",
"queue.Queue",
"time.time",
"typing.TypeVar"
] | [((751, 763), 'typing.TypeVar', 'TypeVar', (['"""T"""'], {}), "('T')\n", (758, 763), False, 'from typing import Any, Callable, Dict, Generic, List, Optional, Set, Tuple, TypeVar\n'), ((768, 780), 'typing.TypeVar', 'TypeVar', (['"""U"""'], {}), "('U')\n", (775, 780), False, 'from typing import Any, Callable, Dict, Gener... |
from discord import Client
from discord.ext import tasks
from configurationparser import ConfigurationParser
from message import Message
import asyncio, logging, random, time
logger = logging.getLogger(__name__)
HELP='''```
Usage:
&help - show this help page
&start [author_id] - start sending mes... | [
"logging.getLogger",
"configurationparser.ConfigurationParser.get_json",
"message.Message",
"asyncio.sleep",
"time.time"
] | [((187, 214), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (204, 214), False, 'import asyncio, logging, random, time\n'), ((1096, 1107), 'time.time', 'time.time', ([], {}), '()\n', (1105, 1107), False, 'import asyncio, logging, random, time\n'), ((1364, 1417), 'message.Message', 'Messag... |
from django.contrib import admin
from django.contrib.admin.widgets import FilteredSelectMultiple
from django.contrib.contenttypes.models import ContentType
from django.forms import ModelMultipleChoiceField
from django.utils.html import format_html
from . import models
class CustomModelMCF(ModelMultipleChoiceField):
... | [
"django.contrib.admin.widgets.FilteredSelectMultiple",
"django.contrib.admin.site.register",
"django.contrib.contenttypes.models.ContentType.objects.all",
"django.utils.html.format_html"
] | [((1945, 2008), 'django.contrib.admin.site.register', 'admin.site.register', (['models.DatabasePurger', 'DatabasePurgerAdmin'], {}), '(models.DatabasePurger, DatabasePurgerAdmin)\n', (1964, 2008), False, 'from django.contrib import admin\n'), ((2009, 2064), 'django.contrib.admin.site.register', 'admin.site.register', (... |
#!/usr/bin/env python3
"""Creates a standard tiff image from RLENGTH data sent by Brother scanners."""
import struct
import sys
def rle_decode(data):
"""Decodes PackBits encoded data."""
i = 0
output = bytearray()
while i < len(data):
val = data[i]
i += 1
if val == 0x80:
... | [
"struct.pack"
] | [((5280, 5309), 'struct.pack', 'struct.pack', (['"""<I"""', 'offset_ifd'], {}), "('<I', offset_ifd)\n", (5291, 5309), False, 'import struct\n')] |
import cherrypy
import urllib.parse, urllib.request
import math
from polyline import decodePolyline
"""
Dispatches OSRM routing requests to backend servers
depending on the requested start and end coordinates
This is a workaround because OSRM needs large amounts of
memory for preprocessing and running. This allows to... | [
"cherrypy.config.update",
"cherrypy.response.headers.keys",
"polyline.decodePolyline",
"cherrypy.engine.start",
"cherrypy.__version__.startswith",
"cherrypy.HTTPError"
] | [((5592, 5630), 'cherrypy.config.update', 'cherrypy.config.update', (['"""settings.cfg"""'], {}), "('settings.cfg')\n", (5614, 5630), False, 'import cherrypy\n'), ((5424, 5462), 'cherrypy.__version__.startswith', 'cherrypy.__version__.startswith', (['"""3.0"""'], {}), "('3.0')\n", (5455, 5462), False, 'import cherrypy\... |
"""scrapli.transport.plugins.asyncssh.transport"""
import asyncio
from dataclasses import dataclass
from typing import Optional
from asyncssh import connect
from asyncssh.connection import SSHClientConnection
from asyncssh.misc import ConnectionLost, PermissionDenied
from asyncssh.stream import SSHReader, SSHWriter
f... | [
"scrapli.exceptions.ScrapliConnectionError",
"scrapli.decorators.TransportTimeout",
"asyncssh.connect",
"scrapli.exceptions.ScrapliAuthenticationFailed",
"scrapli.ssh_config.SSHKnownHosts",
"dataclasses.dataclass"
] | [((637, 648), 'dataclasses.dataclass', 'dataclass', ([], {}), '()\n', (646, 648), False, 'from dataclasses import dataclass\n'), ((6577, 6629), 'scrapli.decorators.TransportTimeout', 'TransportTimeout', (['"""timed out reading from transport"""'], {}), "('timed out reading from transport')\n", (6593, 6629), False, 'fro... |
import utils.config as config
from utils.words import prensetage_of_real_words_in_list
from utils.random import random_subtitution_string
from utils.search import is_known_part_in_text
from string import ascii_lowercase
from tqdm import tqdm
def get_array_key_from_string(string):
return { ascii_lowercase[i]: stri... | [
"utils.search.is_known_part_in_text",
"utils.random.random_subtitution_string"
] | [((825, 852), 'utils.random.random_subtitution_string', 'random_subtitution_string', ([], {}), '()\n', (850, 852), False, 'from utils.random import random_subtitution_string\n'), ((1671, 1698), 'utils.random.random_subtitution_string', 'random_subtitution_string', ([], {}), '()\n', (1696, 1698), False, 'from utils.rand... |
from sqlalchemy.ext.declarative import as_declarative, declared_attr
from pastetape.db.session import engine
@as_declarative()
class Base:
__name__: str
@declared_attr
def __tablename__(cls) -> str:
return cls.__name__.lower()
def initialize_db() -> None:
"""
Initializes the database t... | [
"sqlalchemy.ext.declarative.as_declarative"
] | [((113, 129), 'sqlalchemy.ext.declarative.as_declarative', 'as_declarative', ([], {}), '()\n', (127, 129), False, 'from sqlalchemy.ext.declarative import as_declarative, declared_attr\n')] |
#!/usr/bin/python
# author: qsh
from django.urls import path, re_path
from . import views_old,views1,views
from . import views,user,roles
app_name = 'users'
urlpatterns = [
# http://ip:8000/
path("", views.IndexView.as_view(), name='index'),
# http://ip:8000/login/
path("login/", views.LoginView.as_vi... | [
"django.urls.path"
] | [((409, 455), 'django.urls.path', 'path', (['"""list/"""', 'user.userlist'], {'name': '"""user_list"""'}), "('list/', user.userlist, name='user_list')\n", (413, 455), False, 'from django.urls import path, re_path\n')] |
from generativepy.drawing import makeImage
from generativepy.color import Color
def draw(ctx, width, height, frame_no, frame_count):
ctx.set_source_rgba(*Color(1).get_rgba())
ctx.paint()
for i in range(200):
for j in range(200):
ctx.set_source_rgba(*Color(i/200, j/200, 0).get_rgba())
... | [
"generativepy.color.Color",
"generativepy.drawing.makeImage"
] | [((783, 829), 'generativepy.drawing.makeImage', 'makeImage', (['"""/tmp/rgbcolor.png"""', 'draw', '(300)', '(800)'], {}), "('/tmp/rgbcolor.png', draw, 300, 800)\n", (792, 829), False, 'from generativepy.drawing import makeImage\n'), ((160, 168), 'generativepy.color.Color', 'Color', (['(1)'], {}), '(1)\n', (165, 168), F... |
import appdaemon.plugins.hass.hassapi as hass
import datetime
import pytz
import requests
import json
class SyncGTasksAndGrocy(hass.Hass):
tl_name = 'Corvées'
tl_id = None
tl_main = None
debug = False
gr_cl = None
service = None
tl_lastup = None
google_oauth_tasks = None
grocyapi = ... | [
"datetime.datetime.strptime",
"datetime.datetime.now"
] | [((661, 684), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (682, 684), False, 'import datetime\n'), ((6579, 6644), 'datetime.datetime.strptime', 'datetime.datetime.strptime', (['date_rfc3339', '"""%Y-%m-%dT%H:%M:%S.%fZ"""'], {}), "(date_rfc3339, '%Y-%m-%dT%H:%M:%S.%fZ')\n", (6605, 6644), False, '... |
#!/usr/bin/env python
usage = """Code to filter traces in the directory given a frequency band and file wildcard.
[-fl][-fh][-f][-t] where:
-fl = miniumum frequency value (e.g. 0.05)
-fh = maxiumum frequency value (e.g. 1.0)
-f = filename wildcard (e.g. '*SAC')
-t = type of filtering (e.g. bandpass)
"""
import obsp... | [
"obspy.read",
"argparse.ArgumentParser"
] | [((405, 503), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Preprocessing script for data retrieved from obspy DMT"""'}), "(description=\n 'Preprocessing script for data retrieved from obspy DMT')\n", (428, 503), False, 'import argparse\n'), ((1326, 1348), 'obspy.read', 'obspy.read',... |
#! /usr/bin/env python
"""
InstrumentData Class -- defines data format, wavelength info, mask geometry
Instruments/masks supported:
NIRISS AMI
GPI, VISIR, NIRC2 removed - too much changed for the JWST NIRISS class
"""
# Standard Imports
import numpy as np
from astropy.io import fits
import os, sys, time
import copy
... | [
"numpy.random.normal",
"nrm_analysis.misctools.utils.get_src_spec",
"nrm_analysis.misctools.mask_definitions.NRM_mask_definitions",
"nrm_analysis.misctools.utils.Affine2d",
"nrm_analysis.misctools.utils.get_filt_spec",
"sys.exit",
"nrm_analysis.misctools.utils.combine_src_filt",
"numpy.linalg.norm",
... | [((6375, 6409), 'nrm_analysis.misctools.utils.get_cw_beta', 'utils.get_cw_beta', (['self.throughput'], {}), '(self.throughput)\n', (6392, 6409), False, 'from nrm_analysis.misctools import utils\n'), ((7371, 7469), 'nrm_analysis.misctools.mask_definitions.NRM_mask_definitions', 'NRM_mask_definitions', ([], {'maskname': ... |
from time import sleep
from ina219 import INA219
ina = INA219(shunt_ohms=0.1,
max_expected_amps = 0.2,
address=0x40)
ina.configure(voltage_range=ina.RANGE_32V,
gain=ina.GAIN_AUTO,
bus_adc=ina.ADC_128SAMP,
shunt_adc=ina.ADC_128SAMP)
def get_readings... | [
"ina219.INA219"
] | [((56, 113), 'ina219.INA219', 'INA219', ([], {'shunt_ohms': '(0.1)', 'max_expected_amps': '(0.2)', 'address': '(64)'}), '(shunt_ohms=0.1, max_expected_amps=0.2, address=64)\n', (62, 113), False, 'from ina219 import INA219\n')] |
import pygame, math
pygame.init()
win = pygame.display.set_mode((1000, 600))
pygame.display.set_caption("Plumber")
angle = [pygame.image.load('angl1.png'), pygame.image.load('angl2.png'), pygame.image.load('angl3.png'),
pygame.image.load('angl4.png')]
straight = [pygame.image.load('str1.png'), pyga... | [
"pygame.init",
"pygame.quit",
"pygame.event.get",
"pygame.display.set_mode",
"pygame.mixer.Sound",
"pygame.display.set_caption",
"pygame.image.load",
"pygame.display.update"
] | [((23, 36), 'pygame.init', 'pygame.init', ([], {}), '()\n', (34, 36), False, 'import pygame, math\n'), ((46, 82), 'pygame.display.set_mode', 'pygame.display.set_mode', (['(1000, 600)'], {}), '((1000, 600))\n', (69, 82), False, 'import pygame, math\n'), ((84, 121), 'pygame.display.set_caption', 'pygame.display.set_capti... |
# -*- coding: utf-8 -*-
# This code is part of Qiskit.
#
# (C) Copyright IBM 2020.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modif... | [
"qiskit.compiler.assemble"
] | [((1675, 1728), 'qiskit.compiler.assemble', 'assemble', (['schedules', 'backend'], {'meas_level': '(1)', 'shots': '(256)'}), '(schedules, backend, meas_level=1, shots=256)\n', (1683, 1728), False, 'from qiskit.compiler import assemble\n')] |
from pydantic import BaseModel
from tortoise.contrib.pydantic import pydantic_model_creator
from typing import Optional
from src.database.models import Notes
# Creating new notes
NoteInSchema = pydantic_model_creator(
Notes, name="NoteIn", exclude=["author_id"], exclude_readonly=True
)
# retrieving Notes
NoteOu... | [
"tortoise.contrib.pydantic.pydantic_model_creator"
] | [((196, 290), 'tortoise.contrib.pydantic.pydantic_model_creator', 'pydantic_model_creator', (['Notes'], {'name': '"""NoteIn"""', 'exclude': "['author_id']", 'exclude_readonly': '(True)'}), "(Notes, name='NoteIn', exclude=['author_id'],\n exclude_readonly=True)\n", (218, 290), False, 'from tortoise.contrib.pydantic i... |
import os
settings = {
'host': os.environ.get('ACCOUNT_HOST', 'https://hacktest.documents.azure.com:443/'),
'master_key': os.environ.get('ACCOUNT_KEY', '<KEY>'),
'database_id': os.environ.get('COSMOS_DATABASE', 'hackjoblist'),
'container_id': os.environ.get('COSMOS_CONTAINER', 'joblist'),
} | [
"os.environ.get"
] | [((36, 111), 'os.environ.get', 'os.environ.get', (['"""ACCOUNT_HOST"""', '"""https://hacktest.documents.azure.com:443/"""'], {}), "('ACCOUNT_HOST', 'https://hacktest.documents.azure.com:443/')\n", (50, 111), False, 'import os\n'), ((131, 169), 'os.environ.get', 'os.environ.get', (['"""ACCOUNT_KEY"""', '"""<KEY>"""'], {... |
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
from .target_assigner.proposal_target_layer import ProposalTargetLayer
from ..model_utils.model_nms_utils import class_agnostic_nms
from ...utils import box_coder_utils, common_utils, loss_utils
class RoIHeadTemplate(nn.Module):
... | [
"torch.nn.ReLU",
"torch.nn.Dropout",
"torch.triu",
"torch.nn.Sequential",
"torch.max",
"torch.stack",
"torch.sigmoid",
"torch.nn.functional.normalize",
"torch.nn.BatchNorm1d",
"torch.sum",
"torch.nn.functional.cross_entropy",
"torch.nn.functional.pad",
"torch.no_grad",
"torch.nn.Conv1d",
... | [((1758, 1773), 'torch.no_grad', 'torch.no_grad', ([], {}), '()\n', (1771, 1773), False, 'import torch\n'), ((1701, 1726), 'torch.nn.Sequential', 'nn.Sequential', (['*fc_layers'], {}), '(*fc_layers)\n', (1714, 1726), True, 'import torch.nn as nn\n'), ((7016, 7073), 'torch.clamp', 'torch.clamp', (['heading_label'], {'mi... |
#!/usr/bin/env python3
import sys
import operator
from functools import reduce
from typing import List, Tuple, Iterator
Vector = Tuple[int, int] # x, y
def decode_move(move: str) -> Vector:
d, n = move[0], int(move[1:])
if d == 'U':
return (0, n)
elif d == 'D':
return (0, -n)
elif ... | [
"sys.exit"
] | [((1839, 1850), 'sys.exit', 'sys.exit', (['(1)'], {}), '(1)\n', (1847, 1850), False, 'import sys\n')] |
"""
A simple python package for scraping and downloading images from Google
Usage:
$ noicesoup.py [-h] -k KEYWORD [-cd CHROMEDRIVER]
NOTE: Default webdriver is Chrome in relative path "chromedriver"
Images will be saved in "downloads/<keyword>"
This package is currently under development...
"""
import threading... | [
"os.get_terminal_size",
"argparse.ArgumentParser",
"os.makedirs",
"selenium.webdriver.Chrome",
"pathlib.Path.home",
"time.sleep",
"bs4.BeautifulSoup",
"threading.Thread"
] | [((550, 588), 'selenium.webdriver.Chrome', 'webdriver.Chrome', ([], {'executable_path': 'path'}), '(executable_path=path)\n', (566, 588), False, 'from selenium import webdriver\n'), ((1068, 1116), 'bs4.BeautifulSoup', 'BeautifulSoup', (['driver.page_source', '"""html.parser"""'], {}), "(driver.page_source, 'html.parser... |
from os import getenv
from flask import Flask, render_template, request
from twitoff.twitter import add_or_update_user
from .models import DB, User, Tweet
from .twitter import add_or_update_user, get_all_usernames
from .predict import predict_user
# Create a 'factory' for serving up the app when is launched
def creat... | [
"flask.render_template",
"twitoff.twitter.add_or_update_user",
"os.getenv",
"flask.Flask"
] | [((365, 380), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (370, 380), False, 'from flask import Flask, render_template, request\n'), ((567, 589), 'os.getenv', 'getenv', (['"""DATABASE_URI"""'], {}), "('DATABASE_URI')\n", (573, 589), False, 'from os import getenv\n'), ((1191, 1292), 'flask.render_templat... |
from random import randint
gnum = randint(0, 2)
print(gnum)
print("welcome to the game\n\n")
print(
"you will guess a number \nbetween 1 to 100 \nwe have selected for you\n\n"
)
print("hint: WARM! mean yor are close by 10 ")
print("\nlet's start\n")
z = 0
count_num = 0
out = 0
warm = 0
cold = 0
list1 = []
while z =... | [
"random.randint"
] | [((34, 47), 'random.randint', 'randint', (['(0)', '(2)'], {}), '(0, 2)\n', (41, 47), False, 'from random import randint\n')] |
# load .t7 file and save as .pkl data
import torchfile
import cv2
import numpy as np
import scipy.io as sio
import pickle
import time
data_path = './data/test_PC/'
# panoContext
#img_tr = torchfile.load('./data/panoContext_img_train.t7')
#print(img_tr.shape)
#lne_tr = torchfile.load('./data/panoContext_line_train.t7... | [
"numpy.where",
"torchfile.load",
"numpy.array",
"numpy.loadtxt",
"numpy.transpose"
] | [((870, 918), 'torchfile.load', 'torchfile.load', (['"""./data/panoContext_img_test.t7"""'], {}), "('./data/panoContext_img_test.t7')\n", (884, 918), False, 'import torchfile\n'), ((948, 997), 'torchfile.load', 'torchfile.load', (['"""./data/panoContext_line_test.t7"""'], {}), "('./data/panoContext_line_test.t7')\n", (... |
# -*- coding: utf-8 -*-
#pylint: skip-file
import sys
import numpy as np
import torch
import torch as T
import torch.nn as nn
from torch.autograd import Variable
import copy
from utils_pg import *
from encoder import *
from decoder import *
from transformer.layers import Embeddings, PositionEmbeddings
class Model(nn... | [
"transformer.layers.PositionEmbeddings",
"torch.mean",
"torch.nn.init.xavier_uniform_",
"transformer.layers.Embeddings",
"torch.exp",
"torch.sum"
] | [((1337, 1395), 'transformer.layers.Embeddings', 'Embeddings', (['self.dict_size', 'self.dim_x', 'self.pad_token_idx'], {}), '(self.dict_size, self.dim_x, self.pad_token_idx)\n', (1347, 1395), False, 'from transformer.layers import Embeddings, PositionEmbeddings\n'), ((1421, 1471), 'transformer.layers.PositionEmbedding... |
import pytest
import sys
sys.path.append(".")
sys.path.append("../.")
from boxdetect import config
from boxdetect import pipelines
def test_save_load_config(capsys):
cfg = config.PipelinesConfig()
cfg.morph_kernels_thickness = 10
cfg.save_yaml('test_cfg.yaml')
cfg2 = config.PipelinesConfig('test_cfg.y... | [
"boxdetect.pipelines.get_boxes",
"boxdetect.pipelines.get_checkboxes",
"boxdetect.config.PipelinesConfig",
"sys.path.append"
] | [((25, 45), 'sys.path.append', 'sys.path.append', (['"""."""'], {}), "('.')\n", (40, 45), False, 'import sys\n'), ((46, 69), 'sys.path.append', 'sys.path.append', (['"""../."""'], {}), "('../.')\n", (61, 69), False, 'import sys\n'), ((178, 202), 'boxdetect.config.PipelinesConfig', 'config.PipelinesConfig', ([], {}), '(... |
import logging
import os
import time
from backtesting import get_bot
from config.cst import *
class Backtesting:
def __init__(self, config, exchange_simulator, exit_at_end=True):
self.config = config
self.begin_time = time.time()
self.time_delta = 0
self.force_exit_at_end = exit_a... | [
"logging.getLogger",
"backtesting.get_bot",
"time.sleep",
"os._exit",
"time.time"
] | [((241, 252), 'time.time', 'time.time', ([], {}), '()\n', (250, 252), False, 'import time\n'), ((401, 443), 'logging.getLogger', 'logging.getLogger', (['self.__class__.__name__'], {}), '(self.__class__.__name__)\n', (418, 443), False, 'import logging\n'), ((769, 782), 'time.sleep', 'time.sleep', (['(5)'], {}), '(5)\n',... |
try:
import cv2
import numpy as np
except ImportError as e:
from pip._internal import main as install
packages = ["numpy", "opencv-python"]
for package in packages:
install(["install", package])
finally:
pass
def detectEyeGlasses():
capture = cv2.VideoCapture(0)
eyesCasecade = c... | [
"cv2.rectangle",
"cv2.putText",
"cv2.imshow",
"pip._internal.main",
"cv2.destroyAllWindows",
"cv2.VideoCapture",
"cv2.cvtColor",
"cv2.CascadeClassifier",
"cv2.waitKey"
] | [((280, 299), 'cv2.VideoCapture', 'cv2.VideoCapture', (['(0)'], {}), '(0)\n', (296, 299), False, 'import cv2\n'), ((319, 379), 'cv2.CascadeClassifier', 'cv2.CascadeClassifier', (['"""haarcascade_eye_tree_eyeglasses.xml"""'], {}), "('haarcascade_eye_tree_eyeglasses.xml')\n", (340, 379), False, 'import cv2\n'), ((1153, 1... |
#
# BSD 3-Clause License
#
# Copyright (c) 2022 University of Wisconsin - Madison
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyrig... | [
"numpy.array",
"numpy.linalg.norm",
"rclpy.init",
"numpy.delete",
"numpy.asarray",
"ament_index_python.packages.get_package_share_directory",
"numpy.linspace",
"scipy.interpolate.splev",
"numpy.argmin",
"rclpy.shutdown",
"matplotlib.patches.Circle",
"numpy.abs",
"matplotlib.use",
"matplotl... | [((8571, 8592), 'rclpy.init', 'rclpy.init', ([], {'args': 'args'}), '(args=args)\n', (8581, 8592), False, 'import rclpy\n'), ((8630, 8649), 'rclpy.spin', 'rclpy.spin', (['planner'], {}), '(planner)\n', (8640, 8649), False, 'import rclpy\n'), ((8681, 8697), 'rclpy.shutdown', 'rclpy.shutdown', ([], {}), '()\n', (8695, 86... |