code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
# currScenRecQuery = """
# SELECT * from 'pla_scenario_values_new2' where rid='{rId}' and qno='{qNo}'
# """.format(rId=1, qNo=2)
# currScenRec = db.fetch_results(currScenRecQuery, single_row=True)
#
# updateBetaAttrQuery = """
# UPDATE 'pla_scenario... | [
"os.listdir",
"pymysql.connect",
"db.fetch_results",
"db.execute"
] | [((1141, 1180), 'db.fetch_results', 'db.fetch_results', (['"""cuebiq201911"""', 'query'], {}), "('cuebiq201911', query)\n", (1157, 1180), False, 'import db\n'), ((1255, 1351), 'pymysql.connect', 'mysql.connect', ([], {'host': '"""localhost"""', 'database': '"""cuebiq201911"""', 'user': '"""root"""', 'password': '"""<PA... |
# -*- coding: utf-8 -*-
'''
VKGroups
Copyright © 2010-2018 HeaTTheatR
Для предложений и вопросов:
<<EMAIL>>
Данный файл распространяется по услолвиям той же лицензии,
что и фреймворк Kivy.
'''
from jnius import autoclass, PythonJavaClass, java_method, cast
from android.runnable import run_on_ui_thread
Toast = au... | [
"jnius.autoclass"
] | [((318, 351), 'jnius.autoclass', 'autoclass', (['"""android.widget.Toast"""'], {}), "('android.widget.Toast')\n", (327, 351), False, 'from jnius import autoclass, PythonJavaClass, java_method, cast\n'), ((362, 406), 'jnius.autoclass', 'autoclass', (['"""org.kivy.android.PythonActivity"""'], {}), "('org.kivy.android.Pyt... |
# Copyright 2020 Adap GmbH. 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 ag... | [
"numpy.random.choice",
"numpy.array",
"statistics.mean",
"numpy.max"
] | [((4713, 4780), 'numpy.random.choice', 'np.random.choice', (['indices'], {'size': 'sample_size', 'replace': '(False)', 'p': 'probs'}), '(indices, size=sample_size, replace=False, p=probs)\n', (4729, 4780), True, 'import numpy as np\n'), ((4680, 4696), 'numpy.array', 'np.array', (['logits'], {}), '(logits)\n', (4688, 46... |
import tensorflow as tf
A = tf.constant([4], tf.int32, name='A')
B = tf.constant([4], tf.int32, name='B')
C = tf.constant([4], tf.int32, name='C')
x = tf.placeholder(tf.int32, name='x')
with tf.name_scope("Equation_1"):
AX2_1 = tf.multiply(A, tf.pow(x,2), name='AX2_1')
Bx = tf.multiply(B, tf.pow(x,2), name='... | [
"tensorflow.pow",
"tensorflow.Session",
"tensorflow.placeholder",
"tensorflow.add_n",
"tensorflow.name_scope",
"tensorflow.constant",
"tensorflow.summary.FileWriter"
] | [((29, 65), 'tensorflow.constant', 'tf.constant', (['[4]', 'tf.int32'], {'name': '"""A"""'}), "([4], tf.int32, name='A')\n", (40, 65), True, 'import tensorflow as tf\n'), ((70, 106), 'tensorflow.constant', 'tf.constant', (['[4]', 'tf.int32'], {'name': '"""B"""'}), "([4], tf.int32, name='B')\n", (81, 106), True, 'import... |
import os
class Config():
SECRET_KEY = os.environ.get('FLASK_SECRET_KEY', 'f&k*n@kfa_H*tf^$)')
SSL_DISABLE = False
SQLALCHEMY_COMMIT_ON_TEARDOWN = True
SQLALCHEMY_RECORD_QUERIES = True
SQLALCHEMY_TRACK_MODIFICATIONS = False
FLASKY_SLOW_DB_QUERY_TIME = 0.5
FLASKY_PER_PAGE = 10
CKEDITOR_... | [
"os.environ.get"
] | [((45, 100), 'os.environ.get', 'os.environ.get', (['"""FLASK_SECRET_KEY"""', '"""f&k*n@kfa_H*tf^$)"""'], {}), "('FLASK_SECRET_KEY', 'f&k*n@kfa_H*tf^$)')\n", (59, 100), False, 'import os\n')] |
import random
class Thing:
"""
This represents any physical object that can appear in an Environment.
"""
def is_alive(self):
"""Things that are 'alive' should return true."""
return hasattr(self, 'alive') and self.alive
def show_state(self):
"""Display the agent's int... | [
"random.choice"
] | [((6333, 6362), 'random.choice', 'random.choice', (['[loc_A, loc_B]'], {}), '([loc_A, loc_B])\n', (6346, 6362), False, 'import random\n'), ((5636, 5669), 'random.choice', 'random.choice', (["['Clean', 'Dirty']"], {}), "(['Clean', 'Dirty'])\n", (5649, 5669), False, 'import random\n'), ((5701, 5734), 'random.choice', 'ra... |
# -*- coding: utf-8 -*-
"""
tests.tests_models.test_water_container
~~~~~~~~~~~~~~~~~~~
This script contains tests for the WaterContainer model.
"""
from pytest import fixture, mark, raises
from src.exceptions import CoffeeMachineException
from src.exceptions import NotEnoughWater
from src.models.container import Wat... | [
"src.models.container.WaterContainer",
"pytest.raises"
] | [((646, 690), 'src.models.container.WaterContainer', 'WaterContainer', ([], {'capacity': '_container_capacity'}), '(capacity=_container_capacity)\n', (660, 690), False, 'from src.models.container import WaterContainer\n'), ((893, 915), 'pytest.raises', 'raises', (['NotEnoughWater'], {}), '(NotEnoughWater)\n', (899, 915... |
from quicksectx import IntervalTree, Interval
import unittest
tree = IntervalTree()
tree.add(0, 3, 100)
tree.add(5, 8, 110)
tree.add(6, 10, 120)
tree.add(8, 9, 130)
tree.add(15, 23, 140)
tree.add(19, 20, 150)
tree.add(17, 19, 160)
tree.add(26, 26, 160)
tree.add(25, 30, 160)
tree.add(16, 21, 160)
print(tree.search(3,15... | [
"unittest.main",
"quicksectx.IntervalTree",
"quicksectx.Interval"
] | [((70, 84), 'quicksectx.IntervalTree', 'IntervalTree', ([], {}), '()\n', (82, 84), False, 'from quicksectx import IntervalTree, Interval\n'), ((380, 394), 'quicksectx.IntervalTree', 'IntervalTree', ([], {}), '()\n', (392, 394), False, 'from quicksectx import IntervalTree, Interval\n'), ((1161, 1176), 'unittest.main', '... |
#!/usr/bin/python
# -*- coding: utf-8 -*-
# author arrti
from ss_admin import app
if __name__ == '__main__':
app.run()
| [
"ss_admin.app.run"
] | [((116, 125), 'ss_admin.app.run', 'app.run', ([], {}), '()\n', (123, 125), False, 'from ss_admin import app\n')] |
# Maximum Gap Problem
# http://www.zrzahid.com/the-%E2%80%A9maximum%E2%80%A9-gap%E2%80%A9-problem-%E2%80%A9pigeonhole-%E2%80%A9principle%E2%80%A9/
# http://cgm.cs.mcgill.ca/~godfried/teaching/dm-reading-assignments/Maximum-Gap-Problem.pdf
# https://stackoverflow.com/questions/10262937/array-maximum-difference-algorithm... | [
"math.floor"
] | [((689, 714), 'math.floor', 'floor', (['((i - minn) / delta)'], {}), '((i - minn) / delta)\n', (694, 714), False, 'from math import floor\n')] |
# Copyright (c) Microsoft Corporation.
# Licensed under the MIT license.
from .__misc__ import __version__, __data_version__
from maro.utils.utils import deploy, check_deployment_status
if not check_deployment_status():
deploy()
| [
"maro.utils.utils.deploy",
"maro.utils.utils.check_deployment_status"
] | [((196, 221), 'maro.utils.utils.check_deployment_status', 'check_deployment_status', ([], {}), '()\n', (219, 221), False, 'from maro.utils.utils import deploy, check_deployment_status\n'), ((227, 235), 'maro.utils.utils.deploy', 'deploy', ([], {}), '()\n', (233, 235), False, 'from maro.utils.utils import deploy, check_... |
# -*- coding: UTF-8 -*-
"""
@author: <NAME>
@file : settings.py
@time : 2021/09/10 09:20
@desc :
"""
import configparser
import os
import PySimpleGUI as sg
LANGUAGE_DEF = '中文/英文'
LANGUAGE_NAME_KEY_MAP = {
'中文/英文': 'ch',
'繁体中文': 'ch_tra',
'日语': 'japan',
'韩语': 'korean',
'... | [
"os.path.exists",
"configparser.ConfigParser",
"PySimpleGUI.Cancel",
"PySimpleGUI.Text",
"PySimpleGUI.theme",
"PySimpleGUI.OK"
] | [((706, 730), 'PySimpleGUI.theme', 'sg.theme', (['"""LightBrown12"""'], {}), "('LightBrown12')\n", (714, 730), True, 'import PySimpleGUI as sg\n'), ((2297, 2324), 'configparser.ConfigParser', 'configparser.ConfigParser', ([], {}), '()\n', (2322, 2324), False, 'import configparser\n'), ((2217, 2244), 'os.path.exists', '... |
# Generated by Django 3.1.1 on 2020-09-13 05:19
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('log_reg_app', '0001_initial'),
]
operations = [
migrations.AddField(
model_name='user',
name='password',
... | [
"django.db.models.CharField"
] | [((327, 373), 'django.db.models.CharField', 'models.CharField', ([], {'default': 'None', 'max_length': '(255)'}), '(default=None, max_length=255)\n', (343, 373), False, 'from django.db import migrations, models\n')] |
import math
class Prime:
is_debug = True
prime_list = []
max_ind = 0
max_keep = 0
prev_no = 0
seq_list = []
inter_list = []
def __init__(self, limit):
self.max_keep = round(math.sqrt(limit) / math.log(math.sqrt(limit), math.e) * 1.5)
def get(self, index):
return s... | [
"math.sqrt"
] | [((216, 232), 'math.sqrt', 'math.sqrt', (['limit'], {}), '(limit)\n', (225, 232), False, 'import math\n'), ((244, 260), 'math.sqrt', 'math.sqrt', (['limit'], {}), '(limit)\n', (253, 260), False, 'import math\n')] |
import pandas as pd
import numpy as np
import re
from FeatureExtraction import *
from CrossValidation import *
import warnings
from Preprocessing import *
from collections import Counter
import seaborn as sns
import matplotlib.pyplot as plt
warnings.filterwarnings(action = 'ignore')
#read train file
train=pd.read_csv(... | [
"matplotlib.pyplot.savefig",
"pandas.read_csv",
"pandas.DataFrame",
"seaborn.barplot",
"pandas.concat",
"warnings.filterwarnings",
"matplotlib.pyplot.show"
] | [((241, 281), 'warnings.filterwarnings', 'warnings.filterwarnings', ([], {'action': '"""ignore"""'}), "(action='ignore')\n", (264, 281), False, 'import warnings\n'), ((308, 337), 'pandas.read_csv', 'pd.read_csv', (['"""Data/train.csv"""'], {}), "('Data/train.csv')\n", (319, 337), True, 'import pandas as pd\n'), ((360, ... |
#to run this script once per day (auto-update the washingtonpost data from GitHub) add this to crontab:
# 0 12 * * * python /Users/quran/Dropbox/MusicArtProjects/endsSentenceFunction/data/download.py
import os
import urllib
fullfilename = os.path.join('/Users/quran/Dropbox/MusicArtProjects/endsSentenceFunction/data', ... | [
"urllib.URLopener",
"os.path.join"
] | [((240, 358), 'os.path.join', 'os.path.join', (['"""/Users/quran/Dropbox/MusicArtProjects/endsSentenceFunction/data"""', '"""fatal-police-shootings-data.csv"""'], {}), "('/Users/quran/Dropbox/MusicArtProjects/endsSentenceFunction/data',\n 'fatal-police-shootings-data.csv')\n", (252, 358), False, 'import os\n'), ((36... |
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('core', '0001_initial'),
]
operations = [
migrations.CreateModel(
name='Event',
fields=[
... | [
"django.db.models.DateField",
"django.db.models.TextField",
"django.db.models.ForeignKey",
"django.db.models.BooleanField",
"django.db.models.AutoField",
"django.db.models.CharField"
] | [((331, 424), 'django.db.models.AutoField', 'models.AutoField', ([], {'verbose_name': '"""ID"""', 'serialize': '(False)', 'auto_created': '(True)', 'primary_key': '(True)'}), "(verbose_name='ID', serialize=False, auto_created=True,\n primary_key=True)\n", (347, 424), False, 'from django.db import migrations, models\... |
################################################################################
#
# Select a
#
# Author(s): <NAME>
################################################################################
import pathlib
import random
from typing import Union, List
from enum import Enum
import torch as t
from torchaudio.bac... | [
"random.randint"
] | [((5239, 5281), 'random.randint', 'random.randint', (['(0)', '(num_possible_chunks - 1)'], {}), '(0, num_possible_chunks - 1)\n', (5253, 5281), False, 'import random\n'), ((4905, 4957), 'random.randint', 'random.randint', (['(0)', '(num_samples - self.chunk_size - 1)'], {}), '(0, num_samples - self.chunk_size - 1)\n', ... |
# Copyright (c) 2021 Graphcore Ltd. All rights reserved.
import copy
import inspect
import torch
# Do not import any poptorch.* here: it will break the poptorch module
from . import _impl
from ._logging import logger
class ArgsParser:
class Args:
def __init__(self):
self._args = []
... | [
"copy.copy",
"inspect.signature"
] | [((435, 456), 'copy.copy', 'copy.copy', (['self._args'], {}), '(self._args)\n', (444, 456), False, 'import copy\n'), ((2444, 2482), 'inspect.signature', 'inspect.signature', (['model.model.forward'], {}), '(model.model.forward)\n', (2461, 2482), False, 'import inspect\n'), ((2515, 2547), 'inspect.signature', 'inspect.s... |
from unicodedata import name
from django.shortcuts import render
def home_view(request):
return render(request, 'home.html')
def contact_view(request):
return render(request, 'contact.html')
def skills_view(request):
return render(request, 'skills.html')
def experience_view(request):
... | [
"django.shortcuts.render"
] | [((106, 134), 'django.shortcuts.render', 'render', (['request', '"""home.html"""'], {}), "(request, 'home.html')\n", (112, 134), False, 'from django.shortcuts import render\n'), ((178, 209), 'django.shortcuts.render', 'render', (['request', '"""contact.html"""'], {}), "(request, 'contact.html')\n", (184, 209), False, '... |
import sys
import tkinter
import functools
def getwin():
window = tkinter.Tk()
globals()['window_data'] = window
return window
def close():
globals()['window_data'].destroy()
def popup():
import argoncraft
win = getwin()
win.title('ArgonCraft - Settings')
win.config(bg=argoncraft.get... | [
"argoncraft.gettheme",
"tkinter.Tk"
] | [((71, 83), 'tkinter.Tk', 'tkinter.Tk', ([], {}), '()\n', (81, 83), False, 'import tkinter\n'), ((306, 327), 'argoncraft.gettheme', 'argoncraft.gettheme', ([], {}), '()\n', (325, 327), False, 'import argoncraft\n'), ((450, 471), 'argoncraft.gettheme', 'argoncraft.gettheme', ([], {}), '()\n', (469, 471), False, 'import ... |
import time
import board
import pulseio
import adafruit_irremote
import neopixel
# Configure treasure information
TREASURE_ID = 1
TRANSMIT_DELAY = 15
# Create NeoPixel object to indicate status
pixels = neopixel.NeoPixel(board.NEOPIXEL, 10)
# Create a 'pulseio' output, to send infrared signals on the IR transmitter ... | [
"pulseio.PulseOut",
"adafruit_irremote.GenericTransmit",
"time.sleep",
"pulseio.PWMOut",
"neopixel.NeoPixel"
] | [((205, 242), 'neopixel.NeoPixel', 'neopixel.NeoPixel', (['board.NEOPIXEL', '(10)'], {}), '(board.NEOPIXEL, 10)\n', (222, 242), False, 'import neopixel\n'), ((334, 398), 'pulseio.PWMOut', 'pulseio.PWMOut', (['board.IR_TX'], {'frequency': '(38000)', 'duty_cycle': '(2 ** 15)'}), '(board.IR_TX, frequency=38000, duty_cycle... |
from django.conf.urls import patterns, url
urlpatterns = patterns(
'apps.zblog.views',
url(r'^$', 'index', name='index'),
url(r'^(?P<id>\d+)/(?P<slug>[\w_-]+)', 'detail', name='detail'),
url(r'^archives', 'archives', name='archives'),
url(r'^tag/(?P<tag_name>.+)', 'tag', name='tag'),
ur... | [
"django.conf.urls.url"
] | [((100, 132), 'django.conf.urls.url', 'url', (['"""^$"""', '"""index"""'], {'name': '"""index"""'}), "('^$', 'index', name='index')\n", (103, 132), False, 'from django.conf.urls import patterns, url\n'), ((140, 204), 'django.conf.urls.url', 'url', (['"""^(?P<id>\\\\d+)/(?P<slug>[\\\\w_-]+)"""', '"""detail"""'], {'name'... |
from clients.rabbitmq_client import RabbitMQClient
import json
from settings import APP_QUEUE
if __name__ == "__main__":
rabbit_mq = RabbitMQClient()
payload = {
"component": "DOBIE",
"message": {
"tasks": [
{
"label": "95671c903a5b97a9",
... | [
"json.dumps",
"clients.rabbitmq_client.RabbitMQClient"
] | [((139, 155), 'clients.rabbitmq_client.RabbitMQClient', 'RabbitMQClient', ([], {}), '()\n', (153, 155), False, 'from clients.rabbitmq_client import RabbitMQClient\n'), ((736, 755), 'json.dumps', 'json.dumps', (['payload'], {}), '(payload)\n', (746, 755), False, 'import json\n')] |
import xlrd
import xlwt
import os
class XlsReader:
def __init__(self, file: str):
self.file_path = file
def read_data(self, n:int = 0):
try:
wb = xlrd.open_workbook(self.file_path)
sheet = wb.sheet_by_index(0)
result_list = []
for nr in range(n,... | [
"os.path.exists",
"xlwt.Workbook",
"xlwt.XFStyle",
"xlrd.open_workbook",
"xlwt.Font",
"os.remove"
] | [((748, 768), 'os.path.exists', 'os.path.exists', (['file'], {}), '(file)\n', (762, 768), False, 'import os\n'), ((896, 911), 'xlwt.Workbook', 'xlwt.Workbook', ([], {}), '()\n', (909, 911), False, 'import xlwt\n'), ((979, 990), 'xlwt.Font', 'xlwt.Font', ([], {}), '()\n', (988, 990), False, 'import xlwt\n'), ((1047, 106... |
from subprocess import Popen, PIPE
import sys
import os
def osascript(scpt):
p = Popen(['osascript', '-'], stdin=PIPE, stdout=PIPE, stderr=PIPE)
stdout, stderr = p.communicate(scpt.encode('utf-8'))
return stdout, stderr
def openTab():
script = f"""
tell application "System Events"
... | [
"subprocess.Popen",
"os.getcwd"
] | [((87, 150), 'subprocess.Popen', 'Popen', (["['osascript', '-']"], {'stdin': 'PIPE', 'stdout': 'PIPE', 'stderr': 'PIPE'}), "(['osascript', '-'], stdin=PIPE, stdout=PIPE, stderr=PIPE)\n", (92, 150), False, 'from subprocess import Popen, PIPE\n'), ((530, 541), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (539, 541), False... |
# Generated by Django 3.0.6 on 2020-05-22 08:33
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
import usuarios.managers
class Migration(migrations.Migration):
initial = True
dependencies = [
('auth', '0011_update_proxy_permissions'),
... | [
"django.db.models.EmailField",
"django.db.models.ForeignKey",
"django.db.models.ManyToManyField",
"django.db.models.BooleanField",
"django.db.models.AutoField",
"django.db.models.DateTimeField",
"django.db.models.CharField"
] | [((3112, 3215), 'django.db.models.ManyToManyField', 'models.ManyToManyField', ([], {'related_name': '"""tests"""', 'through': '"""usuarios.User_test"""', 'to': '"""cuestionarios.Test"""'}), "(related_name='tests', through='usuarios.User_test',\n to='cuestionarios.Test')\n", (3134, 3215), False, 'from django.db impor... |
from flask import Flask, render_template, jsonify
from flask_cors import CORS
from makeSentence import makeSentence
app = Flask(__name__)
CORS(app)
@app.route("/")
def index():
return render_template("index.html", sentence=makeSentence())
@app.route("/api")
def api():
return jsonify(sentence=makeSentence()... | [
"makeSentence.makeSentence",
"flask_cors.CORS",
"flask.Flask"
] | [((123, 138), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (128, 138), False, 'from flask import Flask, render_template, jsonify\n'), ((139, 148), 'flask_cors.CORS', 'CORS', (['app'], {}), '(app)\n', (143, 148), False, 'from flask_cors import CORS\n'), ((230, 244), 'makeSentence.makeSentence', 'makeSente... |
import pickle
import random
import cv2 as cv
import numpy as np
import torch
from torch.utils.data import Dataset
from torchvision import transforms
from config import pickle_file, num_workers
from utils import align_face
# Data augmentation and normalization for training
# Just normalization for validation
data_tra... | [
"cv2.imwrite",
"random.sample",
"torchvision.transforms.ToPILImage",
"torchvision.transforms.ToTensor",
"pickle.load",
"torchvision.transforms.RandomHorizontalFlip",
"torchvision.transforms.Normalize",
"torch.utils.data.DataLoader",
"cv2.resize",
"cv2.imread",
"utils.align_face",
"numpy.random... | [((1861, 1895), 'random.sample', 'random.sample', (["data['samples']", '(10)'], {}), "(data['samples'], 10)\n", (1874, 1895), False, 'import random\n'), ((2399, 2517), 'torch.utils.data.DataLoader', 'torch.utils.data.DataLoader', (['train_dataset'], {'batch_size': '(256)', 'shuffle': '(True)', 'num_workers': 'num_worke... |
import multiprocessing as mp
import pandas as pd
import dill
from functools import wraps
__spawn_ctx__ = None
def get_mp_ctx(f):
def with_ctx(*args, **kws):
global __spawn_ctx__
if __spawn_ctx__ is None:
__spawn_ctx__ = mp.get_context('spawn')
return f(*args, mp_ctx=__spawn_ct... | [
"multiprocessing.get_context",
"dill.loads",
"functools.wraps",
"multiprocessing.cpu_count",
"dill.dumps",
"pandas.concat"
] | [((477, 498), 'dill.loads', 'dill.loads', (['f_pickled'], {}), '(f_pickled)\n', (487, 498), False, 'import dill\n'), ((713, 727), 'multiprocessing.cpu_count', 'mp.cpu_count', ([], {}), '()\n', (725, 727), True, 'import multiprocessing as mp\n'), ((1295, 1308), 'dill.dumps', 'dill.dumps', (['f'], {}), '(f)\n', (1305, 13... |
from collections import defaultdict
from typing import List, Any, Tuple, Dict
from util.helpers import solution_timer
from util.input_helper import read_entire_input
data = read_entire_input(2019,6)
def parse(data: List[str]) -> Any:
orbits = defaultdict(list)
orbiting = {}
for row in data:
a,b=ro... | [
"util.input_helper.read_entire_input",
"collections.defaultdict",
"util.helpers.solution_timer"
] | [((174, 200), 'util.input_helper.read_entire_input', 'read_entire_input', (['(2019)', '(6)'], {}), '(2019, 6)\n', (191, 200), False, 'from util.input_helper import read_entire_input\n'), ((1618, 1644), 'util.helpers.solution_timer', 'solution_timer', (['(2019)', '(6)', '(1)'], {}), '(2019, 6, 1)\n', (1632, 1644), False... |
import socket
MAX_PACKET_SIZE = 1024
def start_client(host=socket.gethostname(), port=5000):
# Create socket
client_socket = socket.socket()
# Connect to host and port
client_socket.connect((host, port))
# Enter a message from user
msg = input("Enter a message: ")
while msg.lower().str... | [
"socket.gethostname",
"socket.socket"
] | [((62, 82), 'socket.gethostname', 'socket.gethostname', ([], {}), '()\n', (80, 82), False, 'import socket\n'), ((136, 151), 'socket.socket', 'socket.socket', ([], {}), '()\n', (149, 151), False, 'import socket\n')] |
from math import factorial
def solve(r):
if r == 1:
return 1
elif r == 2:
return 5
elif r == 3:
return 15
fatR = factorial(r)
fatR_m1 = factorial(r-1)
comb_part_one = fatR/(2*factorial(r-2))
comb_part_two = r * (fatR_m1/(2*factorial((r-1)-2)))
arranjo = fatR / ... | [
"math.factorial"
] | [((155, 167), 'math.factorial', 'factorial', (['r'], {}), '(r)\n', (164, 167), False, 'from math import factorial\n'), ((182, 198), 'math.factorial', 'factorial', (['(r - 1)'], {}), '(r - 1)\n', (191, 198), False, 'from math import factorial\n'), ((321, 337), 'math.factorial', 'factorial', (['(r - 4)'], {}), '(r - 4)\n... |
import unittest
from fxphelper import *
C_TEST_PRECISION = 5
class TestConversion(unittest.TestCase):
def test_conv_unsigned_int(self):
x = 3
y = FXPQNumber(0,5,0, float_value = x)
self.assertAlmostEqual(y.to_float(), x, C_TEST_PRECISION)
def test_conv_signed_int(self):
x = -... | [
"unittest.main"
] | [((1004, 1019), 'unittest.main', 'unittest.main', ([], {}), '()\n', (1017, 1019), False, 'import unittest\n')] |
from rest_framework import serializers
from django.contrib.auth.models import Permission, ContentType, Group
class GroupPermissionModelSerializer(serializers.ModelSerializer):
class Meta:
model = Group
fields = '__all__'
class PermissionSimpleSerializer(serializers.ModelSerializer):
content_... | [
"rest_framework.serializers.StringRelatedField"
] | [((327, 359), 'rest_framework.serializers.StringRelatedField', 'serializers.StringRelatedField', ([], {}), '()\n', (357, 359), False, 'from rest_framework import serializers\n')] |
import FWCore.ParameterSet.Config as cms
# Remove duplicates from the electron list
electronsNoDuplicates = cms.EDFilter("DuplicatedElectronCleaner",
## reco electron input source
electronSource = cms.InputTag("gsfElectrons"),
)
| [
"FWCore.ParameterSet.Config.InputTag"
] | [((207, 235), 'FWCore.ParameterSet.Config.InputTag', 'cms.InputTag', (['"""gsfElectrons"""'], {}), "('gsfElectrons')\n", (219, 235), True, 'import FWCore.ParameterSet.Config as cms\n')] |
import json
import os
class ToolSettings:
def __init__(self, repopath, importFacePoses, DEFAULT_DIR_KEY, RECENT_FILES, RECENT_FILES_MAX):
self.repopath = repopath
self.importFacePoses = importFacePoses
self.DEFAULT_DIR_KEY = DEFAULT_DIR_KEY
self.RECENT_FILES = RECENT_FILES
... | [
"json.load",
"json.dumps",
"os.path.split"
] | [((467, 490), 'os.path.split', 'os.path.split', (['__file__'], {}), '(__file__)\n', (480, 490), False, 'import os\n'), ((745, 768), 'os.path.split', 'os.path.split', (['__file__'], {}), '(__file__)\n', (758, 768), False, 'import os\n'), ((608, 630), 'json.load', 'json.load', (['config_file'], {}), '(config_file)\n', (6... |
import streamlit as st
import pandas as pd
import numpy as np
DISPLAY_TEXT = "Display Text"
DISPLAY_DATA = "Display Data"
DISPLAY_CODE = "Display Code"
DISPLAY_GRAPHS = "Display Graphs"
USE_MEDIA = "Webcam and Microphone"
DRAWABLE_CANVAS = "Drawable Canvas"
INTERACTIVE_DISPLAY = "User interaction"
PROGRESS_AND_STATUS ... | [
"pages.progress_and_status.display_page",
"pages.display_text.display_page",
"pages.drawable_canvas.display_page",
"streamlit.sidebar.markdown",
"pages.display_graphs.display_page",
"pages.interactive_widgets.display_page",
"pages.display_data.display_page",
"streamlit.set_page_config",
"pages.displ... | [((364, 397), 'streamlit.set_page_config', 'st.set_page_config', ([], {'layout': '"""wide"""'}), "(layout='wide')\n", (382, 397), True, 'import streamlit as st\n'), ((443, 570), 'streamlit.sidebar.radio', 'st.sidebar.radio', (['"""Choose your page:"""', '[DISPLAY_TEXT, DISPLAY_DATA, DISPLAY_CODE, PROGRESS_AND_STATUS,\n... |
import requests
from bs4 import BeautifulSoup
import re
from datetime import datetime
class PageScrapper:
def __init__(self, server):
self.url = 'https://czech-craft.eu/server/' + server + '/vote/'
def CanVote(self):
page = requests.get(self.url)
if page.status_code != 200:
... | [
"bs4.BeautifulSoup",
"re.findall",
"datetime.datetime.strptime",
"requests.get"
] | [((251, 273), 'requests.get', 'requests.get', (['self.url'], {}), '(self.url)\n', (263, 273), False, 'import requests\n'), ((348, 390), 'bs4.BeautifulSoup', 'BeautifulSoup', (['page.content', '"""html.parser"""'], {}), "(page.content, 'html.parser')\n", (361, 390), False, 'from bs4 import BeautifulSoup\n'), ((624, 650)... |
#First we'll import the os module
#This will allow us to create file paths across operating systems
import os
#Module for reading CSV files
import csv
#Set path for file
csvpath = os.path.join("budget_data.csv")
#Open the csv
with open(csvpath) as csvfile:
csvreader = csv.reader(csvfile, delimiter=",")
#Rea... | [
"os.path.join",
"csv.reader"
] | [((182, 213), 'os.path.join', 'os.path.join', (['"""budget_data.csv"""'], {}), "('budget_data.csv')\n", (194, 213), False, 'import os\n'), ((276, 310), 'csv.reader', 'csv.reader', (['csvfile'], {'delimiter': '""","""'}), "(csvfile, delimiter=',')\n", (286, 310), False, 'import csv\n')] |
#%%
import matplotlib.pyplot as plt
import cv2
import numpy as np
import os
import re
from pathlib import Path
#%%
def find_contours(img):
# img channels assumed to be RGB
img_bw = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
_, thresh = cv2.threshold(img_bw, 0, 255, cv2.THRESH_BINARY_INV)
contours, _ = cv2.... | [
"cv2.fillPoly",
"os.path.exists",
"cv2.imwrite",
"os.makedirs",
"pathlib.Path",
"cv2.threshold",
"cv2.bitwise_and",
"os.path.join",
"os.path.splitext",
"cv2.contourArea",
"numpy.zeros",
"cv2.cvtColor",
"cv2.findContours",
"cv2.imread",
"cv2.boundingRect"
] | [((191, 228), 'cv2.cvtColor', 'cv2.cvtColor', (['img', 'cv2.COLOR_RGB2GRAY'], {}), '(img, cv2.COLOR_RGB2GRAY)\n', (203, 228), False, 'import cv2\n'), ((245, 297), 'cv2.threshold', 'cv2.threshold', (['img_bw', '(0)', '(255)', 'cv2.THRESH_BINARY_INV'], {}), '(img_bw, 0, 255, cv2.THRESH_BINARY_INV)\n', (258, 297), False, ... |
from tile_calculator.main import parse_args
def test_main():
parser = parse_args(["54", "18", "1", "10"])
assert parser.latitude == 54
assert parser.longitude == 18
assert parser.radius == 1
assert parser.zoom_level == 10
assert not parser.miles
assert not parser.total_only
| [
"tile_calculator.main.parse_args"
] | [((76, 111), 'tile_calculator.main.parse_args', 'parse_args', (["['54', '18', '1', '10']"], {}), "(['54', '18', '1', '10'])\n", (86, 111), False, 'from tile_calculator.main import parse_args\n')] |
#!/usr/bin/env python3
"""
Usage:
run_clust.py (create|run) <path> [options] [--] [<add_args> ...]
Options:
Logging:
--log <level> Level of stdout logging [default: INFO]
--lformat <level> Which formatter to use [default: extended]
Experiments:
--raw ... | [
"pathlib.Path",
"vst.reasonable_logging_setup",
"dervo.experiment.run_cluster_experiment",
"dervo.snippets.loglevel_int_to_str",
"dervo.snippets.find_exp_path",
"dervo.experiment.prepare_cluster_experiment",
"docopt.docopt"
] | [((871, 932), 'vst.reasonable_logging_setup', 'vst.reasonable_logging_setup', (['loglevel_int', "args['--lformat']"], {}), "(loglevel_int, args['--lformat'])\n", (899, 932), False, 'import vst\n'), ((1543, 1558), 'docopt.docopt', 'docopt', (['__doc__'], {}), '(__doc__)\n', (1549, 1558), False, 'from docopt import docop... |
from django.contrib.auth.decorators import login_required
from django.contrib.admin.views.decorators import staff_member_required
from django.shortcuts import render, redirect, get_object_or_404
from django.http import Http404
from catalog.models import Paper, Person, Dataset, Venue, Comment, Code
from catalog.models i... | [
"catalog.forms.PaperForm",
"catalog.forms.SearchDatasetsForm",
"re.compile",
"catalog.models.Comment",
"urllib.request.Request",
"catalog.forms.SearchVenuesForm",
"catalog.forms.PaperConnectionForm",
"catalog.forms.PaperImportForm",
"catalog.models.ReadingGroup.objects.all",
"django.urls.reverse",... | [((5612, 5725), 'django.shortcuts.render', 'render', (['request', '"""paper_authors.html"""', "{'authors': authors, 'paper': paper, 'number_of_authors': num_authors}"], {}), "(request, 'paper_authors.html', {'authors': authors, 'paper': paper,\n 'number_of_authors': num_authors})\n", (5618, 5725), False, 'from djang... |
import multiprocessing
debug = False
bind = "0.0.0.0:5000"
pidfile = "gunicorn.pid"
workers = multiprocessing.cpu_count()*2 + 1
worker_class = "gevent"
# daemon=True 在docker中不需要daemon运行，反而会导致看不到gunicorn输出而增加排查问题的难度 | [
"multiprocessing.cpu_count"
] | [((94, 121), 'multiprocessing.cpu_count', 'multiprocessing.cpu_count', ([], {}), '()\n', (119, 121), False, 'import multiprocessing\n')] |
from django.apps import AppConfig
from django.utils.translation import gettext_lazy as _
class MicroblogConfig(AppConfig):
name = 'microblog'
verbose_name = _('Blog')
| [
"django.utils.translation.gettext_lazy"
] | [((167, 176), 'django.utils.translation.gettext_lazy', '_', (['"""Blog"""'], {}), "('Blog')\n", (168, 176), True, 'from django.utils.translation import gettext_lazy as _\n')] |
# Copyright 2014 Google Inc. All Rights Reserved.
"""Implements the command for SSHing into an instance."""
import getpass
from googlecloudsdk.calliope import exceptions
from googlecloudsdk.compute.lib import ssh_utils
from googlecloudsdk.compute.lib import utils
class SSH(ssh_utils.BaseSSHCLICommand):
"""SSH int... | [
"getpass.getuser",
"googlecloudsdk.compute.lib.utils.AddZoneFlag",
"googlecloudsdk.compute.lib.ssh_utils.UserHost",
"googlecloudsdk.compute.lib.ssh_utils.BaseSSHCLICommand.Args"
] | [((394, 434), 'googlecloudsdk.compute.lib.ssh_utils.BaseSSHCLICommand.Args', 'ssh_utils.BaseSSHCLICommand.Args', (['parser'], {}), '(parser)\n', (426, 434), False, 'from googlecloudsdk.compute.lib import ssh_utils\n'), ((2033, 2118), 'googlecloudsdk.compute.lib.utils.AddZoneFlag', 'utils.AddZoneFlag', (['parser'], {'re... |
from sklearn.preprocessing import scale
import numpy as np
class GradientDescent:
learning_rate = 0.01
max_iter = 2000
scale = False
new_theta = []
def __init__(self, learning_rate=0.01, max_iter=2000, scale=False):
self.learning_rate = learning_rate
self.max_ite... | [
"numpy.array",
"numpy.dot",
"numpy.transpose",
"sklearn.preprocessing.scale"
] | [((616, 634), 'numpy.array', 'np.array', (['[zeroes]'], {}), '([zeroes])\n', (624, 634), True, 'import numpy as np\n'), ((467, 475), 'sklearn.preprocessing.scale', 'scale', (['X'], {}), '(X)\n', (472, 475), False, 'from sklearn.preprocessing import scale\n'), ((697, 713), 'numpy.dot', 'np.dot', (['theta', 'X'], {}), '(... |
# Copyright (c) 2013 <NAME>
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may not
# use this file except in compliance with the License. You may obtain a copy of
# the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, softw... | [
"ratatosk.log.get_logger",
"luigi.Parameter",
"ratatosk.utils.fullclassname"
] | [((937, 949), 'ratatosk.log.get_logger', 'get_logger', ([], {}), '()\n', (947, 949), False, 'from ratatosk.log import get_logger\n'), ((1332, 1364), 'luigi.Parameter', 'luigi.Parameter', ([], {'default': '"""bgzip"""'}), "(default='bgzip')\n", (1347, 1364), False, 'import luigi\n'), ((1383, 1451), 'luigi.Parameter', 'l... |
import os,sys
import numpy as np
import random
import matplotlib.pyplot as plt
import seaborn as sns
from copy import deepcopy
import math
import torch
import torch.nn as nn
from tqdm import tqdm
from torch._six import inf
import pandas as pd
from PIL import Image
from sklearn.feature_extraction import image
from argum... | [
"copy.deepcopy",
"torch.nn.CrossEntropyLoss",
"sklearn.feature_extraction.image.mean",
"torch.mean",
"torch.no_grad",
"torch.utils.data.DataLoader",
"arguments.get_args",
"unicodedata.numeric",
"sklearn.feature_extraction.image.size",
"torch.nn.functional.softmax"
] | [((348, 358), 'arguments.get_args', 'get_args', ([], {}), '()\n', (356, 358), False, 'from arguments import get_args\n'), ((2982, 2997), 'copy.deepcopy', 'deepcopy', (['model'], {}), '(model)\n', (2990, 2997), False, 'from copy import deepcopy\n'), ((3781, 3846), 'torch.utils.data.DataLoader', 'torch.utils.data.DataLoa... |
# -*- coding: utf-8 -*-
"""
@author: miko
"""
from sklearn.feature_extraction import DictVectorizer
import csv
from sklearn import tree
from sklearn import preprocessing
from sklearn.externals.six import StringIO
import numpy as np
np.set_printoptions(threshold = 1e6)#设置打印数量的阈值
# Read in the csv file and put feat... | [
"sklearn.preprocessing.LabelBinarizer",
"sklearn.feature_extraction.DictVectorizer",
"sklearn.tree.DecisionTreeClassifier",
"csv.reader",
"numpy.set_printoptions"
] | [((236, 276), 'numpy.set_printoptions', 'np.set_printoptions', ([], {'threshold': '(1000000.0)'}), '(threshold=1000000.0)\n', (255, 276), True, 'import numpy as np\n'), ((512, 542), 'csv.reader', 'csv.reader', (['allElectronicsData'], {}), '(allElectronicsData)\n', (522, 542), False, 'import csv\n'), ((1073, 1089), 'sk... |
# -*- coding: utf-8 -*-
"""
Bot behavior
"""
from irc3 import plugin, event, rfc
from irc3.plugins.cron import cron
from lxml import html
import aiohttp
import random
import re
@plugin
class Behaviors(object):
"""
Defines bot's behavior by scheduling actions or handling channel events
"""
def... | [
"aiohttp.ClientSession",
"random.choice",
"re.compile",
"lxml.html.fromstring",
"irc3.plugins.cron.cron",
"irc3.event"
] | [((1210, 1229), 'irc3.plugins.cron.cron', 'cron', (['"""0 9 * * 1-5"""'], {}), "('0 9 * * 1-5')\n", (1214, 1229), False, 'from irc3.plugins.cron import cron\n'), ((1695, 1715), 'irc3.plugins.cron.cron', 'cron', (['"""0 12 * * 1-5"""'], {}), "('0 12 * * 1-5')\n", (1699, 1715), False, 'from irc3.plugins.cron import cron\... |
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.conf import settings
from django.core import validators
from django.db import models
from django.db.models import fields as django_fields
from django.db.models.signals import pre_save, post_save
from django.dispatch import receiver
from django... | [
"django.dispatch.receiver",
"django.utils.translation.ugettext_lazy",
"django.core.validators._lazy_re_compile"
] | [((561, 698), 'django.utils.translation.ugettext_lazy', '_', (['"""Kurzfassung des Namens für die Adresszeile im Browser. Vorzugsweise englisch, keine Umlaute, nur Bindestrich als Sonderzeichen."""'], {}), "('Kurzfassung des Namens für die Adresszeile im Browser. Vorzugsweise englisch, keine Umlaute, nur Bindestrich al... |
import unittest
from forestgame.colour import colour_to_hex
class ToHexTest(unittest.TestCase):
def test_convert_solid_black(self):
hex_code = colour_to_hex((0, 0, 0))
self.assertEqual(hex_code, "#000000")
def test_convert_solid_whex_codeite(self):
hex_code = colour_to_hex((255, 255, 255))
self.a... | [
"forestgame.colour.colour_to_hex"
] | [((151, 175), 'forestgame.colour.colour_to_hex', 'colour_to_hex', (['(0, 0, 0)'], {}), '((0, 0, 0))\n', (164, 175), False, 'from forestgame.colour import colour_to_hex\n'), ((279, 309), 'forestgame.colour.colour_to_hex', 'colour_to_hex', (['(255, 255, 255)'], {}), '((255, 255, 255))\n', (292, 309), False, 'from forestg... |
from setuptools import setup
NAME = 'XOR_CheckSum_zsd'
VERSION = '1.0.7'
URL = 'https://github.com/zhangsheng377/XOR_CheckSum_zsd'
KEYWORDS = 'XOR checksum string zsd'
EMAIL = '<EMAIL>'
DESCRIPTION = 'XOR_CheckSum tools'
LONG_DESCRIPTION = '''
\>\>\> from XOR_CheckSum import xor_checksum_string
\>\>\> xor_checksum_st... | [
"setuptools.setup"
] | [((593, 1119), 'setuptools.setup', 'setup', ([], {'name': 'NAME', 'author': '"""zhangsheng377"""', 'license': '"""MIT"""', 'zip_safe': '(False)', 'url': 'URL', 'version': 'VERSION', 'description': 'DESCRIPTION', 'long_description': 'LONG_DESCRIPTION', 'author_email': 'EMAIL', 'keywords': 'KEYWORDS', 'install_requires':... |
from django.shortcuts import redirect
def index(request):
return redirect('/home/') | [
"django.shortcuts.redirect"
] | [((68, 86), 'django.shortcuts.redirect', 'redirect', (['"""/home/"""'], {}), "('/home/')\n", (76, 86), False, 'from django.shortcuts import redirect\n')] |
import os, sys
import logging
import weakref
import pygame
from .resourceLoaders import *
class ResourceError(Exception):
pass
_GAME_PATH=calculate_real_path(os.path.dirname(sys.argv[0]))
def _BuildLogger():
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
log_format = logging.F... | [
"logging.getLogger",
"logging.Formatter",
"os.path.dirname",
"os.path.isdir",
"weakref.ref"
] | [((167, 195), 'os.path.dirname', 'os.path.dirname', (['sys.argv[0]'], {}), '(sys.argv[0])\n', (182, 195), False, 'import os, sys\n'), ((231, 258), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (248, 258), False, 'import logging\n'), ((311, 373), 'logging.Formatter', 'logging.Formatter', ... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Jan 16 15:57:57 2020
@author: snoone
"""
###FTP transfer of most up to date diff file for the GHCND from NOAA/NCEI
#####
import ftplib
import os
os.chdir(r"/gws/nopw/j04/c3s311a_lot2/data/level0/land/daily_data_processing/superghc... | [
"os.chdir",
"ftplib.FTP"
] | [((235, 347), 'os.chdir', 'os.chdir', (['"""/gws/nopw/j04/c3s311a_lot2/data/level0/land/daily_data_processing/superghcnd_daily_updates"""'], {}), "(\n '/gws/nopw/j04/c3s311a_lot2/data/level0/land/daily_data_processing/superghcnd_daily_updates'\n )\n", (243, 347), False, 'import os\n'), ((421, 452), 'ftplib.FTP', ... |
"""Data generator for image datasets."""
import itertools
import random
import numpy as np
from kaishi.image.util import swap_channel_dimension
from kaishi.image import ops
def augment_and_label(imobj):
"""Augment an image with common issues and return the modified image + label vector.
Labels at output laye... | [
"itertools.cycle",
"kaishi.image.util.swap_channel_dimension",
"random.shuffle",
"kaishi.image.ops.add_stretching",
"numpy.random.random",
"random.seed",
"numpy.stack",
"numpy.zeros",
"kaishi.image.ops.add_rotation",
"numpy.random.seed",
"kaishi.image.ops.extract_patch"
] | [((684, 698), 'numpy.zeros', 'np.zeros', (['(6,)'], {}), '((6,))\n', (692, 698), True, 'import numpy as np\n'), ((966, 984), 'numpy.random.random', 'np.random.random', ([], {}), '()\n', (982, 984), True, 'import numpy as np\n'), ((1422, 1440), 'numpy.random.random', 'np.random.random', ([], {}), '()\n', (1438, 1440), T... |
import unittest
from nlu import *
class TestMarian(unittest.TestCase):
# GENERATE NAME SPACE ENTRIES PROGRAMMATICLY?!??
def test_marian_en_to_de(self):
pipe = nlu.load('en.translate_to.de',verbose=True)
print('QQP')
# pipe.print_info()
# pipe['t5'].setTask('Answer the question')
... | [
"unittest.main"
] | [((2940, 2955), 'unittest.main', 'unittest.main', ([], {}), '()\n', (2953, 2955), False, 'import unittest\n')] |
# Generated by Django 2.2.10 on 2020-04-29 14:01
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('api', '0024_auto_20200423_1601'),
]
operations = [
migrations.AlterField(
model_name='imagereport',
name='status',
... | [
"django.db.migrations.DeleteModel",
"django.db.models.CharField"
] | [((560, 600), 'django.db.migrations.DeleteModel', 'migrations.DeleteModel', ([], {'name': '"""ImageTags"""'}), "(name='ImageTags')\n", (582, 600), False, 'from django.db import migrations, models\n'), ((338, 549), 'django.db.models.CharField', 'models.CharField', ([], {'choices': "[('pending_review', 'pending_review'),... |
import pytest
from streaming_form_data.validators import MaxSizeValidator, ValidationError
def test_max_size_validator_empty_input():
validator = MaxSizeValidator(0)
with pytest.raises(ValidationError):
validator('x')
def test_max_size_validator_normal():
validator = MaxSizeValidator(5)
f... | [
"streaming_form_data.validators.MaxSizeValidator",
"pytest.raises"
] | [((153, 172), 'streaming_form_data.validators.MaxSizeValidator', 'MaxSizeValidator', (['(0)'], {}), '(0)\n', (169, 172), False, 'from streaming_form_data.validators import MaxSizeValidator, ValidationError\n'), ((294, 313), 'streaming_form_data.validators.MaxSizeValidator', 'MaxSizeValidator', (['(5)'], {}), '(5)\n', (... |
import os;
import abc;
import math;
import multiprocessing;
import psutil;
import numpy as np;
import matplotlib.pyplot as plt;
from Errors import *;
from KMeans import *;
from UnaryLinearRegression import *;
class _Node:
def __init__(self, samplesCount, featureIndex = None, featureValue = None, leftChild = None... | [
"numpy.mat",
"numpy.mean",
"numpy.random.random",
"numpy.random.choice",
"numpy.log",
"matplotlib.pyplot.plot",
"numpy.quantile",
"matplotlib.pyplot.figure",
"psutil.cpu_count",
"numpy.arange",
"matplotlib.pyplot.show"
] | [((6468, 6506), 'numpy.quantile', 'np.quantile', (['scores', 'self.__proportion'], {}), '(scores, self.__proportion)\n', (6479, 6506), True, 'import numpy as np\n'), ((11234, 11254), 'numpy.mat', 'np.mat', (['self._curves'], {}), '(self._curves)\n', (11240, 11254), True, 'import numpy as np\n'), ((2021, 2030), 'numpy.l... |
import torch
def model_to_vector(model, emb_layer_name='input_emb'):
"""
get the wordvec weight
:param model:
:param emb_layer_name:
:return:
"""
sd = model.state_dict()
return sd[emb_layer_name + '.weight'].cpu().numpy().tolist()
def save_embedding(file_name, embeddings, id2word):
... | [
"torch.tensor"
] | [((1010, 1055), 'torch.tensor', 'torch.tensor', (['vali_examples'], {'dtype': 'torch.long'}), '(vali_examples, dtype=torch.long)\n', (1022, 1055), False, 'import torch\n')] |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Oct 15 15:13:29 2018
@author: kazuki.onodera
"""
import numpy as np
import pandas as pd
import os, gc
from glob import glob
from tqdm import tqdm
import sys
sys.path.append(f'/home/{os.environ.get("USER")}/PythonLibrary')
import lgbextension as ex
imp... | [
"numpy.clip",
"pandas.read_csv",
"utils.send_line",
"numpy.log",
"multiprocessing.cpu_count",
"utils.start",
"lightgbm.Dataset",
"utils.submit",
"utils.savefig_sub",
"pandas.read_feather",
"pandas.DataFrame",
"glob.glob",
"utils.stop_instance",
"numpy.ones",
"utils.savefig_imp",
"gc.co... | [((392, 413), 'utils.start', 'utils.start', (['__file__'], {}), '(__file__)\n', (403, 413), False, 'import utils\n'), ((627, 650), 'numpy.random.randint', 'np.random.randint', (['(9999)'], {}), '(9999)\n', (644, 650), True, 'import numpy as np\n'), ((2473, 2485), 'gc.collect', 'gc.collect', ([], {}), '()\n', (2483, 248... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
from setuptools import setup, find_packages
import sys, os
import tracking
setup(
name='django-tracking',
version=tracking.get_version(),
description="Basic visitor tracking and blacklisting for Django",
long_description=open('README.rst', 'r').read(),
... | [
"setuptools.find_packages",
"tracking.get_version"
] | [((170, 192), 'tracking.get_version', 'tracking.get_version', ([], {}), '()\n', (190, 192), False, 'import tracking\n'), ((572, 587), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (585, 587), False, 'from setuptools import setup, find_packages\n')] |
#!/usr/bin/python
# (c) 2018, NetApp, Inc
# GNU General Public License v3.0+ (see COPYING or https://www.gnu.org/licenses/gpl-3.0.txt)
from __future__ import absolute_import, division, print_function
__metaclass__ = type
DOCUMENTATION = """
---
module: update_file_list
short_description: Update log file containing c... | [
"ansible.module_utils.basic.AnsibleModule"
] | [((1838, 1937), 'ansible.module_utils.basic.AnsibleModule', 'AnsibleModule', ([], {'argument_spec': 'ansible_options', 'required_if': 'required_if', 'supports_check_mode': '(True)'}), '(argument_spec=ansible_options, required_if=required_if,\n supports_check_mode=True)\n', (1851, 1937), False, 'from ansible.module_u... |
import os
import subprocess
def render_movie(output_filename, frames_dir, frame_rate):
subprocess.call([
'ffmpeg', '-vcodec', 'png', '-framerate',
str(frame_rate), '-i',
os.path.join(frames_dir, r'frame.%06d.png'), '-pix_fmt', 'yuv420p',
'-vcodec', 'libx264', '-crf', '17', '-thread... | [
"os.path.join"
] | [((200, 242), 'os.path.join', 'os.path.join', (['frames_dir', '"""frame.%06d.png"""'], {}), "(frames_dir, 'frame.%06d.png')\n", (212, 242), False, 'import os\n')] |
import sys
import os
import numpy.random
from amuse.test import amusetest
from amuse.units import units, nbody_system
from amuse.ext.boss_bodenheimer import bb79_cloud
numpy.random.seed(1234567)
class BossBodenheimerTests(amusetest.TestCase):
def test1(self):
numpy.random.seed(1234)
mc=bb79_cloud... | [
"amuse.ext.boss_bodenheimer.bb79_cloud",
"amuse.units.nbody_system.nbody_to_si"
] | [((659, 721), 'amuse.units.nbody_system.nbody_to_si', 'nbody_system.nbody_to_si', (['(1.0 | units.MSun)', '(3.2e+16 | units.cm)'], {}), '(1.0 | units.MSun, 3.2e+16 | units.cm)\n', (683, 721), False, 'from amuse.units import units, nbody_system\n'), ((310, 334), 'amuse.ext.boss_bodenheimer.bb79_cloud', 'bb79_cloud', ([]... |
#!/usr/bin/env python
# Copyright 2018- The Pixie Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicabl... | [
"ssl.create_default_context",
"time.sleep",
"random.randint",
"socket.socket"
] | [((868, 939), 'ssl.create_default_context', 'ssl.create_default_context', (['ssl.Purpose.SERVER_AUTH'], {'cafile': 'server_cert'}), '(ssl.Purpose.SERVER_AUTH, cafile=server_cert)\n', (894, 939), False, 'import ssl\n'), ((1011, 1060), 'socket.socket', 'socket.socket', (['socket.AF_INET', 'socket.SOCK_STREAM'], {}), '(so... |
"""
Copyright 2012-2019 <NAME>
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
di... | [
"hqlib.utils.format_link_object"
] | [((1893, 1933), 'hqlib.utils.format_link_object', 'utils.format_link_object', (['cve[1]', 'cve[0]'], {}), '(cve[1], cve[0])\n', (1917, 1933), False, 'from hqlib import utils\n')] |
# This script goes through OpenSim funcionalties
# required for OpenSim-RL
import opensim
# Settings
stepsize = 0.01
# Load existing model
model_path = "../osim/models/gait9dof18musc.osim"
model = opensim.Model(model_path)
model.setUseVisualizer(True)
# Create the ball
r = 0.000001
ballBody = opensim.B... | [
"opensim.Manager",
"opensim.Model",
"opensim.Inertia",
"opensim.Ellipsoid",
"opensim.Vec3"
] | [((208, 233), 'opensim.Model', 'opensim.Model', (['model_path'], {}), '(model_path)\n', (221, 233), False, 'import opensim\n'), ((410, 436), 'opensim.Ellipsoid', 'opensim.Ellipsoid', (['r', 'r', 'r'], {}), '(r, r, r)\n', (427, 436), False, 'import opensim\n'), ((1273, 1295), 'opensim.Manager', 'opensim.Manager', (['mod... |
#!/usr/bin/env python
import os
import sys
BASE_APP_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.append(os.path.join(BASE_APP_DIR, 'src/'))
sys.path.append(os.path.join(BASE_APP_DIR, 'venv/lib/python3.4/site-packages'))
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "app.settings")
fr... | [
"os.environ.setdefault",
"django.core.wsgi.get_wsgi_application",
"os.path.join",
"os.path.abspath"
] | [((253, 316), 'os.environ.setdefault', 'os.environ.setdefault', (['"""DJANGO_SETTINGS_MODULE"""', '"""app.settings"""'], {}), "('DJANGO_SETTINGS_MODULE', 'app.settings')\n", (274, 316), False, 'import os\n'), ((382, 404), 'django.core.wsgi.get_wsgi_application', 'get_wsgi_application', ([], {}), '()\n', (402, 404), Fal... |
# Generated by Django 3.1.7 on 2021-04-07 15:24
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('projectroles', '0019_project_public_guest_access'),
('timeline', '0006_update_user_optional'),
]
operations... | [
"django.db.models.ForeignKey"
] | [((441, 648), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'help_text': '"""Project to which the event belongs (null for no project)"""', 'null': '(True)', 'on_delete': 'django.db.models.deletion.CASCADE', 'related_name': '"""events"""', 'to': '"""projectroles.project"""'}), "(help_text=\n 'Project to w... |
from collections import defaultdict
def dict_sample_target_iter_concat(sample_target_iter: iter):
"""Gets an sample target iterator of dict samples.
Returns a concatenation of the samples based on each key and the
target list.
Example:
::
sample_target_iter = [({'a': 'a1', 'b': 'b1'},... | [
"collections.defaultdict"
] | [((546, 563), 'collections.defaultdict', 'defaultdict', (['list'], {}), '(list)\n', (557, 563), False, 'from collections import defaultdict\n')] |
# coding: utf-8
from __future__ import absolute_import
from datetime import date, datetime # noqa: F401
from typing import List, Dict # noqa: F401
from tapi_server.models.base_model_ import Model
from tapi_server.models.tapi_common_local_class import TapiCommonLocalClass # noqa: F401,E501
from tapi_server.models.... | [
"tapi_server.util.deserialize_model"
] | [((2650, 2683), 'tapi_server.util.deserialize_model', 'util.deserialize_model', (['dikt', 'cls'], {}), '(dikt, cls)\n', (2672, 2683), False, 'from tapi_server import util\n')] |
from projex.lazymodule import lazy_import
from ..sqliteconnection import SQLiteStatement
orb = lazy_import('orb')
class CREATE(SQLiteStatement):
def __call__(self, model, owner='', includeReferences=True):
if issubclass(model, orb.Table):
return self._createTable(model, owner, includeReferenc... | [
"projex.lazymodule.lazy_import"
] | [((96, 114), 'projex.lazymodule.lazy_import', 'lazy_import', (['"""orb"""'], {}), "('orb')\n", (107, 114), False, 'from projex.lazymodule import lazy_import\n')] |
from raytkTools import RaytkTools
# noinspection PyUnreachableCode
if False:
# noinspection PyUnresolvedReferences
from _stubs import *
from ..ropEditor.ropEditor import ROPEditor
iop.ropEditor = ROPEditor(COMP())
class CreateRopDialog:
def __init__(self, ownerComp: 'COMP'):
self.ownerComp = ownerComp
def _s... | [
"raytkTools.RaytkTools"
] | [((894, 906), 'raytkTools.RaytkTools', 'RaytkTools', ([], {}), '()\n', (904, 906), False, 'from raytkTools import RaytkTools\n')] |
"""
Test the stream module
Does it provide an interface compatible with circus?
"""
from calendar import timegm
from io import StringIO
from pytest import fixture
from mock import patch
from codado import parseDate, py
from circusbase import stream
@fixture
def stdoutStream(pRemoji):
ret = stream.EmojiStdout... | [
"mock.patch.object",
"circusbase.stream.EmojiStdoutStream",
"io.StringIO",
"codado.parseDate"
] | [((302, 328), 'circusbase.stream.EmojiStdoutStream', 'stream.EmojiStdoutStream', ([], {}), '()\n', (326, 328), False, 'from circusbase import stream\n'), ((344, 354), 'io.StringIO', 'StringIO', ([], {}), '()\n', (352, 354), False, 'from io import StringIO\n'), ((656, 693), 'codado.parseDate', 'parseDate', (['"""2018-11... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu Jul 19 15:37:36 2018
@author: phoenix
"""
import glob
path = glob.glob('dataset/*')
for each in path:
print(glob.glob(each+'/*')[0].split('/')[1])
dynamic_dict = { glob.glob(each+'/*')[0].split('/')[1]:glob.glob(each+'/*')[0] for each in path}
pr... | [
"glob.glob"
] | [((130, 152), 'glob.glob', 'glob.glob', (['"""dataset/*"""'], {}), "('dataset/*')\n", (139, 152), False, 'import glob\n'), ((276, 298), 'glob.glob', 'glob.glob', (["(each + '/*')"], {}), "(each + '/*')\n", (285, 298), False, 'import glob\n'), ((238, 260), 'glob.glob', 'glob.glob', (["(each + '/*')"], {}), "(each + '/*'... |
import typer
cli = typer.Typer()
| [
"typer.Typer"
] | [((20, 33), 'typer.Typer', 'typer.Typer', ([], {}), '()\n', (31, 33), False, 'import typer\n')] |
"""ResNets.
With only TensorFlow backend.
Follows fchollet's design
Author: <NAME>
Email : <EMAIL>
"""
from __future__ import print_function, absolute_import
from builtins import range
from spiker import log
logger = log.get_logger("models-resnet", log.DEBUG)
try:
from keras.layers import Input
from keras... | [
"keras.layers.add",
"keras.layers.Input",
"builtins.range",
"spiker.log.get_logger",
"keras.layers.Activation",
"keras.models.Model",
"keras.regularizers.l2",
"keras.layers.GlobalAveragePooling2D",
"keras.layers.BatchNormalization"
] | [((222, 264), 'spiker.log.get_logger', 'log.get_logger', (['"""models-resnet"""', 'log.DEBUG'], {}), "('models-resnet', log.DEBUG)\n", (236, 264), False, 'from spiker import log\n'), ((3569, 3587), 'keras.layers.add', 'add', (['[x, shortcut]'], {}), '([x, shortcut])\n', (3572, 3587), False, 'from keras.layers import ad... |
from pathlib import Path
from openpecha import formatters
from openpecha.formatters import PedurmaFormatter
from openpecha.serializers import PedurmaSerializer
if __name__ == "__main__":
opf_path = "./output/opfs/D1111/D1111.opf/"
opfs_path = "./output/opfs/"
preview_path = "./output/D1111/"
# previe... | [
"openpecha.serializers.PedurmaSerializer",
"openpecha.formatters.PedurmaFormatter"
] | [((345, 384), 'openpecha.formatters.PedurmaFormatter', 'PedurmaFormatter', ([], {'output_path': 'opfs_path'}), '(output_path=opfs_path)\n', (361, 384), False, 'from openpecha.formatters import PedurmaFormatter\n'), ((466, 493), 'openpecha.serializers.PedurmaSerializer', 'PedurmaSerializer', (['opf_path'], {}), '(opf_pa... |
from logmagic.loggerutil import make_logger
from unittest import TestCase
import unittest
import sys
from io import StringIO
import contextlib
import re
class ConsoleOutTest(TestCase):
def test_debugout(self):
# global saved_stdout # Use sys.__stdout__ instead
# saved_stdout = sys.stdout
... | [
"contextlib.redirect_stdout",
"re.fullmatch",
"contextlib.redirect_stderr",
"logmagic.loggerutil.make_logger",
"unittest.main",
"io.StringIO"
] | [((978, 993), 'unittest.main', 'unittest.main', ([], {}), '()\n', (991, 993), False, 'import unittest\n'), ((361, 371), 'io.StringIO', 'StringIO', ([], {}), '()\n', (369, 371), False, 'from io import StringIO\n'), ((740, 890), 're.fullmatch', 're.fullmatch', (['"""[0-9]{4}\\\\-[0-9]{2}\\\\-[0-9]{2} [0-9]{2}:[0-9]{2}:[0... |
import logging
import re
import gzip
from pathlib import Path
from argparse import ArgumentParser
from Bio import AlignIO
from make_prg.from_msa import MSA
from make_prg.prg_encoder import PrgEncoder, PRG_Ints
def load_alignment_file(msa_file: str, alignment_format: str) -> MSA:
msa_file = str(msa_file)
log... | [
"Bio.AlignIO.read",
"logging.debug",
"gzip.open",
"make_prg.prg_encoder.PrgEncoder",
"re.finditer",
"logging.info"
] | [((317, 364), 'logging.info', 'logging.info', (['"""Read from MSA file %s"""', 'msa_file'], {}), "('Read from MSA file %s', msa_file)\n", (329, 364), False, 'import logging\n'), ((406, 437), 'logging.debug', 'logging.debug', (['"""MSA is gzipped"""'], {}), "('MSA is gzipped')\n", (419, 437), False, 'import logging\n'),... |
from __future__ import print_function
import os
import warnings
import shutil
import re
import numpy as np
import sami
from astropy.io import fits
class Tester():
"""This class handles the testing of the SAMI pipeline. To run it requires
additional data:
1) the folder ``sami_ppl_test_data``, i.e. th... | [
"os.path.exists",
"re.compile",
"numpy.testing.assert_allclose",
"shutil.rmtree",
"os.path.basename",
"astropy.io.fits.open",
"warnings.warn",
"numpy.all",
"os.walk",
"sami.manager.Manager"
] | [((5894, 5937), 'sami.manager.Manager', 'sami.manager.Manager', (['output_dir'], {'fast': 'fast'}), '(output_dir, fast=fast)\n', (5914, 5937), False, 'import sami\n'), ((8989, 9006), 'numpy.all', 'np.all', (['all_equal'], {}), '(all_equal)\n', (8995, 9006), True, 'import numpy as np\n'), ((11015, 11032), 're.compile', ... |
from __future__ import absolute_import, division, print_function, unicode_literals
import csv
def csv_filename_to_objects(filename, json_handler):
with open(filename, "r") as f:
objects = csv_stream_to_objects(f, json_handler=json_handler)
return objects
def csv_stream_to_objects(stream, json_handl... | [
"csv.DictWriter",
"csv.DictReader"
] | [((353, 375), 'csv.DictReader', 'csv.DictReader', (['stream'], {}), '(stream)\n', (367, 375), False, 'import csv\n'), ((1204, 1249), 'csv.DictWriter', 'csv.DictWriter', (['stream'], {'fieldnames': 'fieldnames'}), '(stream, fieldnames=fieldnames)\n', (1218, 1249), False, 'import csv\n')] |
import os, re
FILE_DIR = os.path.dirname(os.path.abspath(__file__))
README_PATH = os.path.join(FILE_DIR, os.pardir, 'README.md')
README_CODE_PATH = os.path.join(FILE_DIR, 'README_commands.py')
CODE_INIT = '''
#------------ CODE INIT ------------
# make sure imports from ../src work
import os, sys
FILE_DIR = os.path.d... | [
"os.path.abspath",
"os.path.join",
"re.match"
] | [((83, 129), 'os.path.join', 'os.path.join', (['FILE_DIR', 'os.pardir', '"""README.md"""'], {}), "(FILE_DIR, os.pardir, 'README.md')\n", (95, 129), False, 'import os, re\n'), ((149, 193), 'os.path.join', 'os.path.join', (['FILE_DIR', '"""README_commands.py"""'], {}), "(FILE_DIR, 'README_commands.py')\n", (161, 193), Fa... |
#!/usr/bin/env python3
import os, re, random
import numpy as np
from myClass import Theta
from functions import grad_loss
from hyperParameters import hyperParameters
# hyperParameters
T, D = hyperParameters.T, hyperParameters.D
alpha, epsilon = hyperParameters.alpha, hyperParameters.epsilon
moment = hyperParameters.m... | [
"functions.grad_loss",
"os.listdir",
"os.getcwd",
"numpy.array",
"numpy.zeros",
"re.search"
] | [((359, 370), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (368, 370), False, 'import os, re, random\n'), ((430, 445), 'os.listdir', 'os.listdir', (['dir'], {}), '(dir)\n', (440, 445), False, 'import os, re, random\n'), ((449, 478), 're.search', 're.search', (['"""_graph.txt"""', 'file'], {}), "('_graph.txt', file)\n", ... |
from netmiko import ConnectHandler
# our devices info to connect and session log files to save output
arista_1 = {
'device_type': 'arista_eos',
'ip': 'your_ip',
'username': 'your_username',
'password': '<PASSWORD>',
'session_log': 'sw1.txt'
}
arista_2 = {
'device_type': 'arista_eos',
'ip':... | [
"netmiko.ConnectHandler"
] | [((872, 896), 'netmiko.ConnectHandler', 'ConnectHandler', ([], {}), '(**device)\n', (886, 896), False, 'from netmiko import ConnectHandler\n')] |
from django.contrib.auth import authenticate
from rest_framework import viewsets
from rest_framework.authtoken.models import Token
from rest_framework.authentication import TokenAuthentication
from rest_framework.permissions import IsAuthenticated
from rest_framework.response import Response
from rest_framework.status ... | [
"rest_framework.response.Response",
"rest_framework.authtoken.models.Token.objects.get_or_create"
] | [((784, 822), 'rest_framework.authtoken.models.Token.objects.get_or_create', 'Token.objects.get_or_create', ([], {'user': 'user'}), '(user=user)\n', (811, 822), False, 'from rest_framework.authtoken.models import Token\n'), ((838, 888), 'rest_framework.response.Response', 'Response', (["{'token': token.key}"], {'status... |
"""empty message
Revision ID: f5a5f9bbd6e2
Revises: <PASSWORD>
Create Date: 2018-04-20 19:02:32.403757
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision = 'f5a5f9bbd6e2'
down_revision = '<PASSWORD>'
branch_labels = None
depends_on = None
def upgrade():
op.add... | [
"alembic.op.drop_constraint",
"alembic.op.drop_column",
"sqlalchemy.Integer",
"alembic.op.create_foreign_key"
] | [((404, 503), 'alembic.op.create_foreign_key', 'op.create_foreign_key', (['"""fk_categories_file"""', '"""categories"""', '"""files"""', "['cover_image_id']", "['id']"], {}), "('fk_categories_file', 'categories', 'files', [\n 'cover_image_id'], ['id'])\n", (425, 503), False, 'from alembic import op\n'), ((589, 680),... |
from __future__ import annotations
import pygame
from scripts.engine import world
from scripts.engine.component import Position
from scripts.engine.core import queries
from scripts.engine.core.constants import GameEvent
__all__ = ["process_win_condition"]
def process_win_condition():
"""
Process the win co... | [
"scripts.engine.world.get_entitys_component",
"scripts.engine.world.get_player",
"pygame.event.post",
"pygame.event.Event"
] | [((380, 398), 'scripts.engine.world.get_player', 'world.get_player', ([], {}), '()\n', (396, 398), False, 'from scripts.engine import world\n'), ((416, 461), 'scripts.engine.world.get_entitys_component', 'world.get_entitys_component', (['player', 'Position'], {}), '(player, Position)\n', (443, 461), False, 'from script... |
# Generated by Django 3.1.5 on 2021-09-02 21:07
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('newapp1', '0004_auto_20210830_2333'),
]
operations = [
migrations.AddField(
model_name='userreview',
name='prolific_... | [
"django.db.models.CharField"
] | [((343, 398), 'django.db.models.CharField', 'models.CharField', ([], {'blank': '(True)', 'max_length': '(300)', 'null': '(True)'}), '(blank=True, max_length=300, null=True)\n', (359, 398), False, 'from django.db import migrations, models\n')] |
# Time: O(|V| + |E|)
# Space: O(|V| + |E|)
# 886
# Given a set of N people (numbered 1, 2, ..., N),
# we would like to split everyone into two groups of any size.
#
# Each person may dislike some other people,
# and they should not go into the same group.
#
# Formally, if dislikes[i] = [a, b],
# it means it is not a... | [
"collections.deque",
"collections.defaultdict"
] | [((1478, 1506), 'collections.defaultdict', 'collections.defaultdict', (['set'], {}), '(set)\n', (1501, 1506), False, 'import collections\n'), ((2220, 2249), 'collections.defaultdict', 'collections.defaultdict', (['list'], {}), '(list)\n', (2243, 2249), False, 'import collections\n'), ((2355, 2376), 'collections.deque',... |
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
import random as rdm
# temporary variable, only used in testing, replace with actual graph inputs
# currently, generates 100 evenly spaced numbers between 0 and pi
ps1 = np.linspace(0, 1 * np.pi, 100)
# create the graph plot
f... | [
"numpy.sin",
"numpy.linspace",
"matplotlib.pyplot.pause",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.show"
] | [((263, 293), 'numpy.linspace', 'np.linspace', (['(0)', '(1 * np.pi)', '(100)'], {}), '(0, 1 * np.pi, 100)\n', (274, 293), True, 'import numpy as np\n'), ((329, 343), 'matplotlib.pyplot.subplots', 'plt.subplots', ([], {}), '()\n', (341, 343), True, 'import matplotlib.pyplot as plt\n'), ((622, 643), 'matplotlib.pyplot.s... |
import urllib.request
import shutil
import requests
...
# Download the file from `url` and save it locally under `file_name`:
from fasp.loc import sdlDRSClient
def download(url):
print('in download')
file_name = 'test_file.bam'
req = requests.get(url)
print (req)
file = open(file_name, 'wb')
for chunk ... | [
"fasp.loc.sdlDRSClient",
"requests.get"
] | [((248, 265), 'requests.get', 'requests.get', (['url'], {}), '(url)\n', (260, 265), False, 'import requests\n'), ((713, 769), 'fasp.loc.sdlDRSClient', 'sdlDRSClient', (['"""~/.keys/prj_11218_D17199.ngc"""'], {'debug': '(True)'}), "('~/.keys/prj_11218_D17199.ngc', debug=True)\n", (725, 769), False, 'from fasp.loc import... |
import pytest
from pettingzoo.test.api_test import api_test
from pettingzoo.test.max_cycles_test import max_cycles_test
from pettingzoo.test.parallel_test import parallel_api_test
from pettingzoo.test.render_test import render_test
from pettingzoo.test.seed_test import check_environment_deterministic, seed_test
from p... | [
"pytest.mark.parametrize",
"pettingzoo.test.state_test.state_test",
"pettingzoo.test.api_test.api_test"
] | [((9632, 9709), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (["['name', 'env_module', 'kwargs']", 'parameterized_envs'], {}), "(['name', 'env_module', 'kwargs'], parameterized_envs)\n", (9655, 9709), False, 'import pytest\n'), ((9793, 9807), 'pettingzoo.test.api_test.api_test', 'api_test', (['_env'], {}), '(_... |
from flask_wtf import FlaskForm
from wtforms import StringField, PasswordField, SubmitField, TextAreaField, SelectField, BooleanField
from wtforms.validators import InputRequired, Length, EqualTo, ValidationError, Email, Required
from ..models import User
from wtforms import ValidationError
from flask_wtf.file import F... | [
"wtforms.validators.Email",
"wtforms.validators.InputRequired",
"flask_wtf.file.FileAllowed",
"wtforms.BooleanField",
"wtforms.SubmitField",
"wtforms.validators.EqualTo",
"wtforms.validators.Required",
"wtforms.validators.Length",
"wtforms.ValidationError"
] | [((1399, 1424), 'wtforms.BooleanField', 'BooleanField', (['"""Subscribe"""'], {}), "('Subscribe')\n", (1411, 1424), False, 'from wtforms import StringField, PasswordField, SubmitField, TextAreaField, SelectField, BooleanField\n'), ((1445, 1467), 'wtforms.SubmitField', 'SubmitField', (['"""Sign up"""'], {}), "('Sign up'... |
#
# Copyright (c) 2017 nexB Inc. and others. All rights reserved.
# http://nexb.com and https://github.com/nexB/scancode-toolkit/
# The ScanCode software is licensed under the Apache License version 2.0.
# Data generated with ScanCode require an acknowledgment.
# ScanCode is a trademark of nexB Inc.
#
# You may not use... | [
"textcode.analysis.unicode_text",
"chardet.detect",
"lxml.etree.XMLParser",
"lxml.etree.parse"
] | [((2217, 2294), 'lxml.etree.XMLParser', 'etree.XMLParser', ([], {'recover': '(True)', 'remove_blank_text': '(True)', 'resolve_entities': '(False)'}), '(recover=True, remove_blank_text=True, resolve_entities=False)\n', (2232, 2294), False, 'from lxml import etree\n'), ((2310, 2339), 'lxml.etree.parse', 'etree.parse', ([... |