code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
import logging
from logging.handlers import RotatingFileHandler
import os
import sys
from flask import Flask, request, session, g, redirect, url_for, abort, \
render_template, flash, jsonify, has_request_context, send_from_directory, send_file
from common import constants
from common.db import GarageDb
from comm... | [
"flask.render_template",
"flask.request.args.get",
"common.db.GarageDb",
"flask.Flask",
"time.sleep",
"flask.session.pop",
"flask.request.headers.get",
"flask.jsonify",
"flask.flash",
"webserver.client_api.GaragePiClient",
"common.telegram.TelegramNotification",
"flask.abort",
"csv.writer",
... | [((534, 580), 'flask.Flask', 'Flask', (['__name__'], {'instance_relative_config': '(True)'}), '(__name__, instance_relative_config=True)\n', (539, 580), False, 'from flask import Flask, request, session, g, redirect, url_for, abort, render_template, flash, jsonify, has_request_context, send_from_directory, send_file\n'... |
from django import forms
from zentral.core.probes.forms import BaseCreateProbeForm
from zentral.utils.forms import CommaSeparatedQuotedStringField
from .probes import MunkiInstallProbe
class UpdateInstallProbeForm(forms.Form):
installed_item_names = CommaSeparatedQuotedStringField(help_text="Comma separated names... | [
"django.forms.ChoiceField",
"zentral.utils.forms.CommaSeparatedQuotedStringField"
] | [((256, 366), 'zentral.utils.forms.CommaSeparatedQuotedStringField', 'CommaSeparatedQuotedStringField', ([], {'help_text': '"""Comma separated names of the installed items"""', 'required': '(False)'}), "(help_text=\n 'Comma separated names of the installed items', required=False)\n", (287, 366), False, 'from zentral... |
#!/usr/bin/env python
# coding: utf-8
# # Generate website content
import pinklib.website as web
import os
from astropy.stats import median_absolute_deviation
import numpy as np
import importlib
import pandas as pd
# INPUT PARAMETERS
# Name of the binary file
cutouts_bin_name = 'cutouts_preprocessed'
# SOM para... | [
"pinklib.website.unpack_trained_som",
"numpy.argsort",
"pinklib.website.SOM",
"pinklib.website.plot_som",
"pandas.read_pickle",
"os.path.exists",
"pinklib.website.plot_distance_to_bmu_histogram",
"numpy.mean",
"pinklib.website.plot_som_bmu_heatmap",
"os.mkdir",
"numpy.min",
"numpy.argmin",
"... | [((660, 722), 'os.path.join', 'os.path.join', (['"""SOM_directory"""', '"""catalogue_LOTSS_DR1_final.pkl"""'], {}), "('SOM_directory', 'catalogue_LOTSS_DR1_final.pkl')\n", (672, 722), False, 'import os\n'), ((735, 787), 'os.path.join', 'os.path.join', (['"""SOM_directory"""', '"""LOTSS_DR1_final.bin"""'], {}), "('SOM_d... |
import asyncio
import collections
import functools
import inspect
class LRUDict(collections.OrderedDict):
def __init__(self, max_legnth = 10, *args, **kwargs):
if max_legnth <= 0:
raise ValueError()
self.max_legnth = max_legnth
super().__init__(*args, **kwargs)
def __setit... | [
"asyncio.iscoroutinefunction",
"inspect.isawaitable",
"functools.wraps"
] | [((1234, 1255), 'functools.wraps', 'functools.wraps', (['func'], {}), '(func)\n', (1249, 1255), False, 'import functools\n'), ((1410, 1443), 'asyncio.iscoroutinefunction', 'asyncio.iscoroutinefunction', (['func'], {}), '(func)\n', (1437, 1443), False, 'import asyncio\n'), ((1678, 1704), 'inspect.isawaitable', 'inspect.... |
# Copyright 2020 - 2021 MONAI Consortium
# 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 wri... | [
"torch.mean",
"torch.stack",
"torch.reciprocal",
"torch.tensor",
"torch.sum",
"monai.utils.LossReduction"
] | [((1327, 1346), 'torch.reciprocal', 'torch.reciprocal', (['k'], {}), '(k)\n', (1343, 1346), False, 'import torch\n'), ((1359, 1371), 'torch.sum', 'torch.sum', (['k'], {}), '(k)\n', (1368, 1371), False, 'import torch\n'), ((969, 988), 'torch.tensor', 'torch.tensor', (['sigma'], {}), '(sigma)\n', (981, 988), False, 'impo... |
from django.contrib import admin
from pagedown.widgets import AdminPagedownWidget
from django.db import models
from .models import Article, Comment
class CommentAdmin(admin.ModelAdmin):
formfield_overrides = {
models.TextField: {'widget': AdminPagedownWidget}
}
class ArticleAdmin(admin.ModelAdmin):
... | [
"django.contrib.admin.site.register"
] | [((621, 663), 'django.contrib.admin.site.register', 'admin.site.register', (['Article', 'ArticleAdmin'], {}), '(Article, ArticleAdmin)\n', (640, 663), False, 'from django.contrib import admin\n'), ((664, 706), 'django.contrib.admin.site.register', 'admin.site.register', (['Comment', 'CommentAdmin'], {}), '(Comment, Com... |
# Download the Python helper library from twilio.com/docs/python/install
from flask import Flask
from twilio.twiml.voice_response import VoiceResponse
app = Flask(__name__)
@app.route("/enqueue_call", methods=['GET', 'POST'])
def enqueue_call():
# workflow_sid = 'WW0123456789abcdef0123456789abcdef'
resp = V... | [
"twilio.twiml.voice_response.VoiceResponse",
"flask.Flask"
] | [((158, 173), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (163, 173), False, 'from flask import Flask\n'), ((319, 334), 'twilio.twiml.voice_response.VoiceResponse', 'VoiceResponse', ([], {}), '()\n', (332, 334), False, 'from twilio.twiml.voice_response import VoiceResponse\n')] |
import ipaddress
import king_phisher.errors as errors
import king_phisher.server.plugins as plugins
import king_phisher.server.signals as signals
EXAMPLE_CONFIG = """\
rules:
# first rule is an exception because no target is specified
- source: 192.168.0.0/16
# second rule redirects all ipv4 addresses to google... | [
"king_phisher.errors.KingPhisherAbortRequestError",
"ipaddress.ip_network",
"king_phisher.server.signals.request_handle.connect",
"ipaddress.ip_address"
] | [((1278, 1332), 'king_phisher.server.signals.request_handle.connect', 'signals.request_handle.connect', (['self.on_request_handle'], {}), '(self.on_request_handle)\n', (1308, 1332), True, 'import king_phisher.server.signals as signals\n'), ((1480, 1527), 'ipaddress.ip_address', 'ipaddress.ip_address', (['handler.client... |
from matplotlib import pyplot
from math import cos, sin, atan
import numpy as np
import time
import seaborn
from matplotlib.animation import FuncAnimation
import sys
import json
class Neuron():
def __init__(self, x, y):
self.x = x
self.y = y
def draw(self, neuron_radius):
circle = pyp... | [
"matplotlib.pyplot.text",
"matplotlib.pyplot.Circle",
"matplotlib.pyplot.title",
"matplotlib.pyplot.gca",
"math.cos",
"matplotlib.pyplot.figure",
"json.load",
"matplotlib.pyplot.axis",
"math.sin",
"numpy.arange",
"matplotlib.pyplot.show"
] | [((317, 382), 'matplotlib.pyplot.Circle', 'pyplot.Circle', (['(self.x, self.y)'], {'radius': 'neuron_radius', 'fill': '(False)'}), '((self.x, self.y), radius=neuron_radius, fill=False)\n', (330, 382), False, 'from matplotlib import pyplot\n'), ((4552, 4573), 'matplotlib.pyplot.axis', 'pyplot.axis', (['"""scaled"""'], {... |
#!/usr/bin/env python
import datetime
import os
import unittest
from datetime import timedelta
from datetime import timezone
from os.path import exists
from pds_doi_service.core.db.doi_database import DOIDataBase
from pds_doi_service.core.entities.doi import DoiStatus
from pds_doi_service.core.entities.doi import Prod... | [
"os.path.exists",
"pds_doi_service.core.db.doi_database.DOIDataBase",
"pkg_resources.resource_filename",
"os.remove",
"datetime.datetime.now",
"unittest.main",
"datetime.timedelta",
"pds_doi_service.core.util.general_util.get_logger"
] | [((444, 464), 'pds_doi_service.core.util.general_util.get_logger', 'get_logger', (['__name__'], {}), '(__name__)\n', (454, 464), False, 'from pds_doi_service.core.util.general_util import get_logger\n'), ((10287, 10302), 'unittest.main', 'unittest.main', ([], {}), '()\n', (10300, 10302), False, 'import unittest\n'), ((... |
# -*- coding: ascii -*-
# $Id: CNCCanvas.py,v 1.7 2014/10/15 15:04:06 bnv Exp $
#
# Author: <EMAIL>
# Date: 24-Aug-2014
import math
import time
import bmath
try:
from Tkinter import *
import Tkinter
except ImportError:
from tkinter import *
import tkinter as Tkinter
from CNC import Tab, CNC
import Utils
imp... | [
"math.floor",
"PIL.Image.new",
"math.sqrt",
"Utils.setInt",
"math.cos",
"CNC.CNC.isMarginValid",
"math.log10",
"Utils.getStr",
"Camera.Camera",
"CNC.CNC.isAllMarginValid",
"CNC.CNC.compileLine",
"PIL.ImageTk.PhotoImage",
"tkExtra.Combobox",
"bmath.frange",
"numpy.floor",
"math.radians"... | [((2049, 2065), 'math.radians', 'math.radians', (['(60)'], {}), '(60)\n', (2061, 2065), False, 'import math\n'), ((2082, 2098), 'math.radians', 'math.radians', (['(60)'], {}), '(60)\n', (2094, 2098), False, 'import math\n'), ((6467, 6492), 'Camera.Camera', 'Camera.Camera', (['"""aligncam"""'], {}), "('aligncam')\n", (6... |
from django.db import models
from django.db.models.query import QuerySet
from django.urls import reverse
class TaskList(models.Model):
name = models.CharField(max_length=255)
slug = models.CharField(max_length=255)
tasks: QuerySet["Task"]
class Meta:
verbose_name = "Task List"
verbos... | [
"django.urls.reverse",
"django.db.models.CharField",
"django.db.models.BooleanField",
"django.db.models.ForeignKey"
] | [((148, 180), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(255)'}), '(max_length=255)\n', (164, 180), False, 'from django.db import models\n'), ((192, 224), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(255)'}), '(max_length=255)\n', (208, 224), False, 'from django.d... |
import logging
import asyncio
from .. import *
from ..i2c_master import I2CMasterApplet
class TPS6598xI2CInterface:
def __init__(self, interface, logger, i2c_address):
self.lower = interface
self._i2c_addr = i2c_address
self._logger = logger
self._level = logging.DEBUG if... | [
"logging.getLogger"
] | [((1470, 1497), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1487, 1497), False, 'import logging\n')] |
import pytest
from os import path
from licensify.apply_license import apply_license_header
from licensify.errors import LicensesOutOfDateError
def _contents(file):
with open(file) as fp:
return fp.read()
@pytest.fixture
def tmp_file_factory(tmpdir):
def _factory(contents=''):
filename = path... | [
"pytest.raises",
"licensify.apply_license.apply_license_header"
] | [((567, 624), 'licensify.apply_license.apply_license_header', 'apply_license_header', (['"""My Awesome License"""', '[source_path]'], {}), "('My Awesome License', [source_path])\n", (587, 624), False, 'from licensify.apply_license import apply_license_header\n'), ((839, 896), 'licensify.apply_license.apply_license_head... |
import asyncio
import logging
import sys
import struct
from transporter import Transporter, GCMTransporter
logging.basicConfig(
level=logging.DEBUG,
format='[%(levelname)s][%(name)s %(asctime)s]:%(message)s',
# filename='gms_multicaster.log',
filemode='a',
stream=sys.stderr
)
log = logging.ge... | [
"logging.basicConfig",
"logging.getLogger",
"transporter.Transporter.midman",
"asyncio.start_server",
"struct.unpack",
"asyncio.open_connection",
"transporter.Transporter",
"asyncio.get_event_loop"
] | [((109, 251), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.DEBUG', 'format': '"""[%(levelname)s][%(name)s %(asctime)s]:%(message)s"""', 'filemode': '"""a"""', 'stream': 'sys.stderr'}), "(level=logging.DEBUG, format=\n '[%(levelname)s][%(name)s %(asctime)s]:%(message)s', filemode='a',\n st... |
'''
This module contains all fo the routines needed to set up an alert server.
'''
# Import python modules
import logging
# Import salt modules
import salt.master
import salt.client
import salt.ext.alert.alerter
# Import cryptography modules
from M2Crypto import RSA
log = logging.getLogger(__name__)
class AlertServer... | [
"logging.getLogger"
] | [((274, 301), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (291, 301), False, 'import logging\n')] |
# Copyright (c) OpenMMLab. All rights reserved.
import pytest
import torch
from mmdet.core.bbox.coder import (DeltaXYWHBBoxCoder, DistancePointBBoxCoder,
TBLRBBoxCoder, YOLOBBoxCoder)
def test_yolo_bbox_coder():
coder = YOLOBBoxCoder()
bboxes = torch.Tensor([[-42.... | [
"mmdet.core.bbox.coder.TBLRBBoxCoder",
"mmdet.core.bbox.coder.YOLOBBoxCoder",
"mmdet.core.bbox.coder.DeltaXYWHBBoxCoder",
"torch.Tensor",
"pytest.raises",
"mmdet.core.bbox.coder.DistancePointBBoxCoder",
"torch.zeros"
] | [((271, 286), 'mmdet.core.bbox.coder.YOLOBBoxCoder', 'YOLOBBoxCoder', ([], {}), '()\n', (284, 286), False, 'from mmdet.core.bbox.coder import DeltaXYWHBBoxCoder, DistancePointBBoxCoder, TBLRBBoxCoder, YOLOBBoxCoder\n'), ((301, 433), 'torch.Tensor', 'torch.Tensor', (['[[-42.0, -29.0, 74.0, 61.0], [-10.0, -29.0, 106.0, 6... |
from asyncio import ensure_future, Lock, sleep, get_event_loop
from bisect import insort, bisect, bisect_left
from collections import UserList
from contextlib import suppress
from multiprocessing import Process
from os import rename, remove
from os.path import getsize, isfile
from pickle import load, UnpicklingError
fr... | [
"os.path.getsize",
"os.rename",
"multiprocessing.Process",
"asyncio.Lock",
"pickle.load",
"struct.pack",
"bisect.bisect",
"os.path.isfile",
"contextlib.suppress",
"bisect.insort",
"asyncio.sleep",
"asyncio.get_event_loop",
"bisect.bisect_left",
"os.remove"
] | [((5542, 5558), 'asyncio.get_event_loop', 'get_event_loop', ([], {}), '()\n', (5556, 5558), False, 'from asyncio import ensure_future, Lock, sleep, get_event_loop\n'), ((557, 580), 'bisect.insort', 'insort', (['self.data', 'item'], {}), '(self.data, item)\n', (563, 580), False, 'from bisect import insort, bisect, bisec... |
# automatically generates sentences based on source words
# from output_shortlist.txt
# with a=action (verb), d=descriptor (adjective/adverb), t=thing (noun/pronoun), c=connector (preposition)
import random
filename1 = 'output_shortlist.txt'
# get lines of file into a list:
with open(filename1,'r') as f1:
data =... | [
"random.choice"
] | [((1665, 1696), 'random.choice', 'random.choice', (['connectorIndices'], {}), '(connectorIndices)\n', (1678, 1696), False, 'import random\n')] |
#!/usr/bin/env python3
#
# MIT License
#
# Copyright (c) 2020-2021 EntySec
#
# 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... | [
"random.choice",
"collections.deque",
"string.encode",
"string.decode",
"re.findall"
] | [((2209, 2228), 'collections.deque', 'collections.deque', ([], {}), '()\n', (2226, 2228), False, 'import collections\n'), ((2740, 2759), 'collections.deque', 'collections.deque', ([], {}), '()\n', (2757, 2759), False, 'import collections\n'), ((4663, 4712), 're.findall', 're.findall', (["'[^\\x00-\\x1f\\x7f-ÿ]{4,}'", '... |
import csv
import numpy as np
import pycocotools.mask as mask
import os
import argparse
import imagesize
import base64
import shutil
parser = argparse.ArgumentParser(description='Convert open images segmentation data to coco format.')
parser.add_argument('--annotations', '-a', default='oidv6-train-annotations-bbox.csv... | [
"csv.writer",
"csv.reader",
"argparse.ArgumentParser"
] | [((143, 240), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Convert open images segmentation data to coco format."""'}), "(description=\n 'Convert open images segmentation data to coco format.')\n", (166, 240), False, 'import argparse\n'), ((900, 933), 'csv.reader', 'csv.reader', (['... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Oct 4 17:44:53 2021
@author: mlampert
"""
import os
import copy
#FLAP imports and settings
import flap
import flap_nstx
import flap_mdsplus
flap_nstx.register('NSTX_GPI')
flap_nstx.register('NSTX_THOMSON')
flap_mdsplus.register('NSTX_MDSPlus')
thi... | [
"flap_mdsplus.register",
"numpy.abs",
"flap.config.read",
"flap_nstx.register",
"os.path.join",
"flap.Unit",
"os.path.realpath",
"flap.DataObject",
"flap.add_data_object",
"flap.get_data",
"numpy.interp",
"flap.CoordinateMode"
] | [((211, 241), 'flap_nstx.register', 'flap_nstx.register', (['"""NSTX_GPI"""'], {}), "('NSTX_GPI')\n", (229, 241), False, 'import flap_nstx\n'), ((242, 276), 'flap_nstx.register', 'flap_nstx.register', (['"""NSTX_THOMSON"""'], {}), "('NSTX_THOMSON')\n", (260, 276), False, 'import flap_nstx\n'), ((278, 315), 'flap_mdsplu... |
import sys
from os import path
from jtd_mobs.mobs import *
from jtd_mobs.nodes import *
from jtd_towers.towers import *
from jtd_ui.tilemap import *
from jtd_ui.buttons import Button
from jtd_ui import pathing
from jtd_ui import game_intro
"""
Jonathan's Tower Defence Game
- Better name tbd :)
Developed by Tensor S... | [
"jtd_ui.pathing.load_map",
"jtd_ui.game_intro.game_intro",
"jtd_ui.buttons.Button",
"os.path.join",
"os.path.dirname",
"jtd_ui.pathing.AStar",
"jtd_ui.pathing.load_tiled_map",
"sys.exit",
"jtd_ui.pathing.find_change_in_dir"
] | [((1439, 1461), 'os.path.dirname', 'path.dirname', (['__file__'], {}), '(__file__)\n', (1451, 1461), False, 'from os import path\n'), ((1483, 1513), 'os.path.join', 'path.join', (['game_folder', '"""maps"""'], {}), "(game_folder, 'maps')\n", (1492, 1513), False, 'from os import path\n'), ((1535, 1564), 'os.path.join', ... |
#!/usr/bin/env python
"""
############################################################
Integrated Circuit Package Component Specific Work Book View
############################################################
"""
# -*- coding: utf-8 -*-
#
# rtk.hardware.gui.gtk.IntegratedCircuit.py is part of The RTK Project
#
#... | [
"gtk.Fixed",
"matplotlib.backends.backend_gtk.FigureCanvasGTK",
"locale.setlocale",
"gtk.ScrolledWindow",
"rtk.gui.gtk.Widgets.make_labels",
"matplotlib.use",
"matplotlib.figure.Figure",
"pygtk.require",
"rtk.gui.gtk.Widgets.make_combo",
"sys.exit",
"rtk.gui.gtk.Widgets.make_entry",
"gtk.Label... | [((2950, 2971), 'matplotlib.use', 'matplotlib.use', (['"""GTK"""'], {}), "('GTK')\n", (2964, 2971), False, 'import matplotlib\n'), ((2098, 2118), 'pygtk.require', 'pygtk.require', (['"""2.0"""'], {}), "('2.0')\n", (2111, 2118), False, 'import pygtk\n'), ((2813, 2866), 'locale.setlocale', 'locale.setlocale', (['locale.L... |
from freezegun import freeze_time
import pytest
from ebl.errors import DataError, NotFoundError
from ebl.fragmentarium.application.fragment_schema import FragmentSchema
from ebl.fragmentarium.domain.fragment import Genre, NotLowestJoinError
from ebl.fragmentarium.domain.joins import Join, Joins
from ebl.transliteratio... | [
"ebl.fragmentarium.application.fragment_schema.FragmentSchema",
"ebl.lemmatization.domain.lemmatization.Lemmatization",
"ebl.fragmentarium.domain.fragment.Genre",
"ebl.lemmatization.domain.lemmatization.LemmatizationToken",
"ebl.tests.factories.fragment.TransliteratedFragmentFactory.build",
"pytest.raises... | [((804, 820), 'ebl.fragmentarium.application.fragment_schema.FragmentSchema', 'FragmentSchema', ([], {}), '()\n', (818, 820), False, 'from ebl.fragmentarium.application.fragment_schema import FragmentSchema\n'), ((824, 862), 'freezegun.freeze_time', 'freeze_time', (['"""2018-09-07 15:41:24.032"""'], {}), "('2018-09-07 ... |
from concurrent import futures
import time
import logging
import grpc
import connectionService_pb2
import connectionService_pb2_grpc
from google.protobuf import empty_pb2 as google_dot_protobuf_dot_empty__pb2
_ONE_DAY_IN_SECONDS = 60 * 60 * 24
class connectionService(connectionService_pb2_grpc.ConnectionServiceServi... | [
"logging.basicConfig",
"logging.debug",
"concurrent.futures.ThreadPoolExecutor",
"time.sleep",
"google.protobuf.empty_pb2.Empty",
"connectionService_pb2.ConnectionList"
] | [((1014, 1046), 'logging.debug', 'logging.debug', (['"""Starting server"""'], {}), "('Starting server')\n", (1027, 1046), False, 'import logging\n'), ((1224, 1264), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.DEBUG'}), '(level=logging.DEBUG)\n', (1243, 1264), False, 'import logging\n'), ((380,... |
"""
output diff logs
the format is:
op \t type \t pk \t info \t [old_info]
op: db operation, + for add, - for del, m for modify
type: data type, like neeq_rules, neeq_announce etc.
pk: primary key in database
info: json dict contains all data updated
old_info: json dict contains old data
"""
import datetime
import js... | [
"os.path.exists",
"json.dumps",
"datetime.datetime.now",
"os.makedirs"
] | [((374, 402), 'os.path.exists', 'os.path.exists', (['diffRootPath'], {}), '(diffRootPath)\n', (388, 402), False, 'import os\n'), ((408, 433), 'os.makedirs', 'os.makedirs', (['diffRootPath'], {}), '(diffRootPath)\n', (419, 433), False, 'import os\n'), ((818, 841), 'datetime.datetime.now', 'datetime.datetime.now', ([], {... |
# _*_ coding:utf-8 _*_
from com.common.BaseLoggingObj import BaseLoggingObj
from web.broker.Brokers import Broker
__author__ = 'Administrator'
class InstallService(BaseLoggingObj, object):
def __init__(self):
pass
def installMysql(self, hostKey):
broker = Broker.getBroker(hostKey)
... | [
"web.broker.Brokers.Broker.getBroker"
] | [((286, 311), 'web.broker.Brokers.Broker.getBroker', 'Broker.getBroker', (['hostKey'], {}), '(hostKey)\n', (302, 311), False, 'from web.broker.Brokers import Broker\n'), ((397, 422), 'web.broker.Brokers.Broker.getBroker', 'Broker.getBroker', (['hostKey'], {}), '(hostKey)\n', (413, 422), False, 'from web.broker.Brokers ... |
# Must plug in DC power to Lolin V3 board, to power its 3.3V and 5V rail to external devices like LCD/keypad.
# Dependency: This file reads config.json at same folder.
from time import sleep_ms, sleep
import gc
import mpr121
from convert_seconds_to_minutes_and_seconds import convert_seconds_to_minutes_and_seconds
from ... | [
"mpr121.MPR121",
"relay_controller.RelayController",
"machine.Pin",
"micropython.const",
"time.sleep",
"lcd_controller.LcdController",
"time.sleep_ms",
"convert_seconds_to_minutes_and_seconds.convert_seconds_to_minutes_and_seconds",
"gc.collect",
"ujson.load"
] | [((694, 721), 'machine.Pin', 'Pin', (['(0)', 'Pin.IN', 'Pin.PULL_UP'], {}), '(0, Pin.IN, Pin.PULL_UP)\n', (697, 721), False, 'from machine import Pin, I2C, PWM\n'), ((965, 983), 'mpr121.MPR121', 'mpr121.MPR121', (['i2c'], {}), '(i2c)\n', (978, 983), False, 'import mpr121\n'), ((2034, 2043), 'micropython.const', 'const'... |
#Modules
#Utility imports
import sys
import sqlite3
class SQLConnector():
db_file = None
conn = None
cursor = None
def __init__(self, db_file):
self.db_file = db_file
def connect(self) -> bool:
# Create connection with db
try:
self.conn = sqlite3.connect(sel... | [
"sqlite3.connect"
] | [((301, 330), 'sqlite3.connect', 'sqlite3.connect', (['self.db_file'], {}), '(self.db_file)\n', (316, 330), False, 'import sqlite3\n')] |
import math
import random
from datetime import datetime
from discord.ext.commands.context import Context
from app import BOT
from app.commands.metadata import COMMAND_INFO, build_command_help_msg
from app.database.repositories.birthday import BirthdayRepository
# Remove the default help command, so that we can regis... | [
"app.commands.metadata.build_command_help_msg",
"app.BOT.remove_command",
"app.commands.metadata.COMMAND_INFO.get",
"app.database.repositories.birthday.BirthdayRepository",
"datetime.datetime.strptime",
"app.commands.metadata.COMMAND_INFO.items",
"app.BOT.command"
] | [((332, 358), 'app.BOT.remove_command', 'BOT.remove_command', (['"""help"""'], {}), "('help')\n", (350, 358), False, 'from app import BOT\n'), ((361, 380), 'app.BOT.command', 'BOT.command', (['"""help"""'], {}), "('help')\n", (372, 380), False, 'from app import BOT\n'), ((918, 946), 'app.BOT.command', 'BOT.command', ([... |
from django.urls import path
from authors.apps.social_auth.views import (
FacebookAuthView, GoogleAuthView, TwitterAuthView
)
urlpatterns = [
path('auth/facebook/', FacebookAuthView.as_view()),
path('auth/google/', GoogleAuthView.as_view()),
path('auth/twitter/', TwitterAuthView.as_view()),
]
| [
"authors.apps.social_auth.views.GoogleAuthView.as_view",
"authors.apps.social_auth.views.FacebookAuthView.as_view",
"authors.apps.social_auth.views.TwitterAuthView.as_view"
] | [((174, 200), 'authors.apps.social_auth.views.FacebookAuthView.as_view', 'FacebookAuthView.as_view', ([], {}), '()\n', (198, 200), False, 'from authors.apps.social_auth.views import FacebookAuthView, GoogleAuthView, TwitterAuthView\n'), ((228, 252), 'authors.apps.social_auth.views.GoogleAuthView.as_view', 'GoogleAuthVi... |
import configparser
import json
from telethon.sync import TelegramClient
from telethon import connection
# для корректного переноса времени сообщений в json
from datetime import date, datetime
# классы для работы с каналами
from telethon.tl.functions.channels import GetParticipantsRequest
from telethon.tl.types impo... | [
"json.JSONEncoder.default",
"configparser.ConfigParser",
"telethon.tl.functions.channels.GetParticipantsRequest",
"telethon.tl.functions.messages.GetHistoryRequest",
"telethon.tl.types.ChannelParticipantsSearch",
"json.dump",
"telethon.sync.TelegramClient"
] | [((481, 508), 'configparser.ConfigParser', 'configparser.ConfigParser', ([], {}), '()\n', (506, 508), False, 'import configparser\n'), ((1141, 1267), 'telethon.sync.TelegramClient', 'TelegramClient', (['username', 'api_id', 'api_hash'], {'connection': 'connection.ConnectionTcpMTProxyRandomizedIntermediate', 'proxy': 'p... |
# copyright (c) 2021 PaddlePaddle Authors. All Rights Reserve.
#
# 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 applica... | [
"paddle.nn.Conv2D",
"paddleseg.utils.load_entire_model",
"paddle.nn.BatchNorm2D",
"paddle.nn.ReLU"
] | [((7119, 7128), 'paddle.nn.ReLU', 'nn.ReLU', ([], {}), '()\n', (7126, 7128), True, 'import paddle.nn as nn\n'), ((2347, 2393), 'paddleseg.utils.load_entire_model', 'utils.load_entire_model', (['self', 'self.pretrained'], {}), '(self, self.pretrained)\n', (2370, 2393), False, 'from paddleseg import utils\n'), ((5320, 54... |
import socket
import select
import ipaddress
import ifaddr
from collections import OrderedDict
from unittest.mock import patch, MagicMock as Mock, PropertyMock, call
from soco import discover
from soco import config
from soco.discovery import (
any_soco,
by_name,
_find_ipv4_addresses,
_find_ipv4_netw... | [
"ifaddr._shared.Adapter",
"ifaddr.IP",
"collections.OrderedDict",
"soco.discovery._sonos_scan_worker_thread",
"unittest.mock.MagicMock",
"unittest.mock.call",
"soco.discover",
"soco.discovery._find_ipv4_networks",
"ipaddress.ip_network",
"soco.discovery._is_sonos",
"soco.config.SOCO_CLASS.assert... | [((7670, 7712), 'ifaddr.IP', 'ifaddr.IP', (['"""192.168.0.1"""', '(24)', '"""private-24"""'], {}), "('192.168.0.1', 24, 'private-24')\n", (7679, 7712), False, 'import ifaddr\n'), ((7730, 7772), 'ifaddr.IP', 'ifaddr.IP', (['"""192.168.1.1"""', '(16)', '"""private-16"""'], {}), "('192.168.1.1', 16, 'private-16')\n", (773... |
#!/usr/bin/env python3
import sys, os
from glob import glob
files = glob(os.path.join(sys.argv[1], '*.tmp'))
assert len(files) == 1
with open(files[0]) as ifile, open(sys.argv[2], 'w') as ofile:
ofile.write(ifile.read())
| [
"os.path.join"
] | [((75, 109), 'os.path.join', 'os.path.join', (['sys.argv[1]', '"""*.tmp"""'], {}), "(sys.argv[1], '*.tmp')\n", (87, 109), False, 'import sys, os\n')] |
__Author__ = "<NAME>"
__Project__ = "Construct Data"
__Created__ = "01/11/2018"
__all__ = ['make_data_square']
import numpy as np
import pandas as pd
from warnings import warn
def make_data_square(trade_dataframe=None,
imp_var_name: str = "importer",
exp_var_name: str = "exp... | [
"pandas.DataFrame"
] | [((11298, 11321), 'pandas.DataFrame', 'pd.DataFrame', (['countries'], {}), '(countries)\n', (11310, 11321), True, 'import pandas as pd\n')] |
from __future__ import absolute_import, unicode_literals
import sys
import django
from django.conf import settings
from django.utils.translation import ugettext_lazy as _
from debug_toolbar.compat import import_string
from debug_toolbar.panels import Panel
class VersionsPanel(Panel):
"""
Shows versions of ... | [
"debug_toolbar.compat.import_string",
"django.utils.translation.ugettext_lazy",
"django.get_version"
] | [((482, 495), 'django.utils.translation.ugettext_lazy', '_', (['"""Versions"""'], {}), "('Versions')\n", (483, 495), True, 'from django.utils.translation import ugettext_lazy as _\n'), ((448, 468), 'django.get_version', 'django.get_version', ([], {}), '()\n', (466, 468), False, 'import django\n'), ((1037, 1056), 'debug... |
import plotly.express as px
import plotly.graph_objects as go
import pandas as pd
import datetime
import numpy as np
from tqdm import tqdm
from audioset_tagging_cnn.config import labels
import argparse
parser = argparse.ArgumentParser(
description='Export pkl to hdf5 files')
parser.add_argument('--file', type=str... | [
"pandas.read_pickle",
"pandas.DataFrame",
"argparse.ArgumentParser"
] | [((213, 276), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Export pkl to hdf5 files"""'}), "(description='Export pkl to hdf5 files')\n", (236, 276), False, 'import argparse\n'), ((433, 458), 'pandas.read_pickle', 'pd.read_pickle', (['args.file'], {}), '(args.file)\n', (447, 458), True,... |
import math
def nd(m, s, x):
Z = (x - m)/s
return 0.5*(1 + math.erf(Z/(math.sqrt(2))))
def ans(m, s, x, n):
print(round(nd(m*n, s*math.sqrt(n), x), 4))
if __name__ == '__main__':
x = float(input())
n = float(input())
m = float(input())
s = float(input())
ans(m, s, x, n)
| [
"math.sqrt"
] | [((80, 92), 'math.sqrt', 'math.sqrt', (['(2)'], {}), '(2)\n', (89, 92), False, 'import math\n'), ((144, 156), 'math.sqrt', 'math.sqrt', (['n'], {}), '(n)\n', (153, 156), False, 'import math\n')] |
import os
import mlflow
import numpy as np
import pandas as pd
import pytest
from matplotlib import pyplot as plt
from plotly import graph_objects as go
from mlflow_extend import logging as lg
from mlflow_extend.testing.utils import (
_get_default_args,
_read_data,
assert_file_exists_in_artifacts,
ass... | [
"mlflow_extend.logging.log_metrics_flatten",
"numpy.array",
"pandas.testing.assert_frame_equal",
"mlflow_extend.testing.utils._get_default_args",
"mlflow_extend.logging.log_pr_curve",
"plotly.graph_objects.Bar",
"mlflow_extend.logging.log_feature_importance",
"mlflow_extend.logging.log_roc_curve",
"... | [((472, 557), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""path"""', "['test.txt', 'dir/test.txt', 'dir/dir/test.txt']"], {}), "('path', ['test.txt', 'dir/test.txt',\n 'dir/dir/test.txt'])\n", (495, 557), False, 'import pytest\n'), ((3012, 3083), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Tue Mar 12 13:20:48 2019
@author: asabater
"""
from PIL import Image
import numpy as np
from yolo3.model import preprocess_true_boxes
def rand(a=0, b=1):
return np.random.rand()*(b-a) + a
import cv2
# Perform data augmentation over an annotation lin... | [
"numpy.clip",
"PIL.Image.fromarray",
"numpy.random.rand",
"numpy.logical_and",
"numpy.random.choice",
"PIL.Image.new",
"yolo3.model.preprocess_true_boxes",
"numpy.asarray",
"numpy.stack",
"numpy.zeros",
"numpy.array",
"cv2.cvtColor",
"cv2.resize",
"cv2.imread",
"numpy.arange",
"numpy.r... | [((3564, 3588), 'numpy.zeros', 'np.zeros', (['(max_boxes, 5)'], {}), '((max_boxes, 5))\n', (3572, 3588), True, 'import numpy as np\n'), ((4394, 4421), 'numpy.arange', 'np.arange', (['(320)', '(608 + 1)', '(32)'], {}), '(320, 608 + 1, 32)\n', (4403, 4421), True, 'import numpy as np\n'), ((705, 718), 'cv2.imread', 'cv2.i... |
# Copyright (c) 2012 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Finds desktop browsers that can be controlled by telemetry."""
import logging
import os
import subprocess
import sys
from telemetry.core import brows... | [
"telemetry.core.profile_types.GetProfileCreator",
"os.path.exists",
"telemetry.core.chrome.desktop_browser_backend.DesktopBrowserBackend",
"telemetry.core.platform.linux_platform_backend.LinuxPlatformBackend",
"os.getenv",
"sys.platform.startswith",
"os.path.join",
"logging.warning",
"os.path.dirnam... | [((6023, 6055), 'sys.platform.startswith', 'sys.platform.startswith', (['"""linux"""'], {}), "('linux')\n", (6046, 6055), False, 'import sys\n'), ((6482, 6512), 'sys.platform.startswith', 'sys.platform.startswith', (['"""win"""'], {}), "('win')\n", (6505, 6512), False, 'import sys\n'), ((1402, 1579), 'telemetry.core.ch... |
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from sklearn.calibration import calibration_curve
import pickle
def reliability(y, y_prob):
nbin = 10
# class0
y_true = y.copy()
y_true[y_true == 0] = 4
y_true[y_true != 4] = 0
y_true[y_true == 4] = 1
select = y_prob[:,... | [
"pandas.read_csv",
"matplotlib.pyplot.plot",
"numpy.exp",
"numpy.array",
"numpy.linspace",
"matplotlib.pyplot.figure",
"sklearn.calibration.calibration_curve",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.show"
] | [((355, 401), 'sklearn.calibration.calibration_curve', 'calibration_curve', (['y_true', 'select'], {'n_bins': 'nbin'}), '(y_true, select, n_bins=nbin)\n', (372, 401), False, 'from sklearn.calibration import calibration_curve\n'), ((505, 551), 'sklearn.calibration.calibration_curve', 'calibration_curve', (['y_true', 'se... |
import logging
import unittest
import bus
class FakeHandler:
def __init__(self):
self.handle_called = False
self.command = None
def handle(self, command):
self.handle_called = True
self.command = command
class RaiseExceptionHandler:
def __init__(self):
pass
... | [
"logging.getLogger",
"bus.Bus"
] | [((460, 479), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (477, 479), False, 'import logging\n'), ((578, 587), 'bus.Bus', 'bus.Bus', ([], {}), '()\n', (585, 587), False, 'import bus\n'), ((849, 858), 'bus.Bus', 'bus.Bus', ([], {}), '()\n', (856, 858), False, 'import bus\n'), ((1156, 1165), 'bus.Bus', 'b... |
"""This module provides secure versions of common mathematical statistics functions.
The module is modeled after the statistics module in the Python standard library, and
as such aimed at small scale use ("at the level of graphing and scientific calculators").
Functions mean, median, median_low, median_high, and m... | [
"statistics.mean",
"statistics.stdev",
"statistics.pvariance",
"mpyc.random.random_unit_vector",
"statistics.StatisticsError",
"statistics.median",
"statistics.mode",
"statistics.variance",
"statistics.pstdev"
] | [((2449, 2467), 'statistics.mean', 'statistics.mean', (['x'], {}), '(x)\n', (2464, 2467), False, 'import statistics\n'), ((5384, 5410), 'statistics.pvariance', 'statistics.pvariance', (['x', 'm'], {}), '(x, m)\n', (5404, 5410), False, 'import statistics\n'), ((6243, 6266), 'statistics.pstdev', 'statistics.pstdev', (['x... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import soniccmsscaletest
import os.path as osp
import logging, glob
logger = logging.getLogger('soniccmsscaletest')
class TarballManager(object):
"""
TarballManager docstring
"""
def __init__(self):
"""
Constructor method
"""
... | [
"logging.getLogger",
"soniccmsscaletest.utils.run_command",
"os.path.join",
"os.path.isfile",
"os.path.dirname",
"os.path.basename",
"os.path.abspath",
"soniccmsscaletest.utils.check_is_cmssw_path"
] | [((123, 161), 'logging.getLogger', 'logging.getLogger', (['"""soniccmsscaletest"""'], {}), "('soniccmsscaletest')\n", (140, 161), False, 'import logging, glob\n'), ((660, 683), 'os.path.abspath', 'osp.abspath', (['cmssw_path'], {}), '(cmssw_path)\n', (671, 683), True, 'import os.path as osp\n'), ((701, 720), 'os.path.a... |
from collections import deque
n, q = map(int, input().split())
g = [[] for _ in range(n)]
for _ in range(n - 1):
a, b = map(int, input().split())
a, b = a - 1, b - 1
g[a].append(b)
g[b].append(a)
query = []
for _ in range(q):
x, y = map(int, input().split())
query.append((x - 1, y - 1))
d = ... | [
"collections.deque"
] | [((350, 360), 'collections.deque', 'deque', (['[0]'], {}), '([0])\n', (355, 360), False, 'from collections import deque\n')] |
import funções_exercisios
preco = int(input('digte o preço R$ '))
a = funções_exercisios.metade(preco)
b = funções_exercisios.dobrar(preco)
c = funções_exercisios.porcentagem(preco)
print('a metade de {} é {}'.format(preco, a))
print('o dobro de {} é {}'.format(preco, b))
print('aumentamdo 10% temos {}'.format(c))
| [
"funções_exercisios.dobrar",
"funções_exercisios.porcentagem",
"funções_exercisios.metade"
] | [((70, 102), 'funções_exercisios.metade', 'funções_exercisios.metade', (['preco'], {}), '(preco)\n', (95, 102), False, 'import funções_exercisios\n'), ((107, 139), 'funções_exercisios.dobrar', 'funções_exercisios.dobrar', (['preco'], {}), '(preco)\n', (132, 139), False, 'import funções_exercisios\n'), ((144, 181), 'fun... |
import pytest
from frameioclient import FrameioClient
@pytest.fixture
def frameioclient(token):
return FrameioClient("aaaabbbbccccddddeeee")
| [
"frameioclient.FrameioClient"
] | [((106, 143), 'frameioclient.FrameioClient', 'FrameioClient', (['"""aaaabbbbccccddddeeee"""'], {}), "('aaaabbbbccccddddeeee')\n", (119, 143), False, 'from frameioclient import FrameioClient\n')] |
"""Adds config flow for Blueprint."""
import logging
import voluptuous as vol
from homeassistant import config_entries
from .const import CONF_MQTT_BASE_TOPIC, CONF_PHONIEBOX_NAME, DOMAIN
class BlueprintFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
"""Config flow for Blueprint."""
VERSION = 1
... | [
"voluptuous.Required"
] | [((1381, 1455), 'voluptuous.Required', 'vol.Required', (['CONF_PHONIEBOX_NAME'], {'default': 'user_input[CONF_PHONIEBOX_NAME]'}), '(CONF_PHONIEBOX_NAME, default=user_input[CONF_PHONIEBOX_NAME])\n', (1393, 1455), True, 'import voluptuous as vol\n'), ((1528, 1604), 'voluptuous.Required', 'vol.Required', (['CONF_MQTT_BASE... |
from .. import db
import json
from config import Config
class BaseModelWithOptions(db.Model):
__abstract__ = True
def extract_options(self, prepend="option_"):
"""
Adds "option_" to each individual option and returns
a dict
"""
opts = {}
try:
opts... | [
"json.loads",
"json.dumps"
] | [((323, 347), 'json.loads', 'json.loads', (['self.options'], {}), '(self.options)\n', (333, 347), False, 'import json\n'), ((734, 758), 'json.loads', 'json.loads', (['self.options'], {}), '(self.options)\n', (744, 758), False, 'import json\n'), ((4659, 4672), 'json.dumps', 'json.dumps', (['o'], {}), '(o)\n', (4669, 467... |
import wfdb
import numpy as np
from glob import glob
import biosppy
import os
import cv2
import pandas as pd
wfdb.io.show_ann_labels()
from matplotlib import pyplot as plt
mitdb_path = '/home/jungkap/Documents/datathon/alpha.physionet.org/files/afdb/1.0.0/'
paths = glob('{}*.atr'.format(mitdb_path))
paths = [path[... | [
"wfdb.io.show_ann_labels",
"wfdb.rdann",
"wfdb.rdsamp"
] | [((112, 137), 'wfdb.io.show_ann_labels', 'wfdb.io.show_ann_labels', ([], {}), '()\n', (135, 137), False, 'import wfdb\n'), ((980, 1018), 'wfdb.rdsamp', 'wfdb.rdsamp', (['record_name'], {'channels': '[0]'}), '(record_name, channels=[0])\n', (991, 1018), False, 'import wfdb\n'), ((1030, 1060), 'wfdb.rdann', 'wfdb.rdann',... |
import datetime
import enum
from Swag import db
class Category(enum.Enum):
Shirts = 1
Sweatshirts = 2
Glassware = 3
Stickers = 4
Misc = 5
class PaymentMethod(enum.Enum):
Cash = 1
Check = 2
Venmo = 3
Paypal = 4
Card = 5
Online = 6
class SizeOptions(enum.Enum):
Stand... | [
"Swag.db.backref",
"Swag.db.Column",
"Swag.db.Enum",
"Swag.db.ForeignKey",
"Swag.db.DECIMAL",
"Swag.db.VARCHAR"
] | [((490, 582), 'Swag.db.Column', 'db.Column', (['db.Integer'], {'primary_key': '(True)', 'nullable': '(False)', 'autoincrement': '(True)', 'unique': '(True)'}), '(db.Integer, primary_key=True, nullable=False, autoincrement=True,\n unique=True)\n', (499, 582), False, 'from Swag import db\n'), ((1178, 1270), 'Swag.db.C... |
from setuptools import setup, find_packages
setup(
name="geohealthaccess",
version="0.1",
description="Mapping accessibility to health services",
classifiers=[
"Development Status :: 3 - Alpha",
"Intended Audience :: Developers",
"Intended Audience :: Science/Research",
... | [
"setuptools.find_packages"
] | [((643, 706), 'setuptools.find_packages', 'find_packages', ([], {'include': "['geohealthaccess', 'geohealthaccess.*']"}), "(include=['geohealthaccess', 'geohealthaccess.*'])\n", (656, 706), False, 'from setuptools import setup, find_packages\n')] |
#!/usr/bin/env python3
"""A simple web crawler -- main driver program."""
import asyncio
import logging
import sys
import os
from sky.crawler.crawling import Crawler
from sky.crawler.reporting import report
def get_config(config, loop):
for i in range(len(config["seed_urls"])):
if "://" not in config["... | [
"asyncio.set_event_loop",
"asyncio.new_event_loop",
"sys.stderr.flush",
"sky.crawler.reporting.report"
] | [((885, 909), 'asyncio.new_event_loop', 'asyncio.new_event_loop', ([], {}), '()\n', (907, 909), False, 'import asyncio\n'), ((915, 943), 'asyncio.set_event_loop', 'asyncio.set_event_loop', (['loop'], {}), '(loop)\n', (937, 943), False, 'import asyncio\n'), ((1617, 1632), 'sky.crawler.reporting.report', 'report', (['cra... |
# Copyright 2019 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | [
"tensorflow.compat.v2.reduce_sum",
"tensorflow.compat.v2.size",
"tensorflow.compat.v2.keras.initializers.Ones",
"tensorflow.compat.v2.nn.relu",
"tensorflow.compat.v2.keras.initializers.Zeros",
"tensorflow.compat.v2.cast",
"tensorflow.compat.v2.random.uniform",
"tensorflow.compat.v2.keras.layers.BatchN... | [((2229, 2414), 'tensorflow.compat.v2.keras.layers.BatchNormalization', 'tf.keras.layers.BatchNormalization', ([], {'momentum': 'momentum', 'epsilon': 'epsilon', 'center': '(True)', 'scale': '(True)', 'trainable': 'trainable', 'fused': 'fused', 'gamma_initializer': 'gamma_initializer', 'name': 'name'}), '(momentum=mome... |
import numpy as np
import ac_core
import matplotlib.pyplot as plt
def primaris_smite(bonus = 0, wc = 5):
damage = 0
test = ac_core.d6() + ac_core.d6() + bonus
if test > 10:
damage = ac_core.d6()
elif test > wc:
damage = ac_core.d3()
return damage
def wyrdvane_smite(bonus = ... | [
"ac_core.d6",
"numpy.mean",
"matplotlib.pyplot.grid",
"ac_core.d3",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.title",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.show"
] | [((1621, 1635), 'matplotlib.pyplot.subplots', 'plt.subplots', ([], {}), '()\n', (1633, 1635), True, 'import matplotlib.pyplot as plt\n'), ((1721, 1731), 'matplotlib.pyplot.grid', 'plt.grid', ([], {}), '()\n', (1729, 1731), True, 'import matplotlib.pyplot as plt\n'), ((1736, 1773), 'matplotlib.pyplot.title', 'plt.title'... |
# -*- coding: utf-8 -*-
"""
Creating ``tf.data.Dataset`` instance for image window sampler.
"""
from __future__ import absolute_import, division, print_function
import inspect
import numpy as np
import tensorflow as tf
# pylint: disable=no-name-in-module
from tensorflow.python.data.util import nest
from tensorflow.py... | [
"tensorflow.shape",
"tensorflow.pad",
"tensorflow.data.Dataset.range",
"tensorflow.logging.warning",
"tensorflow.logging.info",
"tensorflow.python.data.util.nest.flatten",
"numpy.asarray",
"tensorflow.data.Dataset.from_generator",
"niftynet.io.misc_io.squeeze_spatial_temporal_dim",
"niftynet.engin... | [((2100, 2131), 'niftynet.layer.base_layer.Layer.__init__', 'Layer.__init__', (['self'], {'name': 'name'}), '(self, name=name)\n', (2114, 2131), False, 'from niftynet.layer.base_layer import Layer\n'), ((2677, 2719), 'inspect.isgeneratorfunction', 'inspect.isgeneratorfunction', (['self.layer_op'], {}), '(self.layer_op)... |
from livewires import games, color
from generate4 import *
import pygame,math
screen_width = 620
screen_height = 620
tilesize = 20
games.init(screen_width = screen_width,screen_height = screen_height, fps=50)
shaft123 = games.load_image("hidden\\shaft.png", transparent=False)
tiles = [games.load_image("hidden\\plan... | [
"pygame.transform.flip",
"livewires.games.init",
"math.ceil",
"livewires.games.load_image",
"livewires.games.screen.set_background",
"pygame.Surface",
"math.floor",
"pygame.transform.rotate",
"livewires.games.screen.add",
"livewires.games.keyboard.is_pressed",
"livewires.games.Text",
"livewire... | [((134, 208), 'livewires.games.init', 'games.init', ([], {'screen_width': 'screen_width', 'screen_height': 'screen_height', 'fps': '(50)'}), '(screen_width=screen_width, screen_height=screen_height, fps=50)\n', (144, 208), False, 'from livewires import games, color\n'), ((224, 280), 'livewires.games.load_image', 'games... |
import numpy as np
fft2 = np.fft.fft2
ifft2 = np.fft.ifft2
fftshift = np.fft.fftshift
ifftshift = np.fft.ifftshift
def cart2pol(x, y):
r = np.sqrt(x**2 + y**2)
phi = np.arctan2(y, x)
return (r, phi)
def pol2cart(r, phi):
x = r * np.cos(phi)
y = r * np.sin(phi)
return (x, y)
def ft2(g, d... | [
"numpy.cos",
"numpy.sin",
"numpy.sqrt",
"numpy.arctan2"
] | [((147, 171), 'numpy.sqrt', 'np.sqrt', (['(x ** 2 + y ** 2)'], {}), '(x ** 2 + y ** 2)\n', (154, 171), True, 'import numpy as np\n'), ((178, 194), 'numpy.arctan2', 'np.arctan2', (['y', 'x'], {}), '(y, x)\n', (188, 194), True, 'import numpy as np\n'), ((252, 263), 'numpy.cos', 'np.cos', (['phi'], {}), '(phi)\n', (258, 2... |
# To add a new cell, type '# %%'
# To add a new markdown cell, type '# %% [markdown]'
# %% [markdown]
# # How to use custom data and implement custom models and metrics
# %% [markdown]
# ## Building a simple, first model
# %% [markdown]
# For demonstration purposes we will choose a simple fully connected model. It take... | [
"torch.nn.ReLU",
"numpy.random.rand",
"torch.nn.Sequential",
"pytorch_lightning.Trainer",
"pytorch_forecasting.metrics.NormalDistributionLoss",
"numpy.arange",
"torch.arange",
"pytorch_forecasting.metrics.SMAPE",
"torch.roll",
"pytorch_forecasting.models.nn.MultiEmbedding",
"numpy.random.choice"... | [((582, 602), 'os.chdir', 'os.chdir', (['"""../../.."""'], {}), "('../../..')\n", (590, 602), False, 'import os\n'), ((1527, 1544), 'torch.rand', 'torch.rand', (['(20)', '(5)'], {}), '(20, 5)\n', (1537, 1544), False, 'import torch\n'), ((3507, 3738), 'pytorch_forecasting.TimeSeriesDataSet', 'TimeSeriesDataSet', (['test... |
from __future__ import unicode_literals
from django import template
from rolepermissions.verifications import has_role, has_permission, has_object_permission
register = template.Library()
@register.filter(name='has_role')
def has_role_template_tag(user, role):
role_list = role.split(',')
return has_role(us... | [
"rolepermissions.verifications.has_permission",
"rolepermissions.verifications.has_role",
"rolepermissions.verifications.has_object_permission",
"django.template.Library"
] | [((173, 191), 'django.template.Library', 'template.Library', ([], {}), '()\n', (189, 191), False, 'from django import template\n'), ((309, 334), 'rolepermissions.verifications.has_role', 'has_role', (['user', 'role_list'], {}), '(user, role_list)\n', (317, 334), False, 'from rolepermissions.verifications import has_rol... |
from utils.io import inspect_data_dirs
from configs import DATA_DIRS
inspect_data_dirs(DATA_DIRS)
| [
"utils.io.inspect_data_dirs"
] | [((70, 98), 'utils.io.inspect_data_dirs', 'inspect_data_dirs', (['DATA_DIRS'], {}), '(DATA_DIRS)\n', (87, 98), False, 'from utils.io import inspect_data_dirs\n')] |
# encoding: utf-8
"""
Training implementation
Author: <NAME>
Update time: 08/11/2020
"""
import re
import sys
import os
import cv2
import time
import numpy as np
import torch
import torch.nn as nn
import torch.backends.cudnn as cudnn
from torch.optim import lr_scheduler
import torch.optim as optim
import torchvision
im... | [
"numpy.uint8",
"re.compile",
"sklearn.metrics.roc_auc_score",
"numpy.array",
"cv2.threshold",
"model.Fusion_Branch",
"numpy.max",
"numpy.min",
"torchvision.transforms.ToTensor",
"os.path.isfile",
"torchvision.transforms.Normalize",
"torchvision.transforms.Resize",
"cv2.resize",
"time.time"... | [((1369, 1444), 'torchvision.transforms.Normalize', 'transforms.Normalize', ([], {'mean': '[0.485, 0.456, 0.406]', 'std': '[0.229, 0.224, 0.225]'}), '(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])\n', (1389, 1444), True, 'import torchvision.transforms as transforms\n'), ((3162, 3229), 'cv2.threshold', 'cv2.thr... |
"""Admin config."""
from flask_admin.contrib.sqla import ModelView
from dude.extensions import admin, db
from dude.user.models import Role, User
admin.add_view(ModelView(Role, db.session))
admin.add_view(ModelView(User, db.session))
| [
"flask_admin.contrib.sqla.ModelView"
] | [((162, 189), 'flask_admin.contrib.sqla.ModelView', 'ModelView', (['Role', 'db.session'], {}), '(Role, db.session)\n', (171, 189), False, 'from flask_admin.contrib.sqla import ModelView\n'), ((206, 233), 'flask_admin.contrib.sqla.ModelView', 'ModelView', (['User', 'db.session'], {}), '(User, db.session)\n', (215, 233),... |
# -*- coding: utf-8 -*-
from django.db import models
from v1.models.Board import Boards
from v1.models.State import States
class Tasks(models.Model):
title = models.CharField(max_length=50)
description = models.CharField(max_length=500)
date_created = models.DateTimeField(auto_now_add=True)
date_mod... | [
"django.db.models.DateTimeField",
"django.db.models.ForeignKey",
"django.db.models.CharField",
"django.db.models.BooleanField"
] | [((166, 197), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(50)'}), '(max_length=50)\n', (182, 197), False, 'from django.db import models\n'), ((216, 248), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(500)'}), '(max_length=500)\n', (232, 248), False, 'from django.db ... |
import unittest
from datetime import date
from pyramid import testing
from whoahqa.utils import format_date_for_locale
class TestLocaleDate(unittest.TestCase):
def test_returns_date_string_as_per_request_locale(self):
request = testing.DummyRequest()
formatted_date = format_date_for_locale(
... | [
"pyramid.testing.DummyRequest",
"datetime.date"
] | [((244, 266), 'pyramid.testing.DummyRequest', 'testing.DummyRequest', ([], {}), '()\n', (264, 266), False, 'from pyramid import testing\n'), ((328, 345), 'datetime.date', 'date', (['(2014)', '(3)', '(13)'], {}), '(2014, 3, 13)\n', (332, 345), False, 'from datetime import date\n')] |
'Build the bundled capnp distribution'
import subprocess
import os
import tempfile
def build_libcapnp(bundle_dir, build_dir, verbose=False):
bundle_dir = os.path.abspath(bundle_dir)
capnp_dir = os.path.join(bundle_dir, 'capnproto-c++')
build_dir = os.path.abspath(build_dir)
with tempfile.TemporaryFile() as f... | [
"subprocess.Popen",
"os.path.join",
"os.environ.get",
"os.path.abspath",
"tempfile.TemporaryFile"
] | [((158, 185), 'os.path.abspath', 'os.path.abspath', (['bundle_dir'], {}), '(bundle_dir)\n', (173, 185), False, 'import os\n'), ((200, 241), 'os.path.join', 'os.path.join', (['bundle_dir', '"""capnproto-c++"""'], {}), "(bundle_dir, 'capnproto-c++')\n", (212, 241), False, 'import os\n'), ((256, 282), 'os.path.abspath', '... |
import asyncio
import time
from asyncio import run, create_task, CancelledError
from typing import List, Dict
from dataclasses import dataclass, asdict, field
import json
import zmq
from zmq.asyncio import Context, Socket
import gamestate
#import traceback
SERVER_UPDATE_TICK_HZ = 10
async def update_from_client(gs:... | [
"gamestate.Event",
"asyncio.wait",
"zmq.asyncio.Context",
"asyncio.sleep",
"gamestate.GameState"
] | [((1298, 1319), 'gamestate.GameState', 'gamestate.GameState', ([], {}), '()\n', (1317, 1319), False, 'import gamestate\n'), ((1877, 1886), 'zmq.asyncio.Context', 'Context', ([], {}), '()\n', (1884, 1886), False, 'from zmq.asyncio import Context, Socket\n'), ((2223, 2287), 'asyncio.wait', 'asyncio.wait', (['[ticker_task... |
import sys
from typing import Any, Text, NoReturn
import rasa.shared.utils.io
def print_color(*args: Any, color: Text):
print(rasa.shared.utils.io.wrap_with_color(*args, color=color))
def print_success(*args: Any):
print_color(*args, color=rasa.shared.utils.io.bcolors.OKGREEN)
def print_info(*args: Any):... | [
"sys.exit"
] | [((743, 762), 'sys.exit', 'sys.exit', (['exit_code'], {}), '(exit_code)\n', (751, 762), False, 'import sys\n')] |
# Generated by Django 3.0.13 on 2021-04-04 06:32
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
("vulnerabilities", "0001_initial"),
]
operations = [
migrations.AddField(
model_name="packagere... | [
"django.db.models.CharField",
"django.db.models.ForeignKey"
] | [((395, 552), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'blank': '(True)', 'null': '(True)', 'on_delete': 'django.db.models.deletion.CASCADE', 'related_name': '"""patched_package"""', 'to': '"""vulnerabilities.Package"""'}), "(blank=True, null=True, on_delete=django.db.models.\n deletion.CASCADE, rel... |
import bpy
import glob
if __name__ == "__main__":
for i in range(0,1000,4):
bpy.ops.object.select_all(action='SELECT')
bpy.ops.object.delete()
files = glob.glob('/home/backes/dev/pbs20-wall/recordings/rec3/obj_*_'+str(i)+'.obj')
for file in files:
if (str(file) == '/home... | [
"bpy.ops.object.delete",
"bpy.ops.object.select_all"
] | [((89, 131), 'bpy.ops.object.select_all', 'bpy.ops.object.select_all', ([], {'action': '"""SELECT"""'}), "(action='SELECT')\n", (114, 131), False, 'import bpy\n'), ((140, 163), 'bpy.ops.object.delete', 'bpy.ops.object.delete', ([], {}), '()\n', (161, 163), False, 'import bpy\n'), ((747, 789), 'bpy.ops.object.select_all... |
# This file was automatically generated by SWIG (http://www.swig.org).
# Version 3.0.12
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.
from sys import version_info as _swig_python_version_info
if _swig_python_version_info >= (2, 7, 0):
def swig_im... | [
"_cssWlsEst.intArray_getitem",
"_cssWlsEst.computeWlsmn",
"_cssWlsEst.new_doubleArray",
"_cssWlsEst.shortArray_getitem",
"imp.load_module",
"_cssWlsEst.new_intArray",
"_cssWlsEst.new_SunlineFilterFswMsg",
"_cssWlsEst.new_shortArray",
"_cssWlsEst.delete_longArray",
"inspect.getmembers",
"_cssWlsE... | [((2940, 2977), '_cssWlsEst.new_doubleArray', '_cssWlsEst.new_doubleArray', (['nelements'], {}), '(nelements)\n', (2966, 2977), False, 'import _cssWlsEst\n'), ((3064, 3098), '_cssWlsEst.delete_doubleArray', '_cssWlsEst.delete_doubleArray', (['ary'], {}), '(ary)\n', (3093, 3098), False, 'import _cssWlsEst\n'), ((3199, 3... |
from discord.ext import commands
import discord
import time
import json
from pathlib import Path
import random
file_path = Path("database/afk.json")
class TestCogCommands(commands.Cog):
def __init__(self, bot: commands.Bot):
self.bot = bot
self.last_msg = None
self.file = None
se... | [
"discord.ext.commands.Cog.listener",
"pathlib.Path",
"discord.Game",
"json.dumps",
"time.time",
"json.load",
"discord.Embed",
"discord.ext.commands.command"
] | [((124, 149), 'pathlib.Path', 'Path', (['"""database/afk.json"""'], {}), "('database/afk.json')\n", (128, 149), False, 'from pathlib import Path\n'), ((370, 399), 'discord.ext.commands.command', 'commands.command', ([], {'name': '"""ping"""'}), "(name='ping')\n", (386, 399), False, 'from discord.ext import commands\n')... |
from os import path
from setuptools import setup, find_packages
version = "0.0.10"
directory = path.abspath(path.dirname(__file__))
with open(path.join(directory, 'README.md'), encoding='utf-8') as file:
long_description = file.read()
setup(
name='DSAs',
version=version,
author='discretegames',
a... | [
"os.path.dirname",
"setuptools.find_packages",
"os.path.join"
] | [((110, 132), 'os.path.dirname', 'path.dirname', (['__file__'], {}), '(__file__)\n', (122, 132), False, 'from os import path\n'), ((144, 177), 'os.path.join', 'path.join', (['directory', '"""README.md"""'], {}), "(directory, 'README.md')\n", (153, 177), False, 'from os import path\n'), ((580, 600), 'setuptools.find_pac... |
from src.utils.db_utils import execute_sql,insert_query, save_rds_pandas
from src.models.save_model import save_upload, parse_filename
from datetime import date, datetime
from pyspark.sql import SparkSession
from pyspark.sql.types import IntegerType, DoubleType
from pyspark.sql.functions import monotonically_increasi... | [
"psycopg2.connect",
"pyspark.mllib.evaluation.MulticlassMetrics",
"pyspark.ml.feature.Imputer",
"pyspark.sql.functions.countDistinct",
"pyspark.ml.classification.LogisticRegression",
"pandas.read_sql_query",
"pyspark.ml.feature.PCA",
"src.models.save_model.parse_filename",
"pyspark.ml.evaluation.Bin... | [((1548, 1572), 'psycopg2.connect', 'pg.connect', (['config_psyco'], {}), '(config_psyco)\n', (1558, 1572), True, 'import psycopg2 as pg\n'), ((2095, 2142), 'pandas.read_sql_query', 'pd.read_sql_query', (['query_select'], {'con': 'connection'}), '(query_select, con=connection)\n', (2112, 2142), True, 'import pandas as ... |
# -*- coding: utf-8 -*-
import scrapy
from scrapy import Spider
from douban.items import BookItem, BookCommentItem
class BookSpider(Spider):
name = 'book_spider'
allowed_domains = ['book.douban.com']
def start_requests(self):
"""
Top250列表页非常规律，每页25条记录，所以后一页查询参数为当前页查询参数+25
:retur... | [
"douban.items.BookItem",
"douban.items.BookCommentItem"
] | [((4823, 4837), 'douban.items.BookItem', 'BookItem', (['data'], {}), '(data)\n', (4831, 4837), False, 'from douban.items import BookItem, BookCommentItem\n'), ((5305, 5322), 'douban.items.BookCommentItem', 'BookCommentItem', ([], {}), '()\n', (5320, 5322), False, 'from douban.items import BookItem, BookCommentItem\n')] |
import typing
import matplotlib.pyplot as plt
import numpy as np
from . import plot_ticks
plot_specs = {
'PlotData': {
'common': {
'merge': {'key_name': 'key_content'},
# ... PlotDatum keys and values
},
'plots': {'PlotID': 'PlotDatum'},
'subplot_height': ... | [
"numpy.ceil",
"matplotlib.pyplot.hist",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.gca",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.axhline",
"matplotlib.pyplot.subplot",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.title",
"matplotlib.pyplot.xlim",
"matplot... | [((4492, 4512), 'matplotlib.pyplot.figure', 'plt.figure', ([], {}), '(**figure)\n', (4502, 4512), True, 'import matplotlib.pyplot as plt\n'), ((2031, 2087), 'matplotlib.pyplot.stackplot', 'plt.stackplot', (['x', "*plot_datum['stacks']"], {}), "(x, *plot_datum['stacks'], **stacks_kwargs)\n", (2044, 2087), True, 'import ... |
import logging
from assigner import manage_repos
from assigner.backends.exceptions import (
UserInAssignerGroup,
UserNotAssigned,
)
help = "Lock students out of repos"
logger = logging.getLogger(__name__)
def lock(args):
"""Sets each student to Reporter status on their homework repository s... | [
"logging.getLogger",
"logging.info",
"assigner.manage_repos"
] | [((200, 227), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (217, 227), False, 'import logging\n'), ((420, 445), 'assigner.manage_repos', 'manage_repos', (['args', '_lock'], {}), '(args, _lock)\n', (432, 445), False, 'from assigner import manage_repos\n'), ((575, 697), 'logging.info', 'l... |
from django.contrib import admin
from .models import CustomUser, Equipment, Search, TagManagement
from .models import Reserved, Request, Vote, Log, Tag
admin.site.register(CustomUser)
admin.site.register(Equipment)
admin.site.register(Search)
admin.site.register(Reserved)
admin.site.register(Request)
admin.site.regist... | [
"django.contrib.admin.site.register"
] | [((153, 184), 'django.contrib.admin.site.register', 'admin.site.register', (['CustomUser'], {}), '(CustomUser)\n', (172, 184), False, 'from django.contrib import admin\n'), ((185, 215), 'django.contrib.admin.site.register', 'admin.site.register', (['Equipment'], {}), '(Equipment)\n', (204, 215), False, 'from django.con... |
"""
996. Number of Squareful Arrays
Given an array A of non-negative integers, the array is squareful if for every pair of adjacent elements, their sum is a perfect square.
Return the number of permutations of A that are squareful. Two permutations A1 and A2 differ if and only if there is some index i such that A1[i]... | [
"math.sqrt"
] | [((2307, 2321), 'math.sqrt', 'math.sqrt', (['num'], {}), '(num)\n', (2316, 2321), False, 'import math\n')] |
import sys
sys.path.insert(0, '')
import torch
import torch.nn as nn
import torch.nn.functional as F
import pickle
from .utils import import_class, count_params
from .ms_gcn import MultiScale_GraphConv as MS_GCN
from .ms_tcn import MultiScale_TemporalConv as MS_TCN
from .ms_gtcn import SpatialTemporal_MS_GCN, UnfoldT... | [
"torch.nn.BatchNorm2d",
"sys.path.insert",
"pickle.dumps",
"einops.rearrange",
"torch.nn.BatchNorm1d",
"torch.nn.Linear",
"torch.nn.Identity",
"sys.path.append",
"torch.randn",
"torch.cat",
"torch.nn.Conv3d"
] | [((11, 33), 'sys.path.insert', 'sys.path.insert', (['(0)', '""""""'], {}), "(0, '')\n", (26, 33), False, 'import sys\n'), ((7145, 7166), 'sys.path.append', 'sys.path.append', (['""".."""'], {}), "('..')\n", (7160, 7166), False, 'import sys\n'), ((7404, 7430), 'torch.randn', 'torch.randn', (['N', 'C', 'T', 'V', 'M'], {}... |
import h5py
import numpy as np
import os
import sys
import time
usage = '''
driver.py D F N outputfile
where D = delay in microseconds between writes
F = number of writes between flushes and chunksize
N = total number of elements to write
outputfile = name of output file
'''
def run_... | [
"os.system",
"time.time"
] | [((347, 358), 'time.time', 'time.time', ([], {}), '()\n', (356, 358), False, 'import time\n'), ((413, 431), 'os.system', 'os.system', (['command'], {}), '(command)\n', (422, 431), False, 'import os\n'), ((715, 726), 'time.time', 'time.time', ([], {}), '()\n', (724, 726), False, 'import time\n'), ((472, 483), 'time.time... |
__author__ = '<NAME>'
"""
Submitted by: <NAME>
i.d: 318013356
date: 25.03.2020
"""
from copy import deepcopy
import random
import argparse
import traceback
random.seed(30)
# ## Reed Solomon error correction
class ReedSolomon:
# Galois fields
# -- exponents (anti-logarithms)
__GFEXP = [0] * 512
# -- l... | [
"traceback.format_exc",
"argparse.ArgumentParser",
"random.seed",
"copy.deepcopy",
"random.randint"
] | [((157, 172), 'random.seed', 'random.seed', (['(30)'], {}), '(30)\n', (168, 172), False, 'import random\n'), ((12377, 12392), 'copy.deepcopy', 'deepcopy', (['tCode'], {}), '(tCode)\n', (12385, 12392), False, 'from copy import deepcopy\n'), ((12548, 12570), 'random.randint', 'random.randint', (['(0)', '(100)'], {}), '(0... |
import os
import shutil
import time
from deeplens.dataflow.agg import counts
from deeplens.full_manager.condition import Condition
from deeplens.full_manager.full_manager import FullStorageManager
from deeplens.full_manager.full_video_processing import CropSplitter
from deeplens.media.youtube_tagger import YoutubeTagg... | [
"os.path.exists",
"deeplens.dataflow.agg.counts",
"deeplens.media.youtube_tagger.YoutubeTagger",
"deeplens.tracking.contour.KeyPoints",
"deeplens.full_manager.condition.Condition",
"deeplens.full_manager.full_video_processing.CropSplitter",
"os.path.basename",
"shutil.rmtree",
"time.time"
] | [((665, 730), 'deeplens.media.youtube_tagger.YoutubeTagger', 'YoutubeTagger', (['src', '"""./train/processed_yt_bb_detection_train.csv"""'], {}), "(src, './train/processed_yt_bb_detection_train.csv')\n", (678, 730), False, 'from deeplens.media.youtube_tagger import YoutubeTagger\n'), ((1158, 1169), 'time.time', 'time.t... |
from __future__ import unicode_literals
import gzip
from io import BytesIO
from django.contrib.staticfiles import finders
from django.contrib.staticfiles.storage import CachedStaticFilesStorage, StaticFilesStorage
from django.contrib.staticfiles.utils import matches_patterns
from django.core.exceptions import Impro... | [
"io.BytesIO",
"django.core.files.storage.get_storage_class",
"django.contrib.staticfiles.utils.matches_patterns",
"gzip.GzipFile",
"pipeline.packager.Packager",
"django.core.files.base.File",
"django.core.exceptions.ImproperlyConfigured"
] | [((733, 755), 'pipeline.packager.Packager', 'Packager', ([], {'storage': 'self'}), '(storage=self)\n', (741, 755), False, 'from pipeline.packager import Packager\n'), ((1957, 1966), 'io.BytesIO', 'BytesIO', ([], {}), '()\n', (1964, 1966), False, 'from io import BytesIO\n'), ((1987, 2028), 'gzip.GzipFile', 'gzip.GzipFil... |
import setuptools
from sys import platform
# Use README for long description
with open('README.md', 'r') as readme_fp:
long_description = readme_fp.read()
with open('requirements.txt', 'r') as req_fp:
required_libs = req_fp.readlines()
# py_cui setup
setuptools.setup(
name='py_cui',
description='A w... | [
"setuptools.find_packages"
] | [((609, 680), 'setuptools.find_packages', 'setuptools.find_packages', ([], {'exclude': "['docs', 'tests', 'examples', 'venv']"}), "(exclude=['docs', 'tests', 'examples', 'venv'])\n", (633, 680), False, 'import setuptools\n')] |
"""
==================
Two-class AdaBoost
==================
This example fits an AdaBoosted decision stump on a non-linearly separable
classification dataset composed of two "Gaussian quantiles" clusters
(see :func:`sklearn.datasets.make_gaussian_quantiles`) and plots the decision
boundary and decision scores. The di... | [
"matplotlib.pyplot.hist",
"matplotlib.pyplot.ylabel",
"numpy.arange",
"matplotlib.pyplot.contourf",
"numpy.where",
"matplotlib.pyplot.xlabel",
"sklearn.tree.DecisionTreeClassifier",
"numpy.concatenate",
"matplotlib.pyplot.scatter",
"matplotlib.pyplot.axis",
"matplotlib.pyplot.ylim",
"matplotli... | [((1171, 1265), 'sklearn.datasets.make_gaussian_quantiles', 'make_gaussian_quantiles', ([], {'cov': '(2.0)', 'n_samples': '(200)', 'n_features': '(2)', 'n_classes': '(2)', 'random_state': '(1)'}), '(cov=2.0, n_samples=200, n_features=2, n_classes=2,\n random_state=1)\n', (1194, 1265), False, 'from sklearn.datasets i... |
# faça um programa que leia o comprimento do cateto oposto e do
# cateto adjacente de um triangulo retangulo
# calcule e mostre o comprimento da hipotenusa
import math
x = float(input('Digite o valor do cateto oposto: '))
y = float(input('Digite o valor do cateto adjacente: '))
hip = math.hypot(x,y)
print('A Hipotenus... | [
"math.hypot"
] | [((285, 301), 'math.hypot', 'math.hypot', (['x', 'y'], {}), '(x, y)\n', (295, 301), False, 'import math\n'), ((366, 382), 'math.hypot', 'math.hypot', (['x', 'y'], {}), '(x, y)\n', (376, 382), False, 'import math\n')] |
import urbanscape as us
import matplotlib.pyplot as pyplot
import matplotlib.animation as animation
ppcr = us.profit_probability_create_rule
rcr = us.random_create_rule
def animate_urbanscape(urbanscape):
fig = pyplot.figure()
ax1 = fig.add_subplot(2, 2, 1)
ax2 = fig.add_subplot(2, 2, 2)
ax3 = fig.a... | [
"matplotlib.animation.FuncAnimation",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.show"
] | [((219, 234), 'matplotlib.pyplot.figure', 'pyplot.figure', ([], {}), '()\n', (232, 234), True, 'import matplotlib.pyplot as pyplot\n'), ((1370, 1433), 'matplotlib.animation.FuncAnimation', 'animation.FuncAnimation', (['fig', 'updatefig'], {'frames': '(100)', 'interval': '(1)'}), '(fig, updatefig, frames=100, interval=1... |
#SPDX-License-Identifier: MIT
"""
Handles global context, I/O, and configuration
"""
import os
from pathlib import Path
import logging
from logging import FileHandler, Formatter
import coloredlogs
import json
from beaker.cache import CacheManager
from beaker.util import parse_cache_config_options
import sqlalchemy as ... | [
"logging.getLogger",
"augur.config.AugurConfig",
"augur.logging.AugurLogging",
"os.path.exists",
"beaker.cache.CacheManager",
"os.makedirs",
"sqlalchemy.create_engine",
"augur.metrics.Metrics",
"beaker.util.parse_cache_config_options"
] | [((498, 525), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (515, 525), False, 'import logging\n'), ((830, 869), 'augur.logging.AugurLogging', 'AugurLogging', ([], {'disable_logs': 'disable_logs'}), '(disable_logs=disable_logs)\n', (842, 869), False, 'from augur.logging import AugurLoggi... |
#!/usr/bin/env python
# pylint: disable=no-value-for-parameter
import click
from decimal import Decimal
import time
import math
from datetime import datetime
from tfchainbalances import unlockhash_get
import stellar_sdk
import requests
FULL_ASSETCODES = {
"TFT": "TFT:GBOVQKJYHXRR3DX6NOX2RRYFRCUMSADGDESTDNBDS6CDV... | [
"tfchainbalances.unlockhash_get",
"click.argument",
"requests.post",
"datetime.datetime.fromtimestamp",
"tfchaintypes.CryptoTypes.PublicKey",
"math.ceil",
"click.option",
"click.File",
"stellar_sdk.Server",
"stellar_sdk.strkey.StrKey.decode_ed25519_public_key",
"click.command",
"time.time",
... | [((1607, 1674), 'click.command', 'click.command', ([], {'help': '"""Conversion check for a single tfchain address"""'}), "(help='Conversion check for a single tfchain address')\n", (1620, 1674), False, 'import click\n'), ((1676, 1733), 'click.argument', 'click.argument', (['"""tfchainaddress"""'], {'type': 'str', 'requ... |
import param
import numpy as np
import panel as pn
import holoviews as hv
from alerce.core import Alerce
hv.extension("bokeh")
hv.opts.defaults(
hv.opts.ErrorBars(
width=300,
height=200,
lower_head=None,
upper_head=None,
xrotation=35,
invert_yaxis=True,
xlim=... | [
"alerce.core.Alerce",
"holoviews.extension",
"holoviews.Overlay",
"param.Integer",
"holoviews.opts.ErrorBars",
"holoviews.DynamicMap",
"param.depends",
"numpy.mod",
"holoviews.ErrorBars",
"panel.Column"
] | [((106, 127), 'holoviews.extension', 'hv.extension', (['"""bokeh"""'], {}), "('bokeh')\n", (118, 127), True, 'import holoviews as hv\n'), ((346, 354), 'alerce.core.Alerce', 'Alerce', ([], {}), '()\n', (352, 354), False, 'from alerce.core import Alerce\n'), ((1880, 1920), 'panel.Column', 'pn.Column', (['explorer.view', ... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Copyright (c) 2012-2021 Snowflake Computing Inc. All rights reserved.
#
from concurrent.futures.thread import ThreadPoolExecutor
from logging import getLogger
import pytest
import snowflake.connector
from snowflake.connector.errors import ProgrammingError
try:
f... | [
"logging.getLogger",
"concurrent.futures.thread.ThreadPoolExecutor",
"pytest.mark.skipif"
] | [((435, 454), 'logging.getLogger', 'getLogger', (['__name__'], {}), '(__name__)\n', (444, 454), False, 'from logging import getLogger\n'), ((1488, 1602), 'pytest.mark.skipif', 'pytest.mark.skipif', (['(not CONNECTION_PARAMETERS_ADMIN)'], {'reason': '"""The user needs a privilege of create warehouse."""'}), "(not CONNEC... |
# Generated by Django 2.2.9 on 2020-01-31 21:16
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('user', '0001_initial'),
]
operations = [
migrations.AlterModelOptions(
name='user',
options={'ordering': ['first_nam... | [
"django.db.migrations.AlterModelOptions",
"django.db.models.FloatField",
"django.db.models.CharField"
] | [((221, 371), 'django.db.migrations.AlterModelOptions', 'migrations.AlterModelOptions', ([], {'name': '"""user"""', 'options': "{'ordering': ['first_name'], 'verbose_name': 'Cliente',\n 'verbose_name_plural': 'Clientes'}"}), "(name='user', options={'ordering': [\n 'first_name'], 'verbose_name': 'Cliente', 'verbos... |
from pandas.io import feather_format
import config
import time
import pandas as pd
import xgboost as xgb
from sklearn import metrics
from sklearn import preprocessing
def run(fold):
df = pd.read_csv(config.TRAINING_FILE)
features = [
f for f in df.columns if f not in ("id", "target", "kfold")
]... | [
"sklearn.preprocessing.LabelEncoder",
"pandas.read_csv",
"sklearn.metrics.roc_auc_score",
"time.time",
"xgboost.XGBClassifier"
] | [((195, 228), 'pandas.read_csv', 'pd.read_csv', (['config.TRAINING_FILE'], {}), '(config.TRAINING_FILE)\n', (206, 228), True, 'import pandas as pd\n'), ((766, 825), 'xgboost.XGBClassifier', 'xgb.XGBClassifier', ([], {'n_jobs': '(-1)', 'max_depth': '(7)', 'n_estimators': '(200)'}), '(n_jobs=-1, max_depth=7, n_estimators... |
import argparse
import ctypes
import ipaddress
import math
import random
import signal
import socket
import selectors
import statistics
import struct
import sys
import textwrap
import time
# The C equivalent of the test header is
# struct udpTestHeader_s {
# int msgIndex;
# int packetIndex;
# double timest... | [
"statistics.mean",
"struct.calcsize",
"signal.signal",
"statistics.stdev",
"math.ceil",
"socket.socket",
"argparse.ArgumentParser",
"time.time",
"struct.pack",
"time.sleep",
"ctypes.create_string_buffer",
"struct.unpack",
"struct.pack_into",
"socket.inet_aton",
"selectors.DefaultSelector... | [((464, 500), 'struct.calcsize', 'struct.calcsize', (['UDPTESTER_HDRFORMAT'], {}), '(UDPTESTER_HDRFORMAT)\n', (479, 500), False, 'import struct\n'), ((6880, 6948), 'socket.socket', 'socket.socket', (['socket.AF_INET', 'socket.SOCK_DGRAM', 'socket.IPPROTO_UDP'], {}), '(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_U... |
import os
import matplotlib.patches as mpatches
import numpy as np
import pkg_resources
from PyQt5 import QtGui, QtWidgets, QtCore, uic
from PyQt5.Qt import QSplashScreen, QObject
from PyQt5.QtCore import QSettings, QThread, pyqtSignal, QTimer, QDateTime
from PyQt5.QtWidgets import QMenu
from PyQt5.QtGui import QPixmap... | [
"matplotlib.backends.backend_qt5agg.NavigationToolbar2QT",
"PyQt5.QtWidgets.QMessageBox",
"PyQt5.uic.loadUiType",
"numpy.array",
"PyQt5.QtWidgets.QFileDialog.getOpenFileName",
"xas.xray.k2e",
"xas.xray.e2k",
"pathlib.Path",
"numpy.stack",
"isstools.elements.figure_update.update_figure",
"PyQt5.Q... | [((848, 921), 'pkg_resources.resource_filename', 'pkg_resources.resource_filename', (['"""isstools"""', '"""ui/ui_xview_project-mac.ui"""'], {}), "('isstools', 'ui/ui_xview_project-mac.ui')\n", (879, 921), False, 'import pkg_resources\n'), ((942, 1011), 'pkg_resources.resource_filename', 'pkg_resources.resource_filenam... |
"""
sentry.testutils.skips
~~~~~~~~~~~~~~~~~~~~~~
:copyright: (c) 2010-2014 by the Sentry Team, see AUTHORS for more details.
:license: BSD, see LICENSE for more details.
"""
from __future__ import absolute_import
import socket
import pytest
def riak_is_available():
try:
socket.create_connection(('127.0... | [
"socket.create_connection"
] | [((288, 338), 'socket.create_connection', 'socket.create_connection', (["('127.0.0.1', 8098)", '(1.0)'], {}), "(('127.0.0.1', 8098), 1.0)\n", (312, 338), False, 'import socket\n'), ((565, 615), 'socket.create_connection', 'socket.create_connection', (["('127.0.0.1', 9042)", '(1.0)'], {}), "(('127.0.0.1', 9042), 1.0)\n"... |