code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
import functools
import logging
import os
import pytest
import tempfile
import devns
import devns.cli
from mock import MagicMock
@pytest.fixture
def config():
return devns.Config()
@pytest.yield_fixture
def resolver_dir(config):
resolvers = []
config.resolver_dir = os.path.join(
tempfile.gette... | [
"functools.partial",
"devns.Config",
"os.path.isdir",
"tempfile.gettempdir",
"devns.server.DevNS",
"os.rmdir",
"mock.MagicMock",
"tempfile.gettempprefix",
"logging.getLogger"
] | [((174, 188), 'devns.Config', 'devns.Config', ([], {}), '()\n', (186, 188), False, 'import devns\n'), ((679, 717), 'logging.getLogger', 'logging.getLogger', (['request.node.nodeid'], {}), '(request.node.nodeid)\n', (696, 717), False, 'import logging\n'), ((771, 825), 'functools.partial', 'functools.partial', (['devns.c... |
from .Node import Node
from .FusedNode import FusedNode
from .SimpleBranchConditionNode import SimpleBranchConditionNode
from .MultipleBranchConditionNode import MultipleBranchConditionNode
from .ControlLoopNode import ControlLoopNode
from .LabelLoopNode import LabelLoopNode
from .LoopNode import LoopNode
from .Multipl... | [
"graphviz.Digraph",
"Utils.utils.clean_regex"
] | [((11111, 11137), 'graphviz.Digraph', 'graphviz.Digraph', (['filename'], {}), '(filename)\n', (11127, 11137), False, 'import graphviz\n'), ((11299, 11324), 'Utils.utils.clean_regex', 'clean_regex', (['current_node'], {}), '(current_node)\n', (11310, 11324), False, 'from Utils.utils import clean_regex\n'), ((11527, 1155... |
import torch.nn as nn
from loss.gradient import grad_loss
from loss.tvloss import tv_loss
from loss.vggloss import vgg_loss
from loss.ssim import ssim_loss as criterionSSIM
from options import opt
criterionCAE = nn.L1Loss()
criterionL1 = criterionCAE
criterionBCE = nn.BCELoss()
criterionMSE = nn.MSELoss()
def get_de... | [
"loss.ssim.ssim_loss",
"torch.nn.MSELoss",
"torch.nn.BCELoss",
"torch.nn.L1Loss",
"loss.vggloss.vgg_loss",
"loss.gradient.grad_loss"
] | [((213, 224), 'torch.nn.L1Loss', 'nn.L1Loss', ([], {}), '()\n', (222, 224), True, 'import torch.nn as nn\n'), ((267, 279), 'torch.nn.BCELoss', 'nn.BCELoss', ([], {}), '()\n', (277, 279), True, 'import torch.nn as nn\n'), ((295, 307), 'torch.nn.MSELoss', 'nn.MSELoss', ([], {}), '()\n', (305, 307), True, 'import torch.nn... |
from __future__ import unicode_literals
from setuptools import setup, find_packages
with open("requirements.txt") as f:
install_requires = f.read().strip().split("\n")
# get version from __version__ variable in network_billing_system/__init__.py
from network_billing_system import __version__ as version
setup(
... | [
"setuptools.find_packages"
] | [((507, 522), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (520, 522), False, 'from setuptools import setup, find_packages\n')] |
from django.shortcuts import render, HttpResponse, redirect
from django.contrib import messages
from .models import Review, Author, Book
from ..login_registration.models import User
# Create your views here.
def books(request):
if 'login' not in request.session or request.session['login'] == False:
return ... | [
"django.shortcuts.redirect",
"django.contrib.messages.error",
"django.shortcuts.render"
] | [((320, 333), 'django.shortcuts.redirect', 'redirect', (['"""/"""'], {}), "('/')\n", (328, 333), False, 'from django.shortcuts import render, HttpResponse, redirect\n'), ((502, 546), 'django.shortcuts.render', 'render', (['request', '"""books/index.html"""', 'context'], {}), "(request, 'books/index.html', context)\n", ... |
import pandas as pd
import plotly.express as px
import plotly.graph_objects as go
import numpy as np
def rmovie_basicvar(cdf,
var = 'tg1',
Mm = False,
km = False,
savefig = False,
figname = 'radynvar.html',
... | [
"pandas.DataFrame",
"pandas.concat",
"numpy.arange",
"plotly.express.line"
] | [((4737, 4890), 'plotly.express.line', 'px.line', (['df'], {'x': 'df.columns[1]', 'y': 'df.columns[0]', 'animation_frame': '"""Time [s]"""', 'log_x': 'xlog', 'log_y': 'ylog', 'template': 'template', 'color_discrete_sequence': '[color]'}), "(df, x=df.columns[1], y=df.columns[0], animation_frame='Time [s]',\n log_x=xl... |
import FWCore.ParameterSet.Config as cms
particleFlowRecHitHBHE = cms.EDProducer("PFRecHitProducer",
navigator = cms.PSet(
hcalEnums = cms.vint32(1, 2),
name = cms.string('PFRecHitHCALDenseIdNavigator')
),
producers = cms.VPSet(cms.PSet(
name = cms.string('PFHBHERecHitCreator'),
... | [
"FWCore.ParameterSet.Config.string",
"FWCore.ParameterSet.Config.vint32",
"FWCore.ParameterSet.Config.vdouble",
"FWCore.ParameterSet.Config.vstring",
"FWCore.ParameterSet.Config.int32",
"FWCore.ParameterSet.Config.InputTag"
] | [((148, 164), 'FWCore.ParameterSet.Config.vint32', 'cms.vint32', (['(1)', '(2)'], {}), '(1, 2)\n', (158, 164), True, 'import FWCore.ParameterSet.Config as cms\n'), ((181, 223), 'FWCore.ParameterSet.Config.string', 'cms.string', (['"""PFRecHitHCALDenseIdNavigator"""'], {}), "('PFRecHitHCALDenseIdNavigator')\n", (191, 22... |
from seeq import spy
import pytest
import time
@pytest.mark.system
class TestCreate:
def test_create_package_and_function(self, instantiate_ui_create_function_and_package):
ui = instantiate_ui_create_function_and_package('testPackage', 'testFunction')
assert 'testPackage' in ui.backend.fetch_udf_p... | [
"time.sleep"
] | [((3032, 3047), 'time.sleep', 'time.sleep', (['(0.5)'], {}), '(0.5)\n', (3042, 3047), False, 'import time\n'), ((3932, 3947), 'time.sleep', 'time.sleep', (['(0.5)'], {}), '(0.5)\n', (3942, 3947), False, 'import time\n')] |
from asyncio import streams
import time
import numpy as np
import pyaudio
import anton.lights.config as config
class AudioProcess():
def __init__(self):
self.audio = pyaudio.PyAudio()
self.frames_per_buffer = int(config.MIC_RATE / config.FPS)
self.overflows = 0
self.prev_ovf_time = ... | [
"pyaudio.PyAudio",
"time.time"
] | [((179, 196), 'pyaudio.PyAudio', 'pyaudio.PyAudio', ([], {}), '()\n', (194, 196), False, 'import pyaudio\n'), ((320, 331), 'time.time', 'time.time', ([], {}), '()\n', (329, 331), False, 'import time\n'), ((1154, 1165), 'time.time', 'time.time', ([], {}), '()\n', (1163, 1165), False, 'import time\n'), ((1233, 1244), 'ti... |
import graphene
from .legislative import LegislativeQuery
from .core import CoreQuery
class Query(LegislativeQuery, CoreQuery, graphene.ObjectType):
pass
schema = graphene.Schema(query=Query)
| [
"graphene.Schema"
] | [((171, 199), 'graphene.Schema', 'graphene.Schema', ([], {'query': 'Query'}), '(query=Query)\n', (186, 199), False, 'import graphene\n')] |
import OGL
import pywavefront
from OpenGL.GL import *
class BasicEnemy(OGL.Cube):
def __init__(self,x,y,z):
OGL.Cube.__init__(self,3,8,2,x,y,z)
self.model = pywavefront.Wavefront("Handgun_obj.obj","models/")
self.model.onload = self.onload
#self.model = OGL.OBJ("Man.obj",Fse,10)
... | [
"pywavefront.Wavefront",
"OGL.Cube.__init__"
] | [((121, 162), 'OGL.Cube.__init__', 'OGL.Cube.__init__', (['self', '(3)', '(8)', '(2)', 'x', 'y', 'z'], {}), '(self, 3, 8, 2, x, y, z)\n', (138, 162), False, 'import OGL\n'), ((178, 229), 'pywavefront.Wavefront', 'pywavefront.Wavefront', (['"""Handgun_obj.obj"""', '"""models/"""'], {}), "('Handgun_obj.obj', 'models/')\n... |
import json
from pathlib import Path
from assertpy import assert_that
from pycep import BicepParser
EXAMPLES_DIR = Path(__file__).parent / "examples/comparison"
BICEP_PARSER = BicepParser()
def test_parse_greater_than_or_equals() -> None:
# given
sub_dir_path = EXAMPLES_DIR / "greater_than_or_equals"
f... | [
"pathlib.Path",
"assertpy.assert_that",
"pycep.BicepParser"
] | [((179, 192), 'pycep.BicepParser', 'BicepParser', ([], {}), '()\n', (190, 192), False, 'from pycep import BicepParser\n'), ((118, 132), 'pathlib.Path', 'Path', (['__file__'], {}), '(__file__)\n', (122, 132), False, 'from pathlib import Path\n'), ((517, 536), 'assertpy.assert_that', 'assert_that', (['result'], {}), '(re... |
# -------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for
# license information.
# --------------------------------------------------------------------------
import py... | [
"inspect.iscoroutinefunction",
"logging.basicConfig",
"asyncio.sleep",
"pytest.mark.describe",
"pytest.mark.it",
"azure.iot.device.common.async_adapter.emulate_async",
"azure.iot.device.common.async_adapter.AwaitableCallback"
] | [((433, 472), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (452, 472), False, 'import logging\n'), ((729, 768), 'pytest.mark.describe', 'pytest.mark.describe', (['"""emulate_async()"""'], {}), "('emulate_async()')\n", (749, 768), False, 'import pytest\n'), ((2... |
from Constants import Constants
from djitellopy import tello
class Controller():
def __init__(self) -> None:
"""
Initialoization of class variables.
"""
self.const = Constants()
self.drone = tello.Tello()
self.up_down_velocity = 0
self.right_left_velocity... | [
"Constants.Constants",
"djitellopy.tello.Tello"
] | [((205, 216), 'Constants.Constants', 'Constants', ([], {}), '()\n', (214, 216), False, 'from Constants import Constants\n'), ((239, 252), 'djitellopy.tello.Tello', 'tello.Tello', ([], {}), '()\n', (250, 252), False, 'from djitellopy import tello\n')] |
import numpy as np
from numba import njit
from snapshot_functions import read_particles_filter
from scipy.linalg import eigh
def run(argv):
if len(argv) < 5:
print('python script.py <IC-file> <preIC-file> <ID> <radius>')
return 1
ID = int(argv[3])
r = float(argv[4])
print('getting ID... | [
"numpy.stack",
"numpy.trace",
"numpy.polyfit",
"numpy.savetxt",
"numpy.zeros",
"numpy.argsort",
"scipy.linalg.eigh",
"snapshot_functions.read_particles_filter",
"numpy.array_equal",
"numpy.diag",
"numpy.printoptions"
] | [((361, 425), 'snapshot_functions.read_particles_filter', 'read_particles_filter', (['argv[2]'], {'ID_list': '[ID]', 'opts': "{'pos': True}"}), "(argv[2], ID_list=[ID], opts={'pos': True})\n", (382, 425), False, 'from snapshot_functions import read_particles_filter\n'), ((440, 514), 'snapshot_functions.read_particles_f... |
from django.shortcuts import render, redirect
from django.http import HttpResponse
from .models import *
from .forms import *
from django.contrib.auth.decorators import login_required
from accounts.decorators import adult_user
# Create your views here.
@login_required(login_url='login')
def bookIndex(request):
bo... | [
"django.contrib.auth.decorators.login_required",
"django.shortcuts.redirect",
"django.shortcuts.render"
] | [((259, 292), 'django.contrib.auth.decorators.login_required', 'login_required', ([], {'login_url': '"""login"""'}), "(login_url='login')\n", (273, 292), False, 'from django.contrib.auth.decorators import login_required\n'), ((612, 645), 'django.contrib.auth.decorators.login_required', 'login_required', ([], {'login_ur... |
#!/usr/bin/env python
from __future__ import print_function
import hashlib
import string
import random
import time
from json import dumps as json_encode, loads as json_decode
import requests
class FileCatalogLowLevel(object):
"""
Low level file catalog interface. Use like a dict::
fc = FileCatalog... | [
"argparse.ArgumentParser",
"json.loads",
"random.randint",
"requests.Session",
"random.choice",
"json.dumps",
"time.time",
"hashlib.sha512"
] | [((2994, 3010), 'hashlib.sha512', 'hashlib.sha512', ([], {}), '()\n', (3008, 3010), False, 'import hashlib\n'), ((3209, 3220), 'time.time', 'time.time', ([], {}), '()\n', (3218, 3220), False, 'import time\n'), ((3593, 3661), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""benchmark file_c... |
from collections import deque
import numpy as np
import cv2
import chainer
from chainer import links as L
import chainerrl
from chainerrl import agents
from chainerrl.action_value import DiscreteActionValue
from chainerrl import explorers
from chainerrl import links
from chainerrl import replay_buffer
def infer(... | [
"cv2.resize",
"chainerrl.links.NatureDQNHead",
"chainerrl.replay_buffer.ReplayBuffer",
"chainer.optimizers.RMSpropGraves",
"cv2.cvtColor",
"numpy.asarray",
"numpy.random.randint",
"numpy.array",
"collections.deque",
"chainer.links.Linear"
] | [((353, 388), 'cv2.cvtColor', 'cv2.cvtColor', (['s', 'cv2.COLOR_RGB2GRAY'], {}), '(s, cv2.COLOR_RGB2GRAY)\n', (365, 388), False, 'import cv2\n'), ((422, 475), 'cv2.resize', 'cv2.resize', (['s', '(84, 84)'], {'interpolation': 'cv2.INTER_AREA'}), '(s, (84, 84), interpolation=cv2.INTER_AREA)\n', (432, 475), False, 'import... |
import pytest
import time
import numpy as np
from spotify_confidence.analysis.frequentist.confidence_computers.z_test_computer import sequential_bounds
@pytest.mark.skip(reason="Skipping because this test is very slow")
def test_many_days():
"""
This input (based on a real experiment) is very long, which can ... | [
"numpy.allclose",
"pytest.mark.skip",
"numpy.array",
"time.time"
] | [((155, 221), 'pytest.mark.skip', 'pytest.mark.skip', ([], {'reason': '"""Skipping because this test is very slow"""'}), "(reason='Skipping because this test is very slow')\n", (171, 221), False, 'import pytest\n'), ((10635, 10701), 'pytest.mark.skip', 'pytest.mark.skip', ([], {'reason': '"""Skipping because this test ... |
#coding: utf-8
import re
from django import forms
from django.utils.translation import ugettext_lazy as _
from main.utils import parse_csv_file as read_file
def _validation_word(word):
if len(word) > 46:
raise forms.ValidationError(_('Maximum length allowed 46 words.'))
if ' ' in word:
raise forms.ValidationEr... | [
"django.utils.translation.ugettext_lazy",
"re.match",
"main.utils.parse_csv_file"
] | [((376, 400), 're.match', 're.match', (['"""^\\\\w+$"""', 'word'], {}), "('^\\\\w+$', word)\n", (384, 400), False, 'import re\n'), ((598, 613), 'main.utils.parse_csv_file', 'read_file', (['file'], {}), '(file)\n', (607, 613), True, 'from main.utils import parse_csv_file as read_file\n'), ((238, 275), 'django.utils.tran... |
# --------------------------------------------------------------------------
# Source file provided under Apache License, Version 2.0, January 2004,
# http://www.apache.org/licenses/
# (c) Copyright <NAME>, 2021
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the Licens... | [
"os.remove",
"base64.b64decode",
"datetime.datetime.utcnow",
"os.close",
"glob.glob",
"os.path.join",
"pandas.DataFrame",
"re.fullmatch",
"datetime.datetime.fromisoformat",
"tempfile.TemporaryDirectory",
"re.search",
"datetime.datetime.now",
"ibm_watson_machine_learning.APIClient",
"io.Str... | [((2966, 2988), 'os.path.basename', 'os.path.basename', (['path'], {}), '(path)\n', (2982, 2988), False, 'import os\n'), ((3879, 3921), 'logging.getLogger', 'logging.getLogger', (['self.__class__.__name__'], {}), '(self.__class__.__name__)\n', (3896, 3921), False, 'import logging\n'), ((8960, 8982), 'packaging.version.... |
# -*- coding: utf-8 -*-
__all__ = ()
# https://docs.python.org/3/howto/logging.html#configuring-logging-for-a-library
import logging
logging.getLogger(__name__).addHandler(logging.NullHandler())
| [
"logging.getLogger",
"logging.NullHandler"
] | [((173, 194), 'logging.NullHandler', 'logging.NullHandler', ([], {}), '()\n', (192, 194), False, 'import logging\n'), ((134, 161), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (151, 161), False, 'import logging\n')] |
import pygame
from pygame.locals import *
pygame.init()
screen = pygame.display.set_mode((600, 600), 0)
pygame.display.set_caption('Simple Pygame Game')
bee = pygame.image.load('bee1.png').convert_alpha()
beeX = 0
beeY = 0
clock = pygame.time.Clock()
loop = True
while loop:
for event in pygame.event.get():
... | [
"pygame.quit",
"pygame.event.get",
"pygame.display.set_mode",
"pygame.init",
"pygame.display.flip",
"pygame.image.load",
"pygame.display.set_caption",
"pygame.time.Clock",
"pygame.key.get_pressed"
] | [((43, 56), 'pygame.init', 'pygame.init', ([], {}), '()\n', (54, 56), False, 'import pygame\n'), ((66, 104), 'pygame.display.set_mode', 'pygame.display.set_mode', (['(600, 600)', '(0)'], {}), '((600, 600), 0)\n', (89, 104), False, 'import pygame\n'), ((105, 153), 'pygame.display.set_caption', 'pygame.display.set_captio... |
#!/usr/bin/env python
import sys
import logging
from configparser import ConfigParser
from os.path import expanduser
from socket import gethostname
from time import sleep
from eq3bt import Thermostat, Mode
from bluepy.btle import BTLEException
from mqttwrapper import run_script
log = logging.getLogger("radcontrold")
... | [
"logging.basicConfig",
"eq3bt.Thermostat",
"logging.getLogger",
"time.sleep",
"socket.gethostname",
"mqttwrapper.run_script",
"configparser.ConfigParser",
"sys.exit"
] | [((287, 319), 'logging.getLogger', 'logging.getLogger', (['"""radcontrold"""'], {}), "('radcontrold')\n", (304, 319), False, 'import logging\n'), ((1522, 1580), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.DEBUG', 'format': 'formatter'}), '(level=logging.DEBUG, format=formatter)\n', (1541, 1580... |
# -*- coding: utf-8 -*-
import os
import sys
import json
import time
import datetime
from django.core.management.base import BaseCommand
from fabric.api import *
from fabric.contrib.files import exists, append, contains
from django.conf import settings
username = 'root'
project_dir = os.getcwd()
project_name = proj... | [
"fabric.contrib.files.exists",
"fabric.contrib.files.contains",
"os.getcwd",
"os.path.exists",
"datetime.datetime.now",
"time.sleep",
"fabric.contrib.files.append",
"os.path.join",
"sys.exit"
] | [((289, 300), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (298, 300), False, 'import os\n'), ((6371, 6407), 'os.path.join', 'os.path.join', (['local_home_dir', '""".ssh"""'], {}), "(local_home_dir, '.ssh')\n", (6383, 6407), False, 'import os\n'), ((6436, 6477), 'os.path.join', 'os.path.join', (['local_ssh_dir', '"""id_... |
# -*- coding: utf-8 -*-
"""
streaming decorators module.
"""
import charma.streaming.services as streaming_services
def stream(*args, **kwargs):
"""
decorator to register a stream provider.
:param object args: stream provider class constructor arguments.
:param object kwargs: stream provider class c... | [
"charma.streaming.services.register_stream_provider"
] | [((886, 949), 'charma.streaming.services.register_stream_provider', 'streaming_services.register_stream_provider', (['instance'], {}), '(instance, **kwargs)\n', (929, 949), True, 'import charma.streaming.services as streaming_services\n')] |
from django.db import models
# Create your models here. Database stuff
class Post(models.Model): #creates a table called posts
title = models.CharField(max_length=140) #Syntax: name = datatype(constraints)
body = models.TextField()
date = models.DateTimeField()
def __str__(self):
return sel... | [
"django.db.models.CharField",
"django.db.models.TextField",
"django.db.models.DateTimeField"
] | [((142, 174), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(140)'}), '(max_length=140)\n', (158, 174), False, 'from django.db import models\n'), ((224, 242), 'django.db.models.TextField', 'models.TextField', ([], {}), '()\n', (240, 242), False, 'from django.db import models\n'), ((254, 276), '... |
import pytest
from ..mutation import Mutation
from ..objecttype import ObjectType
from ..schema import Schema
from ..scalars import String
from ..dynamic import Dynamic
def test_generate_mutation_no_args():
class MyMutation(Mutation):
'''Documentation'''
@classmethod
def mutate(cls, *args... | [
"pytest.raises"
] | [((1056, 1085), 'pytest.raises', 'pytest.raises', (['AssertionError'], {}), '(AssertionError)\n', (1069, 1085), False, 'import pytest\n')] |
import matplotlib.pyplot as plt
import numpy as np
import healpy as hp
map_I = hp.read_map('data/COM_CMB_IQU-smica_1024_R2.02_full.fits')
hp.mollview(map_I, norm='hist', min=-0.1, max=0.1, xsize=2000)
plt.show()
map_Q = hp.read_map('data/COM_CMB_IQU-smica_1024_R2.02_full.fits', field=1)
hp.mollview(map_Q, norm='hist... | [
"matplotlib.pyplot.show",
"healpy.mollview",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.figure",
"healpy.read_map",
"healpy.anafast",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.grid"
] | [((81, 139), 'healpy.read_map', 'hp.read_map', (['"""data/COM_CMB_IQU-smica_1024_R2.02_full.fits"""'], {}), "('data/COM_CMB_IQU-smica_1024_R2.02_full.fits')\n", (92, 139), True, 'import healpy as hp\n'), ((140, 202), 'healpy.mollview', 'hp.mollview', (['map_I'], {'norm': '"""hist"""', 'min': '(-0.1)', 'max': '(0.1)', '... |
import os
import cv2
import random
import logging
from tkinter import Tk
from car import Car, CarSpecs
from HTCSPythonUtil import config
if os.name == "nt":
# https://github.com/opencv/opencv/issues/11360
import ctypes
# Set DPI Awareness (Windows 10 and 8)
_ = ctypes.windll.shcore.SetProcessDpiAwaren... | [
"os.path.abspath",
"ctypes.windll.shcore.SetProcessDpiAwareness",
"logging.getLogger",
"random.getrandbits",
"tkinter.Tk",
"cv2.resize"
] | [((489, 516), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (506, 516), False, 'import logging\n'), ((522, 526), 'tkinter.Tk', 'Tk', ([], {}), '()\n', (524, 526), False, 'from tkinter import Tk\n'), ((2044, 2103), 'cv2.resize', 'cv2.resize', (['im_minimap', '(window_width, im_minimap.sha... |
import emoji
from config import config_email
def enviar_email():
envio_email = emoji.emojize('E-mail enviado com sucesso! :wink:', use_aliases=True)
try:
config_email()
except Exception as e:
print(f'Erro ao chamar a funcao de disparo de emails! {e}')
else:
print(f'{envio_ema... | [
"config.config_email",
"emoji.emojize"
] | [((85, 154), 'emoji.emojize', 'emoji.emojize', (['"""E-mail enviado com sucesso! :wink:"""'], {'use_aliases': '(True)'}), "('E-mail enviado com sucesso! :wink:', use_aliases=True)\n", (98, 154), False, 'import emoji\n'), ((173, 187), 'config.config_email', 'config_email', ([], {}), '()\n', (185, 187), False, 'from conf... |
import show_omnibot
import numpy as np
import nengo
model = nengo.Network()
with model:
bot = show_omnibot.OmniBotNetwork(
show_omnibot.connection.Serial('/dev/ttyUSB2', baud=2000000),
motor=True, arm=True, retina=False, # freqs=[100, 200, 300],
wheel=True, servo=True, load=True, msg_peri... | [
"show_omnibot.connection.Serial",
"nengo.Network",
"nengo.Connection",
"nengo.Node"
] | [((62, 77), 'nengo.Network', 'nengo.Network', ([], {}), '()\n', (75, 77), False, 'import nengo\n'), ((341, 362), 'nengo.Node', 'nengo.Node', (['[0, 0, 0]'], {}), '([0, 0, 0])\n', (351, 362), False, 'import nengo\n'), ((373, 392), 'nengo.Node', 'nengo.Node', (['([0] * 5)'], {}), '([0] * 5)\n', (383, 392), False, 'import... |
from rest_framework.renderers import JSONRenderer, BaseRenderer
from rest_framework_csv.renderers import CSVRenderer as BaseCSVRenderer
class TextRenderer(BaseRenderer):
media_type = "text/plain"
format = "text"
format_description = "text"
def render(self, data, *args, **kwargs):
if isinstanc... | [
"pandas.DataFrame",
"pyjstat.pyjstat.Dataset.read"
] | [((2335, 2367), 'pandas.DataFrame', 'pandas.DataFrame', (['json_stat_data'], {}), '(json_stat_data)\n', (2351, 2367), False, 'import pandas\n'), ((2517, 2557), 'pyjstat.pyjstat.Dataset.read', 'pyjstat.Dataset.read', (['flatten_data_frame'], {}), '(flatten_data_frame)\n', (2537, 2557), False, 'from pyjstat import pyjsta... |
import networkx as nx
import numpy as np
def gen_graph(graph_type, n, mean_deg):
"""Generates and returns a nx.Digraph and its adjacency matrix. Nodes are randomly permutated.
Arguments:
graph_type (string): type of graph Erdos-Renyi, scale-free, sachs or any graph in BNRepo
n (int): number o... | [
"numpy.random.gumbel",
"numpy.random.uniform",
"numpy.float32",
"numpy.random.exponential",
"numpy.zeros",
"networkx.from_numpy_array",
"numpy.random.random",
"numpy.random.normal",
"numpy.eye",
"numpy.cov"
] | [((1068, 1124), 'networkx.from_numpy_array', 'nx.from_numpy_array', (['adj_matrix'], {'create_using': 'nx.DiGraph'}), '(adj_matrix, create_using=nx.DiGraph)\n', (1087, 1124), True, 'import networkx as nx\n'), ((1497, 1513), 'numpy.float32', 'np.float32', (['beta'], {}), '(beta)\n', (1507, 1513), True, 'import numpy as ... |
from Crypto import Random
from Crypto.PublicKey import RSA
import base64
def generate_keys(modulus_length=256*4):
privatekey = RSA.generate(modulus_length, Random.new().read)
publickey = privatekey.publickey()
return privatekey, publickey
def encryptit(message , publickey):
encrypted_msg = publickey... | [
"Crypto.Random.new",
"base64.b64encode",
"base64.b64decode"
] | [((373, 404), 'base64.b64encode', 'base64.b64encode', (['encrypted_msg'], {}), '(encrypted_msg)\n', (389, 404), False, 'import base64\n'), ((504, 529), 'base64.b64decode', 'base64.b64decode', (['message'], {}), '(message)\n', (520, 529), False, 'import base64\n'), ((162, 174), 'Crypto.Random.new', 'Random.new', ([], {}... |
#!/usr/bin/python3
import os
import shutil
import sys
from entrypoint_helpers import env, gen_cfg, gen_container_id, str2bool, start_app, set_perms, set_ownership
RUN_USER = env['sys_user']
RUN_GROUP = env['sys_group']
PG_DATA = env['pgdata']
PG_CONFIG_DIR = env['pg_config_dir']
try:
PG_SSL_KEY_FILE = env['pg_s... | [
"entrypoint_helpers.set_ownership",
"entrypoint_helpers.set_perms",
"entrypoint_helpers.gen_cfg",
"shutil.copyfile",
"entrypoint_helpers.start_app"
] | [((939, 1004), 'entrypoint_helpers.set_ownership', 'set_ownership', (['f"""{PG_CONFIG_DIR}"""'], {'user': 'RUN_USER', 'group': 'RUN_GROUP'}), "(f'{PG_CONFIG_DIR}', user=RUN_USER, group=RUN_GROUP)\n", (952, 1004), False, 'from entrypoint_helpers import env, gen_cfg, gen_container_id, str2bool, start_app, set_perms, set_... |
import sys
import tweepy
def tweeting(consumer_key, consumer_secret, my_access_token, my_access_token_secret, message):
# Authentication
my_auth = tweepy.OAuthHandler(consumer_key, consumer_secret)
my_auth.set_access_token(my_access_token, my_access_token_secret)
my_api = tweepy.API(my_auth)
my_... | [
"tweepy.OAuthHandler",
"tweepy.API"
] | [((159, 209), 'tweepy.OAuthHandler', 'tweepy.OAuthHandler', (['consumer_key', 'consumer_secret'], {}), '(consumer_key, consumer_secret)\n', (178, 209), False, 'import tweepy\n'), ((293, 312), 'tweepy.API', 'tweepy.API', (['my_auth'], {}), '(my_auth)\n', (303, 312), False, 'import tweepy\n')] |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import sys
import os
import argparse
import pandas as pd
from pkg_resources import resource_filename
from .utils import column_exists, fixup_columns, get_app_file_path, download_file
IN_ROLLS_DATA = {'v1': 'https://dataverse.harvard.edu/api/v1/access/datafile/4967581',... | [
"pandas.read_csv",
"pandas.merge",
"os.path.exists",
"argparse.ArgumentParser"
] | [((4631, 4673), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': 'title'}), '(description=title)\n', (4654, 4673), False, 'import argparse\n'), ((4092, 4145), 'pandas.merge', 'pd.merge', (['df', 'cls.__df'], {'how': '"""left"""', 'on': '"""__first_name"""'}), "(df, cls.__df, how='left', on='__... |
from django.urls import path
from itez.users.views import (
update_view,
# UserUpdateView,
user_delete,
user_detail_view,
user_redirect_view,
UserCreateView,
user_profile,
user_profile_photo_update,
)
app_name = "users"
urlpatterns = [
path("user/create/", UserCreateView.as_view(),... | [
"itez.users.views.UserCreateView.as_view",
"django.urls.path"
] | [((346, 407), 'django.urls.path', 'path', (['"""user/delete/<int:user_id>"""', 'user_delete'], {'name': '"""delete"""'}), "('user/delete/<int:user_id>', user_delete, name='delete')\n", (350, 407), False, 'from django.urls import path\n'), ((413, 501), 'django.urls.path', 'path', (['"""user/profile/photo/upload/"""', 'u... |
#!/bin/env python
"""
Implements Python interface to NRL NAAPS files
"""
import os
import sys
from types import *
from pyhdf import SD
from glob import glob
from numpy import ones, concatenate, array,linspace,arange, transpose
from datetime import date, datetime, timedelta
from .config import strTem... | [
"binObs_.binobs3dh",
"os.path.isdir",
"gfio.GFIO",
"numpy.transpose",
"numpy.ones",
"datetime.datetime",
"os.path.isfile",
"datetime.timedelta",
"numpy.arange",
"numpy.linspace",
"pyhdf.SD.SD",
"glob.glob",
"os.path.split",
"os.listdir",
"numpy.concatenate"
] | [((10722, 10766), 'datetime.timedelta', 'timedelta', ([], {'seconds': '(12.0 * 60.0 * 60.0 / nsyn)'}), '(seconds=12.0 * 60.0 * 60.0 / nsyn)\n', (10731, 10766), False, 'from datetime import date, datetime, timedelta\n'), ((12181, 12204), 'datetime.datetime', 'datetime', (['(2007)', '(4)', '(1)', '(0)'], {}), '(2007, 4, ... |
import runexp
import testexp
import summary
memo = "multi_phase/sumo/pipeline"
runexp.main(memo)
print("****************************** runexp ends (generate, train, test)!! ******************************")
summary.main(memo)
print("****************************** summary_detail ends ******************************") | [
"summary.main",
"runexp.main"
] | [((81, 98), 'runexp.main', 'runexp.main', (['memo'], {}), '(memo)\n', (92, 98), False, 'import runexp\n'), ((208, 226), 'summary.main', 'summary.main', (['memo'], {}), '(memo)\n', (220, 226), False, 'import summary\n')] |
from neuromllite import (
Network,
Cell,
Population,
Synapse,
RectangularRegion,
RandomLayout,
)
from neuromllite import (
Projection,
RandomConnectivity,
OneToOneConnector,
Simulation,
InputSource,
Input,
)
from neuromllite.NetworkGenerator import check_to_generate_or_r... | [
"neuromllite.Simulation",
"neuromllite.NetworkGenerator.check_to_generate_or_run",
"neuromllite.RectangularRegion",
"neuromllite.Network",
"neuromllite.RandomLayout",
"neuromllite.Cell"
] | [((511, 527), 'neuromllite.Network', 'Network', ([], {'id': '"""FN"""'}), "(id='FN')\n", (518, 527), False, 'from neuromllite import Network, Cell, Population, Synapse, RectangularRegion, RandomLayout\n'), ((1070, 1137), 'neuromllite.Cell', 'Cell', ([], {'id': '"""fn"""', 'lems_source_file': '"""FN_Definitions.xml"""',... |
"""
Dump Apache HTTPD configuration to stdout.
"""
from os import chdir
from os.path import dirname, join, normpath, realpath
import sys
import coils
www_directory = sys.argv[1]
config_fname = sys.argv[2] if len(sys.argv)>=3 else 'wabbit.conf'
# Load the configuration, and add to it path to www.
config = coils.Conf... | [
"os.path.realpath",
"os.path.normpath",
"coils.Config",
"os.chdir"
] | [((310, 336), 'coils.Config', 'coils.Config', (['config_fname'], {}), '(config_fname)\n', (322, 336), False, 'import coils\n'), ((363, 386), 'os.path.normpath', 'normpath', (['www_directory'], {}), '(www_directory)\n', (371, 386), False, 'from os.path import dirname, join, normpath, realpath\n'), ((465, 480), 'os.chdir... |
from fastapi import FastAPI
from fastapi.responses import JSONResponse
from database import Database
app = FastAPI()
database = Database()
@app.get("/")
def read_root():
return {
"Collections": ["ports", "ssh_logins", "user_connections", "network_traffic", "storage"]
}
@app.get("/collection/{colle... | [
"fastapi.responses.JSONResponse",
"database.Database",
"fastapi.FastAPI"
] | [((109, 118), 'fastapi.FastAPI', 'FastAPI', ([], {}), '()\n', (116, 118), False, 'from fastapi import FastAPI\n'), ((130, 140), 'database.Database', 'Database', ([], {}), '()\n', (138, 140), False, 'from database import Database\n'), ((565, 613), 'fastapi.responses.JSONResponse', 'JSONResponse', ([], {'content': 'docum... |
""" Script for evaluating AE examples.
"""
import argparse
import importlib
import os
import shutil
import sys
import torch
import torchvision
from tqdm import tqdm
from fta.utils.dataset_utils import imagenet_utils
from fta.utils.torch_utils import image_utils, model_utils
import pdb
# Sample Us... | [
"fta.utils.dataset_utils.imagenet_utils.load_imagenet_label_dict",
"tqdm.tqdm",
"argparse.ArgumentParser",
"os.path.exists",
"fta.utils.torch_utils.image_utils.load_img",
"fta.utils.torch_utils.model_utils.Normalize",
"fta.utils.dataset_utils.imagenet_utils.get_imagenet_normalize",
"os.path.splitext",... | [((426, 467), 'fta.utils.dataset_utils.imagenet_utils.load_imagenet_label_dict', 'imagenet_utils.load_imagenet_label_dict', ([], {}), '()\n', (465, 467), False, 'from fta.utils.dataset_utils import imagenet_utils\n'), ((661, 700), 'fta.utils.dataset_utils.imagenet_utils.get_imagenet_normalize', 'imagenet_utils.get_imag... |
#!/usr/bin/env python
from __future__ import division, print_function, absolute_import
from __future__ import unicode_literals
def configuration(parent_package='', top_path=None):
from numpy.distutils.misc_util import Configuration
config = Configuration('sknano', parent_package, top_path)
config.add_subp... | [
"numpy.distutils.misc_util.Configuration"
] | [((251, 300), 'numpy.distutils.misc_util.Configuration', 'Configuration', (['"""sknano"""', 'parent_package', 'top_path'], {}), "('sknano', parent_package, top_path)\n", (264, 300), False, 'from numpy.distutils.misc_util import Configuration\n')] |
import pandas as pd
import datetime
from pathlib import Path
import numpy as np
def plus3h(data):
columns = ['Created','First Lock', 'FirstResponse', 'Close Time']
columns_to_3 = {column: f"{column}+3" for column in columns}
for col in columns:
for index, row in data.iterrows():
row = s... | [
"pandas.read_csv",
"datetime.datetime.fromisoformat",
"datetime.timedelta",
"datetime.datetime"
] | [((1117, 1155), 'datetime.datetime', 'datetime.datetime', (['(1900)', '(1)', '(1)', '(8)', '(0)', '(0)'], {}), '(1900, 1, 1, 8, 0, 0)\n', (1134, 1155), False, 'import datetime\n'), ((1183, 1222), 'datetime.datetime', 'datetime.datetime', (['(1900)', '(1)', '(1)', '(17)', '(0)', '(0)'], {}), '(1900, 1, 1, 17, 0, 0)\n', ... |
import os
import pytest
@pytest.fixture(scope="session")
def settings():
return {
"HOST": "solr",
"PORT": 8983,
"PROTO": "http://",
"SOLR_USER": os.environ["SOLR_USER"],
"SOLR_PASS": os.environ["SOLR_PASS"],
"SERVER_PATH": "solr",
"SOLR_BASE_URL": "http://s... | [
"pytest.fixture"
] | [((28, 59), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""session"""'}), "(scope='session')\n", (42, 59), False, 'import pytest\n')] |
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not... | [
"airflow.providers.google.cloud.hooks.gcs.GCSHook",
"tempfile.NamedTemporaryFile",
"csv.reader",
"airflow.providers.trino.hooks.trino.TrinoHook"
] | [((4038, 4155), 'airflow.providers.google.cloud.hooks.gcs.GCSHook', 'GCSHook', ([], {'gcp_conn_id': 'self.gcp_conn_id', 'delegate_to': 'self.delegate_to', 'impersonation_chain': 'self.impersonation_chain'}), '(gcp_conn_id=self.gcp_conn_id, delegate_to=self.delegate_to,\n impersonation_chain=self.impersonation_chain)... |
# -*- coding: utf-8 -*-
"""
Transmission Line helper functions
"""
import numpy as np
def ZL_2_Zin(L,Z0,gamma,ZL):
"""
Returns the input impedance seen through a lossy transmission line of
characteristic impedance Z0 and complex wavenumber gamma=alpha+j*beta
Zin = ZL_2_Zin(L,Z0,gamma,ZL)
... | [
"numpy.tanh",
"numpy.array",
"numpy.exp",
"numpy.cosh",
"numpy.sinh"
] | [((1595, 1613), 'numpy.array', 'np.array', (['[V0, I0]'], {}), '([V0, I0])\n', (1603, 1613), True, 'import numpy as np\n'), ((2315, 2333), 'numpy.exp', 'np.exp', (['(-gamma * L)'], {}), '(-gamma * L)\n', (2321, 2333), True, 'import numpy as np\n'), ((686, 704), 'numpy.tanh', 'np.tanh', (['(gamma * L)'], {}), '(gamma * ... |
import json
def main():
with open('chips.csv', 'r') as f:
data = f.read()
raw_types = [
t.split('\n') for t in data.split('$$TYPE$$') if t != '\n'
]
items = []
for t in raw_types:
type_name = t[0].strip()
print(type_name)
raw_items = [item.split('\t') for... | [
"json.dump"
] | [((652, 681), 'json.dump', 'json.dump', (['items', 'f'], {'indent': '(2)'}), '(items, f, indent=2)\n', (661, 681), False, 'import json\n')] |
import unittest
from lab1 import get_max
from lab1 import reverse
from lab1 import search
from lab1 import fib
from lab1 import factorial_iter
from lab1 import factorial_rec
class MyTest(unittest.TestCase):
def runTest(self):
with self.subTest(msg="testing get_max"):
self.test_get_max()
... | [
"lab1.search",
"unittest.TextTestRunner",
"lab1.factorial_rec",
"lab1.reverse",
"lab1.fib",
"lab1.factorial_iter",
"lab1.get_max"
] | [((2342, 2367), 'unittest.TextTestRunner', 'unittest.TextTestRunner', ([], {}), '()\n', (2365, 2367), False, 'import unittest\n'), ((716, 728), 'lab1.get_max', 'get_max', (['arr'], {}), '(arr)\n', (723, 728), False, 'from lab1 import get_max\n'), ((785, 797), 'lab1.get_max', 'get_max', (['arr'], {}), '(arr)\n', (792, 7... |
from __future__ import print_function
import numpy as np
from sklearn.preprocessing import Normalizer
# For reproducibility
np.random.seed(1000)
if __name__ == '__main__':
# Create a dummy dataset
data = np.array([1.0, 2.0])
print(data)
# Max normalization
n_max = Normalizer(norm... | [
"numpy.array",
"sklearn.preprocessing.Normalizer",
"numpy.random.seed"
] | [((134, 154), 'numpy.random.seed', 'np.random.seed', (['(1000)'], {}), '(1000)\n', (148, 154), True, 'import numpy as np\n'), ((227, 247), 'numpy.array', 'np.array', (['[1.0, 2.0]'], {}), '([1.0, 2.0])\n', (235, 247), True, 'import numpy as np\n'), ((305, 327), 'sklearn.preprocessing.Normalizer', 'Normalizer', ([], {'n... |
# Generated by Django 2.1.5 on 2019-01-22 20:47
from django.db import migrations, models
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
migrations.CreateModel(
name='Humidity',
fields=[
('id', models.AutoField... | [
"django.db.models.DateTimeField",
"django.db.models.DecimalField",
"django.db.models.AutoField"
] | [((304, 397), 'django.db.models.AutoField', 'models.AutoField', ([], {'auto_created': '(True)', 'primary_key': '(True)', 'serialize': '(False)', 'verbose_name': '"""ID"""'}), "(auto_created=True, primary_key=True, serialize=False,\n verbose_name='ID')\n", (320, 397), False, 'from django.db import migrations, models\... |
# Generated by Django 3.2.4 on 2021-06-30 06:52
from django.db import migrations, models
import django.utils.timezone
class Migration(migrations.Migration):
dependencies = [
('accounts', '0001_initial'),
]
operations = [
migrations.AddField(
model_name='assistant',
... | [
"django.db.models.CharField"
] | [((355, 421), 'django.db.models.CharField', 'models.CharField', ([], {'default': 'django.utils.timezone.now', 'max_length': '(20)'}), '(default=django.utils.timezone.now, max_length=20)\n', (371, 421), False, 'from django.db import migrations, models\n'), ((589, 656), 'django.db.models.CharField', 'models.CharField', (... |
"""
Copyright (C) 2018 University of Massachusetts Amherst.
This file is part of "coref_tools"
http://github.com/nmonath/coref_tools
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.... | [
"argparse.ArgumentParser",
"torch.load",
"datetime.datetime.now",
"coref.train.new_trainer",
"coref.models.new_model",
"coref.util.IO.copy_source_to_dir",
"coref.util.Config.Config",
"os.path.join"
] | [((959, 1022), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Train PWE HAC on dataset"""'}), "(description='Train PWE HAC on dataset')\n", (982, 1022), False, 'import argparse\n'), ((1332, 1351), 'coref.util.Config.Config', 'Config', (['args.config'], {}), '(args.config)\n', (1338, 1351... |
from flask import Flask
# blueprint import
from blueprints.tweets.tweets import tweetsData
from blueprints.btc.btc import btcData
def create_app(app):
# register blueprint
app.register_blueprint(tweetsData)
app.register_blueprint(btcData)
return app
if __name__ == "__main__":
app = Flask(__nam... | [
"flask.Flask"
] | [((309, 324), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (314, 324), False, 'from flask import Flask\n')] |
from django.shortcuts import render
from django.views import View
from django.views.generic import ListView, DetailView
from .models import Video
from django.contrib.auth.mixins import LoginRequiredMixin
# Create your views here.
class PopularVideosList(ListView):
template_name = 'index.html'
context_object... | [
"django.shortcuts.render"
] | [((852, 905), 'django.shortcuts.render', 'render', (['request', '"""youtube/myVideosList.html"""', 'context'], {}), "(request, 'youtube/myVideosList.html', context)\n", (858, 905), False, 'from django.shortcuts import render\n')] |
# -*- coding: utf-8 -*-
# Generated by Django 1.10.5 on 2017-01-25 13:40
from django.db import migrations, models
import jsonfield.fields
class Migration(migrations.Migration):
dependencies = [
('django_prices_vatlayer', '0001_initial'),
]
operations = [
migrations.CreateModel(
... | [
"django.db.models.AutoField"
] | [((385, 478), 'django.db.models.AutoField', 'models.AutoField', ([], {'auto_created': '(True)', 'primary_key': '(True)', 'serialize': '(False)', 'verbose_name': '"""ID"""'}), "(auto_created=True, primary_key=True, serialize=False,\n verbose_name='ID')\n", (401, 478), False, 'from django.db import migrations, models\... |
"""
Observer for iContact instances
"""
import logging
from django.db.models import signals
from icontact.models import IContact
from icontact.client import IContactClient, IContactException
logger = logging.getLogger(__name__)
class IContactObserver(object):
"""
Class that utilizes icontact client to ... | [
"django.db.models.signals.post_delete.connect",
"icontact.models.IContact.objects.delete_contact_id",
"logging.debug",
"icontact.models.IContact.objects.get_contact_id",
"icontact.client.IContactClient",
"django.db.models.signals.post_save.connect",
"logging.getLogger",
"icontact.models.IContact.objec... | [((204, 231), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (221, 231), False, 'import logging\n'), ((774, 829), 'django.db.models.signals.post_save.connect', 'signals.post_save.connect', (['self.on_update'], {'sender': 'model'}), '(self.on_update, sender=model)\n', (799, 829), False, 'f... |
import os
import shutil
import logging
logging.basicConfig(
format='%(asctime)s %(levelname)-8s [%(filename)s:%(lineno)d] %(message)s',
datefmt='%Y-%m-%d %H:%M:%S',
level=logging.DEBUG)
log = logging.getLogger()
class models_genesis_config:
model = "Unet3D"
suffix = "genesis_oct"
exp_name = ... | [
"os.makedirs",
"logging.basicConfig",
"os.path.exists",
"os.path.join",
"logging.getLogger"
] | [((41, 195), 'logging.basicConfig', 'logging.basicConfig', ([], {'format': '"""%(asctime)s %(levelname)-8s [%(filename)s:%(lineno)d] %(message)s"""', 'datefmt': '"""%Y-%m-%d %H:%M:%S"""', 'level': 'logging.DEBUG'}), "(format=\n '%(asctime)s %(levelname)-8s [%(filename)s:%(lineno)d] %(message)s',\n datefmt='%Y-%m-... |
import distutils
import os
from PyInstaller.utils.hooks import logger
# https://github.com/pyinstaller/pyinstaller/issues/4064
# https://pythonhosted.org/PyInstaller/hooks.html#the-pre-find-module-path-pfmp-api-method
def pre_find_module_path(api):
# Absolute path of the system-wide "distutils" package when run... | [
"PyInstaller.utils.hooks.logger.info",
"os.path.dirname"
] | [((773, 879), 'PyInstaller.utils.hooks.logger.info', 'logger.info', (["('>>>>>>> CUSTOM >>>>>>>>> distutils: retargeting to non-venv dir %r' %\n distutils_dir)"], {}), "(\n '>>>>>>> CUSTOM >>>>>>>>> distutils: retargeting to non-venv dir %r' %\n distutils_dir)\n", (784, 879), False, 'from PyInstaller.utils.hoo... |
import argparse
import os
from pathlib import Path
import logging
def missing_image(image_path: Path, label_path: Path):
"""
This function removes the images from the train folder if the correspining labels
are not found in the .txt file.
NOTE - Make sure you perform the conversion from th... | [
"pathlib.Path",
"argparse.ArgumentParser",
"os.remove"
] | [((1165, 1190), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (1188, 1190), False, 'import argparse\n'), ((1385, 1406), 'pathlib.Path', 'Path', (['args.image_path'], {}), '(args.image_path)\n', (1389, 1406), False, 'from pathlib import Path\n'), ((1436, 1457), 'pathlib.Path', 'Path', (['args.l... |
from django.dispatch import Signal, receiver
from django.contrib.auth.signals import user_logged_out
from django.core.exceptions import ObjectDoesNotExist
from axes.models import AccessLog
# django 1.4 has a new timezone aware now() use if available.
try:
from django.utils.timezone import now
except ImportError:
... | [
"django.utils.timezone.now",
"django.dispatch.receiver",
"django.dispatch.Signal",
"axes.models.AccessLog.objects.filter"
] | [((440, 500), 'django.dispatch.Signal', 'Signal', ([], {'providing_args': "['request', 'username', 'ip_address']"}), "(providing_args=['request', 'username', 'ip_address'])\n", (446, 500), False, 'from django.dispatch import Signal, receiver\n'), ((503, 528), 'django.dispatch.receiver', 'receiver', (['user_logged_out']... |
# Copyright 2015 Rackspace
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, sof... | [
"unittest.main",
"cafe.engine.http.behaviors.get_range_data"
] | [((1337, 1352), 'unittest.main', 'unittest.main', ([], {}), '()\n', (1350, 1352), False, 'import unittest\n'), ((776, 803), 'cafe.engine.http.behaviors.get_range_data', 'get_range_data', (['data', '"""0-4"""'], {}), "(data, '0-4')\n", (790, 803), False, 'from cafe.engine.http.behaviors import get_range_data\n'), ((874,... |
#!/usr/bin/env python
# coding: utf-8
#$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$#
#$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$$... | [
"tqdm.tqdm",
"pickle.dump",
"os.getcwd",
"os.path.dirname",
"pathlib.Path",
"pickle.load",
"os.chdir"
] | [((2622, 2639), 'pathlib.Path', 'Path', (['"""MNX_data/"""'], {}), "('MNX_data/')\n", (2626, 2639), False, 'from pathlib import Path\n'), ((2657, 2682), 'pathlib.Path', 'Path', (['"""MNX_ECFP_savings/"""'], {}), "('MNX_ECFP_savings/')\n", (2661, 2682), False, 'from pathlib import Path\n'), ((6194, 6217), 'pickle.load',... |
# Copyright (c) 2019-present, Facebook, Inc.
# All rights reserved.
#
# This source code is licensed under the license found in the
# LICENSE file in the root directory of this source tree.
#
import os
import subprocess
import sys
import uuid
from pathlib import Path, PosixPath
from subprocess import Popen
from .evosu... | [
"subprocess.Popen",
"pathlib.Path.home",
"pathlib.Path"
] | [((2146, 2271), 'subprocess.Popen', 'Popen', (['test_cmd'], {'stdout': 'subprocess.PIPE', 'stderr': 'subprocess.PIPE', 'shell': '(True)', 'executable': '"""/bin/bash"""', 'preexec_fn': 'os.setsid'}), "(test_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, shell=True,\n executable='/bin/bash', preexec_fn=os.setsi... |
from django.urls import path
from .views import call_json_to_db, get_all_movies, add_movie, edit_movie, remove_movie
urlpatterns = [
path('load-db/', call_json_to_db, name='load_db'),
path('list/', get_all_movies, name='all_movies'),
path('add/', add_movie, name='add_movie'),
path('edit/', edit_movie, ... | [
"django.urls.path"
] | [((138, 187), 'django.urls.path', 'path', (['"""load-db/"""', 'call_json_to_db'], {'name': '"""load_db"""'}), "('load-db/', call_json_to_db, name='load_db')\n", (142, 187), False, 'from django.urls import path\n'), ((193, 241), 'django.urls.path', 'path', (['"""list/"""', 'get_all_movies'], {'name': '"""all_movies"""'}... |
from itertools import tee
from pathlib import Path
from typing import Union, List, Tuple
import h5py
import torch
from torch.utils.data import Dataset, DataLoader
from tqdm.auto import tqdm
T = List[Tuple[torch.Tensor, torch.Tensor]]
def dataset_to_h5_file(dataset: Union[Dataset, T], filepath: Union[str, Path], inp... | [
"h5py.File",
"torch.utils.data.DataLoader"
] | [((895, 957), 'h5py.File', 'h5py.File', ([], {'name': 'filepath', 'mode': '"""w"""', 'libver': '"""latest"""', 'swmr': '(True)'}), "(name=filepath, mode='w', libver='latest', swmr=True)\n", (904, 957), False, 'import h5py\n'), ((1204, 1252), 'torch.utils.data.DataLoader', 'DataLoader', (['dataset'], {'batch_size': '(1)... |
# -*- coding: utf-8 -*-
import biapol_utilities as biau
import numpy as np
def test_suppression():
a = np.random.rand(100).reshape(10, -1)
threshold = 0.5
a_sup = biau.label.suppressed_similarity(a, threshold=threshold)
assert(all(a_sup[a < threshold].ravel() == 0))
if __name__ == "__main__":
... | [
"numpy.random.rand",
"biapol_utilities.label.suppressed_similarity"
] | [((180, 236), 'biapol_utilities.label.suppressed_similarity', 'biau.label.suppressed_similarity', (['a'], {'threshold': 'threshold'}), '(a, threshold=threshold)\n', (212, 236), True, 'import biapol_utilities as biau\n'), ((111, 130), 'numpy.random.rand', 'np.random.rand', (['(100)'], {}), '(100)\n', (125, 130), True, '... |
#!/usr/bin/python
# Script to generate sitemaps
# <NAME>
# Requires mysql-python
import MySQLdb
import argparse
import logging
import os
import sys
import subprocess
from config import db
logging.basicConfig(level=logging.INFO)
parser = argparse.ArgumentParser()
parser.add_argument("sitemapdir")
args = parser.parse_a... | [
"logging.error",
"MySQLdb.connect",
"argparse.ArgumentParser",
"logging.basicConfig",
"os.makedirs",
"os.path.exists",
"subprocess.call",
"os.path.join",
"config.db.cursor",
"sys.exit"
] | [((190, 229), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (209, 229), False, 'import logging\n'), ((239, 264), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (262, 264), False, 'import argparse\n'), ((513, 539), 'os.path.exists', 'os.... |
import os
import sys
import platform
from fHDHR import fHDHR_VERSION
from fHDHR.tools import is_docker
class Versions():
"""
fHDHR versioning management system.
"""
def __init__(self, settings, fHDHR_web, logger, web, db, scheduler):
self.fHDHR_web = fHDHR_web
self.logger = logger
... | [
"fHDHR.tools.is_docker",
"os.environ.get",
"os.getuid",
"platform.system",
"os.geteuid",
"platform.machine"
] | [((4149, 4166), 'platform.system', 'platform.system', ([], {}), '()\n', (4164, 4166), False, 'import platform\n'), ((4759, 4777), 'platform.machine', 'platform.machine', ([], {}), '()\n', (4775, 4777), False, 'import platform\n'), ((4857, 4868), 'fHDHR.tools.is_docker', 'is_docker', ([], {}), '()\n', (4866, 4868), Fals... |
from django.shortcuts import render_to_response, redirect
from django.template import RequestContext
from django.template.loader import render_to_string
from django.core.mail import send_mail, mail_managers, EmailMessage
from django.contrib.auth.decorators import login_required
from django.contrib import messages
from ... | [
"django.shortcuts.redirect",
"django.contrib.messages.error",
"django.template.loader.render_to_string",
"datetime.datetime.now",
"django.core.mail.EmailMessage",
"django.contrib.messages.success",
"django.core.mail.mail_managers",
"django.template.RequestContext"
] | [((5469, 5506), 'django.shortcuts.redirect', 'redirect', (['"""/contest/?sort=vote_count"""'], {}), "('/contest/?sort=vote_count')\n", (5477, 5506), False, 'from django.shortcuts import render_to_response, redirect\n'), ((757, 780), 'django.template.RequestContext', 'RequestContext', (['request'], {}), '(request)\n', (... |
# -*- coding: utf-8 -*-
"""
Created on Tue Apr 6 09:59:14 2021
@author: ll17354
"""
from sklearn.base import BaseEstimator, ClassifierMixin
from sklearn.linear_model._logistic import LogisticRegression
from sklearn.utils.validation import check_X_y, check_array, check_is_fitted
import sys
import warnings
import math
... | [
"scipy.stats.chi2.sf",
"numpy.multiply",
"statsmodels.api.Logit",
"sklearn.utils.validation.check_X_y",
"numpy.zeros",
"numpy.transpose",
"sklearn.utils.validation.check_is_fitted",
"numpy.diagonal",
"numpy.linalg.norm",
"numpy.matmul",
"numpy.dot",
"sys.stderr.write",
"numpy.delete",
"num... | [((1714, 1729), 'statsmodels.api.Logit', 'smf.Logit', (['y', 'X'], {}), '(y, X)\n', (1723, 1729), True, 'import statsmodels.api as smf\n'), ((1781, 1801), 'numpy.zeros', 'np.zeros', (['X.shape[1]'], {}), '(X.shape[1])\n', (1789, 1801), True, 'import numpy as np\n'), ((2130, 2140), 'numpy.sqrt', 'np.sqrt', (['W'], {}), ... |
import pytest
from flask_open_directory import BaseQuery, User
from flask_open_directory.query.base_query import _quote_if_str
import ldap3
@pytest.fixture
def base_query(open_directory):
return BaseQuery(open_directory=open_directory)
@pytest.fixture
def connection():
return ldap3.Connection(ldap3.Server(... | [
"flask_open_directory.query.base_query._quote_if_str",
"ldap3.Server",
"flask_open_directory.BaseQuery",
"pytest.raises",
"flask_open_directory.User"
] | [((202, 242), 'flask_open_directory.BaseQuery', 'BaseQuery', ([], {'open_directory': 'open_directory'}), '(open_directory=open_directory)\n', (211, 242), False, 'from flask_open_directory import BaseQuery, User\n'), ((1048, 1054), 'flask_open_directory.User', 'User', ([], {}), '()\n', (1052, 1054), False, 'from flask_o... |
from avgn.utils.audio import get_samplerate
from avgn.utils.json import NoIndent, NoIndentEncoder
import numpy as np
from avgn.utils.paths import DATA_DIR
import librosa
from datetime import datetime
import pandas as pd
import avgn
import json
DATASET_ID = 'mobysound_humpback_whale'
def load_labs(labels):
all_lab... | [
"numpy.argmax",
"avgn.utils.paths.ensure_dir",
"json.dumps",
"datetime.datetime.strptime",
"numpy.array",
"avgn.utils.general.seconds_to_str",
"librosa.load",
"librosa.output.write_wav",
"pandas.concat",
"librosa.get_duration"
] | [((1087, 1158), 'numpy.argmax', 'np.argmax', (['(file_df.start_time.values[1:] - file_df.end_time.values[:-1])'], {}), '(file_df.start_time.values[1:] - file_df.end_time.values[:-1])\n', (1096, 1158), True, 'import numpy as np\n'), ((1407, 1476), 'numpy.array', 'np.array', (['[noise_end_time - noise_start_time, start_n... |
#
# Copyright 2019 The FATE 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 appli... | [
"unittest.main",
"federatedml.ftl.plain_ftl.PlainFTLGuestModel",
"numpy.random.seed",
"federatedml.util.transfer_variable.HeteroFTLTransferVariable",
"federatedml.feature.instance.Instance",
"numpy.zeros",
"numpy.ones",
"federatedml.ftl.test.fake_models.FakeAutoencoder",
"federatedml.ftl.plain_ftl.P... | [((4080, 4086), 'arch.api.eggroll.init', 'init', ([], {}), '()\n', (4084, 4086), False, 'from arch.api.eggroll import init\n'), ((4091, 4106), 'unittest.main', 'unittest.main', ([], {}), '()\n', (4104, 4106), False, 'import unittest\n'), ((1417, 1496), 'numpy.array', 'np.array', (['[[4, 2, 3, 1, 2], [6, 5, 1, 4, 5], [7... |
import logging
from google.appengine.api import memcache
from mlabns.db import model
from mlabns.util import constants
def get_nagios_config():
"""Retrieves nagios config info. First checks memcache, then datastore.
Returns:
Nagios model instance
"""
nagios = memcache.get(constants.DEFAULT_... | [
"logging.error",
"mlabns.db.model.Nagios.get_by_key_name",
"google.appengine.api.memcache.set",
"google.appengine.api.memcache.get"
] | [((289, 333), 'google.appengine.api.memcache.get', 'memcache.get', (['constants.DEFAULT_NAGIOS_ENTRY'], {}), '(constants.DEFAULT_NAGIOS_ENTRY)\n', (301, 333), False, 'from google.appengine.api import memcache\n'), ((370, 430), 'mlabns.db.model.Nagios.get_by_key_name', 'model.Nagios.get_by_key_name', (['constants.DEFAUL... |
import intcode
import utils
class Droid(object):
def __init__(self):
super(Droid, self).__init__()
self.grid = []
self.current_line = []
self.width = 0
self.height = 0
self.neighborhoods = ((1, 0), (0, 1), (-1, 0), (0, -1))
def printGrid(self):
s = ""
... | [
"intcode.Intcode",
"utils.get_input"
] | [((1367, 1421), 'intcode.Intcode', 'intcode.Intcode', (['data', 'droid.getInput', 'droid.setOutput'], {}), '(data, droid.getInput, droid.setOutput)\n', (1382, 1421), False, 'import intcode\n'), ((1296, 1321), 'utils.get_input', 'utils.get_input', (['(2019)', '(17)'], {}), '(2019, 17)\n', (1311, 1321), False, 'import ut... |
__author__ = '<NAME>'
__email__ = '<EMAIL>'
__version__= '1.8'
__status__ = "Research"
__date__ = "2/1/2020"
__license__= "MIT License"
import os
import sys
import numpy as np
import time
import glob
from torchvision.utils import make_grid
from tensorboardX import SummaryWriter
import imageio
import skimage
from para... | [
"tensorboardX.SummaryWriter",
"os.makedirs",
"sys_utils.tohms",
"numpy.floor",
"parameters.Params",
"numpy.zeros",
"os.system",
"numpy.ones",
"time.time",
"torchvision.utils.make_grid",
"os.path.isfile",
"skimage.transform.resize",
"glob.glob",
"os.path.join",
"numpy.sqrt"
] | [((2599, 2622), 'glob.glob', 'glob.glob', (['cfg_filename'], {}), '(cfg_filename)\n', (2608, 2622), False, 'import glob\n'), ((2765, 2773), 'parameters.Params', 'Params', ([], {}), '()\n', (2771, 2773), False, 'from parameters import Params\n'), ((3307, 3336), 'os.path.join', 'os.path.join', (['experiment_name'], {}), ... |
from datetime import timedelta
from unittest import TestCase
from django.utils import timezone
from freezegun import freeze_time
from utils.date import is_time_newer_than
class UtilsDateTestCase(TestCase):
def setUp(self) -> None:
pass
@freeze_time("2020-12-21 03:21:00")
def test_is_less_old_th... | [
"django.utils.timezone.now",
"freezegun.freeze_time",
"utils.date.is_time_newer_than",
"datetime.timedelta"
] | [((258, 292), 'freezegun.freeze_time', 'freeze_time', (['"""2020-12-21 03:21:00"""'], {}), "('2020-12-21 03:21:00')\n", (269, 292), False, 'from freezegun import freeze_time\n'), ((342, 356), 'django.utils.timezone.now', 'timezone.now', ([], {}), '()\n', (354, 356), False, 'from django.utils import timezone\n'), ((359,... |
from pwn import remote
from gmpy2 import next_prime
from Crypto.Util.number import *
conn = remote("03.cr.yp.toc.tf", "25010")
def get_params():
conn.recvuntil("[Q]uit")
conn.sendline("s")
conn.recvuntil(" = ")
p = int(conn.recvuntil("\n").decode())
conn.recvuntil(" = ")
r = int(conn.recvunti... | [
"pwn.remote"
] | [((94, 128), 'pwn.remote', 'remote', (['"""03.cr.yp.toc.tf"""', '"""25010"""'], {}), "('03.cr.yp.toc.tf', '25010')\n", (100, 128), False, 'from pwn import remote\n')] |
import os
import sys
from pykit import fsutil
fn = sys.argv[1]
fsutil.write_file(fn, 'boo')
stat = os.stat(fn)
os.write(1, '{uid},{gid}'.format(uid=stat.st_uid, gid=stat.st_gid))
| [
"pykit.fsutil.write_file",
"os.stat"
] | [((66, 94), 'pykit.fsutil.write_file', 'fsutil.write_file', (['fn', '"""boo"""'], {}), "(fn, 'boo')\n", (83, 94), False, 'from pykit import fsutil\n'), ((102, 113), 'os.stat', 'os.stat', (['fn'], {}), '(fn)\n', (109, 113), False, 'import os\n')] |
""" Define parameters for algorithms. """
import argparse
def str2bool(v):
return v.lower() == "true"
def str2intlist(value):
if not value:
return value
else:
return [int(num) for num in value.split(",")]
def str2list(value):
if not value:
return value
else:
re... | [
"argparse.ArgumentParser"
] | [((501, 614), 'argparse.ArgumentParser', 'argparse.ArgumentParser', (['"""Robot Learning Algorithms"""'], {'formatter_class': 'argparse.ArgumentDefaultsHelpFormatter'}), "('Robot Learning Algorithms', formatter_class=\n argparse.ArgumentDefaultsHelpFormatter)\n", (524, 614), False, 'import argparse\n')] |
import os
import pytest
from ethereum import utils
from ethereum.tools import tester
from ethereum.abi import ContractTranslator
from ethereum.config import config_metropolis
from solc_simple import Builder
GAS_LIMIT = 8000000
START_GAS = GAS_LIMIT - 1000000
config_metropolis['BLOCK_GAS_LIMIT'] = GAS_LIMIT
# Compil... | [
"ethereum.abi.ContractTranslator",
"os.path.realpath",
"solc_simple.Builder",
"ethereum.tools.tester.Chain",
"os.path.join"
] | [((582, 616), 'solc_simple.Builder', 'Builder', (['CONTRACTS_DIR', 'OUTPUT_DIR'], {}), '(CONTRACTS_DIR, OUTPUT_DIR)\n', (589, 616), False, 'from solc_simple import Builder\n'), ((373, 399), 'os.path.realpath', 'os.path.realpath', (['__file__'], {}), '(__file__)\n', (389, 399), False, 'import os\n'), ((693, 707), 'ether... |
from agent import Agent
from monitor import interact
import gym
import numpy as np
env = gym.make('Taxi-v3')
agent = Agent()
avg_rewards, best_avg_reward = interact(env, agent) | [
"agent.Agent",
"gym.make",
"monitor.interact"
] | [((95, 114), 'gym.make', 'gym.make', (['"""Taxi-v3"""'], {}), "('Taxi-v3')\n", (103, 114), False, 'import gym\n'), ((124, 131), 'agent.Agent', 'Agent', ([], {}), '()\n', (129, 131), False, 'from agent import Agent\n'), ((164, 184), 'monitor.interact', 'interact', (['env', 'agent'], {}), '(env, agent)\n', (172, 184), Fa... |
#!/usr/bin/env python3
import sys
import json
for line in sys.stdin:
s = line.split(" ")
obj = {}
obj['id'] = s[0]
obj['date'] = s[1] + " " + s[2] + " " + s[3]
obj['user'] = s[4]
obj['text'] = " ".join(s[5:])
print(json.dumps(obj,ensure_ascii=False)) | [
"json.dumps"
] | [((244, 279), 'json.dumps', 'json.dumps', (['obj'], {'ensure_ascii': '(False)'}), '(obj, ensure_ascii=False)\n', (254, 279), False, 'import json\n')] |
from runpy import run_module
import pytest
from .subtest import _test_stdlib_symbols_in_namespace
# TODO do some research about how to test an interactive CLI application
@pytest.mark.xfail
def test_console_script() -> None:
_test_stdlib_symbols_in_namespace(run_module("importall"))
| [
"runpy.run_module"
] | [((267, 290), 'runpy.run_module', 'run_module', (['"""importall"""'], {}), "('importall')\n", (277, 290), False, 'from runpy import run_module\n')] |
from unittest import TestCase
from fm_agent.fm_config import FastmodelConfig
from fm_agent.utils import SimulatorError
class TestFastmodelConfig(TestCase):
def test_Setting_File(self):
self.assertTrue(FastmodelConfig.SETTINGS_FILE,"settings.json")
def test_parse_params_file_failed(self):
c=Fas... | [
"fm_agent.fm_config.FastmodelConfig"
] | [((317, 334), 'fm_agent.fm_config.FastmodelConfig', 'FastmodelConfig', ([], {}), '()\n', (332, 334), False, 'from fm_agent.fm_config import FastmodelConfig\n'), ((586, 603), 'fm_agent.fm_config.FastmodelConfig', 'FastmodelConfig', ([], {}), '()\n', (601, 603), False, 'from fm_agent.fm_config import FastmodelConfig\n'),... |
from datetime import datetime, date
import unittest
from grandfatherson import (FRIDAY, SATURDAY, SUNDAY)
from grandfatherson.filters import (Seconds, Minutes, Hours, Days, Weeks,
Months, Years, UTC)
def utcdatetime(*args):
return datetime(*args, tzinfo=UTC())
class TestSeco... | [
"grandfatherson.filters.Weeks.filter",
"grandfatherson.filters.Seconds.filter",
"grandfatherson.filters.UTC",
"grandfatherson.filters.Months.filter",
"grandfatherson.filters.Days.mask",
"datetime.date",
"grandfatherson.filters.Days.filter",
"datetime.datetime",
"grandfatherson.filters.Years.filter",... | [((384, 416), 'datetime.datetime', 'datetime', (['(2000)', '(1)', '(1)', '(0)', '(0)', '(1)', '(1)'], {}), '(2000, 1, 1, 0, 0, 1, 1)\n', (392, 416), False, 'from datetime import datetime, date\n'), ((5547, 5579), 'datetime.datetime', 'datetime', (['(2000)', '(1)', '(1)', '(0)', '(1)', '(1)', '(1)'], {}), '(2000, 1, 1, ... |
"""
Players!
"""
import random
from readchar import readchar
class Player(object):
"""
Base player object
"""
def next_move(self, game):
"""
Retrieve the next move for this player in this game
"""
raise NotImplementedError
class HumanPlayer(Player):
"""
Human ... | [
"readchar.readchar",
"random.choice",
"random.randint"
] | [((1190, 1234), 'random.randint', 'random.randint', (['min_mutations', 'max_mutations'], {}), '(min_mutations, max_mutations)\n', (1204, 1234), False, 'import random\n'), ((1919, 1963), 'random.randint', 'random.randint', (['min_mutations', 'max_mutations'], {}), '(min_mutations, max_mutations)\n', (1933, 1963), False,... |
__author__ = 'Administrator'
import requests
import xlstr
import time
class Ticket:
#车票信息
train_no = ''
station_train_code = '' #车次编号，例如K540
from_station_telecode = ''
from_station_name = ''
to_station_telecode = ''
to_station_name = ''
yp_info = '' #未知信息
location_code = ''
s... | [
"time.strptime",
"time.strftime"
] | [((1287, 1333), 'time.strptime', 'time.strptime', (['self.start_train_date', '"""%Y%m%d"""'], {}), "(self.start_train_date, '%Y%m%d')\n", (1300, 1333), False, 'import time\n'), ((1360, 1396), 'time.strftime', 'time.strftime', (['"""%Y-%m-%d"""', 'trainTime'], {}), "('%Y-%m-%d', trainTime)\n", (1373, 1396), False, 'impo... |
import mock
from unittest import TestCase
from ncssl_api_client.config.api import settings
try:
reload # Python 2.7
except NameError:
try:
from importlib import reload # Python 3.4+
except ImportError:
from imp import reload # Python 3.0 - 3.3
try:
__import__('__builtin__')
open... | [
"imp.reload",
"mock.mock_open"
] | [((619, 635), 'imp.reload', 'reload', (['settings'], {}), '(settings)\n', (625, 635), False, 'from imp import reload\n'), ((545, 575), 'mock.mock_open', 'mock.mock_open', ([], {'read_data': 'DATA'}), '(read_data=DATA)\n', (559, 575), False, 'import mock\n')] |
import noisereduce as nr
def remove_noise(data, rate):
return nr.reduce_noise(y=data,
sr=rate,
thresh_n_mult_nonstationary=2,
stationary=False)
| [
"noisereduce.reduce_noise"
] | [((68, 154), 'noisereduce.reduce_noise', 'nr.reduce_noise', ([], {'y': 'data', 'sr': 'rate', 'thresh_n_mult_nonstationary': '(2)', 'stationary': '(False)'}), '(y=data, sr=rate, thresh_n_mult_nonstationary=2, stationary=\n False)\n', (83, 154), True, 'import noisereduce as nr\n')] |
# Copyright 2017 Intel Corporation
#
# 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... | [
"sawtooth_validator.protobuf.block_pb2.BlockHeader",
"sawtooth_validator.protobuf.transaction_pb2.TransactionHeader"
] | [((3753, 3766), 'sawtooth_validator.protobuf.block_pb2.BlockHeader', 'BlockHeader', ([], {}), '()\n', (3764, 3766), False, 'from sawtooth_validator.protobuf.block_pb2 import BlockHeader\n'), ((7790, 7809), 'sawtooth_validator.protobuf.transaction_pb2.TransactionHeader', 'TransactionHeader', ([], {}), '()\n', (7807, 780... |
# coding: utf-8
"""."""
from tango import Database
# Get reference to tango database
DB = Database()
print('=' * 80)
print('Database info:')
print('=' * 80)
print(DB.get_info())
print('=' * 80)
print('Server list:')
print('=' * 80)
print(DB.get_server_list().value_string)
print('')
| [
"tango.Database"
] | [((91, 101), 'tango.Database', 'Database', ([], {}), '()\n', (99, 101), False, 'from tango import Database\n')] |
import unittest
import shutil
import os
import sys
import tests.prep_tests as prep
import validate.validator as v
from validate.common_constants import *
import tests.test_values as test_arrays
class BasicTestCase(unittest.TestCase):
def setUp(self):
self.test_storepath = "./tests/data"
os.makedir... | [
"unittest.main",
"validate.validator.Validator",
"os.makedirs",
"tests.prep_tests.SSTestFile",
"shutil.rmtree",
"os.path.join"
] | [((13692, 13707), 'unittest.main', 'unittest.main', ([], {}), '()\n', (13705, 13707), False, 'import unittest\n'), ((310, 357), 'os.makedirs', 'os.makedirs', (['self.test_storepath'], {'exist_ok': '(True)'}), '(self.test_storepath, exist_ok=True)\n', (321, 357), False, 'import os\n'), ((391, 425), 'shutil.rmtree', 'shu... |
# You need to use this script every time you want to rebuild pyinstaller under the pyQ5 MainWindow.py
#-------------------------------------------------------------
import os
import sys
def resource_path(relative_path):
if hasattr(sys, '_MEIPASS'):
return os.path.join(sys._MEIPASS, relative_path)
... | [
"os.path.abspath",
"os.path.join"
] | [((273, 314), 'os.path.join', 'os.path.join', (['sys._MEIPASS', 'relative_path'], {}), '(sys._MEIPASS, relative_path)\n', (285, 314), False, 'import os\n'), ((340, 360), 'os.path.abspath', 'os.path.abspath', (['"""."""'], {}), "('.')\n", (355, 360), False, 'import os\n')] |
from app.models import Material
from app import db
import json
def handleGetMaterials(page,per_page):
materials = Material.query.paginate(page=page, per_page=per_page, error_out=False)
res = db.engine.execute("select count(*) from material")
count = [r[0] for r in res][0]
materialInfo = {
'mate... | [
"app.models.Material",
"app.models.Material.query.paginate",
"app.models.Material.query.filter_by",
"json.dumps",
"app.db.session.delete",
"app.db.session.commit",
"app.db.engine.execute",
"app.db.session.add"
] | [((119, 189), 'app.models.Material.query.paginate', 'Material.query.paginate', ([], {'page': 'page', 'per_page': 'per_page', 'error_out': '(False)'}), '(page=page, per_page=per_page, error_out=False)\n', (142, 189), False, 'from app.models import Material\n'), ((200, 250), 'app.db.engine.execute', 'db.engine.execute', ... |
import scipy.spatial as sci_spatial
import skimage.draw as ski_draw
import shapely.geometry as shapely_geom
import numpy as np
import os, sys
def create_landscape(no_of_circles, radius):
# create the middle points of the ponds (the ponds should not overlap)
x,y = np.random.randint(0,400), np.random.randi... | [
"numpy.sum",
"numpy.shape",
"numpy.random.randint",
"os.chdir",
"numpy.full",
"numpy.full_like",
"numpy.zeros_like",
"shapely.geometry.Point",
"shapely.geometry.MultiPoint",
"shapely.geometry.Polygon",
"shapely.geometry.LineString",
"numpy.swapaxes",
"scipy.spatial.distance.cdist",
"skimag... | [((1304, 1355), 'numpy.full', 'np.full', (['(1200 + 2 * radius, 1200 + 2 * radius)', '(55)'], {}), '((1200 + 2 * radius, 1200 + 2 * radius), 55)\n', (1311, 1355), True, 'import numpy as np\n'), ((1632, 1685), 'numpy.full', 'np.full', (['(1200 + 2 * radius, 1200 + 2 * radius)', '(-999)'], {}), '((1200 + 2 * radius, 1200... |