code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
import logging
import math
import time
from typing import Dict, List
from servo import Servo
class ControllerForPCA9685:
def __init__(self, servos: Dict[object, Servo], chs: Dict[object, int],
pwm_freq: float, init_angles: Dict[object, float] = None):
import Adafruit_PCA9685 as PCA9685
... | [
"math.isclose",
"Adafruit_PCA9685.software_reset",
"Adafruit_PCA9685.PCA9685",
"logging.info",
"RPi.GPIO.setmode"
] | [((965, 989), 'Adafruit_PCA9685.software_reset', 'PCA9685.software_reset', ([], {}), '()\n', (987, 989), True, 'import Adafruit_PCA9685 as PCA9685\n'), ((1013, 1030), 'Adafruit_PCA9685.PCA9685', 'PCA9685.PCA9685', ([], {}), '()\n', (1028, 1030), True, 'import Adafruit_PCA9685 as PCA9685\n'), ((2259, 2283), 'RPi.GPIO.se... |
from django.db import models
from django.utils import timezone
from django.contrib.auth.models import User
# Create your models here.
class Neighbor(models.Model) :
n_name = models.CharField(max_length=35)
n_location = models.CharField(max_length=35)
n_image = models.ImageField(upload_to='n_posts/')
n_title... | [
"django.db.models.TextField",
"django.db.models.ForeignKey",
"django.db.models.DateTimeField",
"django.db.models.ImageField",
"django.db.models.CharField"
] | [((180, 211), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(35)'}), '(max_length=35)\n', (196, 211), False, 'from django.db import models\n'), ((227, 258), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(35)'}), '(max_length=35)\n', (243, 258), False, 'from django.db im... |
#!/usr/bin/env python3
"""This python program deploys the files needed by the Hillview service
on the machines specified in the configuration file."""
# pylint: disable=invalid-name
from argparse import ArgumentParser
import tempfile
import os.path
from hillviewCommon import ClusterConfiguration, get_config, get_l... | [
"hillviewCommon.get_logger",
"hillviewCommon.get_config",
"argparse.ArgumentParser",
"tempfile.NamedTemporaryFile"
] | [((336, 356), 'hillviewCommon.get_logger', 'get_logger', (['"""deploy"""'], {}), "('deploy')\n", (346, 356), False, 'from hillviewCommon import ClusterConfiguration, get_config, get_logger\n'), ((2641, 2692), 'tempfile.NamedTemporaryFile', 'tempfile.NamedTemporaryFile', ([], {'mode': '"""w"""', 'delete': '(False)'}), "... |
import urllib3
from beautifulsoup4 import beautifulsoup4 as bs
def get_historical_data(name, number_of_days):
data = []
url = "https://finance.yahoo.com/quote/" + name + "/history/"
rows = bs(urllib3.urlopen(url).read()).findAll('table')[0].tbody.findAll('tr')
for each_row in rows:
divs = each_row.findAll('td')... | [
"urllib3.urlopen"
] | [((196, 216), 'urllib3.urlopen', 'urllib3.urlopen', (['url'], {}), '(url)\n', (211, 216), False, 'import urllib3\n')] |
#!/usr/bin/python
import os, glob, hashlib, pickle, argparse, shutil, ntpath
import os, glob, hashlib, pickle, argparse, shutil, multiprocessing, signal, sys
from multiprocessing import Pool
from functools import partial
######################### Classes ##############################
class AndroidDensity:
def __i... | [
"os.path.exists",
"ntpath.basename",
"pickle.dump",
"hashlib.md5",
"argparse.ArgumentParser",
"os.makedirs",
"os.listdir",
"os.path.splitext",
"pickle.load",
"multiprocessing.cpu_count",
"shutil.rmtree",
"os.rmdir",
"functools.partial",
"multiprocessing.Pool",
"os.path.basename",
"sys.... | [((1696, 1723), 'multiprocessing.cpu_count', 'multiprocessing.cpu_count', ([], {}), '()\n', (1721, 1723), False, 'import os, glob, hashlib, pickle, argparse, shutil, multiprocessing, signal, sys\n'), ((2480, 2552), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Seamless mobile assets man... |
import os
from djangular import utils
from django.test import SimpleTestCase
class SiteAndPathUtilsTest(SimpleTestCase):
site_utils = utils.SiteAndPathUtils()
def test_djangular_root(self):
current_dir = os.path.dirname(os.path.abspath(__file__))
djangular_dir = os.path.dirname(current_dir)... | [
"os.path.abspath",
"os.path.dirname",
"djangular.utils.SiteAndPathUtils"
] | [((142, 166), 'djangular.utils.SiteAndPathUtils', 'utils.SiteAndPathUtils', ([], {}), '()\n', (164, 166), False, 'from djangular import utils\n'), ((292, 320), 'os.path.dirname', 'os.path.dirname', (['current_dir'], {}), '(current_dir)\n', (307, 320), False, 'import os\n'), ((241, 266), 'os.path.abspath', 'os.path.absp... |
from django.conf.urls import patterns, include, url
from django.contrib import admin
from django.conf.urls.static import static
from userModule.views import home
from userModule.views import userSettings
from userModule.views import logout
from groupModule.views import createGroup
from groupModule.views import group
fr... | [
"django.conf.urls.static.static",
"django.conf.urls.include",
"django.contrib.staticfiles.urls.staticfiles_urlpatterns",
"django.conf.urls.url"
] | [((1632, 1657), 'django.contrib.staticfiles.urls.staticfiles_urlpatterns', 'staticfiles_urlpatterns', ([], {}), '()\n', (1655, 1657), False, 'from django.contrib.staticfiles.urls import staticfiles_urlpatterns\n'), ((1673, 1734), 'django.conf.urls.static.static', 'static', (['settings.MEDIA_URL'], {'document_root': 'se... |
# License: Apache 2.0. See LICENSE file in root directory.
# Copyright(c) 2021 Intel Corporation. All Rights Reserved.
# test:device L500*
# test:device D400*
import pyrealsense2 as rs
from rspy.stopwatch import Stopwatch
from rspy import test, log
import time
import platform
# Start depth + color streams and measur... | [
"rspy.test.finish",
"rspy.log.f",
"rspy.stopwatch.Stopwatch",
"rspy.test.check",
"rspy.test.print_results_and_exit",
"time.sleep",
"platform.system",
"rspy.test.find_first_device_or_exit"
] | [((1623, 1636), 'time.sleep', 'time.sleep', (['(3)'], {}), '(3)\n', (1633, 1636), False, 'import time\n'), ((1844, 1855), 'rspy.stopwatch.Stopwatch', 'Stopwatch', ([], {}), '()\n', (1853, 1855), False, 'from rspy.stopwatch import Stopwatch\n'), ((1862, 1894), 'rspy.test.find_first_device_or_exit', 'test.find_first_devi... |
from tensorflow.keras import activations, initializers, regularizers, constraints
from tensorflow.keras import backend as K
from tensorflow.keras.layers import Layer
from spektral.layers import ops
from spektral.utils import localpooling_filter
class GraphConv(Layer):
r"""
A graph convolutional layer (GCN) a... | [
"tensorflow.keras.constraints.get",
"tensorflow.keras.regularizers.serialize",
"tensorflow.keras.activations.get",
"spektral.layers.ops.filter_dot",
"tensorflow.keras.initializers.serialize",
"tensorflow.keras.backend.bias_add",
"spektral.utils.localpooling_filter",
"spektral.layers.ops.dot",
"tenso... | [((2188, 2215), 'tensorflow.keras.activations.get', 'activations.get', (['activation'], {}), '(activation)\n', (2203, 2215), False, 'from tensorflow.keras import activations, initializers, regularizers, constraints\n'), ((2283, 2319), 'tensorflow.keras.initializers.get', 'initializers.get', (['kernel_initializer'], {})... |
from django.contrib import admin
from .models import Device,Metric
class DeviceAdmin(admin.ModelAdmin):
list_display = ["name", "token","user", "created_date"]
search_fields = ["name", "token"]
list_filter = ("user",)
class MetricAdmin(admin.ModelAdmin):
list_display = ["device","temperature", "humid... | [
"django.contrib.admin.site.register"
] | [((404, 444), 'django.contrib.admin.site.register', 'admin.site.register', (['Device', 'DeviceAdmin'], {}), '(Device, DeviceAdmin)\n', (423, 444), False, 'from django.contrib import admin\n'), ((445, 485), 'django.contrib.admin.site.register', 'admin.site.register', (['Metric', 'MetricAdmin'], {}), '(Metric, MetricAdmi... |
from django.urls import reverse
from pytest import mark
from core.models import *
urls = [reverse(name) for name in ["core:index", "core:arts"]]
@mark.parametrize("url", urls)
@mark.django_db
def test_nsfw_filter(url, django_user_model, client):
target = django_user_model.objects.create(username="bob", password... | [
"pytest.mark.parametrize",
"django.urls.reverse"
] | [((150, 179), 'pytest.mark.parametrize', 'mark.parametrize', (['"""url"""', 'urls'], {}), "('url', urls)\n", (166, 179), False, 'from pytest import mark\n'), ((92, 105), 'django.urls.reverse', 'reverse', (['name'], {}), '(name)\n', (99, 105), False, 'from django.urls import reverse\n')] |
"""This script *replaces* the processlog.csh shell script. It has
more sophisticated logic to add the etc test name to the pysynphot
command as another keyword-value pair.
Modified to parse the modified line, then write a dictionary that will
be read by the gencases tool.
"""
import sys,re, pickle
from pysynphot impo... | [
"gencases.line2ktuple",
"pickle.dump",
"re.search"
] | [((1136, 1155), 'pickle.dump', 'pickle.dump', (['d', 'out'], {}), '(d, out)\n', (1147, 1155), False, 'import sys, re, pickle\n'), ((598, 631), 're.search', 're.search', (['"""\'(?P<name>.*)\'"""', 'line'], {}), '("\'(?P<name>.*)\'", line)\n', (607, 631), False, 'import sys, re, pickle\n'), ((915, 940), 'gencases.line2k... |
import teek
def on_click():
print("You clicked me!")
window = teek.Window()
button = teek.Button(window, "Click me", command=on_click)
button.pack()
window.on_delete_window.connect(teek.quit)
teek.run()
| [
"teek.run",
"teek.Window",
"teek.Button"
] | [((70, 83), 'teek.Window', 'teek.Window', ([], {}), '()\n', (81, 83), False, 'import teek\n'), ((93, 142), 'teek.Button', 'teek.Button', (['window', '"""Click me"""'], {'command': 'on_click'}), "(window, 'Click me', command=on_click)\n", (104, 142), False, 'import teek\n'), ((200, 210), 'teek.run', 'teek.run', ([], {})... |
# -*- coding: utf-8 -*-
"""
Created on Wed Dec 4 13:54:27 2019
@author: eric.qian
"""
from collections import Counter
from itertools import combinations
# Numeric hand rankings, higher integer value is stronger hand
HAND_RANKINGS = {0: 'High Card',
1: 'One Pair',
2: 'T... | [
"collections.Counter",
"itertools.combinations"
] | [((2383, 2401), 'collections.Counter', 'Counter', (['card_vals'], {}), '(card_vals)\n', (2390, 2401), False, 'from collections import Counter\n'), ((6462, 6484), 'itertools.combinations', 'combinations', (['cards', 'n'], {}), '(cards, n)\n', (6474, 6484), False, 'from itertools import combinations\n')] |
import sublime
import sublime_plugin
import datetime
import re
from pathlib import Path
import os
import fnmatch
import OrgExtended.orgparse.loader as loader
import OrgExtended.orgparse.node as node
import OrgExtended.orgparse.date as orgdate
from OrgExtended.orgparse.sublimenode import *
import OrgExtended.orgutil.... | [
"logging.getLogger",
"re.compile",
"OrgExtended.orgparse.date.OrgDateFreeFloating.from_str",
"OrgExtended.orgparse.date.OrgDate.format_clock",
"sublime.Region",
"OrgExtended.pymitter.Get",
"OrgExtended.orgproperties.UpdateProperty",
"sublime.active_window",
"OrgExtended.orglinks.CreateLink",
"OrgE... | [((961, 988), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (978, 988), False, 'import logging\n'), ((1694, 1732), 're.compile', 're.compile', (['"""^\\\\s*CLOSED:\\\\s*\\\\[.*\\\\]"""'], {}), "('^\\\\s*CLOSED:\\\\s*\\\\[.*\\\\]')\n", (1704, 1732), False, 'import re\n'), ((4792, 4856), '... |
from nt import DirEntry
import os
import self as self
from keras import Model as KerasModel
class Model(object):
"""
Base class for the different models in this project
"""
_files: dict = {}
""" The files that is used to parse the model """
_raw_content: str = ''
""" The files contents ... | [
"self._parse_directory",
"self._get_assets_full_path",
"self.compile_model",
"self._model.load_weights",
"os.scandir",
"self._raw_content.lower",
"os.path.dirname",
"self._model.summary",
"self._model.compile",
"self._parse_file",
"self._files.items"
] | [((1510, 1543), 'self._model.load_weights', 'self._model.load_weights', (['weights'], {}), '(weights)\n', (1534, 1543), True, 'import self as self\n'), ((1552, 1572), 'self.compile_model', 'self.compile_model', ([], {}), '()\n', (1570, 1572), True, 'import self as self\n'), ((1870, 1940), 'self._model.compile', 'self._... |
# coding=utf-8
import re
import traceback
from pesto_common.config.configer import Configer
from pesto_common.log.logger_factory import LoggerFactory
from pesto_orm.core.base import db_config
from pesto_orm.core.executor import ExecutorFactory
from pesto_orm.core.model import BaseModel
from pesto_orm.core.repository i... | [
"traceback.format_exc",
"pesto_orm.core.executor.ExecutorFactory.get_executor",
"re.match",
"pesto_common.log.logger_factory.LoggerFactory.get_logger",
"pesto_common.config.configer.Configer.get"
] | [((401, 449), 'pesto_common.log.logger_factory.LoggerFactory.get_logger', 'LoggerFactory.get_logger', (['"""dialect.mysql.domain"""'], {}), "('dialect.mysql.domain')\n", (425, 449), False, 'from pesto_common.log.logger_factory import LoggerFactory\n'), ((879, 902), 'pesto_common.config.configer.Configer.get', 'Configer... |
import os
import re
import unittest
import shutil
import subprocess
import logging
import zipfile
from io import BytesIO
from ..experiment.file_storage_driver import FileStorageDriver
from ..experiment.experiment_reader import ExperimentReader
from ..experiment.experiment_writer import ExperimentWriter
class Experim... | [
"os.path.exists",
"os.listdir",
"zipfile.ZipFile",
"subprocess.Popen",
"io.BytesIO",
"os.path.join",
"re.match",
"shutil.rmtree",
"logging.info"
] | [((635, 807), 'subprocess.Popen', 'subprocess.Popen', (["['surround', 'init', '-p', 'test_project', '-d', 'test_description', '-w', 'no'\n ]"], {'cwd': '"""temporary"""', 'stdout': 'subprocess.PIPE', 'stderr': 'subprocess.PIPE'}), "(['surround', 'init', '-p', 'test_project', '-d',\n 'test_description', '-w', 'no'... |
from __future__ import print_function
import os
from argparse import ArgumentParser, Namespace
from zope.interface import implementer
from quickmail.commands import ICommand
from quickmail.utils.misc import quick_mail_dir, heavy_tick, quick_mail_template_dir
@implementer(ICommand)
class ClearCommand:
def add_arg... | [
"os.path.exists",
"zope.interface.implementer",
"os.listdir",
"os.remove"
] | [((263, 284), 'zope.interface.implementer', 'implementer', (['ICommand'], {}), '(ICommand)\n', (274, 284), False, 'from zope.interface import implementer\n'), ((858, 888), 'os.path.exists', 'os.path.exists', (['quick_mail_dir'], {}), '(quick_mail_dir)\n', (872, 888), False, 'import os\n'), ((1567, 1608), 'os.remove', '... |
import os
import pytest
from bank_bot.banking_system import Database
class MockMessage(object):
def __init__(self, from_who, chat_id, message_text):
self.json = {"from": {"id": from_who}, "chat": {"id": chat_id}}
self.text = message_text
@pytest.fixture
def database():
test_file_path = "test_d... | [
"bank_bot.banking_system.Database",
"os.remove"
] | [((347, 371), 'bank_bot.banking_system.Database', 'Database', (['test_file_path'], {}), '(test_file_path)\n', (355, 371), False, 'from bank_bot.banking_system import Database\n'), ((428, 453), 'os.remove', 'os.remove', (['test_file_path'], {}), '(test_file_path)\n', (437, 453), False, 'import os\n')] |
from typing import *
from dataclasses import asdict
from transformers import BertModel
from torch.nn.utils.rnn import pad_sequence
from stud.models.ner_classifier import NERClassifier
from stud.models.polarity_classifier import PolarityClassifier
from stud.constants import LOGGER_TRAIN_LOSS, LOGGER_VALID_LOSS, LOGGER_T... | [
"stud.models.ner_classifier.NERClassifier.load_from_checkpoint",
"stud.utils.aggregate_polarities",
"torch.nn.Dropout",
"stud.utils.merge_layers",
"torch.nn.CrossEntropyLoss",
"dataclasses.asdict",
"stud.utils.vocab_tokens_startswith",
"torch.nn.LSTM",
"stud.torch_utils.batch_scatter_mean",
"stud.... | [((4402, 4417), 'torch.no_grad', 'torch.no_grad', ([], {}), '()\n', (4415, 4417), False, 'import torch\n'), ((8295, 8310), 'torch.no_grad', 'torch.no_grad', ([], {}), '()\n', (8308, 8310), False, 'import torch\n'), ((711, 786), 'stud.models.ner_classifier.NERClassifier.load_from_checkpoint', 'NERClassifier.load_from_ch... |
import argparse
import json
import os.path
import random
import re
import time
import cv2
import numpy as np
import requests
from PIL import Image
from config import config
class GermanLicensePlateImagesGenerator:
def __init__(self, output):
self.output = output
self.COUNTRY_MARKS = np.asarray([... | [
"PIL.Image.fromarray",
"random.choice",
"argparse.ArgumentParser",
"re.compile",
"requests.get",
"random.seed",
"time.sleep",
"cv2.imdecode",
"cv2.cvtColor",
"numpy.fromstring",
"random.randint"
] | [((4263, 4288), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (4286, 4288), False, 'import argparse\n'), ((819, 832), 'random.seed', 'random.seed', ([], {}), '()\n', (830, 832), False, 'import random\n'), ((1470, 1503), 'random.choice', 'random.choice', (['self.COUNTRY_MARKS'], {}), '(self.COU... |
# -*- coding:utf8 -*-
import os
from eth_account import Account
import sha3
import base64
import hashlib
from ecdsa import SigningKey, SECP256k1
DID_TYPE = ["weid"]
def create_privkey():
return os.urandom(32)
def create_ecdsa_privkey():
return SigningKey.generate(curve=SECP256k1)
def create_random_weid():
... | [
"eth_account.Account.create",
"os.urandom",
"base64.b64encode",
"ecdsa.SigningKey.generate",
"base64.b64decode",
"sha3.keccak_256",
"eth_account.Account.privateKeyToAccount",
"ecdsa.SigningKey.from_string"
] | [((199, 213), 'os.urandom', 'os.urandom', (['(32)'], {}), '(32)\n', (209, 213), False, 'import os\n'), ((254, 290), 'ecdsa.SigningKey.generate', 'SigningKey.generate', ([], {'curve': 'SECP256k1'}), '(curve=SECP256k1)\n', (273, 290), False, 'from ecdsa import SigningKey, SECP256k1\n'), ((3070, 3087), 'sha3.keccak_256', ... |
import os
from .abstract_command import AbstractCommand
from ..services.state_utils import StateUtils
from ..services.state import StateHolder
from ..services.command_handler import CommandHandler
from ..services.console_logger import ColorPrint
class Start(AbstractCommand):
command = ["start", "up"]
args = ... | [
"os.getcwd"
] | [((1590, 1601), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (1599, 1601), False, 'import os\n')] |
from netfilterqueue import NetfilterQueue
import socket
from os import system
import scapy.all as scapy
import scapy_http.http
from urllib.parse import urlparse, parse_qs
REQUEST_LOGIN = 0
REQUEST_PROTECT = 1
class NetGuardMITM:
def __init__(self, ip, queue_number=1):
self.ip = ip
self.queue_nu... | [
"urllib.parse.parse_qs",
"os.system",
"urllib.parse.urlparse",
"netfilterqueue.NetfilterQueue"
] | [((2749, 2771), 'urllib.parse.urlparse', 'urlparse', (['request.Path'], {}), '(request.Path)\n', (2757, 2771), False, 'from urllib.parse import urlparse, parse_qs\n'), ((2792, 2809), 'urllib.parse.parse_qs', 'parse_qs', (['o.query'], {}), '(o.query)\n', (2800, 2809), False, 'from urllib.parse import urlparse, parse_qs\... |
"""Config options for WDRAX.
Gets settings from environment variables or .env/settings.ini file.
"""
import pathlib
from decouple import AutoConfig
BASE_DIR = pathlib.Path(__name__).absolute().parent
config = AutoConfig(search_path=str(BASE_DIR)) # pylint: disable=invalid-name
LOG_LEVEL = config('LOG_LEVEL', defa... | [
"pathlib.Path"
] | [((163, 185), 'pathlib.Path', 'pathlib.Path', (['__name__'], {}), '(__name__)\n', (175, 185), False, 'import pathlib\n')] |
# BSD 3-Clause License
#
# Copyright (c) 2019, Elasticsearch BV
# 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, t... | [
"elasticapm.contrib.zerorpc.Middleware",
"os.path.join",
"pytest.mark.skipif",
"pytest.importorskip",
"tempfile.mkdtemp",
"pytest.raises",
"shutil.rmtree"
] | [((1734, 1764), 'pytest.importorskip', 'pytest.importorskip', (['"""zerorpc"""'], {}), "('zerorpc')\n", (1753, 1764), False, 'import pytest\n'), ((1774, 1803), 'pytest.importorskip', 'pytest.importorskip', (['"""gevent"""'], {}), "('gevent')\n", (1793, 1803), False, 'import pytest\n'), ((1901, 1975), 'pytest.mark.skipi... |
from bs4 import BeautifulSoup as Soup
import re
import json
import sys
import shutil
import tempfile
import os
import subprocess
from pathlib import Path
from docassemble.base.util import log, path_and_mimetype, validation_error, DADict, DAList, Individual, value, force_ask, space_to_underscore
__all__ = ['run_automa... | [
"subprocess.check_output",
"tempfile.TemporaryDirectory",
"docassemble.base.util.value",
"docassemble.base.util.validation_error",
"json.dumps",
"os.path.join",
"docassemble.base.util.force_ask",
"docassemble.base.util.path_and_mimetype",
"os.path.isfile",
"docassemble.base.util.space_to_underscor... | [((1530, 1577), 're.search', 're.search', (['"""[^A-Za-z\\\\\' 0-9\\\\_\\\\-\\\\n\\\\r]"""', 'text'], {}), '("[^A-Za-z\\\\\' 0-9\\\\_\\\\-\\\\n\\\\r]", text)\n', (1539, 1577), False, 'import re\n'), ((1781, 1811), 'docassemble.base.util.space_to_underscore', 'space_to_underscore', (['base_name'], {}), '(base_name)\n', ... |
#! /usr/bin/env python3
import sys
import argparse
from graphenetools import gt
def create_parser():
parser = argparse.ArgumentParser(description="Plot graphene lattice and C1/3 phase corresponding to printed command line arguments for uniaxially strained graphene (for use with QMC software located at https://code... | [
"graphenetools.gt.plt.style.context",
"graphenetools.gt.c_one_third_commensurate_command_plot",
"graphenetools.gt.c_one_third_commensurate_command",
"argparse.ArgumentParser"
] | [((115, 404), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Plot graphene lattice and C1/3 phase corresponding to printed command line arguments for uniaxially strained graphene (for use with QMC software located at https://code.delmaestro.org)"""', 'formatter_class': 'argparse.Argument... |
import psycopg2
import re
import json
from MedTAG_sket_dock_App.models import *
import os
import pandas as pd
import numpy
from psycopg2.extensions import register_adapter, AsIs
def addapt_numpy_float64(numpy_float64):
return AsIs(numpy_float64)
def addapt_numpy_int64(numpy_int64):
return AsIs(numpy_int64)
regi... | [
"pandas.read_csv",
"psycopg2.extensions.AsIs",
"django.db.transaction.atomic",
"pandas.notnull",
"psycopg2.extensions.register_adapter"
] | [((316, 369), 'psycopg2.extensions.register_adapter', 'register_adapter', (['numpy.float64', 'addapt_numpy_float64'], {}), '(numpy.float64, addapt_numpy_float64)\n', (332, 369), False, 'from psycopg2.extensions import register_adapter, AsIs\n'), ((370, 419), 'psycopg2.extensions.register_adapter', 'register_adapter', (... |
import sys
sys.path.append("/home/ly/workspace/mmsa")
seed = 1938
import numpy as np
import torch
from torch import nn
from torch import optim
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
from models.bigru_rcnn_gate import *
from utils.train import *
from t... | [
"torch.cuda.manual_seed_all",
"torch.manual_seed",
"torch.nn.CrossEntropyLoss",
"numpy.random.seed",
"torch.cuda.manual_seed",
"sys.path.append"
] | [((11, 53), 'sys.path.append', 'sys.path.append', (['"""/home/ly/workspace/mmsa"""'], {}), "('/home/ly/workspace/mmsa')\n", (26, 53), False, 'import sys\n'), ((144, 164), 'numpy.random.seed', 'np.random.seed', (['seed'], {}), '(seed)\n', (158, 164), True, 'import numpy as np\n'), ((165, 188), 'torch.manual_seed', 'torc... |
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
########################################################################
# GNU General Public License v3.0
# GNU GPLv3
# Copyright (c) 2019, <NAME>
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public Licen... | [
"numpy.array",
"platform.node"
] | [((1150, 1213), 'numpy.array', 'np.array', (["['caffe', 'tensorflow', 'pytorch', 'keras', 'caffe2']"], {}), "(['caffe', 'tensorflow', 'pytorch', 'keras', 'caffe2'])\n", (1158, 1213), True, 'import numpy as np\n'), ((1271, 1323), 'numpy.array', 'np.array', (['[2048, 2048, 1000, 1024, 1000, 2048, 2048]'], {}), '([2048, 2... |
import json
import numpy as np
import os
import tensorflow as tf
from keras.models import Sequential
from keras.layers import Dense, Dropout, Embedding, Flatten, Activation, BatchNormalization
from sklearn.model_selection import train_test_split
class SuggestionModeler(object):
"""
A collection of functions ... | [
"os.path.exists",
"random.shuffle",
"sklearn.model_selection.train_test_split",
"tensorflow.Session",
"keras.models.Sequential",
"os.chdir",
"numpy.zeros",
"keras.layers.Dense",
"keras.layers.Dropout",
"tensorflow.get_default_graph"
] | [((5754, 5768), 'os.chdir', 'os.chdir', (['""".."""'], {}), "('..')\n", (5762, 5768), False, 'import os\n'), ((490, 502), 'tensorflow.Session', 'tf.Session', ([], {}), '()\n', (500, 502), True, 'import tensorflow as tf\n'), ((524, 546), 'tensorflow.get_default_graph', 'tf.get_default_graph', ([], {}), '()\n', (544, 546... |
##################################################
#
# Tests for model.py
#
#
#
#
#
#
#
#
#
#
#
##################################################
from boole.core.model import *
from boole.core.language import clear_default_language
from nose.tools import *
def is_prime(x):
if x == 0 or x == 1:
return Fa... | [
"boole.core.language.clear_default_language"
] | [((579, 603), 'boole.core.language.clear_default_language', 'clear_default_language', ([], {}), '()\n', (601, 603), False, 'from boole.core.language import clear_default_language\n'), ((4325, 4349), 'boole.core.language.clear_default_language', 'clear_default_language', ([], {}), '()\n', (4347, 4349), False, 'from bool... |
#!/usr/bin/env python3
"""
Host the setup function.
"""
import pathlib
import setuptools
from cushead import info
def setup() -> None:
"""
Execute the setup.
"""
assets_path = pathlib.Path(info.PACKAGE_NAME) / "console" / "assets" / "images"
templates_path = pathlib.Path(info.PACKAGE_NAME) / "ge... | [
"pathlib.Path"
] | [((196, 227), 'pathlib.Path', 'pathlib.Path', (['info.PACKAGE_NAME'], {}), '(info.PACKAGE_NAME)\n', (208, 227), False, 'import pathlib\n'), ((283, 314), 'pathlib.Path', 'pathlib.Path', (['info.PACKAGE_NAME'], {}), '(info.PACKAGE_NAME)\n', (295, 314), False, 'import pathlib\n'), ((1480, 1505), 'pathlib.Path', 'pathlib.P... |
import os, sys
import re
import zipfile
import requests
import warnings
import logging
import pandas as pd
import numpy as np
from stat import S_IREAD, S_IRGRP, S_IROTH
import getpass
import pymysql
# Code by <NAME> (<EMAIL>), 2016-2017
class LoadData():
"""
This class is inherited by the Data class, and cont... | [
"os.path.exists",
"os.listdir",
"zipfile.ZipFile",
"re.compile",
"os.path.join",
"pymysql.connect",
"requests.get",
"getpass.getpass",
"os.chmod",
"pandas.to_numeric",
"sys.stdin.isatty",
"pandas.concat"
] | [((1685, 1757), 're.compile', 're.compile', (['"""(\\\\d{4})\\\\s*=\\\\s*(https?:\\\\/\\\\/.+\\\\.(dat|zip|csv|txt))\\\\s*"""'], {}), "('(\\\\d{4})\\\\s*=\\\\s*(https?:\\\\/\\\\/.+\\\\.(dat|zip|csv|txt))\\\\s*')\n", (1695, 1757), False, 'import re\n'), ((1771, 1787), 're.compile', 're.compile', (['"""^#"""'], {}), "('^... |
# Copyright (c) 2021 <NAME>(<EMAIL>)
#
# 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 w... | [
"argparse.ArgumentParser",
"torch.jit.load",
"onnxruntime.InferenceSession",
"yaml.load",
"torch.tensor",
"torch.randn",
"torch.onnx.export"
] | [((683, 742), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""export to onnx model"""'}), "(description='export to onnx model')\n", (706, 742), False, 'import argparse\n'), ((1318, 1348), 'torch.jit.load', 'torch.jit.load', (['args.jit_model'], {}), '(args.jit_model)\n', (1332, 1348), Fal... |
from maya import cmds
import copy
# TODO: Find a way to have different naming for different production.
# Maybe handle it in the rig directly?
class BaseName(object):
"""
This class handle the naming of object.
Store a name as a list of 'tokens'
When resolved, the tokens are joinned using a 'separator... | [
"copy.copy",
"maya.cmds.objExists"
] | [((2244, 2266), 'copy.copy', 'copy.copy', (['self.tokens'], {}), '(self.tokens)\n', (2253, 2266), False, 'import copy\n'), ((4201, 4221), 'maya.cmds.objExists', 'cmds.objExists', (['name'], {}), '(name)\n', (4215, 4221), False, 'from maya import cmds\n')] |
# Copyright 2022 Tiernan8r
#
# 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, so... | [
"qcp.matrices.DefaultMatrix"
] | [((1301, 1323), 'qcp.matrices.DefaultMatrix', 'DefaultMatrix', (['entries'], {}), '(entries)\n', (1314, 1323), False, 'from qcp.matrices import SPARSE, DefaultMatrix, Matrix\n')] |
import math
import numpy as np
import torch
from mock import patch
from core.train_utils import compute_angular_error, compute_angular_error_xyz_arr, spherical2cartesial
def test_spherical2cartesial():
spherical = torch.Tensor([
[0, 0],
[math.pi / 2, 0],
[-math.pi / 2, 0],
[0, ma... | [
"core.train_utils.compute_angular_error",
"mock.patch",
"torch.mean",
"core.train_utils.compute_angular_error_xyz_arr",
"torch.Tensor",
"math.sqrt",
"numpy.array",
"core.train_utils.spherical2cartesial"
] | [((740, 776), 'mock.patch', 'patch', (['"""core.train_utils.epsilon"""', '(0)'], {}), "('core.train_utils.epsilon', 0)\n", (745, 776), False, 'from mock import patch\n'), ((1504, 1540), 'mock.patch', 'patch', (['"""core.train_utils.epsilon"""', '(0)'], {}), "('core.train_utils.epsilon', 0)\n", (1509, 1540), False, 'fro... |
import csv
import re
from os import makedirs
from os.path import abspath, basename, dirname, isdir, join
def generate_csv(path, fields, rows, quote_empty=False):
path = abspath(path)
name = basename(path)
name = re.sub('py$', 'csv', name)
cases = join(dirname(dirname(path)), 'cases')
if not isdir(... | [
"csv.DictWriter",
"os.makedirs",
"csv.writer",
"os.path.join",
"os.path.dirname",
"os.path.isdir",
"os.path.basename",
"os.path.abspath",
"re.sub"
] | [((175, 188), 'os.path.abspath', 'abspath', (['path'], {}), '(path)\n', (182, 188), False, 'from os.path import abspath, basename, dirname, isdir, join\n'), ((200, 214), 'os.path.basename', 'basename', (['path'], {}), '(path)\n', (208, 214), False, 'from os.path import abspath, basename, dirname, isdir, join\n'), ((226... |
from datetime import datetime
import traceback
import boto3
from botocore.exceptions import ClientError
from ...config import config
from ...log import log
class Submitter():
def __init__(self, event):
self.event = event
def find_instance(self, instance_id, mac_address): # pylint: disable=R0201
... | [
"traceback.format_exc",
"boto3.resource",
"boto3.client",
"datetime.datetime.now"
] | [((511, 530), 'boto3.client', 'boto3.client', (['"""ec2"""'], {}), "('ec2')\n", (523, 530), False, 'import boto3\n'), ((676, 717), 'boto3.resource', 'boto3.resource', (['"""ec2"""'], {'region_name': 'region'}), "('ec2', region_name=region)\n", (690, 717), False, 'import boto3\n'), ((1420, 1442), 'traceback.format_exc',... |
import pytest
from buyer import serializers
@pytest.mark.django_db
def test_buyer_deserialization():
data = {
'email': '<EMAIL>',
'name': '<NAME>',
'sector': 'AEROSPACE',
'company_name': 'Example corp',
'country': 'China',
}
serializer = serializers.BuyerSerialize... | [
"buyer.serializers.BuyerSerializer"
] | [((294, 332), 'buyer.serializers.BuyerSerializer', 'serializers.BuyerSerializer', ([], {'data': 'data'}), '(data=data)\n', (321, 332), False, 'from buyer import serializers\n')] |
#1d_tests.py
import autograd.numpy as np
import autograd.scipy.stats.norm as norm
from copy import copy
import datetime as dt
from matplotlib import pyplot as plt
import seaborn as sns
import sys; sys.path.append('..')
from mcmc import langevin, MALA, RK_langevin, RWMH, HMC
def bimodal_logprob(z):
return (np.log(n... | [
"autograd.numpy.sin",
"seaborn.distplot",
"autograd.numpy.linspace",
"autograd.scipy.stats.norm.logpdf",
"datetime.datetime.now",
"autograd.numpy.random.randn",
"copy.copy",
"sys.path.append",
"matplotlib.pyplot.show"
] | [((200, 221), 'sys.path.append', 'sys.path.append', (['""".."""'], {}), "('..')\n", (215, 221), False, 'import sys\n'), ((467, 496), 'autograd.numpy.random.randn', 'np.random.randn', (['n_samples', '(1)'], {}), '(n_samples, 1)\n', (482, 496), True, 'import autograd.numpy as np\n'), ((570, 587), 'datetime.datetime.now',... |
import qrcode
# data example
data = "www.google.com"
# file name
file_name = "qrcode.png"
# generate qr code
img = qrcode.make(data=data)
# save generated qr code as img
img.save(file_name)
| [
"qrcode.make"
] | [((118, 140), 'qrcode.make', 'qrcode.make', ([], {'data': 'data'}), '(data=data)\n', (129, 140), False, 'import qrcode\n')] |
"""
Low level miscilanious calls
"""
import UserDict
import types
import random
import datetime
import pprint
import re
import unicodedata
import logging
log = logging.getLogger(__name__)
now_override = None
def now():
"""
A passthough to get now()
We can override this so that automated tests can fake ... | [
"logging.getLogger",
"datetime.datetime.now",
"datetime.date.today",
"datetime.date"
] | [((163, 190), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (180, 190), False, 'import logging\n'), ((409, 432), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (430, 432), False, 'import datetime\n'), ((3686, 3707), 'datetime.date.today', 'datetime.date.today', ([], ... |
import os
from pydantic import BaseSettings
class AppSettings(BaseSettings):
debug: bool = False
time_zone: str = "Asia/Shanghai"
logger_level: str = "INFO"
logger_formatter: str = "%(asctime)s [%(name)s] %(funcName)s[line:%(lineno)d] %(levelname)-7s: %(message)s"
secret_key: str = "1@3$5^7*9)"
... | [
"os.getenv"
] | [((1078, 1102), 'os.getenv', 'os.getenv', (['"""FASTAPI_ENV"""'], {}), "('FASTAPI_ENV')\n", (1087, 1102), False, 'import os\n'), ((374, 402), 'os.getenv', 'os.getenv', (['"""POSTGRESQL_PORT"""'], {}), "('POSTGRESQL_PORT')\n", (383, 402), False, 'import os\n'), ((432, 459), 'os.getenv', 'os.getenv', (['"""REDIS_PASSWORD... |
# coding: utf-8
"""
Layered Insight Assessment, Compliance, Witness & Control
LI Assessment & Compliance performs static vulnerability analysis, license and package compliance. LI Witness provides deep insight and analytics into containerized applications. Control provides dynamic runtime security and analyti... | [
"six.iteritems"
] | [((3539, 3568), 'six.iteritems', 'iteritems', (['self.swagger_types'], {}), '(self.swagger_types)\n', (3548, 3568), False, 'from six import iteritems\n')] |
'''
Different utils used by plotters.
'''
import mpl_toolkits.basemap as bm
import matplotlib.pyplot as pl
from matplotlib import colors, cm
import scipy as sp
# Make spectral plot
def my_psd(x):
P,f=pl.psd(x); pl.clf()
T=2./f; ind= T>=12.
pl.plot(T[ind]/12,P[ind]);
ax=pl.gca();
ax.set_xscale('lo... | [
"matplotlib.colors.normalize",
"matplotlib.pyplot.gca",
"matplotlib.pyplot.psd",
"matplotlib.pyplot.clf",
"matplotlib.pyplot.plot",
"scipy.ma.maximum",
"scipy.ma.minimum",
"matplotlib.cm.get_cmap"
] | [((206, 215), 'matplotlib.pyplot.psd', 'pl.psd', (['x'], {}), '(x)\n', (212, 215), True, 'import matplotlib.pyplot as pl\n'), ((217, 225), 'matplotlib.pyplot.clf', 'pl.clf', ([], {}), '()\n', (223, 225), True, 'import matplotlib.pyplot as pl\n'), ((254, 282), 'matplotlib.pyplot.plot', 'pl.plot', (['(T[ind] / 12)', 'P[i... |
#!/usr/bin/env python
"""
Lyrebird Voice Changer
Simple and powerful voice changer for Linux, written in GTK 3
(c) Charlotte 2020
"""
import sys
import re
from setuptools import setup
version_regex = r'__version__ = ["\']([^"\']*)["\']'
with open('app/__init__.py', 'r') as f:
text = f.read()
match = re.search... | [
"setuptools.setup",
"re.search"
] | [((1102, 1124), 'setuptools.setup', 'setup', ([], {}), '(**extra_options)\n', (1107, 1124), False, 'from setuptools import setup\n'), ((311, 341), 're.search', 're.search', (['version_regex', 'text'], {}), '(version_regex, text)\n', (320, 341), False, 'import re\n')] |
from django.db import models
from django.utils.translation import ugettext_lazy as _
from helusers.models import AbstractUser
class User(AbstractUser):
is_official = models.BooleanField(verbose_name=_("official"), default=False)
class Meta:
verbose_name = _("user")
verbose_name_plural = _("us... | [
"django.utils.translation.ugettext_lazy"
] | [((275, 284), 'django.utils.translation.ugettext_lazy', '_', (['"""user"""'], {}), "('user')\n", (276, 284), True, 'from django.utils.translation import ugettext_lazy as _\n'), ((315, 325), 'django.utils.translation.ugettext_lazy', '_', (['"""users"""'], {}), "('users')\n", (316, 325), True, 'from django.utils.translat... |
#!/usr/bin/env python
# coding: utf-8
# In[1]:
import numpy as np
import pandas as pd
import glob,os,csv,re,math
import shutil, time
from astropy.io import ascii
import matplotlib.pyplot as plt
# Load all data files:
psdir ='/Users/maryumsayeed/Desktop/HuberNess/mlearning/powerspectrum/'
hrdir ='/Users/maryu... | [
"pandas.read_csv",
"numpy.where",
"math.isnan",
"numpy.array",
"numpy.concatenate",
"numpy.loadtxt",
"astropy.io.ascii.read",
"glob.glob",
"re.search"
] | [((790, 821), 'glob.glob', 'glob.glob', (["(pande_dir + '*.fits')"], {}), "(pande_dir + '*.fits')\n", (799, 821), False, 'import glob, os, csv, re, math\n'), ((835, 864), 'glob.glob', 'glob.glob', (["(ast_dir + '*.fits')"], {}), "(ast_dir + '*.fits')\n", (844, 864), False, 'import glob, os, csv, re, math\n'), ((1184, 1... |
#!/usr/bin/python
# -*- coding: utf-8 -*-
# thumbor imaging service
# https://github.com/TechLaProvence/lp_mongodb
# Licensed under the MIT license:
# http://www.opensource.org/licenses/mit-license
# Copyright (c) 2011 figarocms <EMAIL>
from tornado.concurrent import return_future
from lp_mongodb.storages.mongo_sto... | [
"lp_mongodb.storages.mongo_storage.Storage"
] | [((473, 489), 'lp_mongodb.storages.mongo_storage.Storage', 'Storage', (['context'], {}), '(context)\n', (480, 489), False, 'from lp_mongodb.storages.mongo_storage import Storage\n')] |
import numpy as np
from tabulate import tabulate
import matplotlib.pyplot as plt
import Page_Rank_Utils as pru
def detectedConverged(y,x,epsilon):
C = set()
N = set()
for i in range(len(y)):
if abs(y[i] - x[i])/abs(x[i]) < epsilon:
C.add(i)
else:
N.add(i)
return... | [
"Page_Rank_Utils.stochastic_transition_matrix",
"numpy.zeros"
] | [((591, 640), 'Page_Rank_Utils.stochastic_transition_matrix', 'pru.stochastic_transition_matrix', (['G', 'weight', '(True)'], {}), '(G, weight, True)\n', (623, 640), True, 'import Page_Rank_Utils as pru\n'), ((733, 744), 'numpy.zeros', 'np.zeros', (['n'], {}), '(n)\n', (741, 744), True, 'import numpy as np\n')] |
from troyka_led_matrix import TroykaLedMatrix
from urandom import getrandbits
import time
matrix = TroykaLedMatrix()
while True:
matrix.draw_pixel(getrandbits(3), getrandbits(3))
matrix.clear_pixel(getrandbits(3), getrandbits(3))
time.sleep_ms(50)
| [
"time.sleep_ms",
"urandom.getrandbits",
"troyka_led_matrix.TroykaLedMatrix"
] | [((104, 121), 'troyka_led_matrix.TroykaLedMatrix', 'TroykaLedMatrix', ([], {}), '()\n', (119, 121), False, 'from troyka_led_matrix import TroykaLedMatrix\n'), ((253, 270), 'time.sleep_ms', 'time.sleep_ms', (['(50)'], {}), '(50)\n', (266, 270), False, 'import time\n'), ((160, 174), 'urandom.getrandbits', 'getrandbits', ... |
import math
import itertools
class Vector:
"""
Generic vector operations.
"""
def _apply(self,op, other):
pairwise = None
if type(other) is Vector:
pairwise = zip(self.vals, other.vals)
else:
pairwise = zip(self.vals, [other for _ ... | [
"math.pow",
"math.sqrt",
"itertools.starmap"
] | [((907, 923), 'math.sqrt', 'math.sqrt', (['total'], {}), '(total)\n', (916, 923), False, 'import math\n'), ((359, 390), 'itertools.starmap', 'itertools.starmap', (['op', 'pairwise'], {}), '(op, pairwise)\n', (376, 390), False, 'import itertools\n'), ((863, 877), 'math.pow', 'math.pow', (['a', '(2)'], {}), '(a, 2)\n', (... |
import numpy as np
import os
os.environ['TF_FORCE_GPU_ALLOW_GROWTH']='true'
import datetime
from sacred import Experiment
from sacred.observers import FileStorageObserver
from datasets.ucf101 import UCF101Dataset
from algorithms.kerasvideoonenet import KerasVideoOneNet
from algorithms.kerasvideoonenet_admm import Keras... | [
"datasets.ucf101.UCF101Dataset",
"sacred.observers.FileStorageObserver.create",
"algorithms.numpyvideowaveletsparsity_admm.NumpyVideoWaveletSparsityADMM",
"sacred.Experiment",
"algorithms.kerasvideoonenet_admm.KerasVideoOneNetADMM",
"datetime.datetime.now",
"os.path.basename",
"os.getpid",
"algorith... | [((475, 491), 'sacred.Experiment', 'Experiment', (['name'], {}), '(name)\n', (485, 491), False, 'from sacred import Experiment\n'), ((497, 520), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (518, 520), False, 'import datetime\n'), ((752, 791), 'sacred.observers.FileStorageObserver.create', 'FileS... |
#tiersweekly.py
from fantasyfootball import tiers
from fantasyfootball import fantasypros as fp
from fantasyfootball import config
from fantasyfootball import ffcalculator
from fantasyfootball.config import FIGURE_DIR
from sklearn.cluster import KMeans
from sklearn.mixture import GaussianMixture
from matplotlib import... | [
"matplotlib.pyplot.ylabel",
"fantasyfootball.tiers.make_clustering_viz",
"numpy.array_split",
"matplotlib.pyplot.annotate",
"matplotlib.style.use",
"matplotlib.lines.Line2D",
"collections.OrderedDict.fromkeys",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.scatter",
"sklearn.mixture.GaussianMixtu... | [((2721, 2758), 'fantasyfootball.fantasypros.create_fantasy_pros_ecr_df', 'fp.create_fantasy_pros_ecr_df', (['league'], {}), '(league)\n', (2750, 2758), True, 'from fantasyfootball import fantasypros as fp\n'), ((3148, 3160), 'datetime.date.today', 'date.today', ([], {}), '()\n', (3158, 3160), False, 'from datetime imp... |
"""Pauses the execution."""
import time
from dodo_commands.framework.decorator_utils import uses_decorator
class Decorator:
def is_used(self, config, command_name, decorator_name):
return uses_decorator(config, command_name, decorator_name)
def add_arguments(self, parser): # override
parser... | [
"dodo_commands.framework.decorator_utils.uses_decorator",
"time.sleep"
] | [((203, 255), 'dodo_commands.framework.decorator_utils.uses_decorator', 'uses_decorator', (['config', 'command_name', 'decorator_name'], {}), '(config, command_name, decorator_name)\n', (217, 255), False, 'from dodo_commands.framework.decorator_utils import uses_decorator\n'), ((579, 624), 'time.sleep', 'time.sleep', (... |
import logging
from typing import List
from .AnaplanRequest import AnaplanRequest
from .User import User
from .ModelDetails import ModelDetails
logger = logging.getLogger(__name__)
class Model(User):
def get_models_url(self) -> AnaplanRequest:
"""Get list of all Anaplan model for the specified user.
:return: O... | [
"logging.getLogger"
] | [((154, 181), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (171, 181), False, 'import logging\n')] |
# Hangman game
#
# -----------------------------------
# Helper code
# You don't need to understand this helper code,
# but you will have to know how to use the functions
# (so be sure to read the docstrings!)
import random
import string
WORDLIST_FILENAME = "/Users/deedeebanh/Documents/MITx_6.00.1.x/ProblemSet3/word... | [
"random.choice"
] | [((951, 974), 'random.choice', 'random.choice', (['wordlist'], {}), '(wordlist)\n', (964, 974), False, 'import random\n')] |
#!/usr/bin/python3
import argparse
from datetime import datetime
import json
from PyQt5.QtGui import *
from PyQt5.QtWidgets import *
from PyQt5 import uic
import os
import sys
from weather import Weather
BASE_PATH = os.path.dirname(os.path.abspath(__file__))
DISP_SIZE = (640, 384)
WHITE = 0xffffffff
BLACK = 0xff000... | [
"argparse.ArgumentParser",
"PyQt5.uic.loadUi",
"json.load",
"datetime.datetime.now",
"weather.Weather",
"epd7in5.EPD",
"os.path.abspath"
] | [((234, 259), 'os.path.abspath', 'os.path.abspath', (['__file__'], {}), '(__file__)\n', (249, 259), False, 'import os\n'), ((413, 438), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (436, 438), False, 'import argparse\n'), ((1677, 1755), 'weather.Weather', 'Weather', ([], {'api_key': "config['... |
from sklearn.metrics import r2_score
y_true = [3, -0.5, 2, 7]
y_pred = [2.5, 0.0, 2, 8]
r2=r2_score(y_true, y_pred)
print(r2)
y_true = [5,6,7,8]
y_pred = [-100,524,-1,3]
r2=r2_score(y_true, y_pred)
print(r2)
r2_ | [
"sklearn.metrics.r2_score"
] | [((94, 118), 'sklearn.metrics.r2_score', 'r2_score', (['y_true', 'y_pred'], {}), '(y_true, y_pred)\n', (102, 118), False, 'from sklearn.metrics import r2_score\n'), ((177, 201), 'sklearn.metrics.r2_score', 'r2_score', (['y_true', 'y_pred'], {}), '(y_true, y_pred)\n', (185, 201), False, 'from sklearn.metrics import r2_s... |
import pytest
from ssz.sedes import Bitvector
def test_bitvector_instantiation_bound():
with pytest.raises(ValueError):
bit_count = 0
Bitvector(bit_count)
| [
"ssz.sedes.Bitvector",
"pytest.raises"
] | [((100, 125), 'pytest.raises', 'pytest.raises', (['ValueError'], {}), '(ValueError)\n', (113, 125), False, 'import pytest\n'), ((157, 177), 'ssz.sedes.Bitvector', 'Bitvector', (['bit_count'], {}), '(bit_count)\n', (166, 177), False, 'from ssz.sedes import Bitvector\n')] |
# Seguridad Informatica
# ejercicio de encriptacion
# <NAME> (42487)
from Crypto.Cipher import AES
from Crypto.Random import get_random_bytes
with open('key.bin', 'rb') as k:
key = k.read()
with open('vector.bin', 'rb') as v:
init_vector = v.read()
cipher = AES.new(key, AES.MODE_CBC, init_ve... | [
"Crypto.Cipher.AES.new"
] | [((285, 324), 'Crypto.Cipher.AES.new', 'AES.new', (['key', 'AES.MODE_CBC', 'init_vector'], {}), '(key, AES.MODE_CBC, init_vector)\n', (292, 324), False, 'from Crypto.Cipher import AES\n')] |
from setuptools import setup
from setuptools import find_packages
required_packages = [
'beautifulsoup4',
'cssselect',
'duckling',
'feedfinder2',
'feedparser',
'idna',
'jieba3k',
'JPype1',
'Logbook',
'lxml',
'newspaper3k',
'nltk',
'Pillow',
'PyQt5',
'python-d... | [
"setuptools.find_packages"
] | [((725, 740), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (738, 740), False, 'from setuptools import find_packages\n')] |
from base64 import b64encode, b64decode
import binascii
from datetime import datetime
from uuid import UUID
from jsonschema._format import FormatChecker
from jsonschema.exceptions import FormatError
from six import binary_type, text_type, integer_types
DATETIME_HAS_STRICT_RFC3339 = False
DATETIME_HAS_ISODATE = False
... | [
"uuid.UUID",
"datetime.datetime.strptime",
"base64.b64decode",
"jsonschema.exceptions.FormatError",
"strict_rfc3339.validate_rfc3339",
"isodate.parse_datetime",
"six.text_type"
] | [((2494, 2533), 'datetime.datetime.strptime', 'datetime.strptime', (['instance', '"""%Y-%m-%d"""'], {}), "(instance, '%Y-%m-%d')\n", (2511, 2533), False, 'from datetime import datetime\n'), ((2134, 2175), 'strict_rfc3339.validate_rfc3339', 'strict_rfc3339.validate_rfc3339', (['instance'], {}), '(instance)\n', (2165, 21... |
#!/usr/bin/python3
import argparse
import socket
import base64
import binascii
# 'argparse' is a very useful library for building python tools that are easy
# to use from the command line. It greatly simplifies the input validation
# and "usage" prompts which really help when trying to debug your own code.
# parser =... | [
"socket.socket",
"socket.makefile",
"base64.b64encode",
"base64.b64decode",
"socket.connect"
] | [((680, 729), 'socket.socket', 'socket.socket', (['socket.AF_INET', 'socket.SOCK_STREAM'], {}), '(socket.AF_INET, socket.SOCK_STREAM)\n', (693, 729), False, 'import socket\n'), ((826, 852), 'socket.connect', 'socket.connect', (['(ip, port)'], {}), '((ip, port))\n', (840, 852), False, 'import socket\n'), ((992, 1009), '... |
import itertools
import os
import shutil
import numpy as np
import gym
from gym import spaces
import robosuite
from robosuite.controllers import load_controller_config
import robosuite.utils.macros as macros
import imageio, tqdm
from her import HERReplayBuffer
from tianshou.data import Batch
macros.SIMULATION_TIMES... | [
"robosuite.controllers.load_controller_config",
"numpy.full_like",
"os.makedirs",
"imageio.imwrite",
"gym.spaces.Box",
"numpy.array",
"numpy.random.seed",
"numpy.concatenate",
"shutil.rmtree",
"numpy.set_printoptions"
] | [((331, 365), 'numpy.set_printoptions', 'np.set_printoptions', ([], {'suppress': '(True)'}), '(suppress=True)\n', (350, 365), True, 'import numpy as np\n'), ((4148, 4171), 'shutil.rmtree', 'shutil.rmtree', (['"""render"""'], {}), "('render')\n", (4161, 4171), False, 'import shutil\n'), ((4176, 4197), 'os.makedirs', 'os... |
import unittest
import acpc_python_client as acpc
from tools.constants import Action
from weak_agents.action_tilted_agent import create_agent_strategy, create_agent_strategy_from_trained_strategy, TiltType
from tools.io_util import read_strategy_from_file
from evaluation.exploitability import Exploitability
from tool... | [
"tools.io_util.read_strategy_from_file",
"weak_agents.action_tilted_agent.create_agent_strategy",
"tools.game_utils.is_correct_strategy",
"acpc_python_client.read_game_file",
"tools.game_utils.is_strategies_equal",
"evaluation.exploitability.Exploitability",
"weak_agents.action_tilted_agent.create_agent... | [((616, 761), 'weak_agents.action_tilted_agent.create_agent_strategy', 'create_agent_strategy', (['KUHN_POKER_GAME_FILE_PATH', 'Action.RAISE', 'TiltType.ADD', '(0.2)'], {'cfr_iterations': '(20)', 'cfr_weight_delay': '(2)', 'show_progress': '(False)'}), '(KUHN_POKER_GAME_FILE_PATH, Action.RAISE, TiltType.ADD,\n 0.2, ... |
import functools
import operator
from collections.abc import Iterable
from typing import overload, Union, TypeVar
T = TypeVar('T')
S = TypeVar('S') # <1>
@overload
def sum(it: Iterable[T]) -> Union[T, int]: ... # <2>
@overload
def sum(it: Iterable[T], /, start: S) -> Union[T, S]: ... # <3>
def sum(it, /, start=0):... | [
"functools.reduce",
"typing.TypeVar"
] | [((119, 131), 'typing.TypeVar', 'TypeVar', (['"""T"""'], {}), "('T')\n", (126, 131), False, 'from typing import overload, Union, TypeVar\n'), ((136, 148), 'typing.TypeVar', 'TypeVar', (['"""S"""'], {}), "('S')\n", (143, 148), False, 'from typing import overload, Union, TypeVar\n'), ((339, 380), 'functools.reduce', 'fun... |
from __future__ import annotations
import math
from collections import deque
from typing import Optional, Callable
import numpy as np
import pygame
from chess.const import PieceType, PieceColour, Piece, CastlingType, Move, \
PIECE_INDICES, init_zobrist, MoveFlags, GameState
from chess.utils import load_image, lo... | [
"chess.utils.load_image",
"collections.deque",
"numpy.where",
"pygame.sprite.Group",
"chess.const.Move",
"chess.const.Piece.empty",
"math.copysign",
"chess.const.MoveFlags",
"pygame.draw.rect",
"pygame.Color",
"chess.utils.load_font",
"chess.const.Piece",
"chess.const.init_zobrist"
] | [((1993, 2007), 'chess.const.init_zobrist', 'init_zobrist', ([], {}), '()\n', (2005, 2007), False, 'from chess.const import PieceType, PieceColour, Piece, CastlingType, Move, PIECE_INDICES, init_zobrist, MoveFlags, GameState\n'), ((2064, 2090), 'pygame.Color', 'pygame.Color', (['light_colour'], {}), '(light_colour)\n',... |
from conans import ConanFile, tools
import os
class MsysBaseInstallerConan(ConanFile):
name = "msys-base_installer"
version = "2013072300"
license = "http://www.mingw.org/license"
url = "http://github.com/danimtb/conan-msys-installer"
settings = "os", "compiler"
build_policy = "missing"
de... | [
"os.path.join",
"conans.tools.download",
"os.unlink"
] | [((4018, 4061), 'conans.tools.download', 'tools.download', (['files[util_name]', 'util_name'], {}), '(files[util_name], util_name)\n', (4032, 4061), False, 'from conans import ConanFile, tools\n'), ((4163, 4183), 'os.unlink', 'os.unlink', (['util_name'], {}), '(util_name)\n', (4172, 4183), False, 'import os\n'), ((4196... |
"""Tests for 'cloudflare-gh-pages-dns' hook."""
import contextlib
import io
import os
import pytest
from hooks.cf_gh_pages_dns_records import check_cloudflare_gh_pages_dns_records
@pytest.mark.skipif(
not os.environ.get("CF_API_KEY"),
reason=(
"Cloudflare user API key defined in 'CF_API_KEY' enviro... | [
"os.environ.get",
"pytest.param",
"pytest.mark.parametrize",
"contextlib.redirect_stderr",
"io.StringIO",
"hooks.cf_gh_pages_dns_records.check_cloudflare_gh_pages_dns_records"
] | [((365, 451), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""quiet"""', '(True, False)'], {'ids': "('quiet=True', 'quiet=False')"}), "('quiet', (True, False), ids=('quiet=True',\n 'quiet=False'))\n", (388, 451), False, 'import pytest\n'), ((1275, 1288), 'io.StringIO', 'io.StringIO', ([], {}), '()\n', (1... |
import os
os.environ['PREFECT__LOGGING__LEVEL'] = 'DEBUG'
os.environ['DJANGO_ALLOW_ASYNC_UNSAFE'] = 'true'
from prefect import flow, task
import numpy as np
import pandas as pd
from django_pandas.io import read_frame
import helpers
@task
def insert_session(session_id):
from django_connect import connect
con... | [
"helpers.spike_count",
"db.models.TrialSpikeCounts",
"db.models.StimulusPresentation.objects.filter",
"prefect.flow",
"db.models.StimulusPresentation",
"db.models.UnitSpikeTimes.objects.filter",
"django_pandas.io.read_frame",
"django_connect.connect",
"helpers.get_session",
"db.models.Unit.objects... | [((3224, 3243), 'prefect.flow', 'flow', ([], {'name': '"""spikes"""'}), "(name='spikes')\n", (3228, 3243), False, 'from prefect import flow, task\n'), ((317, 326), 'django_connect.connect', 'connect', ([], {}), '()\n', (324, 326), False, 'from django_connect import connect\n'), ((368, 399), 'helpers.get_session', 'help... |
from sqlalchemy import Column, ForeignKey, Integer, DateTime
from sqlalchemy.orm import relationship
from ..database import Base
class Artist_album(Base):
__tablename__ = "artists_albums"
id = Column(Integer, primary_key=True, index=True)
artist_id = Column(Integer, ForeignKey("artists.id"))
album_id... | [
"sqlalchemy.orm.relationship",
"sqlalchemy.ForeignKey",
"sqlalchemy.Column"
] | [((204, 249), 'sqlalchemy.Column', 'Column', (['Integer'], {'primary_key': '(True)', 'index': '(True)'}), '(Integer, primary_key=True, index=True)\n', (210, 249), False, 'from sqlalchemy import Column, ForeignKey, Integer, DateTime\n'), ((381, 413), 'sqlalchemy.Column', 'Column', (['DateTime'], {'nullable': '(False)'})... |
from flask import request
from firebase_admin import auth
import requests
from join import firebase
import ast
import time
def get_join():
token = request.headers['authorization']
decoded_token = auth.verify_id_token(token)
email = decoded_token['firebase']['identities']['email'][0]
tags... | [
"ast.literal_eval",
"firebase_admin.auth.verify_id_token",
"requests.get"
] | [((207, 234), 'firebase_admin.auth.verify_id_token', 'auth.verify_id_token', (['token'], {}), '(token)\n', (227, 234), False, 'from firebase_admin import auth\n'), ((332, 431), 'requests.get', 'requests.get', (['"""http://tags:7000/api/users/tags"""'], {'headers': "{'authorization': token}", 'verify': '(False)'}), "('h... |
#!/usr/bin/env python3.8
# coding=utf-8
"""
Simple Lambda Handler
"""
from lbz.dev.server import MyDevServer
from lbz.dev.test import Client
from lbz.exceptions import LambdaFWException
from lbz.resource import Resource
from lbz.response import Response
from lbz.router import add_route
class HelloWorld(Resource):
... | [
"lbz.exceptions.LambdaFWException",
"lbz.router.add_route",
"lbz.response.Response",
"lbz.dev.test.Client",
"lbz.dev.server.MyDevServer"
] | [((322, 350), 'lbz.router.add_route', 'add_route', (['"""/"""'], {'method': '"""GET"""'}), "('/', method='GET')\n", (331, 350), False, 'from lbz.router import add_route\n'), ((1053, 1092), 'lbz.dev.server.MyDevServer', 'MyDevServer', ([], {'acls': 'HelloWorld', 'port': '(8001)'}), '(acls=HelloWorld, port=8001)\n', (106... |
# -*- coding: utf-8 -*-
"""
Created on Thu May 3 08:04:22 2018
@author: af5u13
"""
import numpy as np
import os
from .geometry_functions import deg2rad, sph2cart
from loudspeakerconfig import createArrayConfigFile
def createArrayConfigFromSofa( sofaFile, xmlFile = None, lspLabels = None, twoDSetup = False, virtua... | [
"os.path.exists",
"numpy.asarray",
"h5py.File",
"loudspeakerconfig.createArrayConfigFile",
"os.path.basename"
] | [((1586, 1605), 'h5py.File', 'h5py.File', (['sofaFile'], {}), '(sofaFile)\n', (1595, 1605), False, 'import h5py\n'), ((2157, 2324), 'loudspeakerconfig.createArrayConfigFile', 'createArrayConfigFile', (['xmlFile', 'posCart.T'], {'loudspeakerLabels': 'lspLabels', 'twoDconfig': 'twoDSetup', 'sphericalPositions': '(True)',... |
# from unittest import skip
from django.conf import settings
from django.contrib import auth
from django.urls import reverse
from django.test import TestCase
from plok.models import Blog, Article
from .ext_test_case import ExtTestCase
class BlogList(TestCase):
url_name = 'plok:blog_list'
def test_reverse_blo... | [
"plok.models.Blog.objects.create",
"django.contrib.auth.get_user_model",
"plok.models.Article.objects.create",
"plok.models.Article.objects.all",
"plok.models.Blog.objects.all",
"django.urls.reverse"
] | [((688, 773), 'plok.models.Blog.objects.create', 'Blog.objects.create', ([], {'created_by': 'creator', 'name': '"""test_blog_1"""', 'title': '"""Test blog 1"""'}), "(created_by=creator, name='test_blog_1', title='Test blog 1'\n )\n", (707, 773), False, 'from plok.models import Blog, Article\n'), ((785, 870), 'plok.m... |
# -*- coding: utf-8 -*-
"""
Created on 2014-5-14
django 帮助函数
@author: skycrab
@sns_userinfo
def oauth(request):
openid = request.openid
"""
import json
import logging
import base64
from functools import wraps
from django.conf import settings
from django.core.cache import cache
from django.short... | [
"logging.getLogger",
"django.contrib.auth.authenticate",
"json.loads",
"core.redis_number.RedisStat",
"urllib.unquote",
"wx.WeixinHelper.proxy",
"django.contrib.auth.login",
"functools.wraps",
"django.core.urlresolvers.reverse",
"django.shortcuts.redirect",
"time.time"
] | [((825, 853), 'logging.getLogger', 'logging.getLogger', (['"""control"""'], {}), "('control')\n", (842, 853), False, 'import logging\n'), ((1287, 1298), 'functools.wraps', 'wraps', (['func'], {}), '(func)\n', (1292, 1298), False, 'from functools import wraps\n'), ((4835, 4846), 'functools.wraps', 'wraps', (['func'], {}... |
# Copyright (c) 2021 Project CHIP Authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in ... | [
"os.path.join",
"enum.auto"
] | [((684, 690), 'enum.auto', 'auto', ([], {}), '()\n', (688, 690), False, 'from enum import Enum, auto\n'), ((702, 708), 'enum.auto', 'auto', ([], {}), '()\n', (706, 708), False, 'from enum import Enum, auto\n'), ((721, 727), 'enum.auto', 'auto', ([], {}), '()\n', (725, 727), False, 'from enum import Enum, auto\n'), ((75... |
# -*- coding: utf-8 -*-
##############################################################################
# Author：QQ173782910
##############################################################################
import logging
from apscheduler.schedulers.background import BlockingScheduler
from RunUse import TradeRun
format ... | [
"logging.basicConfig",
"apscheduler.schedulers.background.BlockingScheduler",
"logging.getLogger",
"RunUse.TradeRun"
] | [((377, 462), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO', 'format': 'format', 'filename': '"""log_print.txt"""'}), "(level=logging.INFO, format=format, filename='log_print.txt'\n )\n", (396, 462), False, 'import logging\n'), ((467, 493), 'logging.getLogger', 'logging.getLogger', (['"... |
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('wiki_images', '0001_initial'),
]
operations = [
migrations.AlterModelTable(
name='image',
table='wik... | [
"django.db.migrations.AlterModelTable"
] | [((244, 311), 'django.db.migrations.AlterModelTable', 'migrations.AlterModelTable', ([], {'name': '"""image"""', 'table': '"""wiki_images_image"""'}), "(name='image', table='wiki_images_image')\n", (270, 311), False, 'from django.db import migrations, models\n'), ((356, 444), 'django.db.migrations.AlterModelTable', 'mi... |
# coding: utf-8
from modules.controller import Controller
LED_PIN = 23 # pin of led
if __name__ == "__main__":
controller = Controller(LED_PIN)
controller.run(50, 1)
print("Led Start for a second with 50% power")
| [
"modules.controller.Controller"
] | [((132, 151), 'modules.controller.Controller', 'Controller', (['LED_PIN'], {}), '(LED_PIN)\n', (142, 151), False, 'from modules.controller import Controller\n')] |
from .base import BaseFactory
from launchkey import LAUNCHKEY_PRODUCTION
from launchkey.clients import ServiceClient
class ServiceFactory(BaseFactory):
"""Factory for creating clients when representing a LaunchKey Service Profile"""
def __init__(self, service_id, private_key, url=LAUNCHKEY_PRODUCTION, testin... | [
"launchkey.clients.ServiceClient"
] | [((1369, 1416), 'launchkey.clients.ServiceClient', 'ServiceClient', (['self._issuer_id', 'self._transport'], {}), '(self._issuer_id, self._transport)\n', (1382, 1416), False, 'from launchkey.clients import ServiceClient\n')] |
""" User api endpoints """
from flask import request
from flask_restplus import Resource
from ..util.dto import UserDto
from ..service.user import save_new_user
api = UserDto.api
_user = UserDto.user
@api.route('/users')
class Users(Resource):
"""
User resource for the API
"""
@api.doc('Create a n... | [
"flask.request.get_json"
] | [((502, 520), 'flask.request.get_json', 'request.get_json', ([], {}), '()\n', (518, 520), False, 'from flask import request\n')] |
import os
import zipfile
from typing import List, Tuple, Dict
import numpy as np
import pandas as pd
import requests
import structlog
import matplotlib.pyplot as plt
from sklearn.ensemble import RandomForestClassifier
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.model_selection import train... | [
"zipfile.ZipFile",
"pandas.read_csv",
"sklearn.neighbors.KNeighborsClassifier",
"numpy.array",
"tensorflow.keras.layers.Dense",
"pandas.read_excel",
"tensorflow.keras.losses.CategoricalCrossentropy",
"os.path.exists",
"sklearn.model_selection.train_test_split",
"tensorflow.keras.layers.ReLU",
"s... | [((548, 601), 'matplotlib.pyplot.rcParams.update', 'plt.rcParams.update', (["{'figure.figsize': (16.0, 12.0)}"], {}), "({'figure.figsize': (16.0, 12.0)})\n", (567, 601), True, 'import matplotlib.pyplot as plt\n'), ((612, 642), 'structlog.get_logger', 'structlog.get_logger', (['__file__'], {}), '(__file__)\n', (632, 642... |
# vim: set et nosi ai ts=2 sts=2 sw=2:
# coding: utf-8
from __future__ import absolute_import, print_function, unicode_literals
import unittest
from schwa import dr
class Node(dr.Ann):
label = dr.Field()
class Doc(dr.Doc):
store = dr.Store(Node)
class Test(unittest.TestCase):
def _test_example(self, doc):
... | [
"schwa.dr.Store",
"schwa.dr.Field"
] | [((198, 208), 'schwa.dr.Field', 'dr.Field', ([], {}), '()\n', (206, 208), False, 'from schwa import dr\n'), ((240, 254), 'schwa.dr.Store', 'dr.Store', (['Node'], {}), '(Node)\n', (248, 254), False, 'from schwa import dr\n')] |
#!/usr/bin/env python
import os,sys
sys.path.insert(1, os.path.join(sys.path[0], '..'))
import argparse
from multiagent.environment import MultiAgentEnv
import multiagent.scenarios as scenarios
import numpy as np
import keras.backend.tensorflow_backend as backend
from keras.models import Sequential
from keras.layers i... | [
"keras.layers.Conv2D",
"numpy.array",
"keras.layers.Activation",
"keras.layers.Dense",
"tensorflow.set_random_seed",
"multiagent.environment.MultiAgentEnv",
"collections.deque",
"argparse.ArgumentParser",
"numpy.random.random",
"numpy.max",
"os.path.isdir",
"numpy.random.seed",
"keras.optimi... | [((55, 86), 'os.path.join', 'os.path.join', (['sys.path[0]', '""".."""'], {}), "(sys.path[0], '..')\n", (67, 86), False, 'import os, sys\n'), ((647, 688), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': 'None'}), '(description=None)\n', (670, 688), False, 'import argparse\n'), ((1017, 1144), ... |
#! python3
# -*- encoding: utf-8 -*-
from job import celery
@celery.task()
def add(x, y):
return x+y
| [
"job.celery.task"
] | [((65, 78), 'job.celery.task', 'celery.task', ([], {}), '()\n', (76, 78), False, 'from job import celery\n')] |
from pathlib import Path
from unittest.mock import call
import pytest
from dbt_sugar.core.clients.dbt import DbtProfile
from dbt_sugar.core.config.config import DbtSugarConfig
from dbt_sugar.core.flags import FlagParser
from dbt_sugar.core.main import parser
from dbt_sugar.core.task.audit import AuditTask
from dbt_su... | [
"dbt_sugar.core.task.audit.AuditTask",
"pathlib.Path",
"unittest.mock.call",
"pytest.mark.datafiles",
"pytest.param",
"dbt_sugar.core.flags.FlagParser",
"dbt_sugar.core.config.config.DbtSugarConfig"
] | [((1852, 1886), 'pytest.mark.datafiles', 'pytest.mark.datafiles', (['FIXTURE_DIR'], {}), '(FIXTURE_DIR)\n', (1873, 1886), False, 'import pytest\n'), ((2607, 2641), 'pytest.mark.datafiles', 'pytest.mark.datafiles', (['FIXTURE_DIR'], {}), '(FIXTURE_DIR)\n', (2628, 2641), False, 'import pytest\n'), ((3481, 3515), 'pytest.... |
"""Functionality to evaluate contents of the ast"""
from functools import singledispatch, wraps
import operator
from typing import Any, Union
from altair_transform.utils import ast, Parser
__all__ = ['evaljs']
def evaljs(expression: Union[str, ast.Expr], namespace: dict = None) -> Any:
"""Evaluate a javascript ... | [
"altair_transform.utils.ast.Global",
"altair_transform.utils.Parser",
"functools.wraps"
] | [((3350, 3361), 'functools.wraps', 'wraps', (['func'], {}), '(func)\n', (3355, 3361), False, 'from functools import singledispatch, wraps\n'), ((417, 425), 'altair_transform.utils.Parser', 'Parser', ([], {}), '()\n', (423, 425), False, 'from altair_transform.utils import ast, Parser\n'), ((2547, 2569), 'altair_transfor... |
#!/usr/bin/env python
# -- coding: UTF-8 --
"""
Magnet API NLP Sample
Copyright 2018, Klangoo Inc.
"""
from klangooclient.MagnetAPIClient import MagnetAPIClient
ENDPOINT = 'https://nlp.klangoo.com/Service.svc'
CALK = 'enter your calk here'
SECRET_KEY = 'enter your secret key here'
client = MagnetAPIClient(END... | [
"klangooclient.MagnetAPIClient.MagnetAPIClient"
] | [((301, 344), 'klangooclient.MagnetAPIClient.MagnetAPIClient', 'MagnetAPIClient', (['ENDPOINT', 'CALK', 'SECRET_KEY'], {}), '(ENDPOINT, CALK, SECRET_KEY)\n', (316, 344), False, 'from klangooclient.MagnetAPIClient import MagnetAPIClient\n')] |
"""log_redaction_cli
Usage:
log_redaction_cli.py --tarfile <tarfile> --working-dir <working-dir> --output-dir <output-dir>
log_redaction_cli.py (-h | --help)
log_redaction_cli.py --version
Options:
-h --help Pass in a string: example command: python log_redaction_cli.py --tarfile "test/files/test_output.t... | [
"docopt.docopt"
] | [((580, 612), 'docopt.docopt', 'docopt', (['__doc__'], {'version': '"""0.0.9"""'}), "(__doc__, version='0.0.9')\n", (586, 612), False, 'from docopt import docopt\n')] |
import torch
import torch.nn as nn
from torch.nn.utils.rnn import pack_padded_sequence, pad_packed_sequence
import numpy as np
import torch.nn.functional as F
from attention import AdditiveAttention
class Encoder(nn.Module):
"""Encoder bi-GRU"""
def __init__(self, input_dim, char_embed_dim,
e... | [
"torch.nn.functional.softmax",
"torch.nn.Dropout",
"torch.ones",
"numpy.random.random",
"torch.stack",
"attention.AdditiveAttention",
"torch.argmax",
"torch.cat",
"torch.nn.utils.rnn.pack_padded_sequence",
"torch.nn.Linear",
"torch.nn.Embedding.from_pretrained",
"torch.nn.utils.rnn.pad_packed_... | [((822, 891), 'torch.nn.Embedding', 'nn.Embedding', (['input_dim', 'char_embed_dim'], {'padding_idx': 'char_padding_idx'}), '(input_dim, char_embed_dim, padding_idx=char_padding_idx)\n', (834, 891), True, 'import torch.nn as nn\n'), ((1507, 1738), 'torch.nn.GRU', 'nn.GRU', ([], {'input_size': '(char_embed_dim + morph_e... |
"""CLI entry points of faddr."""
import argparse
import pathlib
import sys
from faddr import logger
from faddr.config import load_config
from faddr.rancid import RancidDir
from faddr.database import Database
def parse_args_db():
"""Parsing CMD keys."""
parser = argparse.ArgumentParser(argument_default=argpa... | [
"argparse.ArgumentParser",
"pathlib.Path",
"faddr.logger.error",
"faddr.logger.debug",
"sys.exit",
"faddr.config.load_config",
"faddr.rancid.RancidDir"
] | [((274, 333), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'argument_default': 'argparse.SUPPRESS'}), '(argument_default=argparse.SUPPRESS)\n', (297, 333), False, 'import argparse\n'), ((1095, 1138), 'faddr.logger.debug', 'logger.debug', (['f"""Arguments from CMD: {args}"""'], {}), "(f'Arguments from CMD... |
import pandas as pd
from matplotlib import dates as mdates
from timeseries import plot_ts
from timeseries.plotting import ax_settings
def main():
# .csv available to download at:
# https://www.investing.com/currencies/gbp-usd-historical-data
gpd_usd_data = pd.read_csv("../data/GBP_USD Historical Data_mon... | [
"pandas.read_csv",
"matplotlib.dates.DateFormatter",
"timeseries.plotting.ax_settings",
"timeseries.plot_ts",
"matplotlib.dates.YearLocator",
"pandas.to_datetime"
] | [((272, 330), 'pandas.read_csv', 'pd.read_csv', (['"""../data/GBP_USD Historical Data_monthly.csv"""'], {}), "('../data/GBP_USD Historical Data_monthly.csv')\n", (283, 330), True, 'import pandas as pd\n'), ((454, 503), 'pandas.to_datetime', 'pd.to_datetime', (['gpd_usd_data.Date'], {'format': '"""%b %y"""'}), "(gpd_usd... |
from sklearn import metrics
from prettytable import PrettyTable
def evaluate_clustering(name, X, true_labels, pred_labels):
homogeneity = metrics.homogeneity_score(true_labels, pred_labels)
completeness = metrics.completeness_score(true_labels, pred_labels)
v_measure = metrics.v_measure_score(true_labels,... | [
"prettytable.PrettyTable",
"sklearn.metrics.homogeneity_score",
"sklearn.metrics.adjusted_rand_score",
"sklearn.metrics.completeness_score",
"sklearn.metrics.v_measure_score",
"sklearn.metrics.fowlkes_mallows_score",
"sklearn.metrics.normalized_mutual_info_score"
] | [((144, 195), 'sklearn.metrics.homogeneity_score', 'metrics.homogeneity_score', (['true_labels', 'pred_labels'], {}), '(true_labels, pred_labels)\n', (169, 195), False, 'from sklearn import metrics\n'), ((215, 267), 'sklearn.metrics.completeness_score', 'metrics.completeness_score', (['true_labels', 'pred_labels'], {})... |
import os
import pymysql
from dotenv import load_dotenv
from sqlalchemy import create_engine
from sqlalchemy.ext.declarative import declarative_base
from sqlalchemy.orm import relationship
from sqlalchemy import Column, BigInteger, String, Float, ForeignKey
def load_engine():
"""Create the database engine"""
... | [
"sqlalchemy.orm.relationship",
"sqlalchemy.create_engine",
"sqlalchemy.ForeignKey",
"dotenv.load_dotenv",
"sqlalchemy.String",
"sqlalchemy.ext.declarative.declarative_base",
"sqlalchemy.Column"
] | [((609, 627), 'sqlalchemy.ext.declarative.declarative_base', 'declarative_base', ([], {}), '()\n', (625, 627), False, 'from sqlalchemy.ext.declarative import declarative_base\n'), ((321, 334), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (332, 334), False, 'from dotenv import load_dotenv\n'), ((506, 581), 'sq... |