code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
import json
from .base_api import BaseApi
class OriginationRequestApi(BaseApi):
def delete(self, slug):
"""
:param slug:
:return:
"""
http_method = "DELETE"
endpoint = "origination/{0}/".format(slug)
uri = self.client.api_uri + endpoint
respons... | [
"json.loads",
"json.dumps"
] | [((1122, 1147), 'json.loads', 'json.loads', (['response.text'], {}), '(response.text)\n', (1132, 1147), False, 'import json\n'), ((1525, 1550), 'json.loads', 'json.loads', (['response.text'], {}), '(response.text)\n', (1535, 1550), False, 'import json\n'), ((10051, 10076), 'json.loads', 'json.loads', (['response.text']... |
from flask import Flask, render_template,session,redirect,url_for,flash,request,\
current_app
from flask_script import Manager,Shell
from flask_bootstrap import Bootstrap
from flask_moment import Moment
from flask_wtf import FlaskForm
from wtforms import StringField, SubmitField,TextAreaField
from wtforms.validator... | [
"flask.request.args.get",
"flask_script.Manager",
"os.path.dirname",
"flask.Flask",
"flask_moment.Moment",
"wtforms.SubmitField",
"flask_sqlalchemy.SQLAlchemy",
"flask_migrate.Migrate",
"wtforms.validators.Required",
"flask.render_template",
"flask_script.Shell",
"flask_bootstrap.Bootstrap",
... | [((522, 537), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (527, 537), False, 'from flask import Flask, render_template, session, redirect, url_for, flash, request, current_app\n'), ((775, 790), 'flask_sqlalchemy.SQLAlchemy', 'SQLAlchemy', (['app'], {}), '(app)\n', (785, 790), False, 'from flask_sqlalche... |
import os
def getenv(var):
return os.environ[var]
class Config(object):
DEBUG = False
TESTING = False
SQLALCHEMY_DATABASE_URI = "sqlite:///data/data.db"
SQLALCHEMY_TRACK_MODIFICATIONS = False
FLASK_ADMIN_SWATCH = "flatly"
SECRET_KEY = b"\<KEY>"
@classmethod
def from_env(cls):
... | [
"os.getenv"
] | [((332, 359), 'os.getenv', 'os.getenv', (['"""APP_ENV"""', '"""dev"""'], {}), "('APP_ENV', 'dev')\n", (341, 359), False, 'import os\n')] |
#
# Developed for the LSST Data Management System.
# This product includes software developed by the LSST Project
# (https://www.lsst.org).
# See the COPYRIGHT file at the top-level directory of this distribution
# for details of code ownership.
#
# This program is free software: you can redistribute it and/or modify
#... | [
"copy.deepcopy",
"concurrent.futures.thread.ThreadPoolExecutor",
"dateutil.parser.parse",
"sortedcontainers.SortedList",
"logging.getLogger",
"sortedcontainers.SortedDict",
"datetime.datetime.now",
"concurrent.futures.as_completed"
] | [((1305, 1335), 'logging.getLogger', 'logging.getLogger', (['"""changelog"""'], {}), "('changelog')\n", (1322, 1335), False, 'import logging\n'), ((2156, 2168), 'sortedcontainers.SortedDict', 'SortedDict', ([], {}), '()\n', (2166, 2168), False, 'from sortedcontainers import SortedDict, SortedList\n'), ((3711, 3723), 's... |
from django.contrib import admin
from logapp import models
admin.site.register(models.Answer)
admin.site.register(models.Answer2)
admin.site.register(models.Answer3)
admin.site.register(models.Answer4)
admin.site.register(models.Answer5)
| [
"django.contrib.admin.site.register"
] | [((60, 94), 'django.contrib.admin.site.register', 'admin.site.register', (['models.Answer'], {}), '(models.Answer)\n', (79, 94), False, 'from django.contrib import admin\n'), ((95, 130), 'django.contrib.admin.site.register', 'admin.site.register', (['models.Answer2'], {}), '(models.Answer2)\n', (114, 130), False, 'from... |
from __future__ import print_function
import os
import sys
import re
import unicodecsv
from pyspark import SparkContext
from operator import add
import csv
import StringIO
def parse(str, headers=None):
if headers is not None:
retval = {}
else:
retval = []
try:
b = StringIO.StringI... | [
"csv.reader",
"pyspark.SparkContext",
"re.finditer",
"unicodecsv.writer",
"StringIO.StringIO",
"re.compile"
] | [((1443, 1468), 're.finditer', 're.finditer', (['p', 'triple[2]'], {}), '(p, triple[2])\n', (1454, 1468), False, 'import re\n'), ((1658, 1691), 'pyspark.SparkContext', 'SparkContext', ([], {'appName': '"""idb_regex"""'}), "(appName='idb_regex')\n", (1670, 1691), False, 'from pyspark import SparkContext\n'), ((2135, 216... |
from typing import Dict, Any
from nuclear.parser.keyword import format_var_name
class ArgsContainer(object):
def __init__(self, _vars: Dict[str, Any]):
self.__vars = _vars
def __getattr__(self, name):
if name in self.__vars:
return self.__vars[name]
else:
rais... | [
"nuclear.parser.keyword.format_var_name"
] | [((482, 502), 'nuclear.parser.keyword.format_var_name', 'format_var_name', (['key'], {}), '(key)\n', (497, 502), False, 'from nuclear.parser.keyword import format_var_name\n')] |
import sys
sys.path.append('ParseCAN')
import ParseCAN
from ParseCAN.spec import Endianness, Type
from math import ceil, floor, log2
from common import pack_unpack_c_path, pack_unpack_c_base_path, coord, is_multplxd, frame_handler
def swap_endianness_fn(type: Type):
if type.isbool():
return ''
retur... | [
"sys.path.append",
"math.ceil",
"common.is_multplxd",
"common.frame_handler",
"common.coord"
] | [((11, 38), 'sys.path.append', 'sys.path.append', (['"""ParseCAN"""'], {}), "('ParseCAN')\n", (26, 38), False, 'import sys\n'), ((1914, 1960), 'common.coord', 'coord', (['name_prepends', 'frame.name'], {'prefix': '(False)'}), '(name_prepends, frame.name, prefix=False)\n', (1919, 1960), False, 'from common import pack_u... |
__author__ = 'yxc'
import os
from sqlalchemy import session, sessionmaker
URL1 = "http://219.231.0.187/default_ysdx.aspx"
URL2 = "http://jw2.ahjzu.edu.cn/default_ysdx.aspx "
SQL = {"mysql": 0, "redis": 0, "PostgreSql": 0}
setting = {
"debug": True,
"template_path": os.path.join(os.path.dirname(__file__), "t... | [
"os.path.dirname"
] | [((291, 316), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (306, 316), False, 'import os\n'), ((364, 389), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (379, 389), False, 'import os\n')] |
# -*- coding: utf-8 -*-
from typing import Dict, NoReturn, Union
import uuid
from uuid import UUID
from chaosplt_relational_storage.db import Base
from flask_dance.consumer.backend.sqla import OAuthConsumerMixin
from sqlalchemy import Boolean, Column, DateTime, String, \
UniqueConstraint, func
from sqlalchemy.orm.... | [
"sqlalchemy.DateTime",
"sqlalchemy.func.now",
"sqlalchemy_utils.UUIDType",
"sqlalchemy.Boolean",
"sqlalchemy.UniqueConstraint",
"sqlalchemy.String"
] | [((531, 566), 'sqlalchemy.UniqueConstraint', 'UniqueConstraint', (['"""name"""', '"""user_id"""'], {}), "('name', 'user_id')\n", (547, 566), False, 'from sqlalchemy import Boolean, Column, DateTime, String, UniqueConstraint, func\n'), ((622, 644), 'sqlalchemy_utils.UUIDType', 'UUIDType', ([], {'binary': '(False)'}), '(... |
# -*- coding: utf-8 -*-
# Max-Planck-Gesellschaft zur Förderung der Wissenschaften e.V. (MPG) is
# holder of all proprietary rights on this computer program.
# You can only use this computer program if you have closed
# a license agreement with MPG or you get the right to use the computer
# program from someone who is... | [
"pyrender.camera.IntrinsicsCamera",
"torch.cuda.synchronize",
"pickle.dump",
"mesh_intersection.bvh_search_tree.BVH",
"torch.cat",
"numpy.ones",
"pyrender.Mesh.from_trimesh",
"numpy.mean",
"numpy.arange",
"pickle.load",
"pyrender.Scene",
"temp_prox.optimizers.optim_factory.create_optimizer",
... | [((15875, 15913), 'numpy.concatenate', 'np.concatenate', (['contact_fric_verts_ids'], {}), '(contact_fric_verts_ids)\n', (15889, 15913), True, 'import numpy as np\n'), ((19531, 20794), 'temp_prox.fitting_temp_slide.create_loss', 'fitting.create_loss', ([], {'loss_type': 'loss_type', 'joint_weights': 'joint_weights', 'r... |
"""
Push Sum Gossip Gradient Descent class for parallel optimization using column stochastic mixing.
:author: <NAME>
:description: Distributed otpimization using column stochastic mixing and greedy gradient descent.
Based on the paper (nedich2015distributed)
"""
import time
import numpy as np
from .go... | [
"numpy.random.randn",
"numpy.random.seed",
"time.time"
] | [((5484, 5495), 'time.time', 'time.time', ([], {}), '()\n', (5493, 5495), False, 'import time\n'), ((7341, 7365), 'numpy.random.seed', 'np.random.seed', ([], {'seed': 'UID'}), '(seed=UID)\n', (7355, 7365), True, 'import numpy as np\n'), ((7384, 7416), 'numpy.random.randn', 'np.random.randn', (['num_features', '(1)'], {... |
from django.contrib.auth.models import Group
from django.db import models
class GroupInfo(models.Model):
"""
Group Information
"""
group = models.OneToOneField(
Group,
verbose_name="그룹",
primary_key=True,
null=False,
on_delete=models.PROTECT,
related_nam... | [
"django.db.models.OneToOneField",
"django.db.models.IntegerField"
] | [((157, 289), 'django.db.models.OneToOneField', 'models.OneToOneField', (['Group'], {'verbose_name': '"""그룹"""', 'primary_key': '(True)', 'null': '(False)', 'on_delete': 'models.PROTECT', 'related_name': '"""groupInfo"""'}), "(Group, verbose_name='그룹', primary_key=True, null=False,\n on_delete=models.PROTECT, relate... |
from copy import copy
from collections import ChainMap
from collections.abc import Collection, Iterable
from functools import lru_cache
import logging
import os
from pathlib import Path, PurePosixPath
import re
from types import SimpleNamespace
from warnings import warn
import jpype
from jpype import JClass
import num... | [
"ixmp.utils.as_str_list",
"jpype.isJVMStarted",
"ixmp.utils.islistable",
"jpype.JClass",
"copy.copy",
"re.match",
"ixmp.utils.filtered",
"pathlib.Path",
"numpy.array",
"jpype.getDefaultJVMPath",
"ixmp.config.get_platform_info",
"collections.ChainMap",
"warnings.warn",
"functools.lru_cache"... | [((524, 551), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (541, 551), False, 'import logging\n'), ((851, 868), 'types.SimpleNamespace', 'SimpleNamespace', ([], {}), '()\n', (866, 868), False, 'from types import SimpleNamespace\n'), ((30057, 30069), 'functools.lru_cache', 'lru_cache', (... |
import itertools
import operator
import unittest
from functools import reduce, lru_cache
from pytoolz.tools import apply, merge, assoc, dissoc, merge_with, \
merge_with_default, assoc_in, update_in, terminal_dict, \
windows, append, explode, conj, first, nth, rest, reductions, take, \
iterate, drop, get, D... | [
"pytoolz.tools.windows",
"pytoolz.tools.assoc",
"pytoolz.tools.reductions",
"pytoolz.tools.explode",
"unittest.main",
"pytoolz.tools.merge_with_default",
"pytoolz.tools.first",
"pytoolz.tools.get",
"pytoolz.tools.nth",
"pytoolz.tools.Dispatch",
"pytoolz.tools.iterate",
"pytoolz.tools.terminal_... | [((17858, 17873), 'unittest.main', 'unittest.main', ([], {}), '()\n', (17871, 17873), False, 'import unittest\n'), ((1147, 1157), 'pytoolz.tools.merge', 'merge', (['*ds'], {}), '(*ds)\n', (1152, 1157), False, 'from pytoolz.tools import apply, merge, assoc, dissoc, merge_with, merge_with_default, assoc_in, update_in, te... |
import turtle as t
def rectangle(horizontal, vertical, color):
t.pendown()
t.pensize(1)
t.color(color)
t.begin_fill()
for counter in range(1, 3):
t.forward(horizontal)
t.right(90)
t.forward(vertical)
t.right(90)
t.end_fill()
t.penup()
t.speed('very-slow')... | [
"turtle.pensize",
"turtle.end_fill",
"turtle.speed",
"turtle.bgcolor",
"turtle.forward",
"turtle.color",
"turtle.setheading",
"turtle.begin_fill",
"turtle.right",
"turtle.penup",
"turtle.goto",
"turtle.hideturtle",
"turtle.left",
"turtle.pendown"
] | [((633, 651), 'turtle.goto', 't.goto', (['(-100)', '(-150)'], {}), '(-100, -150)\n', (639, 651), True, 'import turtle as t\n'), ((682, 699), 'turtle.goto', 't.goto', (['(-30)', '(-150)'], {}), '(-30, -150)\n', (688, 699), True, 'import turtle as t\n'), ((734, 750), 'turtle.goto', 't.goto', (['(-25)', '(-50)'], {}), '(-... |
import os
import aiofiles
import yaml
import click
import asyncio
from datetime import datetime
from models.user import create_user
from models import Post, User
def run_async(coro):
asyncio.run(coro)
@click.group()
def cli():
...
async def _adduser(**kwargs):
try:
user = await create_user(**kwar... | [
"yaml.load",
"models.Post.acreate",
"aiofiles.open",
"models.Post.async_first",
"models.user.create_user",
"click.option",
"click.echo",
"asyncio.run",
"models.User.async_first",
"click.group",
"datetime.datetime.now",
"os.listdir"
] | [((208, 221), 'click.group', 'click.group', ([], {}), '()\n', (219, 221), False, 'import click\n'), ((2318, 2368), 'click.option', 'click.option', (['"""--name"""'], {'required': '(True)', 'prompt': '(True)'}), "('--name', required=True, prompt=True)\n", (2330, 2368), False, 'import click\n'), ((2370, 2436), 'click.opt... |
"""Cardiff_Web URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/1.11/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: url(r'^$', views.home, name='home')
Clas... | [
"django.conf.urls.url"
] | [((752, 776), 'django.conf.urls.url', 'url', (['"""^$"""', 'views.default'], {}), "('^$', views.default)\n", (755, 776), False, 'from django.conf.urls import url\n'), ((783, 807), 'django.conf.urls.url', 'url', (['"""^repo"""', 'views.repo'], {}), "('^repo', views.repo)\n", (786, 807), False, 'from django.conf.urls imp... |
import sys
import os, glob
# 파일명에 번호 추가하기
def rename_file():
count = 1
dir_name = input('번호처리 할 디렉토리명을 입력하시오: ')
current_dir_path = '[your_current_directory includes png files folder]'
rename_files_path = current_dir_path + '/' + dir_name
# 파일 이름을 변경하기 위해 path 등록
os.makedirs(os.path.dirname(re... | [
"os.rename",
"os.path.dirname",
"os.path.join",
"glob.glob"
] | [((385, 424), 'glob.glob', 'glob.glob', (["(rename_files_path + '/*.png')"], {}), "(rename_files_path + '/*.png')\n", (394, 424), False, 'import os, glob\n'), ((302, 336), 'os.path.dirname', 'os.path.dirname', (['rename_files_path'], {}), '(rename_files_path)\n', (317, 336), False, 'import os, glob\n'), ((704, 745), 'o... |
from flask import Flask, render_template, request
from flask_sqlalchemy import SQLAlchemy
from send_email import send_email
from sqlalchemy.sql import func
app = Flask(__name__)
#app.config['SQLALCHEMY_DATABASE_URI'] = 'postgresql://postgres:postgres123@localhost/Height_collector'
app.config['SQLALCHEMY_DATABAS... | [
"flask.Flask",
"sqlalchemy.sql.func.avg",
"flask_sqlalchemy.SQLAlchemy",
"send_email.send_email",
"flask.render_template"
] | [((168, 183), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (173, 183), False, 'from flask import Flask, render_template, request\n'), ((507, 522), 'flask_sqlalchemy.SQLAlchemy', 'SQLAlchemy', (['app'], {}), '(app)\n', (517, 522), False, 'from flask_sqlalchemy import SQLAlchemy\n'), ((871, 900), 'flask.re... |
#!/usr/bin/env python
import os
import json
import pickle
import sys
import traceback
import pandas as pd
import datetime
from pathlib import Path
import logging
import inspect
os.environ["CUDA_DEVICE_ORDER"]="PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"]="0"
import torch
from transformers import AutoTokenizer
cur... | [
"json.dump",
"json.load",
"datetime.datetime.today",
"os.path.dirname",
"logging.StreamHandler",
"sys.path.insert",
"logging.getLogger",
"torch.cuda.device_count",
"pathlib.Path",
"traceback.format_exc",
"torch.device",
"inspect.currentframe",
"os.path.join",
"sys.exit"
] | [((416, 443), 'os.path.dirname', 'os.path.dirname', (['currentdir'], {}), '(currentdir)\n', (431, 443), False, 'import os\n'), ((461, 487), 'os.path.dirname', 'os.path.dirname', (['parentdir'], {}), '(parentdir)\n', (476, 487), False, 'import os\n'), ((488, 522), 'sys.path.insert', 'sys.path.insert', (['(0)', 'grandpar... |
import logging
import os
from collections import defaultdict
from pathlib import Path
from multiprocessing import Pool, cpu_count
import librosa
import numpy as np
from python_speech_features import fbank
from tqdm import tqdm
from constants import SAMPLE_RATE, NUM_FBANKS
from utils import find_files, ensures_dir
log... | [
"numpy.abs",
"utils.find_files",
"collections.defaultdict",
"pathlib.Path",
"os.path.isfile",
"numpy.mean",
"utils.ensures_dir",
"os.path.join",
"multiprocessing.cpu_count",
"numpy.std",
"os.path.exists",
"librosa.core.frames_to_samples",
"librosa.feature.rms",
"numpy.save",
"numpy.perce... | [((326, 353), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (343, 353), False, 'import logging\n'), ((465, 478), 'numpy.abs', 'np.abs', (['audio'], {}), '(audio)\n', (471, 478), True, 'import numpy as np\n'), ((503, 528), 'numpy.percentile', 'np.percentile', (['energy', '(95)'], {}), '(e... |
from collections import defaultdict
import graphviz
import pandas as pd
from sklearn import tree
from project3.decision_tree import DecisionTree
def pre_processing(filepath: str) -> tuple[pd.DataFrame, dict]:
data = []
attrs = defaultdict(list)
dtypes = dict()
with open(filepath, mode='r') as fin:
... | [
"pandas.DataFrame",
"sklearn.tree.DecisionTreeClassifier",
"sklearn.tree.export_graphviz",
"collections.defaultdict",
"project3.decision_tree.DecisionTree",
"graphviz.Source",
"pandas.api.types.is_string_dtype"
] | [((239, 256), 'collections.defaultdict', 'defaultdict', (['list'], {}), '(list)\n', (250, 256), False, 'from collections import defaultdict\n'), ((1202, 1220), 'pandas.DataFrame', 'pd.DataFrame', (['data'], {}), '(data)\n', (1214, 1220), True, 'import pandas as pd\n'), ((1779, 1801), 'project3.decision_tree.DecisionTre... |
import logging.config
import os
import gridfs
from cert_core.cert_store.gridfs_key_value_store import GridfsKeyValueStore
from pymongo import MongoClient
from simplekv.fs import FilesystemStore
from cert_core.cert_store.certificate_store import CertificateStore
from cert_core.cert_store.certificate_store import V1Awa... | [
"pymongo.MongoClient",
"simplekv.fs.FilesystemStore",
"gridfs.GridFS",
"os.path.dirname",
"cert_core.cert_store.gridfs_key_value_store.GridfsKeyValueStore",
"cert_core.cert_store.certificate_store.V1AwareCertificateStore",
"cert_core.cert_store.certificate_store.CertificateStore",
"os.path.join"
] | [((646, 689), 'pymongo.MongoClient', 'MongoClient', ([], {'host': 'configuration.mongodb_uri'}), '(host=configuration.mongodb_uri)\n', (657, 689), False, 'from pymongo import MongoClient\n'), ((398, 423), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (413, 423), False, 'import os\n'), ((533,... |
import h5py
from keras.models import Model
from keras.layers import Input, Convolution2D, MaxPooling2D, Dropout, GlobalAveragePooling2D, merge, Activation, ZeroPadding2D
from keras.layers import AveragePooling2D, Flatten
from keras.layers.normalization import BatchNormalization
def FireModule(s_1x1, e_1x1, e_3x3, name... | [
"keras.layers.Convolution2D",
"keras.layers.Activation",
"keras.layers.Dropout",
"keras.models.Model",
"keras.layers.GlobalAveragePooling2D",
"keras.layers.Input",
"keras.layers.MaxPooling2D",
"keras.layers.merge",
"keras.layers.normalization.BatchNormalization"
] | [((1859, 1883), 'keras.layers.Input', 'Input', ([], {'shape': 'input_shape'}), '(shape=input_shape)\n', (1864, 1883), False, 'from keras.layers import Input, Convolution2D, MaxPooling2D, Dropout, GlobalAveragePooling2D, merge, Activation, ZeroPadding2D\n'), ((4130, 4172), 'keras.models.Model', 'Model', ([], {'input': '... |
import discord
from ..admin.managecommands import perms
import json
from discord.utils import get
from pymongo import MongoClient, collation
from discord.ext import commands, tasks
import time
import os
import pymongo as pm
import math
import random
import re
import asyncio
class DND(commands.Cog):
def __init__(s... | [
"discord.ext.commands.command",
"random.randint",
"discord.ext.commands.has_permissions",
"discord.ext.commands.check",
"discord.ext.commands.Cog.listener",
"discord.PermissionOverwrite"
] | [((375, 398), 'discord.ext.commands.Cog.listener', 'commands.Cog.listener', ([], {}), '()\n', (396, 398), False, 'from discord.ext import commands, tasks\n'), ((2004, 2055), 'discord.ext.commands.command', 'commands.command', ([], {'pass_context': '(True)', 'aliases': "['df']"}), "(pass_context=True, aliases=['df'])\n"... |
import sys
import unittest
from mock_decorators.mock_sys_output import MockSysOutput
class TestMockIORedirect(unittest.TestCase):
def test_stdout_redirect(self):
if sys.version_info < (3, 0):
from StringIO import StringIO
else:
from io import StringIO
output = Str... | [
"io.StringIO",
"mock_decorators.mock_sys_output.MockSysOutput",
"mock_decorators.mock_sys_output.MockSysOutput._stdout_redirect"
] | [((317, 327), 'io.StringIO', 'StringIO', ([], {}), '()\n', (325, 327), False, 'from io import StringIO\n'), ((1001, 1011), 'io.StringIO', 'StringIO', ([], {}), '()\n', (1009, 1011), False, 'from io import StringIO\n'), ((1091, 1112), 'mock_decorators.mock_sys_output.MockSysOutput', 'MockSysOutput', (['output'], {}), '(... |
import tkinter
import cv2
import PIL.Image, PIL.ImageTk
import time
import numpy as np
import RPi.GPIO as GPIO
import mpv
import sys
import os
import serial
from time import sleep
import picamera
import io
#Initialization
#webcam/blindspot
capleft = ""
capright = ""
all_Cam_Off = 1
left_Camera_On ... | [
"numpy.floor",
"cv2.imdecode",
"cv2.adaptiveThreshold",
"mpv.MPV",
"cv2.rectangle",
"serial.Serial",
"numpy.full",
"cv2.contourArea",
"RPi.GPIO.setup",
"cv2.cvtColor",
"cv2.ml.KNearest_create",
"tkinter.Button",
"numpy.append",
"numpy.loadtxt",
"os.fork",
"tkinter.Tk",
"cv2.resize",
... | [((402, 435), 'mpv.MPV', 'mpv.MPV', ([], {'start_event_thread': '(False)'}), '(start_event_thread=False)\n', (409, 435), False, 'import mpv\n'), ((477, 611), 'serial.Serial', 'serial.Serial', (['"""/dev/ttyAMA0"""', '(9600)'], {'timeout': '(4)', 'parity': 'serial.PARITY_NONE', 'stopbits': 'serial.STOPBITS_ONE', 'bytesi... |
from django.urls import path
from . import views
app_name = 'social'
urlpatterns = [
path('', views.index, name='index'),
path('follow/<int:pk>', views.follow, name='follow'),
path('cards/<int:pk>', views.cards, name="social_cards"),
path('decks/<int:pk>', views.decks, name="social_decks"),
path('b... | [
"django.urls.path"
] | [((90, 125), 'django.urls.path', 'path', (['""""""', 'views.index'], {'name': '"""index"""'}), "('', views.index, name='index')\n", (94, 125), False, 'from django.urls import path\n'), ((131, 183), 'django.urls.path', 'path', (['"""follow/<int:pk>"""', 'views.follow'], {'name': '"""follow"""'}), "('follow/<int:pk>', vi... |
"""
@file test_level_medium.py
"""
from Voltron.Algorithms.level_medium import (
# In order of usage or appearance.
smallest_difference,
three_number_sum,
three_number_sum_with_sorted_array,
move_element_to_end,
is_monotonic,
spiral_traverse,
_find_peaks,
_find_peak_length,
long... | [
"Voltron.Algorithms.level_medium.smallest_difference",
"Voltron.Algorithms.level_medium.move_element_to_end",
"Voltron.Algorithms.level_medium.longest_peak",
"Voltron.Algorithms.level_medium.three_number_sum",
"Voltron.Algorithms.level_medium.remove_islands",
"Voltron.Algorithms.level_medium.is_monotonic"... | [((488, 529), 'Voltron.Algorithms.level_medium.smallest_difference', 'smallest_difference', (['array_one', 'array_two'], {}), '(array_one, array_two)\n', (507, 529), False, 'from Voltron.Algorithms.level_medium import smallest_difference, three_number_sum, three_number_sum_with_sorted_array, move_element_to_end, is_mon... |
from django.contrib import admin
from .models import Cache
@admin.register(Cache)
class CacheAdmin(admin.ModelAdmin):
list_display = ('defined_storage_name', 'maximum_size')
| [
"django.contrib.admin.register"
] | [((68, 89), 'django.contrib.admin.register', 'admin.register', (['Cache'], {}), '(Cache)\n', (82, 89), False, 'from django.contrib import admin\n')] |
import random
with open("england_junk.csv") as fr:
with open("england_test.csv", "a") as f1, open("england_validation.csv", "a") as f2:
for line in fr.readlines():
rd = random.randint(1, 2)
f = f1 if rd == 1 else f2
f.write(line)
| [
"random.randint"
] | [((194, 214), 'random.randint', 'random.randint', (['(1)', '(2)'], {}), '(1, 2)\n', (208, 214), False, 'import random\n')] |
import logging
import django
from contact_form.forms import ContactForm
from django import forms
from django.conf import settings
from django.contrib.sites.models import Site
from django.utils.encoding import force_bytes
from pykismet3 import Akismet, AkismetServerError
logger = logging.getLogger(__name__)
class Ba... | [
"django.utils.encoding.force_bytes",
"django.contrib.sites.models.Site.objects.get_current",
"django.forms.TextInput",
"logging.getLogger",
"django.forms.ValidationError",
"django.forms.Textarea"
] | [((282, 309), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (299, 309), False, 'import logging\n'), ((426, 504), 'django.forms.TextInput', 'forms.TextInput', ([], {'attrs': "{'class': 'required', 'placeholder': 'Message subject'}"}), "(attrs={'class': 'required', 'placeholder': 'Message ... |
from djitellopy import Tello
tello=Tello()
tello.connect()
tello.streamon()
frame_read=tello.get_frame_read()
import cv2
while True:
cv2.imshow('tello stream', frame_read.frame)
key=cv2.waitKey(1)
if key==ord('q'):
break
tello.streamoff()
pass | [
"cv2.waitKey",
"cv2.imshow",
"djitellopy.Tello"
] | [((36, 43), 'djitellopy.Tello', 'Tello', ([], {}), '()\n', (41, 43), False, 'from djitellopy import Tello\n'), ((140, 184), 'cv2.imshow', 'cv2.imshow', (['"""tello stream"""', 'frame_read.frame'], {}), "('tello stream', frame_read.frame)\n", (150, 184), False, 'import cv2\n'), ((193, 207), 'cv2.waitKey', 'cv2.waitKey',... |
#!/usr/bin/env python3
# -*-coding:utf-8 -*
import os
import wx
application = wx.App()
frame = wx.Frame(None)
frame.SetIcon(wx.Icon(os.path.join(os.path.dirname(os.path.abspath(__file__)), "Resources", "Gammasoft.ico")))
frame.Show()
application.MainLoop()
| [
"wx.Frame",
"os.path.abspath",
"wx.App"
] | [((80, 88), 'wx.App', 'wx.App', ([], {}), '()\n', (86, 88), False, 'import wx\n'), ((97, 111), 'wx.Frame', 'wx.Frame', (['None'], {}), '(None)\n', (105, 111), False, 'import wx\n'), ((163, 188), 'os.path.abspath', 'os.path.abspath', (['__file__'], {}), '(__file__)\n', (178, 188), False, 'import os\n')] |
from django.test import TestCase
from django.test.client import Client
from django.core.urlresolvers import reverse
from django.conf import settings
import base64, json
class FHIR_Create_TestCase(TestCase):
"""
Test FHIR Create
"""
#auth_headers = {"HTTP_AUTHORIZATION": "Basic "+base64.b64en... | [
"django.test.client.Client",
"base64.b64encode",
"django.core.urlresolvers.reverse",
"json.loads"
] | [((597, 631), 'base64.b64encode', 'base64.b64encode', (['self.credentials'], {}), '(self.credentials)\n', (613, 631), False, 'import base64, json\n'), ((718, 726), 'django.test.client.Client', 'Client', ([], {}), '()\n', (724, 726), False, 'from django.test.client import Client\n'), ((907, 957), 'django.core.urlresolve... |
# (C) Copyright 2020- ECMWF.
# This software is licensed under the terms of the Apache Licence Version 2.0
# which can be obtained at http://www.apache.org/licenses/LICENSE-2.0.
# In applying this licence, ECMWF does not waive the privileges and immunities granted to it by
# virtue of its status as an intergovernment... | [
"re.finditer",
"importlib.import_module"
] | [((568, 608), 're.finditer', 're.finditer', (['"""\\\\[[^[]*\\\\]"""', 'self.pattern'], {}), "('\\\\[[^[]*\\\\]', self.pattern)\n", (579, 608), False, 'import re\n'), ((1382, 1413), 'importlib.import_module', 'importlib.import_module', (['module'], {}), '(module)\n', (1405, 1413), False, 'import importlib\n')] |
import difflib
import os
import shutil
import subprocess
import sys
import time
import numpy as np
from PyQt5.QtCore import Qt
from PyQt5.QtWidgets import *
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
from matplotlib.figure import Figure
from threading import Thread
# slash = '/' ... | [
"os.listdir",
"os.mkdir",
"numpy.zeros_like",
"numpy.sum",
"shutil.rmtree",
"os.getcwd",
"os.path.isdir",
"subprocess.check_output",
"os.path.exists",
"numpy.zeros",
"time.time",
"numpy.append",
"os.path.isfile",
"matplotlib.figure.Figure",
"numpy.array",
"matplotlib.backends.backend_q... | [((24478, 24489), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (24487, 24489), False, 'import os\n'), ((483, 521), 'numpy.sum', 'np.sum', (['self.matrix_time[mask]'], {'axis': '(0)'}), '(self.matrix_time[mask], axis=0)\n', (489, 521), True, 'import numpy as np\n'), ((2571, 2583), 'numpy.array', 'np.array', (['[]'], {}),... |
import sqlite3
import os
question_separator = "-" * 80
# rpg_db.sqlite3
DB_FILEPATH = os.path.join(os.path.dirname(__file__), "rpg_db.sqlite3")
conn = sqlite3.connect(DB_FILEPATH)
conn.row_factory = sqlite3.Row
cursor = conn.cursor()
print(question_separator)
print("How many total Characters are there")
query = """
... | [
"os.path.dirname",
"sqlite3.connect"
] | [((153, 181), 'sqlite3.connect', 'sqlite3.connect', (['DB_FILEPATH'], {}), '(DB_FILEPATH)\n', (168, 181), False, 'import sqlite3\n'), ((100, 125), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (115, 125), False, 'import os\n')] |
# -*- coding: utf-8 -*-
# Author: <NAME> <<EMAIL>>
# Copyright (C) 2016-2016
# URL: <http://github.com/heltondoria/information_retrival>
# For license information, see LICENSE.TXT
"""
Module that contains classes responsible for tokenize strings
"""
from abc import ABCMeta, abstractmethod
from nltk import RegexpTokeni... | [
"nltk.RegexpTokenizer",
"nltk.corpus.stopwords.words"
] | [((1123, 1146), 'nltk.RegexpTokenizer', 'RegexpTokenizer', (['"""\\\\w+"""'], {}), "('\\\\w+')\n", (1138, 1146), False, 'from nltk import RegexpTokenizer, corpus\n'), ((1176, 1209), 'nltk.corpus.stopwords.words', 'corpus.stopwords.words', (['"""english"""'], {}), "('english')\n", (1198, 1209), False, 'from nltk import ... |
# -*- coding: utf-8 -*-
# Generated by Django 1.10 on 2017-05-04 03:21
from __future__ import unicode_literals
from django.db import migrations
def migrate_markdown_to_richtext(apps, schema_editor):
Announcement = apps.get_model("base", "Announcement")
for ann in Announcement.objects.all():
ann.ccon... | [
"django.db.migrations.RunPython"
] | [((503, 553), 'django.db.migrations.RunPython', 'migrations.RunPython', (['migrate_markdown_to_richtext'], {}), '(migrate_markdown_to_richtext)\n', (523, 553), False, 'from django.db import migrations\n')] |
class Solution(object):
def searchRange(self, nums, target):
"""
:type nums: List[int]
:type target: int
:rtype: List[int]
"""
count = 0
first_position = -1
last_position = -1
if target in nums:
first_position = nums.index(target)
... | [
"unittest.main"
] | [((914, 929), 'unittest.main', 'unittest.main', ([], {}), '()\n', (927, 929), False, 'import unittest\n')] |
from django.contrib import admin
from django.utils.translation import gettext_lazy as _
from cms.utils.conf import get_cms_setting
from cms.utils.i18n import get_language_tuple, get_site_language_from_request
from djangocms_versioning.constants import UNPUBLISHED
class LanguageFilter(admin.SimpleListFilter):
ti... | [
"cms.utils.i18n.get_site_language_from_request",
"cms.utils.i18n.get_language_tuple",
"cms.utils.conf.get_cms_setting",
"django.utils.translation.gettext_lazy"
] | [((326, 339), 'django.utils.translation.gettext_lazy', '_', (['"""language"""'], {}), "('language')\n", (327, 339), True, 'from django.utils.translation import gettext_lazy as _\n'), ((1272, 1288), 'django.utils.translation.gettext_lazy', '_', (['"""unpublished"""'], {}), "('unpublished')\n", (1273, 1288), True, 'from ... |
import time
class Timer:
def get_week(self):
now_time = time.localtime()
now_week = now_time.tm_wday
return now_week
def get_now_hour(self):
now_time = time.localtime()
now_hour = now_time.tm_hour
return now_hour
def get_next_hour(self):
now_time =... | [
"time.strftime",
"time.localtime"
] | [((70, 86), 'time.localtime', 'time.localtime', ([], {}), '()\n', (84, 86), False, 'import time\n'), ((195, 211), 'time.localtime', 'time.localtime', ([], {}), '()\n', (209, 211), False, 'import time\n'), ((321, 337), 'time.localtime', 'time.localtime', ([], {}), '()\n', (335, 337), False, 'import time\n'), ((553, 569)... |
#-*- coding: utf-8 -*-
#For Flask-Alchemy
#使用SqlAutocode，根据数据库已有表，产生符合Flask-SqlAlchemy要求的models的定义
import os.path
from sqlautocode.declarative import name2label
from flask.ext.sqlalchemy import SQLAlchemy
from .flask_factory import FlaskModelFactory
def no_prefix_wrapper(f, prefix=None):
def _name2label(name, sc... | [
"flask.ext.sqlalchemy.SQLAlchemy"
] | [((2050, 2065), 'flask.ext.sqlalchemy.SQLAlchemy', 'SQLAlchemy', (['app'], {}), '(app)\n', (2060, 2065), False, 'from flask.ext.sqlalchemy import SQLAlchemy\n')] |
# -*- coding: utf-8 -*-
"""
Created on Thu Mar 21 10:50:52 2019
"""
import nltk
import sklearn
import re
from nltk.stem.snowball import SnowballStemmer
stemmer = SnowballStemmer("english")
stopwords = nltk.corpus.stopwords.words('english')
def tokenize_and_stem(text):
# first tokenize by sentence, ... | [
"nltk.stem.snowball.SnowballStemmer",
"nltk.sent_tokenize",
"nltk.corpus.stopwords.words",
"re.search",
"nltk.word_tokenize"
] | [((174, 200), 'nltk.stem.snowball.SnowballStemmer', 'SnowballStemmer', (['"""english"""'], {}), "('english')\n", (189, 200), False, 'from nltk.stem.snowball import SnowballStemmer\n'), ((214, 252), 'nltk.corpus.stopwords.words', 'nltk.corpus.stopwords.words', (['"""english"""'], {}), "('english')\n", (241, 252), False,... |
"""
Preprocessing functions.
"""
import numpy as np
import scipy as sp
import nutsml.imageutil as ni
from nutsflow import *
from constants import C, H, W, H_TOP, H_BOTTOM
def flatten_layers(image, order=2, verbose=False):
"""
:param ndarray image: gray scale image.
:param int order: Order of polynom fit... | [
"numpy.pad",
"nutsml.imageutil.gray2rgb",
"numpy.multiply",
"numpy.polyfit",
"numpy.zeros",
"nutsml.imageutil.resize",
"scipy.ndimage.zoom",
"numpy.hstack",
"numpy.isnan",
"numpy.nonzero",
"numpy.mean",
"numpy.vstack"
] | [((802, 825), 'numpy.multiply', 'np.multiply', (['mask', 'idxs'], {}), '(mask, idxs)\n', (813, 825), True, 'import numpy as np\n'), ((1177, 1218), 'numpy.hstack', 'np.hstack', (['[xs[0:d], xs[ncols - d:ncols]]'], {}), '([xs[0:d], xs[ncols - d:ncols]])\n', (1186, 1218), True, 'import numpy as np\n'), ((1229, 1270), 'num... |
import webbrowser
from threading import Timer
from flask import Flask, send_from_directory
from generate.constants import SITE_DIRECTORY
app = Flask(__name__)
app.config["SEND_FILE_MAX_AGE_DEFAULT"] = 0
@app.route("/<path:path>")
def local(path):
return send_from_directory(SITE_DIRECTORY, path)
def open_brow... | [
"webbrowser.open_new_tab",
"flask.send_from_directory",
"flask.Flask",
"argparse.ArgumentParser"
] | [((146, 161), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (151, 161), False, 'from flask import Flask, send_from_directory\n'), ((263, 304), 'flask.send_from_directory', 'send_from_directory', (['SITE_DIRECTORY', 'path'], {}), '(SITE_DIRECTORY, path)\n', (282, 304), False, 'from flask import Flask, send... |
# -*- coding: UTF-8 -*-
# File Name：neural_network
# Author : <NAME>
# Date：2019/2/28
# Description : 神经网络TensorFlow keras代码实现
__author__ = '<NAME>'
import tensorflow as tf
from tensorflow.examples.tutorials.mnist import input_data
mnist = input_data.read_data_sets("data/", one_hot=True)
# 设置参数
learning_rate = 0.1
nu... | [
"tensorflow.keras.layers.Dense",
"tensorflow.keras.Input",
"tensorflow.keras.Model",
"tensorflow.keras.optimizers.Adam",
"tensorflow.examples.tutorials.mnist.input_data.read_data_sets"
] | [((242, 290), 'tensorflow.examples.tutorials.mnist.input_data.read_data_sets', 'input_data.read_data_sets', (['"""data/"""'], {'one_hot': '(True)'}), "('data/', one_hot=True)\n", (267, 290), False, 'from tensorflow.examples.tutorials.mnist import input_data\n'), ((746, 780), 'tensorflow.keras.Input', 'tf.keras.Input', ... |
import random
from running_median.example import compute_median
def generate_samples(samples):
return (random.randint(0, 1000) for _ in range(samples))
def main(samples, window_size, check=False, display=1000):
compute_median(generate_samples(samples), window_size, check, display)
if __name__ == "__main_... | [
"random.randint"
] | [((110, 133), 'random.randint', 'random.randint', (['(0)', '(1000)'], {}), '(0, 1000)\n', (124, 133), False, 'import random\n')] |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
import cv2
import numpy as np
# 找图 返回最近似的点
def search_img(img, template, threshold=0.9, debug=False, gray=0):
"""
在大图中找小图
:param img: 大图
:param template: 小图
:param threshold: 相似度 1为完美 -1为最差
:param debug: 是否显示图片匹配情况，True会框选出匹配项
:param gray: 是... | [
"cv2.cvtColor",
"cv2.waitKey",
"cv2.imread",
"numpy.where",
"cv2.rectangle",
"cv2.imshow",
"cv2.matchTemplate"
] | [((464, 493), 'cv2.cvtColor', 'cv2.cvtColor', (['img', 'color_mode'], {}), '(img, color_mode)\n', (476, 493), False, 'import cv2\n'), ((509, 543), 'cv2.cvtColor', 'cv2.cvtColor', (['template', 'color_mode'], {}), '(template, color_mode)\n', (521, 543), False, 'import cv2\n'), ((557, 611), 'cv2.matchTemplate', 'cv2.matc... |
"""
Helper file containing setup/teardown relevant functions, as well as some common testing constructs.
"""
import os as _os
import sys as _sys
import time as _time
import asyncio as _asyncio
import threading as _threading
import random as _random
import string as _string
import typing as _typing
import discord as _di... | [
"os.getenv",
"inspect.iscoroutinefunction",
"asyncio.gather",
"asyncio.get_event_loop",
"asyncio.sleep",
"dof_discord_bot.src.logger.Log.info",
"os.path.dirname",
"pytest.exit",
"random.choice",
"time.time",
"time.sleep",
"asyncio.run_coroutine_threadsafe",
"discord.ext.commands.Bot",
"dof... | [((942, 987), 'os.path.join', '_os.path.join', (['TESTS_DIR', '"""integration_tests"""'], {}), "(TESTS_DIR, 'integration_tests')\n", (955, 987), True, 'import os as _os\n'), ((998, 1029), 'os.path.join', '_os.path.join', (['TESTS_DIR', '"""log"""'], {}), "(TESTS_DIR, 'log')\n", (1011, 1029), True, 'import os as _os\n')... |
#!/usr/bin/env python3
import itertools
import sys
# Functions
def sumitup(numbers, target):
count = 0
results = set()
for length in range(1, len(numbers) + 1):
for combination in itertools.combinations(numbers, length):
if sum(combination) == target and combination not in results:... | [
"itertools.combinations"
] | [((206, 245), 'itertools.combinations', 'itertools.combinations', (['numbers', 'length'], {}), '(numbers, length)\n', (228, 245), False, 'import itertools\n')] |
import numpy as np
def get_sonic_specific_actions():
buttons = ["B", "A", "MODE", "START", "UP", "DOWN", "LEFT", "RIGHT", "C", "Y", "X", "Z"]
actions = [['LEFT'], ['RIGHT'], ['LEFT', 'DOWN'], ['RIGHT', 'DOWN'], ['DOWN'],
['DOWN', 'B'], ['B'], [], ['LEFT', 'B'], ['RIGHT', 'B']]
_actions = []... | [
"numpy.array"
] | [((362, 384), 'numpy.array', 'np.array', (['([False] * 12)'], {}), '([False] * 12)\n', (370, 384), True, 'import numpy as np\n')] |
import sys
sys.path.insert(0, '.')
from unidef.__main__ import *
def try_parse(fm, to):
args = parser.parse_args([f'examples/{fm}', '-l', 'javascript', '-t', to])
config = CommandLineConfig.from_args(args)
main(config, open(args.file).read())
def test_parse_js():
for target in ['rust_lang']:
... | [
"sys.path.insert"
] | [((12, 35), 'sys.path.insert', 'sys.path.insert', (['(0)', '"""."""'], {}), "(0, '.')\n", (27, 35), False, 'import sys\n')] |
import os
import tensorflow as tf
from tensorflow.keras.models import load_model, Model
from unit_test.helper import save_config, get_test_item_mean_std
from converter.converter import conver_model
from converter.model_adaptation import adapt_keras_model
from optimization.optimize_graph import apply_transformations, ch... | [
"optimization.optimize_graph.check_transform",
"tensorflow.keras.models.load_model",
"argparse.ArgumentParser",
"converter.converter.conver_model",
"converter.model_adaptation.adapt_keras_model",
"unit_test.helper.get_test_item_mean_std",
"os.path.dirname",
"os.path.basename",
"optimization.optimize... | [((772, 833), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Process some integers."""'}), "(description='Process some integers.')\n", (795, 833), False, 'import argparse\n'), ((2107, 2144), 'optimization.optimize_graph.apply_transformations', 'apply_transformations', (['keras_model_in']... |
# The MIT License (MIT)
# Copyright (c) 2016, 2017 by the ESA CCI Toolbox development team and contributors
#
# Permission is hereby granted, free of charge, to any person obtaining a copy of
# this software and associated documentation files (the "Software"), to deal in
# the Software without restriction, including wi... | [
"cate.core.op.op",
"fnmatch.filter",
"cate.core.types.VarNamesLike.convert",
"cate.core.op.op_input",
"cate.core.op.op_return",
"cate.core.types.DatasetLike.convert"
] | [((1421, 1455), 'cate.core.op.op', 'op', ([], {'tags': "['filter']", 'version': '"""1.0"""'}), "(tags=['filter'], version='1.0')\n", (1423, 1455), False, 'from cate.core.op import op, op_input, op_return\n'), ((1457, 1494), 'cate.core.op.op_input', 'op_input', (['"""ds"""'], {'data_type': 'DatasetLike'}), "('ds', data_... |
# -*- coding: utf-8 -*-
import logging
from datetime import datetime
from ipware import get_client_ip
from django.conf.urls import url, include
from django.conf import settings
from django.contrib.auth.models import Group
from django.contrib.auth import authenticate, login, logout
from django.db import connection # Use... | [
"ecommerce.serializers.PaymentEventSerializer",
"rest_framework.response.Response",
"ipware.get_client_ip"
] | [((1634, 1661), 'ipware.get_client_ip', 'get_client_ip', (['self.request'], {}), '(self.request)\n', (1647, 1661), False, 'from ipware import get_client_ip\n'), ((1715, 1820), 'ecommerce.serializers.PaymentEventSerializer', 'PaymentEventSerializer', ([], {'data': 'request.data', 'context': "{'from': client_ip, 'from_is... |
# -*- coding: utf-8 -*-
MAJOR = 0
MINOR = 1
PATCH = 2
#
__tool_name__ = "Artist Playblast"
__version__ = "v{}.{}.{}".format(MAJOR, MINOR, PATCH)
__release__ = __tool_name__ + __version__
#
import os
import sys
import platform
import getpass
import artistplayblast
from os.path import expanduser
from config.... | [
"maya.cmds.ToggleEvaluationManagerVisibility",
"getpass.getuser",
"maya.cmds.deleteUI",
"maya.cmds.playblast",
"maya.cmds.inViewMessage",
"maya.cmds.playbackOptions",
"os.path.join",
"maya.cmds.workspace",
"maya.cmds.ToggleFrameRate",
"os.path.expanduser",
"maya.cmds.fileDialog2",
"maya.cmds.l... | [((686, 711), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (701, 711), False, 'import os\n'), ((820, 837), 'platform.system', 'platform.system', ([], {}), '()\n', (835, 837), False, 'import platform\n'), ((852, 869), 'getpass.getuser', 'getpass.getuser', ([], {}), '()\n', (867, 869), False,... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
showcase paths
==============
This example shows how OMAS supports dynamic path crection using different syntaxes.
.. figure:: ../images/dynamic_path_testimonial.png
:align: center
:width: 100%
:alt: What people say about OMAS dynamic path creation
:target: ../... | [
"numpy.array"
] | [((2030, 2047), 'numpy.array', 'numpy.array', (['data'], {}), '(data)\n', (2041, 2047), False, 'import numpy\n'), ((2073, 2126), 'numpy.array', 'numpy.array', (['[1000.0, 2000.0, 3000.0, 4000.0, 5000.0]'], {}), '([1000.0, 2000.0, 3000.0, 4000.0, 5000.0])\n', (2084, 2126), False, 'import numpy\n'), ((2259, 2312), 'numpy... |
import random
import numpy as np
from PIL import Image
_plan_square = np.array([[0, 0], [1, 0], [0, 1], [1, 1]], dtype=np.float64)
_middle_point_coordinates = np.array([0.5, 0.5], dtype=np.float64)
def compute_perspective_params(plan_1, plan_2, width_, height_):
"""
Given the coordinates of the four corner... | [
"random.gauss",
"numpy.array"
] | [((74, 134), 'numpy.array', 'np.array', (['[[0, 0], [1, 0], [0, 1], [1, 1]]'], {'dtype': 'np.float64'}), '([[0, 0], [1, 0], [0, 1], [1, 1]], dtype=np.float64)\n', (82, 134), True, 'import numpy as np\n'), ((163, 201), 'numpy.array', 'np.array', (['[0.5, 0.5]'], {'dtype': 'np.float64'}), '([0.5, 0.5], dtype=np.float64)\... |
import os
import json
import unittest
import numpy as np
import pandas as pd
from komapy.chart import Chart
from komapy.cache import ResolverCache
from komapy.decorators import counter
from komapy.series import Series
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
FIXTURE_DIR = os.path.join(B... | [
"pandas.DataFrame",
"unittest.main",
"os.path.abspath",
"json.load",
"komapy.cache.ResolverCache",
"pandas.read_csv",
"komapy.cache.ResolverCache.get_resolver_cache_config",
"komapy.series.Series",
"komapy.cache.ResolverCache.create_instance_from_series",
"komapy.cache.ResolverCache.create_key_fro... | [((306, 340), 'os.path.join', 'os.path.join', (['BASE_DIR', '"""fixtures"""'], {}), "(BASE_DIR, 'fixtures')\n", (318, 340), False, 'import os\n'), ((453, 505), 'os.path.join', 'os.path.join', (['FIXTURE_DIR', '"""tiltmeter_selokopo.json"""'], {}), "(FIXTURE_DIR, 'tiltmeter_selokopo.json')\n", (465, 505), False, 'import... |
import os
import sys
import logging
import uvicorn
from starlette.applications import Starlette
from starlette.middleware.cors import CORSMiddleware
from starlette.responses import JSONResponse
from starlette.exceptions import HTTPException
import textract
import tempfile
logging.basicConfig(level=logging.INFO)
app ... | [
"tempfile.NamedTemporaryFile",
"starlette.applications.Starlette",
"logging.basicConfig",
"starlette.exceptions.HTTPException",
"starlette.responses.JSONResponse",
"os.environ.get",
"logging.info",
"os.path.splitext",
"textract.process"
] | [((275, 314), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (294, 314), False, 'import logging\n'), ((322, 333), 'starlette.applications.Starlette', 'Starlette', ([], {}), '()\n', (331, 333), False, 'from starlette.applications import Starlette\n'), ((1136, 115... |
"""The global configuration for the test suite"""
import atexit
import os
import shutil
import subprocess
import pytest
HERE = os.path.dirname(os.path.abspath(__file__))
DATAFILES_PATH = os.path.join(HERE, 'data')
# after we have run all tests, use git to delete the built files in data/
@pytest.fixture(scope='ses... | [
"os.path.abspath",
"subprocess.Popen",
"atexit.unregister",
"pytest.fixture",
"shutil.rmtree",
"os.path.join"
] | [((189, 215), 'os.path.join', 'os.path.join', (['HERE', '"""data"""'], {}), "(HERE, 'data')\n", (201, 215), False, 'import os\n'), ((295, 340), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""session"""', 'autouse': '(True)'}), "(scope='session', autouse=True)\n", (309, 340), False, 'import pytest\n'), ((145, 17... |
# -*- coding: utf-8 -*-
# Generated by Django 1.9.13 on 2018-01-15 15:43
from __future__ import unicode_literals
from django.db import migrations
def populate_m2m(apps, schema_editor):
ScriptParser = apps.get_model('wooey', 'ScriptParser')
ScriptParameterGroup = apps.get_model('wooey', 'ScriptParameterGroup'... | [
"django.db.migrations.RunPython"
] | [((661, 695), 'django.db.migrations.RunPython', 'migrations.RunPython', (['populate_m2m'], {}), '(populate_m2m)\n', (681, 695), False, 'from django.db import migrations\n')] |
import numpy as np
import imageio
import argparse
import glob
import os
np.seterr(invalid='ignore')
def make_grayscale(depth: np.ndarray) -> np.ndarray:
"""Get depth for grayscale images."""
depth_not_nan = depth[np.logical_not(np.isnan(depth))]
min_v = np.min(depth_not_nan)
max_v = np.max(depth_not_... | [
"numpy.stack",
"os.path.abspath",
"argparse.ArgumentParser",
"numpy.seterr",
"numpy.power",
"numpy.square",
"numpy.isnan",
"numpy.min",
"numpy.max",
"numpy.array",
"numpy.arange",
"glob.glob",
"os.path.join",
"numpy.sqrt"
] | [((73, 100), 'numpy.seterr', 'np.seterr', ([], {'invalid': '"""ignore"""'}), "(invalid='ignore')\n", (82, 100), True, 'import numpy as np\n'), ((269, 290), 'numpy.min', 'np.min', (['depth_not_nan'], {}), '(depth_not_nan)\n', (275, 290), True, 'import numpy as np\n'), ((303, 324), 'numpy.max', 'np.max', (['depth_not_nan... |
# SPDX-License-Identifier: Apache-2.0
#
# The OpenSearch Contributors require contributions made to
# this file be licensed under the Apache-2.0 license or a
# compatible open source license.
"""Provides functions for writing to file.
Functions:
get_file_obj(): Get a writeable file object.
write_json(): Writes... | [
"json.dump"
] | [((965, 1001), 'json.dump', 'json.dump', (['data', 'file'], {'indent': 'indent'}), '(data, file, indent=indent)\n', (974, 1001), False, 'import json\n')] |
from django.shortcuts import render, HttpResponse, render, redirect
from django.contrib.auth.forms import UserCreationForm
from django.forms import inlineformset_factory
from .forms import CreateUserForm, CreatengoForm
from django.contrib import messages
from django.contrib.auth.decorators import login_required
f... | [
"django.contrib.auth.decorators.login_required",
"django.shortcuts.redirect",
"django.contrib.auth.logout",
"django.contrib.messages.info",
"django.contrib.auth.authenticate",
"django.shortcuts.render",
"django.contrib.messages.success",
"django.contrib.auth.login",
"django.contrib.auth.models.Group... | [((3462, 3495), 'django.contrib.auth.decorators.login_required', 'login_required', ([], {'login_url': '"""login"""'}), "(login_url='login')\n", (3476, 3495), False, 'from django.contrib.auth.decorators import login_required\n'), ((4277, 4310), 'django.contrib.auth.decorators.login_required', 'login_required', ([], {'lo... |
from ctypes import c_int32, c_char_p, c_void_p, c_float, c_size_t, c_ubyte, c_long, cdll, POINTER, CDLL
from face_class import *
import os
wuyongdll = CDLL('libarcsoft/libarcsoft_face.so')
dll = CDLL('libarcsoft/libarcsoft_face_engine.so')
dllc = CDLL('libc.so.6')
ASF_DETECT_MODE_VIDEO = 0x00000000
ASF_DETECT_MODE_IMAG... | [
"ctypes.CDLL",
"ctypes.POINTER"
] | [((151, 188), 'ctypes.CDLL', 'CDLL', (['"""libarcsoft/libarcsoft_face.so"""'], {}), "('libarcsoft/libarcsoft_face.so')\n", (155, 188), False, 'from ctypes import c_int32, c_char_p, c_void_p, c_float, c_size_t, c_ubyte, c_long, cdll, POINTER, CDLL\n'), ((195, 239), 'ctypes.CDLL', 'CDLL', (['"""libarcsoft/libarcsoft_face... |
"""
Example producer that sends a single message and exits.
You can use `complete_receive.py` to receive the message sent.
"""
from kombu import Connection, Producer, Exchange, Queue
#: By default messages sent to exchanges are persistent (delivery_mode=2),
#: and queues and exchanges are durable.
exchange =... | [
"kombu.Queue",
"kombu.Connection",
"kombu.Producer",
"kombu.Exchange"
] | [((321, 331), 'kombu.Exchange', 'Exchange', ([], {}), '()\n', (329, 331), False, 'from kombu import Connection, Producer, Exchange, Queue\n'), ((346, 395), 'kombu.Connection', 'Connection', (['"""amqp://guest:guest@localhost:5672//"""'], {}), "('amqp://guest:guest@localhost:5672//')\n", (356, 395), False, 'from kombu i... |
# -*- coding: utf-8 -*-
import scrapy, json, time
from douyuSpider.items import DouyuspiderItem
from scrapy.linkextractors import LinkExtractor
from scrapy.linkextractors import LinkExtractor
#
# link_list = LinkExtractor(allow=("start=\d+")) # 返回的就是Ruler对象
# link_list.extract_links(response) # 每个LinkExtractor有唯一的公共方... | [
"douyuSpider.items.DouyuspiderItem",
"json.loads"
] | [((1436, 1456), 'json.loads', 'json.loads', (['json_str'], {}), '(json_str)\n', (1446, 1456), False, 'import scrapy, json, time\n'), ((1548, 1565), 'douyuSpider.items.DouyuspiderItem', 'DouyuspiderItem', ([], {}), '()\n', (1563, 1565), False, 'from douyuSpider.items import DouyuspiderItem\n')] |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Feb 19 14:53:42 2018
@author: zsc
"""
import sys
from optparse import OptionParser
sys.path.append('./')
import yolo
from yolo.utils.process_config import processConfig
parser = OptionParser()
parser.add_option("-c", "--conf", dest="configure", help... | [
"sys.path.append",
"yolo.utils.process_config.processConfig",
"optparse.OptionParser"
] | [((152, 173), 'sys.path.append', 'sys.path.append', (['"""./"""'], {}), "('./')\n", (167, 173), False, 'import sys\n'), ((249, 263), 'optparse.OptionParser', 'OptionParser', ([], {}), '()\n', (261, 263), False, 'from optparse import OptionParser\n'), ((543, 566), 'yolo.utils.process_config.processConfig', 'processConfi... |
from six.moves import queue
import numpy as np
import pyaudio
import wave
from .utils import audio_resample
class AudioInputStreamer(object):
r"""Streams raw audio from microphone/wav file. Data is received in a separate thread,
and stored in a buffer, to be read from."""
# Audio recording parameters, ... | [
"wave.open",
"six.moves.queue.Queue",
"pyaudio.PyAudio"
] | [((1350, 1363), 'six.moves.queue.Queue', 'queue.Queue', ([], {}), '()\n', (1361, 1363), False, 'from six.moves import queue\n'), ((1643, 1660), 'pyaudio.PyAudio', 'pyaudio.PyAudio', ([], {}), '()\n', (1658, 1660), False, 'import pyaudio\n'), ((1522, 1548), 'wave.open', 'wave.open', (['file_path', '"""rb"""'], {}), "(fi... |
from malcolm.core import Part, method_takes, REQUIRED, MethodModel, \
snake_to_camel
class PandABlocksActionPart(Part):
"""This will normally be instantiated by the PandABox assembly, not created
in yaml"""
def __init__(self, client, block_name, field_name, description, tags,
arg_met... | [
"malcolm.core.snake_to_camel",
"malcolm.core.MethodModel",
"malcolm.core.method_takes"
] | [((708, 739), 'malcolm.core.snake_to_camel', 'snake_to_camel', (['self.field_name'], {}), '(self.field_name)\n', (722, 739), False, 'from malcolm.core import Part, method_takes, REQUIRED, MethodModel, snake_to_camel\n'), ((867, 919), 'malcolm.core.method_takes', 'method_takes', (['self.arg_name', 'self.arg_meta', 'REQU... |
from typing import Any, Dict, List, Optional, Set
from starlette.applications import Starlette
from rap.api_gateway.component import api_exception
from rap.api_gateway.route import route_func, websocket_route_func
from rap.client import Client
def create_app(
prefix: str,
rap_client_list: List[Client],
... | [
"starlette.applications.Starlette"
] | [((647, 658), 'starlette.applications.Starlette', 'Starlette', ([], {}), '()\n', (656, 658), False, 'from starlette.applications import Starlette\n')] |
# -*- coding: utf-8 -*-
# Coin Price indicator
import os
import signal
import yaml
import sys
import gi
gi.require_version('Gtk', '3.0')
from gi.repository import Gtk
from indicator import Indicator
from exchange.kraken import Kraken
from exchange.bitstamp import Bitstamp
PROJECT_ROOT = os.path.abspath(os.path.dirn... | [
"gi.require_version",
"gi.repository.Gtk.main",
"os.path.dirname",
"exchange.kraken.Kraken",
"exchange.bitstamp.Bitstamp",
"signal.signal",
"indicator.Indicator"
] | [((105, 137), 'gi.require_version', 'gi.require_version', (['"""Gtk"""', '"""3.0"""'], {}), "('Gtk', '3.0')\n", (123, 137), False, 'import gi\n'), ((353, 397), 'signal.signal', 'signal.signal', (['signal.SIGINT', 'signal.SIG_DFL'], {}), '(signal.SIGINT, signal.SIG_DFL)\n', (366, 397), False, 'import signal\n'), ((2477,... |
# -*- coding: utf-8 -*-
import pytest
from verta.code import Git, Notebook
pytestmark = pytest.mark.not_oss # skip if run in oss setup. Applied to entire module
class TestLogCode:
def test_log_code(self, model_version):
key1, key2, key3 = "version1", "version2", "version3"
version1 = Git(
... | [
"verta.code.Git",
"verta.code.Notebook"
] | [((312, 400), 'verta.code.Git', 'Git', ([], {'repo_url': '"""<EMAIL>:VertaAI/models.git"""', 'commit_hash': '"""52f3d22"""', 'autocapture': '(False)'}), "(repo_url='<EMAIL>:VertaAI/models.git', commit_hash='52f3d22',\n autocapture=False)\n", (315, 400), False, 'from verta.code import Git, Notebook\n'), ((463, 560), ... |
from django.db import transaction
from rest_framework import serializers
from risks.models import FieldType, AbstractField, AbstractRisk, Field, Risk
from risks.validation_helpers import get_non_matching_fields
class FieldTypeSerializer(serializers.ModelSerializer):
class Meta:
model = FieldType
f... | [
"risks.models.Risk.objects.create",
"risks.models.Field.objects.filter",
"risks.models.AbstractField.get_regexes",
"risks.models.AbstractRisk.objects.create",
"risks.models.AbstractField",
"risks.models.Field",
"risks.validation_helpers.get_non_matching_fields",
"django.db.transaction.atomic",
"rest... | [((2172, 2220), 'risks.models.AbstractField.get_regexes', 'AbstractField.get_regexes', (["data['abstract_risk']"], {}), "(data['abstract_risk'])\n", (2197, 2220), False, 'from risks.models import FieldType, AbstractField, AbstractRisk, Field, Risk\n'), ((2377, 2425), 'risks.validation_helpers.get_non_matching_fields', ... |
from django.contrib.postgres.fields import JSONField
from django.db import models
class Image(models.Model):
title = models.CharField(max_length=100, unique=True)
desc = models.CharField(max_length=100)
file_path = models.CharField(max_length=100)
date_created = models.DateTimeField(auto_now_add=True)... | [
"django.db.models.CharField",
"django.db.models.DateTimeField",
"django.contrib.postgres.fields.JSONField",
"django.db.models.ForeignKey"
] | [((123, 168), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(100)', 'unique': '(True)'}), '(max_length=100, unique=True)\n', (139, 168), False, 'from django.db import models\n'), ((180, 212), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(100)'}), '(max_length=100)\n', ... |
# Написать программу, которая генерирует в указанных пользователем границах:
# случайное целое число;
# случайное вещественное число;
# случайный символ.
#
# Для каждого из трех случаев пользователь задает свои границы диапазона.
# Например, если надо получить случайный символ от 'a' до 'f', то вводятся эти симво... | [
"random.random",
"random.randint"
] | [((815, 837), 'random.randint', 'random.randint', (['a1', 'a2'], {}), '(a1, a2)\n', (829, 837), False, 'import random\n'), ((846, 861), 'random.random', 'random.random', ([], {}), '()\n', (859, 861), False, 'import random\n')] |
import logging
import os
from typing import Union, List
from uuid import uuid4
import util
from config import get_active_config
from collector.xml_query import XMLQuery
import xmltodict
from exc import NoIdsError
logger = logging.getLogger(__name__)
conf = get_active_config()
class ExportParameter:
domain = co... | [
"collector.xml_query.XMLQuery",
"uuid.uuid4",
"config.get_active_config",
"util.load_xml",
"os.path.exists",
"exc.NoIdsError",
"xmltodict.unparse",
"os.path.join",
"logging.getLogger"
] | [((224, 251), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (241, 251), False, 'import logging\n'), ((259, 278), 'config.get_active_config', 'get_active_config', ([], {}), '()\n', (276, 278), False, 'from config import get_active_config\n'), ((704, 711), 'uuid.uuid4', 'uuid4', ([], {}), ... |
#!/usr/bin/env python
# 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, sof... | [
"os.mkdir",
"threading.active_count",
"argparse.ArgumentParser",
"os.environ.copy",
"time.strftime",
"logging.Formatter",
"libs.common._index_result",
"pathlib.Path",
"shutil.rmtree",
"threading.currentThread",
"logging.error",
"logging.FileHandler",
"json.loads",
"logging.warning",
"os.... | [((2182, 2232), 'logging.info', 'logging.info', (['"""Testing rosa command with: rosa -h"""'], {}), "('Testing rosa command with: rosa -h')\n", (2194, 2232), False, 'import logging\n'), ((2285, 2359), 'subprocess.Popen', 'subprocess.Popen', (['rosa_cmd'], {'stdout': 'subprocess.PIPE', 'stderr': 'subprocess.PIPE'}), '(r... |
#!/usr/bin/env python3
# https://codeforces.com/blog/entry/18051
# This code use Increment as modifications
# And use queries for maximum
import math
import operator
class segment_tree:
def __init__(self, a):
self.n = len(a)
self.tree = [0]*self.n + a
self.lazy = [0]*self.n
self.H... | [
"math.log2"
] | [((333, 350), 'math.log2', 'math.log2', (['self.n'], {}), '(self.n)\n', (342, 350), False, 'import math\n'), ((551, 568), 'math.log2', 'math.log2', (['self.n'], {}), '(self.n)\n', (560, 568), False, 'import math\n')] |
import os
from os import PathLike
from typing import TYPE_CHECKING, AnyStr, ClassVar, Dict, Iterable, Union
import boto3
import botocore.exceptions
from tqdm import tqdm
if TYPE_CHECKING:
from mypy_boto3_s3 import S3ServiceResource
from mypy_boto3_s3.service_resource import Bucket, ObjectSummary
else:
Buc... | [
"tempfile.NamedTemporaryFile",
"os.remove"
] | [((9464, 9496), 'tempfile.NamedTemporaryFile', 'NamedTemporaryFile', ([], {'delete': '(False)'}), '(delete=False)\n', (9482, 9496), False, 'from tempfile import NamedTemporaryFile\n'), ((9878, 9903), 'os.remove', 'os.remove', (['temp_file.name'], {}), '(temp_file.name)\n', (9887, 9903), False, 'import os\n')] |
#-------------------------------------------------------------------------------
# Name: vpt2
# Purpose: Submodule implementing VPT2 anharmonic calculations/computations
#
# Author: <NAME>
# <EMAIL>
#
# Created: 6 Oct 2015
# Copyright: (c) <NAME> 2016
# License: The MIT License;... | [
"os.path.isabs",
"os.remove",
"os.path.isdir",
"os.path.isfile",
"os.path.split",
"os.path.join"
] | [((4016, 4031), 'os.path.isdir', 'osp.isdir', (['repo'], {}), '(repo)\n', (4025, 4031), True, 'from os import path as osp\n'), ((4206, 4222), 'os.path.isfile', 'osp.isfile', (['repo'], {}), '(repo)\n', (4216, 4222), True, 'from os import path as osp\n'), ((3123, 3174), 'os.path.join', 'osp.join', (['basepath', '(basena... |
# -*- coding: utf-8 -*-
#
# Copyright 2017-2019 - Swiss Data Science Center (SDSC)
# A partnership between École Polytechnique Fédérale de Lausanne (EPFL) and
# Eidgenössische Technische Hochschule Zürich (ETHZ).
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in c... | [
"yaml.safe_dump",
"renku.cli._providers.ProviderFactory.from_id",
"click.option",
"click.echo",
"patoolib.extract_archive",
"yaml.safe_load",
"click.Path",
"multiprocessing.cpu_count",
"click.BadParameter",
"click.confirm",
"click.Choice",
"tempfile.mkdtemp",
"renku.models.datasets.Creator.f... | [((5157, 5197), 'click.group', 'click.group', ([], {'invoke_without_command': '(True)'}), '(invoke_without_command=True)\n', (5168, 5197), False, 'import click\n'), ((5199, 5239), 'click.option', 'click.option', (['"""--revision"""'], {'default': 'None'}), "('--revision', default=None)\n", (5211, 5239), False, 'import ... |
import math
import numpy as np
from loguru import logger
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.distributions.categorical import Categorical
from torch.distributions.normal import Normal
from torch.distributions import kl_divergence
import utils
from utils.checker import *
from... | [
"torch.multinomial",
"torch.cat",
"torch.cos",
"torch.arange",
"utils.data_helper.get_canvasd",
"torch.softmax",
"torch.nn.Linear",
"torch.zeros",
"math.log",
"torch.log",
"torch.zeros_like",
"torch.nn.ModuleList",
"torch.nn.Conv2d",
"torch.nn.BatchNorm2d",
"torch.rand",
"torch.bernoul... | [((1517, 1534), 'torch.rand', 'torch.rand', (['shape'], {}), '(shape)\n', (1527, 1534), False, 'import torch\n'), ((1735, 1769), 'torch.nn.functional.softmax', 'F.softmax', (['(y / temperature)'], {'dim': '(-1)'}), '(y / temperature, dim=-1)\n', (1744, 1769), True, 'import torch.nn.functional as F\n'), ((6097, 6139), '... |
# Generated by Django 3.2.4 on 2021-06-23 03:05
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('denomination', '0001_initial'),
]
operations = [
migrations.CreateModel(
name='Entry',
... | [
"django.db.models.BigAutoField",
"django.db.models.IntegerField",
"django.db.models.ForeignKey",
"django.db.models.DateField"
] | [((356, 452), 'django.db.models.BigAutoField', 'models.BigAutoField', ([], {'auto_created': '(True)', 'primary_key': '(True)', 'serialize': '(False)', 'verbose_name': '"""ID"""'}), "(auto_created=True, primary_key=True, serialize=False,\n verbose_name='ID')\n", (375, 452), False, 'from django.db import migrations, m... |
from datetime import datetime
from dateutil.tz import tzoffset
API_ACCOUNT_LIST = [
{
'id': 174,
'UserDefinedFields': '',
'Address1': '26 Tech Valley Drive',
'Address2': 'Suite 2',
'AlternatePhone1': '',
'AlternatePhone2': '',
'City': 'East Greenbush',
... | [
"dateutil.tz.tzoffset"
] | [((11235, 11255), 'dateutil.tz.tzoffset', 'tzoffset', (['None', '(3600)'], {}), '(None, 3600)\n', (11243, 11255), False, 'from dateutil.tz import tzoffset\n'), ((11346, 11366), 'dateutil.tz.tzoffset', 'tzoffset', (['None', '(3600)'], {}), '(None, 3600)\n', (11354, 11366), False, 'from dateutil.tz import tzoffset\n'), (... |
import sys
from k0emu.debug import make_debugger_from_argv
def test(debug, outfile):
# bank 0 is the working bank so it is not tested
for bank, opc in enumerate((0xD8, 0xF0, 0xF8), 1):
code = [
0x61, opc, # sel rb<bank>
0x10, 0x88, 0x99, # movw ax,#0x8899
... | [
"k0emu.debug.make_debugger_from_argv"
] | [((863, 888), 'k0emu.debug.make_debugger_from_argv', 'make_debugger_from_argv', ([], {}), '()\n', (886, 888), False, 'from k0emu.debug import make_debugger_from_argv\n')] |
import json
import joblib
import os
with open(os.path.join('..','open_images', 'bbox_labels_600_hierarchy.json')) as f:
hierarchy = json.load(f)
mid2label = joblib.load(os.path.join('..','data','mid2label.joblib'))
mid2parents = joblib.load(os.path.join('..','data','mid2parents.joblib'))
lens = set()
for mid,lab... | [
"json.load",
"os.path.join"
] | [((137, 149), 'json.load', 'json.load', (['f'], {}), '(f)\n', (146, 149), False, 'import json\n'), ((175, 221), 'os.path.join', 'os.path.join', (['""".."""', '"""data"""', '"""mid2label.joblib"""'], {}), "('..', 'data', 'mid2label.joblib')\n", (187, 221), False, 'import os\n'), ((247, 295), 'os.path.join', 'os.path.joi... |
#!/usr/bin/env python3
import math
import string
import binascii
import itertools
from Crypto.Cipher import AES
def hex_to_base64(s):
'''Return the base64 representation of the given hex encoded string.'''
s_bytes = binascii.a2b_hex(s)
result_bytes = binascii.b2a_base64(s_bytes, newline=False)
return... | [
"binascii.b2a_hex",
"binascii.a2b_hex",
"itertools.combinations",
"binascii.b2a_base64",
"Crypto.Cipher.AES.new"
] | [((227, 246), 'binascii.a2b_hex', 'binascii.a2b_hex', (['s'], {}), '(s)\n', (243, 246), False, 'import binascii\n'), ((266, 309), 'binascii.b2a_base64', 'binascii.b2a_base64', (['s_bytes'], {'newline': '(False)'}), '(s_bytes, newline=False)\n', (285, 309), False, 'import binascii\n'), ((703, 733), 'binascii.b2a_hex', '... |
#!/usr/bin/python
#coding: utf-8 -*-
# (c) 2015, <NAME> <<EMAIL>>
#
# This module is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# ... | [
"re.split",
"subprocess.check_output",
"os.environ.copy",
"shlex.split",
"subprocess.call",
"os.getenv",
"subprocess.check_call"
] | [((5470, 5492), 'shlex.split', 'shlex.split', (['args_data'], {}), '(args_data)\n', (5481, 5492), False, 'import shlex\n'), ((2185, 2260), 'subprocess.call', 'subprocess.call', (["['xcversion', '--version']"], {'shell': '(True)', 'stdout': 'null_device'}), "(['xcversion', '--version'], shell=True, stdout=null_device)\n... |
import _init_pathes
from CAD_wrapper.CAD_pipeline import CAD_Pipeline
pipeline = CAD_Pipeline()
pipeline.initialize()
pipeline.predict_risk_for(r'D:\data\data_root\patient_0000232') | [
"CAD_wrapper.CAD_pipeline.CAD_Pipeline"
] | [((87, 101), 'CAD_wrapper.CAD_pipeline.CAD_Pipeline', 'CAD_Pipeline', ([], {}), '()\n', (99, 101), False, 'from CAD_wrapper.CAD_pipeline import CAD_Pipeline\n')] |
from discord.ext import commands
from discord import ActivityType
from cogs.roles import Roles
from cogs.youtube import Youtube
from cogs.weather import Weather
from cogs.role_distribution import RoleDistribution
from cogs.monitor import Monitor
from cogs.change_banner import ChangeBanner
from cogs.boost_role import Bo... | [
"logging.FileHandler",
"cogs.roles.Roles",
"cogs.change_banner.ChangeBanner",
"cogs.monitor.Monitor",
"logging.Formatter",
"discord.ext.commands.Bot",
"cogs.boost_role.BoostRole",
"logging.getLogger"
] | [((504, 536), 'discord.ext.commands.Bot', 'commands.Bot', ([], {'command_prefix': '"""!"""'}), "(command_prefix='!')\n", (516, 536), False, 'from discord.ext import commands\n'), ((554, 582), 'logging.getLogger', 'logging.getLogger', (['"""discord"""'], {}), "('discord')\n", (571, 582), False, 'import logging\n'), ((17... |
import vtk
from pulse.uix.vtk.vtkActorBase import vtkActorBase
class ActorEntityElements(vtkActorBase):
def __init__(self, elements, tag=-1):
super().__init__()
self.elements = elements
self.tag = tag
self._object = vtk.vtkAppendPolyData()
self._nodes = vtk.vtkPoint... | [
"vtk.vtkPoints",
"vtk.vtkAppendPolyData",
"vtk.vtkLine",
"vtk.vtkUnsignedCharArray",
"vtk.vtkPolyData",
"vtk.vtkCellArray",
"vtk.vtkTubeFilter",
"vtk.vtkPolyDataMapper"
] | [((253, 276), 'vtk.vtkAppendPolyData', 'vtk.vtkAppendPolyData', ([], {}), '()\n', (274, 276), False, 'import vtk\n'), ((308, 323), 'vtk.vtkPoints', 'vtk.vtkPoints', ([], {}), '()\n', (321, 323), False, 'import vtk\n'), ((346, 364), 'vtk.vtkCellArray', 'vtk.vtkCellArray', ([], {}), '()\n', (362, 364), False, 'import vtk... |
import praw
import prawcore
import os
def reddit_login():
'''logs in the user using OAuth 2.0 and returns a redditor object for use'''
user_agent = 'PC:redditFavoriteGrab:v0.1 (by /u/Scien)'
r = praw.Reddit('mysettings', user_agent=user_agent)
try:
return r.user.me()
except prawcore.excepti... | [
"os.path.isfile",
"praw.Reddit"
] | [((208, 256), 'praw.Reddit', 'praw.Reddit', (['"""mysettings"""'], {'user_agent': 'user_agent'}), "('mysettings', user_agent=user_agent)\n", (219, 256), False, 'import praw\n'), ((493, 532), 'os.path.isfile', 'os.path.isfile', (['"""./redditFavorites.txt"""'], {}), "('./redditFavorites.txt')\n", (507, 532), False, 'imp... |
from os import times
from cuesdk import CueSdk
import json
import sacn
import time
JSON_PATH = 'config.json'
def setup_receiver(universe, device_index):
name = sdk.get_device_info(device_index)
led_info = sdk.get_led_positions_by_device_index(device_index)
led_ids = tuple(led_info.keys())
led_buffer =... | [
"json.dump",
"json.load",
"sacn.sACNreceiver",
"cuesdk.CueSdk"
] | [((1480, 1499), 'sacn.sACNreceiver', 'sacn.sACNreceiver', ([], {}), '()\n', (1497, 1499), False, 'import sacn\n'), ((1540, 1548), 'cuesdk.CueSdk', 'CueSdk', ([], {}), '()\n', (1546, 1548), False, 'from cuesdk import CueSdk\n'), ((1332, 1396), 'json.dump', 'json.dump', (['conf', 'f'], {'ensure_ascii': '(False)', 'sort_k... |
import re
import numpy as np
from kabuki import kabuki_mask
# We want to use the output
# of kabuki kidpix to initialize
# a Game of Life grid.
#
# Here is the format that Life expects:
#
# initialState : '[{"39":[60]},{"40":[62]},{"41":[59,60,63,64,65]}]',
#
# '[
# { "<row-id>" : [<col-id>, <col-id>, <col-id... | [
"numpy.shape",
"kabuki.kabuki_mask",
"numpy.array",
"re.sub"
] | [((1463, 1565), 'kabuki.kabuki_mask', 'kabuki_mask', (['img_filename', "kwargs['final_size']", "kwargs['brightness_threshold']", "kwargs['invert']"], {}), "(img_filename, kwargs['final_size'], kwargs[\n 'brightness_threshold'], kwargs['invert'])\n", (1474, 1565), False, 'from kabuki import kabuki_mask\n'), ((1568, 1... |
#!/usr/bin/env python
r"""
The following parameters come from:
[1] <NAME>., <NAME>., <NAME>. & <NAME>.
Collisionless Isotropization of the Solar-Wind Protons By Compressive
Fluctuations and Plasma Instabilities. Astrophys. J. 831, 128 (2016).
for which the Bibtex entry is:
@article{Verscharen2016a,
... | [
"pandas.DataFrame",
"matplotlib.pyplot.FuncFormatter",
"pandas.MultiIndex.from_tuples",
"pandas.DataFrame.from_dict",
"matplotlib.colors.Normalize",
"matplotlib.patches.Rectangle",
"pandas.Index",
"collections.namedtuple",
"pandas.Series",
"matplotlib.cbook.normalize_kwargs",
"pandas.concat",
... | [((1184, 1240), 'pandas.Index', 'pd.Index', (["['AIC', 'FMW', 'MM', 'OFI']"], {'name': '"""Intability"""'}), "(['AIC', 'FMW', 'MM', 'OFI'], name='Intability')\n", (1192, 1240), True, 'import pandas as pd\n'), ((1254, 1301), 'pandas.Index', 'pd.Index', (["['a', 'b', 'c']"], {'name': '"""Fit Parameter"""'}), "(['a', 'b',... |