code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
"""
HexitecDAQ for Hexitec ODIN control.
<NAME>, STFC Detector Systems Software Group
"""
import logging
from functools import partial
from tornado.ioloop import IOLoop
from odin.adapters.adapter import ApiAdapterRequest
from odin.adapters.parameter_tree import ParameterTree, ParameterTreeError
from hexitec.Generat... | [
"os.path.exists",
"logging.debug",
"os.path.join",
"logging.info",
"logging.warning",
"os.getcwd",
"h5py.File",
"hexitec.GenerateConfigFiles.GenerateConfigFiles",
"os.path.isfile",
"tornado.ioloop.IOLoop.instance",
"odin.adapters.adapter.ApiAdapterRequest",
"datetime.datetime.now",
"functool... | [((2072, 2083), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (2081, 2083), False, 'import os\n'), ((7839, 7878), 'logging.debug', 'logging.debug', (['"""Setting up Acquisition"""'], {}), "('Setting up Acquisition')\n", (7852, 7878), False, 'import logging\n'), ((9097, 9225), 'logging.info', 'logging.info', (['"""FRAME S... |
from pathlib import Path
import pandas as pd
flights = pd.concat(
pd.read_csv(file, parse_dates=["firstseen", "lastseen", "day"])
for file in Path("../dataset").glob("flightlist_*.csv.gz")
)
flights_dropna = flights.dropna(axis=0, subset=['registration', 'typecode','origin','destination', 'altitude_2'])
print(... | [
"pandas.read_csv",
"pathlib.Path"
] | [((71, 134), 'pandas.read_csv', 'pd.read_csv', (['file'], {'parse_dates': "['firstseen', 'lastseen', 'day']"}), "(file, parse_dates=['firstseen', 'lastseen', 'day'])\n", (82, 134), True, 'import pandas as pd\n'), ((151, 169), 'pathlib.Path', 'Path', (['"""../dataset"""'], {}), "('../dataset')\n", (155, 169), False, 'fr... |
# -*- coding: utf-8 -*-
#
# This code is part of Qiskit.
#
# (C) Copyright IBM 2019, 2020.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# An... | [
"numpy.abs",
"qiskit.ignis.verification.tomography.basis.default_gateset_basis",
"qiskit.ignis.verification.tomography.GatesetTomographyFitter",
"numpy.sqrt",
"qiskit.ignis.verification.tomography.gateset_tomography_circuits",
"numpy.nditer",
"qiskit.compiler.assemble",
"qiskit.extensions.SGate",
"n... | [((6227, 6242), 'unittest.main', 'unittest.main', ([], {}), '()\n', (6240, 6242), False, 'import unittest\n'), ((1256, 1289), 'qiskit.Aer.get_backend', 'Aer.get_backend', (['"""qasm_simulator"""'], {}), "('qasm_simulator')\n", (1271, 1289), False, 'from qiskit import Aer\n'), ((1309, 1365), 'qiskit.ignis.verification.t... |
#!/usr/bin/env python3
import dataclasses
import enum
import json
import pathlib
import subprocess
import textwrap
from typing import Any, Dict, Iterable, List, Optional, Set, Tuple, TypeVar
import inflection
import jinja2
from jinja2 import StrictUndefined
PROJECT_ROOT = pathlib.Path(__file__).parent.parent
API_INP... | [
"jinja2.Environment",
"pathlib.Path",
"json.load",
"textwrap.wrap",
"dataclasses.replace",
"inflection.camelize",
"inflection.singularize",
"dataclasses.field",
"typing.TypeVar"
] | [((590, 602), 'typing.TypeVar', 'TypeVar', (['"""T"""'], {}), "('T')\n", (597, 602), False, 'from typing import Any, Dict, Iterable, List, Optional, Set, Tuple, TypeVar\n'), ((5875, 5926), 'dataclasses.field', 'dataclasses.field', ([], {'init': '(False)', 'default_factory': 'list'}), '(init=False, default_factory=list)... |
import datetime
entrada = input("Informe a data: ")
datainicial = datetime.datetime.strptime(entrada,"dd/mm/aa") | [
"datetime.datetime.strptime"
] | [((68, 115), 'datetime.datetime.strptime', 'datetime.datetime.strptime', (['entrada', '"""dd/mm/aa"""'], {}), "(entrada, 'dd/mm/aa')\n", (94, 115), False, 'import datetime\n')] |
"""Support for the Airzone diagnostics."""
from __future__ import annotations
from typing import Any
from aioairzone.const import AZD_MAC
from homeassistant.components.diagnostics.util import async_redact_data
from homeassistant.config_entries import ConfigEntry
from homeassistant.core import HomeAssistant
from .co... | [
"homeassistant.components.diagnostics.util.async_redact_data"
] | [((702, 749), 'homeassistant.components.diagnostics.util.async_redact_data', 'async_redact_data', (['config_entry.data', 'TO_REDACT'], {}), '(config_entry.data, TO_REDACT)\n', (719, 749), False, 'from homeassistant.components.diagnostics.util import async_redact_data\n'), ((767, 813), 'homeassistant.components.diagnost... |
import torch
import torch.nn as nn
class CNNLayer(nn.Module):
"""
This layer is callable for 1d convolution and pooling functions with fatten result
"""
def __init__(self,
input_dim,
kernel_size=(3, 4, 5),
kernel_num=200):
"""
:par... | [
"torch.cat",
"torch.nn.Conv2d"
] | [((960, 983), 'torch.cat', 'torch.cat', (['pooling_x', '(1)'], {}), '(pooling_x, 1)\n', (969, 983), False, 'import torch\n'), ((694, 735), 'torch.nn.Conv2d', 'nn.Conv2d', (['(1)', 'kernel_num', '(ks, input_dim)'], {}), '(1, kernel_num, (ks, input_dim))\n', (703, 735), True, 'import torch.nn as nn\n')] |
"""Tests for lookup handler for env."""
# pylint: disable=no-self-use
# pyright: basic
from __future__ import annotations
from typing import TYPE_CHECKING
import pytest
from runway.lookups.handlers.env import EnvLookup
if TYPE_CHECKING:
from ...factories import MockRunwayContext
ENV_VARS = {"str_val": "test"}
... | [
"pytest.raises",
"runway.lookups.handlers.env.EnvLookup.handle"
] | [((562, 613), 'runway.lookups.handlers.env.EnvLookup.handle', 'EnvLookup.handle', (['"""str_val"""'], {'context': 'runway_context'}), "('str_val', context=runway_context)\n", (578, 613), False, 'from runway.lookups.handlers.env import EnvLookup\n'), ((855, 880), 'pytest.raises', 'pytest.raises', (['ValueError'], {}), '... |
import pandas as pd
from os import listdir
from datetime import datetime as dtt
import logging
import json
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
class WalletManager:
def __init__(self, client, states):
self.binance = client
self.states = states
self._wallet_h... | [
"logging.getLogger"
] | [((117, 144), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (134, 144), False, 'import logging\n')] |
import tensorflow as tf
from wacky_rl import losses
from wacky_rl import models
from itertools import count
class SharedNetLoss(losses.WackyLoss):
_ids = count(0)
def __init__(self, alphas: list =None, sub_models=None, sub_agents=None, logger=None):
super().__init__()
self.alphas = alphas
... | [
"itertools.count"
] | [((161, 169), 'itertools.count', 'count', (['(0)'], {}), '(0)\n', (166, 169), False, 'from itertools import count\n')] |
import cv2
from shapes import Myinit
class Circle(Myinit):
def __init__(self):
super(Circle, self).__init__()
self.center = (100,100)
self.radius = 50
self.color = (0,0,255)
self.thickness = -1
def form_shape(self):
self.img = cv2.circle(self.img, se... | [
"cv2.circle",
"cv2.waitKey",
"cv2.destroyAllWindows",
"cv2.imshow"
] | [((297, 359), 'cv2.circle', 'cv2.circle', (['self.img', 'self.center', 'self.radius', 'self.color', '(-1)'], {}), '(self.img, self.center, self.radius, self.color, -1)\n', (307, 359), False, 'import cv2\n'), ((599, 629), 'cv2.imshow', 'cv2.imshow', (['"""Circle"""', 'self.img'], {}), "('Circle', self.img)\n", (609, 629... |
"""
Unit test script for convert.py
"""
import unittest
import pyeto
class TestConvert(unittest.TestCase):
def test_celsius2kelvin(self):
self.assertEqual(pyeto.celsius2kelvin(0), 273.15)
def test_kelvin2celsius(self):
self.assertEqual(pyeto.kelvin2celsius(273.15), 0.0)
def test_deg2r... | [
"pyeto.celsius2kelvin",
"pyeto.deg2rad",
"pyeto.kelvin2celsius",
"unittest.main",
"pyeto.rad2deg"
] | [((1026, 1041), 'unittest.main', 'unittest.main', ([], {}), '()\n', (1039, 1041), False, 'import unittest\n'), ((172, 195), 'pyeto.celsius2kelvin', 'pyeto.celsius2kelvin', (['(0)'], {}), '(0)\n', (192, 195), False, 'import pyeto\n'), ((266, 294), 'pyeto.kelvin2celsius', 'pyeto.kelvin2celsius', (['(273.15)'], {}), '(273... |
# important necessary classes and functions
import math
from node import Node
from queue_assignment import Queue
from essentials import transition_nodes
from heuristic import HeuristicCalc
from copy import deepcopy
from flatland.envs.rail_env import RailEnv
# class for solving single agent using sipp
class SIPP:
"... | [
"queue_assignment.Queue",
"node.Node",
"essentials.transition_nodes",
"copy.deepcopy"
] | [((4384, 4391), 'queue_assignment.Queue', 'Queue', ([], {}), '()\n', (4389, 4391), False, 'from queue_assignment import Queue\n'), ((4842, 4986), 'node.Node', 'Node', ([], {'loc': 'start', 'direction': 'start_direction', 'goal': 'goal', 'heuristic_func': 'heuristic_calc.calculate_heuristic', 'heuristic_weight': 'heuris... |
from scipy.optimize import fsolve
import numpy as np
from household_dist import HOUSEHOLD_DIST
def compute_household_infection_prob(prevalence, household_dist, SAR=0.3741):
"""
computes the probability that a household is infected given population level prevalence,
household size distribution and househol... | [
"scipy.optimize.fsolve",
"numpy.sum"
] | [((2099, 2177), 'scipy.optimize.fsolve', 'fsolve', (['match_prevalence', '(0.005)'], {'args': '(target_prevalence, household_dist, SAR)'}), '(match_prevalence, 0.005, args=(target_prevalence, household_dist, SAR))\n', (2105, 2177), False, 'from scipy.optimize import fsolve\n'), ((564, 586), 'numpy.sum', 'np.sum', (['ho... |
import torch
import torch.nn as nn
# from torch.nn import init
import functools
# from torch.autograd import Variable
import numpy as np
import pdb
###############################################################################
# Functions
##############################################################################... | [
"torch.nn.Sigmoid",
"torch.nn.ReLU",
"torch.nn.parallel.data_parallel",
"numpy.ceil",
"torch.nn.Tanh",
"torch.nn.LeakyReLU",
"torch.nn.Dropout",
"torch.nn.Sequential",
"torch.nn.ReflectionPad2d",
"torch.nn.Conv2d",
"torch.cuda.is_available",
"functools.partial",
"torch.nn.ReplicationPad2d",
... | [((739, 785), 'functools.partial', 'functools.partial', (['nn.BatchNorm2d'], {'affine': '(True)'}), '(nn.BatchNorm2d, affine=True)\n', (756, 785), False, 'import functools\n'), ((1527, 1552), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {}), '()\n', (1550, 1552), False, 'import torch\n'), ((4480, 4505), '... |
# -*- coding: utf-8 -*-
"""
Created on Sat Apr 13 16:12:34 2019
@author: bosmanjw
"""
import httpInterface
import sys
sys.path.append('../')
sys.path.append('../shamir_ss')
from shamir_ss.reconstruct_value import reconstruct_value
import config
import asyncio
import json
class Combiner(object):
... | [
"httpInterface.Requestor",
"json.dumps",
"httpInterface.Listener",
"asyncio.get_event_loop",
"sys.path.append",
"shamir_ss.reconstruct_value.reconstruct_value"
] | [((129, 151), 'sys.path.append', 'sys.path.append', (['"""../"""'], {}), "('../')\n", (144, 151), False, 'import sys\n'), ((153, 184), 'sys.path.append', 'sys.path.append', (['"""../shamir_ss"""'], {}), "('../shamir_ss')\n", (168, 184), False, 'import sys\n'), ((453, 489), 'httpInterface.Requestor', 'httpInterface.Requ... |
"""Main object for getting the PECO outage counter data."""
from __future__ import annotations
from typing import Any
import aiohttp
from .const import *
from pydantic import BaseModel
class PecoOutageApi:
"""Main object for getting the PECO outage counter data."""
def __init__(self) -> None:
"""Init... | [
"aiohttp.ClientSession"
] | [((839, 862), 'aiohttp.ClientSession', 'aiohttp.ClientSession', ([], {}), '()\n', (860, 862), False, 'import aiohttp\n'), ((1527, 1550), 'aiohttp.ClientSession', 'aiohttp.ClientSession', ([], {}), '()\n', (1548, 1550), False, 'import aiohttp\n'), ((3050, 3073), 'aiohttp.ClientSession', 'aiohttp.ClientSession', ([], {})... |
import cv2
import numpy as np
import torch
from matplotlib import pyplot as plt
from dataset import mydataset_PCA
from torch.utils.data import DataLoader
from tqdm import tqdm
import pickle
import sklearn.decomposition as dc
import argparse
parser = argparse.ArgumentParser(description='Process some integers.')
parser.... | [
"numpy.mean",
"argparse.ArgumentParser",
"sklearn.decomposition.PCA",
"tqdm.tqdm",
"numpy.argsort",
"numpy.array",
"numpy.sum",
"numpy.concatenate",
"torch.utils.data.DataLoader",
"dataset.mydataset_PCA"
] | [((251, 312), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Process some integers."""'}), "(description='Process some integers.')\n", (274, 312), False, 'import argparse\n'), ((688, 788), 'dataset.mydataset_PCA', 'mydataset_PCA', ([], {'image_dir': 'image_dir', 'text_path': 'text_path',... |
import environ
env = environ.Env(
DEBUG=(bool, True)
)
| [
"environ.Env"
] | [((22, 53), 'environ.Env', 'environ.Env', ([], {'DEBUG': '(bool, True)'}), '(DEBUG=(bool, True))\n', (33, 53), False, 'import environ\n')] |
#coding: utf-8
import requests
import AdvancedHTMLParser
import json
import datetime
import html
from unidecode import unidecode
# Placeholder, will be replaced by reference to main cfg object
# This is only to satisfy builtin vs code verifier
try:
cfg = None
cfg.teachermap_filename = None
except:
pass
print("SEMI... | [
"datetime.datetime.strptime",
"AdvancedHTMLParser.AdvancedHTMLParser",
"html.unescape",
"requests.get"
] | [((390, 441), 'requests.get', 'requests.get', (['"""http://www.zseil.edu.pl/zastepstwa/"""'], {}), "('http://www.zseil.edu.pl/zastepstwa/')\n", (402, 441), False, 'import requests\n'), ((519, 558), 'AdvancedHTMLParser.AdvancedHTMLParser', 'AdvancedHTMLParser.AdvancedHTMLParser', ([], {}), '()\n', (556, 558), False, 'im... |
#import sqlite3
from flask import (Blueprint, flash, g, redirect,
render_template, request, session, url_for)
import functools
from setting import Config
import hashlib
bp = Blueprint('login', __name__, url_prefix='/web')
@bp.route('/login', methods=('GET', 'POST'))
def login():
# 登录
if re... | [
"flask.render_template",
"flask.flash",
"flask.session.get",
"functools.wraps",
"flask.url_for",
"flask.session.clear",
"flask.Blueprint",
"setting.Config.PASSWORD.encode"
] | [((194, 241), 'flask.Blueprint', 'Blueprint', (['"""login"""', '__name__'], {'url_prefix': '"""/web"""'}), "('login', __name__, url_prefix='/web')\n", (203, 241), False, 'from flask import Blueprint, flash, g, redirect, render_template, request, session, url_for\n'), ((984, 1017), 'flask.render_template', 'render_templ... |
from pfwrapper import PyPatternFinder
from collections import namedtuple
Pattern = namedtuple('Pattern', ['base', 'sens', 'pBase', 'pAll',
'pDX', 'pD_X', 'pX',
'pDY', 'pD_Y', 'pY',
'pDXY', 'pD_XY', 'pXY'])
DivergentPa... | [
"pfwrapper.PyPatternFinder",
"collections.namedtuple"
] | [((84, 210), 'collections.namedtuple', 'namedtuple', (['"""Pattern"""', "['base', 'sens', 'pBase', 'pAll', 'pDX', 'pD_X', 'pX', 'pDY', 'pD_Y', 'pY',\n 'pDXY', 'pD_XY', 'pXY']"], {}), "('Pattern', ['base', 'sens', 'pBase', 'pAll', 'pDX', 'pD_X', 'pX',\n 'pDY', 'pD_Y', 'pY', 'pDXY', 'pD_XY', 'pXY'])\n", (94, 210), ... |
#!/usr/bin/env python
import gtk, sys, os
mynumber="5555555555"
calnum=0
fakenum=0
def press(widget):
num = entry.get_text()
pnum = widget.get_label()
entry.set_text(num + pnum)
def send_press(widget):
print("Dialing: " + entry.get_text())
def add_call(widget):
callnum = entry.get_text()
entry.set_text("")
d... | [
"gtk.Table",
"gtk.Entry",
"gtk.Button",
"gtk.Window",
"gtk.main_quit",
"gtk.VBox",
"gtk.HBox",
"gtk.main"
] | [((396, 408), 'gtk.Window', 'gtk.Window', ([], {}), '()\n', (406, 408), False, 'import gtk, sys, os\n'), ((466, 476), 'gtk.VBox', 'gtk.VBox', ([], {}), '()\n', (474, 476), False, 'import gtk, sys, os\n'), ((499, 510), 'gtk.Entry', 'gtk.Entry', ([], {}), '()\n', (508, 510), False, 'import gtk, sys, os\n'), ((549, 574), ... |
from simple_rl.mdp.oomdp.OOMDPStateClass import OOMDPState
class TrenchOOMDPState(OOMDPState):
''' Class for Trench World States '''
def __init__(self, objects):
OOMDPState.__init__(self, objects=objects)
def get_agent_x(self):
return self.objects["agent"][0]["x"]
def get_agent_y(sel... | [
"simple_rl.mdp.oomdp.OOMDPStateClass.OOMDPState.__init__"
] | [((180, 222), 'simple_rl.mdp.oomdp.OOMDPStateClass.OOMDPState.__init__', 'OOMDPState.__init__', (['self'], {'objects': 'objects'}), '(self, objects=objects)\n', (199, 222), False, 'from simple_rl.mdp.oomdp.OOMDPStateClass import OOMDPState\n')] |
import json
file = open('buildings.json', 'r')
buildings = json.load(file)['data']
output = []
for building in buildlings:
temp = {}
temp["id"] = building["number"]
temp["name"] = {}
temp["name"]["value"] = building["name"]
output.append(temp) | [
"json.load"
] | [((60, 75), 'json.load', 'json.load', (['file'], {}), '(file)\n', (69, 75), False, 'import json\n')] |
import src.library as s_lib
# s_lib.update_team_table()
# s_lib.test_func()
# s_lib.update_result()
st = '2018-10-29'
end = '2019-05-23'
s_lib.update_period_result(st, end)
| [
"src.library.update_period_result"
] | [((140, 175), 'src.library.update_period_result', 's_lib.update_period_result', (['st', 'end'], {}), '(st, end)\n', (166, 175), True, 'import src.library as s_lib\n')] |
#!/usr/bin/env python
import os
import sys
import argparse
import requests
sys.path.append(os.path.join(os.path.dirname(__file__), '..'))
import messagebird
parser = argparse.ArgumentParser()
parser.add_argument('--accessKey', help='Access key for MessageBird API.', type=str, required=True)
parser.add_argument('--pho... | [
"messagebird.Client",
"os.path.dirname",
"argparse.ArgumentParser"
] | [((168, 193), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (191, 193), False, 'import argparse\n'), ((494, 531), 'messagebird.Client', 'messagebird.Client', (["args['accessKey']"], {}), "(args['accessKey'])\n", (512, 531), False, 'import messagebird\n'), ((105, 130), 'os.path.dirname', 'os.pa... |
# -*- coding: utf-8 -*-
import logging
from django.conf import settings
from django_redis import get_redis_connection
from uuid import uuid4
logger = logging.getLogger(__name__)
class LatestViewedStudies(object):
""" Interfaces with Redis to keep a list of latest viewed studies """
def __init__(self, use... | [
"logging.getLogger",
"django_redis.get_redis_connection",
"uuid.uuid4"
] | [((154, 181), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (171, 181), False, 'import logging\n'), ((461, 508), 'django_redis.get_redis_connection', 'get_redis_connection', (['settings.EDD_LATEST_CACHE'], {}), '(settings.EDD_LATEST_CACHE)\n', (481, 508), False, 'from django_redis import... |
#!/usr/bin/env python
# Copyright JS Foundation and other contributors, http://js.foundation
#
# 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.... | [
"argparse.ArgumentParser",
"os.access",
"os.path.join",
"os.path.isfile",
"itertools.chain.from_iterable",
"os.path.basename",
"sys.exit",
"os.path.abspath",
"warnings.warn",
"csv.reader"
] | [((907, 980), 'os.path.join', 'os.path.join', (['PROJECT_DIR', '"""jerry-core/lit/lit-unicode-conversions.inc.h"""'], {}), "(PROJECT_DIR, 'jerry-core/lit/lit-unicode-conversions.inc.h')\n", (919, 980), False, 'import os\n'), ((802, 827), 'os.path.abspath', 'os.path.abspath', (['__file__'], {}), '(__file__)\n', (817, 82... |
# Solution of;
# Project Euler Problem 465: Polar polygons
# https://projecteuler.net/problem=465
#
# The kernel of a polygon is defined by the set of points from which the
# entire polygon's boundary is visible. We define a polar polygon as a polygon
# for which the origin is strictly contained inside its kernel. F... | [
"timed.caller"
] | [((1483, 1517), 'timed.caller', 'timed.caller', (['dummy', 'n', 'i', 'prob_id'], {}), '(dummy, n, i, prob_id)\n', (1495, 1517), False, 'import timed\n')] |
#!/usr/bin/python
"""
GFS.py - GFS GRIB2 class
"""
# Stock modules
import sys
import os
import re
import logging
import traceback
import datetime
import collections
import operator
# Local modules
import error_codes
import utils
from dataset import dataset
LOG = logging.getLogger(__name__)
# gfs.t18z.pgrb2.1p00.f0... | [
"logging.getLogger",
"utils.error",
"datetime.datetime.strptime"
] | [((267, 294), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (284, 294), False, 'import logging\n'), ((1042, 1085), 'datetime.datetime.strptime', 'datetime.datetime.strptime', (['DTS', '"""%Y%m%d%H"""'], {}), "(DTS, '%Y%m%d%H')\n", (1068, 1085), False, 'import datetime\n'), ((1432, 1477),... |
from __future__ import unicode_literals
import frappe
from frappe.utils import date_diff, nowdate, add_days, format_datetime
from datetime import timedelta, datetime
def expire_doc_mail_notify():
# stuff to do every 10 minutes
today = nowdate()
employee_documents = frappe.db.get_list('Employee Documents',... | [
"frappe.db.get_all",
"frappe._",
"frappe.utils.nowdate",
"frappe.get_doc",
"datetime.datetime.today",
"frappe.db.get_list"
] | [((245, 254), 'frappe.utils.nowdate', 'nowdate', ([], {}), '()\n', (252, 254), False, 'from frappe.utils import date_diff, nowdate, add_days, format_datetime\n'), ((280, 426), 'frappe.db.get_list', 'frappe.db.get_list', (['"""Employee Documents"""'], {'fields': "['parent', 'doc_name', 'reminder_days', 'expire_date']", ... |
from flask import Flask
from flask import request
from flask import Response
from handling import Handler
import json
app = Flask(__name__)
INDEX_NAME = 'contacts'
PORT = 9200
handler = Handler(INDEX_NAME, port = PORT, wipe_index = True)
@app.route('/contact', methods=['GET','POST'])
def contact_without_name():
... | [
"json.dumps",
"flask.Response",
"handling.Handler",
"flask.Flask"
] | [((125, 140), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (130, 140), False, 'from flask import Flask\n'), ((189, 236), 'handling.Handler', 'Handler', (['INDEX_NAME'], {'port': 'PORT', 'wipe_index': '(True)'}), '(INDEX_NAME, port=PORT, wipe_index=True)\n', (196, 236), False, 'from handling import Handle... |
from node import Node
class Stack:
def __init__(self):
self.head = None
def __str__(self):
node = self.head
list = []
while node:
list.append(node.get_item())
node = node.get_next()
return str(list)
def is_empty(self):
return not self.head
def push(self, item):
if not self.head:
self.hea... | [
"node.Node"
] | [((324, 334), 'node.Node', 'Node', (['item'], {}), '(item)\n', (328, 334), False, 'from node import Node\n'), ((359, 380), 'node.Node', 'Node', (['item', 'self.head'], {}), '(item, self.head)\n', (363, 380), False, 'from node import Node\n')] |
import logging
import logging.handlers
"""
Returns a logging handler with a default format
"""
def get_logging_handler(log_filename):
handler = logging.handlers.RotatingFileHandler(log_filename, maxBytes=2*1024*1024, backupCount=5)
formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(name)s - %... | [
"logging.Formatter",
"logging.handlers.RotatingFileHandler"
] | [((155, 250), 'logging.handlers.RotatingFileHandler', 'logging.handlers.RotatingFileHandler', (['log_filename'], {'maxBytes': '(2 * 1024 * 1024)', 'backupCount': '(5)'}), '(log_filename, maxBytes=2 * 1024 * 1024,\n backupCount=5)\n', (191, 250), False, 'import logging\n'), ((259, 332), 'logging.Formatter', 'logging.... |
from queue import Queue
from typing import TYPE_CHECKING
from galaxy_crawler.crawl import Crawler
from galaxy_crawler.filters import DefaultFilter
from galaxy_crawler.filters.v1 import V1FilterEnum
from galaxy_crawler.models.engine import EngineType
from galaxy_crawler.models.dependeny_resolver import DependencyResolv... | [
"galaxy_crawler.filters.DefaultFilter",
"galaxy_crawler.queries.v1.V1QueryBuilder",
"galaxy_crawler.models.engine.EngineType.from_url",
"galaxy_crawler.models.engine.EngineType.from_env_var",
"galaxy_crawler.utils.mkdir",
"galaxy_crawler.queries.v1.V1QueryOrder.choices",
"galaxy_crawler.filters.v1.V1Fil... | [((997, 1004), 'queue.Queue', 'Queue', ([], {}), '()\n', (1002, 1004), False, 'from queue import Queue\n'), ((1151, 1168), 'galaxy_crawler.utils.mkdir', 'mkdir', (['output_dir'], {}), '(output_dir)\n', (1156, 1168), False, 'from galaxy_crawler.utils import mkdir\n'), ((1469, 1485), 'galaxy_crawler.queries.v1.V1QueryBui... |
import ipywidgets as widgets
import ipywidgets
from traitlets import Unicode
import traitlets
from traittypes import Array
import logging
import numpy as np
from .serialize import array_cube_png_serialization, array_serialization
from .transferfunction import *
import warnings
logger = logging.getLogger("ipyvolume")
... | [
"logging.getLogger",
"traitlets.Instance",
"traitlets.List",
"ipywidgets.FloatSlider",
"numpy.nanmin",
"ipywidgets.HBox",
"traittypes.Array",
"ipywidgets.register",
"numpy.nanmax",
"warnings.warn",
"ipyvolume.pylab.figure",
"traitlets.Unicode",
"traitlets.CInt",
"ipywidgets.jslink",
"tra... | [((289, 319), 'logging.getLogger', 'logging.getLogger', (['"""ipyvolume"""'], {}), "('ipyvolume')\n", (306, 319), False, 'import logging\n'), ((352, 389), 'ipywidgets.register', 'widgets.register', (['"""ipyvolume.Scatter"""'], {}), "('ipyvolume.Scatter')\n", (368, 389), True, 'import ipywidgets as widgets\n'), ((1748,... |
# Copyright (c) 2015 <NAME> <<EMAIL>>
# Author: <NAME> <<EMAIL>>
#
# Permission is hereby granted, free of charge, to any person obtaining a copy of
# this software and associated documentation files (the "Software"), to deal in
# the Software without restriction, including without limitation the rights to
# use, copy... | [
"fine_mapping_pipeline.utils.shell.run_command_return_output",
"logging.info"
] | [((3643, 3673), 'logging.info', 'logging.info', (['bcftools_command'], {}), '(bcftools_command)\n', (3655, 3673), False, 'import logging\n'), ((3708, 3763), 'fine_mapping_pipeline.utils.shell.run_command_return_output', 'run_command_return_output', (['bcftools_command'], {'shell': '(True)'}), '(bcftools_command, shell=... |
from src.requests.search_requests import search
from constants.search_bar_constants import GOOGLE_SEARCH_URL
def search_testcases(testcases):
for testcase in testcases:
response = search(GOOGLE_SEARCH_URL, testcase)
print(response.url)
print(response.ok)
print(response.status_code)... | [
"src.requests.search_requests.search"
] | [((194, 229), 'src.requests.search_requests.search', 'search', (['GOOGLE_SEARCH_URL', 'testcase'], {}), '(GOOGLE_SEARCH_URL, testcase)\n', (200, 229), False, 'from src.requests.search_requests import search\n')] |
"""
``$ drafttopic fetch_text -h``
::
Fetches text for labelings using a MediaWiki API.
Usage:
fetch_text --api-host=<url> [--labelings=<path>] [--output=<path>]
[--verbose]
Options:
-h --help Show this documentation.
--api-host=<url> ... | [
"logging.getLogger",
"itertools.islice",
"re.compile",
"concurrent.futures.ThreadPoolExecutor",
"sys.stderr.flush",
"revscoring.utilities.util.dump_observation",
"sys.stderr.write",
"revscoring.utilities.util.read_observations",
"mw.lib.title.normalize",
"docopt.docopt",
"mwapi.Session"
] | [((1080, 1107), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1097, 1107), False, 'import logging\n'), ((1122, 1151), 're.compile', 're.compile', (['"""#redirect"""', 're.I'], {}), "('#redirect', re.I)\n", (1132, 1151), False, 'import re\n'), ((1236, 1262), 'docopt.docopt', 'docopt', ([... |
import exodus
import os
from output_suppression import Suppressor
import numpy as np
def get_nodal_variable_values(filename, varname, step=1):
"""
Extracts nodal field data from exodus file and returns a numpy array of nodal values
"""
with Suppressor():
e = exodus.exodus(filename, array_type='... | [
"exodus.copy_mesh",
"os.path.isfile",
"output_suppression.Suppressor",
"exodus.exodus",
"exodus.add_variables",
"os.remove"
] | [((1166, 1196), 'os.path.isfile', 'os.path.isfile', (['outputfilename'], {}), '(outputfilename)\n', (1180, 1196), False, 'import os\n'), ((1772, 1802), 'os.path.isfile', 'os.path.isfile', (['outputfilename'], {}), '(outputfilename)\n', (1786, 1802), False, 'import os\n'), ((2729, 2759), 'os.path.isfile', 'os.path.isfil... |
# coding: utf-8
from __future__ import absolute_import
from datetime import date, datetime # noqa: F401
from typing import List, Dict # noqa: F401
from swagger_server.models.base_model_ import Model
from swagger_server import util
class PreferencesProfilePeople(Model):
"""NOTE: This class is auto generated b... | [
"swagger_server.util.deserialize_model"
] | [((3116, 3149), 'swagger_server.util.deserialize_model', 'util.deserialize_model', (['dikt', 'cls'], {}), '(dikt, cls)\n', (3138, 3149), False, 'from swagger_server import util\n')] |
# pylint: disable=invalid-name
import os
import platform
from flask import Flask
from flask import render_template, request, send_from_directory
from flask_cors import CORS
import pandas as pd
from app.ABSA import AspectsBased
from app.scrapper import amazonScrapper
EXTERNALS_DIR = os.path.realpath(os.path.join(__fil... | [
"flask.render_template",
"flask.send_from_directory",
"flask_cors.CORS",
"flask.Flask",
"os.path.join",
"platform.system",
"app.ABSA.AspectsBased",
"app.scrapper.amazonScrapper"
] | [((352, 451), 'flask.Flask', 'Flask', (['__name__'], {'static_folder': '"""./templates/build/static"""', 'template_folder': '"""./templates/build"""'}), "(__name__, static_folder='./templates/build/static', template_folder=\n './templates/build')\n", (357, 451), False, 'from flask import Flask\n'), ((447, 456), 'fla... |
from abc import ABC, abstractmethod
import logging
from typing import Any
from ROAR.utilities_module.module import Module
from ROAR.utilities_module.vehicle_models import Vehicle, VehicleControl
from collections import deque
import numpy as np
class ROARManiaPlanner(Module):
def __init__(self, agent, **kwargs):
... | [
"logging.getLogger",
"numpy.sign"
] | [((406, 433), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (423, 433), False, 'import logging\n'), ((3298, 3318), 'numpy.sign', 'np.sign', (['norm_offset'], {}), '(norm_offset)\n', (3305, 3318), True, 'import numpy as np\n')] |
"""
Defines a set of document formats.
(c) 2015 Massachusetts Institute of Technology
"""
# Native
import datetime
import hashlib
import os
# LO-PHI Automation
import lophi_automation.database.utils as utils
DELIMITER = '_'
def analysis_doc_uid(analyzer_name, analyzer_version, sample_uid):
"""
Ret... | [
"lophi_automation.database.utils.calculate_sha1",
"os.path.getsize",
"lophi_automation.database.utils.calculate_combined_hash",
"datetime.datetime.utcnow",
"lophi_automation.database.utils.calculate_md5",
"datetime.datetime.now",
"lophi_automation.database.utils.calculate_sha512",
"lophi_automation.da... | [((1666, 1692), 'datetime.datetime.utcnow', 'datetime.datetime.utcnow', ([], {}), '()\n', (1690, 1692), False, 'import datetime\n'), ((3687, 3713), 'datetime.datetime.utcnow', 'datetime.datetime.utcnow', ([], {}), '()\n', (3711, 3713), False, 'import datetime\n'), ((5277, 5317), 'lophi_automation.database.utils.calcula... |
# Member.py
import discord
from discord.ext import commands
from discord.utils import get
import os
import mysql.connector
import isbnlib
from isbnlib import *
import asyncio
ROLE = "Book Worm"
def initdb():
return mysql.connector.connect(
host = os.getenv('HOST'),
user = os.geten... | [
"discord.Colour.green",
"discord.ext.commands.command",
"os.getenv"
] | [((907, 925), 'discord.ext.commands.command', 'commands.command', ([], {}), '()\n', (923, 925), False, 'from discord.ext import commands\n'), ((2296, 2314), 'discord.ext.commands.command', 'commands.command', ([], {}), '()\n', (2312, 2314), False, 'from discord.ext import commands\n'), ((4911, 4929), 'discord.ext.comma... |
from django.contrib.contenttypes.models import ContentType
from nautobot.dcim.models import Site
from nautobot.extras.choices import CustomFieldTypeChoices
from nautobot.extras.jobs import Job
from nautobot.extras.models import CustomField
class TestCreateSiteWithCustomField(Job):
class Meta:
name = "Sit... | [
"nautobot.dcim.models.Site.objects.create",
"django.contrib.contenttypes.models.ContentType.objects.get_for_model",
"nautobot.extras.models.CustomField.objects.create"
] | [((451, 490), 'django.contrib.contenttypes.models.ContentType.objects.get_for_model', 'ContentType.objects.get_for_model', (['Site'], {}), '(Site)\n', (484, 490), False, 'from django.contrib.contenttypes.models import ContentType\n'), ((504, 599), 'nautobot.extras.models.CustomField.objects.create', 'CustomField.object... |
from collections import namedtuple
import numpy as np
import pandas as pd
import rdkit.Chem as Chem
from tqdm import tqdm
from neural_fingerprint import NFPRegressor
from neural_fingerprint.chemutils import rf_evaluation
from neural_fingerprint.models.ecfp import ECFP
max_val = 1000
train_idx = 800
def read_data(m... | [
"sklearn.gaussian_process.GaussianProcessRegressor",
"neural_fingerprint.chemutils.rf_evaluation",
"numpy.ones",
"matplotlib.pyplot.pcolor",
"matplotlib.pyplot.colorbar",
"rdkit.Chem.MolFromSmiles",
"tqdm.tqdm",
"neural_fingerprint.NFPRegressor",
"sklearn.manifold.TSNE",
"numpy.linspace",
"numpy... | [((354, 400), 'pandas.read_table', 'pd.read_table', (['"""./data/train.txt"""'], {'header': 'None'}), "('./data/train.txt', header=None)\n", (367, 400), True, 'import pandas as pd\n'), ((414, 464), 'pandas.read_table', 'pd.read_table', (['"""./data/train.logP-SA"""'], {'header': 'None'}), "('./data/train.logP-SA', head... |
#
# core/urls.py
#
# Author: <NAME>
#
from django.conf.urls import include
from django.contrib.auth.decorators import login_required
from django.urls import path
from . import views
urlpatterns = [
path('', login_required(views.index), name='index'),
path('libraries/', login_required(views.libraries), name=... | [
"django.contrib.auth.decorators.login_required"
] | [((215, 242), 'django.contrib.auth.decorators.login_required', 'login_required', (['views.index'], {}), '(views.index)\n', (229, 242), False, 'from django.contrib.auth.decorators import login_required\n'), ((282, 313), 'django.contrib.auth.decorators.login_required', 'login_required', (['views.libraries'], {}), '(views... |
#!/usr/bin/python
# -*- coding: utf-8 -*-
from collections import namedtuple
import queue
Item = namedtuple("Item", ['index', 'value', 'weight', 'density'])
# Node = namedtuple("Node", ["level", "profit", "bound", "weight"])
class Node(object):
def __init__(self, level=-1, profit=0, weight=0, bound=0):
... | [
"queue.Queue",
"collections.namedtuple"
] | [((99, 158), 'collections.namedtuple', 'namedtuple', (['"""Item"""', "['index', 'value', 'weight', 'density']"], {}), "('Item', ['index', 'value', 'weight', 'density'])\n", (109, 158), False, 'from collections import namedtuple\n'), ((3468, 3481), 'queue.Queue', 'queue.Queue', ([], {}), '()\n', (3479, 3481), False, 'im... |
import os
from pathlib import Path
def make_backup(c, file):
if file.exists() and not file.is_symlink():
file_backup = Path('{}.orig'.format(file))
if not file_backup.exists():
c.run('mv -f {} {}'.format(file, file_backup))
return True
return False
def symlink(c, sou... | [
"pathlib.Path.cwd",
"pathlib.Path"
] | [((367, 377), 'pathlib.Path.cwd', 'Path.cwd', ([], {}), '()\n', (375, 377), False, 'from pathlib import Path\n'), ((546, 563), 'pathlib.Path', 'Path', (['cwd', 'source'], {}), '(cwd, source)\n', (550, 563), False, 'from pathlib import Path\n'), ((404, 421), 'pathlib.Path', 'Path', (['destination'], {}), '(destination)\... |
import importlib
import os
import sys
from typing import Any, Callable, Optional
from mkdocs.config import Config, config_options
from mkdocs.livereload import LiveReloadServer
from mkdocs.plugins import BasePlugin
from .collectors import ModuleCollector
class Plugin(BasePlugin):
"""
MkDocs Plugin class.
... | [
"mkdocs.config.config_options.Type",
"sys.path.append",
"importlib.import_module",
"os.getcwd"
] | [((1914, 1925), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (1923, 1925), False, 'import os\n'), ((456, 495), 'mkdocs.config.config_options.Type', 'config_options.Type', (['str'], {'required': '(True)'}), '(str, required=True)\n', (475, 495), False, 'from mkdocs.config import Config, config_options\n'), ((519, 557), 'm... |
# _*_ encoding: utf-8 _*_
__author__ = 'nzb'
__date__ = '2020/6/6 17:47'
__doc__ = "二值化（Thresholding）"
import cv2
import numpy as np
# 计算： y={0 (if y<128 ) 255 (else)
def Grayscale(img):
b = img[:,:,0].copy()
g = img[:,:,1].copy()
r = img[:,:,2].copy()
ret = 0.2126 * r + 0.7152 * g + 0.0722 * b
... | [
"cv2.imread",
"cv2.waitKey",
"cv2.destroyAllWindows",
"cv2.imshow"
] | [((579, 602), 'cv2.imshow', 'cv2.imshow', (['"""ret"""', 'img2'], {}), "('ret', img2)\n", (589, 602), False, 'import cv2\n'), ((604, 618), 'cv2.waitKey', 'cv2.waitKey', (['(0)'], {}), '(0)\n', (615, 618), False, 'import cv2\n'), ((619, 642), 'cv2.destroyAllWindows', 'cv2.destroyAllWindows', ([], {}), '()\n', (640, 642)... |
"""Test for pretty format table from jsons."""
from datetime import datetime
from tabulate import tabulate
from ecs_tasks_ops import pretty_json
from ecs_tasks_ops import pretty_table
def test_tabulate_list_json_empty():
"""Test empty data."""
out = pretty_table.tabulate_list_json()
assert "No data to s... | [
"ecs_tasks_ops.pretty_json.DateTimeEncoder",
"ecs_tasks_ops.pretty_table.tabulate_list_json_keys",
"tabulate.tabulate",
"ecs_tasks_ops.pretty_table.tabulate_list_json",
"datetime.datetime.now",
"ecs_tasks_ops.pretty_json.dumps"
] | [((262, 295), 'ecs_tasks_ops.pretty_table.tabulate_list_json', 'pretty_table.tabulate_list_json', ([], {}), '()\n', (293, 295), False, 'from ecs_tasks_ops import pretty_table\n'), ((460, 512), 'ecs_tasks_ops.pretty_table.tabulate_list_json', 'pretty_table.tabulate_list_json', ([], {'empty_msg': 'empty_msg'}), '(empty_m... |
import logging
import socketserver
import threading
from robottelemetryservice.infrastructure.serialisation import serializer
from robottelemetryservice.infrastructure.configuration import application
log=logging.getLogger(__name__)
measurement_repository=application.get_measurement_repository()
class UDPMeasurementE... | [
"logging.getLogger",
"robottelemetryservice.infrastructure.configuration.application.get_measurement_repository"
] | [((206, 233), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (223, 233), False, 'import logging\n'), ((257, 297), 'robottelemetryservice.infrastructure.configuration.application.get_measurement_repository', 'application.get_measurement_repository', ([], {}), '()\n', (295, 297), False, 'fr... |
import base64
import os
import unittest
from unittest.mock import patch
from click.testing import CliRunner
from keeper_secrets_manager_core.core import SecretsManager
from keeper_secrets_manager_core.storage import InMemoryKeyValueStorage
from keeper_secrets_manager_core import mock
from keeper_secrets_manager_core.mo... | [
"configparser.ConfigParser",
"keeper_secrets_manager_core.mock.MockConfig.make_base64",
"unittest.main",
"unittest.mock.patch",
"re.search",
"os.path.exists",
"keeper_secrets_manager_core.storage.InMemoryKeyValueStorage",
"json.dumps",
"keeper_secrets_manager_core.mock.Response",
"os.unlink",
"t... | [((14095, 14110), 'unittest.main', 'unittest.main', ([], {}), '()\n', (14108, 14110), False, 'import unittest\n'), ((653, 664), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (662, 664), False, 'import os\n'), ((689, 718), 'tempfile.TemporaryDirectory', 'tempfile.TemporaryDirectory', ([], {}), '()\n', (716, 718), False, '... |
import os
import pytest
from unittest import mock
from breaking_changes import inspector
from tests import mod
TEST_ROOT = os.path.dirname(__file__)
BASE_ROOT = os.path.abspath(os.path.join(TEST_ROOT, '..'))
def relative(subpath: str) -> str:
return os.path.abspath(os.path.join(TEST_ROOT, subpath))
def func... | [
"breaking_changes.inspector.public_interface",
"breaking_changes.inspector.module_transform",
"os.path.join",
"os.path.dirname",
"pytest.mark.parametrize",
"breaking_changes.inspector.function_args"
] | [((127, 152), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (142, 152), False, 'import os\n'), ((716, 830), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (["('pkg_name', 'packages')", "[('package1', ['a', 'b']), ('package2', ['a', 'nested.c'])]"], {}), "(('pkg_name', 'packages'), [('... |
import logging
from logging.handlers import RotatingFileHandler
from flask.logging import default_handler
from app import app
if __name__ == '__main__':
handler = RotatingFileHandler(filename='./log/app.log', maxBytes=1048576, backupCount=3)
formatter = logging.Formatter(fmt='%(asctime)s - %(name)s[line:%(line... | [
"app.app.run",
"logging.Formatter",
"logging.handlers.RotatingFileHandler",
"app.app.logger.addHandler",
"flask.logging.default_handler.setLevel"
] | [((168, 246), 'logging.handlers.RotatingFileHandler', 'RotatingFileHandler', ([], {'filename': '"""./log/app.log"""', 'maxBytes': '(1048576)', 'backupCount': '(3)'}), "(filename='./log/app.log', maxBytes=1048576, backupCount=3)\n", (187, 246), False, 'from logging.handlers import RotatingFileHandler\n'), ((263, 395), '... |
#!/usr/bin/env python
# manual
"""
This script allows you to manually control the simulator or Duckiebot
using the keyboard arrows.
"""
import os
os.sys.path.append("../../gym-duckietown")
import cv2
import sys
import argparse
import pyglet
from pyglet.window import key
import numpy as np
import gym
import gym_duckie... | [
"PIL.Image.fromarray",
"pyglet.window.key.KeyStateHandler",
"pyglet.clock.schedule_interval",
"pyglet.app.run",
"NaiveLaneDetection.NaiveLaneDetection",
"os.sys.path.append",
"cv2.imshow",
"numpy.array",
"cv2.addWeighted",
"cv2.cvtColor",
"sys.exit",
"cv2.waitKey",
"cv2.namedWindow"
] | [((147, 189), 'os.sys.path.append', 'os.sys.path.append', (['"""../../gym-duckietown"""'], {}), "('../../gym-duckietown')\n", (165, 189), False, 'import os\n'), ((1290, 1346), 'numpy.array', 'np.array', (['[[(0, 200), (640, 200), (640, 480), (0, 480)]]'], {}), '([[(0, 200), (640, 200), (640, 480), (0, 480)]])\n', (1298... |
from collections import Counter, defaultdict
def fizz_buzz_counter():
values = []
for i in range(1, 101):
if i % 3 == 0 and i % 5 == 0:
values.append("fizzbuzz")
elif i % 3 == 0:
values.append("fizz")
elif i % 5 == 0:
values.append("buzz")
els... | [
"collections.Counter",
"collections.defaultdict"
] | [((368, 383), 'collections.Counter', 'Counter', (['values'], {}), '(values)\n', (375, 383), False, 'from collections import Counter, defaultdict\n'), ((428, 444), 'collections.defaultdict', 'defaultdict', (['int'], {}), '(int)\n', (439, 444), False, 'from collections import Counter, defaultdict\n')] |
import base64
import itertools
import json
import requests
from presqt.json_schemas.schema_handlers import schema_validator
from presqt.targets.github.utilities import validation_check
from presqt.targets.github.utilities.utils.upload_extra_metadata import upload_extra_metadata
from presqt.utilities import PresQTError... | [
"itertools.chain",
"json.loads",
"base64.b64encode",
"json.dumps",
"presqt.targets.github.utilities.validation_check",
"base64.b64decode",
"presqt.targets.github.utilities.utils.upload_extra_metadata.upload_extra_metadata",
"presqt.json_schemas.schema_handlers.schema_validator"
] | [((742, 765), 'presqt.targets.github.utilities.validation_check', 'validation_check', (['token'], {}), '(token)\n', (758, 765), False, 'from presqt.targets.github.utilities import validation_check\n'), ((1601, 1648), 'base64.b64decode', 'base64.b64decode', (["metadata_file_data['content']"], {}), "(metadata_file_data['... |
#/usr/bin/env python
#-*- coding: utf-8 -*-
#Refer http://www.wooyun.org/bugs/wooyun-2015-0135532
#__Author__ = 上善若水
#_PlugName_ = tianrongxin_sql Plugin
#_FileName_ = tianrongxin_sql.py
import re
def assign(service, arg):
if service == "topsec":
return True, arg
def audit(arg):
paylo... | [
"re.findall"
] | [((628, 669), 're.findall', 're.findall', (['"""thrown in <b>(.*?)</b>"""', 'res'], {}), "('thrown in <b>(.*?)</b>', res)\n", (638, 669), False, 'import re\n')] |
#!/usr/bin/env python3
import hashlib
import re
import requests
import sys
from pprint import pprint as pp
from .exceptions import PCloudException
from .connection import AbstractPCloudConnection
from .pcloudbin import PCloudBinaryConnection
PCLOUD_SERVER_SUFFIX = '.pcloud.com' # only allow downloads from pcloud s... | [
"re.sub",
"pprint.pprint",
"requests.get"
] | [((7559, 7650), 'requests.get', 'requests.get', (['url'], {'stream': '(True)', 'allow_redirects': '(False)', 'timeout': 'self.connection.timeout'}), '(url, stream=True, allow_redirects=False, timeout=self.\n connection.timeout)\n', (7571, 7650), False, 'import requests\n'), ((3743, 3782), 'pprint.pprint', 'pp', (['(... |
import math
import os
import time
import numpy as np
from torch.utils.tensorboard import SummaryWriter
import utils.loss as loss
import utils.tensorboard as utb
def get_probs(length, exp):
probs = (np.arange(1, length + 1) / 100) ** exp
last_x = int(0.9 * length)
probs[last_x:] = probs[last_x]
retur... | [
"numpy.random.normal",
"torch.utils.tensorboard.SummaryWriter",
"numpy.tile",
"math.ceil",
"utils.loss.PSNR",
"numpy.log",
"numpy.max",
"numpy.argsort",
"numpy.sum",
"numpy.linspace",
"utils.tensorboard.load_event_accumulator",
"numpy.zeros",
"numpy.exp",
"numpy.transpose",
"time.time",
... | [((1385, 1412), 'numpy.linspace', 'np.linspace', (['(0.01)', '(0.3)', '(200)'], {}), '(0.01, 0.3, 200)\n', (1396, 1412), True, 'import numpy as np\n'), ((733, 766), 'utils.tensorboard.load_loglikelihood', 'utb.load_loglikelihood', (['event_acc'], {}), '(event_acc)\n', (755, 766), True, 'import utils.tensorboard as utb\... |
"""
References:
https://fdc.nal.usda.gov/api-guide.html
"""
import json
import decouple
import requests
from datatrans import utils
from datatrans.fooddata import search
__all__ = ['send_food_search_api_request', 'send_food_detail_api_request']
def send_food_search_api_request(
criteria: search.reques... | [
"json.dumps",
"decouple.config",
"datatrans.utils.snake_to_camel",
"requests.get"
] | [((368, 417), 'decouple.config', 'decouple.config', (['"""DATA_GOV_API_KEY"""', '"""MY_API_KEY"""'], {}), "('DATA_GOV_API_KEY', 'MY_API_KEY')\n", (383, 417), False, 'import decouple\n'), ((1891, 1940), 'decouple.config', 'decouple.config', (['"""DATA_GOV_API_KEY"""', '"""MY_API_KEY"""'], {}), "('DATA_GOV_API_KEY', 'MY_... |
#!/usr/bin/python3
# -*- coding: utf-8 -*-
# @Time : 2019/5/18 10:20
# @Author : chensw、wangwei
# @File : model_fusion.py
# @Describe: 标明文件实现的功能
# @Modify : 修改的地方
import pandas as pd
# Step3:模型投票融合
# 读取5个模型输出的预测概率文件
predict_1_4 = pd.read_csv('../data/output/predict/prediction_1_4.csv')
predict_2... | [
"pandas.merge",
"pandas.read_csv"
] | [((253, 309), 'pandas.read_csv', 'pd.read_csv', (['"""../data/output/predict/prediction_1_4.csv"""'], {}), "('../data/output/predict/prediction_1_4.csv')\n", (264, 309), True, 'import pandas as pd\n'), ((325, 381), 'pandas.read_csv', 'pd.read_csv', (['"""../data/output/predict/prediction_2_4.csv"""'], {}), "('../data/o... |
import unittest
# Run tests without using GPU
import os
os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
os.environ['TEST'] = "1"
import sys
from pathlib import Path
TEST_DIR = str(Path(__file__).parent.resolve())
BASE_DIR = str(Path(__file__).parent.parent.resolve())
sys.path.append(BASE_DIR)
from core.filters import Publ... | [
"core.api.IndependentClaimsRequest",
"core.api.ForwardCitationsRequest",
"core.api.DrawingRequest",
"unittest.main",
"core.api.CitationsRequest",
"core.api.ConceptVectorRequest",
"sys.path.append",
"core.api.AggregatedCitationsRequest",
"core.api.TitleRequest",
"core.api.OneClaimRequest",
"core.... | [((264, 289), 'sys.path.append', 'sys.path.append', (['BASE_DIR'], {}), '(BASE_DIR)\n', (279, 289), False, 'import sys\n'), ((19348, 19363), 'unittest.main', 'unittest.main', ([], {}), '()\n', (19361, 19363), False, 'import unittest\n'), ((2285, 2297), 'core.api.APIRequest', 'APIRequest', ([], {}), '()\n', (2295, 2297)... |
#%% Setup
from matplotlib import rc
rc("font", **{"family": "serif", "serif": ["Computer Modern Roman"], "size": 20})
rc("text", usetex=True)
import os
import numpy as np
import mpmath as mp
import matplotlib.pyplot as plt
from scipy.special import lambertw
from scipy import optimize
# path = os.path.expanduser(
# ... | [
"matplotlib.pyplot.xticks",
"matplotlib.pyplot.ylabel",
"scipy.special.lambertw",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"numpy.log",
"matplotlib.pyplot.fill_between",
"numpy.linspace",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.yticks",
"matplotlib.rc",
"scipy.optimize.root... | [((37, 122), 'matplotlib.rc', 'rc', (['"""font"""'], {}), "('font', **{'family': 'serif', 'serif': ['Computer Modern Roman'], 'size':\n 20})\n", (39, 122), False, 'from matplotlib import rc\n'), ((119, 142), 'matplotlib.rc', 'rc', (['"""text"""'], {'usetex': '(True)'}), "('text', usetex=True)\n", (121, 142), False, ... |
#!/usr/bin/env python3
import cudasift
import cv2
import numpy as np
from profiling import TaggedTimer
def main():
sift = cudasift.PyCudaSift(dev_num=0)
timr = TaggedTimer()
filename = "../data/CY_279b46b9_1575825158217_1575825184058.jpg"
# filename = "/home/jfinken/projects/here/sp/jfinken/faiss_gp... | [
"numpy.asarray",
"cudasift.i_align_up",
"cudasift.PyCudaSift",
"profiling.TaggedTimer",
"cv2.imread"
] | [((129, 159), 'cudasift.PyCudaSift', 'cudasift.PyCudaSift', ([], {'dev_num': '(0)'}), '(dev_num=0)\n', (148, 159), False, 'import cudasift\n'), ((171, 184), 'profiling.TaggedTimer', 'TaggedTimer', ([], {}), '()\n', (182, 184), False, 'from profiling import TaggedTimer\n'), ((349, 391), 'cv2.imread', 'cv2.imread', (['fi... |
# - *- coding: utf- 8 - *-
#decorator fonksiyonlar, pythonda fonksiyonlarımızın dinamik olarak ekstra özellik ekledigimiz fonksiyonlarıdr
#kod tekrarını engeller
#flask django gibi frameworklerde cok kullanılır
import time
def calculate_time(func):
def wrapper(numbers):
start = time.time()
resul... | [
"time.time"
] | [((294, 305), 'time.time', 'time.time', ([], {}), '()\n', (303, 305), False, 'import time\n'), ((353, 364), 'time.time', 'time.time', ([], {}), '()\n', (362, 364), False, 'import time\n')] |
#!/usr/bin/env python
"""
Perform the Mann-Whitney U test, the Kolmogorov-Smirnov test, and the Student's
t-test for the following ensembles:
- GPU double precision (reference & control)
- CPU double precision
- GPU single precision
- GPU double precision with additional explicit diffusion
Make sure to compile the cp... | [
"numpy.mean",
"pickle.dump",
"numpy.sqrt",
"kolmogorov_smirnov.ks",
"numpy.max",
"mannwhitneyu.mwu",
"numpy.zeros",
"numpy.quantile",
"numpy.min",
"xarray.open_dataset",
"numpy.arange"
] | [((2243, 2267), 'xarray.open_dataset', 'xr.open_dataset', (['fname_r'], {}), '(fname_r)\n', (2258, 2267), True, 'import xarray as xr\n'), ((2292, 2316), 'xarray.open_dataset', 'xr.open_dataset', (['fname_c'], {}), '(fname_c)\n', (2307, 2316), True, 'import xarray as xr\n'), ((2343, 2369), 'xarray.open_dataset', 'xr.ope... |
#!/usr/bin/env python
"""Tests for Yara flows."""
import functools
import psutil
import yara
import yara_procdump
from grr.client.client_actions import tempfiles
from grr.client.client_actions import yara_actions
from grr.lib import flags
from grr.lib import utils
from grr.lib.rdfvalues import client as rdf_client
fr... | [
"psutil.NoSuchProcess",
"grr.lib.flags.StartMain",
"grr.server.aff4.FACTORY.Open",
"grr.test_lib.test_lib.main",
"grr.test_lib.test_lib.FakeTime",
"psutil.Process.old_target",
"yara.TimeoutError",
"functools.partial",
"grr.test_lib.flow_test_lib.TestFlowHelper",
"grr.test_lib.action_mocks.ActionMo... | [((9321, 9340), 'grr.test_lib.test_lib.main', 'test_lib.main', (['argv'], {}), '(argv)\n', (9334, 9340), False, 'from grr.test_lib import test_lib\n'), ((9372, 9393), 'grr.lib.flags.StartMain', 'flags.StartMain', (['main'], {}), '(main)\n', (9387, 9393), False, 'from grr.lib import flags\n'), ((1955, 2008), 'psutil.NoS... |
import os
import csv
import pandas as pd
import numpy as np
import test
#gets the path of current working directory
CWD = os.getcwd()
def Load_Data (csvpath):
try:
datapath = CWD + csvpath
df= pd.read_csv(datapath)
except:
print("Error with reading csv: ", csvpath)
print (df.hea... | [
"pandas.read_csv",
"os.getcwd"
] | [((125, 136), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (134, 136), False, 'import os\n'), ((218, 239), 'pandas.read_csv', 'pd.read_csv', (['datapath'], {}), '(datapath)\n', (229, 239), True, 'import pandas as pd\n'), ((595, 625), 'pandas.read_csv', 'pd.read_csv', (['advantix_raw_path'], {}), '(advantix_raw_path)\n',... |
from matplotlib.gridspec import GridSpec
import matplotlib.pyplot as plt
import numpy as np
import matplotlib
import math
from ._default_matplotlib_figure_dimensions import _default_matplotlib_figure_dimensions
def _calculate_nrows(nplots, ncols):
return math.ceil(nplots / ncols)
def _initialize_plot_with_dimens... | [
"math.ceil",
"numpy.ones",
"numpy.any",
"numpy.array",
"matplotlib.pyplot.figure",
"matplotlib.gridspec.GridSpec"
] | [((261, 286), 'math.ceil', 'math.ceil', (['(nplots / ncols)'], {}), '(nplots / ncols)\n', (270, 286), False, 'import math\n'), ((980, 1014), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': 'fig_dimensions'}), '(figsize=fig_dimensions)\n', (990, 1014), True, 'import matplotlib.pyplot as plt\n'), ((1783, 1906)... |
from Section01_SOLID.OpenClosePrinciple.BetterFilter import BetterFilter
from Section01_SOLID.OpenClosePrinciple.Color import Color
from Section01_SOLID.OpenClosePrinciple.ColorSpecification import ColorSpecification
from Section01_SOLID.OpenClosePrinciple.Product import Product
from Section01_SOLID.OpenClosePrinciple.... | [
"Section01_SOLID.OpenClosePrinciple.ColorSpecification.ColorSpecification",
"Section01_SOLID.OpenClosePrinciple.Product.Product",
"Section01_SOLID.OpenClosePrinciple.ProductFilter.ProductFilter",
"Section01_SOLID.OpenClosePrinciple.BetterFilter.BetterFilter",
"Section01_SOLID.OpenClosePrinciple.SizeSpecific... | [((783, 824), 'Section01_SOLID.OpenClosePrinciple.Product.Product', 'Product', (['"""Apple"""', 'Color.GREEN', 'Size.SMALL'], {}), "('Apple', Color.GREEN, Size.SMALL)\n", (790, 824), False, 'from Section01_SOLID.OpenClosePrinciple.Product import Product\n'), ((832, 872), 'Section01_SOLID.OpenClosePrinciple.Product.Prod... |
# open external links in a new window
from django.utils.html import escape
from wagtail.contrib.modeladmin.helpers import ButtonHelper
from wagtail.contrib.modeladmin.mixins import ThumbnailMixin
from wagtail.contrib.modeladmin.options import ModelAdmin, modeladmin_register
from wagtail.core import hooks
from wagtail.... | [
"wagtail.contrib.modeladmin.options.modeladmin_register",
"django.utils.html.escape",
"wagtail.core.hooks.register"
] | [((982, 1027), 'wagtail.core.hooks.register', 'hooks.register', (['"""register_rich_text_features"""'], {}), "('register_rich_text_features')\n", (996, 1027), False, 'from wagtail.core import hooks\n'), ((1130, 1178), 'wagtail.core.hooks.register', 'hooks.register', (['"""construct_page_listing_buttons"""'], {}), "('co... |
import sublime, sublime_plugin
import os
try:
# ST3
from ..apis.core import Core
except (ImportError, ValueError):
# ST2
from apis.core import Core
# Completion
class ERBAutocompleteListener(sublime_plugin.EventListener):
def on_query_completions(self, view, prefix, locations):
core = Core(... | [
"apis.core.Core"
] | [((315, 321), 'apis.core.Core', 'Core', ([], {}), '()\n', (319, 321), False, 'from apis.core import Core\n'), ((1187, 1193), 'apis.core.Core', 'Core', ([], {}), '()\n', (1191, 1193), False, 'from apis.core import Core\n')] |
from tkinter import *
from tkinter import ttk
from Controller import controleBanco
# Tela de relatorios em xlsx
def TelaRelatorio(tela):
# Cria a tela de relatorios
telaRelatorio = Toplevel(tela)
telaRelatorio.title('RELATORIO')
telaRelatorio.geometry('500x500+620+120')
telaRelatorio['bg'] = 'gr... | [
"Controller.controleBanco.ControleLerDados",
"Controller.controleBanco.BuscaPrimeiro",
"Controller.controleBanco.BuscaDadosPeloId",
"Controller.controleBanco.BuscaUltimo",
"Controller.controleBanco.EscreveNoExcel",
"tkinter.ttk.Treeview"
] | [((440, 470), 'Controller.controleBanco.BuscaPrimeiro', 'controleBanco.BuscaPrimeiro', (['(3)'], {}), '(3)\n', (467, 470), False, 'from Controller import controleBanco\n'), ((484, 512), 'Controller.controleBanco.BuscaUltimo', 'controleBanco.BuscaUltimo', (['(3)'], {}), '(3)\n', (509, 512), False, 'from Controller impor... |
# -*- coding: utf-8 -*-
from runScraper import test, scrapeRecipeUrl
from parser import parseIngredients
test('https://healthyfitnessmeals.com/artichoke-stuffed-chicken/')
# ingredient = parseIngredients(
# ["cans refrigerated crescent dinner rolls"])
# print(ingredient)
# print(scrapeRecipeUrl)
| [
"runScraper.test"
] | [((107, 173), 'runScraper.test', 'test', (['"""https://healthyfitnessmeals.com/artichoke-stuffed-chicken/"""'], {}), "('https://healthyfitnessmeals.com/artichoke-stuffed-chicken/')\n", (111, 173), False, 'from runScraper import test, scrapeRecipeUrl\n')] |
# Generated by Django 2.2.13 on 2020-10-21 14:39
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('houses', '0002_house_user_id'),
]
operations = [
migrations.RenameField(
model_name='house',
old_name='user_id',
... | [
"django.db.migrations.RenameField"
] | [((222, 301), 'django.db.migrations.RenameField', 'migrations.RenameField', ([], {'model_name': '"""house"""', 'old_name': '"""user_id"""', 'new_name': '"""user"""'}), "(model_name='house', old_name='user_id', new_name='user')\n", (244, 301), False, 'from django.db import migrations\n')] |
from django.contrib.auth import authenticate, login, logout
from django.contrib.auth.decorators import login_required
from django.db import IntegrityError
from django.http import HttpResponse, HttpResponseRedirect
from django.shortcuts import render
from django.urls import reverse
from .models import User, Listing, Bi... | [
"django.shortcuts.render",
"django.contrib.auth.authenticate",
"django.contrib.auth.login",
"django.urls.reverse",
"django.contrib.auth.logout"
] | [((401, 463), 'django.shortcuts.render', 'render', (['request', '"""auctions/index.html"""', "{'listings': listings}"], {}), "(request, 'auctions/index.html', {'listings': listings})\n", (407, 463), False, 'from django.shortcuts import render\n'), ((577, 646), 'django.shortcuts.render', 'render', (['request', '"""aucti... |
import sys
import logging
from face_client import face_client
from face_client.api_proxy import FaceApiProxy
from face_client.camera_controller import CameraController
from face_client.image_displayer import ImageDisplayer
def main(argv):
client = face_client.FaceClient(CameraController(), ImageDisplayer(), Face... | [
"face_client.api_proxy.FaceApiProxy",
"face_client.image_displayer.ImageDisplayer",
"logging.exception",
"face_client.camera_controller.CameraController",
"sys.exit"
] | [((278, 296), 'face_client.camera_controller.CameraController', 'CameraController', ([], {}), '()\n', (294, 296), False, 'from face_client.camera_controller import CameraController\n'), ((298, 314), 'face_client.image_displayer.ImageDisplayer', 'ImageDisplayer', ([], {}), '()\n', (312, 314), False, 'from face_client.im... |
"""
Categorize mapping between Dutch and English into polysemy profiles
Usage:
categorize_lemma_to_lemma_polysemy.py --config_path=<config_path> --input_folder=<input_folder> --output_folder=<output_folder> --rbn_pos=<rbn_pos> --fn_pos=<fn_pos> --verbose=<verbose>
Options:
--config_path=<config_path>
--inpu... | [
"os.path.exists",
"pickle.dump",
"pathlib.Path",
"graph_utils.get_paths_from_rbn_to_fn",
"datetime.datetime.now",
"collections.defaultdict",
"load_utils.load_python_module",
"networkx.read_gpickle",
"docopt.docopt"
] | [((1071, 1183), 'load_utils.load_python_module', 'load_utils.load_python_module', ([], {'module_path': '"""../resources/ODWN_Reader"""', 'module_name': '"""odwn_classes"""', 'verbose': '(1)'}), "(module_path='../resources/ODWN_Reader',\n module_name='odwn_classes', verbose=1)\n", (1100, 1183), False, 'import load_ut... |
#!/usr/bin/env python3
"""
corrections.py: Script to apply corrections to the images.
"""
import os
from argparse import ArgumentParser
from datetime import date, datetime
from typing import Optional, Sequence
import numpy as np
from astropy.io import fits
from dresscode.utils import load_config
def main(argv: Op... | [
"numpy.abs",
"numpy.full_like",
"astropy.io.fits.PrimaryHDU",
"argparse.ArgumentParser",
"dresscode.utils.load_config",
"numpy.where",
"numpy.std",
"numpy.nanmedian",
"os.path.isfile",
"numpy.sum",
"datetime.date",
"os.path.basename",
"astropy.io.fits.open",
"numpy.log1p"
] | [((371, 387), 'argparse.ArgumentParser', 'ArgumentParser', ([], {}), '()\n', (385, 387), False, 'from argparse import ArgumentParser\n'), ((542, 566), 'dresscode.utils.load_config', 'load_config', (['args.config'], {}), '(args.config)\n', (553, 566), False, 'from dresscode.utils import load_config\n'), ((2419, 2438), '... |
import pathlib
from setuptools import setup, find_packages
from pokemontcgsdkasync.config import __version__, __pypi_package_name__, __github_username__, __github_repo_name__
# The directory containing this file
HERE = pathlib.Path(__file__).parent
# The text of the README file
README = (HERE / "README.md").read_te... | [
"setuptools.find_packages",
"pathlib.Path"
] | [((222, 244), 'pathlib.Path', 'pathlib.Path', (['__file__'], {}), '(__file__)\n', (234, 244), False, 'import pathlib\n'), ((1325, 1340), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (1338, 1340), False, 'from setuptools import setup, find_packages\n')] |
#!/usr/bin/env python3
import sys
def plot(x, y):
print((x, y))
def plot_line_low(x0, y0, x1, y1):
dx = x1 - x0
dy = y1 - y0
yi = 1
if dy < 0:
yi = -1
dy = -dy
D = (2 * dy) - dx
y = y0
for x in range(x0, x1):
plot(x, y)
if D > 0:
y = y... | [
"sys.exit"
] | [((3031, 3042), 'sys.exit', 'sys.exit', (['(0)'], {}), '(0)\n', (3039, 3042), False, 'import sys\n')] |
# -*- coding: utf-8 -*-
"""
/***************************************************************************
Name : DB Manager
Description : Database manager plugin for QGIS
Date : May 23, 2011
copyright : (C) 2011 by <NAME>
email : <EMAIL>
The content of... | [
"psycopg2.connect",
"functools.cmp_to_key",
"psycopg2.extensions.register_type",
"os.environ.get",
"qgis.PyQt.QtCore.QFile",
"builtins.str",
"builtins.range",
"qgis.core.QgsCredentials.instance",
"qgis.PyQt.QtCore.QRegExp",
"qgis.core.QgsDataSourceUri"
] | [((1443, 1505), 'psycopg2.extensions.register_type', 'psycopg2.extensions.register_type', (['psycopg2.extensions.UNICODE'], {}), '(psycopg2.extensions.UNICODE)\n', (1476, 1505), False, 'import psycopg2\n'), ((1506, 1573), 'psycopg2.extensions.register_type', 'psycopg2.extensions.register_type', (['psycopg2.extensions.U... |
#!/usr/bin/python
import os
from subprocess import call
NCMDS = 2
message = str(raw_input('type your message: '))
command1 = "git commit -m '%s'"%(message)
push = 'git push origin master'
cmd_list = [command1, push]
for cmd in cmd_list:
call(cmd, shell=True)
| [
"subprocess.call"
] | [((250, 271), 'subprocess.call', 'call', (['cmd'], {'shell': '(True)'}), '(cmd, shell=True)\n', (254, 271), False, 'from subprocess import call\n')] |
import smtplib
from contextlib import contextmanager
import pandas as pd, datetime as dt,numpy as np
import re, os, ssl
import credentials, glob
import base64
from templateReport import * # template html of all content of the email
from email.mime.multipart import MIMEMultipart
from email.mime.base import MIMEBase... | [
"smtplib.SMTP",
"pandas.read_csv",
"datetime.datetime.now",
"email.mime.multipart.MIMEMultipart",
"datetime.date.today",
"email.mime.text.MIMEText"
] | [((521, 585), 'pandas.read_csv', 'pd.read_csv', (['f"""/home/lorenzo/Quanvas/Dollar Futures {today}.csv"""'], {}), "(f'/home/lorenzo/Quanvas/Dollar Futures {today}.csv')\n", (532, 585), True, 'import pandas as pd, datetime as dt, numpy as np\n'), ((2091, 2141), 'pandas.read_csv', 'pd.read_csv', (['"""/home/lorenzo/Quan... |
"""Block.Io API backend.
Supports Bitcoin, Dogecoin and Litecoin on `block.io <https://block.io>`_ API.
The backend configuration takes following parameters.
:param class: Always ``cryptoassets.core.backend.blockio.BlockIo``
:param api_key: block.io API key
:param password: <PASSWORD>
:param network: one of ``btc... | [
"logging.getLogger",
"datetime.datetime.fromtimestamp",
"block_io.BlockIo",
"decimal.Decimal",
"slugify.slugify"
] | [((1573, 1600), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1590, 1600), False, 'import logging\n'), ((8431, 8441), 'decimal.Decimal', 'Decimal', (['(1)'], {}), '(1)\n', (8438, 8441), False, 'from decimal import Decimal\n'), ((2611, 2636), 'block_io.BlockIo', '_BlockIo', (['api_key', ... |
from setuptools import setup
setup(
name="flex_version",
version='1.2.3',
url='https://github.com/caesar0301/FlexVersion',
author='<NAME>',
author_email='<EMAIL>',
description='A cute Python library to manipulate version stuff.',
license="Apache License, Version 2.0",
packages=['flex_ve... | [
"setuptools.setup"
] | [((30, 968), 'setuptools.setup', 'setup', ([], {'name': '"""flex_version"""', 'version': '"""1.2.3"""', 'url': '"""https://github.com/caesar0301/FlexVersion"""', 'author': '"""<NAME>"""', 'author_email': '"""<EMAIL>"""', 'description': '"""A cute Python library to manipulate version stuff."""', 'license': '"""Apache Li... |
#!/usr/bin/env python
# Copyright 2017-2018 Biomedical Imaging Group Rotterdam, Departments of
# Medical Informatics and Radiology, Erasmus MC, Rotterdam, The Netherlands
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obt... | [
"logging.getLogger",
"collections.OrderedDict",
"radiomics.featureextractor.RadiomicsFeaturesExtractor",
"logging.Formatter",
"logging.FileHandler"
] | [((3018, 3071), 'radiomics.featureextractor.RadiomicsFeaturesExtractor', 'featureextractor.RadiomicsFeaturesExtractor', ([], {}), '(**kwargs)\n', (3061, 3071), False, 'from radiomics import featureextractor\n'), ((3262, 3292), 'logging.getLogger', 'logging.getLogger', (['"""radiomics"""'], {}), "('radiomics')\n", (3279... |
from django import forms
from django.contrib.auth.forms import UserCreationForm, AuthenticationForm
from .models import User
class RegistrationForm(UserCreationForm):
class Meta:
model = User
fields = ('email',)
class LoginForm(AuthenticationForm):
username = forms.EmailField()
| [
"django.forms.EmailField"
] | [((288, 306), 'django.forms.EmailField', 'forms.EmailField', ([], {}), '()\n', (304, 306), False, 'from django import forms\n')] |
# -*- coding: utf-8 -*-
import re
import json
import requests
import itertools
from settings import *
import tools
# retrieve prices from tarkov-market for each item
def crawl_prices_tarkov_market(data):
logger.info("Getting JSON from " + CONST_TARKOV_MARKET)
try:
# escape the 401 first, no Simple... | [
"tools.find_substring",
"re.sub",
"json.loads",
"requests.get"
] | [((3212, 3243), 'requests.get', 'requests.get', (['CONST_LOOT_GOBLIN'], {}), '(CONST_LOOT_GOBLIN)\n', (3224, 3243), False, 'import requests\n'), ((3287, 3305), 'json.loads', 'json.loads', (['r.text'], {}), '(r.text)\n', (3297, 3305), False, 'import json\n'), ((397, 430), 'requests.get', 'requests.get', (['CONST_TARKOV_... |
import numpy as np
import os
from scipy.optimize import least_squares, minimize
from scipy.special import fresnel
def autophase(S):
'''Optimize phase of complex data by maximizing the sum of imaginary over sum of real
.. math::
\phi = \\arctan \left( \\frac{\sum_i^N \Im(s_i) }{ \sum_i^N \Re(s_i) } \\... | [
"numpy.sqrt",
"numpy.linalg.pinv",
"numpy.polyfit",
"numpy.log",
"numpy.roots",
"numpy.array",
"numpy.linalg.norm",
"numpy.sin",
"numpy.imag",
"scipy.optimize.least_squares",
"numpy.max",
"numpy.exp",
"numpy.real",
"numpy.dot",
"scipy.special.fresnel",
"numpy.abs",
"numpy.eye",
"nu... | [((2633, 2666), 'os.path.join', 'os.path.join', (['directory', 'filename'], {}), '(directory, filename)\n', (2645, 2666), False, 'import os\n'), ((2687, 2723), 'numpy.loadtxt', 'np.loadtxt', (['full_path'], {'delimiter': '""","""'}), "(full_path, delimiter=',')\n", (2697, 2723), True, 'import numpy as np\n'), ((2995, 3... |
import sys, arrow, time, dateutil
from uuid import uuid4
from datetime import datetime
sys.path.insert(0, 'controller/')
#Import library essentials
from sumy.parsers.plaintext import PlaintextParser #We're choosing a plaintext parser here, other parsers available for HTML etc.
from sumy.nlp.tokenizers import Tokenize... | [
"sys.path.insert",
"textblob.classifiers.NaiveBayesClassifier",
"sumy.summarizers.lex_rank.LexRankSummarizer",
"dateutil.tz.gettz",
"time.strftime",
"arrow.get",
"sumy.nlp.tokenizers.Tokenizer",
"datetime.datetime.today"
] | [((88, 121), 'sys.path.insert', 'sys.path.insert', (['(0)', '"""controller/"""'], {}), "(0, 'controller/')\n", (103, 121), False, 'import sys, arrow, time, dateutil\n'), ((692, 726), 'time.strftime', 'time.strftime', (['"""%d/%m/%y %H:%M:%S"""'], {}), "('%d/%m/%y %H:%M:%S')\n", (705, 726), False, 'import sys, arrow, ti... |
'''
IoT Bootcamp
Trainer: <NAME>
Phase 4 - Part 2: Building Web App for Home Automation
Code Sample: Controlling LED using an HTML page
'''
from flask import Flask, render_template, request
from gpiozero import LED
from time import sleep
app = Flask(__name__)
# Default: GPIO4
led = LED(4)
@app.route('/')
def home()... | [
"flask.render_template",
"gpiozero.LED",
"flask.Flask"
] | [((245, 260), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (250, 260), False, 'from flask import Flask, render_template, request\n'), ((285, 291), 'gpiozero.LED', 'LED', (['(4)'], {}), '(4)\n', (288, 291), False, 'from gpiozero import LED\n'), ((425, 468), 'flask.render_template', 'render_template', (['"... |
import os
import cv2
import numpy as np
from PIL import Image
from IPython.display import Video
from IPython.display import display as ds
DESTINATION_FOLDER = "results"
def check_folder(folder):
if not os.path.exists(folder):
os.makedirs(folder)
def display(images_array, save=False):
for im in ... | [
"cv2.rectangle",
"os.path.exists",
"PIL.Image.fromarray",
"cv2.imwrite",
"os.makedirs",
"IPython.display.Video",
"cv2.putText",
"cv2.imdecode",
"cv2.cvtColor",
"numpy.fromstring"
] | [((888, 918), 'numpy.fromstring', 'np.fromstring', (['image', 'np.uint8'], {}), '(image, np.uint8)\n', (901, 918), True, 'import numpy as np\n'), ((934, 971), 'cv2.imdecode', 'cv2.imdecode', (['nparr', 'cv2.IMREAD_COLOR'], {}), '(nparr, cv2.IMREAD_COLOR)\n', (946, 971), False, 'import cv2\n'), ((1482, 1523), 'cv2.cvtCo... |
#!/usr/bin/env python
# coding=utf-8
import unittest
from app.domain.model import User, AnonymousUser, Permission, Role
class UserModelTestCase(unittest.TestCase):
def test_password_setter(self):
u = User(password = '<PASSWORD>')
self.assertTrue(u.password_hash is not None)
def test_no_passwo... | [
"app.domain.model.User",
"app.domain.model.Role.insert_roles",
"app.domain.model.AnonymousUser"
] | [((214, 241), 'app.domain.model.User', 'User', ([], {'password': '"""<PASSWORD>"""'}), "(password='<PASSWORD>')\n", (218, 241), False, 'from app.domain.model import User, AnonymousUser, Permission, Role\n'), ((349, 376), 'app.domain.model.User', 'User', ([], {'password': '"""<PASSWORD>"""'}), "(password='<PASSWORD>')\n... |
import os
import sys
import logging
from flask import Flask # type: ignore
import sentry_sdk
from sentry_sdk.integrations.flask import FlaskIntegration
from sentry_sdk.integrations.sqlalchemy import SqlalchemyIntegration
def create_app(test_config=None):
# create and configure the app
app = Flask(__name__, ... | [
"sentry_sdk.integrations.flask.FlaskIntegration",
"logging.StreamHandler",
"flask.Flask",
"os.environ.get",
"sentry_sdk.integrations.sqlalchemy.SqlalchemyIntegration",
"doppelkopf.db.init_app"
] | [((304, 350), 'flask.Flask', 'Flask', (['__name__'], {'instance_relative_config': '(True)'}), '(__name__, instance_relative_config=True)\n', (309, 350), False, 'from flask import Flask\n'), ((1179, 1195), 'doppelkopf.db.init_app', 'db.init_app', (['app'], {}), '(app)\n', (1190, 1195), False, 'from doppelkopf import db\... |