code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
import os
from django.core.wsgi import get_wsgi_application
from rest_base.utils import dotenv
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'project.settings')
dotenv.load(os.path.join(os.path.dirname(__file__), '../.env'))
application = get_wsgi_application()
| [
"os.environ.setdefault",
"os.path.dirname",
"django.core.wsgi.get_wsgi_application"
] | [((97, 164), 'os.environ.setdefault', 'os.environ.setdefault', (['"""DJANGO_SETTINGS_MODULE"""', '"""project.settings"""'], {}), "('DJANGO_SETTINGS_MODULE', 'project.settings')\n", (118, 164), False, 'import os\n'), ((244, 266), 'django.core.wsgi.get_wsgi_application', 'get_wsgi_application', ([], {}), '()\n', (264, 26... |
from .context import CoCoDataset
import os
from torchvision import transforms
import torch.utils.data as data
from src.data_loader import get_loader
from context import COCO_SMALL
from context import clean_sentence
def test_coco_dataset():
transform_train = transforms.Compose([
transforms.Resize(256), # ... | [
"src.data_loader.get_loader",
"os.path.join",
"torchvision.transforms.RandomHorizontalFlip",
"torchvision.transforms.RandomCrop",
"context.clean_sentence",
"torchvision.transforms.Normalize",
"torch.utils.data.DataLoader",
"torchvision.transforms.Resize",
"torchvision.transforms.ToTensor"
] | [((981, 1033), 'os.path.join', 'os.path.join', (['cocoapi_loc', '"""cocoapi/images/val2014/"""'], {}), "(cocoapi_loc, 'cocoapi/images/val2014/')\n", (993, 1033), False, 'import os\n'), ((1057, 1127), 'os.path.join', 'os.path.join', (['cocoapi_loc', '"""cocoapi/annotations/captions_val2014.json"""'], {}), "(cocoapi_loc,... |
#!/usr/bin/env python3
#
# Copyright 2021 <NAME>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law o... | [
"argparse.ArgumentParser",
"os.access",
"os.path.realpath",
"os.path.basename",
"sys.exit",
"unittest.TextTestRunner",
"unittest.TestLoader"
] | [((744, 770), 'os.path.basename', 'os.path.basename', (['__file__'], {}), '(__file__)\n', (760, 770), False, 'import os\n'), ((2561, 2586), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (2584, 2586), False, 'import argparse\n'), ((4081, 4117), 'os.path.basename', 'os.path.basename', (['testOpt... |
import numpy as np
from stardist import star_dist, relabel_image_stardist
import pytest
from utils import random_image, real_image2d, check_similar, circle_image
@pytest.mark.parametrize('img', (real_image2d()[1], random_image((128, 123))))
@pytest.mark.parametrize('n_rays', (4, 16, 32))
def test_types(img, n_rays):
... | [
"matplotlib.pyplot.imshow",
"stardist.star_dist",
"utils.check_similar",
"utils.circle_image",
"utils.random_image",
"numpy.count_nonzero",
"pytest.mark.parametrize",
"stardist.relabel_image_stardist",
"matplotlib.pyplot.figure",
"numpy.bitwise_and",
"matplotlib.pyplot.tight_layout",
"matplotl... | [((244, 290), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""n_rays"""', '(4, 16, 32)'], {}), "('n_rays', (4, 16, 32))\n", (267, 290), False, 'import pytest\n'), ((819, 865), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""n_rays"""', '(4, 16, 32)'], {}), "('n_rays', (4, 16, 32))\n", (842, 865)... |
import math
import functools
from scipy.stats import binom
import numpy as np
import itertools
import sys
import matplotlib.pyplot as plt
import matplotlib.patheffects as PathEffects
from copy import copy
def combine_distribs(deletes, inserts):
"""
Combine insert and delete models/distributions
:param de... | [
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.pcolor",
"numpy.log",
"copy.copy",
"math.exp",
"matplotlib.patheffects.withStroke",
"numpy.arange",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"numpy.max",
"matplotlib.pyplot.close",
"numpy.exp",
"numpy.concatenate",
"matplotlib.pyp... | [((691, 726), 'numpy.zeros_like', 'np.zeros_like', (['deletes'], {'dtype': 'float'}), '(deletes, dtype=float)\n', (704, 726), True, 'import numpy as np\n'), ((3544, 3613), 'functools.partial', 'functools.partial', (['model_full', 'rng', 'model_params'], {'rate_func': 'rate_func'}), '(model_full, rng, model_params, rate... |
"""
Metrics to calculate and manipulate the ROC Convex Hull on a classification task given scores.
"""
# Author: <NAME> <<EMAIL>>
from collections import namedtuple
from math import sqrt
from typing import List, Dict, Tuple, Union
# DESCRIPTION:
#
# This program computes the convex hull of a set of ROC points
# (t... | [
"doctest.testmod",
"collections.namedtuple",
"math.sqrt"
] | [((1651, 1693), 'collections.namedtuple', 'namedtuple', (['"""Point"""', "['x', 'y', 'clfname']"], {}), "('Point', ['x', 'y', 'clfname'])\n", (1661, 1693), False, 'from collections import namedtuple\n'), ((10010, 10055), 'math.sqrt', 'sqrt', (['((p1.x - p2.x) ** 2 + (p1.y - p2.y) ** 2)'], {}), '((p1.x - p2.x) ** 2 + (p... |
import os
import re
from setuptools import find_packages, setup
def get_version(package):
path = os.path.join(os.path.dirname(__file__), package, "__init__.py")
with open(path, "rb") as f:
init_py = f.read().decode("utf-8")
return re.search("__version__ = ['\"]([^'\"]+)['\"]", init_py).group(1)
... | [
"os.path.dirname",
"setuptools.find_packages",
"re.search"
] | [((117, 142), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (132, 142), False, 'import os\n'), ((517, 532), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (530, 532), False, 'from setuptools import find_packages, setup\n'), ((254, 309), 're.search', 're.search', (['"""__versi... |
from django.shortcuts import render
# Create your views here.
from user.forms import UserForm
def register(request):
form = UserForm()
if request.method == 'POST':
form = UserForm(request.POST)
if form.is_valid():
form.save()
return render(request, 'user/registeration/register... | [
"django.shortcuts.render",
"user.forms.UserForm"
] | [((131, 141), 'user.forms.UserForm', 'UserForm', ([], {}), '()\n', (139, 141), False, 'from user.forms import UserForm\n'), ((276, 343), 'django.shortcuts.render', 'render', (['request', '"""user/registeration/register.html"""', "{'form': form}"], {}), "(request, 'user/registeration/register.html', {'form': form})\n", ... |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'gui.ui'
#
# Created by: PyQt5 UI code generator 5.6
#
# WARNING! All changes made in this file will be lost!
import os
from PyQt5 import QtCore, QtGui, QtWidgets
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets imp... | [
"matplotlib.backends.qt_compat.QtWidgets.QCheckBox",
"PLOT.fmfxsect",
"matplotlib.backends.qt_compat.QtWidgets.QMenu",
"matplotlib.backends.qt_compat.QtCore.QMetaObject.connectSlotsByName",
"matplotlib.backends.qt_compat.QtWidgets.QMainWindow",
"matplotlib.backends.qt_compat.QtWidgets.QPushButton",
"mat... | [((581, 591), 'matplotlib.backends.qt_compat.is_pyqt5', 'is_pyqt5', ([], {}), '()\n', (589, 591), False, 'from matplotlib.backends.qt_compat import QtCore, QtWidgets, is_pyqt5\n'), ((25636, 25668), 'matplotlib.backends.qt_compat.QtWidgets.QApplication', 'QtWidgets.QApplication', (['sys.argv'], {}), '(sys.argv)\n', (256... |
'''
file: donkey_env.py
author: <NAME>
date: 2018-08-31
'''
import os
from threading import Thread
import numpy as np
import gym
from gym import error, spaces, utils
from gym.utils import seeding
from donkey_gym.envs.donkey_sim import DonkeyUnitySimContoller
from donkey_gym.envs.donkey_proc import DonkeyU... | [
"gym.utils.seeding.np_random",
"donkey_gym.envs.donkey_sim.DonkeyUnitySimContoller",
"numpy.array",
"donkey_gym.envs.donkey_proc.DonkeyUnityProcess"
] | [((705, 725), 'donkey_gym.envs.donkey_proc.DonkeyUnityProcess', 'DonkeyUnityProcess', ([], {}), '()\n', (723, 725), False, 'from donkey_gym.envs.donkey_proc import DonkeyUnityProcess\n'), ((1535, 1603), 'donkey_gym.envs.donkey_sim.DonkeyUnitySimContoller', 'DonkeyUnitySimContoller', ([], {'level': 'level', 'time_step':... |
"""
____ _____ _ _ _
| _ \ | __ \ (_) | | |
| |_) |_ _ | |__) |_ _ _ __ _____| |__ _ _| |_ ___
| _ <| | | | | ___/ _` | '__|_ / | '_ \| | | | __/ _ \
| |_) | |_| | | | | (_| | | / /| | |_) | |_| | || __/
|____/ \__, | |_| ... | [
"flask.render_template",
"flask.flash",
"flask.Flask",
"flask.redirect",
"flask.session.pop"
] | [((1540, 1555), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (1545, 1555), False, 'from flask import Flask, render_template, request, redirect, session, flash\n'), ((2218, 2252), 'flask.render_template', 'render_template', (['"""escritorio.html"""'], {}), "('escritorio.html')\n", (2233, 2252), False, 'fr... |
import json
import traceback
from db_adapter.exceptions import DatabaseAdapterError
from db_adapter.logger import logger
"""
Source JSON Object would looks like this
e.g.:
{
'model' : 'wrfSE',
'version' : 'v3',
'parameters': { }
}
{
'model' : 'OBS_WATER_LEVEL',
... | [
"db_adapter.logger.logger.error",
"traceback.print_exc",
"json.dumps"
] | [((1322, 1349), 'db_adapter.logger.logger.error', 'logger.error', (['error_message'], {}), '(error_message)\n', (1334, 1349), False, 'from db_adapter.logger import logger\n'), ((1358, 1379), 'traceback.print_exc', 'traceback.print_exc', ([], {}), '()\n', (1377, 1379), False, 'import traceback\n'), ((2245, 2272), 'db_ad... |
import unittest
from katas.kyu_7.binary_addition import add_binary
class AddBinaryTestCase(unittest.TestCase):
def test_equals(self):
self.assertEqual(add_binary(1, 1), '10')
def test_equals_2(self):
self.assertEqual(add_binary(0, 1), '1')
def test_equals_3(self):
self.assertEqu... | [
"katas.kyu_7.binary_addition.add_binary"
] | [((166, 182), 'katas.kyu_7.binary_addition.add_binary', 'add_binary', (['(1)', '(1)'], {}), '(1, 1)\n', (176, 182), False, 'from katas.kyu_7.binary_addition import add_binary\n'), ((245, 261), 'katas.kyu_7.binary_addition.add_binary', 'add_binary', (['(0)', '(1)'], {}), '(0, 1)\n', (255, 261), False, 'from katas.kyu_7.... |
from presentation.models import Author, Follower, Post, Comment
from django.shortcuts import get_object_or_404
from presentation.Serializers.comment_serializer import CommentSerializer
from rest_framework import viewsets, status
from django.http import JsonResponse
from rest_framework.response import Response
import uu... | [
"presentation.models.Comment.objects.filter",
"django.http.JsonResponse",
"presentation.Serializers.comment_serializer.CommentSerializer",
"presentation.models.Comment.objects.get",
"django.shortcuts.get_object_or_404",
"presentation.models.Comment.objects.all",
"uuid.uuid4",
"rest_framework.response.... | [((1033, 1054), 'presentation.models.Comment.objects.all', 'Comment.objects.all', ([], {}), '()\n', (1052, 1054), False, 'from presentation.models import Author, Follower, Post, Comment\n'), ((1382, 1418), 'presentation.models.Comment.objects.filter', 'Comment.objects.filter', ([], {'post': 'post_id'}), '(post=post_id)... |
#
# Copyright (C) 2019 Databricks, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to i... | [
"pyspark.sql.types.StringType",
"pyspark.sql.types.BooleanType"
] | [((1494, 1506), 'pyspark.sql.types.StringType', 'StringType', ([], {}), '()\n', (1504, 1506), False, 'from pyspark.sql.types import StringType, BinaryType, BooleanType\n'), ((1762, 1774), 'pyspark.sql.types.StringType', 'StringType', ([], {}), '()\n', (1772, 1774), False, 'from pyspark.sql.types import StringType, Bina... |
from src import most_invoices
EXPECTED_RESULT = (14, 'Berlin')
def test_most_invoices() -> None:
tested_result = most_invoices.get_city_with_most_invoices()
assert tested_result == EXPECTED_RESULT
| [
"src.most_invoices.get_city_with_most_invoices"
] | [((120, 163), 'src.most_invoices.get_city_with_most_invoices', 'most_invoices.get_city_with_most_invoices', ([], {}), '()\n', (161, 163), False, 'from src import most_invoices\n')] |
from __future__ import annotations
import csv
import pathlib
import textwrap
from operator import itemgetter
from typing import Any
from typing import Callable
from typing import Dict
from typing import IO
from typing import Iterable
from typing import Iterator
from typing import List
from typing import NamedTuple
fro... | [
"csv.DictWriter",
"textwrap.dedent",
"spinta.manifests.helpers.load_manifest_nodes",
"spinta.core.ufuncs.unparse",
"spinta.commands.link",
"openpyxl.load_workbook",
"spinta.manifests.tabular.formats.gsheets.read_gsheets_manifest",
"pathlib.Path",
"typing.cast",
"spinta.utils.data.take",
"spinta.... | [((32209, 32257), 'typing.TypeVar', 'TypeVar', (['"""T"""', 'Dataset', 'Model', 'Property', 'EnumItem'], {}), "('T', Dataset, Model, Property, EnumItem)\n", (32216, 32257), False, 'from typing import TypeVar\n'), ((27941, 27969), 'openpyxl.load_workbook', 'openpyxl.load_workbook', (['path'], {}), '(path)\n', (27963, 27... |
import glob, os
import subprocess
from difflib import context_diff
class TestRunner(object):
def __init__(self, context):
self.context = context
self.error_count = 0
self.test_count = 0
self.success_count = 0
def run(self):
os.getcwd()
os.chdir(self.context.repo... | [
"subprocess.Popen",
"os.path.join",
"os.getcwd",
"os.chdir",
"os.path.isfile",
"difflib.context_diff",
"glob.glob"
] | [((274, 285), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (283, 285), False, 'import glob, os\n'), ((294, 325), 'os.chdir', 'os.chdir', (['self.context.repo_dir'], {}), '(self.context.repo_dir)\n', (302, 325), False, 'import glob, os\n'), ((344, 390), 'os.path.join', 'os.path.join', (['self.context.testcasedir', '"""*.... |
# coding=utf-8
import optparse
import torch
import time
import pickle
from torch.autograd import Variable
from loader import *
from utils import *
# python -m visdom.server
optparser = optparse.OptionParser()
optparser.add_option(
"-t", "--test", default="data/eng.testb",
help="Test set location"
)
optparse... | [
"torch.LongTensor",
"torch.load",
"pickle.load",
"optparse.OptionParser",
"torch.cuda.is_available",
"time.time"
] | [((189, 212), 'optparse.OptionParser', 'optparse.OptionParser', ([], {}), '()\n', (210, 212), False, 'import optparse\n'), ((1903, 1930), 'torch.load', 'torch.load', (['opts.model_path'], {}), '(opts.model_path)\n', (1913, 1930), False, 'import torch\n'), ((5002, 5013), 'time.time', 'time.time', ([], {}), '()\n', (5011... |
import os
import sys
sys.path.insert(0, os.path.abspath('..'))
def get_version(filename):
from re import findall
with open(filename) as f:
metadata = dict(findall(r"__([a-z]+)__ = '([^']+)'", f.read()))
return metadata['version']
project = 'carreralib'
copyright = '2015-2017 <NAME>'
version = g... | [
"os.path.abspath"
] | [((41, 62), 'os.path.abspath', 'os.path.abspath', (['""".."""'], {}), "('..')\n", (56, 62), False, 'import os\n')] |
#!/usr/bin/env python
# encoding: utf-8
"""
@author: sherlock
@contact: <EMAIL>
"""
import logging
import os
import sys
sys.path.append('.')
from fastreid.config import get_cfg
from projects.InterpretationReID.interpretationreid.engine import DefaultTrainer, default_argument_parser, default_setup, launch
from fastr... | [
"logging.getLogger",
"projects.InterpretationReID.interpretationreid.add_build_reid_test_loader",
"fastreid.utils.checkpoint.Checkpointer",
"projects.InterpretationReID.interpretationreid.add_build_reid_train_loader",
"projects.InterpretationReID.interpretationreid.add_interpretation_config",
"os.path.joi... | [((123, 143), 'sys.path.append', 'sys.path.append', (['"""."""'], {}), "('.')\n", (138, 143), False, 'import sys\n'), ((1635, 1644), 'fastreid.config.get_cfg', 'get_cfg', ([], {}), '()\n', (1642, 1644), False, 'from fastreid.config import get_cfg\n'), ((1649, 1683), 'projects.InterpretationReID.interpretationreid.add_i... |
#!/usr/bin/env python
'''Tests for the likelihood.py module'''
from time import perf_counter_ns
import pytest
import numpy as np
from numpy.testing import assert_array_equal, assert_almost_equal
from scipy.stats import gamma
import likelihood
SMALL_FIT_PARAMS = {
'baseline_intensities': np.asarray([1, 2, np.na... | [
"numpy.random.default_rng",
"likelihood.read_and_tidy_data",
"time.perf_counter_ns",
"likelihood.likelihood",
"scipy.stats.gamma.pdf",
"numpy.asarray",
"likelihood.cached_single_excitation",
"numpy.testing.assert_almost_equal",
"numpy.linspace",
"numpy.testing.assert_array_equal",
"likelihood.si... | [((1212, 1332), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""test_element,result_dtype"""', '[(123456789, np.uint32), (65535, np.uint16), (255, np.uint8)]'], {}), "('test_element,result_dtype', [(123456789, np.uint32\n ), (65535, np.uint16), (255, np.uint8)])\n", (1235, 1332), False, 'import pytest\n'... |
import requests, os
from dotenv import load_dotenv
load_dotenv()
API_TOKEN = os.getenv('API_TOKEN')
def sendMessage(user_id: str, text: str, max_retries: int = 1):
url = f'https://api.telegram.org/bot{API_TOKEN}/sendMessage'
payload = {
"chat_id": user_id,
"text": text
}
for i in rang... | [
"requests.get",
"os.getenv",
"dotenv.load_dotenv"
] | [((52, 65), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (63, 65), False, 'from dotenv import load_dotenv\n'), ((79, 101), 'os.getenv', 'os.getenv', (['"""API_TOKEN"""'], {}), "('API_TOKEN')\n", (88, 101), False, 'import requests, os\n'), ((348, 381), 'requests.get', 'requests.get', (['url'], {'params': 'payl... |
from numpy.testing import assert_array_almost_equal as array_assert
from badboids.boids import SimulationParameters
def test_simulation_parameters_init():
"""Tests Simulation Parameters constructor"""
# Arrange
formation_flying_distance = 800
formation_flying_strength = 0.10
alert_distance = 8
... | [
"badboids.boids.SimulationParameters",
"numpy.testing.assert_array_almost_equal",
"badboids.boids.SimulationParameters.get_defaults"
] | [((392, 520), 'badboids.boids.SimulationParameters', 'SimulationParameters', (['formation_flying_distance', 'formation_flying_strength', 'alert_distance', 'move_to_middle_strength', 'delta_t'], {}), '(formation_flying_distance, formation_flying_strength,\n alert_distance, move_to_middle_strength, delta_t)\n', (412, ... |
#-*- coding: utf-8 -*-
from django_town.core.settings import OAUTH2_SETTINGS
try:
if not OAUTH2_SETTINGS.ACCESS_TOKEN_SECRET_KEY:
raise ImportError
except KeyError:
# import traceback
# traceback.print_exc()
raise ImportError
from django.db import models
from django.conf import settings
from ... | [
"django_town.utils.generate_random_from_vschar_set",
"django_town.core.fields.JSONField",
"django.db.models.ForeignKey",
"django.db.models.IntegerField",
"django.contrib.admin.site.register",
"django.db.models.URLField",
"django.db.models.CharField"
] | [((3154, 3199), 'django.contrib.admin.site.register', 'admin.site.register', (['Client', 'admin.ModelAdmin'], {}), '(Client, admin.ModelAdmin)\n', (3173, 3199), False, 'from django.contrib import admin\n'), ((3200, 3246), 'django.contrib.admin.site.register', 'admin.site.register', (['Service', 'admin.ModelAdmin'], {})... |
# List files in a directory. Useful for testing the path
from local_tools import *
from image_renamer import ImageRenamer
if confirm_config('path'):
img_path = get_config('path')
fl = ImageRenamer(img_path)
for ff in fl.image_files():
print(ff)
| [
"image_renamer.ImageRenamer"
] | [((192, 214), 'image_renamer.ImageRenamer', 'ImageRenamer', (['img_path'], {}), '(img_path)\n', (204, 214), False, 'from image_renamer import ImageRenamer\n')] |
#!/usr/bin/env python3
import logging
import argparse
from pathlib import Path
from vosk import list_models, list_languages
from vosk.transcriber.transcriber import Transcriber
parser = argparse.ArgumentParser(
description = 'Transcribe audio file and save result in selected format')
parser.add_argument(
... | [
"vosk.list_languages",
"logging.getLogger",
"argparse.ArgumentParser",
"pathlib.Path",
"vosk.list_models",
"vosk.transcriber.transcriber.Transcriber",
"logging.info"
] | [((189, 289), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Transcribe audio file and save result in selected format"""'}), "(description=\n 'Transcribe audio file and save result in selected format')\n", (212, 289), False, 'import argparse\n'), ((1814, 1831), 'vosk.transcriber.trans... |
import numpy as np
import cv2
from imutils.object_detection import non_max_suppression
import pytesseract
from matplotlib import pyplot as plt
def ocr(images):
results = []
for image in images:
args = {"image": image, "east": "frozen_east_text_detection.pb", "min_confidence": 0.5, "width": 320,
... | [
"cv2.dnn.blobFromImage",
"numpy.array",
"numpy.cos",
"pytesseract.image_to_string",
"numpy.sin",
"cv2.resize",
"cv2.imread",
"cv2.dnn.readNet"
] | [((391, 416), 'cv2.imread', 'cv2.imread', (["args['image']"], {}), "(args['image'])\n", (401, 416), False, 'import cv2\n'), ((627, 658), 'cv2.resize', 'cv2.resize', (['image', '(newW, newH)'], {}), '(image, (newW, newH))\n', (637, 658), False, 'import cv2\n'), ((708, 805), 'cv2.dnn.blobFromImage', 'cv2.dnn.blobFromImag... |
""" Tests for validators
"""
from decimal import Decimal
from unittest.mock import Mock
import random
import string
from styler_validation import validators as va
from styler_validation import messages as msg
class MyModel:
pass
class TestIsRequired:
def test_is_required(self):
val = va.is_require... | [
"styler_validation.validators.is_integer",
"styler_validation.validators.is_greater_than_number",
"styler_validation.validators.is_money",
"styler_validation.validators.is_valid_time",
"random.choices",
"styler_validation.validators.if_",
"styler_validation.validators.is_greater_than_field",
"styler_v... | [((307, 323), 'styler_validation.validators.is_required', 'va.is_required', ([], {}), '()\n', (321, 323), True, 'from styler_validation import validators as va\n'), ((532, 548), 'styler_validation.validators.is_required', 'va.is_required', ([], {}), '()\n', (546, 548), True, 'from styler_validation import validators as... |
from django.core.files.storage import FileSystemStorage
from django.db import models
# Create your models here.
from datetime import date
from django.urls import reverse #Used to generate URLs by reversing the URL patterns
from django.contrib.auth.models import User #Blog author or commenter
def attachment_path(ins... | [
"django.db.models.ForeignKey",
"django.db.models.FileField",
"django.db.models.DateTimeField",
"django.db.models.ImageField",
"django.db.models.CharField"
] | [((614, 742), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(50)', 'unique': '(True)', 'verbose_name': '"""Type of animal"""', 'help_text': '"""Enter a type of animal (e.g. Savec)"""'}), "(max_length=50, unique=True, verbose_name='Type of animal',\n help_text='Enter a type of animal (e.g. Sa... |
"""
github : https://github.com/amingolnari/Deep-Learning-Course
Author : <NAME>
Keras Version : 2.2.4
Date : 4/12/2018
Keras CNN Classification on MNIST Data
Code 301
"""
## If your GPU is AMD , you can use PlaidML Backend
# import os
# os.environ["KERAS_BACKEND"] = "plaidml.keras.backend"
from keras.models import ... | [
"keras.layers.Conv2D",
"matplotlib.pyplot.grid",
"keras.layers.Flatten",
"keras.datasets.mnist.load_data",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.gcf",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.tick_params",
"keras.models.Sequential",
"keras.utils.np_utils.... | [((640, 657), 'keras.datasets.mnist.load_data', 'mnist.load_data', ([], {}), '()\n', (655, 657), False, 'from keras.datasets import mnist\n'), ((866, 892), 'keras.utils.np_utils.to_categorical', 'to_categorical', (['Ytrain', '(10)'], {}), '(Ytrain, 10)\n', (880, 892), False, 'from keras.utils.np_utils import to_categor... |
# derwin.py - testing a window within a window
import curses
def main(stdscr):
# Create container window from stdscr
sh, sw = stdscr.getmaxyx()
container_win = curses.newwin(sh-1, sw-1, 1, 1)
# Create inner window from container win
bh, bw = container_win.getmaxyx()
box_win = container_win.de... | [
"curses.wrapper",
"curses.newwin"
] | [((174, 209), 'curses.newwin', 'curses.newwin', (['(sh - 1)', '(sw - 1)', '(1)', '(1)'], {}), '(sh - 1, sw - 1, 1, 1)\n', (187, 209), False, 'import curses\n'), ((600, 620), 'curses.wrapper', 'curses.wrapper', (['main'], {}), '(main)\n', (614, 620), False, 'import curses\n')] |
import sys
import logging
from unicorn import *
from unicorn.arm_const import *
from androidemu.emulator import Emulator
from UnicornTraceDebugger import udbg
logging.basicConfig(stream=sys.stdout,
level=logging.DEBUG,
format="%(asctime)s %(levelname)7s %(name)34s | %(message)s")
logger = logging.getLogger(__n... | [
"logging.basicConfig",
"UnicornTraceDebugger.udbg.UnicornDebugger",
"androidemu.emulator.Emulator",
"logging.getLogger"
] | [((160, 286), 'logging.basicConfig', 'logging.basicConfig', ([], {'stream': 'sys.stdout', 'level': 'logging.DEBUG', 'format': '"""%(asctime)s %(levelname)7s %(name)34s | %(message)s"""'}), "(stream=sys.stdout, level=logging.DEBUG, format=\n '%(asctime)s %(levelname)7s %(name)34s | %(message)s')\n", (179, 286), False... |
#!/usr/bin/env python
import rospy
from std_msgs.msg import String
from nav_msgs.msg import Odometry
from trajectory_msgs.msg import JointTrajectory
from control_msgs.msg import JointTrajectoryControllerState
def callback_odom(data):
print("odom\n" + str(data))
def callback_JointTrajectory(data):
print("gri... | [
"rospy.init_node",
"rospy.Subscriber",
"rospy.spin"
] | [((474, 519), 'rospy.init_node', 'rospy.init_node', (['"""listener12"""'], {'anonymous': '(True)'}), "('listener12', anonymous=True)\n", (489, 519), False, 'import rospy\n'), ((685, 806), 'rospy.Subscriber', 'rospy.Subscriber', (['"""/arm_1/gripper_controller/state"""', 'JointTrajectoryControllerState', 'callback_gripp... |
#Botpic:https://upload.wikimedia.org/wikipedia/commons/thumb/b/b8/Red_Rose_Photography.jpg/800px-Red_Rose_Photography.jpg
#Botpic:https://commons.wikimedia.org/wiki/File:Red_Rose_Photography.jpg
#reference:https://www.youtube.com/watch?v=SPTfmiYiuok
import discord
import os
import requests
import json
import math, ra... | [
"discord.Game",
"discord.FFmpegPCMAudio",
"keep_alive.keep_alive",
"time.sleep",
"youtube_dl.YoutubeDL",
"discord.Client",
"os.remove",
"discord.ext.commands.Cog.listener",
"time.ctime",
"os.listdir",
"discord.ext.commands.Bot",
"dotenv.load_dotenv",
"os.mkdir",
"discord.Color.blue",
"di... | [((742, 755), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (753, 755), False, 'from dotenv import load_dotenv\n'), ((766, 782), 'discord.Client', 'discord.Client', ([], {}), '()\n', (780, 782), False, 'import discord\n'), ((939, 964), 'discord.Intents.default', 'discord.Intents.default', ([], {}), '()\n', (96... |
# Code Taken from https://github.com/LYH-YF/MWPToolkit
# -*- encoding: utf-8 -*-
# @Author: <NAME>
# @Time: 2021/08/29 22:05:03
# @File: transformer_layer.py
import torch
import math
from torch import nn
from torch.nn import functional as F
from transformers.activations import gelu_new as gelu_bert
from module.Att... | [
"module.Attention.multi_head_attention.EPTMultiHeadAttention",
"torch.nn.Dropout",
"torch.nn.init.constant_",
"torch.nn.LayerNorm",
"math.sqrt",
"torch.nn.Linear",
"module.Attention.multi_head_attention.MultiHeadAttention",
"torch.zeros",
"torch.nn.init.normal_",
"torch.ones"
] | [((1572, 1644), 'module.Attention.multi_head_attention.MultiHeadAttention', 'MultiHeadAttention', (['embedding_size', 'num_heads', 'attn_weight_dropout_ratio'], {}), '(embedding_size, num_heads, attn_weight_dropout_ratio)\n', (1590, 1644), False, 'from module.Attention.multi_head_attention import MultiHeadAttention\n')... |
from correlate import *
import matplotlib
import matplotlib.pyplot as plt
import seaborn as sns
from matplotlib import rc, rcParams
rc('axes', linewidth=1)
rc('font', weight='bold', size=10)
def barplots(prefixes, regions, stains, corre, error, name, folder, ylim):
for stain in stains:
barplot(prefixes, r... | [
"matplotlib.pyplot.subplots",
"matplotlib.rc",
"matplotlib.pyplot.close"
] | [((133, 156), 'matplotlib.rc', 'rc', (['"""axes"""'], {'linewidth': '(1)'}), "('axes', linewidth=1)\n", (135, 156), False, 'from matplotlib import rc, rcParams\n'), ((157, 191), 'matplotlib.rc', 'rc', (['"""font"""'], {'weight': '"""bold"""', 'size': '(10)'}), "('font', weight='bold', size=10)\n", (159, 191), False, 'f... |
# Generated by Django 2.2.1 on 2019-05-16 23:28
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
ope... | [
"django.db.models.OneToOneField",
"django.db.models.TextField",
"django.db.models.AutoField",
"django.db.models.SmallIntegerField",
"django.db.migrations.swappable_dependency",
"django.db.models.CharField"
] | [((247, 304), 'django.db.migrations.swappable_dependency', 'migrations.swappable_dependency', (['settings.AUTH_USER_MODEL'], {}), '(settings.AUTH_USER_MODEL)\n', (278, 304), False, 'from django.db import migrations, models\n'), ((442, 535), 'django.db.models.AutoField', 'models.AutoField', ([], {'auto_created': '(True)... |
from rest_framework import serializers, exceptions
from greenbudget.lib.rest_framework_utils.serializers import (
EnhancedModelSerializer)
from greenbudget.app.account.models import BudgetAccount, TemplateAccount
from greenbudget.app.tagging.serializers import ColorField
from greenbudget.app.subaccount.models imp... | [
"rest_framework.serializers.DateTimeField",
"rest_framework.serializers.IntegerField",
"rest_framework.serializers.PrimaryKeyRelatedField",
"greenbudget.app.subaccount.models.BudgetSubAccount.objects.active",
"greenbudget.app.subaccount.models.TemplateSubAccount.objects.active",
"greenbudget.app.account.m... | [((568, 608), 'rest_framework.serializers.IntegerField', 'serializers.IntegerField', ([], {'read_only': '(True)'}), '(read_only=True)\n', (592, 608), False, 'from rest_framework import serializers, exceptions\n'), ((620, 694), 'rest_framework.serializers.CharField', 'serializers.CharField', ([], {'required': '(False)',... |
# -*- coding: utf-8 -*-
"""
INTRO
@author: <NAME>. Created on Tue May 21 11:57:52 2019
Department of Aerodynamics
Faculty of Aerospace Engineering
TU Delft,
Delft, the Netherlands
"""
import inspect
from screws.freeze.main import FrozenOnly
from typing import Dict, Union
import nu... | [
"numpy.shape",
"inspect.getfullargspec"
] | [((1001, 1038), 'inspect.getfullargspec', 'inspect.getfullargspec', (['self.__init__'], {}), '(self.__init__)\n', (1023, 1038), False, 'import inspect\n'), ((4446, 4465), 'numpy.shape', 'np.shape', (['_dict_[R]'], {}), '(_dict_[R])\n', (4454, 4465), True, 'import numpy as np\n')] |
from app import db
from app.models.serializer import Serializer
class Weather(db.Model, Serializer):
id = db.Column(db.Integer, primary_key=True)
ip = db.Column(db.String(15), index=True, unique=True)
country = db.Column(db.String(80))
flag = db.Column(db.String(512))
town = db.Column(db.String(80... | [
"app.db.String",
"app.db.Column",
"app.models.serializer.Serializer.serialize"
] | [((112, 151), 'app.db.Column', 'db.Column', (['db.Integer'], {'primary_key': '(True)'}), '(db.Integer, primary_key=True)\n', (121, 151), False, 'from app import db\n'), ((171, 184), 'app.db.String', 'db.String', (['(15)'], {}), '(15)\n', (180, 184), False, 'from app import db\n'), ((235, 248), 'app.db.String', 'db.Stri... |
from pgdrive.component.blocks.curve import Curve
from pgdrive.component.blocks.first_block import FirstPGBlock
from pgdrive.component.blocks.std_t_intersection import StdTInterSection
from pgdrive.component.blocks.straight import Straight
from pgdrive.component.road.road_network import RoadNetwork
from pgdrive.tests.vi... | [
"pgdrive.component.blocks.first_block.FirstPGBlock",
"pgdrive.tests.vis_block.vis_block_base.TestBlock",
"pgdrive.component.road.road_network.RoadNetwork",
"pgdrive.engine.asset_loader.initialize_asset_loader"
] | [((399, 414), 'pgdrive.tests.vis_block.vis_block_base.TestBlock', 'TestBlock', (['(True)'], {}), '(True)\n', (408, 414), False, 'from pgdrive.tests.vis_block.vis_block_base import TestBlock\n'), ((488, 517), 'pgdrive.engine.asset_loader.initialize_asset_loader', 'initialize_asset_loader', (['test'], {}), '(test)\n', (5... |
#!/usr/bin/env python3
"""
Author : <NAME> <<EMAIL>>
Date : 2021-11-09
Purpose: FInd the similarities between sequences.
"""
import argparse
# --------------------------------------------------
def get_args():
"""Get command-line arguments"""
parser = argparse.ArgumentParser(
description='Rock the... | [
"argparse.FileType",
"argparse.ArgumentParser"
] | [((266, 381), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Rock the Casbah"""', 'formatter_class': 'argparse.ArgumentDefaultsHelpFormatter'}), "(description='Rock the Casbah', formatter_class=\n argparse.ArgumentDefaultsHelpFormatter)\n", (289, 381), False, 'import argparse\n'), ((5... |
import pygame
import my_colors as color
pygame.init()
screen_width = 800
screen_height = 600
screen_size = (screen_width, screen_height)
screen = pygame.display.set_mode(screen_size)
pygame.display.set_caption("Search the green pixel at the coordinates (x=10, y=100)")
running = True
while running:
screen.set_at((... | [
"pygame.init",
"pygame.quit",
"pygame.display.set_mode",
"pygame.event.wait",
"pygame.display.set_caption",
"pygame.display.update"
] | [((41, 54), 'pygame.init', 'pygame.init', ([], {}), '()\n', (52, 54), False, 'import pygame\n'), ((147, 183), 'pygame.display.set_mode', 'pygame.display.set_mode', (['screen_size'], {}), '(screen_size)\n', (170, 183), False, 'import pygame\n'), ((184, 274), 'pygame.display.set_caption', 'pygame.display.set_caption', ([... |
#!/usr/bin/env python3
import os
import re
import glob
import sys
import operator
import ast
import argparse
###############################################################################################
# This script was written as part of the analysis conducted on the output generated by #
# hmmsearch, when... | [
"operator.itemgetter",
"os.path.splitext",
"argparse.ArgumentParser"
] | [((985, 1277), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Step 3: Generate summary tables for each taxonomic rank. Make sure to run the script from within the directory containing the domtbl output directories (check comment block for guidance) and following the scripts that execute ... |
# 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, software
# distributed under the Li... | [
"mock.Mock",
"openstack.telemetry.v2.sample.Sample.list",
"openstack.telemetry.v2.sample.Sample",
"openstack.telemetry.v2.sample.Sample.new"
] | [((1269, 1290), 'openstack.telemetry.v2.sample.Sample', 'sample.Sample', (['SAMPLE'], {}), '(SAMPLE)\n', (1282, 1290), False, 'from openstack.telemetry.v2 import sample\n'), ((1761, 1782), 'openstack.telemetry.v2.sample.Sample', 'sample.Sample', (['SAMPLE'], {}), '(SAMPLE)\n', (1774, 1782), False, 'from openstack.telem... |
# -*- coding: utf8 -*-
"""
======================================
Project Name: NLP
File Name: linears
Author: czh
Create Date: 2021/11/15
--------------------------------------
Change Activity:
======================================
"""
import math
import torch
import torch.nn as nn
import torch.... | [
"torch.mul",
"torch.nn.functional.tanh",
"torch.nn.Dropout",
"torch.nn.Tanh",
"torch.nn.LayerNorm",
"torch.nn.functional.gelu",
"torch.Tensor",
"math.sqrt",
"torch.nn.init.orthogonal_",
"torch.nn.init._calculate_fan_in_and_fan_out",
"torch.sum",
"torch.nn.Linear",
"torch.nn.functional.relu",... | [((537, 568), 'torch.nn.Linear', 'nn.Linear', (['input_dim', 'input_dim'], {}), '(input_dim, input_dim)\n', (546, 568), True, 'import torch.nn as nn\n'), ((588, 619), 'torch.nn.Linear', 'nn.Linear', (['input_dim', 'input_dim'], {}), '(input_dim, input_dim)\n', (597, 619), True, 'import torch.nn as nn\n'), ((639, 682), ... |
import requests
def company(SIREN):
r = requests.get('https://entreprise.data.gouv.fr/api/sirene/v2/siren/'+SIREN+'')
json_object = r.json()
settings = dict()
if json_object['sirene']['status'] == 404:
return None
if json_object['sirene']['data']['siege_social']['nom_raison_sociale'... | [
"requests.get"
] | [((48, 133), 'requests.get', 'requests.get', (["('https://entreprise.data.gouv.fr/api/sirene/v2/siren/' + SIREN + '')"], {}), "('https://entreprise.data.gouv.fr/api/sirene/v2/siren/' + SIREN +\n '')\n", (60, 133), False, 'import requests\n')] |
# --------------------------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for license information.
# --------------------------------------------------------------------... | [
"json.loads"
] | [((3391, 3421), 'json.loads', 'json.loads', (['direct_connections'], {}), '(direct_connections)\n', (3401, 3421), False, 'import json\n'), ((5033, 5063), 'json.loads', 'json.loads', (['direct_connections'], {}), '(direct_connections)\n', (5043, 5063), False, 'import json\n'), ((5274, 5306), 'json.loads', 'json.loads', ... |
"""Coverage based QC calculations.
"""
import glob
import os
import subprocess
from bcbio.bam import ref, readstats, utils
from bcbio.distributed import transaction
from bcbio.heterogeneity import chromhacks
import bcbio.pipeline.datadict as dd
from bcbio.provenance import do
from bcbio.variation import coverage as co... | [
"bcbio.bam.readstats.number_of_mapped_reads",
"bcbio.distributed.transaction.tx_tmpdir",
"bcbio.bam.utils.safe_makedir",
"bcbio.bam.utils.file_exists",
"bcbio.heterogeneity.chromhacks.is_sex",
"bcbio.qc.samtools.run",
"bcbio.variation.coverage.coverage_region_detailed_stats",
"bcbio.pipeline.datadict.... | [((466, 493), 'bcbio.bam.utils.safe_makedir', 'utils.safe_makedir', (['out_dir'], {}), '(out_dir)\n', (484, 493), False, 'from bcbio.bam import ref, readstats, utils\n'), ((953, 1013), 'bcbio.variation.coverage.get_average_coverage', 'cov.get_average_coverage', (['target_name', 'merged_bed_file', 'data'], {}), '(target... |
from concepts.letter_addition import LetterAddition
from learners.sim_memoryless_learner import SimMemorylessLearner
def test_see_example():
concept = LetterAddition(6)
learner = SimMemorylessLearner(concept, list(range(0, 7)))
learner.see_example(((0, 1), 10))
| [
"concepts.letter_addition.LetterAddition"
] | [((157, 174), 'concepts.letter_addition.LetterAddition', 'LetterAddition', (['(6)'], {}), '(6)\n', (171, 174), False, 'from concepts.letter_addition import LetterAddition\n')] |
import logging
import pandas as pd
from datetime import datetime
from typing import (
Any,
Callable,
Dict,
Hashable,
Iterable,
List,
NamedTuple,
Optional,
Pattern,
Set,
Tuple,
Union,
)
logger = logging.getLogger(__name__)
# add_jde_batch() {{{1... | [
"logging.getLogger",
"datetime.datetime.now",
"pandas.Series"
] | [((265, 292), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (282, 292), False, 'import logging\n'), ((2496, 2516), 'pandas.Series', 'pd.Series', (['range_seq'], {}), '(range_seq)\n', (2505, 2516), True, 'import pandas as pd\n'), ((2137, 2151), 'datetime.datetime.now', 'datetime.now', ([]... |
import os
import shutil
import logging
class BColors(object):
HEADER = "\033[95m"
OK_BLUE = "\033[94m"
OK_CYAN = "\033[96m"
OK_GREEN = "\033[92m"
WARNING = "\033[93m"
FAIL = "\033[91m"
END_C = "\033[0m"
BOLD = "\033[1m"
UNDERLINE = "\033[4m"
def touch(fname: str, times=None, crea... | [
"logging.getLogger",
"os.path.exists",
"logging.StreamHandler",
"os.makedirs",
"logging.Formatter",
"os.path.join",
"os.utime",
"os.path.dirname",
"shutil.rmtree"
] | [((1556, 1582), 'logging.getLogger', 'logging.getLogger', (['"""stats"""'], {}), "('stats')\n", (1573, 1582), False, 'import logging\n'), ((1819, 1845), 'logging.getLogger', 'logging.getLogger', (['"""debug"""'], {}), "('debug')\n", (1836, 1845), False, 'import logging\n'), ((1895, 1918), 'logging.StreamHandler', 'logg... |
#!/usr/bin/env python
from __future__ import division, absolute_import, print_function
from setuptools import setup
import os
import re
import shutil
_versionRE = re.compile(r'__version__\s*=\s*\"([^\"]+)\"')
# read the version number for the settings file
with open('drawBot/drawBotSettings.py', "r") as settings:
... | [
"re.compile",
"os.path.join",
"setuptools.setup",
"os.chmod",
"os.path.dirname",
"shutil.copyfile",
"os.remove"
] | [((165, 214), 're.compile', 're.compile', (['"""__version__\\\\s*=\\\\s*\\\\"([^\\\\"]+)\\\\\\""""'], {}), '(\'__version__\\\\s*=\\\\s*\\\\"([^\\\\"]+)\\\\"\')\n', (175, 214), False, 'import re\n'), ((1015, 1745), 'setuptools.setup', 'setup', ([], {'name': '"""drawBot"""', 'version': '__version__', 'description': '"""D... |
# Copyright 2013 Google Inc. All Rights Reserved.
"""Deletes a Cloud SQL instance."""
from googlecloudapis.apitools.base import py as apitools_base
from googlecloudsdk.calliope import base
from googlecloudsdk.calliope import exceptions
from googlecloudsdk.core import log
from googlecloudsdk.core.util import console_io... | [
"googlecloudsdk.sql.util.ValidateInstanceName",
"googlecloudsdk.core.util.console_io.PromptContinue",
"googlecloudsdk.sql.util.GetErrorMessage",
"googlecloudsdk.core.log.DeletedResource"
] | [((1461, 1501), 'googlecloudsdk.sql.util.ValidateInstanceName', 'util.ValidateInstanceName', (['args.instance'], {}), '(args.instance)\n', (1486, 1501), False, 'from googlecloudsdk.sql import util\n'), ((1592, 1693), 'googlecloudsdk.core.util.console_io.PromptContinue', 'console_io.PromptContinue', (['"""All of the ins... |
# lines 1-4 imports the necessary libraries
import pygame
import os
import random
import math
import sys
import hlp
import intro
import dsb # this is the last module with the description files
'''
declaring some global variables beacause in Python, we can set global variables that can be used in future functions
se... | [
"pygame.init",
"pygame.quit",
"pygame.font.Font",
"math.log10",
"pygame.display.set_mode",
"pygame.display.flip",
"pygame.mouse.get_pos",
"hlp.InsertNumber",
"pygame.draw.rect",
"random.sample",
"random.randrange",
"pygame.Color",
"pygame.time.Clock",
"hlp.AddText",
"os.path.abspath",
... | [((802, 815), 'pygame.init', 'pygame.init', ([], {}), '()\n', (813, 815), False, 'import pygame\n'), ((831, 856), 'pygame.Color', 'pygame.Color', (['(50)', '(50)', '(120)'], {}), '(50, 50, 120)\n', (843, 856), False, 'import pygame\n'), ((921, 1018), 'pygame.display.set_mode', 'pygame.display.set_mode', (['(1280, 550)'... |
import aiohttp
import asyncio
import async_timeout
import logging
from collections import namedtuple, deque
from .events import Events
from html.parser import HTMLParser
log = logging.getLogger(__name__)
class Parser(HTMLParser):
def handle_starttag(self, tag, attrs):
log.debug("Encountered a start tag:... | [
"logging.getLogger",
"aiohttp.ClientSession",
"collections.namedtuple",
"collections.deque",
"async_timeout.timeout",
"asyncio.sleep"
] | [((178, 205), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (195, 205), False, 'import logging\n'), ((1520, 1573), 'collections.namedtuple', 'namedtuple', (['"""Command"""', '"""name method params completed"""'], {}), "('Command', 'name method params completed')\n", (1530, 1573), False, ... |
from ..models import Classify, Fields, Asset, AssetBind, ClassifyBind
from django.db.models import Q
from collections import OrderedDict
from django.forms.models import model_to_dict
class OperateInstance:
@staticmethod
def get_classify(id):
"""通过ID 查找指定分类表"""
return Classify.objects.filter(id... | [
"django.db.models.Q",
"django.forms.models.model_to_dict",
"collections.OrderedDict"
] | [((4506, 4529), 'django.db.models.Q', 'Q', ([], {'parent_asset_id': 'c_id'}), '(parent_asset_id=c_id)\n', (4507, 4529), False, 'from django.db.models import Q\n'), ((4532, 4554), 'django.db.models.Q', 'Q', ([], {'child_asset_id': 'c_id'}), '(child_asset_id=c_id)\n', (4533, 4554), False, 'from django.db.models import Q\... |
import os
import torch
from modeling.unet import *
from modeling.bAttenUnet import MDecoderUNet, MMultiBAUNet, MMultiBUNet
def build_model(args, nchannels, nclass, model='unet'):
if model == 'unet':
return UNet(
n_channels=nchannels,
n_classes=nclass,
bilinear=True,
... | [
"modeling.bAttenUnet.MDecoderUNet",
"modeling.bAttenUnet.MMultiBAUNet",
"modeling.bAttenUnet.MMultiBUNet",
"torch.load",
"os.path.isfile"
] | [((3316, 3338), 'torch.load', 'torch.load', (['pretrained'], {}), '(pretrained)\n', (3326, 3338), False, 'import torch\n'), ((3200, 3226), 'os.path.isfile', 'os.path.isfile', (['pretrained'], {}), '(pretrained)\n', (3214, 3226), False, 'import os\n'), ((439, 528), 'modeling.bAttenUnet.MDecoderUNet', 'MDecoderUNet', ([]... |
import KeyPressModule as kp
from djitellopy import tello
import time
import cv2
global img
kp.init()
skynet = tello.Tello()
skynet.connect()
print(skynet.get_battery())
skynet.streamon()
def getKeyboardInput():
lr, fb, ud, yv = 0, 0, 0, 0
speed = 50
if kp.getKey("LEFT"): lr = -speed
elif kp.getKey(... | [
"time.sleep",
"cv2.imshow",
"KeyPressModule.init",
"djitellopy.tello.Tello",
"time.time",
"cv2.waitKey",
"KeyPressModule.getKey"
] | [((92, 101), 'KeyPressModule.init', 'kp.init', ([], {}), '()\n', (99, 101), True, 'import KeyPressModule as kp\n'), ((112, 125), 'djitellopy.tello.Tello', 'tello.Tello', ([], {}), '()\n', (123, 125), False, 'from djitellopy import tello\n'), ((270, 287), 'KeyPressModule.getKey', 'kp.getKey', (['"""LEFT"""'], {}), "('LE... |
from foolbox import zoo
import numpy as np
import foolbox
import sys
import pytest
from foolbox.zoo.model_loader import ModelLoader
from os.path import join, dirname
@pytest.fixture(autouse=True)
def unload_foolbox_model_module():
# reload foolbox_model from scratch for every run
# to ensure atomic tests with... | [
"numpy.argmax",
"foolbox.zoo.model_loader.ModelLoader.get",
"pytest.mark.parametrize",
"numpy.zeros",
"numpy.sum",
"pytest.raises",
"os.path.dirname",
"foolbox.utils.softmax",
"pytest.fixture",
"foolbox.zoo.get_model",
"numpy.random.randn"
] | [((169, 197), 'pytest.fixture', 'pytest.fixture', ([], {'autouse': '(True)'}), '(autouse=True)\n', (183, 197), False, 'import pytest\n'), ((853, 899), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""url, dim"""', 'test_data'], {}), "('url, dim', test_data)\n", (876, 899), False, 'import pytest\n'), ((967, 9... |
"""
Copyright 2015-2017 <NAME>
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
di... | [
"nistbeacon.NistBeacon.get_next",
"unittest.mock.Mock",
"nistbeacon.NistBeacon.get_first_record",
"nistbeacon.NistBeacon.get_last_record",
"nistbeacon.NistBeaconValue.from_json",
"nistbeacon.NistBeacon.get_previous",
"nistbeacon.NistBeacon.chain_check",
"nistbeacon.NistBeacon.get_record",
"unittest.... | [((1955, 1976), 'unittest.mock.patch', 'patch', (['"""requests.get"""'], {}), "('requests.get')\n", (1960, 1976), False, 'from unittest.mock import Mock, patch\n'), ((2729, 2750), 'unittest.mock.patch', 'patch', (['"""requests.get"""'], {}), "('requests.get')\n", (2734, 2750), False, 'from unittest.mock import Mock, pa... |
import cv2
import numpy as np
import os
from auto_pose.meshrenderer import meshrenderer
from auto_pose.ae.utils import lazy_property
class PoseVisualizer:
def __init__(self, mp_pose_estimator, downsample=1, vertex_scale=False):
self.downsample = downsample
self.vertex_scale = [mp_pose_estimator... | [
"cv2.rectangle",
"numpy.dstack",
"numpy.any",
"cv2.imshow",
"cv2.putText",
"cv2.waitKey",
"cv2.resize",
"numpy.zeros_like"
] | [((2879, 2908), 'cv2.resize', 'cv2.resize', (['image', '(W_d, H_d)'], {}), '(image, (W_d, H_d))\n', (2889, 2908), False, 'import cv2\n'), ((3016, 3034), 'numpy.zeros_like', 'np.zeros_like', (['bgr'], {}), '(bgr)\n', (3029, 3034), True, 'import numpy as np\n'), ((3798, 3817), 'numpy.any', 'np.any', (['depth_image'], {})... |
"""
User module
"""
import discord
import random
import asyncio
from discord.ext import commands
from discord.ext.commands import has_permissions, MissingPermissions, BadArgument
import requests, json, pyfiglet
from datetime import timedelta, datetime
class User(commands.Cog):
api_key = "<KEY>"
base_url = "... | [
"random.choice",
"random.randint",
"pyfiglet.figlet_format",
"requests.get",
"discord.ext.commands.group",
"discord.Color.dark_theme",
"asyncio.sleep",
"json.load",
"discord.ext.commands.command"
] | [((2097, 2115), 'discord.ext.commands.command', 'commands.command', ([], {}), '()\n', (2113, 2115), False, 'from discord.ext import commands\n'), ((2324, 2342), 'discord.ext.commands.command', 'commands.command', ([], {}), '()\n', (2340, 2342), False, 'from discord.ext import commands\n'), ((2550, 2568), 'discord.ext.c... |
"""Admin sites for the ``django-tinylinks`` app."""
from django.contrib import admin
from django.template.defaultfilters import truncatechars
from django.utils.translation import ugettext_lazy as _
from django.template.loader import render_to_string
from tinylinks.forms import TinylinkAdminForm
from tinylinks.models ... | [
"django.contrib.admin.site.register",
"django.utils.translation.ugettext_lazy",
"django.template.defaultfilters.truncatechars"
] | [((1003, 1047), 'django.contrib.admin.site.register', 'admin.site.register', (['Tinylink', 'TinylinkAdmin'], {}), '(Tinylink, TinylinkAdmin)\n', (1022, 1047), False, 'from django.contrib import admin\n'), ((1230, 1280), 'django.contrib.admin.site.register', 'admin.site.register', (['TinylinkLog', 'TinylinkLogAdmin'], {... |
import requests
import json
def main():
host = "http://localhost:5006"
urlpattern = "/user/"
response = requests.post(f"{host}{urlpattern}", json={'key1': 'random value'})
if 199 < response.status_code < 300:
for k, v in response.headers.items():
print(f"{k} -> {v}")
prin... | [
"json.loads",
"requests.post"
] | [((119, 186), 'requests.post', 'requests.post', (['f"""{host}{urlpattern}"""'], {'json': "{'key1': 'random value'}"}), "(f'{host}{urlpattern}', json={'key1': 'random value'})\n", (132, 186), False, 'import requests\n'), ((353, 378), 'json.loads', 'json.loads', (['response.text'], {}), '(response.text)\n', (363, 378), F... |
#!/usr/bin/python
import os
import glob
import traceback
import datetime
import dandan
from flask import Flask
from flask import abort
from flask import send_file
from flask import send_from_directory
from flask import render_template
from werkzeug.routing import BaseConverter
import config
__VERSI... | [
"flask.render_template",
"os.path.exists",
"os.path.getsize",
"os.listdir",
"flask.Flask",
"dandan.value.AttrDict",
"os.path.join",
"os.path.isfile",
"datetime.datetime.now",
"os.path.isdir",
"os.path.basename",
"os.path.abspath",
"os.path.getmtime",
"flask.send_file",
"traceback.print_e... | [((406, 456), 'os.path.join', 'os.path.join', (['dirname', '"""static/images/favicon.ico"""'], {}), "(dirname, 'static/images/favicon.ico')\n", (418, 456), False, 'import os\n'), ((602, 617), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (607, 617), False, 'from flask import Flask\n'), ((368, 393), 'os.pa... |
#!/usr/bin/env python3
from subprocess import Popen, PIPE, DEVNULL, run
import socket
import sys
import traceback
import argparse
import time
import logging
import os
logger = logging.getLogger("django")
def startProcess(command, port):
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
... | [
"logging.getLogger",
"traceback.format_exc",
"socket.socket",
"subprocess.run",
"time.sleep",
"os.path.dirname",
"sys.exit",
"socket.gethostname"
] | [((178, 205), 'logging.getLogger', 'logging.getLogger', (['"""django"""'], {}), "('django')\n", (195, 205), False, 'import logging\n'), ((264, 313), 'socket.socket', 'socket.socket', (['socket.AF_INET', 'socket.SOCK_STREAM'], {}), '(socket.AF_INET, socket.SOCK_STREAM)\n', (277, 313), False, 'import socket\n'), ((613, 6... |
"""Datatest main program"""
import sys as _sys
from unittest import TestProgram as _TestProgram
from unittest import defaultTestLoader as _defaultTestLoader
try:
from unittest.signals import installHandler
except ImportError:
installHandler = None
from datatest import DataTestRunner
__unittest = True
__datat... | [
"unittest.TestProgram.__init__",
"unittest.signals.installHandler"
] | [((677, 904), 'unittest.TestProgram.__init__', '_TestProgram.__init__', (['self'], {'module': 'module', 'defaultTest': 'defaultTest', 'argv': 'argv', 'testRunner': 'testRunner', 'testLoader': 'testLoader', 'exit': 'exit', 'verbosity': 'verbosity', 'failfast': 'failfast', 'catchbreak': 'catchbreak', 'buffer': 'buffer'})... |
import numpy as np
from uncertainties import umath as um
def getTeqpl(Teffst, aR, ecc, A=0, f=1/4.):
"""Return the planet equilibrium temperature.
Relation adapted from equation 4 page 4 in http://www.mpia.de/homes/ppvi/chapter/madhusudhan.pdf
and https://en.wikipedia.org/wiki/Stefan%E2%80%93Boltzmann_law... | [
"numpy.sqrt",
"uncertainties.umath.sqrt"
] | [((1240, 1255), 'numpy.sqrt', 'np.sqrt', (['(1 / aR)'], {}), '(1 / aR)\n', (1247, 1255), True, 'import numpy as np\n'), ((2469, 2484), 'uncertainties.umath.sqrt', 'um.sqrt', (['(1 / aR)'], {}), '(1 / aR)\n', (2476, 2484), True, 'from uncertainties import umath as um\n')] |
import pandas as pd
import re
import os
from tqdm import tqdm
## Cleaning train raw dataset
train = open('./data/raw/train.crash').readlines()
train_ids = []
train_texts = []
train_labels = []
for id, line in tqdm(enumerate(train)):
line = line.strip()
if line.startswith("train_"):
train_ids.append... | [
"os.path.exists",
"pandas.read_csv",
"os.makedirs",
"pandas.DataFrame",
"re.sub",
"pandas.concat"
] | [((646, 721), 'pandas.DataFrame', 'pd.DataFrame', (["{'id': train_ids, 'text': train_texts, 'label': train_labels}"], {}), "({'id': train_ids, 'text': train_texts, 'label': train_labels})\n", (658, 721), True, 'import pandas as pd\n'), ((1388, 1438), 'pandas.DataFrame', 'pd.DataFrame', (["{'id': test_ids, 'text': test_... |
import pathlib
from setuptools import setup, find_packages
HERE = pathlib.Path(__file__).parent
README = (HERE / "README.md").read_text()
setup(name="google-ads-api-report-fetcher",
version="0.1",
description="Library for fetching reports from Google Ads API and saving them locally / BigQuery.",
lo... | [
"setuptools.find_packages",
"pathlib.Path"
] | [((67, 89), 'pathlib.Path', 'pathlib.Path', (['__file__'], {}), '(__file__)\n', (79, 89), False, 'import pathlib\n'), ((889, 934), 'setuptools.find_packages', 'find_packages', ([], {'include': "['runner', 'runner.*']"}), "(include=['runner', 'runner.*'])\n", (902, 934), False, 'from setuptools import setup, find_packag... |
import glob
import os
from io import StringIO
from threading import Thread
import logging
from logger import TimeHandler
from costants import THREADS, INFERENCE_GRAPH
from pipeline import pipeline
logger = logging.getLogger(__name__)
logger.setLevel(logging.INFO)
logger.addHandler(TimeHandler().handler)
... | [
"logging.getLogger",
"threading.Thread.__init__",
"glob.iglob",
"os.path.join",
"logger.TimeHandler",
"io.StringIO",
"pipeline.pipeline"
] | [((216, 243), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (233, 243), False, 'import logging\n'), ((917, 974), 'glob.iglob', 'glob.iglob', (["('..\\\\Polizze\\\\' + '/**/*.pdf')"], {'recursive': '(True)'}), "('..\\\\Polizze\\\\' + '/**/*.pdf', recursive=True)\n", (927, 974), False, 'im... |
import time
import sys
import json
import argparse
from tqdm import trange
from typing import Any, Callable, Dict, List, Optional, Tuple, Union
import torch
import numpy as np
from scipy.spatial.distance import jensenshannon
import gym
import matplotlib.pyplot as plt
from matplotlib.axes import Axes
fr... | [
"pandemic_simulator.sh.DefaultPersonRoutineAssignment",
"torch.as_tensor",
"numpy.sqrt",
"pandemic_simulator.model.StageModel",
"torch.exp",
"numpy.array",
"pandemic_simulator.init_globals",
"matplotlib.ticker.MaxNLocator",
"pandemic_simulator.viz.GymViz.from_config",
"pandemic_simulator.env.Locat... | [((8355, 8376), 'numpy.array', 'np.array', (['viz._stages'], {}), '(viz._stages)\n', (8363, 8376), True, 'import numpy as np\n'), ((8395, 8420), 'numpy.array', 'np.array', (['viz._stages_std'], {}), '(viz._stages_std)\n', (8403, 8420), True, 'import numpy as np\n'), ((8930, 8982), 'matplotlib.lines.Line2D', 'Line2D', (... |
from setuptools import setup
setup(
name="codewars_unittest",
version="0.1.0",
packages=["codewars_unittest"],
license="MIT",
description="unittest runner with Codewars output",
install_requires=[],
url="https://github.com/Codewars/python-unittest",
)
| [
"setuptools.setup"
] | [((30, 264), 'setuptools.setup', 'setup', ([], {'name': '"""codewars_unittest"""', 'version': '"""0.1.0"""', 'packages': "['codewars_unittest']", 'license': '"""MIT"""', 'description': '"""unittest runner with Codewars output"""', 'install_requires': '[]', 'url': '"""https://github.com/Codewars/python-unittest"""'}), "... |
import torch
CONFIG = {"device": torch.device("cuda" if torch.cuda.is_available() else "cpu")}
def get(): return CONFIG["device"]
def set_device(device): CONFIG["device"] = device
| [
"torch.cuda.is_available"
] | [((57, 82), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {}), '()\n', (80, 82), False, 'import torch\n')] |
import logging
import random
import os
import json
from typing import Tuple, List
import requests
def predict(player_name: str) -> str:
next_move = _predict_next_move(*_get_player_games(player_name))
return _convert_game_to_json(next_move)
R_rock, P_paper, S_scissors, V_spock, L_lizard = ('R', ... | [
"random.choice",
"os.getenv",
"json.dumps",
"requests.get",
"logging.info"
] | [((505, 540), 'os.getenv', 'os.getenv', (['"""GAME_MANAGER_URI"""', 'None'], {}), "('GAME_MANAGER_URI', None)\n", (514, 540), False, 'import os\n'), ((625, 671), 'logging.info', 'logging.info', (['f"""requesting human moves: {url}"""'], {}), "(f'requesting human moves: {url}')\n", (637, 671), False, 'import logging\n')... |
# -*- coding: utf-8 -*-
import io
import collections
from stella.core.utils import RewindableIterator
from stella.core.interpreter.productions import Token
__all__ = ['Tokenizer', 'Lexer']
################################################################################
### Tokenizer
################################... | [
"stella.core.interpreter.productions.Token",
"stella.core.utils.RewindableIterator"
] | [((853, 881), 'stella.core.utils.RewindableIterator', 'RewindableIterator', (['iterator'], {}), '(iterator)\n', (871, 881), False, 'from stella.core.utils import RewindableIterator\n'), ((957, 981), 'stella.core.utils.RewindableIterator', 'RewindableIterator', (['self'], {}), '(self)\n', (975, 981), False, 'from stella... |
import matplotlib.pyplot as plt
import numpy as np
import tensorflow as tf
tf.logging.set_verbosity(tf.logging.ERROR)
max_epochs = 6000
init_stddev = 0.0001
source_embedding_size = 2
target_embedding_size = 2
source_state_size = 2
preattention_size = 2
target_state_size = 2
max_seq_len = 10
source_tokens = [
... | [
"tensorflow.shape",
"tensorflow.nn.bidirectional_dynamic_rnn",
"tensorflow.reduce_sum",
"tensorflow.logging.set_verbosity",
"tensorflow.nn.sparse_softmax_cross_entropy_with_logits",
"tensorflow.contrib.rnn.GRUCell",
"tensorflow.nn.softmax",
"tensorflow.zeros_initializer",
"tensorflow.Graph",
"tens... | [((76, 118), 'tensorflow.logging.set_verbosity', 'tf.logging.set_verbosity', (['tf.logging.ERROR'], {}), '(tf.logging.ERROR)\n', (100, 118), True, 'import tensorflow as tf\n'), ((2201, 2211), 'tensorflow.Graph', 'tf.Graph', ([], {}), '()\n', (2209, 2211), True, 'import tensorflow as tf\n'), ((2254, 2310), 'tensorflow.p... |
import codecs
def encode_macaroon(macaroon):
encoded_macaroon = codecs.encode(macaroon, 'hex')
return encoded_macaroon
def read_file(file_path):
opened_file = open(file_path, 'rb').read()
return opened_file | [
"codecs.encode"
] | [((69, 99), 'codecs.encode', 'codecs.encode', (['macaroon', '"""hex"""'], {}), "(macaroon, 'hex')\n", (82, 99), False, 'import codecs\n')] |
import numpy as np
from ctapipe.core import Component
from ctapipe.containers import MuonRingContainer
from .fitting import kundu_chaudhuri_circle_fit, taubin_circle_fit
import traitlets as traits
# the fit methods do not expose the same interface, so we
# force the same interface onto them, here.
# we also modify th... | [
"numpy.sqrt",
"numpy.arctan2"
] | [((1539, 1569), 'numpy.arctan2', 'np.arctan2', (['center_y', 'center_x'], {}), '(center_y, center_x)\n', (1549, 1569), True, 'import numpy as np\n'), ((1599, 1637), 'numpy.sqrt', 'np.sqrt', (['(center_x ** 2 + center_y ** 2)'], {}), '(center_x ** 2 + center_y ** 2)\n', (1606, 1637), True, 'import numpy as np\n')] |
#! /usr/bin/env python
# -*-coding: utf-8 -*-
__author__ = 'dracarysX'
from django.db import models
class Publisher(models.Model):
id = models.AutoField(primary_key=True)
name = models.CharField(max_length=100)
class Meta:
db_table = 'Publisher'
def __str__(self):
return 'Publisher:... | [
"django.db.models.ForeignKey",
"django.db.models.AutoField",
"django.db.models.CharField",
"django.db.models.IntegerField"
] | [((143, 177), 'django.db.models.AutoField', 'models.AutoField', ([], {'primary_key': '(True)'}), '(primary_key=True)\n', (159, 177), False, 'from django.db import models\n'), ((189, 221), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(100)'}), '(max_length=100)\n', (205, 221), False, 'from djan... |
from django.conf import settings
from django.conf.urls import *
from django.conf.urls.static import static
from django.contrib import admin
from django.contrib.sitemaps.views import sitemap
from django.views.decorators.cache import cache_page
from django.views.generic import TemplateView
from ajax_select import urls as... | [
"django.views.generic.TemplateView.as_view",
"django.conf.urls.static.static",
"django.views.decorators.cache.cache_page",
"django.contrib.admin.autodiscover"
] | [((467, 487), 'django.contrib.admin.autodiscover', 'admin.autodiscover', ([], {}), '()\n', (485, 487), False, 'from django.contrib import admin\n'), ((1863, 1926), 'django.conf.urls.static.static', 'static', (['settings.STATIC_URL'], {'document_root': 'settings.STATIC_ROOT'}), '(settings.STATIC_URL, document_root=setti... |
'''
This script makes an image very similar to Figure 2 of Hutchison et al. 2019 (https://arxiv.org/pdf/1905.08812.pdf). Undoubtedly, there are likely simpler ways to make this figure -- this is how I chose to code it up.
Because the figure in the paper uses some proprietary data, the code below will generate fake dat... | [
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.Subplot",
"matplotlib.pyplot.close",
"matplotlib.gridspec.GridSpec",
"matplotlib.pyplot.figure",
"numpy.random.seed",
"numpy.random.uniform",
"matplotlib.gridspec.GridSpecFromSubplotSpec",
"numpy.loadtxt",
"matplotlib.patheffects.withStroke",
"matp... | [((808, 830), 'numpy.random.seed', 'np.random.seed', ([], {'seed': '(3)'}), '(seed=3)\n', (822, 830), True, 'import numpy as np\n'), ((897, 938), 'numpy.loadtxt', 'np.loadtxt', (['"""gaussian2D_sig2_kernel7.txt"""'], {}), "('gaussian2D_sig2_kernel7.txt')\n", (907, 938), True, 'import numpy as np\n'), ((973, 1014), 'num... |
import sys
import os
if __name__ == '__main__':
if len(sys.argv) < 3:
print("Usage: {} <conf-list> <conf-dir> [white-list-files]".format(sys.argv[0]))
sys.exit(-1)
conf_list_file = sys.argv[1]
conf_dir = sys.argv[2]
conf_list = {}
white_list_files = sys.argv[3:]
ele_white_list ... | [
"sys.exit"
] | [((173, 185), 'sys.exit', 'sys.exit', (['(-1)'], {}), '(-1)\n', (181, 185), False, 'import sys\n')] |
import torch
from torch.autograd import Variable
from util.util import *
from util.data_util import *
import numpy as np
from PIL import Image
from data.base_dataset import get_transform_params, get_raw_transform_fn, \
get_transform_fn, get_soft_bbox, get_masked_image
from util.data_util i... | [
"util.data_util.crop_canvas",
"numpy.random.choice",
"util.data_util.paste_canvas",
"data.base_dataset.get_raw_transform_fn",
"torch.no_grad",
"torch.zeros_like",
"torch.autograd.Variable"
] | [((2324, 2371), 'data.base_dataset.get_raw_transform_fn', 'get_raw_transform_fn', ([], {'normalize': 'normalize_image'}), '(normalize=normalize_image)\n', (2344, 2371), False, 'from data.base_dataset import get_transform_params, get_raw_transform_fn, get_transform_fn, get_soft_bbox, get_masked_image\n'), ((2397, 2434),... |
from osbot_aws.apis.IAM import IAM
class IAM_Policy:
def __init__(self, policy_name=None, policy_path=None):
self.iam = IAM()
self.policy_name = policy_name
self.version = "2012-10-17"
self.statements = []
self.policy_path = policy_path
self.account_id ... | [
"osbot_aws.apis.IAM.IAM"
] | [((142, 147), 'osbot_aws.apis.IAM.IAM', 'IAM', ([], {}), '()\n', (145, 147), False, 'from osbot_aws.apis.IAM import IAM\n')] |
# copyright (c) 2018 Larz60+
from lxml import html
import ScraperPaths
import CIA_ScanTools
import GetPage
import os
import json
import sys
from bs4 import BeautifulSoup
class CIA_History:
def __init__(self):
self.spath = ScraperPaths.ScraperPaths()
self.gp = GetPage.GetPage()
self.getpag... | [
"bs4.BeautifulSoup",
"CIA_ScanTools.CIA_Scan_Tools",
"GetPage.GetPage",
"ScraperPaths.ScraperPaths"
] | [((237, 264), 'ScraperPaths.ScraperPaths', 'ScraperPaths.ScraperPaths', ([], {}), '()\n', (262, 264), False, 'import ScraperPaths\n'), ((283, 300), 'GetPage.GetPage', 'GetPage.GetPage', ([], {}), '()\n', (298, 300), False, 'import GetPage\n'), ((409, 439), 'CIA_ScanTools.CIA_Scan_Tools', 'CIA_ScanTools.CIA_Scan_Tools',... |
from django.conf.urls import patterns
from django.conf import settings
urlpatterns = patterns(
'',
(r'^media/(?P<path>.+)$', 'django.views.static.serve',
{'document_root': settings.MEDIA_ROOT, 'show_indexes': True}),
(r'^(.*\.html)$', 'thumbnail_tests.views.direct_to_template'),
)
| [
"django.conf.urls.patterns"
] | [((87, 289), 'django.conf.urls.patterns', 'patterns', (['""""""', "('^media/(?P<path>.+)$', 'django.views.static.serve', {'document_root':\n settings.MEDIA_ROOT, 'show_indexes': True})", "('^(.*\\\\.html)$', 'thumbnail_tests.views.direct_to_template')"], {}), "('', ('^media/(?P<path>.+)$', 'django.views.static.serve... |
r"""Train an EfficientNet classifier.
Currently implementation of multi-label multi-class classification is
non-functional.
During training, start tensorboard from within the classification/ directory:
tensorboard --logdir run --bind_all --samples_per_plugin scalars=0,images=0
Example usage:
python train_cla... | [
"tensorflow.io.read_file",
"tensorflow.GradientTape",
"tensorflow.nn.softmax",
"tensorflow.image.random_saturation",
"tensorflow.summary.image",
"tensorflow.keras.layers.Input",
"os.path.exists",
"classification.train_utils.imgs_with_confidences",
"argparse.ArgumentParser",
"tensorflow.data.Datase... | [((3300, 3345), 'tensorflow.data.Dataset.from_tensor_slices', 'tf.data.Dataset.from_tensor_slices', (['img_files'], {}), '(img_files)\n', (3334, 3345), True, 'import tensorflow as tf\n'), ((4063, 4105), 'tensorflow.data.Dataset.from_tensor_slices', 'tf.data.Dataset.from_tensor_slices', (['labels'], {}), '(labels)\n', (... |
# 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, ... | [
"unittest.main",
"pyreach.impl.test_data.get_workcell_constraints_json",
"pyreach.impl.constraints_impl.ConstraintsDevice",
"pyreach.impl.test_data.get_robot_constraints_json"
] | [((4688, 4703), 'unittest.main', 'unittest.main', ([], {}), '()\n', (4701, 4703), False, 'import unittest\n'), ((925, 949), 'pyreach.impl.constraints_impl.ConstraintsDevice', 'impl.ConstraintsDevice', ([], {}), '()\n', (947, 949), True, 'from pyreach.impl import constraints_impl as impl\n'), ((2877, 2903), 'pyreach.imp... |
from sys import stdin
from collections import defaultdict, deque
MAX_COLORS = 51
def load_num():
return int(stdin.readline())
def load_pair():
return tuple(map(int, stdin.readline().split()))
def load_case():
nbeads = load_num()
return [load_pair() for b in range(nbeads)]
def build_necklace(beads... | [
"sys.stdin.readline",
"collections.deque",
"collections.defaultdict"
] | [((601, 617), 'collections.defaultdict', 'defaultdict', (['int'], {}), '(int)\n', (612, 617), False, 'from collections import defaultdict, deque\n'), ((1354, 1366), 'collections.deque', 'deque', (['[nxt]'], {}), '([nxt])\n', (1359, 1366), False, 'from collections import defaultdict, deque\n'), ((115, 131), 'sys.stdin.r... |
import spacy
from nltk.tokenize import word_tokenize
from nltk.tokenize import sent_tokenize
from nltk.corpus import stopwords
from nltk.probability import FreqDist
from string import punctuation
from tqdm import tqdm
from rank_bm25 import BM25Okapi
import time
from collections import defaultdict
from heapq import nlar... | [
"src.Entity.Files.Files.getFiles",
"src.Entity.ChatResponse.ChatResponse.updateChatResponse",
"nltk.download"
] | [((337, 359), 'nltk.download', 'nltk.download', (['"""punkt"""'], {}), "('punkt')\n", (350, 359), False, 'import nltk\n'), ((360, 386), 'nltk.download', 'nltk.download', (['"""stopwords"""'], {}), "('stopwords')\n", (373, 386), False, 'import nltk\n'), ((922, 961), 'src.Entity.Files.Files.getFiles', 'Files.getFiles', (... |
import csv
from pylab import *
import matplotlib.pyplot as plt
count1=[]
req_data=[]
def get_request (str):
f=open('weblog.txt','r')
pdata=[]
req_data1=[]
data=csv.reader(f,delimiter=' ')
for row in data:
row[3]=row[3][1:]
row[3]=... | [
"csv.reader"
] | [((205, 233), 'csv.reader', 'csv.reader', (['f'], {'delimiter': '""" """'}), "(f, delimiter=' ')\n", (215, 233), False, 'import csv\n')] |
## 2018/08/17 Initial
## 2018/08/18 Add CSV format
## 2018/08/23 Add def get_stockidxname_SeymourExcel(),def get_stockidx_SeymourExcel()
## def get_all_stockidx_SeymourExcel() from test_crawl.py
## 2018/09/06 Add value of column 'PBR' in def readExcel()
## 2018/10/27 Add exception handling in def readEx... | [
"xlrd.open_workbook",
"csv.writer",
"os.path.join"
] | [((3335, 3371), 'os.path.join', 'os.path.join', (['dirnamelog', 'excelfname'], {}), '(dirnamelog, excelfname)\n', (3347, 3371), False, 'import os\n'), ((4395, 4431), 'os.path.join', 'os.path.join', (['dirnamelog', 'excelfname'], {}), '(dirnamelog, excelfname)\n', (4407, 4431), False, 'import os\n'), ((5257, 5293), 'os.... |
#
# Test for the standard lead acid parameters
#
import pybamm
from tests import get_discretisation_for_testing
import unittest
class TestStandardParametersLeadAcid(unittest.TestCase):
def test_scipy_constants(self):
param = pybamm.LeadAcidParameters()
self.assertAlmostEqual(param.R.evaluate(), 8... | [
"pybamm.Scalar",
"pybamm.LeadAcidParameters",
"unittest.main",
"pybamm.ParameterValues",
"pybamm.lead_acid.BaseModel",
"tests.get_discretisation_for_testing"
] | [((8738, 8753), 'unittest.main', 'unittest.main', ([], {}), '()\n', (8751, 8753), False, 'import unittest\n'), ((240, 267), 'pybamm.LeadAcidParameters', 'pybamm.LeadAcidParameters', ([], {}), '()\n', (265, 267), False, 'import pybamm\n'), ((463, 490), 'pybamm.LeadAcidParameters', 'pybamm.LeadAcidParameters', ([], {}), ... |
#!/usr/bin/env python
# ======================================================================
# This software is distributed under the MIT license reproduced below:
#
# Copyright (C) 2009-2014 <NAME>' <<EMAIL>>
#
# Permission to use, copy, modify, and distribute this software and
# its documentation for any purp... | [
"distutils.core.Extension",
"sys.exit"
] | [((1420, 1468), 'sys.exit', 'sys.exit', (['"""python version not supported (< 2.5)"""'], {}), "('python version not supported (< 2.5)')\n", (1428, 1468), False, 'import sys\n'), ((3546, 3618), 'distutils.core.Extension', 'Extension', (['"""sendfile"""'], {'sources': "['sendfilemodule.c']", 'libraries': 'libraries'}), "... |
from Stroke import Stroke
from TactileBrush import TactileBrush
import json
from sortedcontainers import SortedList
EPSILON = 0.001
class Point:
def __init__(self, x : int, y : int):
self.x = int(x)
self.y = int(y)
def __repr__(self):
return "(" + str(self.x) + ", " + str(self.y) ... | [
"sortedcontainers.SortedList",
"Stroke.Stroke",
"json.dumps",
"TactileBrush.TactileBrush",
"json.load"
] | [((4493, 4551), 'TactileBrush.TactileBrush', 'TactileBrush', (['Config.lines', 'Config.columns', 'Config.spacing'], {}), '(Config.lines, Config.columns, Config.spacing)\n', (4505, 4551), False, 'from TactileBrush import TactileBrush\n'), ((4560, 4611), 'Stroke.Stroke', 'Stroke', (['start_x', 'start_y', 'end_x', 'end_y'... |
import sys
import json
from h5model import h5model
if len(sys.argv) < 2:
print('Usage: ' + sys.argv[0] + ' ' + '<model name>')
exit(1)
modelName = sys.argv[1]
model = h5model(modelName)
model.createModel()
if model.responseStatus >= 400:
print("Unable to create model '" + modelName + "': " + model.errorMessage... | [
"h5model.h5model"
] | [((174, 192), 'h5model.h5model', 'h5model', (['modelName'], {}), '(modelName)\n', (181, 192), False, 'from h5model import h5model\n')] |
# -*- coding: utf-8 -*-
import os, sys
from PyQt5.QtWidgets import (QWizard, QMessageBox)
from PyQt5.QtGui import QPixmap
from PyQt5.QtCore import pyqtSlot, Qt
try:
import odmltables
have_odmltables = True
except:
have_odmltables = False
from .settings import Settings
class OdmltablesWizard(QWizard):
... | [
"os.path.exists",
"PyQt5.QtWidgets.QMessageBox",
"os.path.join",
"PyQt5.QtCore.pyqtSlot",
"os.path.dirname",
"PyQt5.QtGui.QPixmap",
"os.path.expanduser"
] | [((1709, 1719), 'PyQt5.QtCore.pyqtSlot', 'pyqtSlot', ([], {}), '()\n', (1717, 1719), False, 'from PyQt5.QtCore import pyqtSlot, Qt\n'), ((2233, 2246), 'PyQt5.QtWidgets.QMessageBox', 'QMessageBox', ([], {}), '()\n', (2244, 2246), False, 'from PyQt5.QtWidgets import QWizard, QMessageBox\n'), ((494, 517), 'os.path.expandu... |