code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
#!/usr/bin/env python3
import unittest
import sys
import os
import re
from io import StringIO
from unittest.mock import patch
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".")))
import scripts.patch_apply.apply as apply
class TestApplied(unittest.TestCase):
def setUp(self):
... | [
"unittest.main",
"os.listdir",
"io.StringIO",
"os.getcwd",
"os.path.dirname",
"scripts.patch_apply.apply.main",
"scripts.patch_apply.apply.findGitPrefix",
"os.chdir"
] | [((4355, 4370), 'unittest.main', 'unittest.main', ([], {}), '()\n', (4368, 4370), False, 'import unittest\n'), ((336, 347), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (345, 347), False, 'import os\n'), ((425, 446), 'os.chdir', 'os.chdir', (['self.oldcwd'], {}), '(self.oldcwd)\n', (433, 446), False, 'import os\n'), ((1... |
from django.contrib import admin
from habitat._common.admin import HabitatAdmin
from habitat.sensors.models import CarbonDioxide
@admin.register(CarbonDioxide)
class CarbonDioxideAdmin(HabitatAdmin):
list_display = ['datetime', 'location', 'value']
list_filter = ['created', 'location']
search_fields = ['^... | [
"django.contrib.admin.register"
] | [((132, 161), 'django.contrib.admin.register', 'admin.register', (['CarbonDioxide'], {}), '(CarbonDioxide)\n', (146, 161), False, 'from django.contrib import admin\n')] |
from pygame import mixer
class Player():
"""Handles everything concerning the current song"""
def __init__(self):
mixer.init()
self.currentlength = 0
self.currentadress = ""
self.name = ""
self.plogo = "||"
self.endless = True
self.elogo = ... | [
"pygame.mixer.music.get_pos",
"pygame.mixer.music.unpause",
"pygame.mixer.init",
"pygame.mixer.music.play",
"pygame.mixer.music.set_volume",
"pygame.mixer.music.get_busy",
"pygame.mixer.music.pause",
"pygame.mixer.music.load",
"pygame.mixer.music.stop"
] | [((140, 152), 'pygame.mixer.init', 'mixer.init', ([], {}), '()\n', (150, 152), False, 'from pygame import mixer\n'), ((1334, 1364), 'pygame.mixer.music.set_volume', 'mixer.music.set_volume', (['volume'], {}), '(volume)\n', (1356, 1364), False, 'from pygame import mixer\n'), ((1416, 1437), 'pygame.mixer.music.get_pos', ... |
import pytz
import pandas as pd
def get_utc_timestamp(dt):
mytz = pytz.timezone("UTC")
return mytz.normalize(mytz.localize(dt, is_dst=False))
def goals_wide_to_long(df: pd.DataFrame, unit_type: str = "test_unit_type") -> pd.DataFrame:
"""
Modify the input DataFrame in a way that it can be evaluatetd... | [
"pandas.melt",
"pandas.merge",
"pytz.timezone"
] | [((72, 92), 'pytz.timezone', 'pytz.timezone', (['"""UTC"""'], {}), "('UTC')\n", (85, 92), False, 'import pytz\n'), ((1472, 1584), 'pandas.melt', 'pd.melt', (['df'], {'id_vars': "['exp_id', 'exp_variant_id']", 'value_vars': 'cols', 'var_name': '"""goal"""', 'value_name': '"""sum_value"""'}), "(df, id_vars=['exp_id', 'ex... |
from multiprocessing import Pool
import pandas as pd
from functools import partial
import numpy as np
from tqdm import tqdm
def inductive_pooling(df, embeddings, G, workers, gamma=1000, dict_node=None, average_embedding=True):
if average_embedding:
avg_emb = embeddings.mean().values
else:
... | [
"numpy.array_split",
"functools.partial",
"multiprocessing.Pool"
] | [((384, 397), 'multiprocessing.Pool', 'Pool', (['workers'], {}), '(workers)\n', (388, 397), False, 'from multiprocessing import Pool\n'), ((422, 513), 'functools.partial', 'partial', (['inductive_pooling_chunk'], {'embeddings': 'embeddings', 'G': 'G', 'average_embedding': 'avg_emb'}), '(inductive_pooling_chunk, embeddi... |
import os
import subprocess
import datetime
def render_today(update):
string = []
string.append("# Update %s"%datetime.datetime.now().strftime('%Y-%m-%d'))
if(len(update)==0):
string.append('No Update Today!')
for item in update:
string.append("## %s"%item['CVE_ID'])
string.appe... | [
"subprocess.getstatusoutput",
"datetime.datetime.now"
] | [((1696, 1751), 'subprocess.getstatusoutput', 'subprocess.getstatusoutput', (['"""rm -rf PocOrExp_in_Github"""'], {}), "('rm -rf PocOrExp_in_Github')\n", (1722, 1751), False, 'import subprocess\n'), ((1772, 1873), 'subprocess.getstatusoutput', 'subprocess.getstatusoutput', (['"""git clone <EMAIL>:ycdxsb/PocOrExp_in_Git... |
import argparse
parser = argparse.ArgumentParser()
parser.add_argument("-n", "--name", help="the name of the person you want to find")
parser.add_argument("-a", "--age", help="the age of the person you'd like to find", type=int)
parser.add_argument("-c", "--city", help="the city you'd like to search")
parser.add_argu... | [
"argparse.ArgumentParser"
] | [((26, 51), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (49, 51), False, 'import argparse\n')] |
# -*- coding: UTF-8 -*-
import re
import argparse
from urllib.parse import urlparse
import wikipedia
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.cluster import KMeans
import nltk
from nltk.corpus import stopwords
from nltk.tokenize import sent_tokenize, word_tokenize
from nltk.stem impo... | [
"wikipedia.page",
"nltk.tokenize.word_tokenize",
"argparse.ArgumentParser",
"re.split",
"sklearn.cluster.KMeans",
"wikipedia.set_lang",
"nltk.tokenize.sent_tokenize",
"nltk.download",
"re.sub",
"urllib.parse.urlparse"
] | [((3292, 3317), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (3315, 3317), False, 'import argparse\n'), ((529, 559), 'nltk.download', 'nltk.download', (['pkg'], {'quiet': '(True)'}), '(pkg, quiet=True)\n', (542, 559), False, 'import nltk\n'), ((826, 845), 'nltk.tokenize.word_tokenize', 'word_... |
from AirSimClient import *
# connect to the AirSim simulator
import car_client_for_rl
# connect to the AirSim simulator
client = car_client_for_rl.CarClientForRL()
client.__init__
#state = client.getStatus()
#print("state: %s" % state)
throttle = float(input("Please enter throttle: "))
steering = float(input(... | [
"car_client_for_rl.CarClientForRL"
] | [((135, 169), 'car_client_for_rl.CarClientForRL', 'car_client_for_rl.CarClientForRL', ([], {}), '()\n', (167, 169), False, 'import car_client_for_rl\n')] |
from tensorflow.keras.layers import (
MaxPooling2D, SeparableConv2D, UpSampling2D, Activation, BatchNormalization,
GlobalAveragePooling2D, Conv2D, Dropout, Concatenate, multiply, Add, concatenate,
DepthwiseConv2D, Reshape, ZeroPadding2D, Dense, GlobalMaxPooling2D, Permute, Lambda, Subtract)
import tensorflo... | [
"tensorflow.keras.layers.multiply",
"tensorflow.keras.layers.Reshape",
"tensorflow.keras.layers.Dense",
"tensorflow.keras.backend.max",
"tensorflow.keras.backend.int_shape",
"tensorflow.keras.regularizers.L2",
"tensorflow.keras.layers.DepthwiseConv2D",
"tensorflow.keras.layers.experimental.preprocessi... | [((1377, 1416), 'tensorflow.keras.regularizers.L2', 'tf.keras.regularizers.L2', ([], {'l2': '(0.0001 / 2)'}), '(l2=0.0001 / 2)\n', (1401, 1416), True, 'import tensorflow as tf\n'), ((1513, 1614), 'tensorflow.keras.initializers.VarianceScaling', 'tf.keras.initializers.VarianceScaling', ([], {'scale': '(1.0)', 'mode': '"... |
import flask
import zeeguu
from flask import request
from zeeguu.content_recommender.mixed_recommender import user_article_info
from zeeguu.model import Article, UserArticle
from .utils.route_wrappers import cross_domain, with_session
from .utils.json_result import json_result
from . import api, db_session
# -------... | [
"zeeguu.model.Article.find_or_create",
"flask.request.args.get",
"flask.request.form.get",
"zeeguu.content_recommender.mixed_recommender.user_article_info",
"flask.abort",
"zeeguu.model.Article.query.filter_by",
"zeeguu.model.UserArticle.find_or_create"
] | [((2107, 2134), 'flask.request.form.get', 'request.form.get', (['"""starred"""'], {}), "('starred')\n", (2123, 2134), False, 'from flask import request\n'), ((2147, 2172), 'flask.request.form.get', 'request.form.get', (['"""liked"""'], {}), "('liked')\n", (2163, 2172), False, 'from flask import request\n'), ((2253, 231... |
import smtplib
from email.message import EmailMessage
from datetime import datetime
def notify_error(report_name, error_log, to_list: str, login: str, password: str):
"""Auto-notify for automated scripts crashing.
:param report_name: Name of automated report.
:param error_log: Raised exception or other e... | [
"email.message.EmailMessage",
"datetime.datetime.now",
"smtplib.SMTP"
] | [((582, 621), 'smtplib.SMTP', 'smtplib.SMTP', (['"""smtp.office365.com"""', '(587)'], {}), "('smtp.office365.com', 587)\n", (594, 621), False, 'import smtplib\n'), ((718, 732), 'email.message.EmailMessage', 'EmailMessage', ([], {}), '()\n', (730, 732), False, 'from email.message import EmailMessage\n'), ((975, 989), 'd... |
import argparse
import datetime
import os,sys
import time
os.chdir('/home/qiuziming/product/torchdistill')
root=os.getcwd()
sys.path.append(root)
import torch
from torch import distributed as dist
from torch.backends import cudnn
from torch.nn import DataParallel
from torch.nn.parallel import DistributedDataParallel
fr... | [
"argparse.ArgumentParser",
"SST.utils.Matrix.Kernel_VIS",
"torchdistill.datasets.util.get_all_datasets",
"torch.device",
"SST.utils.Pmatrix.Matrix_VIS",
"os.chdir",
"torch.isnan",
"torchdistill.common.main_util.is_main_process",
"sys.path.append",
"torchdistill.datasets.util.build_data_loader",
... | [((58, 106), 'os.chdir', 'os.chdir', (['"""/home/qiuziming/product/torchdistill"""'], {}), "('/home/qiuziming/product/torchdistill')\n", (66, 106), False, 'import os, sys\n'), ((112, 123), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (121, 123), False, 'import os, sys\n'), ((124, 145), 'sys.path.append', 'sys.path.appen... |
from sqlalchemy import Column, Integer, String
from base import Base
class Qualifier(Base):
__tablename__ = 'Qualifiers'
id = Column('QualifierID', Integer, primary_key=True)
code = Column('QualifierCode', String, nullable=False)
description = Column('QualifierDescription', String, nullable=False)
def __... | [
"sqlalchemy.Column"
] | [((135, 183), 'sqlalchemy.Column', 'Column', (['"""QualifierID"""', 'Integer'], {'primary_key': '(True)'}), "('QualifierID', Integer, primary_key=True)\n", (141, 183), False, 'from sqlalchemy import Column, Integer, String\n'), ((194, 241), 'sqlalchemy.Column', 'Column', (['"""QualifierCode"""', 'String'], {'nullable':... |
from __future__ import absolute_import
import daisy
import logging
import unittest
import networkx as nx
logger = logging.getLogger(__name__)
# logging.basicConfig(level=logging.DEBUG)
daisy.scheduler._NO_SPAWN_STATUS_THREAD = True
class TestFilterMongoGraph(unittest.TestCase):
def get_mongo_graph_provider(
... | [
"daisy.Coordinate",
"daisy.persistence.MongoDbGraphProvider",
"daisy.Roi",
"networkx.set_edge_attributes",
"logging.getLogger"
] | [((116, 143), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (133, 143), False, 'import logging\n'), ((358, 446), 'daisy.persistence.MongoDbGraphProvider', 'daisy.persistence.MongoDbGraphProvider', (['"""test_daisy_graph"""'], {'directed': '(True)', 'mode': 'mode'}), "('test_daisy_graph',... |
import asyncio
import json
import logging
import os
import sys
from typing import Optional
from discord_webhook import DiscordWebhook
from fastapi import FastAPI
from pydantic import BaseModel, BaseSettings
from pyngrok import ngrok
from meraki_register_webhook import MerakiWebhook
logging.basicConfig(level=os.envir... | [
"pyngrok.ngrok.get_tunnels",
"logging.error",
"logging.exception",
"asyncio.sleep",
"meraki_register_webhook.MerakiWebhook",
"os.environ.get",
"logging.info",
"pyngrok.ngrok.connect",
"sys.argv.index",
"pyngrok.ngrok.set_auth_token",
"sys.exit",
"fastapi.FastAPI"
] | [((3752, 3863), 'meraki_register_webhook.MerakiWebhook', 'MerakiWebhook', (['settings.MERAKI_API_KEY', 'settings.WEBHOOK_NAME', 'settings.WEBHOOK_URL', 'settings.NETWORK_NAME'], {}), '(settings.MERAKI_API_KEY, settings.WEBHOOK_NAME, settings.\n WEBHOOK_URL, settings.NETWORK_NAME)\n', (3765, 3863), False, 'from merak... |
import matplotlib.pyplot as plt
import numpy as np
from numpy import pi
import pandas as pd
from scripts.volatility_tree import build_volatility_tree
from scripts.profiler import profiler
i = complex(0, 1)
# option parameters
T = 1
H_original = 90 # limit
K_original = 100.0 # strike
r_premia = 10 # annu... | [
"numpy.fft.ifft",
"scripts.profiler.profiler",
"matplotlib.pyplot.show",
"numpy.log",
"matplotlib.pyplot.plot",
"scripts.volatility_tree.build_volatility_tree",
"matplotlib.pyplot.close",
"numpy.fft.fft",
"numpy.power",
"numpy.fft.fftshift",
"numpy.array",
"numpy.exp",
"numpy.linspace",
"n... | [((819, 845), 'numpy.log', 'np.log', (['(r_premia / 100 + 1)'], {}), '(r_premia / 100 + 1)\n', (825, 845), True, 'import numpy as np\n'), ((906, 965), 'numpy.linspace', 'np.linspace', (['(-M * dx / 2)', '(M * dx / 2)'], {'num': 'M', 'endpoint': '(False)'}), '(-M * dx / 2, M * dx / 2, num=M, endpoint=False)\n', (917, 96... |
from django.urls import path
from . import views
app_name = 'TestApp'
urlpatterns = [
path('', views.index, name='index'),
path('hello/<name>/', views.hello, name='hello'),
]
| [
"django.urls.path"
] | [((92, 127), 'django.urls.path', 'path', (['""""""', 'views.index'], {'name': '"""index"""'}), "('', views.index, name='index')\n", (96, 127), False, 'from django.urls import path\n'), ((133, 181), 'django.urls.path', 'path', (['"""hello/<name>/"""', 'views.hello'], {'name': '"""hello"""'}), "('hello/<name>/', views.he... |
from PIL import Image, ImageDraw, ImageFilter
from math import *
step=50
I=Image.new('RGBA',(1000,1000),(0,0,0,255))
d=ImageDraw.Draw(I)
def draw_circle(d,i,j, fill=(255,255,255,255)):
r=max(5, sin(i*pi/1000)*sin(j*pi/1000)*15)
d.ellipse((i-r,j-r,i+r,j+r),fill=fill)
for j in range(0,1000+step,step/2):
f... | [
"PIL.ImageDraw.Draw",
"PIL.Image.new"
] | [((77, 124), 'PIL.Image.new', 'Image.new', (['"""RGBA"""', '(1000, 1000)', '(0, 0, 0, 255)'], {}), "('RGBA', (1000, 1000), (0, 0, 0, 255))\n", (86, 124), False, 'from PIL import Image, ImageDraw, ImageFilter\n'), ((121, 138), 'PIL.ImageDraw.Draw', 'ImageDraw.Draw', (['I'], {}), '(I)\n', (135, 138), False, 'from PIL imp... |
#
# Copyright (c) 2019, 2020, 2021, <NAME>
# All rights reserved.
#
from gfs.common.log import GFSLogger
from gfs.common.base import GFSBase
class GremlinFSConfig(GFSBase):
logger = GFSLogger.getLogger("GremlinFSConfig")
@classmethod
def defaults(clazz):
return {
"kf_topic1": "g... | [
"gfs.common.log.GFSLogger.getLogLevel",
"gfs.common.log.GFSLogger.getLogger"
] | [((194, 232), 'gfs.common.log.GFSLogger.getLogger', 'GFSLogger.getLogger', (['"""GremlinFSConfig"""'], {}), "('GremlinFSConfig')\n", (213, 232), False, 'from gfs.common.log import GFSLogger\n'), ((425, 448), 'gfs.common.log.GFSLogger.getLogLevel', 'GFSLogger.getLogLevel', ([], {}), '()\n', (446, 448), False, 'from gfs.... |
import json
import os
import random
from pathlib import Path
from typing import Optional, List, Dict
import cherrypy
import numpy as np
import psutil
import yaml
from app.emotions import predict_topk_emotions, EMOTIONS, get_fonts
from app.features import extract_audio_features
from app.keywords import predict_keyword... | [
"os.remove",
"cherrypy.expose",
"os.getpid",
"cherrypy.engine.start",
"json.dumps",
"cherrypy.config.update",
"cherrypy.engine.block",
"random.randrange",
"numpy.array",
"app.features.extract_audio_features",
"app.emotions.get_fonts",
"os.path.join",
"cherrypy.engine.stop"
] | [((968, 979), 'os.getpid', 'os.getpid', ([], {}), '()\n', (977, 979), False, 'import os\n'), ((1110, 1147), 'cherrypy.expose', 'cherrypy.expose', (['METHOD_NAME_EMOTIONS'], {}), '(METHOD_NAME_EMOTIONS)\n', (1125, 1147), False, 'import cherrypy\n'), ((1622, 1656), 'cherrypy.expose', 'cherrypy.expose', (['METHOD_NAME_FON... |
import os
import subprocess
def unix_tail(filename, lines=20):
if not os.access(filename, os.R_OK):
raise Exception('Cannot access "%s"' %(filename))
try:
args = ['tail', filename, '-n', str(lines)]
proc = subprocess.Popen(args, stdout=subprocess.PIPE)
output = proc.communicat... | [
"subprocess.Popen",
"os.access"
] | [((77, 105), 'os.access', 'os.access', (['filename', 'os.R_OK'], {}), '(filename, os.R_OK)\n', (86, 105), False, 'import os\n'), ((241, 287), 'subprocess.Popen', 'subprocess.Popen', (['args'], {'stdout': 'subprocess.PIPE'}), '(args, stdout=subprocess.PIPE)\n', (257, 287), False, 'import subprocess\n')] |
import pycurl
import urllib.parse
from collections import defaultdict
from io import BytesIO
import json
def pycurlgetURL(url):
buffer = BytesIO()
c = pycurl.Curl()
c.setopt(c.URL, url)
c.setopt(c.WRITEDATA, buffer)
c.perform()
c.close()
body = buffer.getvalue()
return json.loads(body.d... | [
"io.BytesIO",
"pycurl.Curl"
] | [((142, 151), 'io.BytesIO', 'BytesIO', ([], {}), '()\n', (149, 151), False, 'from io import BytesIO\n'), ((160, 173), 'pycurl.Curl', 'pycurl.Curl', ([], {}), '()\n', (171, 173), False, 'import pycurl\n'), ((383, 392), 'io.BytesIO', 'BytesIO', ([], {}), '()\n', (390, 392), False, 'from io import BytesIO\n'), ((401, 414)... |
import uuid
import xml.etree.ElementTree as Et
import csv
import lampak
bedir = './xmlz/'
kidir = './csvk/'
bef = 'ntsz_old.xml'
befile = bedir + bef
kifile = kidir + bef + "_conv.csv"
# Ezek a mezők vannak a capture csv-ben
fields = ['Fixture', 'Optics', 'Wattage', 'Unit', 'Circuit', 'Channel',
'Groups', 'P... | [
"xml.etree.ElementTree.parse",
"lampak.Lampa",
"uuid.uuid4",
"csv.writer"
] | [((773, 789), 'xml.etree.ElementTree.parse', 'Et.parse', (['befile'], {}), '(befile)\n', (781, 789), True, 'import xml.etree.ElementTree as Et\n'), ((1571, 1583), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (1581, 1583), False, 'import uuid\n'), ((3233, 3309), 'csv.writer', 'csv.writer', (['csvfile'], {'delimiter': '... |
import base64
from apistar import http
from apistar.authentication import Authenticated
from apistar.interfaces import Auth
class BasicAuthentication():
def authenticate(self, authorization: http.Header):
"""
Determine the user associated with a request, using HTTP Basic Authentication.
"... | [
"base64.b64decode",
"apistar.authentication.Authenticated"
] | [((586, 609), 'apistar.authentication.Authenticated', 'Authenticated', (['username'], {}), '(username)\n', (599, 609), False, 'from apistar.authentication import Authenticated\n'), ((520, 543), 'base64.b64decode', 'base64.b64decode', (['token'], {}), '(token)\n', (536, 543), False, 'import base64\n')] |
import requests
from pathlib import Path
import os
from PIL import Image
from instabot import Bot
from dotenv import load_dotenv
import random
from scripts import download_file
Image.MAX_IMAGE_PIXELS = 900000000
IMAGES_DIRECTORY = 'images/'
INSTAGRAM_IMAGES_DIRECTORY = 'images_instagram/'
def main():
... | [
"os.listdir",
"random.choice",
"PIL.Image.open",
"dotenv.load_dotenv",
"pathlib.Path",
"requests.get",
"instabot.Bot",
"os.getenv",
"scripts.download_file"
] | [((324, 337), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (335, 337), False, 'from dotenv import load_dotenv\n'), ((403, 434), 'os.getenv', 'os.getenv', (['"""INSTAGRAM_PASSWORD"""'], {}), "('INSTAGRAM_PASSWORD')\n", (412, 434), False, 'import os\n'), ((654, 669), 'pathlib.Path', 'Path', (['directory'], {}),... |
import logging
from logging import handlers as logging_handlers
class Logg():
LOGMAXSIZE = 50000000
LOGBACKUPCOUT = 2
LOGLEVEL = logging.ERROR
def create_logger(name, logfile=None, logmaxsize=LOGMAXSIZE, loglevel=LOGLEVEL,
logbackupcount=LOGBACKUPCOUT):
""" create and re... | [
"logging.Formatter",
"logging.getLogger"
] | [((382, 405), 'logging.getLogger', 'logging.getLogger', (['name'], {}), '(name)\n', (399, 405), False, 'import logging\n'), ((537, 562), 'logging.Formatter', 'logging.Formatter', (['format'], {}), '(format)\n', (554, 562), False, 'import logging\n')] |
import math
SNAP = 0.001
class Vector2(object):
def __init__(self, x=0.0, y=0.0):
self.x = x
self.y = y
class Vector3(object):
def __init__(self, x=0, y=0, z=0):
self.x = x
self.y = y
self.z = z
def clone(self):
return Vector3(self.x, self.y, s... | [
"math.sin",
"math.cos",
"math.sqrt"
] | [((635, 673), 'math.sqrt', 'math.sqrt', (['(dx * dx + dy * dy + dz * dz)'], {}), '(dx * dx + dy * dy + dz * dz)\n', (644, 673), False, 'import math\n'), ((946, 1008), 'math.sqrt', 'math.sqrt', (['(self.x * self.x + self.y * self.y + self.z * self.z)'], {}), '(self.x * self.x + self.y * self.y + self.z * self.z)\n', (95... |
from django.test import TestCase
from rest_framework.test import force_authenticate
from rest_framework import status
from django.contrib.auth.models import User
from django.test.client import RequestFactory
from users.api import AccountDetailsView
class TestAccountDetailsView(TestCase):
def setUp(self):
... | [
"django.contrib.auth.models.User.objects.create",
"django.test.client.RequestFactory",
"users.api.AccountDetailsView.as_view",
"rest_framework.test.force_authenticate"
] | [((397, 458), 'django.contrib.auth.models.User.objects.create', 'User.objects.create', ([], {'username': 'self.username', 'email': 'self.email'}), '(username=self.username, email=self.email)\n', (416, 458), False, 'from django.contrib.auth.models import User\n'), ((479, 507), 'users.api.AccountDetailsView.as_view', 'Ac... |
#!/usr/bin/python3
"""Remove all end of line whitespace and tabs in a given text file(s).
Usage:
trimeol.py [input_files]
If no input_files are supplied, the program reads from stdin.
"""
import os
import stat
import sys
import time
import binarycheck
def process_file(fname):
"""Remove all end of line wh... | [
"os.remove",
"os.path.basename",
"os.rename",
"time.clock",
"binarycheck.is_binary_file",
"os.fstat",
"sys.exit"
] | [((537, 570), 'binarycheck.is_binary_file', 'binarycheck.is_binary_file', (['fname'], {}), '(fname)\n', (563, 570), False, 'import binarycheck\n'), ((1999, 2011), 'time.clock', 'time.clock', ([], {}), '()\n', (2009, 2011), False, 'import time\n'), ((2735, 2747), 'time.clock', 'time.clock', ([], {}), '()\n', (2745, 2747... |
import logging
logger = logging.getLogger(__name__)
import uuid
class SchedulerLock(object):
def __init__(self, duration, lock_name="scheduler_lock"):
self.id = self.get_instance_id()
self.duration = duration
self.lock_name = lock_name
logger.debug("%s:%s initialized with %s dura... | [
"uuid.uuid4",
"logging.getLogger"
] | [((25, 52), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (42, 52), False, 'import logging\n'), ((544, 556), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (554, 556), False, 'import uuid\n')] |
#!/usr/bin/env python
# encoding: utf-8
from pdb_break import f
f(5)
| [
"pdb_break.f"
] | [((66, 70), 'pdb_break.f', 'f', (['(5)'], {}), '(5)\n', (67, 70), False, 'from pdb_break import f\n')] |
import pandas as pd
from wind_power_forecasting.preprocessing.dataframe import sort_df_index_if_needed, \
convert_df_index_to_datetime_if_needed
from wind_power_forecasting.utils.dataframe import copy_or_not_copy
def input_preprocessing(X_df: pd.DataFrame, datetime_label) -> pd.DataFrame:
# Convert dataframe... | [
"wind_power_forecasting.preprocessing.dataframe.sort_df_index_if_needed",
"wind_power_forecasting.utils.dataframe.copy_or_not_copy",
"wind_power_forecasting.preprocessing.dataframe.convert_df_index_to_datetime_if_needed"
] | [((722, 748), 'wind_power_forecasting.utils.dataframe.copy_or_not_copy', 'copy_or_not_copy', (['df', 'copy'], {}), '(df, copy)\n', (738, 748), False, 'from wind_power_forecasting.utils.dataframe import copy_or_not_copy\n'), ((949, 1003), 'wind_power_forecasting.preprocessing.dataframe.convert_df_index_to_datetime_if_ne... |
'''List all User Shell Folders via ID number.
An alternative to the usual
objShell = win32com.client.Dispatch("WScript.Shell")
allUserProgramsMenu = objShell.SpecialFolders("AllUsersPrograms")
because "These special folders do not work in all language locales, a preferred
method is to query the value... | [
"collections.namedtuple"
] | [((869, 912), 'collections.namedtuple', 'namedtuple', (['"""UserFolder"""', '"""id, description"""'], {}), "('UserFolder', 'id, description')\n", (879, 912), False, 'from collections import namedtuple\n')] |
import torch.nn as nn
from torch.nn.modules.utils import _pair
from ..functions.roi_align import roi_align
class RoIAlign(nn.Module):
def __init__(self,
out_size,
spatial_scale,
sample_num=0,
use_torchvision=False):
super(R... | [
"torch.nn.modules.utils._pair"
] | [((716, 736), 'torch.nn.modules.utils._pair', '_pair', (['self.out_size'], {}), '(self.out_size)\n', (721, 736), False, 'from torch.nn.modules.utils import _pair\n')] |
import json
import datetime
import os
from src.utils.youtube.channels import Channels
def test_list_channels_should_return_right_url():
channel_req = Channels("snippet", "channel_id")
assert channel_req.get_url() == "https://www.googleapis.com/youtube/v3/channels"
def test_list_channels_should_return_righ... | [
"datetime.datetime",
"json.load",
"src.utils.youtube.channels.Channels"
] | [((157, 190), 'src.utils.youtube.channels.Channels', 'Channels', (['"""snippet"""', '"""channel_id"""'], {}), "('snippet', 'channel_id')\n", (165, 190), False, 'from src.utils.youtube.channels import Channels\n'), ((354, 387), 'src.utils.youtube.channels.Channels', 'Channels', (['"""snippet"""', '"""channel_id"""'], {}... |
import matplotlib.pyplot as plt
import pylab
import numpy as N
import scipy.io as sio
import math
from pyfmi import load_fmu
fmu_loc = '/home/shashank/Documents/Gap Year Work/TAMU_ROVm/ROVm/Resources/FMU/'
fmu_sm_name = 'SimplifiedBlueROV2.fmu'
fmu_fm_name = 'InputBasedBlueROV2.fmu'
fmu_full_sm_name = fmu_lo... | [
"matplotlib.pyplot.subplot",
"matplotlib.pyplot.plot",
"scipy.io.loadmat",
"matplotlib.pyplot.legend",
"math.floor",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.ylabel",
"pyfmi.load_fmu",
"matplotlib.pyplot.grid",
"numpy.vstack",
"matplotlib.pyplot.xlabel"
] | [((389, 415), 'pyfmi.load_fmu', 'load_fmu', (['fmu_full_sm_name'], {}), '(fmu_full_sm_name)\n', (397, 415), False, 'from pyfmi import load_fmu\n'), ((427, 453), 'pyfmi.load_fmu', 'load_fmu', (['fmu_full_fm_name'], {}), '(fmu_full_fm_name)\n', (435, 453), False, 'from pyfmi import load_fmu\n'), ((936, 961), 'scipy.io.lo... |
import sys
import os
import sklearn
from sklearn.decomposition import TruncatedSVD
# give this a different alias so that it does not conflict with SPACY
from sklearn.externals import joblib as sklearn_joblib
import data_io, params, SIF_embedding
from SIF_embedding import get_weighted_average
# helper for word2vec fo... | [
"past.builtins.xrange",
"SIF_embedding.get_weighted_average",
"numpy.count_nonzero",
"sklearn.decomposition.TruncatedSVD",
"data_io.load_glove_word_map",
"data_io_w2v.load_w2v_word_map",
"data_io.seq2weight",
"numpy.zeros",
"data_io.sentences2idx"
] | [((2442, 2476), 'numpy.zeros', 'np.zeros', (['(n_samples, We.shape[1])'], {}), '((n_samples, We.shape[1]))\n', (2450, 2476), True, 'import numpy as np\n'), ((2490, 2507), 'past.builtins.xrange', 'xrange', (['n_samples'], {}), '(n_samples)\n', (2496, 2507), False, 'from past.builtins import xrange\n'), ((2525, 2550), 'n... |
import argparse
import numpy as np
import torch
from models.common import *
if __name__ == '__main__':
weights_path = r'runs\evolution\weights\best.pt'
is_half = True
# Load pytorch model
model = torch.load(weights_path, map_location=torch.device('cpu'))
net = model['model']
if is_half:
... | [
"torch.save",
"torch.device"
] | [((563, 615), 'torch.save', 'torch.save', (['ckpt', '"""runs\\\\evolution\\\\weights/test.pt"""'], {}), "(ckpt, 'runs\\\\evolution\\\\weights/test.pt')\n", (573, 615), False, 'import torch\n'), ((254, 273), 'torch.device', 'torch.device', (['"""cpu"""'], {}), "('cpu')\n", (266, 273), False, 'import torch\n')] |
from PIL import Image
import math
def combine_frames(frames: list[Image], output: str, framerate: int = 50) -> None:
"""Combine a list of frame images into a single .gif
Note that Chrome has a fun bug where GIFs are limited to 50FPS
This function will automatically clamp framerates to 50FPS
Args:
... | [
"math.floor"
] | [((595, 623), 'math.floor', 'math.floor', (['(1000 / framerate)'], {}), '(1000 / framerate)\n', (605, 623), False, 'import math\n')] |
# coding=utf8
# This code is adapted from the https://github.com/tensorflow/models/tree/master/official/r1/resnet.
# ==========================================================================================
# NAVER’s modifications are Copyright 2020 NAVER corp. All rights reserved.
# ==================================... | [
"numpy.sum",
"tensorflow.logging.info",
"numpy.argmax",
"tensorflow.local_variables_initializer",
"os.path.join",
"tensorflow.estimator.export.TensorServingInputReceiver",
"tensorflow.placeholder",
"tensorflow.map_fn",
"functools.partial",
"numpy.fill_diagonal",
"tensorflow.global_variables_init... | [((1436, 1510), 'tensorflow.data.Dataset.list_files', 'tf.data.Dataset.list_files', (["(flags_obj.data_dir + '/' + flags_obj.val_regex)"], {}), "(flags_obj.data_dir + '/' + flags_obj.val_regex)\n", (1462, 1510), True, 'import tensorflow as tf\n'), ((2116, 2162), 'functions.data_config.get_config', 'data_config.get_conf... |
# Talon voice commands for Xcode
# <NAME> <EMAIL>
from talon.voice import Key, Context
from ..misc.mouse import control_shift_click
ctx = Context("xcode", bundle="com.apple.dt.Xcode")
ctx.keymap(
{
"build it": Key("cmd-b"),
"stop it": Key("cmd-."),
"run it": Key("cmd-r"),
"go bac... | [
"talon.voice.Key",
"talon.voice.Context"
] | [((141, 186), 'talon.voice.Context', 'Context', (['"""xcode"""'], {'bundle': '"""com.apple.dt.Xcode"""'}), "('xcode', bundle='com.apple.dt.Xcode')\n", (148, 186), False, 'from talon.voice import Key, Context\n'), ((226, 238), 'talon.voice.Key', 'Key', (['"""cmd-b"""'], {}), "('cmd-b')\n", (229, 238), False, 'from talon... |
from django.urls import path
from . import views
from . import AmendViews
app_name = 'polls'
# urlpatterns = [
# path('', views.index, name = 'index'),
#
# path('<int:question_id>/', views.detail, name='detail'),
#
# path('<int:question_id>/results/', views.results, name='results'),
#
# path(... | [
"django.urls.path"
] | [((623, 684), 'django.urls.path', 'path', (['"""<int:question_id>/vote/"""', 'AmendViews.vote'], {'name': '"""vote"""'}), "('<int:question_id>/vote/', AmendViews.vote, name='vote')\n", (627, 684), False, 'from django.urls import path\n')] |
import json
class Person:
def __init__(self, name, age, job, verified, parents):
self.name = name
self.age = age
self.job = job
self.verified = verified
self.parents = parents
def __str__(self):
return ", ".join([f"{k}: {v}" for k, v in self.__dict__.items()])
... | [
"json.JSONDecoder.decode",
"json.loads",
"json.dumps"
] | [((688, 718), 'json.dumps', 'json.dumps', (['bob'], {'cls': 'MyEncoder'}), '(bob, cls=MyEncoder)\n', (698, 718), False, 'import json\n'), ((749, 784), 'json.loads', 'json.loads', (['bob_json'], {'cls': 'MyDecoder'}), '(bob_json, cls=MyDecoder)\n', (759, 784), False, 'import json\n'), ((483, 515), 'json.JSONDecoder.deco... |
from django.http import *
from heartbeat.models import Heartbeat
from heartbeat.forms import HeartBeatForm
from django.views.decorators.csrf import csrf_exempt
from heartbeat.PhasNoiseReduce import noiseReduce
import json
from datetime import datetime
import os
import sys
import time
@csrf_exempt
def save_audio_file(... | [
"heartbeat.models.Heartbeat",
"json.loads",
"os.system",
"json.dumps",
"heartbeat.models.Heartbeat.objects.filter",
"heartbeat.forms.HeartBeatForm",
"heartbeat.PhasNoiseReduce.noiseReduce",
"datetime.datetime.now"
] | [((402, 444), 'heartbeat.forms.HeartBeatForm', 'HeartBeatForm', (['request.POST', 'request.FILES'], {}), '(request.POST, request.FILES)\n', (415, 444), False, 'from heartbeat.forms import HeartBeatForm\n'), ((1762, 1786), 'json.loads', 'json.loads', (['request.body'], {}), '(request.body)\n', (1772, 1786), False, 'impo... |
import cv2 as cv
import numpy as np
# https://docs.opencv.org/4.2.0/d7/dfc/group__highgui.html
def white_balance(img):
result = cv.cvtColor(img, cv.COLOR_BGR2LAB)
avg_a = np.average(result[:, :, 1])
avg_b = np.average(result[:, :, 2])
result[:, :, 1] = result[:, :, 1] - ((avg_a - 128) * (result[:, :, ... | [
"numpy.average",
"cv2.cvtColor",
"cv2.waitKey",
"cv2.destroyAllWindows",
"cv2.merge",
"cv2.imread",
"cv2.namedWindow",
"cv2.split",
"cv2.moveWindow",
"cv2.imshow",
"cv2.resize"
] | [((499, 523), 'cv2.namedWindow', 'cv.namedWindow', (['"""webcam"""'], {}), "('webcam')\n", (513, 523), True, 'import cv2 as cv\n'), ((524, 553), 'cv2.moveWindow', 'cv.moveWindow', (['"""webcam"""', '(0)', '(0)'], {}), "('webcam', 0, 0)\n", (537, 553), True, 'import cv2 as cv\n'), ((555, 574), 'cv2.namedWindow', 'cv.nam... |
# Generated by Django 2.2.6 on 2019-10-14 14:13
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('tasks', '0001_initial'),
]
operations = [
migrations.AlterField(
model_name='countbeanstask',
name='status',
... | [
"django.db.models.CharField"
] | [((331, 688), 'django.db.models.CharField', 'models.CharField', ([], {'choices': "[('PENDING', 'PENDING'), ('RECEIVED', 'RECEIVED'), ('STARTED', 'STARTED'),\n ('PROGESS', 'PROGESS'), ('SUCCESS', 'SUCCESS'), ('FAILURE', 'FAILURE'),\n ('REVOKED', 'REVOKED'), ('REJECTED', 'REJECTED'), ('RETRY', 'RETRY'), (\n 'IGN... |
"""
Course Unit API Serializers. Representing course unit catalog data
"""
from rest_framework import serializers
class UnitSerializer(serializers.Serializer):
"""
Serializer for Course Unit objects providing minimal data about the course unit.
"""
id = serializers.CharField(read_only=True)
... | [
"rest_framework.serializers.CharField"
] | [((277, 314), 'rest_framework.serializers.CharField', 'serializers.CharField', ([], {'read_only': '(True)'}), '(read_only=True)\n', (298, 314), False, 'from rest_framework import serializers\n'), ((388, 425), 'rest_framework.serializers.CharField', 'serializers.CharField', ([], {'read_only': '(True)'}), '(read_only=Tru... |
import os
from dotenv import load_dotenv
from config import PROJECT_NAME
# load env variables
load_dotenv()
pg_user = os.getenv("POSTGRES_USER")
pg_password = os.getenv("POSTGRES_PASSWORD")
pg_db = os.getenv("POSTGRES_DB")
SENTRY_ENV_NAME = f"{PROJECT_NAME}_lottery_bot".casefold()
GUILD_INDEX = 0
TORTOISE_ORM =... | [
"dotenv.load_dotenv",
"os.getenv"
] | [((96, 109), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (107, 109), False, 'from dotenv import load_dotenv\n'), ((122, 148), 'os.getenv', 'os.getenv', (['"""POSTGRES_USER"""'], {}), "('POSTGRES_USER')\n", (131, 148), False, 'import os\n'), ((163, 193), 'os.getenv', 'os.getenv', (['"""POSTGRES_PASSWORD"""'],... |
from time import sleep
from playsound import playsound
from frontend import Frontend
from leds import LEDs, Color
frontend = Frontend()
leds = LEDs()
print("Testing audio output")
playsound('sample.mp3')
print("Audio playback ended")
try:
print("Testing EEG Frontend")
data = frontend.read_regs(0x00, 1)
... | [
"playsound.playsound",
"leds.LEDs",
"frontend.Frontend",
"time.sleep"
] | [((127, 137), 'frontend.Frontend', 'Frontend', ([], {}), '()\n', (135, 137), False, 'from frontend import Frontend\n'), ((145, 151), 'leds.LEDs', 'LEDs', ([], {}), '()\n', (149, 151), False, 'from leds import LEDs, Color\n'), ((183, 206), 'playsound.playsound', 'playsound', (['"""sample.mp3"""'], {}), "('sample.mp3')\n... |
import os
from setuptools import find_packages, setup
def read(fname):
with open(os.path.join(os.path.dirname(__file__), fname)) as _in:
return _in.read()
setup(
name="civis-jupyter-extensions",
version="1.1.0",
author="<NAME>",
author_email="<EMAIL>",
url="https://www.civisanalytics... | [
"os.path.dirname",
"setuptools.find_packages"
] | [((440, 455), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (453, 455), False, 'from setuptools import find_packages, setup\n'), ((100, 125), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (115, 125), False, 'import os\n')] |
from sample import *
import time
import os
import functools
from pprint import pprint
from fft import Fft
from prune import *
import math
import multiprocessing
import sys
def runParallelTest(params):
header = params[0]
data = params[1]
test = params[2]
#Start Time
startTime = time.time(... | [
"multiprocessing.Pool",
"os.path.abspath",
"fft.Fft",
"time.time"
] | [((2596, 2607), 'time.time', 'time.time', ([], {}), '()\n', (2605, 2607), False, 'import time\n'), ((3188, 3210), 'multiprocessing.Pool', 'multiprocessing.Pool', ([], {}), '()\n', (3208, 3210), False, 'import multiprocessing\n'), ((3219, 3253), 'multiprocessing.Pool', 'multiprocessing.Pool', ([], {'processes': '(25)'})... |
# Date: 2020/11/21
# Author: <NAME>
# Description:
# This is a simple program to learn how to use cristal boxes in python
##
#import
import unittest
#is_older(): Verify if the person is older
def is_older(age):
if age >= 18:
return True
else:
return False
#Class
class cris... | [
"unittest.main"
] | [((594, 609), 'unittest.main', 'unittest.main', ([], {}), '()\n', (607, 609), False, 'import unittest\n')] |
import os
from dotenv import load_dotenv
basedir = os.path.abspath(os.path.dirname(__file__))
env = os.path.join(basedir, '.env')
if os.path.exists(env):
load_dotenv(env)
else:
print('Warning: .env file not found')
class Config(object):
DEBUG = False
TESTING = False
NO_SOCKETIO = True if os.envi... | [
"os.path.dirname",
"os.path.exists",
"dotenv.load_dotenv",
"os.environ.get",
"os.path.join"
] | [((102, 131), 'os.path.join', 'os.path.join', (['basedir', '""".env"""'], {}), "(basedir, '.env')\n", (114, 131), False, 'import os\n'), ((135, 154), 'os.path.exists', 'os.path.exists', (['env'], {}), '(env)\n', (149, 154), False, 'import os\n'), ((69, 94), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__... |
#This file for checking vocabulary testing programme for beginner to advance purpose in this programe show hindi meaning word and user give english word for this hindi meaning.
from tkinter import *
from tkinter import messagebox
from insert import *
from tempInsert import *
root = Tk()
root.title("VocabQuiz")
root... | [
"tkinter.messagebox.askretrycancel"
] | [((1334, 1391), 'tkinter.messagebox.askretrycancel', 'messagebox.askretrycancel', (['"""Incorrect Word"""', '"""Try again?"""'], {}), "('Incorrect Word', 'Try again?')\n", (1359, 1391), False, 'from tkinter import messagebox\n'), ((2039, 2096), 'tkinter.messagebox.askretrycancel', 'messagebox.askretrycancel', (['"""Inc... |
from nltk import word_tokenize, WordNetLemmatizer
from plotly.graph_objs import Scatter, Bar
from wordcloud import WordCloud
def generate_plots(df):
"""
Generate plot objected to be rendered int the dashboard:
- Bar chart to plot distribution of genre
- Bar chart to plot distribution of disast... | [
"nltk.WordNetLemmatizer",
"wordcloud.WordCloud",
"nltk.word_tokenize",
"plotly.graph_objs.Bar"
] | [((2570, 2589), 'nltk.word_tokenize', 'word_tokenize', (['text'], {}), '(text)\n', (2583, 2589), False, 'from nltk import word_tokenize, WordNetLemmatizer\n'), ((2607, 2626), 'nltk.WordNetLemmatizer', 'WordNetLemmatizer', ([], {}), '()\n', (2624, 2626), False, 'from nltk import word_tokenize, WordNetLemmatizer\n'), ((3... |
import os
import random
import shutil
import tempfile
import time
from multiprocessing import Pool
from multiprocessing import Process
from pathlib import Path
import more_itertools as mo
from diskcache import Cache
from diskcache import Deque
from six import wraps
from fasteners import test
from fasteners.process_lo... | [
"tempfile.NamedTemporaryFile",
"os.remove",
"os.getpid",
"more_itertools.split_at",
"random.choice",
"random.random",
"pathlib.Path",
"tempfile.mkdtemp",
"fasteners.process_lock.InterProcessReaderWriterLock",
"more_itertools.chunked",
"multiprocessing.Pool",
"shutil.rmtree",
"multiprocessing... | [((424, 435), 'six.wraps', 'wraps', (['func'], {}), '(func)\n', (429, 435), False, 'from six import wraps\n'), ((7543, 7566), 'multiprocessing.Pool', 'Pool', (['(readers + writers)'], {}), '(readers + writers)\n', (7547, 7566), False, 'from multiprocessing import Pool\n'), ((7748, 7775), 'fasteners.process_lock.InterPr... |
from todoist_gcal_sync.utils.auth.gcal_OAuth import get_credentials
from todoist_gcal_sync.utils import sql_ops
import httplib2
from apiclient import discovery
gcal_creds = get_credentials()
http = gcal_creds.authorize(httplib2.Http())
# 'cache_discovery=False' is used to circumvent the file_cache issue for oauth2cli... | [
"httplib2.Http",
"todoist_gcal_sync.utils.sql_ops.select_from_where",
"apiclient.discovery.build",
"todoist_gcal_sync.utils.sql_ops.update_set_where",
"todoist_gcal_sync.utils.auth.gcal_OAuth.get_credentials"
] | [((174, 191), 'todoist_gcal_sync.utils.auth.gcal_OAuth.get_credentials', 'get_credentials', ([], {}), '()\n', (189, 191), False, 'from todoist_gcal_sync.utils.auth.gcal_OAuth import get_credentials\n'), ((436, 503), 'apiclient.discovery.build', 'discovery.build', (['"""calendar"""', '"""v3"""'], {'http': 'http', 'cache... |
# Copyright (c) Facebook, Inc. and its affiliates.
import os
import unittest
import numpy as np
import torch
from mmf.common.registry import registry
from mmf.common.sample import Sample, SampleList
from mmf.models.cnn_lstm import CNNLSTM
from mmf.utils.configuration import Configuration
from mmf.utils.general import... | [
"mmf.common.sample.SampleList",
"os.path.abspath",
"torch.randint",
"torch.manual_seed",
"mmf.models.cnn_lstm.CNNLSTM",
"mmf.common.registry.registry.register",
"mmf.utils.general.get_mmf_root",
"tests.test_utils.dummy_args",
"torch.randn",
"mmf.common.sample.Sample",
"torch.Size",
"mmf.utils.... | [((448, 471), 'torch.manual_seed', 'torch.manual_seed', (['(1234)'], {}), '(1234)\n', (465, 471), False, 'import torch\n'), ((480, 526), 'mmf.common.registry.registry.register', 'registry.register', (['"""clevr_text_vocab_size"""', '(80)'], {}), "('clevr_text_vocab_size', 80)\n", (497, 526), False, 'from mmf.common.reg... |
import numpy as np
import math
from geofractal import *
#-------------------------------------------------------
# Fractal dimension
#-------------------------------------------------------
df = 1.8
#-------------------------------------------------------
# Fractal prefactor
#--------------------------------------... | [
"math.log",
"numpy.zeros",
"numpy.sqrt"
] | [((829, 840), 'numpy.zeros', 'np.zeros', (['N'], {}), '(N)\n', (837, 840), True, 'import numpy as np\n'), ((375, 387), 'numpy.sqrt', 'np.sqrt', (['(3.0)'], {}), '(3.0)\n', (382, 387), True, 'import numpy as np\n'), ((788, 802), 'math.log', 'math.log', (['Nmin'], {}), '(Nmin)\n', (796, 802), False, 'import math\n'), ((8... |
# coding: utf-8
from riemann.config.config_loader import initialize_config
from riemann.data.data_loader import get_training_data
from riemann.config.graph_sampling_config import GraphSamplingConfig
initialize_config()
g = get_training_data()
iter = g.get_neighbor_iterator(GraphSamplingConfig())
| [
"riemann.config.graph_sampling_config.GraphSamplingConfig",
"riemann.data.data_loader.get_training_data",
"riemann.config.config_loader.initialize_config"
] | [((201, 220), 'riemann.config.config_loader.initialize_config', 'initialize_config', ([], {}), '()\n', (218, 220), False, 'from riemann.config.config_loader import initialize_config\n'), ((225, 244), 'riemann.data.data_loader.get_training_data', 'get_training_data', ([], {}), '()\n', (242, 244), False, 'from riemann.da... |
"""
A Maximum-Entropy model for backbone torsion angles.
Reference: Rowicka and Otwinowski 2004
"""
import numpy
from csb.statistics.pdf import BaseDensity
class MaxentModel(BaseDensity):
"""
Fourier expansion of a biangular log-probability density
"""
def __init__(self, n, beta=1.):
"""
... | [
"numpy.sum",
"csb.numeric.log",
"numpy.zeros",
"numpy.max",
"numpy.multiply.outer",
"numpy.arange",
"numpy.reshape",
"numpy.array",
"scipy.integrate.dblquad",
"numpy.linspace",
"numpy.dot",
"numpy.random.standard_normal",
"numpy.add.outer",
"os.path.expanduser",
"csb.io.load",
"csb.num... | [((566, 597), 'numpy.zeros', 'numpy.zeros', (['(self._n, self._n)'], {}), '((self._n, self._n))\n', (577, 597), False, 'import numpy\n'), ((617, 648), 'numpy.zeros', 'numpy.zeros', (['(self._n, self._n)'], {}), '((self._n, self._n))\n', (628, 648), False, 'import numpy\n'), ((668, 699), 'numpy.zeros', 'numpy.zeros', ([... |
# -*- mode:python; coding:utf-8 -*-
# Copyright (c) 2020 IBM Corp. 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
#
#... | [
"trestle.core.utils.classname_to_alias",
"trestle.core.err.TrestleError",
"trestle.core.models.elements.ElementPath",
"trestle.utils.log.set_log_level_from_args",
"logging.getLogger",
"pathlib.Path",
"trestle.core.models.file_content_type.FileContentType.to_content_type",
"trestle.core.models.actions.... | [((1310, 1337), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1327, 1337), False, 'import logging\n'), ((2353, 2386), 'trestle.utils.log.set_log_level_from_args', 'log.set_log_level_from_args', (['args'], {}), '(args)\n', (2380, 2386), False, 'from trestle.utils import log\n'), ((2442, ... |
import configparser
from dlpipe.data_reader.mongodb import MongoDBConnect
from dlpipe.utils import DLPipeLogger
from bson import ObjectId
import plotly.graph_objs as go
import plotly.offline as offline
def create_plot_data(convert_data: list, batch_size: int, smooth_window: int=1):
"""
Convert metric data in... | [
"plotly.graph_objs.Scatter",
"dlpipe.data_reader.mongodb.MongoDBConnect.add_connections_from_config",
"dlpipe.utils.DLPipeLogger.remove_file_logger",
"dlpipe.data_reader.mongodb.MongoDBConnect.get_collection",
"configparser.ConfigParser",
"bson.ObjectId"
] | [((1940, 2018), 'plotly.graph_objs.Scatter', 'go.Scatter', ([], {'x': 'x_train_loss', 'y': 'y_train_loss', 'mode': '"""lines"""', 'name': '"""training loss"""'}), "(x=x_train_loss, y=y_train_loss, mode='lines', name='training loss')\n", (1950, 2018), True, 'import plotly.graph_objs as go\n'), ((2040, 2116), 'plotly.gra... |
import ctre
import wpilib
import math
from ctre import WPI_TalonSRX as Talon
from wpilib.drive.differentialdrive import DifferentialDrive
from wpilib.speedcontrollergroup import SpeedControllerGroup
from wpilib.smartdashboard import SmartDashboard as SD
from wpilib.command import Subsystem
#from robotpy_ext.common_dri... | [
"wpilib.drive.differentialdrive.DifferentialDrive",
"wpilib.LiveWindow.addActuator",
"ctre.WPI_TalonSRX",
"wpilib.RobotDrive.limit",
"math.copysign",
"wpilib.smartdashboard.SmartDashboard.putNumber",
"wpilib.PIDController",
"navx.AHRS.create_spi",
"wpilib.speedcontrollergroup.SpeedControllerGroup"
] | [((667, 684), 'navx.AHRS.create_spi', 'AHRS.create_spi', ([], {}), '()\n', (682, 684), False, 'from navx import AHRS\n'), ((905, 949), 'ctre.WPI_TalonSRX', 'Talon', (["self.robot.kDriveTrain['left_master']"], {}), "(self.robot.kDriveTrain['left_master'])\n", (910, 949), True, 'from ctre import WPI_TalonSRX as Talon\n')... |
import psycopg2
def open_db(db_config):
"""
This function open posgresql-session with db-config
:param db_config: dict of db-parameters
:type db_config: dict
:return: 2 objects - connect-object and cursor-object
:rtype: object
"""
user = db_config["user"]
password = db_config["pass... | [
"psycopg2.connect"
] | [((437, 525), 'psycopg2.connect', 'psycopg2.connect', ([], {'dbname': 'db_name', 'user': 'user', 'password': 'password', 'host': 'host', 'port': 'port'}), '(dbname=db_name, user=user, password=password, host=host,\n port=port)\n', (453, 525), False, 'import psycopg2\n')] |
# This file is part of the pycalver project
# https://gitlab.com/mbarkhau/pycalver
#
# Copyright (c) 2019 <NAME> (<EMAIL>) - MIT License
# SPDX-License-Identifier: MIT
#
# pycalver/vcs.py (this file) is based on code from the
# bumpversion project: https://github.com/peritus/bumpversion
# Copyright (c) 2013-2014 <NAME>... | [
"tempfile.NamedTemporaryFile",
"os.unlink",
"os.environ.copy",
"os.path.exists",
"subprocess.call",
"logging.getLogger"
] | [((620, 653), 'logging.getLogger', 'logging.getLogger', (['"""pycalver.vcs"""'], {}), "('pycalver.vcs')\n", (637, 653), False, 'import logging\n'), ((4494, 4541), 'tempfile.NamedTemporaryFile', 'tempfile.NamedTemporaryFile', (['"""wb"""'], {'delete': '(False)'}), "('wb', delete=False)\n", (4521, 4541), False, 'import t... |
import wx
import images
from .generic_bitmap_button import GenericBitmapButton
from pubsub import pub
from datetime import datetime
class _ToolColor(wx.Panel):
def __init__(self, parent):
super().__init__(parent)
self._init_ui()
self.display_color('#000000')
def _init_ui(self):
... | [
"wx.StaticLine",
"wx.Choice",
"pubsub.pub.sendMessage",
"wx.BoxSizer",
"wx.GetColourFromUser",
"datetime.datetime.now"
] | [((340, 364), 'wx.BoxSizer', 'wx.BoxSizer', (['wx.VERTICAL'], {}), '(wx.VERTICAL)\n', (351, 364), False, 'import wx\n'), ((465, 498), 'wx.StaticLine', 'wx.StaticLine', (['self'], {'size': '(-1, 2)'}), '(self, size=(-1, 2))\n', (478, 498), False, 'import wx\n'), ((930, 956), 'wx.BoxSizer', 'wx.BoxSizer', (['wx.HORIZONTA... |
#!/usr/bin/env python3.6
# Is a work in progress
# TODO: split to multiple files
import glob
import os
import sys
import carla
import zmq
import random
import time
import os
ROTATION_PARAMS = ("pitch", "yaw", "roll")
COORDINATES_PARAMS = ("velocity", "acceleration", "angular_velocity", "location")
CONTROL_PARAMS... | [
"carla.Transform",
"os.makedirs",
"time.sleep",
"carla.Client",
"carla.Rotation",
"carla.Location",
"os.listdir",
"zmq.Context"
] | [((5300, 5338), 'os.makedirs', 'os.makedirs', (['out_folder'], {'exist_ok': '(True)'}), '(out_folder, exist_ok=True)\n', (5311, 5338), False, 'import os\n'), ((5506, 5537), 'carla.Client', 'carla.Client', (['"""localhost"""', '(2000)'], {}), "('localhost', 2000)\n", (5518, 5537), False, 'import carla\n'), ((3642, 3715)... |
"""
Test the abilities of the limit filter.
This is not about query parsing, but rather
handling once we have the filter.
"""
import py.test
from tiddlyweb.model.tiddler import Tiddler
from tiddlyweb.filters.limit import limit
from tiddlyweb.filters import parse_for_filters, recursive_filter, FilterError
tiddlers = ... | [
"tiddlyweb.filters.recursive_filter",
"tiddlyweb.model.tiddler.Tiddler",
"tiddlyweb.filters.limit.limit",
"tiddlyweb.filters.parse_for_filters"
] | [((321, 333), 'tiddlyweb.model.tiddler.Tiddler', 'Tiddler', (['"""1"""'], {}), "('1')\n", (328, 333), False, 'from tiddlyweb.model.tiddler import Tiddler\n'), ((335, 347), 'tiddlyweb.model.tiddler.Tiddler', 'Tiddler', (['"""c"""'], {}), "('c')\n", (342, 347), False, 'from tiddlyweb.model.tiddler import Tiddler\n'), ((3... |
from datetime import datetime
from django.db import models
from apps.users.models import BaseModel
from apps.organizations.models import Teacher
from apps.organizations.models import CourseOrg
from DjangoUeditor.models import UEditorField
# Create your models here.
#订单表
class Order(models.Model):
order_number =... | [
"django.db.models.FileField",
"django.db.models.CharField",
"django.db.models.ForeignKey",
"DjangoUeditor.models.UEditorField",
"django.db.models.BooleanField",
"django.db.models.ImageField",
"django.db.models.IntegerField",
"django.db.models.DateTimeField"
] | [((321, 372), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(64)', 'verbose_name': '"""订单号"""'}), "(max_length=64, verbose_name='订单号')\n", (337, 372), False, 'from django.db import models\n'), ((438, 513), 'django.db.models.IntegerField', 'models.IntegerField', ([], {'choices': 'status_choices'... |
#!/usr/bin/env python
""" Calculates a lookup table with optimal switching times for an isolated matrix-type DAB three-phase rectifier.
This file calculates a 3D lookup table of relative switching times for an IMDAB3R, which are optimized for minimal
conduction losses. In discontinuous conduction mode (DCM) analytical... | [
"sys.stdout.write",
"numpy.abs",
"csv_io.export_csv",
"argparse.ArgumentParser",
"hw_functions.rms_current_grad",
"numpy.clip",
"hw_functions.dab_io_currents",
"sys.stdout.flush",
"scipy.optimize.fmin_slsqp",
"time.clock",
"numpy.max",
"numpy.linspace",
"hw_functions.rms_current_harm",
"nu... | [((955, 982), 'numpy.clip', 'np.clip', (['shift', '(-0.25)', '(0.25)'], {}), '(shift, -0.25, 0.25)\n', (962, 982), True, 'import numpy as np\n'), ((1012, 1033), 'numpy.clip', 'np.clip', (['d_dc', '(0)', '(0.5)'], {}), '(d_dc, 0, 0.5)\n', (1019, 1033), True, 'import numpy as np\n'), ((1345, 1438), 'numpy.array', 'np.arr... |
import unittest
import numpy
from chainer import cuda
from chainer import testing
from chainer.testing import attr
from chainer import utils
class TestWalkerAlias(unittest.TestCase):
def setUp(self):
self.ps = numpy.array([5, 3, 4, 1, 2], dtype=numpy.int32)
self.sampler = utils.WalkerAlias(self... | [
"chainer.testing.assert_allclose",
"chainer.utils.WalkerAlias",
"chainer.cuda.to_cpu",
"numpy.array",
"chainer.testing.run_module"
] | [((1059, 1097), 'chainer.testing.run_module', 'testing.run_module', (['__name__', '__file__'], {}), '(__name__, __file__)\n', (1077, 1097), False, 'from chainer import testing\n'), ((227, 274), 'numpy.array', 'numpy.array', (['[5, 3, 4, 1, 2]'], {'dtype': 'numpy.int32'}), '([5, 3, 4, 1, 2], dtype=numpy.int32)\n', (238,... |
import math
import re
import torch
def read_bpseq(file):
with open(file) as f:
p = [0]
s = ['']
name = sc = t = None
for l in f:
if l.startswith('#'):
m = re.search(r'^# (.*) \(s=([\d.]+), ([\d.]+)s\)', l)
if m:
name,... | [
"re.search",
"argparse.ArgumentParser",
"math.sqrt"
] | [((2217, 2339), 'argparse.ArgumentParser', 'ArgumentParser', ([], {'description': '"""calculate SEN, PPV, F, MCC for the predicted RNA secondary structure"""', 'add_help': '(True)'}), "(description=\n 'calculate SEN, PPV, F, MCC for the predicted RNA secondary structure',\n add_help=True)\n", (2231, 2339), False,... |
import httpretty
import requests
from behave import given, when, then
from nose.tools import assert_in
import requestsdefaulter
@given(u'I have the default headers set to')
def set_default_headers(context):
"""
:type context: behave.runner.Context
"""
headers = row_table(context)
def default_... | [
"behave.when",
"behave.then",
"httpretty.last_request",
"nose.tools.assert_in",
"requestsdefaulter.default_headers",
"requests.get",
"behave.given"
] | [((132, 175), 'behave.given', 'given', (['u"""I have the default headers set to"""'], {}), "(u'I have the default headers set to')\n", (137, 175), False, 'from behave import given, when, then\n'), ((569, 594), 'behave.when', 'when', (['u"""I make a request"""'], {}), "(u'I make a request')\n", (573, 594), False, 'from ... |
#!/usr/bin/env python
__author__ = '<NAME>'
import sys
import argparse
from RouToolPa.Routines import AnnotationsRoutines
parser = argparse.ArgumentParser()
parser.add_argument("-g", "--gff", action="store", dest="gff", required=True,
help="Gff file")
parser.add_argument("-o", "--output", action... | [
"argparse.ArgumentParser",
"RouToolPa.Routines.AnnotationsRoutines.get_scaffold_ids_from_gff"
] | [((133, 158), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (156, 158), False, 'import argparse\n'), ((494, 571), 'RouToolPa.Routines.AnnotationsRoutines.get_scaffold_ids_from_gff', 'AnnotationsRoutines.get_scaffold_ids_from_gff', (['args.gff'], {'out_file': 'args.output'}), '(args.gff, out_fi... |
from django.contrib.auth.models import User
from django.db import models
# Create your models here.
class Book(models.Model):
title = models.CharField(max_length=200)
subject = models.ForeignKey('Subject', on_delete=models.CASCADE, blank=True, null=True)
author = models.ForeignKey('Author', on_delete=mo... | [
"django.db.models.TextField",
"django.db.models.ManyToManyField",
"django.db.models.CharField",
"django.db.models.ForeignKey",
"django.db.models.BooleanField",
"django.db.models.ImageField"
] | [((142, 174), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(200)'}), '(max_length=200)\n', (158, 174), False, 'from django.db import models\n'), ((189, 266), 'django.db.models.ForeignKey', 'models.ForeignKey', (['"""Subject"""'], {'on_delete': 'models.CASCADE', 'blank': '(True)', 'null': '(Tru... |
# -*- coding: utf-8 -*-
import os, jinja2
import numpy as np
import scipy.optimize
from ..util import functions as f
from ..util import tools, constants
# see README for terminology, terminolology, lol
class Vertex():
""" point with an index that's used in block and face definition
and can output in OpenFOAM ... | [
"numpy.shape",
"numpy.array",
"numpy.concatenate"
] | [((383, 398), 'numpy.array', 'np.array', (['point'], {}), '(point)\n', (391, 398), True, 'import numpy as np\n'), ((1708, 1724), 'numpy.array', 'np.array', (['points'], {}), '(points)\n', (1716, 1724), True, 'import numpy as np\n'), ((1741, 1757), 'numpy.shape', 'np.shape', (['points'], {}), '(points)\n', (1749, 1757),... |
# coding: utf-8
"""
NiFi Rest Api
The Rest Api provides programmatic access to command and control a NiFi instance in real time. Start and stop processors, monitor queues, query provenance data, and more. Each endpoint below includes a description, ... | [
"six.iteritems"
] | [((21026, 21055), 'six.iteritems', 'iteritems', (['self.swagger_types'], {}), '(self.swagger_types)\n', (21035, 21055), False, 'from six import iteritems\n')] |
from gevent import monkey
# monkey.patch_all(aggressive=False)
monkey.patch_socket()
monkey.patch_thread()
monkey.patch_time()
monkey.patch_ssl()
from JumpScale import j
from gevent.pywsgi import WSGIServer
from JumpScale.servers.serverbase import returnCodes
import time
import gevent
def jsonrpc(func):
def wra... | [
"JumpScale.j.servers.base.getDaemon",
"gevent.greenlet.Greenlet",
"JumpScale.j.servers.base._unserializeBinSend",
"JumpScale.j.data.time.getHourId",
"gevent.monkey.patch_ssl",
"JumpScale.j.servers.base._serializeBinReturn",
"time.time",
"gevent.monkey.patch_time",
"gevent.monkey.patch_socket",
"ge... | [((63, 84), 'gevent.monkey.patch_socket', 'monkey.patch_socket', ([], {}), '()\n', (82, 84), False, 'from gevent import monkey\n'), ((85, 106), 'gevent.monkey.patch_thread', 'monkey.patch_thread', ([], {}), '()\n', (104, 106), False, 'from gevent import monkey\n'), ((107, 126), 'gevent.monkey.patch_time', 'monkey.patch... |
import numpy
from numpy.testing import assert_array_equal
import pandas as pd
import pytest
import ipdb
import alpha_tech_tracker.technical_analysis as ta
import alpha_tech_tracker.stock_price_data_loader as data_loader
def test_load_from_csv():
data_loader.load_from_csv()
| [
"alpha_tech_tracker.stock_price_data_loader.load_from_csv"
] | [((254, 281), 'alpha_tech_tracker.stock_price_data_loader.load_from_csv', 'data_loader.load_from_csv', ([], {}), '()\n', (279, 281), True, 'import alpha_tech_tracker.stock_price_data_loader as data_loader\n')] |
import datetime
import re
from decimal import Decimal
from flask import Blueprint, request
from sqlalchemy import text
from cache import cache, make_cache_key
from db import db
from timer import timer
routes = Blueprint('ebrake', __name__, url_prefix='/federal-emergency-brake')
@routes.route('/', methods=['GET'])
... | [
"flask.Blueprint",
"cache.cache.cached",
"flask.request.args.get",
"sqlalchemy.text",
"datetime.timedelta",
"datetime.datetime.now",
"re.sub"
] | [((213, 281), 'flask.Blueprint', 'Blueprint', (['"""ebrake"""', '__name__'], {'url_prefix': '"""/federal-emergency-brake"""'}), "('ebrake', __name__, url_prefix='/federal-emergency-brake')\n", (222, 281), False, 'from flask import Blueprint, request\n'), ((328, 367), 'cache.cache.cached', 'cache.cached', ([], {'key_pre... |
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not u... | [
"marvin.sshClient.SshClient",
"nose.plugins.attrib.attr"
] | [((2972, 3079), 'marvin.sshClient.SshClient', 'SshClient', (["self.mgtSvrDetails['mgtSvrIp']", '(22)', "self.mgtSvrDetails['user']", "self.mgtSvrDetails['passwd']"], {}), "(self.mgtSvrDetails['mgtSvrIp'], 22, self.mgtSvrDetails['user'],\n self.mgtSvrDetails['passwd'])\n", (2981, 3079), False, 'from marvin.sshClient ... |
# Generated by Django 3.0.3 on 2020-03-07 08:20
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('contenttypes', '0002_remove_content_type_name'),
('munactives', '0003_auto_20200209_1142'),
]
operations = ... | [
"django.db.models.TextField",
"django.db.models.CharField",
"django.db.models.ForeignKey",
"django.db.models.PositiveIntegerField",
"django.db.models.AutoField",
"django.db.models.IntegerField"
] | [((430, 484), 'django.db.models.IntegerField', 'models.IntegerField', ([], {'primary_key': '(True)', 'serialize': '(False)'}), '(primary_key=True, serialize=False)\n', (449, 484), False, 'from django.db import migrations, models\n'), ((512, 544), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(1... |
from annotypes import Anno, Array, Union, Sequence, TYPE_CHECKING
from enum import Enum
import numpy as np
from malcolm.core import Table, Future, Context, PartRegistrar, DEFAULT_TIMEOUT
from malcolm.modules import scanning
if TYPE_CHECKING:
from typing import List, Any
class AttributeDatasetType(Enum):
DET... | [
"malcolm.modules.scanning.infos.RunProgressInfo",
"annotypes.Anno"
] | [((1130, 1151), 'annotypes.Anno', 'Anno', (['"""Dataset names"""'], {}), "('Dataset names')\n", (1134, 1151), False, 'from annotypes import Anno, Array, Union, Sequence, TYPE_CHECKING\n'), ((1186, 1236), 'annotypes.Anno', 'Anno', (['"""Filenames of HDF files relative to fileDir"""'], {}), "('Filenames of HDF files rela... |
"""
MIT License
Copyright (c) 2021-present Defxult#8269
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 without limitation
the rights to use, copy, modify, merge, p... | [
"discord.ui.View",
"random.choice",
"re.escape",
"asyncio.iscoroutinefunction",
"re.search",
"inspect.cleandoc",
"re.sub"
] | [((5262, 5301), 'discord.ui.View', 'discord.ui.View', ([], {'timeout': 'self.__timeout'}), '(timeout=self.__timeout)\n', (5277, 5301), False, 'import discord\n'), ((6328, 6365), 'discord.ui.View', 'discord.ui.View', ([], {'timeout': 'self.timeout'}), '(timeout=self.timeout)\n', (6343, 6365), False, 'import discord\n'),... |
import random
import string
def generate_secure_password(length=32):
return "".join(random.choices(string.ascii_letters + string.digits, k=length))
def poll_options(options):
while True:
for index, option in enumerate(options):
print(f"[{index+1}]: {option}")
val = input("Selecti... | [
"random.choices"
] | [((90, 152), 'random.choices', 'random.choices', (['(string.ascii_letters + string.digits)'], {'k': 'length'}), '(string.ascii_letters + string.digits, k=length)\n', (104, 152), False, 'import random\n')] |
import argparse
import pandas as pd
from mongoengine import QuerySet
from ..tables import species, dataset
def _load_configuration() -> argparse.Namespace:
"""
Parse command line arguments.
Parameters
----------
:return: configuration object
"""
parser = argparse.ArgumentParser()
p... | [
"pandas.DataFrame",
"argparse.ArgumentParser"
] | [((289, 314), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (312, 314), False, 'import argparse\n'), ((2548, 2562), 'pandas.DataFrame', 'pd.DataFrame', ([], {}), '()\n', (2560, 2562), True, 'import pandas as pd\n')] |
import numpy as np
from matplotlib import image as mimage
from time import time
class Timer(object):
"""A simple timer context-manager, taken from
https://blog.usejournal.com/how-to-create-your-own-timing-context-manager-in-python-a0e944b48cf8
"""
def __init__(self, description):
self.descri... | [
"numpy.dot",
"matplotlib.image.imread",
"numpy.max",
"time.time"
] | [((906, 950), 'numpy.dot', 'np.dot', (['rgb[..., :3]', '[0.2989, 0.587, 0.114]'], {}), '(rgb[..., :3], [0.2989, 0.587, 0.114])\n', (912, 950), True, 'import numpy as np\n'), ((1416, 1439), 'matplotlib.image.imread', 'mimage.imread', (['filename'], {}), '(filename)\n', (1429, 1439), True, 'from matplotlib import image a... |
#
# Copyright (C) 2021 <NAME>
#
from typing import Any
import math
class Point:
"""
Class representing a point on a plane.
"""
def __init__(self, x: float, y: float):
"""
Constructs a 2d point.
Args:
x: The x-coordinate of the point.
y: The y-coordi... | [
"math.sqrt"
] | [((1824, 1860), 'math.sqrt', 'math.sqrt', (['(self.x ** 2 + self.y ** 2)'], {}), '(self.x ** 2 + self.y ** 2)\n', (1833, 1860), False, 'import math\n')] |
import numpy as np
import pandas as pd
from scipy import interpolate
from .Constants import *
from .AtomicData import *
from .Conversions import *
##########################
# Taken from: https://stackoverflow.com/questions/779495/python-access-data-in-package-subdirectory
# This imports the file 'PREM500.csv' withi... | [
"pandas.read_csv",
"numpy.asarray",
"scipy.interpolate.interp1d",
"os.path.split",
"os.path.join"
] | [((409, 432), 'os.path.split', 'os.path.split', (['__file__'], {}), '(__file__)\n', (422, 432), False, 'import os\n'), ((580, 621), 'os.path.join', 'os.path.join', (['this_dir', '"""PREM500_Mod.csv"""'], {}), "(this_dir, 'PREM500_Mod.csv')\n", (592, 621), False, 'import os\n'), ((642, 686), 'os.path.join', 'os.path.joi... |
#!/usr/bin/env python
# Copyright 2019, <NAME>, mailto:<EMAIL>
#
# Part of "Nuitka", an optimizing Python compiler that is compatible and
# integrates with CPython, but also works on its own.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in co... | [
"os.path.abspath",
"os.pathsep.join",
"nuitka.tools.testing.Valgrind.runValgrind",
"os.path.basename",
"os.path.dirname",
"os.path.exists",
"os.system",
"os.environ.get",
"nuitka.tools.testing.Valgrind.getBinarySizes",
"sys.stdout.flush",
"os.path.normpath",
"shutil.rmtree",
"sys.exit"
] | [((1298, 1329), 'os.path.normpath', 'os.path.normpath', (['nuitka_binary'], {}), '(nuitka_binary)\n', (1314, 1329), False, 'import os\n'), ((1342, 1370), 'os.path.basename', 'os.path.basename', (['input_file'], {}), '(input_file)\n', (1358, 1370), False, 'import os\n'), ((1768, 1793), 'os.pathsep.join', 'os.pathsep.joi... |
# Import APIView class from the rest_framework.views modules
from rest_framework.views import APIView
# Imports the response object which used to return responses from the APIView
from rest_framework.response import Response
# Create new class based on the APIView class.
class HelloApiView(APIView):
"""Test API V... | [
"rest_framework.response.Response"
] | [((849, 905), 'rest_framework.response.Response', 'Response', (["{'message': 'Hello', 'an_apiview': an_apiview}"], {}), "({'message': 'Hello', 'an_apiview': an_apiview})\n", (857, 905), False, 'from rest_framework.response import Response\n')] |
#!/usr/bin/env python
# <examples/doc_nistgauss2.py>
import matplotlib.pyplot as plt
import numpy as np
from lmfit.models import ExponentialModel, GaussianModel
dat = np.loadtxt('NIST_Gauss2.dat')
x = dat[:, 1]
y = dat[:, 0]
exp_mod = ExponentialModel(prefix='exp_')
gauss1 = GaussianModel(prefix='g1_')
gauss2 = Gau... | [
"matplotlib.pyplot.show",
"matplotlib.pyplot.plot",
"numpy.where",
"numpy.loadtxt",
"lmfit.models.GaussianModel",
"lmfit.models.ExponentialModel"
] | [((170, 199), 'numpy.loadtxt', 'np.loadtxt', (['"""NIST_Gauss2.dat"""'], {}), "('NIST_Gauss2.dat')\n", (180, 199), True, 'import numpy as np\n'), ((239, 270), 'lmfit.models.ExponentialModel', 'ExponentialModel', ([], {'prefix': '"""exp_"""'}), "(prefix='exp_')\n", (255, 270), False, 'from lmfit.models import Exponentia... |
import datetime
import twint
import csv
import re
import json
import os
# 現在時刻
dt_now = datetime.datetime.now().strftime("%Y/%m/%d %H:%M")
c = twint.Config()
c.Username = "pref_toyama"
c.Search = "感染者の現況"
c.Since = datetime.datetime.now().strftime("%Y-%m-%d")
c.Store_csv = True
c.Output = "tmp.csv"
twint.run.Search(... | [
"json.dump",
"os.remove",
"json.load",
"csv.reader",
"twint.run.Search",
"twint.Config",
"re.search",
"datetime.datetime.now"
] | [((145, 159), 'twint.Config', 'twint.Config', ([], {}), '()\n', (157, 159), False, 'import twint\n'), ((303, 322), 'twint.run.Search', 'twint.run.Search', (['c'], {}), '(c)\n', (319, 322), False, 'import twint\n'), ((2325, 2345), 'os.remove', 'os.remove', (['"""tmp.csv"""'], {}), "('tmp.csv')\n", (2334, 2345), False, '... |
import librosa
import librosa.display
import matplotlib.pyplot as plt
import numpy as np
import torch
from tqdm import tqdm
from trainer.base_trainer import BaseTrainer
from util.utils import compute_SDR
plt.switch_backend('agg')
class Trainer(BaseTrainer):
def __init__(self, config, resume: boo... | [
"matplotlib.pyplot.switch_backend",
"matplotlib.pyplot.tight_layout",
"tqdm.tqdm",
"numpy.sum",
"librosa.display.waveplot",
"numpy.std",
"torch.split",
"torch.cat",
"numpy.max",
"numpy.mean",
"numpy.min",
"librosa.amplitude_to_db",
"util.utils.compute_SDR",
"torch.no_grad",
"matplotlib.p... | [((218, 243), 'matplotlib.pyplot.switch_backend', 'plt.switch_backend', (['"""agg"""'], {}), "('agg')\n", (236, 243), True, 'import matplotlib.pyplot as plt\n'), ((2571, 2586), 'torch.no_grad', 'torch.no_grad', ([], {}), '()\n', (2584, 2586), False, 'import torch\n'), ((804, 848), 'tqdm.tqdm', 'tqdm', (['self.train_dat... |
import src.view.senhasView as sv
import src.model.senhasModel as sm
class SenhasController:
def __init__(self):
self.senhas_model = sm.SenhasModel()
def start(self):
sev = sv.SenhasView(self)
sev.start()
def searchAllSenhas(self):
return self.senhas_model.selectAll()
... | [
"src.model.senhasModel.SenhasModel",
"src.view.senhasView.SenhasView"
] | [((146, 162), 'src.model.senhasModel.SenhasModel', 'sm.SenhasModel', ([], {}), '()\n', (160, 162), True, 'import src.model.senhasModel as sm\n'), ((199, 218), 'src.view.senhasView.SenhasView', 'sv.SenhasView', (['self'], {}), '(self)\n', (212, 218), True, 'import src.view.senhasView as sv\n')] |
'''
Copyright 2015 by <NAME>
This file is part of Statistical Parameter Estimation Tool (SPOTPY).
:author: <NAME>
This example implements the Rosenbrock function into SPOT.
'''
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from __future__ import unicode... | [
"spotpy.parameter.List",
"spotpy.parameter.generate",
"numpy.sin",
"numpy.array",
"spotpy.algorithms.mc",
"spotpy.objectivefunctions.rmse"
] | [((1669, 1701), 'spotpy.algorithms.mc', 'spotpy.algorithms.mc', (['spot_setup'], {}), '(spot_setup)\n', (1689, 1701), False, 'import spotpy\n'), ((778, 816), 'spotpy.parameter.generate', 'spotpy.parameter.generate', (['self.params'], {}), '(self.params)\n', (803, 816), False, 'import spotpy\n'), ((869, 885), 'numpy.arr... |
from kivy.app import App
from kivy.uix.button import Button
from kivy.uix.label import Label
from kivy.uix.textinput import TextInput
from kivy.uix.boxlayout import BoxLayout
from kivy.uix.scrollview import ScrollView
from kivy.uix.screenmanager import ScreenManager, Screen
from kivy.config import Config
clas... | [
"kivy.uix.boxlayout.BoxLayout",
"kivy.uix.label.Label",
"kivy.uix.screenmanager.ScreenManager",
"kivy.uix.button.Button"
] | [((423, 456), 'kivy.uix.boxlayout.BoxLayout', 'BoxLayout', ([], {'orientation': '"""vertical"""'}), "(orientation='vertical')\n", (432, 456), False, 'from kivy.uix.boxlayout import BoxLayout\n'), ((472, 514), 'kivy.uix.label.Label', 'Label', ([], {'text': '"""[size=20][b]Hello[/b][/size]"""'}), "(text='[size=20][b]Hell... |
# flake8: noqa
import logging
import os
import warnings
logger = logging.getLogger(__name__)
warnings.simplefilter("default")
try:
import alchemy
from .alchemy import AlchemyRunner, SupervisedAlchemyRunner
warnings.warn(
"AlchemyRunner and SupervisedAlchemyRunner are deprecated; "
"use Al... | [
"os.environ.get",
"warnings.warn",
"warnings.simplefilter",
"logging.getLogger"
] | [((66, 93), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (83, 93), False, 'import logging\n'), ((94, 126), 'warnings.simplefilter', 'warnings.simplefilter', (['"""default"""'], {}), "('default')\n", (115, 126), False, 'import warnings\n'), ((221, 393), 'warnings.warn', 'warnings.warn', ... |