code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
import random
import aiohttp
import discord
from PIL import ImageFilter, Image, UnidentifiedImageError, ImageFont, ImageDraw, ImageOps
from discord.ext import commands
from io import BytesIO
class Utility(commands.Cog):
def __init__(self, bot):
self.bot = bot
# self.session = aiohttp.ClientSessio... | [
"aiohttp.ClientSession",
"PIL.Image.open",
"random.choice",
"PIL.ImageOps.fit",
"io.BytesIO",
"PIL.ImageFont.truetype",
"PIL.ImageDraw.Draw",
"discord.ext.commands.cooldown",
"discord.ext.commands.command",
"discord.File"
] | [((1677, 1713), 'discord.ext.commands.command', 'commands.command', ([], {'aliases': "['colpal']"}), "(aliases=['colpal'])\n", (1693, 1713), False, 'from discord.ext import commands\n'), ((1719, 1768), 'discord.ext.commands.cooldown', 'commands.cooldown', (['(3)', '(5)', 'commands.BucketType.user'], {}), '(3, 5, comman... |
from fastapi import Depends, FastAPI
#from .image.image.uncolorization import users
app = FastAPI()
import importlib
import pkgutil
def import_submodules(package, recursive=True):
""" Import all submodules of a module, recursively, including subpackages
:param package: package (name or actual module)
... | [
"fastapi.FastAPI",
"importlib.import_module",
"pkgutil.walk_packages"
] | [((94, 103), 'fastapi.FastAPI', 'FastAPI', ([], {}), '()\n', (101, 103), False, 'from fastapi import Depends, FastAPI\n'), ((533, 572), 'pkgutil.walk_packages', 'pkgutil.walk_packages', (['package.__path__'], {}), '(package.__path__)\n', (554, 572), False, 'import pkgutil\n'), ((451, 483), 'importlib.import_module', 'i... |
from spinup.utils.run_utils import ExperimentGrid
from spinup import ddpg_pytorch
import torch
if __name__ == '__main__':
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('--cpu', type=int, default=-1)
parser.add_argument('--num_runs', type=int, default=3)
parser.add_argument(... | [
"spinup.utils.run_utils.ExperimentGrid",
"argparse.ArgumentParser"
] | [((156, 181), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (179, 181), False, 'import argparse\n'), ((406, 433), 'spinup.utils.run_utils.ExperimentGrid', 'ExperimentGrid', ([], {'name': '"""DDPG"""'}), "(name='DDPG')\n", (420, 433), False, 'from spinup.utils.run_utils import ExperimentGrid\n'... |
"""
defines methods to access MPC/rigid element data:
- get_mpc_node_ids( mpc_id, stop_on_failure=True)
- get_mpc_node_ids_c1( mpc_id, stop_on_failure=True)
- get_rigid_elements_with_node_ids(self, node_ids)
- get_dependent_nid_to_components(self, mpc_id=None, stop_on_failure=True)
- get_lines_rigid(model: BD... | [
"collections.defaultdict",
"numpy.unique"
] | [((3592, 3609), 'collections.defaultdict', 'defaultdict', (['list'], {}), '(list)\n', (3603, 3609), False, 'from collections import defaultdict\n'), ((3638, 3655), 'collections.defaultdict', 'defaultdict', (['list'], {}), '(list)\n', (3649, 3655), False, 'from collections import defaultdict\n'), ((13745, 13775), 'numpy... |
from setuptools import setup
"""
pip install twine
pip install build
CREATING RELEASES-------------------------------------------------------------------------------------------------------
- Update README.md version number
- Update setup.cfg version number
- Update goopylib/__init__.py __version__ variab... | [
"setuptools.setup"
] | [((1793, 1982), 'setuptools.setup', 'setup', ([], {'package_dir': "{':maths': 'goopylib/maths', ':objects': 'goopylib/objects',\n ':applications': 'goopylib/applications', ':sound': 'goopylib/sound',\n ':physics': 'goopylib/physics'}"}), "(package_dir={':maths': 'goopylib/maths', ':objects':\n 'goopylib/object... |
import unittest
import json
from rpc_proxy.request import parse_request, translate_to_app_base
class ProxyTestCase(unittest.TestCase):
@classmethod
def setUpClass(cls):
cls.maxDiff = 1000
def test_parse_request_01(self):
# should read api and method from "method"
js = '{"jsonrpc"... | [
"rpc_proxy.request.parse_request",
"json.loads",
"rpc_proxy.request.translate_to_app_base"
] | [((449, 463), 'json.loads', 'json.loads', (['js'], {}), '(js)\n', (459, 463), False, 'import json\n'), ((894, 908), 'json.loads', 'json.loads', (['js'], {}), '(js)\n', (904, 908), False, 'import json\n'), ((1291, 1305), 'json.loads', 'json.loads', (['js'], {}), '(js)\n', (1301, 1305), False, 'import json\n'), ((1692, 1... |
##########################################################################
#
# Copyright (c) 2017, Image Engine Design Inc. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# * Redistrib... | [
"GafferUI.Timeline",
"GafferUI.SplitContainer",
"GafferUI.PathPreviewWidget.registerType",
"GafferImage.ImageReader",
"Gaffer.ScriptNode",
"GafferImage.ImageReader.supportedExtensions",
"GafferUI.Viewer",
"GafferUI.PathPreviewWidget.__init__"
] | [((3806, 3878), 'GafferUI.PathPreviewWidget.registerType', 'GafferUI.PathPreviewWidget.registerType', (['"""Image"""', 'ImageReaderPathPreview'], {}), "('Image', ImageReaderPathPreview)\n", (3845, 3878), False, 'import GafferUI\n'), ((1968, 2037), 'GafferUI.SplitContainer', 'GafferUI.SplitContainer', (['GafferUI.SplitC... |
# various Amiga Math utils
import struct
import math
def int32(x):
st = struct.pack("I", x)
return struct.unpack("i", st)[0]
def int16(x):
st = struct.pack("H", x)
return struct.unpack("h", st)[0]
def int8(x):
st = struct.pack("B", x)
return struct.unpack("b", st)[0]
def signext16(x):
... | [
"math.isinf",
"struct.unpack",
"struct.pack",
"math.isnan"
] | [((79, 98), 'struct.pack', 'struct.pack', (['"""I"""', 'x'], {}), "('I', x)\n", (90, 98), False, 'import struct\n'), ((161, 180), 'struct.pack', 'struct.pack', (['"""H"""', 'x'], {}), "('H', x)\n", (172, 180), False, 'import struct\n'), ((242, 261), 'struct.pack', 'struct.pack', (['"""B"""', 'x'], {}), "('B', x)\n", (2... |
#!/usr/bin/python3
# -*- coding: utf-8 -*-
#
# @Author: xiaochenghua
# @Date: 2019/08/02
import os
from configparser import ConfigParser
class Config(object):
def __init__(self):
parser = ConfigParser()
parser.read(os.path.join(os.path.split(os.path.realpath(__file__))[0], 'config.ini'))
... | [
"os.path.realpath",
"configparser.ConfigParser"
] | [((205, 219), 'configparser.ConfigParser', 'ConfigParser', ([], {}), '()\n', (217, 219), False, 'from configparser import ConfigParser\n'), ((267, 293), 'os.path.realpath', 'os.path.realpath', (['__file__'], {}), '(__file__)\n', (283, 293), False, 'import os\n')] |
# -*- coding: utf-8 -*-
from django.conf import settings
from django.shortcuts import render
from django.urls import reverse
from django.http import HttpResponseRedirect
from djforms.athletics.soccer import BCC
from djforms.athletics.soccer import INSURANCE_TO_LIST
from djforms.athletics.soccer import TO_LIST
... | [
"django.shortcuts.render",
"djforms.processors.forms.TrustCommerceForm",
"djforms.athletics.soccer.forms.SoccerCampBalanceOrderForm",
"djforms.athletics.soccer.forms.SoccerCampRegistrationForm",
"djforms.athletics.soccer.forms.SoccerCampBalanceForm",
"djtools.utils.mail.send_mail",
"django.urls.reverse"... | [((5156, 5284), 'django.shortcuts.render', 'render', (['request', '"""athletics/soccer/camp_registration.html"""', "{'form_reg': form_reg, 'form_proc': form_proc, 'status': status}"], {}), "(request, 'athletics/soccer/camp_registration.html', {'form_reg':\n form_reg, 'form_proc': form_proc, 'status': status})\n", (5... |
import os
import pygame
from levelformat import Recorder as r
from collections import deque
from recording import Recording
import copy
class Recorder(pygame.sprite.Sprite):
images = {}
def __init__(self, recorderformat):
pygame.sprite.Sprite.__init__(self)
path = os.path.join('assets', 'images'... | [
"recording.Recording",
"pygame.sprite.Sprite.__init__",
"collections.deque",
"os.path.join"
] | [((238, 273), 'pygame.sprite.Sprite.__init__', 'pygame.sprite.Sprite.__init__', (['self'], {}), '(self)\n', (267, 273), False, 'import pygame\n'), ((289, 321), 'os.path.join', 'os.path.join', (['"""assets"""', '"""images"""'], {}), "('assets', 'images')\n", (301, 321), False, 'import os\n'), ((1024, 1031), 'collections... |
import os
NAME = os.environ.get("NAME", default="theshashankk")
IMAGE = os.environ.get("IMAGE", default="https://telegra.ph/file/10ff6d59629bed12a47ef.jpg")
SHORT_BIO = os.environ.get("SHORT_BIO", default="2022 Countdown")
ABOUT = os.environ.get("ABOUT", default="it's just a countdown, ntg else ;)")
GITHUB = os.enviro... | [
"os.environ.get"
] | [((18, 64), 'os.environ.get', 'os.environ.get', (['"""NAME"""'], {'default': '"""theshashankk"""'}), "('NAME', default='theshashankk')\n", (32, 64), False, 'import os\n'), ((73, 162), 'os.environ.get', 'os.environ.get', (['"""IMAGE"""'], {'default': '"""https://telegra.ph/file/10ff6d59629bed12a47ef.jpg"""'}), "('IMAGE'... |
#!/usr/bin/env python3
"""
Tutorial example of training a statistical model to tension test data
from from a known distribution.
"""
import sys
import os.path
sys.path.append("../../../..")
sys.path.append("..")
import numpy.random as ra
import xarray as xr
import torch
from maker import make_model, downs... | [
"matplotlib.pyplot.ylabel",
"torch.cuda.is_available",
"sys.path.append",
"pyoptmat.optimize.HierarchicalStatisticalModel",
"matplotlib.pyplot.loglog",
"numpy.random.random",
"pyro.param",
"matplotlib.pyplot.xlabel",
"torch.set_default_tensor_type",
"pyro.infer.SVI",
"pyro.optim.ClippedAdam",
... | [((170, 200), 'sys.path.append', 'sys.path.append', (['"""../../../.."""'], {}), "('../../../..')\n", (185, 200), False, 'import sys\n'), ((201, 222), 'sys.path.append', 'sys.path.append', (['""".."""'], {}), "('..')\n", (216, 222), False, 'import sys\n'), ((510, 543), 'warnings.filterwarnings', 'warnings.filterwarning... |
#!coding:utf-8
from sys import path as sys_path
from os import path as os_path
import subprocess
import pytest
sys_path.append(os_path.abspath(os_path.join(os_path.dirname(__file__), "../")))
import autoargparse
@pytest.mark.example
@pytest.mark.parametrize(
"input,expected",
[
("python ./example/c... | [
"os.path.dirname",
"pytest.mark.parametrize"
] | [((239, 862), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""input,expected"""', "[('python ./example/calculator.py 1', ['!!!']), (\n 'python ./example/calculator.py 2', ['Great !!!']), (\n 'python ./example/calculator.py 1 -m 2 3', ['!!!', '6']), (\n 'python ./example/calculator.py 1 -m 2 3 -v', ... |
"""Utilities for working with XML documents, particularly those
that are returned in a majority of MWS responses.
"""
import re
from mws.future_utils.collections import DotDict
# from mws.utils import DotDict
MWS_ENCODING = "iso-8859-1"
"""Amazon documents this as the encoding to expect in responses.
If it doesn't w... | [
"re.sub"
] | [((747, 781), 're.sub', 're.sub', (['pattern', 'replacement', 'data'], {}), '(pattern, replacement, data)\n', (753, 781), False, 'import re\n')] |
# @Author : bamtercelboo
# @Datetime : 2018/10/15 9:52
# @File : CNN.py
# @Last Modify Time : 2018/10/15 9:52
# @Contact : <EMAIL>, <EMAIL>}
"""
FILE : CNN.py
FUNCTION : None
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.nn.utils.rnn import pack_padded_sequence, pad_packed... | [
"torch.manual_seed",
"torch.nn.Dropout",
"random.seed",
"torch.nn.Conv2d",
"torch.cat",
"torch.nn.Linear",
"torch.nn.Embedding"
] | [((512, 539), 'torch.manual_seed', 'torch.manual_seed', (['seed_num'], {}), '(seed_num)\n', (529, 539), False, 'import torch\n'), ((540, 561), 'random.seed', 'random.seed', (['seed_num'], {}), '(seed_num)\n', (551, 561), False, 'import random\n'), ((1002, 1043), 'torch.nn.Embedding', 'nn.Embedding', (['V', 'D'], {'padd... |
#extract_baseline_features.py
from __future__ import unicode_literals
import time, sys, ast
from isc_tokenizer import Tokenizer
from isc_tagger import Tagger
from nltk import ngrams, pos_tag
import numpy as np
from collections import Counter#collections in python 3
import vocab_helpers as helper
import pre_processing ... | [
"pre_processing.get_subj_lexicon",
"collections.Counter",
"isc_tokenizer.Tokenizer",
"nltk.ngrams",
"isc_tagger.Tagger"
] | [((968, 989), 'isc_tokenizer.Tokenizer', 'Tokenizer', ([], {'lang': '"""hin"""'}), "(lang='hin')\n", (977, 989), False, 'from isc_tokenizer import Tokenizer\n'), ((1002, 1020), 'isc_tagger.Tagger', 'Tagger', ([], {'lang': '"""hin"""'}), "(lang='hin')\n", (1008, 1020), False, 'from isc_tagger import Tagger\n'), ((2607, ... |
import sys
from lib.options import Options
from lib.clippings import Clippings
def run_project(args):
options = Options()
options.parse(args)
if options.known.do_clippings:
clip = Clippings(options.known.directory)
clip.parse()
#print(repr(clip.entries))
if __name__ == '__main__':... | [
"lib.clippings.Clippings",
"lib.options.Options"
] | [((117, 126), 'lib.options.Options', 'Options', ([], {}), '()\n', (124, 126), False, 'from lib.options import Options\n'), ((202, 236), 'lib.clippings.Clippings', 'Clippings', (['options.known.directory'], {}), '(options.known.directory)\n', (211, 236), False, 'from lib.clippings import Clippings\n')] |
from typing import List
import asyncpg
from fastapi import APIRouter, HTTPException, Response
import utils
from api.dependencies import has_permissions
from api.models import ChallengeLanguage
from api.models.permissions import ManageWeeklyChallengeLanguages
from .helpers import check_piston_language_version
from .m... | [
"api.models.ChallengeLanguage.pool.fetchrow",
"api.models.ChallengeLanguage",
"fastapi.Response",
"fastapi.HTTPException",
"api.models.permissions.ManageWeeklyChallengeLanguages",
"fastapi.APIRouter",
"api.models.ChallengeLanguage.pool.execute",
"api.models.ChallengeLanguage.pool.fetch"
] | [((441, 471), 'fastapi.APIRouter', 'APIRouter', ([], {'prefix': '"""/languages"""'}), "(prefix='/languages')\n", (450, 471), False, 'from fastapi import APIRouter, HTTPException, Response\n'), ((3667, 3694), 'api.models.ChallengeLanguage', 'ChallengeLanguage', ([], {}), '(**record)\n', (3684, 3694), False, 'from api.mo... |
#!/usr/bin/env python3
# date: 2020.03.05
#
import requests
from bs4 import BeautifulSoup
url = "http://www.S/ederson/profil/spieler/238223"
response = requests.get(url, headers={'user-agent':"Mozilla/5.0"})
soup = BeautifulSoup(response.text, 'html.parser')
table = soup.find('table', {'class': 'auflistung'})
d... | [
"bs4.BeautifulSoup",
"requests.get"
] | [((157, 213), 'requests.get', 'requests.get', (['url'], {'headers': "{'user-agent': 'Mozilla/5.0'}"}), "(url, headers={'user-agent': 'Mozilla/5.0'})\n", (169, 213), False, 'import requests\n'), ((221, 264), 'bs4.BeautifulSoup', 'BeautifulSoup', (['response.text', '"""html.parser"""'], {}), "(response.text, 'html.parser... |
from mockito import mock, verify
import unittest
from helloworld import helloworld
class HelloWorldTest(unittest.TestCase):
def test_should_issue_hello_world_message(self):
out = mock()
helloworld(out)
verify(out).write("Hello world of Python\n")
| [
"helloworld.helloworld",
"mockito.mock",
"mockito.verify"
] | [((193, 199), 'mockito.mock', 'mock', ([], {}), '()\n', (197, 199), False, 'from mockito import mock, verify\n'), ((209, 224), 'helloworld.helloworld', 'helloworld', (['out'], {}), '(out)\n', (219, 224), False, 'from helloworld import helloworld\n'), ((234, 245), 'mockito.verify', 'verify', (['out'], {}), '(out)\n', (2... |
""" Example of normally distributed variable specified using sympy.stats """
import sympy
import sympy.stats
import probayes as pb
from pylab import *; ion()
x = pb.RV('x', vtype=float, vset=[-2, 2])
x.set_prob(sympy.stats.Normal(x[:], mean=0, std=1), pscale='log')
fx = x({1000}).rescaled()
rx = x({-1000})
figure()
s... | [
"probayes.RV",
"sympy.stats.Normal"
] | [((163, 200), 'probayes.RV', 'pb.RV', (['"""x"""'], {'vtype': 'float', 'vset': '[-2, 2]'}), "('x', vtype=float, vset=[-2, 2])\n", (168, 200), True, 'import probayes as pb\n'), ((212, 251), 'sympy.stats.Normal', 'sympy.stats.Normal', (['x[:]'], {'mean': '(0)', 'std': '(1)'}), '(x[:], mean=0, std=1)\n', (230, 251), False... |
import os
import click
from . import settings, aws, logging_at
@click.group()
@click.option('-c', '--cfg', type=click.File())
@click.option('-l', '--log-level', type=click.Choice(['d', 'i', 'w']), default=os.environ.get('CONFU_LOG') or 'w')
@click.option('-p', '--profile', default=os.environ.get('CONFU_PROFILE') or... | [
"click.group",
"click.Choice",
"click.File",
"os.environ.get"
] | [((68, 81), 'click.group', 'click.group', ([], {}), '()\n', (79, 81), False, 'import click\n'), ((116, 128), 'click.File', 'click.File', ([], {}), '()\n', (126, 128), False, 'import click\n'), ((170, 199), 'click.Choice', 'click.Choice', (["['d', 'i', 'w']"], {}), "(['d', 'i', 'w'])\n", (182, 199), False, 'import click... |
import time, random
from core.Profiler import *
from colorama import Fore
from core import settings
from datetime import date
from txt.text import text
from txt.header import lb_header
from tkinter import *
def checkVersion():
version = sys.version[:1]
if int(version) == 3:
pass
else:
sys.exit(warning+" Please ... | [
"datetime.date.today",
"time.strftime",
"random.choice"
] | [((463, 488), 'time.strftime', 'time.strftime', (['"""%H:%M:%S"""'], {}), "('%H:%M:%S')\n", (476, 488), False, 'import time, random\n'), ((2642, 2661), 'random.choice', 'random.choice', (['text'], {}), '(text)\n', (2655, 2661), False, 'import time, random\n'), ((2164, 2176), 'datetime.date.today', 'date.today', ([], {}... |
from spylunking.log.setup_logging import test_logger
from antinex_utils.consts import SUCCESS
from antinex_utils.consts import ERR
from antinex_utils.consts import FAILED
from tests.mock_model import MockModel
log = test_logger(name='mock-predictions')
def build_response_data(
req):
"""build_response_da... | [
"tests.mock_model.MockModel",
"spylunking.log.setup_logging.test_logger"
] | [((218, 254), 'spylunking.log.setup_logging.test_logger', 'test_logger', ([], {'name': '"""mock-predictions"""'}), "(name='mock-predictions')\n", (229, 254), False, 'from spylunking.log.setup_logging import test_logger\n'), ((373, 391), 'tests.mock_model.MockModel', 'MockModel', ([], {'req': 'req'}), '(req=req)\n', (38... |
import numpy as np
import matplotlib.pyplot as pl
import h5py
import time
from readout_fn import *
def xyplot(ix,iy):
pl.close(2)
fig, ax = pl.subplots(figsize=(10,6), nrows=2, ncols=2,num = 'OBSERVED & SYNTHETIC PROFILES')
ax = ax.flatten()
ix = int(np.ceil(ix))
iy = int(np.ceil(iy))
for i in range(0,4):
ax[i... | [
"numpy.ceil",
"numpy.reshape",
"h5py.File",
"matplotlib.pyplot.close",
"matplotlib.pyplot.tight_layout",
"numpy.loadtxt",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.show"
] | [((120, 131), 'matplotlib.pyplot.close', 'pl.close', (['(2)'], {}), '(2)\n', (128, 131), True, 'import matplotlib.pyplot as pl\n'), ((143, 231), 'matplotlib.pyplot.subplots', 'pl.subplots', ([], {'figsize': '(10, 6)', 'nrows': '(2)', 'ncols': '(2)', 'num': '"""OBSERVED & SYNTHETIC PROFILES"""'}), "(figsize=(10, 6), nro... |
import numpy as np
import pytest
from shapecheck import (ShapeError, check_shapes, is_checking_enabled, is_compatible,
set_checking_enabled, str_to_shape)
from .utils import CaptureStdOut
def test_basic():
@check_shapes('3', '4', out_='2')
def f(x, y):
return x[:2]**2 + y[:2]... | [
"numpy.mean",
"numpy.ones",
"shapecheck.is_compatible",
"shapecheck.check_shapes",
"pytest.mark.parametrize",
"shapecheck.is_checking_enabled",
"numpy.array",
"shapecheck.str_to_shape",
"pytest.raises",
"shapecheck.set_checking_enabled"
] | [((3149, 3389), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""string, shape"""', "[('N,1,3,M', ('N', 1, 3, 'M')), ('N, 1, 3, M', ('N', 1, 3, 'M')), (\n '...,a,1', ('...', 'a', 1)), ('1, ... ,2', (1, '...', 2)), ('a,b,c,...',\n ('a', 'b', 'c', '...')), ('...', ('...',))]"], {}), "('string, shape', [(... |
from setuptools import setup, find_packages
setup(
name="SinFactory",
version="0.0.1",
author="<NAME>",
description="Program for using powerfactory for power system analysis",
packages=find_packages(exclude=["tests"]),
classifiers=[
"Programming Language :: Python :: 3",
"Licens... | [
"setuptools.find_packages"
] | [((206, 238), 'setuptools.find_packages', 'find_packages', ([], {'exclude': "['tests']"}), "(exclude=['tests'])\n", (219, 238), False, 'from setuptools import setup, find_packages\n')] |
#!/usr/bin/env python
import rospy
from std_msgs.msg import Float32
import math
RATE = 10 # Publishing rate of new data per second
FREQ = 1 # Frequency of the sinusoidal signal
# Execute this when run as a script
if __name__ == '__main__':
rospy.init_node('publisher')
pub = rospy.Publisher('data', Fl... | [
"rospy.is_shutdown",
"rospy.init_node",
"math.sin",
"rospy.Rate",
"rospy.Publisher"
] | [((253, 281), 'rospy.init_node', 'rospy.init_node', (['"""publisher"""'], {}), "('publisher')\n", (268, 281), False, 'import rospy\n'), ((294, 340), 'rospy.Publisher', 'rospy.Publisher', (['"""data"""', 'Float32'], {'queue_size': '(1)'}), "('data', Float32, queue_size=1)\n", (309, 340), False, 'import rospy\n'), ((352,... |
from shutil import copy
import json, os
"""
Architecture (list type)
image [identifier], [imsize]
regions [ansize], [boxcorners] or [vertices], [class], [type]
- linegroup [tags], [vertices]
version
json = list type
regions = list type
linegroup = list type... but may be length = 1
box = dict[0]['region... | [
"os.path.isdir",
"shutil.copy",
"os.mkdir",
"os.walk"
] | [((2665, 2716), 'os.walk', 'os.walk', (['"""C:/Users/user/Desktop/화정/vehicle-1.0/Car"""'], {}), "('C:/Users/user/Desktop/화정/vehicle-1.0/Car')\n", (2672, 2716), False, 'import json, os\n'), ((983, 1023), 'os.path.isdir', 'os.path.isdir', (['(folder_path + folder_name)'], {}), '(folder_path + folder_name)\n', (996, 1023)... |
'''
Model.py
Bachelorthesis "Eine App zur Objekterkennung in Bildern mittels neuronaler Netze,
trainiert mit dem ILSVRC-Datensatz"
Hochschule Niederrhein
Copyright (c) 2017 <NAME>
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "So... | [
"keras.layers.Conv2D",
"keras.layers.Flatten",
"keras.layers.MaxPooling2D",
"keras.models.Sequential",
"keras.layers.Dense",
"keras.layers.Activation",
"keras.layers.advanced_activations.LeakyReLU",
"keras.layers.BatchNormalization",
"keras.layers.Dropout"
] | [((1954, 1966), 'keras.models.Sequential', 'Sequential', ([], {}), '()\n', (1964, 1966), False, 'from keras.models import Sequential\n'), ((2869, 2928), 'keras.layers.Conv2D', 'Conv2D', (['(64)', '(3, 3)'], {'padding': '"""same"""', 'input_shape': 'input_shape'}), "(64, (3, 3), padding='same', input_shape=input_shape)\... |
""" Copyright © 2017-2020 ABBYY Production 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 writ... | [
"neoml.PythonWrapper.tensor",
"numpy.asarray"
] | [((2482, 2501), 'numpy.asarray', 'numpy.asarray', (['data'], {}), '(data)\n', (2495, 2501), False, 'import numpy\n'), ((4811, 4830), 'numpy.asarray', 'numpy.asarray', (['data'], {}), '(data)\n', (4824, 4830), False, 'import numpy\n'), ((2766, 2818), 'neoml.PythonWrapper.tensor', 'PythonWrapper.tensor', (['math_engine._... |
import tensorflow as tf
import numpy as np
from tensorflow.contrib.tensorboard.plugins import projector
class cnn_model():
"""
Using bidirectional LSTM to learn sentence embedding
for users' questions
"""
def __init__(self, FLAGS, initializer=
tf.contrib.layers.xavier_initiali... | [
"tensorflow.get_variable",
"tensorflow.reduce_mean",
"tensorflow.nn.embedding_lookup",
"tensorflow.pow",
"tensorflow.placeholder",
"tensorflow.concat",
"tensorflow.greater",
"tensorflow.less",
"tensorflow.train.AdamOptimizer",
"tensorflow.nn.conv2d",
"tensorflow.nn.xw_plus_b",
"tensorflow.nn.l... | [((287, 325), 'tensorflow.contrib.layers.xavier_initializer', 'tf.contrib.layers.xavier_initializer', ([], {}), '()\n', (323, 325), True, 'import tensorflow as tf\n'), ((1365, 1405), 'tensorflow.placeholder', 'tf.placeholder', (['tf.int32', '[None, self.n]'], {}), '(tf.int32, [None, self.n])\n', (1379, 1405), True, 'im... |
import json
import socket
from smb import smb_structs
from nmb.NetBIOS import NetBIOS
from smb.SMBConnection import SMBConnection
from core.alert import *
from core._time import now
from core.targets import target_type
from core.log import __log_into_file
smb_structs.SUPPORT_SMB2 = True
def extra_requirements_dict(... | [
"core._time.now",
"nmb.NetBIOS.NetBIOS",
"core.targets.target_type",
"core.log.__log_into_file",
"smb.SMBConnection.SMBConnection"
] | [((2497, 2546), 'core.log.__log_into_file', '__log_into_file', (['log_in_file', '"""a"""', 'data', 'language'], {}), "(log_in_file, 'a', data, language)\n", (2512, 2546), False, 'from core.log import __log_into_file\n'), ((385, 394), 'nmb.NetBIOS.NetBIOS', 'NetBIOS', ([], {}), '()\n', (392, 394), False, 'from nmb.NetBI... |
from __future__ import absolute_import
from __future__ import unicode_literals
from corehq.pillows.cacheinvalidate import CacheInvalidateProcessor
from memoized import memoized
@memoized
def _get_cache_processor():
return CacheInvalidateProcessor()
def invalidate_document(document, deleted=False):
"""
I... | [
"corehq.pillows.cacheinvalidate.CacheInvalidateProcessor"
] | [((228, 254), 'corehq.pillows.cacheinvalidate.CacheInvalidateProcessor', 'CacheInvalidateProcessor', ([], {}), '()\n', (252, 254), False, 'from corehq.pillows.cacheinvalidate import CacheInvalidateProcessor\n')] |
from flask_wtf import Form
from wtforms import StringField,PasswordField,validators
class RegistrationForm(Form):
username=StringField("用戶名：",[validators.DataRequired("請輸入用戶名")])
password=PasswordField("密碼：",[validators.DataRequired("請輸入密碼")])
password2=StringField("再次輸入密碼：",[validators.EqualTo("password",... | [
"wtforms.validators.DataRequired",
"wtforms.validators.Email",
"wtforms.validators.EqualTo"
] | [((156, 189), 'wtforms.validators.DataRequired', 'validators.DataRequired', (['"""請輸入用戶名"""'], {}), "('請輸入用戶名')\n", (179, 189), False, 'from wtforms import StringField, PasswordField, validators\n'), ((224, 256), 'wtforms.validators.DataRequired', 'validators.DataRequired', (['"""請輸入密碼"""'], {}), "('請輸入密碼')\n", (247, 2... |
from typing import Union
import matplotlib.pyplot as plt
import pandas as pd
from scipy.stats import ttest_1samp
from pandas import DataFrame, Series
from sklearn.linear_model import LinearRegression
from module.latex_generator import RESULTS_DIR_NAME, generate_image_figure, generate_table
def calculate_statistics(... | [
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.plot",
"module.latex_generator.generate_image_figure",
"matplotlib.pyplot.close",
"matplotlib.pyplot.scatter",
"scipy.stats.ttest_1samp",
"pandas.DataFrame",
"sklearn.linear_model.LinearRegression",
"matplotlib.pyplot.show"
] | [((1109, 1276), 'pandas.DataFrame', 'pd.DataFrame', (["{'Hipoteza zerowa': ['średni wiek = 54', 'średnie ciśnienie = 131',\n 'średnie maks. tętno = 148'], 'p-value': p_values, 'Czy odrzucona':\n rejected}"], {}), "({'Hipoteza zerowa': ['średni wiek = 54',\n 'średnie ciśnienie = 131', 'średnie maks. tętno = 148... |
from flask.views import MethodView
import flask
from .extensions import plugin_manager
from . import classes, models
import flask_login
from webapp.extensions import db
class IndexView(MethodView):
def get_context(self, **kwargs):
context = dict(plugins=list())
preferences = plugin_manager.get_use... | [
"webapp.extensions.db.session.query",
"flask.url_for",
"webapp.extensions.db.session.commit",
"webapp.extensions.db.session.add"
] | [((1165, 1184), 'webapp.extensions.db.session.add', 'db.session.add', (['obj'], {}), '(obj)\n', (1179, 1184), False, 'from webapp.extensions import db\n'), ((1197, 1216), 'webapp.extensions.db.session.commit', 'db.session.commit', ([], {}), '()\n', (1214, 1216), False, 'from webapp.extensions import db\n'), ((1572, 159... |
import argparse
def dataset(
some_positional_arg,
folder : str = 'default',
):
"""Creates a dataset.
Parameters
----------
some_positional_arg
Some positional argument that gets passed in via the script.
folder : str, optional
Folder for the dataset, by default 'default'
... | [
"argparse.ArgumentParser"
] | [((386, 411), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (409, 411), False, 'import argparse\n')] |
# =============================================================================
# Fog Fagin Clustering
# =============================================================================
#
# Miscellaneous functions related to Fagin's algorithms in order to perform
# top k queries and such.
#
# [Articles]:
# Optimal aggrega... | [
"collections.Counter",
"collections.defaultdict",
"random.shuffle",
"fog.metrics.cosine.sparse_cosine_similarity"
] | [((1012, 1029), 'collections.defaultdict', 'defaultdict', (['list'], {}), '(list)\n', (1023, 1029), False, 'from collections import defaultdict, Counter\n'), ((1832, 1849), 'collections.defaultdict', 'defaultdict', (['list'], {}), '(list)\n', (1843, 1849), False, 'from collections import defaultdict, Counter\n'), ((340... |
import logging
import pathlib
import dask.array as da
import h5py
from area_detector_handlers import HandlerBase
logger = logging.getLogger(__name__)
class EigerHandlerMX(HandlerBase):
spec = "AD_EIGER_MX"
def __init__(self, fpath, seq_id):
self._seq_id = seq_id
# From https://github.com/bl... | [
"logging.getLogger",
"dask.array.from_array",
"dask.array.stack",
"pathlib.Path",
"h5py.File"
] | [((124, 151), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (141, 151), False, 'import logging\n'), ((903, 930), 'h5py.File', 'h5py.File', (['self._fpath', '"""r"""'], {}), "(self._fpath, 'r')\n", (912, 930), False, 'import h5py\n'), ((1247, 1261), 'dask.array.stack', 'da.stack', (['temp... |
# -*- coding: utf-8 -*-
# Copyright 2015 www.suishouguan.com
#
# Licensed under the Private License (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# https://github.com/samuelbaizg/ssguan/blob/master/LICENSE
#
# Unless ... | [
"ssguan.ignitor.orm.properti.DateTimeProperty",
"ssguan.ignitor.orm.properti.DictProperty",
"ssguan.ignitor.orm.properti.BooleanProperty",
"ssguan.ignitor.orm.validator.RangeValidator",
"ssguan.ignitor.orm.validator.LengthValidator",
"ssguan.ignitor.orm.properti.DateTimeProperty.utcnow",
"ssguan.ignitor... | [((21634, 21657), 'ssguan.ignitor.orm.properti.DictProperty', 'properti.DictProperty', ([], {}), '()\n', (21655, 21657), False, 'from ssguan.ignitor.orm import dbpool, properti, config as dbconfig\n'), ((1443, 1474), 'ssguan.ignitor.orm.config.get_default_dbinfo', 'orm_config.get_default_dbinfo', ([], {}), '()\n', (147... |
import logging
import os
import json
from pprint import pformat
from me4storage.common.exceptions import ApiError
from me4storage.models.system import System
from me4storage.models.license import License
from me4storage.models.service_tag_info import ServiceTagInfo
from me4storage.models.ntp_status import NTPStatus
fr... | [
"logging.getLogger",
"me4storage.models.volume_view.VolumeView",
"me4storage.models.network_parameters.NetworkParameters",
"me4storage.models.disk_group.DiskGroup",
"me4storage.models.volume.Volume",
"me4storage.models.version.Version",
"me4storage.models.mgmt_hostnames.MGMTHostnames",
"me4storage.mod... | [((1293, 1320), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1310, 1320), False, 'import logging\n'), ((1650, 1661), 'me4storage.models.user.User', 'User', (['_dict'], {}), '(_dict)\n', (1654, 1661), False, 'from me4storage.models.user import User\n'), ((1927, 1940), 'me4storage.models... |
import sympy as sp
x, y, z = sp.symbols('x y z')
sp.init_printing()
# Here we simply give the input needed as The Following:
# ( X0 ) & ( X1 ) & ( X2 )
# ( Fx ) is the equation of the function
# ( n ) is the number of Iterations needed
x0 = 4.5
x1 = 5.5
x2 = 5
Fx = x**3 - 13*x - 12
n = 3
print("________________... | [
"sympy.symbols",
"sympy.sqrt",
"sympy.init_printing"
] | [((29, 48), 'sympy.symbols', 'sp.symbols', (['"""x y z"""'], {}), "('x y z')\n", (39, 48), True, 'import sympy as sp\n'), ((49, 67), 'sympy.init_printing', 'sp.init_printing', ([], {}), '()\n', (65, 67), True, 'import sympy as sp\n'), ((1150, 1177), 'sympy.sqrt', 'sp.sqrt', (['(B ** 2 - 4 * A * C)'], {}), '(B ** 2 - 4 ... |
__author__ = 'kunal'
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sns
data = pd.read_csv('../data/train.csv', header=0)
rows = len(data.axes[0])
data = pd.crosstab(data.Category, data.Resolution)
heat_map = sns.heatmap(data, square=True, linewidths=1, label='tiny')
plt.show()
| [
"pandas.crosstab",
"seaborn.heatmap",
"pandas.read_csv",
"matplotlib.pyplot.show"
] | [((105, 147), 'pandas.read_csv', 'pd.read_csv', (['"""../data/train.csv"""'], {'header': '(0)'}), "('../data/train.csv', header=0)\n", (116, 147), True, 'import pandas as pd\n'), ((180, 223), 'pandas.crosstab', 'pd.crosstab', (['data.Category', 'data.Resolution'], {}), '(data.Category, data.Resolution)\n', (191, 223), ... |
import json
import random
import os
import logging
import pickle
import string
import re
from pathlib import Path
from collections import Counter, OrderedDict, defaultdict as ddict
import torch
import numpy as np
from tqdm.notebook import tqdm
from torch.utils.data import Dataset
def set_seed(seed):
random.seed(se... | [
"logging.getLogger",
"re.compile",
"numpy.argsort",
"os.path.exists",
"pathlib.Path",
"numpy.max",
"logging.FileHandler",
"numpy.random.seed",
"collections.OrderedDict",
"pickle.load",
"re.sub",
"torch.cuda.manual_seed_all",
"torch.manual_seed",
"pickle.dump",
"os.makedirs",
"logging.F... | [((306, 323), 'random.seed', 'random.seed', (['seed'], {}), '(seed)\n', (317, 323), False, 'import random\n'), ((328, 348), 'numpy.random.seed', 'np.random.seed', (['seed'], {}), '(seed)\n', (342, 348), True, 'import numpy as np\n'), ((353, 376), 'torch.manual_seed', 'torch.manual_seed', (['seed'], {}), '(seed)\n', (37... |
#!/bin/python
import sys
import json
text = ""
with open(sys.argv[1]) as fp:
text = fp.read();
data = json.loads(text);
if sys.argv[2] == "list":
for key in data:
print(data[key])
else:
lines = []
with open(sys.argv[2]) as fd:
lines = fd.readlines()
... | [
"json.loads",
"json.dumps"
] | [((113, 129), 'json.loads', 'json.loads', (['text'], {}), '(text)\n', (123, 129), False, 'import json\n'), ((448, 501), 'json.dumps', 'json.dumps', (['data'], {'indent': '(4)', 'separators': "(',\\n', ' : ')"}), "(data, indent=4, separators=(',\\n', ' : '))\n", (458, 501), False, 'import json\n')] |
import tensorflow as tf
f = tf.random.uniform([2, 2], minval=0, maxval=1)
print("f:", f)
| [
"tensorflow.random.uniform"
] | [((29, 74), 'tensorflow.random.uniform', 'tf.random.uniform', (['[2, 2]'], {'minval': '(0)', 'maxval': '(1)'}), '([2, 2], minval=0, maxval=1)\n', (46, 74), True, 'import tensorflow as tf\n')] |
from typing import Dict, List
import pytest
from boardfarm.devices.base_devices.acs_template import AcsTemplate
def test_cannot_instantiate_abc_acs():
with pytest.raises(TypeError) as err:
acs = AcsTemplate() # noqa: F841
print(str(err.value))
assert "Can't instantiate abstract class AcsTem... | [
"pytest.raises",
"boardfarm.devices.base_devices.acs_template.AcsTemplate"
] | [((164, 188), 'pytest.raises', 'pytest.raises', (['TypeError'], {}), '(TypeError)\n', (177, 188), False, 'import pytest\n'), ((211, 224), 'boardfarm.devices.base_devices.acs_template.AcsTemplate', 'AcsTemplate', ([], {}), '()\n', (222, 224), False, 'from boardfarm.devices.base_devices.acs_template import AcsTemplate\n'... |
from fastapi import FastAPI
import uvicorn
from typing import Optional
from pydantic import BaseModel
import secrets
from fastapi import Depends, FastAPI, HTTPException, status
from fastapi.security import HTTPBasic, HTTPBasicCredentials
class Item(BaseModel):
name: str
description: Optional[str] = None
p... | [
"fastapi.FastAPI",
"secrets.compare_digest",
"fastapi.HTTPException",
"fastapi.security.HTTPBasic",
"fastapi.Depends"
] | [((370, 379), 'fastapi.FastAPI', 'FastAPI', ([], {}), '()\n', (377, 379), False, 'from fastapi import Depends, FastAPI, HTTPException, status\n'), ((392, 403), 'fastapi.security.HTTPBasic', 'HTTPBasic', ([], {}), '()\n', (401, 403), False, 'from fastapi.security import HTTPBasic, HTTPBasicCredentials\n'), ((466, 483), ... |
from django.contrib.sqlite3.search import FTS5Model, FTSField
class Breakfast(FTS5Model):
ingredients = FTSField()
| [
"django.contrib.sqlite3.search.FTSField"
] | [((110, 120), 'django.contrib.sqlite3.search.FTSField', 'FTSField', ([], {}), '()\n', (118, 120), False, 'from django.contrib.sqlite3.search import FTS5Model, FTSField\n')] |
import torch
from torch.autograd import Variable
from typing import Dict
from torch.nn import Module, Linear, Dropout, Sequential, Embedding, LogSigmoid, ReLU
from torch.nn.functional import sigmoid, logsigmoid, softmax, normalize, log_softmax
from embeddings.representation import SpanRepresentation
from torch.nn.init ... | [
"torch.index_select",
"torch.nn.ReLU",
"torch.nn.Dropout",
"torch.autograd.Variable",
"embeddings.representation.SpanRepresentation",
"torch.multinomial",
"torch.nn.functional.cosine_similarity",
"torch.from_numpy",
"torch.nn.functional.sigmoid",
"torch.nn.functional.normalize",
"torch.cat",
"... | [((531, 548), 'numpy.load', 'np.load', (['filename'], {}), '(filename)\n', (538, 548), True, 'import numpy as np\n'), ((782, 804), 'torch.from_numpy', 'torch.from_numpy', (['data'], {}), '(data)\n', (798, 804), False, 'import torch\n'), ((2987, 3027), 'torch.nn.Embedding', 'Embedding', (['config.n_args', 'config.d_embe... |
from collections import OrderedDict
from tqdm import tqdm
def load_flickr_set(images, text, file, test):
"""
Produces a ordered dict of tuples of data and label from the ids defined in file.
Train Structure:
{
id: (id, img_data, word vector)
}
Test Structure:
{
... | [
"collections.OrderedDict",
"tqdm.tqdm"
] | [((681, 694), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (692, 694), False, 'from collections import OrderedDict\n'), ((746, 793), 'tqdm.tqdm', 'tqdm', (['set_ids'], {'desc': '"""Generating Flickr dataset"""'}), "(set_ids, desc='Generating Flickr dataset')\n", (750, 793), False, 'from tqdm import tqdm\... |
from app import app
app.run(host='localhost',port=5000,debug=True) | [
"app.app.run"
] | [((20, 68), 'app.app.run', 'app.run', ([], {'host': '"""localhost"""', 'port': '(5000)', 'debug': '(True)'}), "(host='localhost', port=5000, debug=True)\n", (27, 68), False, 'from app import app\n')] |
#!/usr/bin/env python
# coding: utf-8
# `Firefly/ntbks/multiple_datasets_tutorial.ipynb`
# In[1]:
get_ipython().run_line_magic('load_ext', 'autoreload')
get_ipython().run_line_magic('autoreload', '2')
from IPython.display import YouTubeVideo
# A recording of this jupyter notebook in action is available at:
# In[... | [
"sys.path.insert",
"numpy.random.random",
"Firefly.data_reader.ArrayReader",
"numpy.array",
"numpy.linspace",
"IPython.display.YouTubeVideo",
"numpy.meshgrid"
] | [((326, 353), 'IPython.display.YouTubeVideo', 'YouTubeVideo', (['"""TMq3IvnxGY8"""'], {}), "('TMq3IvnxGY8')\n", (338, 353), False, 'from IPython.display import YouTubeVideo\n'), ((408, 472), 'sys.path.insert', 'sys.path.insert', (['(0)', '"""/Users/agurvich/research/repos/Firefly/src"""'], {}), "(0, '/Users/agurvich/re... |
# main.py -- put your code here!
# See https://docs.pycom.io for more information regarding library specifics
import utime
import pycom
import machine
from pycoproc import Pycoproc
from LIS2HH12 import LIS2HH12
from SI7006A20 import SI7006A20
from LTR329ALS01 import LTR329ALS01
from MPL3115A2 import MPL3115A2, ALTITU... | [
"SI7006A20.SI7006A20",
"machine.RTC",
"datapoint.DataPoint",
"MPL3115A2.MPL3115A2",
"helpers.setup_rtc",
"machine.deepsleep",
"machine.Timer.Chrono",
"pycoproc.Pycoproc.__init__",
"helpers.connect_to_WLAN",
"LIS2HH12.LIS2HH12",
"utime.time",
"LTR329ALS01.LTR329ALS01",
"thingspeak.send_to_thi... | [((481, 503), 'pycom.heartbeat', 'pycom.heartbeat', (['(False)'], {}), '(False)\n', (496, 503), False, 'import pycom\n'), ((525, 538), 'machine.RTC', 'machine.RTC', ([], {}), '()\n', (536, 538), False, 'import machine\n'), ((553, 575), 'machine.Timer.Chrono', 'machine.Timer.Chrono', ([], {}), '()\n', (573, 575), False,... |
# -*- coding: utf-8 -*-
"""
@Datetime: 2019/1/16
@Author: <NAME>
"""
from django.conf.urls import url, include
from api.views import course
from api.views import account
urlpatterns = [
# 方式一
# url(r'^course/$', course.CourseView.as_view()),
# url(r'^course/(?P<pk>\d+)$', course.CourseView.as_view()),
... | [
"api.views.account.AuthView.as_view",
"api.views.course.CourseView.as_view",
"django.conf.urls.url",
"api.views.course.MicroView.as_view"
] | [((482, 508), 'django.conf.urls.url', 'url', (['"""^test$"""', 'course.test'], {}), "('^test$', course.test)\n", (485, 508), False, 'from django.conf.urls import url, include\n'), ((351, 393), 'api.views.course.CourseView.as_view', 'course.CourseView.as_view', (["{'get': 'list'}"], {}), "({'get': 'list'})\n", (376, 393... |
from __future__ import unicode_literals
from __future__ import absolute_import, division, print_function
"""
Value mapper for Identifier (URI/CURIE) field
"""
__author__ = "<NAME> (<EMAIL>)"
__copyright__ = "Copyright 2017, <NAME>"
__license__ = "MIT (http://opensource.org/licenses/MIT)"
import logging
lo... | [
"logging.getLogger",
"utils.py3porting.is_string"
] | [((324, 351), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (341, 351), False, 'import logging\n'), ((962, 984), 'utils.py3porting.is_string', 'is_string', (['field_value'], {}), '(field_value)\n', (971, 984), False, 'from utils.py3porting import is_string, to_unicode\n')] |
from django.contrib.auth.models import User
from rest_framework import viewsets, decorators
from rest_offlinesync import limit
from rest_fuzzysearch import sort, search
from .models import Notebook, Note, Task
from .rest import serializers, links
from . import permissions
def get_view_description(cls, html=False):
... | [
"django.contrib.auth.models.User.objects.all",
"rest_framework.decorators.list_route"
] | [((551, 569), 'django.contrib.auth.models.User.objects.all', 'User.objects.all', ([], {}), '()\n', (567, 569), False, 'from django.contrib.auth.models import User\n'), ((1889, 1927), 'rest_framework.decorators.list_route', 'decorators.list_route', ([], {'suffix': '"""Search"""'}), "(suffix='Search')\n", (1910, 1927), F... |
from django.views import View
from django.http import JsonResponse, HttpResponse, HttpRequest
from app.models import Company
from app.core.mixin.base import UserLoggedInRequiredMixinJSON
class UserCompanySign(View, UserLoggedInRequiredMixinJSON):
"""
URL: /api/v1/user/company/sign/
SUPPORT_METHOD: ['POST... | [
"app.models.Company.objects.company_exists",
"django.http.HttpResponse",
"app.models.Company.objects.get",
"django.http.JsonResponse"
] | [((1160, 1178), 'django.http.JsonResponse', 'JsonResponse', (['data'], {}), '(data)\n', (1172, 1178), False, 'from django.http import JsonResponse, HttpResponse, HttpRequest\n'), ((562, 606), 'app.models.Company.objects.company_exists', 'Company.objects.company_exists', (['company_name'], {}), '(company_name)\n', (592,... |
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
# Import our models
from models.user import User
from models.mood import Mood
from models.notes import Notes
from models.visit import Visit
# Create a new engine and bind it to a session
engine = create_engine('sqlite:///store/database.db', ... | [
"sqlalchemy.orm.sessionmaker",
"sqlalchemy.create_engine",
"models.notes.Notes.__table__.create",
"models.mood.Mood.__table__.create",
"models.visit.Visit.__table__.create",
"models.user.User.__table__.create"
] | [((275, 367), 'sqlalchemy.create_engine', 'create_engine', (['"""sqlite:///store/database.db"""'], {'connect_args': "{'check_same_thread': False}"}), "('sqlite:///store/database.db', connect_args={\n 'check_same_thread': False})\n", (288, 367), False, 'from sqlalchemy import create_engine\n'), ((377, 402), 'sqlalche... |
# FHIR Data Model Class
"""
Models for Patient Membership Data
All of the models are stored in this module
Models
------
Pat - A patient in membership list
Attributes:
-----------
Profile = a top-level model injerated from base model
resourceType (string) - the resource type, i.e. "Patient"
active (boolean)... | [
"logging.getLogger",
"re.compile",
"datetime.datetime.strptime",
"email_validator.validate_email",
"flask_sqlalchemy.SQLAlchemy"
] | [((1480, 1515), 'logging.getLogger', 'logging.getLogger', (['"""gunicorn.error"""'], {}), "('gunicorn.error')\n", (1497, 1515), False, 'import logging\n'), ((1590, 1602), 'flask_sqlalchemy.SQLAlchemy', 'SQLAlchemy', ([], {}), '()\n', (1600, 1602), False, 'from flask_sqlalchemy import SQLAlchemy\n'), ((1657, 1695), 're.... |
################################################################################
# #
# ONE-ZONE OPTICALLY THIN BREMSSTRAHLUNG COOLING #
# ... | [
"sys.path.insert",
"numpy.sqrt",
"matplotlib.pyplot.ylabel",
"sys.exit",
"matplotlib.pyplot.xlabel",
"numpy.linspace",
"subprocess.call",
"matplotlib.pyplot.ylim",
"matplotlib.pyplot.savefig",
"hdf5_to_dict.load_hdr",
"scipy.integrate.odeint",
"matplotlib.use",
"util.safe_remove",
"matplot... | [((507, 539), 'sys.path.insert', 'sys.path.insert', (['(0)', '"""../script/"""'], {}), "(0, '../script/')\n", (522, 539), False, 'import sys\n'), ((540, 580), 'sys.path.insert', 'sys.path.insert', (['(0)', '"""../script/analysis"""'], {}), "(0, '../script/analysis')\n", (555, 580), False, 'import sys\n'), ((685, 700), ... |
import matplotlib.pyplot as plt
import numpy
import argparse
import json
import socket
def get_args():
parser = argparse.ArgumentParser(
description='Charcoal Dryrot Generate result plots.',
formatter_class=argparse.ArgumentDefaultsHelpFormatter)
parser.add_argument('-e',
... | [
"argparse.ArgumentParser",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.clf",
"matplotlib.pyplot.close",
"json.load",
"matplotlib.pyplot.title",
"socket.gethostname",
"matplotlib.pyplot.legend"
] | [((117, 260), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Charcoal Dryrot Generate result plots."""', 'formatter_class': 'argparse.ArgumentDefaultsHelpFormatter'}), "(description=\n 'Charcoal Dryrot Generate result plots.', formatter_class=argparse.\n ArgumentDefaultsHelpFormatt... |
# @Time : 2020/11/14
# @Author : <NAME>, <NAME>
# @Email : <EMAIL>
# UPDATE
# @Time : 2021/4/12
# @Author : <NAME>
# @Email : <EMAIL>
"""
textbox.evaluator.abstract_evaluator
#####################################
"""
import numpy as np
class AbstractEvaluator(object):
""":class:`AbstractEvaluator` is an ... | [
"numpy.mean"
] | [((1180, 1196), 'numpy.mean', 'np.mean', (['tp_list'], {}), '(tp_list)\n', (1187, 1196), True, 'import numpy as np\n')] |
# Copyright 2017 Google Inc. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or a... | [
"tensorflow.shape",
"tensorflow.scatter_update",
"tensorflow.reduce_sum",
"numpy.log",
"tensorflow.truncated_normal_initializer",
"tensorflow.group",
"tensorflow.control_dependencies",
"tensorflow.nn.softmax",
"tensorflow.reduce_mean",
"tensorflow.variables_initializer",
"tensorflow.slice",
"t... | [((1826, 1843), 'tensorflow.constant', 'tf.constant', (['(True)'], {}), '(True)\n', (1837, 1843), True, 'import tensorflow as tf\n'), ((3294, 3386), 'tensorflow.variables_initializer', 'tf.variables_initializer', (['[self.mem_keys, self.mem_vals, self.mem_age, self.recent_idx]'], {}), '([self.mem_keys, self.mem_vals, s... |
from typing import List
import heapq
class Solution:
def kSmallestPairs(self, nums1: List[int], nums2: List[int], k: int) -> List[List[int]]:
heap = []
for n1 in nums1:
for n2 in nums2:
if len(heap) < k:
heapq.heappush(heap, (-n1-n2, [n1,n2]))
... | [
"heapq.heappop",
"heapq.heappush"
] | [((593, 612), 'heapq.heappop', 'heapq.heappop', (['heap'], {}), '(heap)\n', (606, 612), False, 'import heapq\n'), ((272, 314), 'heapq.heappush', 'heapq.heappush', (['heap', '(-n1 - n2, [n1, n2])'], {}), '(heap, (-n1 - n2, [n1, n2]))\n', (286, 314), False, 'import heapq\n'), ((413, 432), 'heapq.heappop', 'heapq.heappop'... |
from copy import deepcopy
import jsonschema
from django.contrib.postgres.fields.jsonb import JSONField
from django.core import exceptions
from django.db import DataError, connection, models
from prettytable import from_db_cursor
from rest_framework import exceptions
from .utils import DefaultValidatingDraft4Validator... | [
"django.db.DataError",
"django.db.models.TextField",
"django.db.models.ForeignKey",
"django.db.models.BooleanField",
"prettytable.from_db_cursor",
"django.contrib.postgres.fields.jsonb.JSONField",
"django.db.connection.cursor",
"copy.deepcopy"
] | [((384, 425), 'django.db.models.TextField', 'models.TextField', ([], {'null': '(False)', 'blank': '(False)'}), '(null=False, blank=False)\n', (400, 425), False, 'from django.db import DataError, connection, models\n'), ((439, 480), 'django.db.models.TextField', 'models.TextField', ([], {'null': '(False)', 'blank': '(Fa... |
import serial
import struct
import time
import numpy as np
from ahrs.filters import Madgwick
from cube import CubeRenderer
sync = b'\xEF\xBE\xAD\xDE'
def reset(ser):
ser.write(sync)
ser.write(b'\x01\x00')
ser.write(b'\x00')
def begin(ser):
ser.write(sync)
ser.write(b'\x03\x00')
ser.write(b'\x10')
ser.w... | [
"time.sleep",
"numpy.array",
"struct.unpack",
"serial.Serial",
"cube.CubeRenderer",
"ahrs.filters.Madgwick"
] | [((1049, 1062), 'time.sleep', 'time.sleep', (['(3)'], {}), '(3)\n', (1059, 1062), False, 'import time\n'), ((1142, 1172), 'numpy.array', 'np.array', (['[1.0, 0.0, 0.0, 0.0]'], {}), '([1.0, 0.0, 0.0, 0.0])\n', (1150, 1172), True, 'import numpy as np\n'), ((1182, 1210), 'ahrs.filters.Madgwick', 'Madgwick', ([], {'Dt': '(... |
import logging
import datetime
from pprint import pformat
from pymongo import MongoClient
def mongo_connect():
host = '127.0.0.1'
client = MongoClient(host=host)
db = client.test_database
list_db_collections(db)
results_collection = db.results
res = {'model': 'model_id_1',
'dataset':... | [
"logging.getLogger",
"logging.basicConfig",
"pprint.pformat",
"datetime.datetime.now",
"pymongo.MongoClient"
] | [((148, 170), 'pymongo.MongoClient', 'MongoClient', ([], {'host': 'host'}), '(host=host)\n', (159, 170), False, 'from pymongo import MongoClient\n'), ((545, 585), 'logging.getLogger', 'logging.getLogger', (['"""list_db_collections"""'], {}), "('list_db_collections')\n", (562, 585), False, 'import logging\n'), ((1071, 1... |
# -*- coding: utf-8; mode: python -*-
# pylint: disable=R0903, C0330, R0914, R0912, E0401
import os
import sys
from sphinx.util.pycompat import execfile_
# ------------------------------------------------------------------------------
def loadConfig(namespace):
# ------------------------------------------------------... | [
"sphinx.util.pycompat.execfile_",
"os.environ.get",
"os.path.normpath",
"os.path.isfile",
"os.path.abspath",
"sys.stdout.write"
] | [((695, 730), 'os.environ.get', 'os.environ.get', (['"""SPHINX_CONF"""', 'None'], {}), "('SPHINX_CONF', None)\n", (709, 730), False, 'import os\n'), ((873, 901), 'os.path.abspath', 'os.path.abspath', (['config_file'], {}), '(config_file)\n', (888, 901), False, 'import os\n'), ((1738, 1765), 'os.path.isfile', 'os.path.i... |
from rest_framework import serializers
from model_garden.constants import LabelingTaskStatus
from model_garden.models import MediaAsset
class MediaAssetIDSerializer(serializers.Serializer):
id = serializers.ListField(
child=serializers.IntegerField(),
required=True,
allow_empty=False,
min_length=1,... | [
"rest_framework.serializers.IntegerField",
"rest_framework.serializers.SerializerMethodField"
] | [((399, 434), 'rest_framework.serializers.SerializerMethodField', 'serializers.SerializerMethodField', ([], {}), '()\n', (432, 434), False, 'from rest_framework import serializers\n'), ((457, 492), 'rest_framework.serializers.SerializerMethodField', 'serializers.SerializerMethodField', ([], {}), '()\n', (490, 492), Fal... |
from django.contrib.auth import get_user_model
from ...conf.test import override_dynamic_settings
from ..setupnewuser import set_default_subscription_options, setup_new_user
User = get_user_model()
def user(db):
return User.objects.create_user("User", "<EMAIL>")
def test_default_avatar_is_set_for_user(dynamic... | [
"django.contrib.auth.get_user_model"
] | [((183, 199), 'django.contrib.auth.get_user_model', 'get_user_model', ([], {}), '()\n', (197, 199), False, 'from django.contrib.auth import get_user_model\n')] |
""" Common pytest fixtures. """
import pytest
from craigslist_meta import base, metadata
@pytest.fixture
def get_keys():
""" Get all keys of a given class. """
yield lambda selector: base.find_keys(metadata.CRAIGSLIST, selector)
@pytest.fixture
def get_children():
""" Get children of a given instance. ... | [
"craigslist_meta.base.find_title",
"craigslist_meta.base.find_children",
"craigslist_meta.base.find_keys",
"craigslist_meta.base.find_url"
] | [((194, 239), 'craigslist_meta.base.find_keys', 'base.find_keys', (['metadata.CRAIGSLIST', 'selector'], {}), '(metadata.CRAIGSLIST, selector)\n', (208, 239), False, 'from craigslist_meta import base, metadata\n'), ((356, 410), 'craigslist_meta.base.find_children', 'base.find_children', (['metadata.CRAIGSLIST', 'selecto... |
from __future__ import division, absolute_import, print_function
__all__ = ['styled']
# noinspection PyUnresolvedReferences
from six.moves.html_parser import HTMLParser
from blessings import Terminal
term = Terminal()
default_styles = {
'err': term.red,
'ref': term.yellow,
'rev': term.bold,
'cmd': t... | [
"six.moves.html_parser.HTMLParser.__init__",
"blessings.Terminal"
] | [((210, 220), 'blessings.Terminal', 'Terminal', ([], {}), '()\n', (218, 220), False, 'from blessings import Terminal\n'), ((487, 512), 'six.moves.html_parser.HTMLParser.__init__', 'HTMLParser.__init__', (['self'], {}), '(self)\n', (506, 512), False, 'from six.moves.html_parser import HTMLParser\n')] |
# -*- coding: utf-8 -*-
"""
Tencent is pleased to support the open source community by making 蓝鲸智云PaaS平台社区版 (BlueKing PaaS Community
Edition) available.
Copyright (C) 2017-2020 THL A29 Limited, a Tencent company. All rights reserved.
Licensed under the MIT License (the "License"); you may not use this file except in co... | [
"importlib.import_module"
] | [((797, 875), 'importlib.import_module', 'importlib.import_module', (["('gcloud.core.utils.sites.%s.utils' % settings.RUN_VER)"], {}), "('gcloud.core.utils.sites.%s.utils' % settings.RUN_VER)\n", (820, 875), False, 'import importlib\n')] |
from collections import namedtuple
class Config(namedtuple('Config', ['origin', 'api_key', 'maybe_logger'])):
"""Configuration for interacting with SLS API."""
__slots__ = ()
def __new__(cls, origin, api_key, maybe_logger=None):
return super(Config, cls).__new__(cls, origin, api_key,
... | [
"collections.namedtuple"
] | [((50, 109), 'collections.namedtuple', 'namedtuple', (['"""Config"""', "['origin', 'api_key', 'maybe_logger']"], {}), "('Config', ['origin', 'api_key', 'maybe_logger'])\n", (60, 109), False, 'from collections import namedtuple\n')] |
from pyraat import PraatAnalysisFunction as PyraatFunction
from .functions import BaseAnalysisFunction
class PraatAnalysisFunction(BaseAnalysisFunction):
def __init__(self, praat_script_path, praat_path=None, arguments=None):
super(PraatAnalysisFunction, self).__init__()
self._function = PyraatFu... | [
"pyraat.PraatAnalysisFunction"
] | [((312, 368), 'pyraat.PraatAnalysisFunction', 'PyraatFunction', (['praat_script_path', 'praat_path', 'arguments'], {}), '(praat_script_path, praat_path, arguments)\n', (326, 368), True, 'from pyraat import PraatAnalysisFunction as PyraatFunction\n')] |
import numpy as np
import time
import gym
def execute(env, policy, gamma=1.0, render=False):
totalReward = 0
start = env.reset()
stepIndex = 0
while True:
if render:
env.render()
start, reward, done, _ = env.step(int(policy[start]))
totalReward += (gamma ** stepIndex... | [
"numpy.mean",
"numpy.copy",
"numpy.fabs",
"numpy.random.choice",
"numpy.argmax",
"numpy.max",
"numpy.zeros",
"numpy.all",
"time.time",
"gym.make"
] | [((570, 585), 'numpy.mean', 'np.mean', (['scores'], {}), '(scores)\n', (577, 585), True, 'import numpy as np\n'), ((638, 658), 'numpy.zeros', 'np.zeros', (['env.env.nS'], {}), '(env.env.nS)\n', (646, 658), True, 'import numpy as np\n'), ((963, 983), 'numpy.zeros', 'np.zeros', (['env.env.nS'], {}), '(env.env.nS)\n', (97... |
import PIL
from PIL import Image
name = input("Please enter the name of the image: ")
n = int(input("Choose the extension \n press '1' for jpg\n press '2' for jpeg \n press '3' for png\n"))
def myfun(n, b):
print("For better quality please enter original dimensions of Image")
width = int(input("Ente... | [
"PIL.Image.open"
] | [((504, 517), 'PIL.Image.open', 'Image.open', (['n'], {}), '(n)\n', (514, 517), False, 'from PIL import Image\n')] |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Feb 11 17:10:49 2020
@author: <NAME>
In this code a Hamiltonian Neural Network is designed and employed
to solve a system of four differential equations obtained by Hamilton's
equations for the Hamiltonian of Henon-Heiles chaotic dynamical.
"""
import ... | [
"utils_HHsystem.HHsolution",
"matplotlib.pyplot.ylabel",
"torch.sin",
"torch.exp",
"copy.deepcopy",
"sys.exit",
"utils_HHsystem.HH_exact",
"os.path.exists",
"utils_HHsystem.symEuler",
"matplotlib.pyplot.loglog",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.close",... | [((611, 627), 'matplotlib.pyplot.close', 'plt.close', (['"""all"""'], {}), "('all')\n", (620, 627), True, 'import matplotlib.pyplot as plt\n'), ((8927, 8964), 'torch.linspace', 'torch.linspace', (['t0', 't_max_test', 'nTest'], {}), '(t0, t_max_test, nTest)\n', (8941, 8964), False, 'import torch\n'), ((9177, 9202), 'uti... |
from setuptools import setup, find_packages
setup(
name = 'lisa2',
description = """Lisa: inferring transcriptional regulators through integrative modeling of public chromatin accessibility and ChIP-seq data\n
X. Shirley Liu Lab, 2020""",
version = '2.2.1',
url = 'https://genomebiology.biomedcentral.... | [
"setuptools.find_packages"
] | [((429, 444), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (442, 444), False, 'from setuptools import setup, find_packages\n')] |
import nltk
from operator import itemgetter
class Argument:
def __init__(self, arg):
self.words = [x for x in arg[0].strip().split(' ') if x]
self.posTags = list(map(itemgetter(1), nltk.pos_tag(self.words)))
self.indices = arg[1]
self.feats = {}
COREF = 'coref'
it... | [
"operator.itemgetter",
"nltk.pos_tag"
] | [((187, 200), 'operator.itemgetter', 'itemgetter', (['(1)'], {}), '(1)\n', (197, 200), False, 'from operator import itemgetter\n'), ((202, 226), 'nltk.pos_tag', 'nltk.pos_tag', (['self.words'], {}), '(self.words)\n', (214, 226), False, 'import nltk\n')] |
# -*- coding: utf-8 -*-
# Generated by Django 1.11.24 on 2019-09-27 19:37
from __future__ import unicode_literals
from django.db import migrations
from vakt import Policy, ALLOW_ACCESS, DENY_ACCESS
import apps.noclook.vakt.rules as srirules
import apps.noclook.vakt.utils as sriutils
import uuid
import vakt.rules as v... | [
"apps.noclook.vakt.utils.get_vakt_storage_and_guard",
"uuid.uuid4",
"django.db.migrations.RunPython",
"vakt.rules.Eq",
"apps.noclook.vakt.rules.ContainsElement",
"vakt.rules.Any",
"apps.noclook.vakt.rules.HasAuthAction",
"apps.noclook.vakt.rules.BelongsContext"
] | [((421, 458), 'apps.noclook.vakt.utils.get_vakt_storage_and_guard', 'sriutils.get_vakt_storage_and_guard', ([], {}), '()\n', (456, 458), True, 'import apps.noclook.vakt.utils as sriutils\n'), ((2403, 2454), 'django.db.migrations.RunPython', 'migrations.RunPython', (['forwards_func', 'backwards_func'], {}), '(forwards_f... |
# Generated by Django 3.1.4 on 2020-12-28 03:31
from django.db import migrations, models
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
migrations.CreateModel(
name='Route',
fields=[
('id', models.AutoField(au... | [
"django.db.models.JSONField",
"django.db.models.AutoField",
"django.db.models.TextField"
] | [((301, 394), '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", (317, 394), False, 'from django.db import migrations, models\... |
"""Tests related to the @defended decorator."""
from generics import defended
defended(None)
| [
"generics.defended"
] | [((79, 93), 'generics.defended', 'defended', (['None'], {}), '(None)\n', (87, 93), False, 'from generics import defended\n')] |
import calendar
import json
import os
import re
from datetime import datetime
from urllib.parse import quote
import barcode
import qrcode
import requests
from barcode.writer import ImageWriter
from bs4 import BeautifulSoup
from PIL import Image, ImageColor
from telethon.errors.rpcerrorlist import YouBlockedUserError
... | [
"os.path.exists",
"barcode.writer.ImageWriter",
"qrcode.QRCode",
"audynesia.udy.cod_cmd",
"PIL.Image.new",
"json.dumps",
"urllib.parse.quote",
"requests.get",
"bs4.BeautifulSoup",
"datetime.datetime.now",
"PIL.ImageColor.getrgb",
"os.remove"
] | [((618, 1063), 'audynesia.udy.cod_cmd', 'udy.cod_cmd', ([], {'pattern': '"""cur(?:\\\\s|$)([\\\\s\\\\S]*)"""', 'command': "('cur', plugin_category)", 'info': "{'header': 'To convert one currency value to other.', 'description':\n 'To find exchange rates of currencies.', 'usage':\n '{tr}cur <value> <from currencyi... |
import rxsci as rs
def clip(lower_bound=None, higher_bound=None):
'''clip values between lower_bound (included) and higher_bound (included)
The source can be an Observable or a MuxObservable.
.. marble::
:alt: clip
-0-1-2-1-3-4-2-6---|
[ clip(2, 4) ]
-2-2-2-2-3-4-2... | [
"rxsci.ops.map"
] | [((1299, 1317), 'rxsci.ops.map', 'rs.ops.map', (['__clip'], {}), '(__clip)\n', (1309, 1317), True, 'import rxsci as rs\n')] |
#!/usr/bin/env python3
from pymongo import MongoClient
import pymongo.errors
username, password, host, dbname = 'user0', '<PASSWORD>', '127.0.0.1', 'test_db'
client = MongoClient('mongodb://%s:%s@%s/%s' % (username, password, host, dbname))
try:
db = client.test_db
pycollection = db.pycollection
pycollection.... | [
"pymongo.MongoClient"
] | [((169, 242), 'pymongo.MongoClient', 'MongoClient', (["('mongodb://%s:%s@%s/%s' % (username, password, host, dbname))"], {}), "('mongodb://%s:%s@%s/%s' % (username, password, host, dbname))\n", (180, 242), False, 'from pymongo import MongoClient\n')] |
#! /usr/bin/env python
# IDLE Behavior
# WARNING! if person tracking is acting crazy, check that
# the person tracker node is using the correct camera!!
import rospy
import actionlib
import behavior_common.msg
import time
import rospkg
import rosparam
from std_msgs.msg import Float64
from std_msgs.msg import String... | [
"rospy.init_node",
"rosparam.upload_params",
"time.sleep",
"rospy.Duration.from_sec",
"rospy.spin",
"rospy.sleep",
"rospy.Subscriber",
"random.randint",
"actionlib.SimpleActionClient",
"random.uniform",
"rospy.get_param",
"actionlib.SimpleActionServer",
"sensor_msgs.msg.JointState",
"rospy... | [((16988, 17020), 'rospy.init_node', 'rospy.init_node', (['"""idle_behavior"""'], {}), "('idle_behavior')\n", (17003, 17020), False, 'import rospy\n'), ((17071, 17083), 'rospy.spin', 'rospy.spin', ([], {}), '()\n', (17081, 17083), False, 'import rospy\n'), ((1527, 1661), 'actionlib.SimpleActionServer', 'actionlib.Simpl... |
#!/usr/bin/env python
"""Render conference metadata to markdown
Functionality to dump proceedings records to well-formatted metadata.
Example usage
-------------
$ ./scripts/pubs_to_markdown.py \
publications.yaml \
pubs.md
"""
import argparse
import os
import sys
import yaml
TEMPLATE = '''
| {} |
| --- |
'... | [
"os.path.exists",
"argparse.ArgumentParser"
] | [((1097, 1141), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '__doc__'}), '(description=__doc__)\n', (1120, 1141), False, 'import argparse\n'), ((1655, 1687), 'os.path.exists', 'os.path.exists', (['args.output_file'], {}), '(args.output_file)\n', (1669, 1687), False, 'import os\n')] |
'''
A decorator for API methods that require some kind of authentication. If the
method doesn't require authentication, this decorator desn't need to be applied.
'''
from appython.components.api.api_status import ApiStatus
from flask_login import current_user
# import logging
def api_auth(login_required=False, admi... | [
"flask_login.current_user.is_active",
"flask_login.current_user.is_authenticated"
] | [((762, 793), 'flask_login.current_user.is_authenticated', 'current_user.is_authenticated', ([], {}), '()\n', (791, 793), False, 'from flask_login import current_user\n'), ((1040, 1064), 'flask_login.current_user.is_active', 'current_user.is_active', ([], {}), '()\n', (1062, 1064), False, 'from flask_login import curre... |
from dataclasses import dataclass
from typing import Tuple, List
import ase.data
import numpy as np
from networkx import Graph
from rdkit import Chem
import graphdg.parse.tools as tools
from graphdg.parse.extended_graph import mol_to_extended_graph
from graphdg.tools import GLOBALS, NODES, EDGES, SENDERS, RECEIVERS, ... | [
"graphdg.parse.tools.get_atom_distance",
"numpy.array",
"graphdg.parse.extended_graph.mol_to_extended_graph"
] | [((4616, 4649), 'numpy.array', 'np.array', (['targets'], {'dtype': 'np.float'}), '(targets, dtype=np.float)\n', (4624, 4649), True, 'import numpy as np\n'), ((4826, 4868), 'graphdg.parse.extended_graph.mol_to_extended_graph', 'mol_to_extended_graph', (['molecule'], {'seed': 'seed'}), '(molecule, seed=seed)\n', (4847, 4... |
# Under MIT license, see LICENSE.txt
from Util.pose import Pose
from Util.role import Role
from ai.STA.Strategy.team_go_to_position import TeamGoToPosition
from ai.STA.Tactic.penalty_goalkeeper import PenaltyGoalKeeper
class PrepareShootoutDefense(TeamGoToPosition):
def __init__(self, p_game_state):
sup... | [
"Util.pose.Pose.from_values",
"ai.STA.Tactic.penalty_goalkeeper.PenaltyGoalKeeper"
] | [((476, 540), 'Util.pose.Pose.from_values', 'Pose.from_values', (['(our_goal.position.x * 1 / 8)', '(field.top * 4 / 5)'], {}), '(our_goal.position.x * 1 / 8, field.top * 4 / 5)\n', (492, 540), False, 'from Util.pose import Pose\n'), ((584, 648), 'Util.pose.Pose.from_values', 'Pose.from_values', (['(our_goal.position.x... |
#ATS:test(SELF, label="2-D line segment intersecting edges of a polygon.")
from math import *
from Spheral2d import *
from SpheralTestUtilities import *
import unittest
# Create a global random number generator.
import random
rangen = random.Random()
#=================================================================... | [
"random.uniform",
"random.Random",
"unittest.main",
"random.random",
"random.randint"
] | [((237, 252), 'random.Random', 'random.Random', ([], {}), '()\n', (250, 252), False, 'import random\n'), ((4823, 4838), 'unittest.main', 'unittest.main', ([], {}), '()\n', (4836, 4838), False, 'import unittest\n'), ((3308, 3337), 'random.uniform', 'random.uniform', (['(0.0)', '(2.0 * pi)'], {}), '(0.0, 2.0 * pi)\n', (3... |
#!/usr/bin/env python3
import sys
from time import sleep
from bleson import get_provider, EddystoneBeacon
# Get the wait time from the first script argument or default it to 10 seconds
WAIT_TIME = int(sys.argv[1]) if len(sys.argv)>1 else 10
with EddystoneBeacon(get_provider().get_adapter(), 'https://www.bluetooth.co... | [
"bleson.get_provider",
"time.sleep"
] | [((330, 346), 'time.sleep', 'sleep', (['WAIT_TIME'], {}), '(WAIT_TIME)\n', (335, 346), False, 'from time import sleep\n'), ((265, 279), 'bleson.get_provider', 'get_provider', ([], {}), '()\n', (277, 279), False, 'from bleson import get_provider, EddystoneBeacon\n')] |
# -*- coding: utf-8 -*-
# Generated by Django 1.11.20 on 2019-07-29 21:42
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('lan', '0013_auto_20190721_0705'),
]
operations = [
migrations.AddField(
... | [
"django.db.models.TextField",
"django.db.models.CharField"
] | [((403, 543), 'django.db.models.CharField', 'models.CharField', ([], {'blank': '(True)', 'help_text': "b'Title to show above stream. May be empty.'", 'max_length': '(100)', 'verbose_name': "b'visible title'"}), "(blank=True, help_text=\n b'Title to show above stream. May be empty.', max_length=100,\n verbose_name... |
#!/usr/bin/python3
"""
Deactivate the relay, then exit. This script will not wait for new commands.
"""
from hyperion_relay import setup, switch_relay
setup()
switch_relay(False)
| [
"hyperion_relay.setup",
"hyperion_relay.switch_relay"
] | [((156, 163), 'hyperion_relay.setup', 'setup', ([], {}), '()\n', (161, 163), False, 'from hyperion_relay import setup, switch_relay\n'), ((164, 183), 'hyperion_relay.switch_relay', 'switch_relay', (['(False)'], {}), '(False)\n', (176, 183), False, 'from hyperion_relay import setup, switch_relay\n')] |
from django.contrib import admin
from .models import Log
@admin.register(Log)
class LogAdmin(admin.ModelAdmin):
pass
| [
"django.contrib.admin.register"
] | [((59, 78), 'django.contrib.admin.register', 'admin.register', (['Log'], {}), '(Log)\n', (73, 78), False, 'from django.contrib import admin\n')] |
from setuptools import setup, find_packages
setup(
name="RandomUsers",
description="A simple tool helps you generate fake data.",
long_description=open("README.md").read(),
long_description_content_type="text/markdown",
version="1.3",
author="SiriusKoan",
author_email="<EMAIL>",
package... | [
"setuptools.find_packages"
] | [((322, 337), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (335, 337), False, 'from setuptools import setup, find_packages\n')] |