code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
from spade.agent import Agent
from typing import Iterable
from driftage.analyser.behaviour.receive_new_data import ReceiveNewData
from driftage.analyser.behaviour.train_predictor import TrainPredictor
from driftage.analyser.predictor import AnalyserPredictor
from driftage.db.connection import Connection
from driftage.b... | [
"driftage.base.conf.getLogger",
"driftage.analyser.behaviour.receive_new_data.ReceiveNewData",
"driftage.analyser.behaviour.train_predictor.TrainPredictor"
] | [((1621, 1642), 'driftage.base.conf.getLogger', 'getLogger', (['"""analyser"""'], {}), "('analyser')\n", (1630, 1642), False, 'from driftage.base.conf import getLogger\n'), ((2253, 2269), 'driftage.analyser.behaviour.receive_new_data.ReceiveNewData', 'ReceiveNewData', ([], {}), '()\n', (2267, 2269), False, 'from drifta... |
'''
Helper functions to work with matrices
'''
import numpy as np
def random_unique_permutations(num_permutations, permutation_size):
'''Returns a set of randomly chosen unique permutations
Example:
array([[3, 1, 2, 0],
[1, 2, 0, 3],
[2, 0, 3, 1]])
References:
*... | [
"numpy.random.rand"
] | [((468, 518), 'numpy.random.rand', 'np.random.rand', (['num_permutations', 'permutation_size'], {}), '(num_permutations, permutation_size)\n', (482, 518), True, 'import numpy as np\n')] |
import collections
import numpy as np
import pandas as pd
from sklearn.neighbors import KDTree
from sklearn.externals.joblib import Parallel, delayed
train = pd.read_csv('../input/training.txt', header=None, names=['id', 'type'])
test = pd.read_csv('../input/testing.txt', header=None, names=['id'])
type_to_idx = {t:... | [
"sklearn.externals.joblib.Parallel",
"sklearn.externals.joblib.delayed",
"pandas.read_csv",
"numpy.hstack",
"collections.OrderedDict",
"sklearn.neighbors.KDTree",
"pandas.concat"
] | [((160, 231), 'pandas.read_csv', 'pd.read_csv', (['"""../input/training.txt"""'], {'header': 'None', 'names': "['id', 'type']"}), "('../input/training.txt', header=None, names=['id', 'type'])\n", (171, 231), True, 'import pandas as pd\n'), ((239, 301), 'pandas.read_csv', 'pd.read_csv', (['"""../input/testing.txt"""'], ... |
from django.db import models
from django.utils.translation import ugettext_lazy as _
from django.utils.translation import ugettext
class Feedback(models.Model):
date = models.DateTimeField(_('date'), auto_now_add=True)
name = models.CharField(_('name'), max_length=254, blank=True, null=True)
email = model... | [
"django.db.models.ForeignKey",
"django.utils.translation.ugettext",
"django.utils.translation.ugettext_lazy"
] | [((374, 407), 'django.db.models.ForeignKey', 'models.ForeignKey', (['"""FeedbackType"""'], {}), "('FeedbackType')\n", (391, 407), False, 'from django.db import models\n'), ((522, 576), 'django.db.models.ForeignKey', 'models.ForeignKey', (['"""Attachment"""'], {'blank': '(True)', 'null': '(True)'}), "('Attachment', blan... |
import xml.etree.ElementTree as ET
from tableaudocumentapi.dbclass import is_valid_dbclass
class Connection(object):
"""A class representing connections inside Data Sources."""
def __init__(self, connxml):
"""Connection is usually instantiated by passing in connection elements
in a Data Sourc... | [
"tableaudocumentapi.dbclass.is_valid_dbclass",
"xml.etree.ElementTree.Element"
] | [((1553, 1608), 'xml.etree.ElementTree.Element', 'ET.Element', (['"""connection"""'], {'authentication': 'authentication'}), "('connection', authentication=authentication)\n", (1563, 1608), True, 'import xml.etree.ElementTree as ET\n'), ((3711, 3734), 'tableaudocumentapi.dbclass.is_valid_dbclass', 'is_valid_dbclass', (... |
#!/usr/bin/env python
# coding: utf-8
# this kernel was based https://www.kaggle.com/corochann/ashrae-training-lgbm-by-meter-type
import argparse
import gc
import os
from pathlib import Path
import random
import sys
from tqdm import tqdm_notebook as tqdm
import numpy as np
import pandas as pd
import matplotlib.pypl... | [
"utils.timer",
"argparse.ArgumentParser",
"utils.add_lag_feature",
"sklearn.metrics.mean_squared_error",
"numpy.zeros",
"pandas.read_feather",
"utils.add_holiyday",
"utils.reduce_mem_usage",
"gc.collect",
"pathlib.Path",
"numpy.expm1",
"pickle.load",
"seaborn.distplot",
"utils.add_sg",
"... | [((672, 688), 'pathlib.Path', 'Path', (['"""../input"""'], {}), "('../input')\n", (676, 688), False, 'from pathlib import Path\n'), ((700, 720), 'pathlib.Path', 'Path', (['"""../processed"""'], {}), "('../processed')\n", (704, 720), False, 'from pathlib import Path\n'), ((735, 752), 'pathlib.Path', 'Path', (['"""../out... |
import xlwings as xw
import datetime
import pandas as pd
import revs_helper
import wbes_helper
import scada_files_helper
import state_files_helper
import ids_helper
import db_helper
import re
import log_helper
import numpy as np
try:
from itertools import izip as zip
except ImportError: # will be 3.x series
pa... | [
"scada_files_helper.get_min_minute_val_minute",
"scada_files_helper.get_import_mu_val",
"db_helper.push_report_vals_to_db",
"state_files_helper.get_max_hourly_mul_rngs",
"log_helper.deleteLogsBetweenTimes",
"scada_files_helper.convert_blk_to_time_strs",
"ids_helper.get_config_df",
"wbes_helper.paste_s... | [((2509, 2545), 'xlwings.arg', 'xw.arg', (['"""baseURLStr"""'], {'doc': '"""Base URL"""'}), "('baseURLStr', doc='Base URL')\n", (2515, 2545), True, 'import xlwings as xw\n'), ((2547, 2583), 'xlwings.arg', 'xw.arg', (['"""dateObj"""'], {'doc': '"""Date String"""'}), "('dateObj', doc='Date String')\n", (2553, 2583), True... |
from django import forms
from apps_.usuario.models import Usuario, Debito
from django.utils.safestring import mark_safe
class DebitoForm(forms.ModelForm):
#fecha = models.DateField(default=timezone.now, widget=forms.HiddenInput(default=timezone.now))
class Meta:
model = Debito
fields = ['cuent... | [
"django.forms.NumberInput",
"django.forms.TextInput"
] | [((480, 530), 'django.forms.NumberInput', 'forms.NumberInput', ([], {'attrs': "{'class': 'form-control'}"}), "(attrs={'class': 'form-control'})\n", (497, 530), False, 'from django import forms\n'), ((553, 603), 'django.forms.NumberInput', 'forms.NumberInput', ([], {'attrs': "{'class': 'form-control'}"}), "(attrs={'clas... |
#
# Conduct some preprocessing on data.
#
# @author <NAME> <EMAIL>
#
import sys
import random
import os
ROOT_PATH = sys.path[0]
def mixDataDirs_intoOneFile(dirs):
output_file = open(ROOT_PATH+'/flat_entry_data.html', 'w')
inputs_files = []
for d in dirs:
inputs_files.extend(list(map((lamb... | [
"os.listdir"
] | [((340, 353), 'os.listdir', 'os.listdir', (['d'], {}), '(d)\n', (350, 353), False, 'import os\n')] |
# Project: AttractionRepulsionModel
# Filename: arm_exp.py
# Authors: <NAME> (<EMAIL>).
"""
arm_exp: A framework for defining and running experiments for the
Attraction-Repulsion Model.
"""
import argparse
from arm import arm
from itertools import product
import pickle
import math
fr... | [
"pickle.dump",
"argparse.ArgumentParser",
"matplotlib.animation.FuncAnimation",
"numpy.random.default_rng",
"numpy.shape",
"numpy.histogram",
"matplotlib.colors.LogNorm",
"numpy.arange",
"arm.arm",
"matplotlib.pyplot.tight_layout",
"numpy.meshgrid",
"numpy.copy",
"matplotlib.pyplot.close",
... | [((12440, 12466), 'numpy.arange', 'np.arange', (['(0.05)', '(1.01)', '(0.1)'], {}), '(0.05, 1.01, 0.1)\n', (12449, 12466), True, 'import numpy as np\n'), ((15066, 15096), 'numpy.arange', 'np.arange', (['(0.05)', '(2 ** 0.5)', '(0.1)'], {}), '(0.05, 2 ** 0.5, 0.1)\n', (15075, 15096), True, 'import numpy as np\n'), ((169... |
import importlib
from hydroDL import kPath, utils
from hydroDL.app import waterQuality
from hydroDL.master import basins
from hydroDL.data import usgs, gageII, gridMET, ntn
from hydroDL.master import slurm
from hydroDL.post import axplot, figplot
import numpy as np
import matplotlib.pyplot as plt
import os
import panda... | [
"pandas.DataFrame",
"json.load",
"numpy.datetime64",
"pandas.read_csv",
"hydroDL.utils.stat.calErr",
"numpy.isnan",
"hydroDL.master.basins.loadSeq",
"numpy.where",
"numpy.mean",
"os.path.join",
"hydroDL.utils.rmNan",
"hydroDL.app.waterQuality.readSiteTS"
] | [((445, 504), 'os.path.join', 'os.path.join', (['kPath.dirData', '"""USGS"""', '"""inventory"""', '"""siteSel"""'], {}), "(kPath.dirData, 'USGS', 'inventory', 'siteSel')\n", (457, 504), False, 'import os\n'), ((3108, 3165), 'pandas.DataFrame', 'pd.DataFrame', ([], {'index': 'codeLst', 'columns': "['nSite', 'nSample']"}... |
"""
Script to convert declarations in the new format (both, returned by API and found in new dumps)
to the format, compatible with a previous one
"""
import json
from datetime import datetime
from dateutil.parser import parse as dt_parse
from collections import OrderedDict
class LastUpdatedOrderedDict(OrderedDict):
... | [
"json.load",
"dateutil.parser.parse",
"datetime.datetime.fromtimestamp"
] | [((1038, 1051), 'json.load', 'json.load', (['fp'], {}), '(fp)\n', (1047, 1051), False, 'import json\n'), ((8218, 8268), 'datetime.datetime.fromtimestamp', 'datetime.fromtimestamp', (["self._data['created_date']"], {}), "(self._data['created_date'])\n", (8240, 8268), False, 'from datetime import datetime\n'), ((8384, 84... |
"""
Choosing good features is one of your most important jobs.
"""
import numpy as np
from sklearn.datasets import load_iris
from sklearn import tree
iris = load_iris()
# print(iris.feature_names)
# print(iris.target_names)
# print(iris.data[:10])
# print(iris.target[:10])
# one of each kind of iris
test_indexes =... | [
"sklearn.datasets.load_iris",
"numpy.delete",
"sklearn.tree.DecisionTreeClassifier"
] | [((160, 171), 'sklearn.datasets.load_iris', 'load_iris', ([], {}), '()\n', (169, 171), False, 'from sklearn.datasets import load_iris\n'), ((379, 421), 'numpy.delete', 'np.delete', (['iris.data', 'test_indexes'], {'axis': '(0)'}), '(iris.data, test_indexes, axis=0)\n', (388, 421), True, 'import numpy as np\n'), ((437, ... |
#!/usr/bin/env python3
import argparse
import sys
import math
from typing import List
import random
import numpy
import soundfile
import samplerate as libsamplerate
import progressbar
def divide_sound_file(data: numpy.ndarray, samples_per_chunk: int):
return [
data[i * samples_per_chunk:(i + 1) * sample... | [
"samplerate.Resampler",
"soundfile.read",
"numpy.average",
"argparse.ArgumentParser",
"math.fabs",
"random.choices",
"numpy.append",
"random.seed",
"math.log2",
"numpy.concatenate",
"progressbar.ProgressBarThread"
] | [((892, 945), 'random.choices', 'random.choices', (['chunks'], {'weights': 'weights', 'k': 'num_chunks'}), '(chunks, weights=weights, k=num_chunks)\n', (906, 945), False, 'import random\n'), ((973, 1039), 'argparse.ArgumentParser', 'argparse.ArgumentParser', (['"""Rearrange a sound file to match another"""'], {}), "('R... |
import glob
import time
import cv2
import math
import numpy as np
from Modules.foregroundExtraction import readyFrame, frameDifferencing, morphologicalOperations, natural_sort
from Modules.ballDetection import findContours, sizeDetection, playerProximityDetection, regionDetection, courtBoundaryDetection
startTimeReadi... | [
"cv2.medianBlur",
"Modules.foregroundExtraction.morphologicalOperations",
"Modules.foregroundExtraction.readyFrame",
"Modules.ballDetection.findContours",
"Modules.ballDetection.regionDetection",
"glob.glob",
"cv2.imshow",
"Modules.foregroundExtraction.natural_sort",
"math.pow",
"cv2.drawContours"... | [((331, 342), 'time.time', 'time.time', ([], {}), '()\n', (340, 342), False, 'import time\n'), ((401, 434), 'glob.glob', 'glob.glob', (["(datasetName + '/*.jpg')"], {}), "(datasetName + '/*.jpg')\n", (410, 434), False, 'import glob\n'), ((572, 583), 'time.time', 'time.time', ([], {}), '()\n', (581, 583), False, 'import... |
# import all the required modules
import threading
from tkinter import *
from tkinter import font
from tkinter import ttk
import base64
import socket
import os
import json
from io import StringIO
import time
TARGET_IP = "127.0.0.1"
TARGET_PORT = 8889
last_msg = ''
last_sender = ''
# GUI class for the chat
class GUI:
... | [
"threading.Thread",
"io.StringIO",
"json.dump",
"json.loads",
"socket.socket",
"base64.b64decode",
"time.sleep",
"tkinter.ttk.Combobox",
"json.dumps",
"base64.b64encode"
] | [((377, 426), 'socket.socket', 'socket.socket', (['socket.AF_INET', 'socket.SOCK_STREAM'], {}), '(socket.AF_INET, socket.SOCK_STREAM)\n', (390, 426), False, 'import socket\n'), ((3584, 3619), 'threading.Thread', 'threading.Thread', ([], {'target': 'self.inbox'}), '(target=self.inbox)\n', (3600, 3619), False, 'import th... |
from leapp.libraries.actor import library
from leapp.models import PartitionEntry, FstabEntry, MountEntry, LsblkEntry, PvsEntry, VgsEntry, \
LvdisplayEntry, SystemdMountEntry
def test_get_partitions_info(monkeypatch):
def is_file_readable_mocked(path):
return False
expected = [
PartitionE... | [
"leapp.models.PvsEntry",
"leapp.models.SystemdMountEntry",
"leapp.models.PartitionEntry",
"leapp.models.LvdisplayEntry",
"leapp.models.VgsEntry",
"leapp.libraries.actor.library._get_pvs_info",
"leapp.models.LsblkEntry",
"leapp.libraries.actor.library._get_lvdisplay_info",
"leapp.libraries.actor.libr... | [((310, 379), 'leapp.models.PartitionEntry', 'PartitionEntry', ([], {'major': '"""252"""', 'minor': '"""0"""', 'blocks': '"""41943040"""', 'name': '"""vda"""'}), "(major='252', minor='0', blocks='41943040', name='vda')\n", (324, 379), False, 'from leapp.models import PartitionEntry, FstabEntry, MountEntry, LsblkEntry, ... |
from __future__ import unicode_literals
from django.contrib import admin
import swapper
from inline_ordering.admin import OrderableStackedInline
from rest_surveys.models import SurveyStep, SurveyQuestion,\
SurveyQuestionResponseOption, SurveyResponseOption
from rest_surveys.utils import admin_edit_link
Survey =... | [
"swapper.load_model",
"rest_surveys.utils.admin_edit_link",
"django.contrib.admin.site.register"
] | [((321, 365), 'swapper.load_model', 'swapper.load_model', (['"""rest_surveys"""', '"""Survey"""'], {}), "('rest_surveys', 'Survey')\n", (339, 365), False, 'import swapper\n'), ((383, 435), 'swapper.load_model', 'swapper.load_model', (['"""rest_surveys"""', '"""SurveyResponse"""'], {}), "('rest_surveys', 'SurveyResponse... |
from falcon import testing
import pytest
from main import application
@pytest.fixture()
def client():
return testing.TestClient(application)
def test_painting_not_found(client):
result = client.simulate_get('/painting/Scream')
assert result.status_code == 404
def test_find_painting_by_name(client):
... | [
"pytest.fixture",
"falcon.testing.TestClient"
] | [((75, 91), 'pytest.fixture', 'pytest.fixture', ([], {}), '()\n', (89, 91), False, 'import pytest\n'), ((117, 148), 'falcon.testing.TestClient', 'testing.TestClient', (['application'], {}), '(application)\n', (135, 148), False, 'from falcon import testing\n')] |
from mushroom_rl.core import Serializable
import torch
import numpy as np
from mushroom_rl.utils.parameters import Parameter
class TestClass(Serializable):
def __init__(self, value):
# Create some different types of variables
self._primitive_variable = value # Primitive python variable
... | [
"torch.nn.Parameter",
"mushroom_rl.utils.parameters.Parameter",
"numpy.zeros",
"numpy.ones",
"numpy.array",
"torch.from_numpy"
] | [((341, 368), 'numpy.array', 'np.array', (['([1, 2, 3] * value)'], {}), '([1, 2, 3] * value)\n', (349, 368), True, 'import numpy as np\n'), ((575, 603), 'torch.from_numpy', 'torch.from_numpy', (['data_array'], {}), '(data_array)\n', (591, 603), False, 'import torch\n'), ((633, 664), 'torch.nn.Parameter', 'torch.nn.Para... |
"""
Faça um programa que tenha uma lista chamada numeros e duas funções chamadas sorteio e somapar
a primeira vai sortear 5 números e colocar eles dentro de uma lista e a segunda vai mostrar a soma entre os valores
pares sorteados pela função anterior
"""
from random import randint
from time import sleep
def sorteio(nu... | [
"random.randint",
"time.sleep"
] | [((405, 419), 'random.randint', 'randint', (['(0)', '(50)'], {}), '(0, 50)\n', (412, 419), False, 'from random import randint\n'), ((482, 493), 'time.sleep', 'sleep', (['(0.35)'], {}), '(0.35)\n', (487, 493), False, 'from time import sleep\n')] |
# Name : Bubble Sort Animation
# Author : <NAME>
# Liscence : MIT Liscence
# Sorting Series Part 2(b)
# Email : <EMAIL>
import turtle
import random
import time
# Inital Screen Setup
screen = turtle.Screen()
# Defining Screen Size
screen.setup(2000,2000)
# Complicated Argument mostly means that the turtle should no... | [
"turtle.up",
"turtle.end_fill",
"turtle.speed",
"turtle.down",
"random.randint",
"turtle.seth",
"turtle.begin_fill",
"turtle.clear",
"time.sleep",
"turtle.Screen",
"turtle.fillcolor",
"turtle.goto",
"turtle.hideturtle",
"turtle.left",
"turtle.fd"
] | [((196, 211), 'turtle.Screen', 'turtle.Screen', ([], {}), '()\n', (209, 211), False, 'import turtle\n'), ((400, 415), 'turtle.speed', 'turtle.speed', (['(0)'], {}), '(0)\n', (412, 415), False, 'import turtle\n'), ((416, 435), 'turtle.hideturtle', 'turtle.hideturtle', ([], {}), '()\n', (433, 435), False, 'import turtle\... |
import re
from html.parser import HTMLParser
from urllib.request import urlopen
from googlesearch import search
import os
import sys
import ssl
ssl._create_default_https_context = ssl._create_unverified_context
# Get path of topic and doc files
basepath = os.path.dirname(os.path.abspath(__file__))
dataset_path = os.p... | [
"os.mkdir",
"os.path.abspath",
"googlesearch.search",
"os.path.exists",
"urllib.request.urlopen",
"os.path.isfile",
"os.path.join",
"re.sub"
] | [((316, 349), 'os.path.join', 'os.path.join', (['basepath', '"""dataset"""'], {}), "(basepath, 'dataset')\n", (328, 349), False, 'import os\n'), ((274, 299), 'os.path.abspath', 'os.path.abspath', (['__file__'], {}), '(__file__)\n', (289, 299), False, 'import os\n'), ((395, 423), 'os.path.exists', 'os.path.exists', (['d... |
import math
import struct
import numbers
try:
from itertools import zip_longest as ziplong
except ImportError:
from itertools import izip_longest as ziplong
from .float_fmt import float_fmt
class Point3D(object):
"""Class to represent a 3D Point."""
def __init__(self, *args):
self._values =... | [
"itertools.izip_longest",
"math.pow",
"struct.pack"
] | [((1557, 1596), 'itertools.izip_longest', 'ziplong', (['self._values', 'p'], {'fillvalue': '(0.0)'}), '(self._values, p, fillvalue=0.0)\n', (1564, 1596), True, 'from itertools import izip_longest as ziplong\n'), ((2772, 2805), 'struct.pack', 'struct.pack', (['"""<3f"""', '*self._values'], {}), "('<3f', *self._values)\n... |
from __future__ import division, print_function
from unittest import TestCase
import numpy as np
from scipy.signal import fftconvolve
import pyroomacoustics as pra
'''
We create a signal, a simple filter and compute their convolution.
Then we test STFT block procesing with and without overlap,
and with and without f... | [
"numpy.random.seed",
"pyroomacoustics.realtime.STFT",
"numpy.abs",
"numpy.random.randn",
"numpy.zeros",
"numpy.ones",
"numpy.linalg.norm",
"scipy.signal.fftconvolve",
"pyroomacoustics.hann"
] | [((364, 381), 'numpy.random.seed', 'np.random.seed', (['(0)'], {}), '(0)\n', (378, 381), True, 'import numpy as np\n'), ((474, 493), 'numpy.ones', 'np.ones', (['(h_len, D)'], {}), '((h_len, D))\n', (481, 493), True, 'import numpy as np\n'), ((499, 524), 'numpy.linalg.norm', 'np.linalg.norm', (['h'], {'axis': '(0)'}), '... |
#!/usr/bin/env python
###
# KINOVA (R) KORTEX (TM)
#
# Copyright (c) 2019 Kinova inc. All rights reserved.
#
# This software may be modified and distributed
# under the terms of the BSD 3-Clause license.
#
# Refer to the LICENSE file for details.
#
###
import sys
import rospy
import threading
from kortex_driver.srv im... | [
"rospy.logerr",
"rospy.Subscriber",
"rospy.delete_param",
"rospy.set_param",
"rospy.ServiceProxy",
"rospy.sleep",
"rospy.loginfo",
"rospy.get_param",
"threading.Event",
"rospy.init_node",
"rospy.wait_for_service"
] | [((4366, 4383), 'rospy.sleep', 'rospy.sleep', (['(0.25)'], {}), '(0.25)\n', (4377, 4383), False, 'import rospy\n'), ((5336, 5391), 'rospy.loginfo', 'rospy.loginfo', (['"""Activating the action notifications..."""'], {}), "('Activating the action notifications...')\n", (5349, 5391), False, 'import rospy\n'), ((5774, 588... |
import graphene
from tracker.api.types import RoleDuplicationChecksType
class RoleDuplicationCheckQuery(graphene.ObjectType):
duplication_check = graphene.Field(
RoleDuplicationChecksType,
description='Check if user already takes part in given project',
required=True
)
def resolv... | [
"graphene.Field"
] | [((153, 279), 'graphene.Field', 'graphene.Field', (['RoleDuplicationChecksType'], {'description': '"""Check if user already takes part in given project"""', 'required': '(True)'}), "(RoleDuplicationChecksType, description=\n 'Check if user already takes part in given project', required=True)\n", (167, 279), False, '... |
# AUTOGENERATED! DO NOT EDIT! File to edit: 05_database.ipynb (unless otherwise specified).
__all__ = ['create_db', 'mapper_registry', 'Base', 'database_path', 'engine', 'Session']
# Cell
from sqlalchemy.orm import registry
from sqlalchemy import create_engine
from sqlalchemy.orm import sessionmaker
from pathlib imp... | [
"sqlalchemy.create_engine",
"sqlalchemy.orm.registry",
"sqlalchemy.orm.sessionmaker",
"pathlib.Path"
] | [((356, 366), 'sqlalchemy.orm.registry', 'registry', ([], {}), '()\n', (364, 366), False, 'from sqlalchemy.orm import registry\n'), ((423, 443), 'pathlib.Path', 'Path', (['"""./data/db.db"""'], {}), "('./data/db.db')\n", (427, 443), False, 'from pathlib import Path\n'), ((454, 530), 'sqlalchemy.create_engine', 'create_... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Copyright (c) 2016 by <NAME>
# Licensed under MIT (https://github.com/mservillat/uws-server/blob/master/LICENSE)
"""
WSGI script for UWS server
"""
import os
import sys
curdir = os.path.dirname(__file__)
sys.path.append(curdir)
# Change working directory so relative pa... | [
"sys.path.append",
"os.path.dirname",
"os.chdir"
] | [((228, 253), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (243, 253), False, 'import os\n'), ((254, 277), 'sys.path.append', 'sys.path.append', (['curdir'], {}), '(curdir)\n', (269, 277), False, 'import sys\n'), ((357, 373), 'os.chdir', 'os.chdir', (['curdir'], {}), '(curdir)\n', (365, 373... |
# coding: utf-8
import io
import re
from sqlalchemy import create_engine, text, MetaData
import alembic
from alembic.compat import configparser
from alembic import util
from alembic.compat import string_types, text_type
from alembic.migration import MigrationContext
from alembic.environment import EnvironmentContext
... | [
"sqlalchemy.MetaData",
"io.BytesIO",
"alembic.operations.Operations",
"io.StringIO",
"alembic.compat.configparser.ConfigParser",
"sqlalchemy.text",
"sqlalchemy.create_engine",
"re.sub"
] | [((556, 583), 'alembic.compat.configparser.ConfigParser', 'configparser.ConfigParser', ([], {}), '()\n', (581, 583), False, 'from alembic.compat import configparser\n'), ((1857, 1919), 'sqlalchemy.create_engine', 'create_engine', (['"""postgresql://"""'], {'strategy': '"""mock"""', 'executor': 'dump'}), "('postgresql:/... |
import sys
from matplotlib import path
import numpy as np
#=======================================================================================================
class RTStructFile:
def __init__(self,RTS):
self.Status = True
self.DCM = RTS
self.ROINameList = list()
self.ROIIDList = list()
for ROI i... | [
"matplotlib.path.Path",
"numpy.min",
"numpy.max",
"numpy.rint"
] | [((3162, 3181), 'numpy.min', 'np.min', (['self.i_list'], {}), '(self.i_list)\n', (3168, 3181), True, 'import numpy as np\n'), ((3191, 3210), 'numpy.min', 'np.min', (['self.j_list'], {}), '(self.j_list)\n', (3197, 3210), True, 'import numpy as np\n'), ((3220, 3239), 'numpy.min', 'np.min', (['self.k_list'], {}), '(self.k... |
from logger import Logger
import logging
import sys
logging.basicConfig(level=logging.INFO)
if __name__ == '__main__':
if len(sys.argv) != 2:
logging.error('Usage: python3 main.py clan_id')
sys.exit(1)
# Insert your key in the next line
key = '<YOUR TOKEN>'
clan_tag = sys.argv[1]
... | [
"sys.exit",
"logging.error",
"logger.Logger",
"logging.basicConfig"
] | [((53, 92), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (72, 92), False, 'import logging\n'), ((330, 351), 'logger.Logger', 'Logger', (['key', 'clan_tag'], {}), '(key, clan_tag)\n', (336, 351), False, 'from logger import Logger\n'), ((156, 203), 'logging.erro... |
import pytest
from hypothesis import given, settings
from hypothesis import strategies as st
from ipyannotations.controls.dropdownbutton import DropdownButton
@settings(deadline=None)
@given(options=st.lists(st.text(), unique=True))
def test_that_options_are_set(options):
widget = DropdownButton(options)
as... | [
"pytest.raises",
"hypothesis.settings",
"hypothesis.strategies.text",
"ipyannotations.controls.dropdownbutton.DropdownButton"
] | [((163, 186), 'hypothesis.settings', 'settings', ([], {'deadline': 'None'}), '(deadline=None)\n', (171, 186), False, 'from hypothesis import given, settings\n'), ((290, 313), 'ipyannotations.controls.dropdownbutton.DropdownButton', 'DropdownButton', (['options'], {}), '(options)\n', (304, 313), False, 'from ipyannotati... |
# Programmeer Project
#
# <NAME>
# 10563865
#
# data_miner.py converts csv data to json
import json, csv
from countrycodes import *
data_array = {}
linegraph = {}
with open('GHG_Emission.csv', 'rb') as input:
workbook_GHG = csv.reader(input, delimiter=',')
for row in workbook_GHG:
# data array for l... | [
"json.dump",
"csv.reader"
] | [((231, 263), 'csv.reader', 'csv.reader', (['input'], {'delimiter': '""","""'}), "(input, delimiter=',')\n", (241, 263), False, 'import json, csv\n'), ((2401, 2441), 'json.dump', 'json.dump', (['data_array', 'outfile'], {'indent': '(4)'}), '(data_array, outfile, indent=4)\n', (2410, 2441), False, 'import json, csv\n'),... |
# -*- coding: utf-8 -*-
#!/usr/bin/python
from geopy.geocoders import Nominatim
from mr_logger.logger import Logger
from keyboard import KeyboardBuilder
geolocator = Nominatim()
logger = Logger()
def locate(location):
result = None
try:
result = geolocator.geocode(str(location))
except Exception ... | [
"mr_logger.logger.Logger",
"keyboard.KeyboardBuilder",
"geopy.geocoders.Nominatim"
] | [((167, 178), 'geopy.geocoders.Nominatim', 'Nominatim', ([], {}), '()\n', (176, 178), False, 'from geopy.geocoders import Nominatim\n'), ((188, 196), 'mr_logger.logger.Logger', 'Logger', ([], {}), '()\n', (194, 196), False, 'from mr_logger.logger import Logger\n'), ((1273, 1290), 'keyboard.KeyboardBuilder', 'KeyboardBu... |
import pytest
from pypy.module._hpy_universal import handles
from pypy.module._hpy_universal.handles import HandleManager, HandleReleaseCallback
class FakeSpace(object):
def __init__(self):
self._cache = {}
def fromcache(self, cls):
if cls not in self._cache:
self._cache[cls] = cls... | [
"pypy.module._hpy_universal.handles.using",
"pypy.module._hpy_universal.handles.HandleManager"
] | [((792, 816), 'pypy.module._hpy_universal.handles.HandleManager', 'HandleManager', (['fakespace'], {}), '(fakespace)\n', (805, 816), False, 'from pypy.module._hpy_universal.handles import HandleManager, HandleReleaseCallback\n'), ((917, 941), 'pypy.module._hpy_universal.handles.HandleManager', 'HandleManager', (['fakes... |
from django.db import models
from datetime import date
from django.urls import reverse
class Article(models.Model):
"""Статьи"""
title = models.CharField("Название", max_length=100)
tagline = models.CharField("Слоган", max_length=100, default='')
description = models.TextField("Описание")
poster =... | [
"django.db.models.TextField",
"django.db.models.CharField",
"django.db.models.SlugField",
"django.db.models.BooleanField",
"django.db.models.ImageField",
"django.urls.reverse",
"django.db.models.DateField"
] | [((147, 191), 'django.db.models.CharField', 'models.CharField', (['"""Название"""'], {'max_length': '(100)'}), "('Название', max_length=100)\n", (163, 191), False, 'from django.db import models\n'), ((206, 260), 'django.db.models.CharField', 'models.CharField', (['"""Слоган"""'], {'max_length': '(100)', 'default': '"""... |
"""In this module we define the ApplicationTemplate.
This is an abstract, base class. Use an implementation like MaterialTemplate"""
import pathlib
import panel as pn
import param
from awesome_panel.application.components import (
LoadingPageComponent,
PageComponent,
ProgressSpinnerComponent,
)... | [
"param.depends",
"param.Integer",
"panel.Spacer",
"panel.panel",
"param.Dict",
"param.Action",
"panel.Column",
"panel.pane.HTML",
"awesome_panel.application.components.PageComponent.create",
"awesome_panel.application.services.Services",
"awesome_panel.application.components.ProgressSpinnerCompo... | [((685, 724), 'param.ClassSelector', 'param.ClassSelector', ([], {'class_': 'Application'}), '(class_=Application)\n', (704, 724), False, 'import param\n'), ((746, 786), 'param.ClassSelector', 'param.ClassSelector', ([], {'class_': 'pathlib.Path'}), '(class_=pathlib.Path)\n', (765, 786), False, 'import param\n'), ((803... |
import logging
_loggers = {}
def get_logger(name=None, filename=None):
if name not in _loggers.keys():
logger = logging.getLogger(name)
logger.setLevel(logging.DEBUG)
# create console handler with a higher log level
ch = logging.StreamHandler()
ch.setLevel(logging.DEBUG)... | [
"logging.Formatter",
"logging.StreamHandler",
"logging.FileHandler",
"logging.getLogger"
] | [((129, 152), 'logging.getLogger', 'logging.getLogger', (['name'], {}), '(name)\n', (146, 152), False, 'import logging\n'), ((262, 285), 'logging.StreamHandler', 'logging.StreamHandler', ([], {}), '()\n', (283, 285), False, 'import logging\n'), ((395, 468), 'logging.Formatter', 'logging.Formatter', (['"""%(asctime)s - ... |
# -*- coding: utf-8 -*-
# Generated by Django 1.11.3 on 2017-11-21 07:17
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('learn', '0006_auto_20171121_1501'),
]
operations = [
migratio... | [
"django.db.models.FileField"
] | [((412, 482), 'django.db.models.FileField', 'models.FileField', ([], {'upload_to': '"""D:/system/mysystem/learn/knowledge/file/"""'}), "(upload_to='D:/system/mysystem/learn/knowledge/file/')\n", (428, 482), False, 'from django.db import migrations, models\n')] |
# coding: utf-8
from __future__ import print_function, division, unicode_literals, absolute_import
import os
import abipy.data as abidata
import abipy.abilab as abilab
from abiflows.fireworks.tasks.abinit_tasks import RestartInfo, AbinitRuntimeError, RelaxFWTask
from abiflows.fireworks.utils.task_history import TaskH... | [
"abiflows.fireworks.tasks.abinit_tasks.AbinitRuntimeError",
"os.path.abspath",
"abiflows.fireworks.utils.task_history.TaskHistory",
"abipy.flowtk.events.DilatmxError",
"abiflows.fireworks.tasks.abinit_tasks.RelaxFWTask",
"abipy.data.cif_file",
"abipy.data.pseudos",
"abipy.flowtk.events.DilatmxErrorHan... | [((799, 812), 'abiflows.fireworks.utils.task_history.TaskHistory', 'TaskHistory', ([], {}), '()\n', (810, 812), False, 'from abiflows.fireworks.utils.task_history import TaskHistory, TaskEvent\n'), ((1836, 1849), 'abiflows.fireworks.utils.task_history.TaskHistory', 'TaskHistory', ([], {}), '()\n', (1847, 1849), False, ... |
# -*- coding: utf-8 -*-
# Generated by Django 1.11.20 on 2019-04-03 19:54
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('cmsplugin_cascade', '0022_auto_20181202_1055'),
]
operations = [
migration... | [
"django.db.models.BooleanField"
] | [((416, 577), 'django.db.models.BooleanField', 'models.BooleanField', ([], {'default': '(False)', 'help_text': '"""Use this font as default, unless an icon font is set for the current page."""', 'verbose_name': '"""Default Font"""'}), "(default=False, help_text=\n 'Use this font as default, unless an icon font is se... |
import os
from phising.blob_storage_operations.blob_operations import Blob_Operation
from utils.logger import App_Logger
from utils.read_params import read_params
class Azure_Container:
def __init__(self):
self.config = read_params()
self.connection_string = os.environ["AZURE_CONN_STR"]
... | [
"utils.logger.App_Logger",
"utils.read_params.read_params",
"phising.blob_storage_operations.blob_operations.Blob_Operation"
] | [((234, 247), 'utils.read_params.read_params', 'read_params', ([], {}), '()\n', (245, 247), False, 'from utils.read_params import read_params\n'), ((399, 415), 'phising.blob_storage_operations.blob_operations.Blob_Operation', 'Blob_Operation', ([], {}), '()\n', (413, 415), False, 'from phising.blob_storage_operations.b... |
import wave
import pylab as pl
import numpy as np
import speech_features_kit.Volume.Volume as vp
# ============ test the algorithm =============
# read wave file and get parameters.
fw = wave.open('../data/english.wav','rb')
params = fw.getparams()
print(params)
nchannels, sampwidth, framerate, nframes = params[:4]
st... | [
"wave.open",
"speech_features_kit.Volume.Volume.calVolumeDB",
"pylab.show",
"pylab.ylabel",
"speech_features_kit.Volume.Volume.calVolume",
"pylab.plot",
"pylab.subplot",
"numpy.arange",
"pylab.xlabel",
"numpy.fromstring"
] | [((188, 226), 'wave.open', 'wave.open', (['"""../data/english.wav"""', '"""rb"""'], {}), "('../data/english.wav', 'rb')\n", (197, 226), False, 'import wave\n'), ((362, 400), 'numpy.fromstring', 'np.fromstring', (['strData'], {'dtype': 'np.int16'}), '(strData, dtype=np.int16)\n', (375, 400), True, 'import numpy as np\n'... |
# -*- Mode: Python -*-
import socket
import threading
import logging
import sys
W = sys.stderr.write
from cys2n import PROTOCOL, s2n_socket, Config, Error as S2N_Error
# XXX EC not available in s2n yet?
key = b"""-----<KEY>
"""
crt = b"""-----BEGIN CER<KEY>
-----END CERTIFICATE-----
"""
cfg = Config()
cfg.add_ce... | [
"threading.Thread",
"logging.error",
"logging.basicConfig",
"socket.socket",
"cys2n.s2n_socket",
"cys2n.Config",
"logging.info",
"cys2n.PROTOCOL.reverse_map.get"
] | [((301, 309), 'cys2n.Config', 'Config', ([], {}), '()\n', (307, 309), False, 'from cys2n import PROTOCOL, s2n_socket, Config, Error as S2N_Error\n'), ((377, 415), 'cys2n.PROTOCOL.reverse_map.get', 'PROTOCOL.reverse_map.get', (['n', '"""unknown"""'], {}), "(n, 'unknown')\n", (401, 415), False, 'from cys2n import PROTOCO... |
import unittest
from corpus2graph import FileParser, WordPreprocessor, Tokenizer, WordProcessing, \
SentenceProcessing, WordPairsProcessing, util
import configparser
config = configparser.ConfigParser()
config.read('config.ini')
class TestProcessings(unittest.TestCase):
""" ATTENTION
Normally, data_folder... | [
"unittest.main",
"corpus2graph.WordProcessing",
"corpus2graph.SentenceProcessing",
"corpus2graph.WordPairsProcessing",
"corpus2graph.util.read_two_columns_file_to_build_dictionary_type_specified",
"configparser.ConfigParser"
] | [((179, 206), 'configparser.ConfigParser', 'configparser.ConfigParser', ([], {}), '()\n', (204, 206), False, 'import configparser\n'), ((9961, 9976), 'unittest.main', 'unittest.main', ([], {}), '()\n', (9974, 9976), False, 'import unittest\n'), ((963, 1149), 'corpus2graph.WordProcessing', 'WordProcessing', ([], {'outpu... |
import os
import sys
import pysftp
import datetime
from datetime import date
import time
from time import strftime
from djequis.adp.utilities import fn_write_log, fn_write_error
# python path
# sys.path.append('/usr/lib/python2.7/dist-packages/')
# sys.path.append('/usr/lib/python2.7/')
# sys.path.append... | [
"pysftp.Connection",
"os.environ.setdefault",
"pysftp.CnOpts",
"djequis.adp.utilities.fn_write_error"
] | [((539, 606), 'os.environ.setdefault', 'os.environ.setdefault', (['"""DJANGO_SETTINGS_MODULE"""', '"""djequis.settings"""'], {}), "('DJANGO_SETTINGS_MODULE', 'djequis.settings')\n", (560, 606), False, 'import os\n'), ((888, 903), 'pysftp.CnOpts', 'pysftp.CnOpts', ([], {}), '()\n', (901, 903), False, 'import pysftp\n'),... |
# Generated by Django 3.0.8 on 2020-07-20 15:17
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('PROKART', '0001_initial'),
]
operations = [
migrations.AlterField(
model_name='phones',
name='image',
fi... | [
"django.db.models.FilePathField"
] | [((324, 357), 'django.db.models.FilePathField', 'models.FilePathField', ([], {'path': '"""/img"""'}), "(path='/img')\n", (344, 357), False, 'from django.db import migrations, models\n')] |
from classgenerator.scripts.parser import Parser
def test_make_empty_parser():
p = Parser()
assert p is not None
assert isinstance(p, Parser)
| [
"classgenerator.scripts.parser.Parser"
] | [((89, 97), 'classgenerator.scripts.parser.Parser', 'Parser', ([], {}), '()\n', (95, 97), False, 'from classgenerator.scripts.parser import Parser\n')] |
import io
import os.path
import pickle
from dagster_databricks import DatabricksJobRunner, databricks_step_main
from dagster_pyspark.utils import build_pyspark_zip
from dagster import Bool, Field, StringSource, check, resource, seven
from dagster.core.definitions.step_launcher import StepLauncher
from dagster.core.ev... | [
"pickle.loads",
"dagster.check.bool_param",
"io.BytesIO",
"pickle.dump",
"dagster.check.str_param",
"dagster.core.events.log_step_event",
"dagster.core.execution.plan.external_step.step_context_to_step_run_ref",
"dagster_pyspark.utils.build_pyspark_zip",
"dagster.check.dict_param",
"dagster.seven.... | [((777, 884), 'dagster.Field', 'Field', (['StringSource'], {'is_required': '(True)', 'description': '"""Databricks host, e.g. uksouth.azuredatabricks.com"""'}), "(StringSource, is_required=True, description=\n 'Databricks host, e.g. uksouth.azuredatabricks.com')\n", (782, 884), False, 'from dagster import Bool, Fiel... |
#!/usr/bin/env python
from setuptools import setup
setup(
name='kitti2bag2',
version='1.0',
description='Convert KITTI dataset to ROS2 bag file the easy way!',
author='<NAME>',
author_email='<EMAIL>',
url='https://github.com/klintan/kitti2bag2/',
download_url='https://github.com/klintan/ki... | [
"setuptools.setup"
] | [((53, 532), 'setuptools.setup', 'setup', ([], {'name': '"""kitti2bag2"""', 'version': '"""1.0"""', 'description': '"""Convert KITTI dataset to ROS2 bag file the easy way!"""', 'author': '"""<NAME>"""', 'author_email': '"""<EMAIL>"""', 'url': '"""https://github.com/klintan/kitti2bag2/"""', 'download_url': '"""https://g... |
"""Command-line interface."""
from typing import Optional
import click
from click.core import Context
from chenv import fs, settings, transform
from chenv.console import as_link, Color, fatal
from chenv.models.output import Output
from . import __version__
settings.mount()
@click.group()
@click.pass_context
@click... | [
"chenv.transform.apply",
"click.version_option",
"chenv.console.as_link",
"click.group",
"chenv.settings.mount",
"click.secho",
"chenv.fs.assign_env"
] | [((260, 276), 'chenv.settings.mount', 'settings.mount', ([], {}), '()\n', (274, 276), False, 'from chenv import fs, settings, transform\n'), ((280, 293), 'click.group', 'click.group', ([], {}), '()\n', (291, 293), False, 'import click\n'), ((315, 356), 'click.version_option', 'click.version_option', ([], {'version': '_... |
import numpy as np
import datetime as dt
import struct
from dateutil.relativedelta import relativedelta
from netCDF4 import Dataset
from os.path import exists
from scipy.interpolate import griddata
from scipy.interpolate.interpnd import _ndim_coords_from_arrays
from scipy.spatial import cKDTree
class Pathfinder():
... | [
"numpy.maximum",
"numpy.empty",
"numpy.shape",
"scipy.spatial.cKDTree",
"numpy.nanmean",
"netCDF4.Dataset",
"os.path.exists",
"dateutil.relativedelta.relativedelta",
"numpy.genfromtxt",
"datetime.timedelta",
"scipy.interpolate.griddata",
"numpy.asarray",
"numpy.flipud",
"datetime.datetime"... | [((897, 920), 'datetime.datetime', 'dt.datetime', (['(1970)', '(1)', '(1)'], {}), '(1970, 1, 1)\n', (908, 920), True, 'import datetime as dt\n'), ((1649, 1672), 'datetime.datetime', 'dt.datetime', (['(1970)', '(1)', '(1)'], {}), '(1970, 1, 1)\n', (1660, 1672), True, 'import datetime as dt\n'), ((10474, 10502), 'numpy.e... |
import json
from live2p.websockets import Live2pServer
from live2p import Alert
test_params = {
'fr': 6.36,
'p': 1, # deconv 0 is off, 1 is slow, 2 is fast
'nb': 2, # background compenents -> nb: 3 for complex
'decay_time': 1.0, # sensor tau
'gSig': (7, 7), # expected half size of neurons in pi... | [
"json.loads",
"live2p.Alert"
] | [((936, 955), 'json.loads', 'json.loads', (['payload'], {}), '(payload)\n', (946, 955), False, 'import json\n'), ((1063, 1105), 'live2p.Alert', 'Alert', (['"""No event type specified."""', '"""error"""'], {}), "('No event type specified.', 'error')\n", (1068, 1105), False, 'from live2p import Alert\n'), ((1558, 1596), ... |
#!/usr/bin/env python3
from __future__ import print_function
from collections import defaultdict
from argparse import ArgumentParser
from typing import Sequence, TextIO
import puz
import sys
import logging
_log = logging.getLogger(__name__)
def main(argl: Sequence[str]=None, stdout: TextIO=sys.stdout):
parser ... | [
"collections.defaultdict",
"puz.read",
"argparse.ArgumentParser",
"logging.getLogger"
] | [((216, 243), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (233, 243), False, 'import logging\n'), ((322, 338), 'argparse.ArgumentParser', 'ArgumentParser', ([], {}), '()\n', (336, 338), False, 'from argparse import ArgumentParser\n'), ((444, 464), 'puz.read', 'puz.read', (['args.input'... |
"""Bash-like interface extensions for xonsh2."""
import shlex
import sys
import re
import builtins
__all__ = ()
@events.on_transform_command
def bash_preproc(cmd, **kw):
bang_previous = {
"!": lambda x: x,
"$": lambda x: shlex.split(x)[-1],
"^": lambda x: shlex.split(x)[0],
"*": ... | [
"re.sub",
"shlex.split"
] | [((1040, 1085), 're.sub', 're.sub', (['"""!([!$^*]|[\\\\w]+)"""', 'replace_bang', 'cmd'], {}), "('!([!$^*]|[\\\\w]+)', replace_bang, cmd)\n", (1046, 1085), False, 'import re\n'), ((245, 259), 'shlex.split', 'shlex.split', (['x'], {}), '(x)\n', (256, 259), False, 'import shlex\n'), ((288, 302), 'shlex.split', 'shlex.spl... |
# Add your Python code here. E.g.
from microbit import *
from time import sleep
dot1 = Image("00000:"
"00000:"
"00000:"
"00000:"
"50000")
dot2 = Image("00000:"
"00000:"
"00000:"
"00000:"
"05000")
dot3... | [
"time.sleep"
] | [((459, 469), 'time.sleep', 'sleep', (['(0.5)'], {}), '(0.5)\n', (464, 469), False, 'from time import sleep\n'), ((489, 499), 'time.sleep', 'sleep', (['(0.5)'], {}), '(0.5)\n', (494, 499), False, 'from time import sleep\n'), ((519, 529), 'time.sleep', 'sleep', (['(0.5)'], {}), '(0.5)\n', (524, 529), False, 'from time i... |
import smbus
from functools import reduce
class I2cController(object):
def __init__(self):
self.bus = smbus.SMBus(1)
self.on_pins = set()
self.off_pins = {0, 1, 2, 3, 4, 5}
self._update()
def on(self, decimal_pin_number):
self.off_pins.remove(decimal_pin_number)
... | [
"smbus.SMBus"
] | [((116, 130), 'smbus.SMBus', 'smbus.SMBus', (['(1)'], {}), '(1)\n', (127, 130), False, 'import smbus\n')] |
# Copyright (c) 2018-2021, Texas Instruments
# All Rights Reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# * Redistributions of source code must retain the above copyright notice, this
# list of condition... | [
"jai_benchmark.pipelines.pipeline_runner.PipelineRunner",
"jai_benchmark.datasets.get_datasets"
] | [((3426, 3468), 'jai_benchmark.pipelines.pipeline_runner.PipelineRunner', 'PipelineRunner', (['settings', 'pipeline_configs'], {}), '(settings, pipeline_configs)\n', (3440, 3468), False, 'from jai_benchmark.pipelines.pipeline_runner import PipelineRunner\n'), ((2059, 2090), 'jai_benchmark.datasets.get_datasets', 'datas... |
#!/usr/bin/env python
# coding: UTF-8
'''
diff_svg module
===============
Print differences between two SVG maps.
Uses the yaml module (``pip install pyyaml``).
The output is a hierarchical dictionary of differences between the two maps. Differences in tags (properties) and children are recorded. Item keys are thei... | [
"xml.etree.cElementTree.parse",
"yaml.dump",
"argparse.ArgumentParser",
"sys.exit"
] | [((2961, 3061), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'prog': '"""diff_svg"""', 'description': '"""Print differences between two SVG maps."""'}), "(prog='diff_svg', description=\n 'Print differences between two SVG maps.')\n", (2984, 3061), False, 'import argparse\n'), ((3878, 3892), 'xml.etree... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
selfsupervised3d.model.frankunet
A Frankenstein's monster version of a U-Net neural network
(typically to support context encoder-style self-supervised
learning methods [1])
References:
[1] D. Pathak et al. "Context encoders: Feature learning by inpainting."
... | [
"functools.partial",
"torch.nn.BatchNorm3d",
"torch.nn.ReLU",
"torch.nn.ModuleList",
"torch.nn.Conv3d",
"torch.nn.functional.dropout3d",
"torch.cat",
"torch.randn",
"torch.nn.functional.interpolate",
"torch.nn.ReplicationPad3d"
] | [((560, 590), 'functools.partial', 'partial', (['nn.ReLU'], {'inplace': '(True)'}), '(nn.ReLU, inplace=True)\n', (567, 590), False, 'from functools import partial\n'), ((2950, 2971), 'torch.nn.ModuleList', 'nn.ModuleList', (['layers'], {}), '(layers)\n', (2963, 2971), False, 'from torch import nn\n'), ((3276, 3297), 't... |
import numpy as np
from anomaly import adm
naive_filter = adm.NaiveFilter()
def _test_fit(filter):
ts = np.random.random(100)
ts_predicted = np.random.random(100)
anomalies = np.random.random(100) > 0.9
anomalies_predicted = anomalies & (np.random.random(100) > 0.9)
filter.fit(ts, ts_predicted, a... | [
"anomaly.adm.NaiveFilter",
"numpy.random.random"
] | [((59, 76), 'anomaly.adm.NaiveFilter', 'adm.NaiveFilter', ([], {}), '()\n', (74, 76), False, 'from anomaly import adm\n'), ((111, 132), 'numpy.random.random', 'np.random.random', (['(100)'], {}), '(100)\n', (127, 132), True, 'import numpy as np\n'), ((152, 173), 'numpy.random.random', 'np.random.random', (['(100)'], {}... |
import torch
from torch import tensor
import numpy as np
from torch.utils.data import TensorDataset, DataLoader, ConcatDataset
import os
def mnist():
path = '/Users/davidipsen/Documents/DTU/3. Semester (MSc)/MLOps/dtu_mlops/data/corruptmnist/'
# exchange with the corrupted mnist dataset
#train = torch.rand... | [
"torch.utils.data.DataLoader",
"numpy.load",
"numpy.concatenate",
"torch.tensor"
] | [((2006, 2051), 'numpy.load', 'np.load', (['f"""{path}test.npz"""'], {'allow_pickle': '(True)'}), "(f'{path}test.npz', allow_pickle=True)\n", (2013, 2051), True, 'import numpy as np\n'), ((2144, 2179), 'torch.tensor', 'torch.tensor', (["testcontent['labels']"], {}), "(testcontent['labels'])\n", (2156, 2179), False, 'im... |
#!/usr/bin/env python3
import sys, time, struct
import socket as s
def print_tcp_info(sock):
tcp_info = struct.unpack("B"*8+"I"*24, sock.getsockopt(s.SOL_TCP, s.TCP_INFO, 32))
info_str = f'cwin: {tcp_info[26]}'
# ... see /usr/include/linux/tcp.h
print(info_str)
sock = s.socket(s.AF_INET, s.SOCK_STRE... | [
"time.time",
"socket.socket",
"socket.gethostbyname"
] | [((289, 323), 'socket.socket', 's.socket', (['s.AF_INET', 's.SOCK_STREAM'], {}), '(s.AF_INET, s.SOCK_STREAM)\n', (297, 323), True, 'import socket as s\n'), ((333, 361), 'socket.gethostbyname', 's.gethostbyname', (['sys.argv[1]'], {}), '(sys.argv[1])\n', (348, 361), True, 'import socket as s\n'), ((370, 381), 'time.time... |
__author__ = '<NAME>'
from django.core.management.base import BaseCommand
from taskengine.taskdef import TaskDefinition
from deftcore.log import Logger
logger = Logger.get()
class Command(BaseCommand):
def add_arguments(self, parser):
parser.add_argument(
'-t',
'--types',
... | [
"taskengine.taskdef.TaskDefinition",
"deftcore.log.Logger.get"
] | [((163, 175), 'deftcore.log.Logger.get', 'Logger.get', ([], {}), '()\n', (173, 175), False, 'from deftcore.log import Logger\n'), ((647, 663), 'taskengine.taskdef.TaskDefinition', 'TaskDefinition', ([], {}), '()\n', (661, 663), False, 'from taskengine.taskdef import TaskDefinition\n')] |
from flask_restful import Resource, reqparse
from models.produto_pedido_model import ProdutoPedidoModel
from models.pedido_model import PedidoModel
from models.produto_model import ProdutoModel
from resources.mensagem import produtoNaoEncontrado, pedidoNaoEncontrado
from resources.mensagem import pPNaoEncontrado, erroS... | [
"models.produto_model.ProdutoModel.find_produto",
"models.produto_pedido_model.ProdutoPedidoModel.find_produtoPedido",
"models.pedido_model.PedidoModel.find_pedido",
"flask_restful.reqparse.RequestParser",
"models.produto_pedido_model.ProdutoPedidoModel"
] | [((445, 469), 'flask_restful.reqparse.RequestParser', 'reqparse.RequestParser', ([], {}), '()\n', (467, 469), False, 'from flask_restful import Resource, reqparse\n'), ((1011, 1058), 'models.produto_pedido_model.ProdutoPedidoModel.find_produtoPedido', 'ProdutoPedidoModel.find_produtoPedido', (['cod_nota'], {}), '(cod_n... |
from bs4 import BeautifulSoup
import requests
import re
import sys
import os
inputs ={}
outputs = {}
ios = {}
docs = {}
def get():
if os.path.isfile("cache/docs.html"):
with open("cache/docs.html", 'r') as f:
print("Using cache", file=sys.stderr)
return f.read()
r = requests.get("https://docs.nvidia.com/dee... | [
"os.path.isfile",
"requests.get",
"re.search",
"bs4.BeautifulSoup",
"re.sub",
"re.compile"
] | [((137, 170), 'os.path.isfile', 'os.path.isfile', (['"""cache/docs.html"""'], {}), "('cache/docs.html')\n", (151, 170), False, 'import os\n'), ((279, 352), 'requests.get', 'requests.get', (['"""https://docs.nvidia.com/deeplearning/cudnn/api/index.html"""'], {}), "('https://docs.nvidia.com/deeplearning/cudnn/api/index.h... |
import tree
from asm.Asm import *
from asm.Registers import Registers
from tree.nodes.AssignmentType import AssignmentType
from tree.nodes.Node import Node
from tree.nodes.operations.OperationType import OperationType
class Assignment(Node):
def __init__(self, operation, parent=None):
self.operation = ope... | [
"tree.nodes.operations.BinaryOperation.BinaryOperation",
"asm.Registers.Registers.RAX.dereference"
] | [((810, 885), 'tree.nodes.operations.BinaryOperation.BinaryOperation', 'tree.nodes.operations.BinaryOperation.BinaryOperation', (['arithmetic_operation'], {}), '(arithmetic_operation)\n', (863, 885), False, 'import tree\n'), ((2153, 2180), 'asm.Registers.Registers.RAX.dereference', 'Registers.RAX.dereference', ([], {})... |
from alarms import add_alarm
from drama_scheduler.drama_node_types import DramaNodeType
from event_testing.resolver import SingleSimResolver
from tutorials.tutorial_tip import TutorialMode
from sims4.service_manager import Service
from sims4.tuning.tunable import OptionalTunable, TunableReference, TunableTuple
from sni... | [
"services.client_manager",
"services.get_instance_manager",
"services.game_clock_service",
"services.get_persistence_service",
"services.drama_scheduler_service",
"snippets.TunableAffordanceFilterSnippet",
"services.active_sim_info",
"alarms.add_alarm"
] | [((2381, 2442), 'alarms.add_alarm', 'add_alarm', (['self', 'time_till_satisfy', 'callback'], {'cross_zone': '(True)'}), '(self, time_till_satisfy, callback, cross_zone=True)\n', (2390, 2442), False, 'from alarms import add_alarm\n'), ((6265, 6299), 'services.drama_scheduler_service', 'services.drama_scheduler_service',... |
# Написать программу, которая будет по нажатию на экран рисовать фигуру в месте клика. Фигура - стрелочка.
#
# 1) Сделать слайдер, который будет отвечать за размер фигуры, рядом выводить значение слайдера.
# 2) Сделать слайдер для поворота фигуры, рядом выводить значение слайдера.
# Интерфейс: Справа канвас, слев... | [
"tkinter.ttk.Combobox"
] | [((1141, 1162), 'tkinter.ttk.Combobox', 'Combobox', (['param_frame'], {}), '(param_frame)\n', (1149, 1162), False, 'from tkinter.ttk import Combobox\n')] |
# Copyright 2021 Google LLC. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or a... | [
"inspect.getmodule",
"kfp.components.load_component_from_text",
"inspect.ismethod",
"inspect.signature"
] | [((947, 971), 'inspect.ismethod', 'inspect.ismethod', (['method'], {}), '(method)\n', (963, 971), False, 'import inspect\n'), ((1034, 1077), 'inspect.signature', 'inspect.signature', (['method.__self__.__init__'], {}), '(method.__self__.__init__)\n', (1051, 1077), False, 'import inspect\n'), ((1267, 1298), 'inspect.sig... |
import os
import csv
#grab data file
election_csv = os.path.join("election_data.csv")
#set initial variables to zero sincce we are counting each one
total_votes = 0
khan_votes = 0
correy_votes = 0
li_votes = 0
otooley_votes = 0
#open csv file and read it in
with open(election_csv) as election_data:
#store csv d... | [
"csv.reader",
"os.path.join"
] | [((53, 86), 'os.path.join', 'os.path.join', (['"""election_data.csv"""'], {}), "('election_data.csv')\n", (65, 86), False, 'import os\n'), ((1993, 2029), 'os.path.join', 'os.path.join', (['"""Election_Results.txt"""'], {}), "('Election_Results.txt')\n", (2005, 2029), False, 'import os\n'), ((378, 418), 'csv.reader', 'c... |
from testconfig import config
from tests.integration.core.chroma_integration_testcase import ChromaIntegrationTestCase
from tests.integration.core.remote_operations import SimulatorRemoteOperations, RealRemoteOperations
class TestInstallationAndUpgrade(ChromaIntegrationTestCase):
def setUp(self):
# Crea... | [
"tests.integration.core.remote_operations.SimulatorRemoteOperations",
"testconfig.config.get",
"tests.integration.core.remote_operations.RealRemoteOperations"
] | [((468, 498), 'testconfig.config.get', 'config.get', (['"""simulator"""', '(False)'], {}), "('simulator', False)\n", (478, 498), False, 'from testconfig import config\n'), ((537, 584), 'tests.integration.core.remote_operations.SimulatorRemoteOperations', 'SimulatorRemoteOperations', (['self', 'self.simulator'], {}), '(... |
from bayetorch.layers.base import BayesianModule
from bayetorch.layers.base import EPSILON
from torch import Tensor
import numpy as np
import torch
import torch.nn as nn
import torch.nn.functional as F
class BayesianLinear(BayesianModule):
def __init__(
self,
in_features: int,
out_feat... | [
"torch.log1p",
"torch.exp",
"torch.Tensor",
"torch.nn.functional.linear"
] | [((1416, 1442), 'torch.exp', 'torch.exp', (['(-self.log_alpha)'], {}), '(-self.log_alpha)\n', (1425, 1442), False, 'import torch\n'), ((610, 625), 'torch.Tensor', 'Tensor', (['*W_size'], {}), '(*W_size)\n', (616, 625), False, 'from torch import Tensor\n'), ((665, 680), 'torch.Tensor', 'Tensor', (['*W_size'], {}), '(*W_... |
# -*- coding: utf-8 -*-
# @Time : 2020/12/4 下午4:34
# @Author : 司云中
# @File : hasher.py
# @Software: Pycharm
import functools
from werkzeug.utils import import_string
from extensions.extensions import encryption
from application.utils.exception import ImproperlyConfigured
from flask import current_app
def get_salt(sa... | [
"extensions.extensions.encryption.encode",
"flask.current_app.config.get",
"werkzeug.utils.import_string",
"application.utils.exception.ImproperlyConfigured",
"functools.lru_cache"
] | [((946, 967), 'functools.lru_cache', 'functools.lru_cache', ([], {}), '()\n', (965, 967), False, 'import functools\n'), ((1529, 1550), 'functools.lru_cache', 'functools.lru_cache', ([], {}), '()\n', (1548, 1550), False, 'import functools\n'), ((908, 941), 'extensions.extensions.encryption.encode', 'encryption.encode', ... |
import sys
from time import sleep
from influxdb import InfluxDBClient
import subprocess
import re
client = InfluxDBClient(host='localhost', port=8086)
client.switch_database('temp')
regex = re.compile('=([\d\.]*)\'')
def getTemp():
result = subprocess.check_output(['vcgencmd','measure_temp']).decode('utf-8')
... | [
"subprocess.check_output",
"influxdb.InfluxDBClient",
"time.sleep",
"sys.stderr.write",
"sys.exit",
"re.compile"
] | [((108, 151), 'influxdb.InfluxDBClient', 'InfluxDBClient', ([], {'host': '"""localhost"""', 'port': '(8086)'}), "(host='localhost', port=8086)\n", (122, 151), False, 'from influxdb import InfluxDBClient\n'), ((191, 218), 're.compile', 're.compile', (['"""=([\\\\d\\\\.]*)\'"""'], {}), '("=([\\\\d\\\\.]*)\'")\n', (201, 2... |
from unittest import TestCase
from dataclass_bakery.generators import defaults
from dataclass_bakery.generators.random_complex_generator import RandomComplexGenerator
class TestRandomComplexGenerator(TestCase):
def setUp(self):
self.random_complex_generator = RandomComplexGenerator()
def test_genera... | [
"dataclass_bakery.generators.random_complex_generator.RandomComplexGenerator"
] | [((275, 299), 'dataclass_bakery.generators.random_complex_generator.RandomComplexGenerator', 'RandomComplexGenerator', ([], {}), '()\n', (297, 299), False, 'from dataclass_bakery.generators.random_complex_generator import RandomComplexGenerator\n')] |
import asyncio
import json
from .. import BOT_TOKEN, OWNER
from .. import mode
if mode=="DUAL":
from .. import bot, user
elif mode=="BOT":
from .. import bot
else:
from .. import user
from .._helper import log
from traceback import format_exc as ec
from pyrogram import Client
from pyrogram.types import Mes... | [
"traceback.format_exc",
"asyncio.sleep"
] | [((2836, 2840), 'traceback.format_exc', 'ec', ([], {}), '()\n', (2838, 2840), True, 'from traceback import format_exc as ec\n'), ((2636, 2658), 'asyncio.sleep', 'asyncio.sleep', (['(e.x + 5)'], {}), '(e.x + 5)\n', (2649, 2658), False, 'import asyncio\n')] |
# -*- coding: utf-8 -*-
import pytest
@pytest.mark.unit
@pytest.mark.parametrize("width, height", [
(640, 480),
])
def test_create_window(width, height):
from lose.utils import create_windows
windows = create_windows(width, height)
for name, window in windows.items():
assert name is not None
... | [
"pytest.mark.parametrize",
"lose.utils.create_windows"
] | [((59, 113), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""width, height"""', '[(640, 480)]'], {}), "('width, height', [(640, 480)])\n", (82, 113), False, 'import pytest\n'), ((217, 246), 'lose.utils.create_windows', 'create_windows', (['width', 'height'], {}), '(width, height)\n', (231, 246), False, 'fro... |
import FWCore.ParameterSet.Config as cms
process = cms.Process("QcdPhotonsDQM")
process.load("DQM.Physics.qcdPhotonsDQM_cfi")
process.load("DQMServices.Core.DQM_cfg")
process.load("DQMServices.Components.DQMEnvironment_cfi")
process.DQM.collectorHost = ''
process.dqmSaver.workflow = cms.untracked.string('/My/Test/Da... | [
"FWCore.ParameterSet.Config.string",
"FWCore.ParameterSet.Config.untracked.int32",
"FWCore.ParameterSet.Config.untracked.vstring",
"FWCore.ParameterSet.Config.untracked.string",
"FWCore.ParameterSet.Config.Process",
"FWCore.ParameterSet.Config.Path"
] | [((52, 80), 'FWCore.ParameterSet.Config.Process', 'cms.Process', (['"""QcdPhotonsDQM"""'], {}), "('QcdPhotonsDQM')\n", (63, 80), True, 'import FWCore.ParameterSet.Config as cms\n'), ((287, 327), 'FWCore.ParameterSet.Config.untracked.string', 'cms.untracked.string', (['"""/My/Test/DataSet"""'], {}), "('/My/Test/DataSet'... |
from .utils import generic_search
from blog.models import Post, Category, Tag
from django.shortcuts import render, redirect
from django.core.urlresolvers import reverse
def search(request):
if request.method == 'POST':
slug = request.POST.get('search_term', None)
if slug is not None:
... | [
"django.shortcuts.redirect",
"django.core.urlresolvers.reverse"
] | [((375, 393), 'django.shortcuts.redirect', 'redirect', (['"""/blog/"""'], {}), "('/blog/')\n", (383, 393), False, 'from django.shortcuts import render, redirect\n'), ((327, 360), 'django.core.urlresolvers.reverse', 'reverse', (['"""search_blog"""'], {'args': 'slug'}), "('search_blog', args=slug)\n", (334, 360), False, ... |
import icebox
vm = icebox.attach("win10")
# list current processes
for proc in vm.processes():
print("%d: %s" % (proc.pid(), proc.name()))
proc = vm.processes.current() # get current process
proc = vm.processes.find_name("explorer.exe") # get explorer.exe
proc = vm.processes.find_name("Taskmgr.exe", icebox.fla... | [
"icebox.attach",
"icebox.counter"
] | [((20, 42), 'icebox.attach', 'icebox.attach', (['"""win10"""'], {}), "('win10')\n", (33, 42), False, 'import icebox\n'), ((713, 729), 'icebox.counter', 'icebox.counter', ([], {}), '()\n', (727, 729), False, 'import icebox\n')] |
import logging
import signal
import sys
import time
import traceback
from datetime import datetime, timezone
from pymongo import MongoClient
from pymongo.collection import Collection
from pymongo.database import Database
class Record:
def __init__(self, mongodb_uri: str):
self.stop_flag = False
s... | [
"pymongo.MongoClient",
"logging.debug",
"time.sleep",
"signal.signal",
"datetime.datetime.now",
"sys.exit"
] | [((480, 520), 'logging.debug', 'logging.debug', (['"""Stopping record process"""'], {}), "('Stopping record process')\n", (493, 520), False, 'import logging\n'), ((557, 568), 'sys.exit', 'sys.exit', (['(0)'], {}), '(0)\n', (565, 568), False, 'import sys\n'), ((632, 658), 'datetime.datetime.now', 'datetime.now', (['time... |
"""Metadata Manager Application."""
import asyncio
import logging
from typing import Optional
import click
from .metadata_manager import MetadataManager
LOGGER = logging.getLogger(__name__)
loop = asyncio.get_event_loop()
@click.command("astmetad")
@click.option("-v", "--verbose", is_flag=True)
@click.option("-c... | [
"asyncio.get_event_loop",
"click.option",
"click.command",
"click.Path",
"logging.getLogger"
] | [((166, 193), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (183, 193), False, 'import logging\n'), ((202, 226), 'asyncio.get_event_loop', 'asyncio.get_event_loop', ([], {}), '()\n', (224, 226), False, 'import asyncio\n'), ((230, 255), 'click.command', 'click.command', (['"""astmetad"""'... |
import simuvex
from simuvex.s_type import SimTypeInt
import logging
l = logging.getLogger("simuvex.procedures.libc.sleep")
class sleep(simuvex.SimProcedure):
#pylint:disable=arguments-differ
def run(self, seconds):
#pylint:disable=attribute-defined-outside-init
self.argument_types = {0: SimT... | [
"simuvex.s_type.SimTypeInt",
"logging.getLogger"
] | [((73, 123), 'logging.getLogger', 'logging.getLogger', (['"""simuvex.procedures.libc.sleep"""'], {}), "('simuvex.procedures.libc.sleep')\n", (90, 123), False, 'import logging\n'), ((383, 421), 'simuvex.s_type.SimTypeInt', 'SimTypeInt', (['self.state.arch.bits', '(True)'], {}), '(self.state.arch.bits, True)\n', (393, 42... |
from Ex01 import MDC
def test_ex01():
assert MDC(10, 15) == 5
assert MDC(20, 30) == 10
assert MDC(45, 450) == 45
assert MDC(12, 18) == 6 | [
"Ex01.MDC"
] | [((53, 64), 'Ex01.MDC', 'MDC', (['(10)', '(15)'], {}), '(10, 15)\n', (56, 64), False, 'from Ex01 import MDC\n'), ((82, 93), 'Ex01.MDC', 'MDC', (['(20)', '(30)'], {}), '(20, 30)\n', (85, 93), False, 'from Ex01 import MDC\n'), ((112, 124), 'Ex01.MDC', 'MDC', (['(45)', '(450)'], {}), '(45, 450)\n', (115, 124), False, 'fro... |
from __future__ import print_function
import remclient
def clean_rem(url):
connection = remclient.Connector(url)
for q in connection.ListObjects('queues'):
print(q)
for p in connection.Queue(q[0]).ListPackets('all'):
p.Stop()
p.Delete()
connection.Queue(q[0]).De... | [
"remclient.Connector"
] | [((94, 118), 'remclient.Connector', 'remclient.Connector', (['url'], {}), '(url)\n', (113, 118), False, 'import remclient\n')] |
"""Demonstrate ``g1.http.clients``."""
from startup import startup
from g1.apps import asyncs
from g1.apps import utils
from g1.asyncs import kernels
from g1.http import clients
import g1.http.clients.parts
import g1.threads.parts
LABELS = g1.http.clients.parts.define_session()
utils.bind_label(
g1.threads.par... | [
"g1.http.clients.Request",
"g1.apps.asyncs.run"
] | [((583, 615), 'g1.http.clients.Request', 'clients.Request', (['"""GET"""', 'args.url'], {}), "('GET', args.url)\n", (598, 615), False, 'from g1.http import clients\n'), ((790, 806), 'g1.apps.asyncs.run', 'asyncs.run', (['main'], {}), '(main)\n', (800, 806), False, 'from g1.apps import asyncs\n')] |
# Copyright 2020 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, ... | [
"shared.train.train",
"waterbirds.data_builder.build_input_fns",
"absl.flags.DEFINE_string",
"absl.app.run",
"absl.flags.DEFINE_integer",
"absl.flags.DEFINE_float",
"absl.flags.DEFINE_list"
] | [((759, 831), 'absl.flags.DEFINE_float', 'flags.DEFINE_float', (['"""p_tr"""', '(0.8)', '"""proportion of data used for training."""'], {}), "('p_tr', 0.8, 'proportion of data used for training.')\n", (777, 831), False, 'from absl import flags\n'), ((831, 924), 'absl.flags.DEFINE_float', 'flags.DEFINE_float', (['"""p_v... |
import argparse
import logging
import multiprocessing
import os
import platform
import sys
from contextlib import suppress
from functools import partial
from qtpy.QtCore import Qt
from qtpy.QtGui import QIcon
from qtpy.QtWidgets import QApplication
from PartSeg import ANALYSIS_NAME, APP_NAME, MASK_NAME
from PartSeg._... | [
"multiprocessing.set_start_method",
"qtpy.QtWidgets.QApplication.setAttribute",
"napari.Viewer",
"os.path.join",
"PartSeg._launcher.check_version.CheckVersionThread",
"os.path.dirname",
"napari.qt.get_app",
"contextlib.suppress",
"PartSeg.common_backend.base_argparser.CustomParser",
"functools.par... | [((599, 631), 'multiprocessing.freeze_support', 'multiprocessing.freeze_support', ([], {}), '()\n', (629, 631), False, 'import multiprocessing\n'), ((749, 765), 'qtpy.QtWidgets.QApplication', 'QApplication', (['[]'], {}), '([])\n', (761, 765), False, 'from qtpy.QtWidgets import QApplication\n'), ((1331, 1346), 'PartSeg... |
import pandas as pd
class Team:
""" A class used to represent an team
Attributes
----------
_name : str
Name of the team
_initRank : int
Ranking of the team.
The initial order is based on alphabetic order.
_point : int
Number of point won by te team
_re... | [
"pandas.DataFrame"
] | [((8571, 8592), 'pandas.DataFrame', 'pd.DataFrame', (['dataset'], {}), '(dataset)\n', (8583, 8592), True, 'import pandas as pd\n'), ((9304, 9325), 'pandas.DataFrame', 'pd.DataFrame', (['dataset'], {}), '(dataset)\n', (9316, 9325), True, 'import pandas as pd\n')] |
import re
import pandas as pd
def correct_gutenberg_meta(input_path: str, output_path: str):
with open(input_path, "r", encoding="utf-8") as file:
content = file.read()
content = re.sub(r'\n\n+', ' ', content)
# content = content.replace('\n\n', '')
# print(content[:1000])
... | [
"pandas.read_csv",
"pandas.isna",
"re.sub"
] | [((899, 916), 'pandas.read_csv', 'pd.read_csv', (['path'], {}), '(path)\n', (910, 916), True, 'import pandas as pd\n'), ((201, 232), 're.sub', 're.sub', (['"""\\\\n\\\\n+"""', '""" """', 'content'], {}), "('\\\\n\\\\n+', ' ', content)\n", (207, 232), False, 'import re\n'), ((1104, 1119), 'pandas.isna', 'pd.isna', (['au... |
from os import path
from unittest import TestCase
from revenue.utils import loader
THIS_DIR = path.dirname(__file__)
SAMPLE_DATA_FILE = path.join(THIS_DIR, "data", "sample_data.csv")
class TestLoader(TestCase):
def test_item_stream(self):
stream = loader.get_csv_stream(SAMPLE_DATA_FILE)
num_lin... | [
"os.path.dirname",
"os.path.join",
"revenue.utils.loader.get_receipt_stream",
"revenue.utils.loader.get_csv_stream"
] | [((97, 119), 'os.path.dirname', 'path.dirname', (['__file__'], {}), '(__file__)\n', (109, 119), False, 'from os import path\n'), ((139, 185), 'os.path.join', 'path.join', (['THIS_DIR', '"""data"""', '"""sample_data.csv"""'], {}), "(THIS_DIR, 'data', 'sample_data.csv')\n", (148, 185), False, 'from os import path\n'), ((... |
#!/usr/bin/env/ python3
# coding=utf-8
#
# Sync Alma - ILLiad Database
# Developer: <NAME>
# Version: 0.9 (05222018)
#
# Description: Downloads email report sent from Alma and extracts the document(.txt report). Then,
# creates a new document with UTF-8 encoding, parses the hard-coded UserValidation lines and
# and the... | [
"sys.stdout.write",
"os.mkdir",
"csv.reader",
"argparse.ArgumentParser",
"email.mime.text.MIMEText",
"os.path.isfile",
"os.path.join",
"codecs.open",
"smtplib.SMTP",
"os.path.exists",
"email.utils.mktime_tz",
"email.mime.multipart.MIMEMultipart",
"configparser.ConfigParser",
"datetime.date... | [((1652, 1678), 'os.path.exists', 'os.path.exists', (['"""/var/run"""'], {}), "('/var/run')\n", (1666, 1678), False, 'import sys, os, codecs, datetime, time, logging, signal\n'), ((1777, 1791), 'configparser.ConfigParser', 'ConfigParser', ([], {}), '()\n', (1789, 1791), False, 'from configparser import ConfigParser\n')... |
import glob
import shutil
import os
import sys
def copy_files_to_one_folder_by_pattern(file_pattern, dst_folder):
# 出力ファイル一覧
file_list = glob.glob(file_pattern)
for file in file_list:
# basename
try:
basename = os.path.basename(file)
except:
print(
... | [
"os.path.basename",
"os.path.splitext",
"sys.exc_info",
"glob.glob",
"os.path.join"
] | [((148, 171), 'glob.glob', 'glob.glob', (['file_pattern'], {}), '(file_pattern)\n', (157, 171), False, 'import glob\n'), ((484, 510), 'os.path.splitext', 'os.path.splitext', (['basename'], {}), '(basename)\n', (500, 510), False, 'import os\n'), ((254, 276), 'os.path.basename', 'os.path.basename', (['file'], {}), '(file... |
import time
import random
import turtle
def snake():
print("****************************************************************************")
print("* *")
print("* CONTROLS OF SNAKE GAME:-- ... | [
"random.randint",
"turtle.Turtle",
"random.choice",
"time.sleep",
"turtle.Screen"
] | [((759, 774), 'turtle.Screen', 'turtle.Screen', ([], {}), '()\n', (772, 774), False, 'import turtle\n'), ((977, 992), 'turtle.Turtle', 'turtle.Turtle', ([], {}), '()\n', (990, 992), False, 'import turtle\n'), ((1150, 1165), 'turtle.Turtle', 'turtle.Turtle', ([], {}), '()\n', (1163, 1165), False, 'import turtle\n'), ((1... |
from setuptools import setup
PACKAGES = [
'vary',
'vary.exceptions',
'vary.flows',
'vary.variational_autoencoder',
'vary.information_bottlekneck'
]
def setup_package():
setup(
name="Vary",
version='0.1.0',
description='Neural Variational Inference A... | [
"setuptools.setup"
] | [((216, 464), 'setuptools.setup', 'setup', ([], {'name': '"""Vary"""', 'version': '"""0.1.0"""', 'description': '"""Neural Variational Inference Algorithms"""', 'author': '"""<NAME>"""', 'url': '"""https://github.com/joshloyal/Vary"""', 'license': '"""MIT"""', 'install_requires': "['numpy', 'scipy', 'tensorflow']", 'pa... |
# -*- coding: utf-8 -*-
"""
Created on Mon Apr 6 16:25:59 2020
@author: <NAME>
"""
import numpy as np
from Algoritmi_Quadratura import CompositeTrapezoid
from Algoritmi_Grafico_Integrali import DrawCompositeTrapezoid
# Funzione test da integrare
def f(x):
y = 5*(x**3) + 6*x - 2
return y
# Primitiva della ... | [
"Algoritmi_Quadratura.CompositeTrapezoid",
"Algoritmi_Grafico_Integrali.DrawCompositeTrapezoid"
] | [((592, 622), 'Algoritmi_Quadratura.CompositeTrapezoid', 'CompositeTrapezoid', (['f', 'a', 'b', 'N'], {}), '(f, a, b, N)\n', (610, 622), False, 'from Algoritmi_Quadratura import CompositeTrapezoid\n'), ((900, 934), 'Algoritmi_Grafico_Integrali.DrawCompositeTrapezoid', 'DrawCompositeTrapezoid', (['f', 'a', 'b', 'N'], {}... |
# Generated by Django 2.0.1 on 2018-01-05 02:01
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('scores', '0007_auto_20180104_1745'),
]
operations = [
migrations.AlterField(
model_name='title',
name='primary_title... | [
"django.db.models.TextField"
] | [((341, 368), 'django.db.models.TextField', 'models.TextField', ([], {'null': '(True)'}), '(null=True)\n', (357, 368), False, 'from django.db import migrations, models\n')] |
#!/usr/bin/env python
from setuptools import setup, find_packages
with open('README.rst') as f:
long_description = f.read()
setup(
name='redisai',
version='1.0.1',
description='RedisAI Python Client',
long_description=long_description,
long_description_content_type='text/x-rst',
url='http... | [
"setuptools.find_packages"
] | [((420, 435), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (433, 435), False, 'from setuptools import setup, find_packages\n')] |