code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
#!/usr/bin/env python
"""Parse various Windows persistence mechanisms into PersistenceFiles."""
from grr.lib import artifact_utils
from grr.lib import parsers
from grr.lib.rdfvalues import client as rdf_client
from grr.lib.rdfvalues import paths as rdf_paths
from grr.lib.rdfvalues import standard as rdf_standard
from ... | [
"grr.lib.rdfvalues.paths.PathSpec",
"grr.lib.artifact_utils.GetWindowsEnvironmentVariablesMap",
"grr.path_detection.windows.DetectExecutablePaths",
"grr.lib.rdfvalues.standard.PersistenceFile"
] | [((865, 917), 'grr.lib.artifact_utils.GetWindowsEnvironmentVariablesMap', 'artifact_utils.GetWindowsEnvironmentVariablesMap', (['kb'], {}), '(kb)\n', (913, 917), False, 'from grr.lib import artifact_utils\n'), ((937, 1003), 'grr.path_detection.windows.DetectExecutablePaths', 'path_detection_windows.DetectExecutablePath... |
from django.contrib import admin
from django.urls import path
from django.conf.urls import url, include
from rest_framework import routers
from goods import views
router = routers.DefaultRouter()
router.register(r'users', views.UserViewSet)
router.register(r'groups', views.GroupViewSet)
urlpatterns = [
url(r'^'... | [
"django.urls.path",
"django.conf.urls.include",
"rest_framework.routers.DefaultRouter"
] | [((174, 197), 'rest_framework.routers.DefaultRouter', 'routers.DefaultRouter', ([], {}), '()\n', (195, 197), False, 'from rest_framework import routers\n'), ((433, 464), 'django.urls.path', 'path', (['"""admin/"""', 'admin.site.urls'], {}), "('admin/', admin.site.urls)\n", (437, 464), False, 'from django.urls import pa... |
from http.server import HTTPServer, SimpleHTTPRequestHandler
import re
import json
import time
PORT = 8000
server = None
class CustomHandler(SimpleHTTPRequestHandler):
def do_GET(self):
if re.search('/api/global_regex', self.path):
print(self.path.split('/'))
#This URL will trigger our sample fun... | [
"http.server.HTTPServer",
"http.server.SimpleHTTPRequestHandler.do_GET",
"json.dumps",
"time.sleep",
"re.search"
] | [((204, 245), 're.search', 're.search', (['"""/api/global_regex"""', 'self.path'], {}), "('/api/global_regex', self.path)\n", (213, 245), False, 'import re\n'), ((1311, 1344), 're.search', 're.search', (['"""/api/r/.*"""', 'self.path'], {}), "('/api/r/.*', self.path)\n", (1320, 1344), False, 'import re\n'), ((1712, 174... |
# Create your models here.
from copy import copy
from datetime import date
from django import forms
from django.core.serializers.json import DjangoJSONEncoder
from django.db import DataError, IntegrityError, models, transaction
from django.db.models import Q
from import_common.core import (
matchuj_autora,
ma... | [
"django.db.models.NullBooleanField",
"django.db.models.ForeignKey",
"import_common.exceptions.BPPDatabaseMismatch",
"django.contrib.postgres.fields.JSONField",
"datetime.date.fromisoformat",
"django.forms.IntegerField",
"django.forms.BooleanField",
"django.db.models.BooleanField",
"bpp.models.Autor_... | [((1223, 1256), 'django.forms.CharField', 'forms.CharField', ([], {'max_length': '(10240)'}), '(max_length=10240)\n', (1238, 1256), False, 'from django import forms\n'), ((1272, 1303), 'django.forms.CharField', 'forms.CharField', ([], {'max_length': '(500)'}), '(max_length=500)\n', (1287, 1303), False, 'from django imp... |
import os
from fairing.cloud import gcp
from fairing import utils
from fairing.constants import constants
from fairing.kubernetes.manager import client, KubeManager
from fairing.builders.cluster.context_source import ContextSourceInterface
class GCSContextSource(ContextSourceInterface):
def __init__(self,
... | [
"fairing.kubernetes.manager.KubeManager",
"fairing.cloud.gcp.guess_project_name",
"fairing.utils.crc",
"fairing.cloud.gcp.GCSUploader",
"os.environ.get",
"fairing.kubernetes.manager.client.V1Container"
] | [((383, 425), 'os.environ.get', 'os.environ.get', (['constants.GOOGLE_CREDS_ENV'], {}), '(constants.GOOGLE_CREDS_ENV)\n', (397, 425), False, 'import os\n'), ((577, 590), 'fairing.kubernetes.manager.KubeManager', 'KubeManager', ([], {}), '()\n', (588, 590), False, 'from fairing.kubernetes.manager import client, KubeMana... |
"""
Bilateral Filtering
A bilateral filter is used for smoothening images and reducing noise, while
preserving edges.
"""
import cv2
# read the image
import numpy as np
img = cv2.imread("../images/taj.jpg")
# apply bilateral filter width s = 15
# sigmaColor = sigmaSpace = 75
bilateral = cv2.bilateralFi... | [
"cv2.GaussianBlur",
"cv2.medianBlur",
"cv2.waitKey",
"cv2.destroyAllWindows",
"cv2.blur",
"numpy.hstack",
"cv2.bilateralFilter",
"cv2.imread",
"cv2.imshow"
] | [((191, 222), 'cv2.imread', 'cv2.imread', (['"""../images/taj.jpg"""'], {}), "('../images/taj.jpg')\n", (201, 222), False, 'import cv2\n'), ((305, 341), 'cv2.bilateralFilter', 'cv2.bilateralFilter', (['img', '(15)', '(75)', '(75)'], {}), '(img, 15, 75, 75)\n', (324, 341), False, 'import cv2\n'), ((377, 398), 'cv2.blur'... |
# Copyright (c) 2018 PaddlePaddle 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... | [
"argparse.ArgumentParser",
"paddle.fluid.profiler.profiler",
"utility.get_attention_feeder_data",
"paddle.fluid.layers.reduce_sum",
"paddle.fluid.profiler.cuda_profiler",
"os.path.exists",
"paddle.fluid.dygraph.guard",
"paddle.fluid.layers.cross_entropy",
"paddle.fluid.dygraph.BackwardStrategy",
"... | [((979, 1023), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '__doc__'}), '(description=__doc__)\n', (1002, 1023), False, 'import argparse\n'), ((1034, 1084), 'functools.partial', 'functools.partial', (['add_arguments'], {'argparser': 'parser'}), '(add_arguments, argparser=parser)\n', (1051... |
#!/usr/bin/env python
#
# Copyright 2015 Google Inc.
#
# 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 o... | [
"apitools.base.protorpclite.messages.IntegerField",
"six.with_metaclass",
"textwrap.wrap",
"operator.attrgetter",
"apitools.base.protorpclite.message_types.DateTimeMessage.definition_name",
"apitools.base.protorpclite.messages.Field.lookup_field_type_by_variant",
"apitools.base.protorpclite.messages.Mes... | [((8583, 8622), 'six.with_metaclass', 'six.with_metaclass', (['abc.ABCMeta', 'object'], {}), '(abc.ABCMeta, object)\n', (8601, 8622), False, 'import six\n'), ((1732, 1755), 'apitools.base.protorpclite.messages.StringField', 'messages.StringField', (['(1)'], {}), '(1)\n', (1752, 1755), False, 'from apitools.base.protorp... |
from django.conf.urls import url
from django.contrib.auth import views as django_views
from . import views
urlpatterns = [
url(r'^login/$', views.login, name='account_login'),
url(r'^logout/$', views.logout, name='account_logout'),
url(r'^signup/$', views.signup, name='account_signup'),
url(r'^passwor... | [
"django.contrib.auth.views.PasswordResetDoneView.as_view",
"django.conf.urls.url",
"django.contrib.auth.views.PasswordResetCompleteView.as_view"
] | [((129, 179), 'django.conf.urls.url', 'url', (['"""^login/$"""', 'views.login'], {'name': '"""account_login"""'}), "('^login/$', views.login, name='account_login')\n", (132, 179), False, 'from django.conf.urls import url\n'), ((186, 239), 'django.conf.urls.url', 'url', (['"""^logout/$"""', 'views.logout'], {'name': '""... |
# coding=utf-8
from __future__ import unicode_literals
import os
from mock import patch
from django_app.test import PyW4CTestCase
from utils import gui, path, tmp, patterns
class UtilsTest(PyW4CTestCase):
temp_dir = 'temp'
@staticmethod
@patch('subprocess.check_call')
def test_gui_open_file(subpr... | [
"os.remove",
"utils.path.get_bin_dir",
"utils.gui.open_file",
"mock.patch",
"utils.tmp.get_temp_filename",
"os.listdir"
] | [((257, 287), 'mock.patch', 'patch', (['"""subprocess.check_call"""'], {}), "('subprocess.check_call')\n", (262, 287), False, 'from mock import patch\n'), ((534, 580), 'mock.patch', 'patch', (['"""utils.tmp.settings"""'], {'TEMP_DIR': 'temp_dir'}), "('utils.tmp.settings', TEMP_DIR=temp_dir)\n", (539, 580), False, 'from... |
import torch
from tqdm import tqdm
from codes.utils.moving_average import MovingAverage
class ExperimentRunner:
moving_average_window_size = 100
def __init__(self, configuration):
self.configuration = configuration
def evaluate_model(self, model, problem, split, gpu_number=-1):
problem... | [
"torch.no_grad",
"torch.cuda.is_available",
"codes.utils.moving_average.MovingAverage"
] | [((535, 550), 'torch.no_grad', 'torch.no_grad', ([], {}), '()\n', (548, 550), False, 'import torch\n'), ((651, 709), 'codes.utils.moving_average.MovingAverage', 'MovingAverage', ([], {'window_size': 'self.moving_average_window_size'}), '(window_size=self.moving_average_window_size)\n', (664, 709), False, 'from codes.ut... |
import logging
import requests
from .auth import MpesaBase
logger = logging.getLogger(__name__)
class C2B(MpesaBase):
def __init__(self, *args, **kwargs):
MpesaBase.__init__(self, *args, **kwargs)
def register(self, shortcode=None, response_type=None, confirmation_url=None, validation_url=None):
... | [
"logging.getLogger"
] | [((70, 97), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (87, 97), False, 'import logging\n')] |
try:
from setuptools import setup, find_packages
except ImportError:
from distutils.core import setup, find_packages
__version__ = None
exec(open('wikiscraper/version.py').read())
setup(name='wikiscraper',
version=__version__,
description=__doc__,
author='<NAME>',
author_email='<EMAIL... | [
"distutils.core.find_packages"
] | [((339, 354), 'distutils.core.find_packages', 'find_packages', ([], {}), '()\n', (352, 354), False, 'from distutils.core import setup, find_packages\n')] |
from setuptools import setup
from setuptools.command.build_py import build_py as _build_py
import glob
import platform
import os
import shutil
from openvisualizer import ovVersion
'''
This implementation of the traditional setup.py uses the root package's
package_data parameter to store data files, rather than th... | [
"setuptools.command.build_py.build_py.build_package_data",
"os.path.join",
"platform.architecture"
] | [((1226, 1284), 'os.path.join', 'os.path.join', (['"""openvisualizer"""', '"""data"""', '"""requirements.txt"""'], {}), "('openvisualizer', 'data', 'requirements.txt')\n", (1238, 1284), False, 'import os\n'), ((1974, 2008), 'setuptools.command.build_py.build_py.build_package_data', '_build_py.build_package_data', (['se... |
"""
This script creates an instance of a sacred experiment and defines default configurations.
"""
from src.neural_nets.models import get_model
from src.neural_nets.load_data import get_loader
from src.neural_nets.metrics import MaskedBCE, Accuracy, compute_acc, compute_loss
import src.regression.logistic_regression ... | [
"numpy.random.seed",
"src.neural_nets.load_data.get_loader",
"src.neural_nets.metrics.compute_loss",
"src.neural_nets.models.get_model",
"torch.optim.lr_scheduler.LambdaLR",
"torch.autograd.set_detect_anomaly",
"torch.device",
"src.neural_nets.metrics.MaskedBCE",
"random.randint",
"src.regression.... | [((916, 941), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {}), '()\n', (939, 941), False, 'import torch\n'), ((969, 980), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (978, 980), False, 'import os\n'), ((2195, 2231), 'torch.distributions.Uniform', 'torch.distributions.Uniform', (['(0)', '(0.75)'], {}), '(... |
#!/usr/bin/env python
"""polymer.py - prototype bond breaking reactions:
Uses hydrogels to configure the following system
2 reactions:
-A-A-A- + E -> -A-B-A- + E (spatial) r=2.0, k=1.0
{ (structural) k=10000...
-A-B-A- -> -A + A-A-
A-B -> C + C
}
2 particle_types:
E (enzyme)
... | [
"pandas.DataFrame",
"hydrogels.utils.topology.TopologyBond",
"argparse.ArgumentParser",
"hydrogels.utils.topology.Topology",
"pandas.read_csv",
"softnanotools.logger.Logger",
"hydrogels.utils.system.System",
"pathlib.Path",
"readdy.StructuralReactionRecipe",
"numpy.array",
"yaml.safe_load",
"n... | [((750, 767), 'softnanotools.logger.Logger', 'Logger', (['"""POLYMER"""'], {}), "('POLYMER')\n", (756, 767), False, 'from softnanotools.logger import Logger\n'), ((1117, 1210), 'hydrogels.utils.topology.TopologyBond', 'TopologyBond', (['"""harmonic"""', 'monomer', 'monomer'], {'length': 'length', 'force_constant': 'for... |
# uncompyle6 version 3.3.5
# Python bytecode 2.7 (62211)
# Decompiled from: Python 3.7.3 (default, Apr 24 2019, 15:29:51) [MSC v.1915 64 bit (AMD64)]
# Embedded file name: c:\Jenkins\live\output\win_64_static\Release\python-bundle\MIDI Remote Scripts\pushbase\note_layout_switcher.py
# Compiled at: 2018-11-30 15:48:12
f... | [
"ableton.v2.control_surface.control.ButtonControl"
] | [((886, 901), 'ableton.v2.control_surface.control.ButtonControl', 'ButtonControl', ([], {}), '()\n', (899, 901), False, 'from ableton.v2.control_surface.control import ButtonControl\n')] |
import pytest
import os
import json
from injector import Injector
from datetime import timedelta
from backup.config import Config, Setting, VERSION, Version
from backup.util import DataCache, UpgradeFlags, KEY_CREATED, KEY_LAST_SEEN, CACHE_EXPIRATION_DAYS
from backup.time import Time
@pytest.mark.asyncio
async def te... | [
"json.load",
"backup.util.DataCache",
"backup.config.Version.default",
"datetime.timedelta",
"backup.config.Version.parse"
] | [((387, 410), 'backup.util.DataCache', 'DataCache', (['config', 'time'], {}), '(config, time)\n', (396, 410), False, 'from backup.util import DataCache, UpgradeFlags, KEY_CREATED, KEY_LAST_SEEN, CACHE_EXPIRATION_DAYS\n'), ((653, 676), 'backup.util.DataCache', 'DataCache', (['config', 'time'], {}), '(config, time)\n', (... |
import healpy as hp
import numpy as np
import matplotlib.pyplot as plt
from matplotlib import cm
import scipy.special as spc
import math
import matplotlib as mpl
from scipy.special import lpmn
import scipy.integrate as integrate
from scipy.integrate import quad
from numpy import sin, cos
from matplotlib.cm import Scal... | [
"random.randint",
"healpy.mollview",
"healpy.graticule",
"numpy.zeros",
"healpy.nside2npix",
"matplotlib.pyplot.savefig"
] | [((365, 385), 'healpy.nside2npix', 'hp.nside2npix', (['nside'], {}), '(nside)\n', (378, 385), True, 'import healpy as hp\n'), ((419, 449), 'numpy.zeros', 'np.zeros', (['npix'], {'dtype': 'np.float'}), '(npix, dtype=np.float)\n', (427, 449), True, 'import numpy as np\n'), ((728, 826), 'healpy.mollview', 'hp.mollview', (... |
import speech_recognition as sr
import pyttsx3
import os
speech = sr.Recognizer()
try:
engine = pyttsx3.init()
except ImportError:
print("Requested driver not found")
except RuntimeError:
print("Driver could not be initialized")
voices = engine.getProperty('voices')
engine.setProperty('voice','HKEY_LOCAL_... | [
"pyttsx3.init",
"speech_recognition.Recognizer",
"speech_recognition.Microphone"
] | [((67, 82), 'speech_recognition.Recognizer', 'sr.Recognizer', ([], {}), '()\n', (80, 82), True, 'import speech_recognition as sr\n'), ((101, 115), 'pyttsx3.init', 'pyttsx3.init', ([], {}), '()\n', (113, 115), False, 'import pyttsx3\n'), ((606, 621), 'speech_recognition.Microphone', 'sr.Microphone', ([], {}), '()\n', (6... |
# Generated by Django 3.0.7 on 2020-07-15 22:54
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('properties', '0013_monthlymaintenance_renovationteam_renovationteamexpenses'),
migr... | [
"django.db.migrations.swappable_dependency",
"django.db.models.ForeignKey",
"django.db.models.CharField",
"django.db.models.BooleanField",
"django.db.models.EmailField"
] | [((316, 373), 'django.db.migrations.swappable_dependency', 'migrations.swappable_dependency', (['settings.AUTH_USER_MODEL'], {}), '(settings.AUTH_USER_MODEL)\n', (347, 373), False, 'from django.db import migrations, models\n'), ((561, 678), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'on_delete': 'django.... |
# Generated by Django 2.2.1 on 2019-05-28 09:47
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('tasks', '0009_auto_20190528_0936'),
]
operations = [
migrations.AlterField(
model_name='task',
name='figure',
... | [
"django.db.models.TextField"
] | [((332, 387), 'django.db.models.TextField', 'models.TextField', ([], {'blank': '(True)', 'editable': '(False)', 'null': '(True)'}), '(blank=True, editable=False, null=True)\n', (348, 387), False, 'from django.db import migrations, models\n'), ((506, 561), 'django.db.models.TextField', 'models.TextField', ([], {'blank':... |
#!/usr/bin/env python
# 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
# "Li... | [
"rich.console.Console",
"pathlib.Path",
"sys.exit",
"yaml.safe_dump"
] | [((1153, 1196), 'rich.console.Console', 'Console', ([], {'color_system': '"""standard"""', 'width': '(200)'}), "(color_system='standard', width=200)\n", (1160, 1196), False, 'from rich.console import Console\n'), ((3261, 3272), 'sys.exit', 'sys.exit', (['(1)'], {}), '(1)\n', (3269, 3272), False, 'import sys\n'), ((1571... |
import torch
from torch import nn
import torch.nn.functional as F
from torchvision import datasets, models
#import numpy as np
#import nn_model
# load a pre-trained network
def load_pretrained_model(arch = 'vgg'):
if arch == 'vgg':
model = models.vgg16(pretrained=True)
input_size = 25088
elif ... | [
"torch.nn.Dropout",
"torch.load",
"torchvision.models.densenet121",
"torch.save",
"torch.nn.functional.log_softmax",
"torch.nn.Linear",
"torch.device",
"torchvision.models.vgg16"
] | [((3062, 3114), 'torch.save', 'torch.save', (['checkpoint', "(save_dir + '/checkpoint.pth')"], {}), "(checkpoint, save_dir + '/checkpoint.pth')\n", (3072, 3114), False, 'import torch\n'), ((3307, 3357), 'torch.device', 'torch.device', (["('cuda:0' if isgpu is True else 'cpu')"], {}), "('cuda:0' if isgpu is True else 'c... |
from moto import mock_dynamodb2
import boto3
import os
import time
phone = "+15551234567"
mock_verification = {
'pk': phone,
'sk': 'verificationCode#123456',
'expiration': str(int(time.time() + 1200))
}
@mock_dynamodb2
def setup_mocks():
dynamodb = boto3.resource('dynamodb')
table = dynamodb.c... | [
"boto3.resource",
"time.time"
] | [((270, 296), 'boto3.resource', 'boto3.resource', (['"""dynamodb"""'], {}), "('dynamodb')\n", (284, 296), False, 'import boto3\n'), ((196, 207), 'time.time', 'time.time', ([], {}), '()\n', (205, 207), False, 'import time\n')] |
from django.conf import settings
from django.urls import reverse
from django.utils.translation import ugettext as _
from django_webtest import WebTest
from brouwers.albums.tests.factories import PhotoFactory
from brouwers.forum_tools.tests.factories import ForumUserFactory, TopicFactory
from brouwers.kits.tests.facto... | [
"brouwers.users.tests.factories.UserFactory.create",
"brouwers.albums.tests.factories.PhotoFactory.create",
"brouwers.forum_tools.tests.factories.TopicFactory.create",
"brouwers.kits.tests.factories.ModelKitFactory.create_batch",
"django.urls.reverse",
"brouwers.albums.tests.factories.PhotoFactory.create_... | [((670, 690), 'brouwers.users.tests.factories.UserFactory.create', 'UserFactory.create', ([], {}), '()\n', (688, 690), False, 'from brouwers.users.tests.factories import UserFactory\n'), ((783, 806), 'django.urls.reverse', 'reverse', (['"""builds:index"""'], {}), "('builds:index')\n", (790, 806), False, 'from django.ur... |
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for license information.
from typing import TYPE_CHECKING
from cdm.enums import CdmObjectType, CdmLogCode
from cdm.enums.cdm_operation_type import OperationTypeConvertor, CdmOperationType
... | [
"cdm.persistence.cdmfolder.types.OperationIncludeAttributes",
"cdm.persistence.cdmfolder.types.OperationAddAttributeGroup",
"cdm.persistence.cdmfolder.types.OperationArrayExpansion",
"cdm.persistence.cdmfolder.types.OperationReplaceAsForeignKey",
"cdm.persistence.cdmfolder.types.OperationAddCountAttribute",... | [((2342, 2395), 'cdm.enums.cdm_operation_type.OperationTypeConvertor._from_object_type', 'OperationTypeConvertor._from_object_type', (['object_type'], {}), '(object_type)\n', (2382, 2395), False, 'from cdm.enums.cdm_operation_type import OperationTypeConvertor, CdmOperationType\n'), ((2447, 2537), 'cdm.enums.cdm_operat... |
# -*- coding: utf-8 -*-
#
# 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
#... | [
"airflow.utils.db.create_session",
"flask.flash",
"flask.request.args.get",
"flask.request.form.get",
"flask.request.headers.get",
"wtforms.validators.InputRequired",
"flask_login.login_user",
"flask_bcrypt.check_password_hash",
"base64.b64decode",
"airflow.utils.log.logging_mixin.LoggingMixin",
... | [((1668, 1694), 'flask_login.LoginManager', 'flask_login.LoginManager', ([], {}), '()\n', (1692, 1694), False, 'import flask_login\n'), ((1803, 1817), 'airflow.utils.log.logging_mixin.LoggingMixin', 'LoggingMixin', ([], {}), '()\n', (1815, 1817), False, 'from airflow.utils.log.logging_mixin import LoggingMixin\n'), ((5... |
import main as m
import os
clientes = []
def mostrar_menu_cliente():
os.system('clear')
print("---------------------------------------------")
print(" Agregar cliente ")
print("---------------------------------------------")
print("[1]Agregar")
print("[2]Listar")
... | [
"main.mostrar_menu_principal",
"os.system"
] | [((75, 93), 'os.system', 'os.system', (['"""clear"""'], {}), "('clear')\n", (84, 93), False, 'import os\n'), ((789, 807), 'os.system', 'os.system', (['"""clear"""'], {}), "('clear')\n", (798, 807), False, 'import os\n'), ((1527, 1545), 'os.system', 'os.system', (['"""clear"""'], {}), "('clear')\n", (1536, 1545), False,... |
import unittest
from unittest.mock import patch
from testfixtures import TempDirectory
import os
from hardware.Utils.logger import Logger
from hardware.gpsPi.gps_reader import GPSReader
@patch("serial.Serial")
class GPSPiTests(unittest.TestCase):
def setUp(self):
self.temp_dir = TempDirectory()
def... | [
"unittest.main",
"unittest.mock.patch.dict",
"unittest.mock.patch",
"hardware.gpsPi.gps_reader.GPSReader",
"testfixtures.TempDirectory"
] | [((191, 213), 'unittest.mock.patch', 'patch', (['"""serial.Serial"""'], {}), "('serial.Serial')\n", (196, 213), False, 'from unittest.mock import patch\n'), ((1807, 1872), 'unittest.mock.patch', 'patch', (['"""hardware.gpsPi.gps_reader.date_str_with_current_timezone"""'], {}), "('hardware.gpsPi.gps_reader.date_str_with... |
import argparse
import os
class TestParam( object ):
def __init__( self, host="", port=0, threads=1, http_pool=None, base_url="", ramp=1,
duration=1, conns=1, rand_req=False, max_rand_obj=1, req_dist="", poisson_lam=1.0,
gauss_mean=1.0, gauss_std=1.0, max_iters=5000, loop='clos... | [
"os.path.realpath",
"argparse.ArgumentParser"
] | [((1054, 1079), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (1077, 1079), False, 'import argparse\n'), ((3048, 3074), 'os.path.realpath', 'os.path.realpath', (['__file__'], {}), '(__file__)\n', (3064, 3074), False, 'import os\n')] |
# Copyright 2019-2021 ETH Zurich and the DaCe authors. All rights reserved.
import dace
from dace.memlet import Memlet
import numpy as np
sr = dace.SDFG('strided_range_test')
s0 = sr.add_state('s0')
A = s0.add_array('A', [2, 16, 4], dace.float32)
B = s0.add_array('B', [16], dace.float32)
tasklet = s0.add_tasklet(
... | [
"dace.memlet.Memlet.simple",
"numpy.array",
"numpy.linalg.norm",
"numpy.random.rand",
"dace.SDFG"
] | [((144, 175), 'dace.SDFG', 'dace.SDFG', (['"""strided_range_test"""'], {}), "('strided_range_test')\n", (153, 175), False, 'import dace\n'), ((644, 684), 'dace.memlet.Memlet.simple', 'Memlet.simple', (['A', '"""1, 2*i:2*i+10:8:2, 3"""'], {}), "(A, '1, 2*i:2*i+10:8:2, 3')\n", (657, 684), False, 'from dace.memlet import ... |
import datetime
import paste
import pylons.test
import ckan
from ckan.lib.helpers import json
from ckan.tests import are_foreign_keys_supported, SkipTest
def datetime_from_string(s):
'''Return a standard datetime.datetime object initialised from a string in
the same format used for timestamps in dictized activ... | [
"ckan.model.repo.rebuild_db",
"paste.fixture.TestApp",
"ckan.tests.are_foreign_keys_supported",
"ckan.model.Session",
"ckan.tests.SkipTest",
"ckan.lib.helpers.json.dumps",
"datetime.datetime.strptime",
"ckan.tests.CreateTestData.create",
"ckan.model.Package.get",
"ckan.model.User.get",
"datetime... | [((405, 458), 'datetime.datetime.strptime', 'datetime.datetime.strptime', (['s', '"""%Y-%m-%dT%H:%M:%S.%f"""'], {}), "(s, '%Y-%m-%dT%H:%M:%S.%f')\n", (431, 458), False, 'import datetime\n'), ((1019, 1048), 'ckan.lib.helpers.json.dumps', 'json.dumps', (["{'id': object_id}"], {}), "({'id': object_id})\n", (1029, 1048), F... |
# This file is subject to the terms and conditions defined in
# file 'LICENSE', which is part of this source code package.
import random
from .heuristics import path_cost
from .rrt_star import RRTStar
class RRTStarBidirectional(RRTStar):
def __init__(self, X, Q, x_init, x_goal, max_samples, r, prc=0.01, rewire_... | [
"random.random"
] | [((4035, 4050), 'random.random', 'random.random', ([], {}), '()\n', (4048, 4050), False, 'import random\n')] |
from builtins import zip
from builtins import range
import numpy as np
def save_data_regresssion():
# n = 20 # number of labeled/training data
# D = 1 # dimension of input data
x = np.array([[2.083970427750732, -0.821018066101379, -0.617870699182597, -1.183822608860694,\
0.2740... | [
"numpy.zeros_like",
"numpy.ones",
"numpy.prod",
"numpy.array",
"numpy.linalg.inv",
"numpy.arange",
"numpy.dot",
"numpy.eye",
"numpy.savez",
"builtins.range",
"numpy.concatenate",
"numpy.sqrt"
] | [((1348, 1409), 'numpy.savez', 'np.savez', (['"""Regression/regression_data"""'], {'x': 'x', 'y': 'y', 'xstar': 'xstar'}), "('Regression/regression_data', x=x, y=y, xstar=xstar)\n", (1356, 1409), True, 'import numpy as np\n'), ((1899, 5413), 'numpy.array', 'np.array', (['[[0.089450165731417, -0.000700765006939], [1.171... |
import torch
import torch.optim as optim
import numpy as np
from PIL import Image
#import pano
import pano_gen as pano
import time
def vecang(vec1, vec2):
vec1 = vec1 / np.sqrt((vec1 ** 2).sum())
vec2 = vec2 / np.sqrt((vec2 ** 2).sum())
return np.arccos(np.dot(vec1, vec2))
def rotatevec(vec, theta):
... | [
"torch.cat",
"torch.cos",
"torch.ceil",
"numpy.mean",
"torch.arange",
"torch.no_grad",
"pano_gen.fit_avg_z",
"torch.FloatTensor",
"numpy.append",
"torch.atan2",
"numpy.stack",
"torch.zeros_like",
"pano_gen.constraint_cor_id_same_z",
"torch.floor",
"numpy.dot",
"numpy.concatenate",
"t... | [((451, 468), 'torch.cat', 'torch.cat', (['[x, y]'], {}), '([x, y])\n', (460, 468), False, 'import torch\n'), ((840, 864), 'torch.cat', 'torch.cat', (['[u, v]'], {'dim': '(1)'}), '([u, v], dim=1)\n', (849, 864), False, 'import torch\n'), ((3390, 3429), 'torch.stack', 'torch.stack', (['[corid[:, 1], corid[:, 0]]'], {}),... |
# -*- coding: utf-8 -*-
# Copyright (c) 2017, Softbank Robotics Europe
# All rights reserved.
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
# * Redistributions of source code must retain the above copyright notice, t... | [
"xmp.xmp.registerNamespace",
"qidata.metadata_objects.Transform",
"qidata.metadata_objects.TimeStamp",
"qidata.qidataobject.QiDataObject.__unicode__",
"_mixin._removePrefixes"
] | [((1995, 2046), 'xmp.xmp.registerNamespace', 'registerNamespace', (['QIDATA_SENSOR_NS', '"""qidatasensor"""'], {}), "(QIDATA_SENSOR_NS, 'qidatasensor')\n", (2012, 2046), False, 'from xmp.xmp import XMPFile, registerNamespace\n'), ((3270, 3300), 'qidata.qidataobject.QiDataObject.__unicode__', 'QiDataObject.__unicode__',... |
import cStringIO
from utils import makeIndentString
def writerFor(obj):
return {
dict: writeDict,
list: writeList,
str: writeString,
bool: writeBoolean
}[type(obj)]
def write(obj, outstream=None, indentStr=None, level=0):
outstream = outstream or cStringIO.StringIO()
... | [
"cStringIO.StringIO",
"utils.makeIndentString"
] | [((330, 364), 'utils.makeIndentString', 'makeIndentString', (['indentStr', 'level'], {}), '(indentStr, level)\n', (346, 364), False, 'from utils import makeIndentString\n'), ((1179, 1213), 'utils.makeIndentString', 'makeIndentString', (['indentStr', 'level'], {}), '(indentStr, level)\n', (1195, 1213), False, 'from util... |
import os
from datetime import datetime
from flask import (
Flask, flash, render_template, redirect, request, session, url_for)
from flask_pymongo import PyMongo
import cloudinary as Cloud
from cloudinary.uploader import upload, destroy
from bson.objectid import ObjectId
from werkzeug.security import generate_passw... | [
"cloudinary.uploader.destroy",
"flask.flash",
"flask.session.pop",
"flask.request.args.get",
"flask.request.form.get",
"bson.objectid.ObjectId",
"flask.Flask",
"os.path.exists",
"flask.session.get",
"os.environ.get",
"flask.url_for",
"flask.render_template",
"flask_pymongo.PyMongo",
"datet... | [((353, 377), 'os.path.exists', 'os.path.exists', (['"""env.py"""'], {}), "('env.py')\n", (367, 377), False, 'import os\n'), ((402, 417), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (407, 417), False, 'from flask import Flask, flash, render_template, redirect, request, session, url_for\n'), ((448, 478),... |
import datetime
import logging as logme
from .tweet import utc_to_local
class Datelock:
until = None
since = None
_since_def_user = None
def convertToDateTime(string):
dateTimeList = string.split()
ListLength = len(dateTimeList)
if ListLength == 2:
return string
if ListLength =... | [
"datetime.datetime.strptime",
"logging.debug",
"datetime.datetime.today"
] | [((418, 448), 'logging.debug', 'logme.debug', (["(__name__ + ':Set')"], {}), "(__name__ + ':Set')\n", (429, 448), True, 'import logging as logme\n'), ((538, 583), 'datetime.datetime.strptime', 'datetime.datetime.strptime', (['Until', '"""%Y-%m-%d"""'], {}), "(Until, '%Y-%m-%d')\n", (564, 583), False, 'import datetime\n... |
import pandas as pd
import time
import calendar
from datetime import datetime, timedelta
# Filenames (Files are in same folder as the python script)
chicago = 'chicago.csv'
new_york_city = 'new_york_city.csv'
washington = 'washington.csv'
def get_city():
'''Asks the user for a city and returns the filename for t... | [
"pandas.read_csv",
"datetime.datetime",
"time.time",
"pandas.to_datetime",
"calendar.monthrange"
] | [((10547, 10558), 'time.time', 'time.time', ([], {}), '()\n', (10556, 10558), False, 'import time\n'), ((10856, 10867), 'time.time', 'time.time', ([], {}), '()\n', (10865, 10867), False, 'import time\n'), ((11089, 11100), 'time.time', 'time.time', ([], {}), '()\n', (11098, 11100), False, 'import time\n'), ((11527, 1153... |
from datetime import date
from email import message
from vigilancia.order_screenshot import Orders
from django.db.models.fields import DateField
from django.http import Http404
from django.http import HttpResponse
from django.template import loader
from django.shortcuts import get_object_or_404, render
from .models imp... | [
"json.loads",
"django.http.HttpResponse",
"os.path.dirname",
"django.http.JsonResponse",
"datetime.datetime.now",
"vigilancia.order_screenshot.Orders",
"rest_framework.response.Response",
"ftplib.FTP",
"rest_framework.parsers.JSONParser",
"os.path.join",
"logging.getLogger"
] | [((952, 979), 'logging.getLogger', 'logging.getLogger', (['"""django"""'], {}), "('django')\n", (969, 979), False, 'import logging\n'), ((1043, 1086), 'django.http.JsonResponse', 'JsonResponse', (["{message: 'test'}"], {'status': '(201)'}), "({message: 'test'}, status=201)\n", (1055, 1086), False, 'from django.http imp... |
'''
@author: <NAME>
Created on May 12, 2011
'''
from django.conf.urls.defaults import patterns
import handlers
urlpatterns = patterns(
'',
(r'^notification/$',
handlers.notification_resource,
{},
'notification'),
) | [
"django.conf.urls.defaults.patterns"
] | [((127, 216), 'django.conf.urls.defaults.patterns', 'patterns', (['""""""', "('^notification/$', handlers.notification_resource, {}, 'notification')"], {}), "('', ('^notification/$', handlers.notification_resource, {},\n 'notification'))\n", (135, 216), False, 'from django.conf.urls.defaults import patterns\n')] |
"""
A basic python script that demonstrates how to use the FST8 reader, writer, and wrapper in a purely
python setting. These functions are constructed to provide a simple interface for controlling FAST
programmatically with minimal additional dependencies.
"""
# Hacky way of doing relative imports
from __future__ impo... | [
"CaseGen_IEC.CaseGen_IEC",
"ROSCO_toolbox.ofTools.fast_io.FAST_writer.InputWriter_OpenFAST",
"os.makedirs",
"ROSCO_toolbox.ofTools.fast_io.FAST_reader.InputReader_FAST7",
"ROSCO_toolbox.ofTools.fast_io.FAST_wrapper.FastWrapper",
"os.path.realpath",
"os.path.exists",
"multiprocessing.cpu_count",
"Cas... | [((16453, 16545), 'CaseGen_General.CaseGen_General', 'CaseGen_General', (['case_inputs'], {'dir_matrix': 'fastBatch.FAST_runDirectory', 'namebase': '"""testing"""'}), "(case_inputs, dir_matrix=fastBatch.FAST_runDirectory,\n namebase='testing')\n", (16468, 16545), False, 'from CaseGen_General import CaseGen_General\n... |
"""
Prior class for use in pisa.core.Param objects
"""
from __future__ import absolute_import, division
from collections import Iterable, OrderedDict
from numbers import Number
from operator import setitem
import numpy as np
from scipy.interpolate import splev, splrep, interp1d
from scipy.optimize import fminbound
... | [
"numpy.abs",
"matplotlib.pyplot.figure",
"numpy.sin",
"pisa.utils.log.logging.info",
"scipy.interpolate.interp1d",
"matplotlib.pyplot.tight_layout",
"pisa.utils.log.logging.debug",
"pisa.utils.fileio.from_file",
"numpy.max",
"numpy.linspace",
"scipy.interpolate.splrep",
"pisa.utils.log.set_ver... | [((15175, 15189), 'matplotlib.use', 'mpl.use', (['"""pdf"""'], {}), "('pdf')\n", (15182, 15189), True, 'import matplotlib as mpl\n'), ((15439, 15480), 'pisa.utils.log.logging.info', 'logging.info', (['"""Plotting Prior: %s"""', 'prior'], {}), "('Plotting Prior: %s', prior)\n", (15451, 15480), False, 'from pisa.utils.lo... |
# -*- coding: UTF-8 -*-
from flask import url_for, g, redirect
from flask_login import logout_user, current_user
from datetime import datetime
from importlib import import_module
from .. import db, login_manager
from ..models import User
from . import auth
@auth.route('/login/<string:authtype>')
def login_authorize(... | [
"flask.redirect",
"datetime.datetime.utcnow",
"importlib.import_module",
"flask_login.logout_user"
] | [((546, 559), 'flask_login.logout_user', 'logout_user', ([], {}), '()\n', (557, 559), False, 'from flask_login import logout_user, current_user\n'), ((571, 584), 'flask.redirect', 'redirect', (['"""/"""'], {}), "('/')\n", (579, 584), False, 'from flask import url_for, g, redirect\n'), ((351, 393), 'importlib.import_mod... |
#!/usr/bin env python
import json
import mock
from tests.unit import AWSMockServiceTestCase
from boto.cloudsearch2.domain import Domain
from boto.cloudsearch2.layer1 import CloudSearchConnection
from boto.cloudsearchdomain.layer1 import CloudSearchDomainConnection
class CloudSearchDomainConnectionTest(AWSMockServiceT... | [
"boto.cloudsearch2.layer1.CloudSearchConnection",
"json.loads",
"boto.cloudsearchdomain.layer1.CloudSearchDomainConnection",
"json.dumps"
] | [((1331, 1461), 'boto.cloudsearch2.layer1.CloudSearchConnection', 'CloudSearchConnection', ([], {'aws_access_key_id': '"""aws_access_key_id"""', 'aws_secret_access_key': '"""aws_secret_access_key"""', 'sign_request': '(True)'}), "(aws_access_key_id='aws_access_key_id',\n aws_secret_access_key='aws_secret_access_key'... |
"""
Copyright 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved
Licensed under the MIT No Attribution License (MIT-0) (the ‘License’). You may not use this file except in compliance
with the License. A copy of the License is located at
https://opensource.org/licenses/MIT-0
Permission is here... | [
"boto3.client",
"json.dumps"
] | [((1809, 1833), 'boto3.client', 'boto3.client', (['"""pinpoint"""'], {}), "('pinpoint')\n", (1821, 1833), False, 'import boto3\n'), ((1754, 1781), 'json.dumps', 'json.dumps', (['event'], {'indent': '(4)'}), '(event, indent=4)\n', (1764, 1781), False, 'import json\n'), ((2491, 2521), 'json.dumps', 'json.dumps', (['respo... |
#
# Copyright (c) 2021 Software AG, Darmstadt, Germany and/or its licensors
#
# SPDX-License-Identifier: Apache-2.0
#
# 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.apach... | [
"click.argument",
"c8ylp.env.loadenv",
"click.option",
"os.path.exists",
"click.echo",
"logging.info",
"os.path.isfile",
"click.Path",
"c8ylp.rest_client.c8yclient.CumulocityClient",
"click.secho",
"click.IntRange"
] | [((2964, 3140), 'click.option', 'click.option', (['"""--host"""', '"""host"""'], {'is_eager': '(True)', 'prompt': '(False)', 'envvar': "('C8Y_HOST', 'C8Y_BASEURL', 'C8Y_URL')", 'help': '"""Cumulocity Hostname [required] [env var: C8Y_HOST]"""'}), "('--host', 'host', is_eager=True, prompt=False, envvar=(\n 'C8Y_HOST... |
import sys
import unittest
import numpy as np
import crocoddyl
import pinocchio
from crocoddyl.utils import (CoMPositionCostDerived, ControlCostDerived, FramePlacementCostDerived,
FrameTranslationCostDerived, FrameVelocityCostDerived, StateCostDerived)
class CostModelAbstractTestCase(un... | [
"numpy.allclose",
"pinocchio.forwardKinematics",
"unittest.TestLoader",
"pinocchio.jacobianCenterOfMass",
"crocoddyl.CostModelCoMPosition",
"crocoddyl.utils.FrameVelocityCostDerived",
"pinocchio.SE3.Random",
"crocoddyl.utils.FrameTranslationCostDerived",
"crocoddyl.CostModelState",
"pinocchio.comp... | [((6529, 6571), 'pinocchio.buildSampleModelHumanoidRandom', 'pinocchio.buildSampleModelHumanoidRandom', ([], {}), '()\n', (6569, 6571), False, 'import pinocchio\n'), ((6590, 6627), 'crocoddyl.StateMultibody', 'crocoddyl.StateMultibody', (['ROBOT_MODEL'], {}), '(ROBOT_MODEL)\n', (6614, 6627), False, 'import crocoddyl\n'... |
from _mnncengine.cv import *
import _mnncengine.cv as _F
import MNN.numpy as _np
import MNN
def __to_int(x):
dtype = x.dtype
if dtype == _np.int32:
return x
return x.astype(_np.int32)
def resize(src, dsize=None, fx=None, fy=None, interpolation=INTER_LINEAR, code = None, mean=[], norm=[]):
if ds... | [
"MNN.numpy.pad",
"MNN.numpy.bitwise_xor",
"MNN.CVMatrix",
"MNN.numpy.concatenate",
"MNN.numpy.where",
"MNN.numpy.zeros_like",
"MNN.numpy.expand_dims",
"MNN.numpy.bitwise_or",
"MNN.numpy.mean",
"MNN.numpy.bitwise_and",
"MNN.numpy.tile",
"_mnncengine.cv.resize"
] | [((583, 645), '_mnncengine.cv.resize', '_F.resize', (['src', 'dsize', 'fx', 'fy', 'interpolation', 'code', 'mean', 'norm'], {}), '(src, dsize, fx, fy, interpolation, code, mean, norm)\n', (592, 645), True, 'import _mnncengine.cv as _F\n'), ((922, 947), 'MNN.numpy.expand_dims', '_np.expand_dims', (['mask', '(-1)'], {}),... |
#
# Copyright (c) 2017, UT-BATTELLE, LLC
# All rights reserved.
#
# This software is released under the BSD license detailed
# in the LICENSE file in the top level a-prime directory
#
import numpy
from get_season_months_index import get_season_months_index
def get_days_in_season_months(begin_month, end_month):
da... | [
"get_season_months_index.get_season_months_index",
"numpy.array"
] | [((334, 395), 'numpy.array', 'numpy.array', (['[31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]'], {}), '([31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31])\n', (345, 395), False, 'import numpy\n'), ((433, 480), 'get_season_months_index.get_season_months_index', 'get_season_months_index', (['begin_month', 'end_month'], ... |
import discord
from discord.ext import commands
from discord.ext.commands import Cog
import config
import json
from helpers.checks import check_if_staff
from helpers.userlogs import get_userlog, set_userlog, userlog_event_types
class ModUserlog(Cog):
def __init__(self, bot):
self.bot = bot
def get_us... | [
"discord.ext.commands.command",
"discord.ext.commands.check",
"discord.Color.green",
"json.dumps",
"discord.ext.commands.clean_content",
"discord.Color.dark_red",
"discord.ext.commands.guild_only",
"helpers.userlogs.get_userlog"
] | [((3450, 3471), 'discord.ext.commands.guild_only', 'commands.guild_only', ([], {}), '()\n', (3469, 3471), False, 'from discord.ext import commands\n'), ((3477, 3507), 'discord.ext.commands.check', 'commands.check', (['check_if_staff'], {}), '(check_if_staff)\n', (3491, 3507), False, 'from discord.ext import commands\n'... |
#!/usr/bin/env python3
import pandas as pd
import sys
input_file = sys.argv[1]
output_file = sys.argv[2]
data_frame = pd.read_csv(input_file, header=None)
data_frame = data_frame.drop([0,1,2,16,17,18])
data_frame.columns = data_frame.iloc[0]
data_frame = data_frame.reindex(data_frame.index.drop(3))
data_frame.to_cs... | [
"pandas.read_csv"
] | [((120, 156), 'pandas.read_csv', 'pd.read_csv', (['input_file'], {'header': 'None'}), '(input_file, header=None)\n', (131, 156), True, 'import pandas as pd\n')] |
import requests
import warnings
from .helper import String
from ..errors import RequestError
class Session(object):
"""Dynamic way to way to keep requests.Session through out whole programs."""
TIMEOUT = 10
TIMEOUT_COUNT = 0
def __new__(cls, *args, **kwargs):
if not hasattr(cls, "cache"):
... | [
"requests.adapters.HTTPAdapter",
"warnings.warn",
"requests.Session"
] | [((441, 459), 'requests.Session', 'requests.Session', ([], {}), '()\n', (457, 459), False, 'import requests\n'), ((510, 579), 'requests.adapters.HTTPAdapter', 'requests.adapters.HTTPAdapter', ([], {'pool_connections': '(600)', 'pool_maxsize': '(600)'}), '(pool_connections=600, pool_maxsize=600)\n', (539, 579), False, '... |
from calendar import monthrange
from datetime import datetime, timedelta, tzinfo, date
from google.appengine.ext import ndb
from pytz import timezone, UTC
from consts.event_type import EventType
from models.event import Event
EST = timezone('EST')
class SeasonHelper:
""" General season-information helper metho... | [
"database.event_query.EventListQuery",
"datetime.datetime",
"datetime.timedelta",
"pytz.timezone",
"datetime.datetime.now",
"models.event.Event.event_type_enum.IN"
] | [((235, 250), 'pytz.timezone', 'timezone', (['"""EST"""'], {}), "('EST')\n", (243, 250), False, 'from pytz import timezone, UTC\n'), ((381, 395), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (393, 395), False, 'from datetime import datetime, timedelta, tzinfo, date\n'), ((1433, 1450), 'datetime.datetime.n... |
import torch
import torch.nn as nn
import torch.nn.functional as F
from .resblocks import BasicBlock
from .attention import SEAttention
class SEFCResPRE(nn.Module):
def __init__(self, args = {}):
super(SEFCResPRE, self).__init__()
in_channel, out_channel = args.get('input_channel', 441), args.get(... | [
"torch.nn.Conv2d",
"torch.nn.ReLU",
"torch.nn.InstanceNorm2d",
"torch.nn.Sequential"
] | [((557, 621), 'torch.nn.Conv2d', 'nn.Conv2d', (['in_channel', 'hidden_channel'], {'kernel_size': '(1)', 'bias': '(False)'}), '(in_channel, hidden_channel, kernel_size=1, bias=False)\n', (566, 621), True, 'import torch.nn as nn\n'), ((645, 678), 'torch.nn.InstanceNorm2d', 'nn.InstanceNorm2d', (['hidden_channel'], {}), '... |
from socket import *
import _io
class Socket(socket):
def __init__(self,*args,**kwargs):
bufsize=kwargs.get("bufsize",1024)
if bufsize<10:
raise ValueError("buffer too small")
self.bufsize=bufsize
if "bufsize" in kwargs:
del kwargs["bufsize"]
super()._... | [
"_io.BytesIO"
] | [((789, 806), '_io.BytesIO', '_io.BytesIO', (['data'], {}), '(data)\n', (800, 806), False, 'import _io\n')] |
# -*- coding: utf-8 -*-
from __future__ import print_function
from __future__ import division
import time
from datetime import datetime
import warnings
import numpy as np
import pandas as pd
from numpy import dot, exp
from numpy.linalg import norm, inv
from scipy.linalg import solve as spsolve
from scipy.integrate im... | [
"lifelines.utils.significance_codes_as_text",
"scipy.linalg.solve",
"lifelines.statistics.chisq_test",
"numpy.empty",
"numpy.ones",
"numpy.isnan",
"numpy.argsort",
"datetime.datetime.utcnow",
"matplotlib.pyplot.figure",
"numpy.linalg.norm",
"numpy.exp",
"lifelines.utils.normalize",
"numpy.un... | [((5481, 5510), 'lifelines.utils.coalesce', 'coalesce', (['strata', 'self.strata'], {}), '(strata, self.strata)\n', (5489, 5510), False, 'from lifelines.utils import survival_table_from_events, inv_normal_cdf, normalize, significance_code, significance_codes_as_text, concordance_index, _get_index, qth_survival_times, p... |
from JumpScale import j
j.application.start("gendocs")
j.application.stop()
| [
"JumpScale.j.application.stop",
"JumpScale.j.application.start"
] | [((25, 55), 'JumpScale.j.application.start', 'j.application.start', (['"""gendocs"""'], {}), "('gendocs')\n", (44, 55), False, 'from JumpScale import j\n'), ((58, 78), 'JumpScale.j.application.stop', 'j.application.stop', ([], {}), '()\n', (76, 78), False, 'from JumpScale import j\n')] |
"""pypi package setup."""
from __future__ import print_function
import codecs
from os import path
from setuptools import setup, find_packages
try:
import ROOT # pylint: disable=W0611
except ImportError:
print("ROOT is required by this library.")
DEPS = ['numpy', 'PyYAML>4.*', 'future', 'pylint']
HERE = path.... | [
"os.path.dirname",
"os.path.join",
"setuptools.find_packages"
] | [((328, 350), 'os.path.dirname', 'path.dirname', (['__file__'], {}), '(__file__)\n', (340, 350), False, 'from os import path\n'), ((370, 398), 'os.path.join', 'path.join', (['HERE', '"""README.md"""'], {}), "(HERE, 'README.md')\n", (379, 398), False, 'from os import path\n'), ((1083, 1134), 'setuptools.find_packages', ... |
from __future__ import absolute_import
from RecoTracker.IterativeTracking.LowPtQuadStep_cff import *
from .HIPixelTripletSeeds_cff import *
from .HIPixel3PrimTracks_cfi import *
hiLowPtQuadStepClusters = cms.EDProducer("HITrackClusterRemover",
clusterLessSolution = cms.bool(True),
trajectories = cms.InputTag... | [
"Configuration.Eras.Modifier_trackingPhase1_cff.trackingPhase1.toModify",
"RecoTracker.TkHitPairs.hitPairEDProducer_cfi.hitPairEDProducer.clone",
"RecoPixelVertexing.PixelTrackFitting.pixelTracks_cfi.pixelTracks.clone"
] | [((2342, 2570), 'RecoTracker.TkHitPairs.hitPairEDProducer_cfi.hitPairEDProducer.clone', '_hitPairEDProducer.clone', ([], {'clusterCheck': '""""""', 'seedingLayers': '"""hiLowPtQuadStepSeedLayers"""', 'trackingRegions': '"""hiLowPtQuadStepTrackingRegions"""', 'maxElement': '(50000000)', 'produceIntermediateHitDoublets':... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Example script to run shipdemo.py
shipdemo copies RAW files to a "collector" folder, simulating an echosounder
when collecting data. shipdemo is useful for testing the RapidKrill listening
routine.
Created on Thu Aug 15 12:40:32 2019
@author: <NAME>, British Antarcti... | [
"shipdemo.shipdemo"
] | [((1315, 1336), 'shipdemo.shipdemo', 'shipdemo', ([], {'timerate': 'tr'}), '(timerate=tr)\n', (1323, 1336), False, 'from shipdemo import shipdemo\n')] |
#!/usr/bin/env python
# coding=utf-8
"""
pattern base class.
generates a test pattern.
history:
see git commits
todo:
~ all fine :-)
"""
# https://docs.python.org/2.7/howto/pyporting.html#division
from __future__ import division
import sys
import importlib
import os
import pkgutil
impo... | [
"importlib.import_module",
"colorsys.hsv_to_rgb",
"os.path.dirname",
"struct.pack",
"collections.namedtuple",
"array.array"
] | [((6622, 6673), 'collections.namedtuple', 'collections.namedtuple', (['"""Value_16bit"""', "['hb', 'lb']"], {}), "('Value_16bit', ['hb', 'lb'])\n", (6644, 6673), False, 'import collections\n'), ((6122, 6165), 'colorsys.hsv_to_rgb', 'colorsys.hsv_to_rgb', (['hue', 'saturation', 'value'], {}), '(hue, saturation, value)\n... |
import argparse
from pack import doPack
from extract import doExtract
parser = argparse.ArgumentParser()
subParsers = parser.add_subparsers(title="subcommands")
parserPack = subParsers.add_parser(
"pack",
help = "compress and pack data into a .p8 cart",
description = "Reads assets from a text file, com... | [
"argparse.ArgumentParser"
] | [((81, 106), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (104, 106), False, 'import argparse\n')] |
""" imports & globals """
from azure.storage import CloudStorageAccount
from azure.storage.blob import BlockBlobService, Blob, ContentSettings
import datetime, os
from ast import literal_eval
from functools import wraps
import uuid
from mimetypes import guess_type, guess_extension, guess_all_extensions
""" helpers "... | [
"os.remove",
"azure.storage.blob.ContentSettings",
"os.path.isfile",
"os.path.join",
"mimetypes.guess_type",
"azurestoragewrap.exception.ModelRegisteredMoreThanOnceError",
"azurestoragewrap.encryption.KeyWrapper",
"azurestoragewrap.encryption.KeyResolver",
"azurestoragewrap.exception.AzureStorageWra... | [((721, 758), 'logging.getLogger', 'logging.getLogger', (['"""azurestoragewrap"""'], {}), "('azurestoragewrap')\n", (738, 758), False, 'import logging\n'), ((5060, 5088), 'os.path.isfile', 'os.path.isfile', (['path_to_file'], {}), '(path_to_file)\n', (5074, 5088), False, 'import datetime, os\n'), ((7093, 7120), 'os.pat... |
# Generated by the protocol buffer compiler. DO NOT EDIT!
# sources: validate/v1/validate.proto
# plugin: python-betterproto
from dataclasses import dataclass
from datetime import datetime, timedelta
from typing import List
import betterproto
from betterproto.grpc.grpclib_server import ServiceBase
class KnownRegex(... | [
"betterproto.int32_field",
"betterproto.bytes_field",
"betterproto.bool_field",
"betterproto.sfixed64_field",
"betterproto.int64_field",
"betterproto.sfixed32_field",
"betterproto.string_field",
"betterproto.fixed64_field",
"betterproto.fixed32_field",
"betterproto.uint64_field",
"betterproto.me... | [((600, 631), 'dataclasses.dataclass', 'dataclass', ([], {'eq': '(False)', 'repr': '(False)'}), '(eq=False, repr=False)\n', (609, 631), False, 'from dataclasses import dataclass\n'), ((2483, 2514), 'dataclasses.dataclass', 'dataclass', ([], {'eq': '(False)', 'repr': '(False)'}), '(eq=False, repr=False)\n', (2492, 2514)... |
#-
# ==========================================================================
# Copyright 2015 Autodesk, Inc. All rights reserved.
#
# Use of this software is subject to the terms of the Autodesk
# license agreement provided at the time of installation or download,
# or which otherwise accompanies this software in e... | [
"io.BytesIO",
"maya.api.OpenMaya.MPxCommand.__init__",
"maya.api.OpenMaya.MFnDependencyNode",
"maya.api.OpenMaya.MGlobal.getActiveSelectionList",
"maya.api.OpenMaya.MFnPlugin",
"maya.api.OpenMaya.MItSelectionList",
"maya.api.OpenMaya.MFnPluginData",
"maya.api.OpenMaya.MFnTypedAttribute",
"pickle.Pic... | [((930, 948), 'maya.api.OpenMaya.MTypeId', 'om.MTypeId', (['(524291)'], {}), '(524291)\n', (940, 948), True, 'import maya.api.OpenMaya as om\n'), ((4095, 4138), 'maya.api.OpenMaya.MFnPlugin', 'om.MFnPlugin', (['obj', '"""Autodesk"""', '"""3.0"""', '"""Any"""'], {}), "(obj, 'Autodesk', '3.0', 'Any')\n", (4107, 4138), Tr... |
import json
import statistics
import collections
import re
from qcg.pilotjob.utils.auxdir import find_report_files, find_log_files, find_rtimes_files, find_final_status_files
from qcg.pilotjob.utils.util import parse_datetime
from json import JSONDecodeError
from datetime import datetime, timedelta
class JobsReport... | [
"qcg.pilotjob.utils.auxdir.find_log_files",
"statistics.pstdev",
"statistics.variance",
"qcg.pilotjob.utils.auxdir.find_rtimes_files",
"statistics.median_low",
"json.loads",
"statistics.pvariance",
"datetime.timedelta",
"statistics.median_high",
"statistics.median",
"statistics.stdev",
"dateti... | [((419, 445), 'qcg.pilotjob.utils.auxdir.find_report_files', 'find_report_files', (['workdir'], {}), '(workdir)\n', (436, 445), False, 'from qcg.pilotjob.utils.auxdir import find_report_files, find_log_files, find_rtimes_files, find_final_status_files\n'), ((557, 580), 'qcg.pilotjob.utils.auxdir.find_log_files', 'find_... |
from typing import List, Optional, Tuple
from collections import defaultdict
from mp_api.core.client import BaseRester
from mp_api.routes.eos.models import EOSDoc
class EOSRester(BaseRester):
suffix = "eos"
document_model = EOSDoc # type: ignore
primary_key = "task_id"
def search_eos_docs(
... | [
"collections.defaultdict"
] | [((1651, 1668), 'collections.defaultdict', 'defaultdict', (['dict'], {}), '(dict)\n', (1662, 1668), False, 'from collections import defaultdict\n')] |
from django.db import models
# Create your models here.
class Moeda(models.Model):
codigo = models.CharField('Código', max_length=3, primary_key=True)
moeda = models.CharField('Nome da Moeda', max_length=255)
simbolo = models.CharField('Símbolo', max_length=5)
def __str__(self):
return self.co... | [
"django.db.models.CharField",
"django.db.models.DecimalField",
"django.db.models.ForeignKey",
"django.db.models.DateField"
] | [((97, 155), 'django.db.models.CharField', 'models.CharField', (['"""Código"""'], {'max_length': '(3)', 'primary_key': '(True)'}), "('Código', max_length=3, primary_key=True)\n", (113, 155), False, 'from django.db import models\n'), ((168, 217), 'django.db.models.CharField', 'models.CharField', (['"""Nome da Moeda"""']... |
from torch.utils.data import Dataset
from scipy import ndimage
from .augmentation import augmentation
import skimage
import imageio
import numpy as np
import h5py
import os
import random
class NeuroDataset(Dataset):
def __init__(self, data_path, phase='train', transform=False, target_channels="3"):
"""Cus... | [
"h5py.File",
"numpy.expand_dims"
] | [((1287, 1312), 'numpy.expand_dims', 'np.expand_dims', (['x'], {'axis': '(0)'}), '(x, axis=0)\n', (1301, 1312), True, 'import numpy as np\n'), ((951, 981), 'h5py.File', 'h5py.File', (['self.data_path', '"""r"""'], {}), "(self.data_path, 'r')\n", (960, 981), False, 'import h5py\n'), ((1172, 1202), 'h5py.File', 'h5py.Fil... |
# configuration steps import
import subprocess
import traceback
from nedgeBlockerException import NedgeBlockerException
from steps.firewallCheck import FirewallCheck
from steps.baseConfigurationStep import BaseConfigurationStep
from steps.nedeployRCConfig import NedeployRCConfig
from steps.nedeployBashActivation impor... | [
"steps.neadmSystemInit.NeadmSystemInit",
"steps.neadmLicenseActivation.NeadmLicenseActivation",
"steps.systemPreConfig.SystemPreConfig",
"steps.systemPostConfig.SystemPostConfig",
"steps.nedeployPrecheck.NedeployPrecheck",
"steps.waitAuditService.WaitAuditService",
"steps.waitNodeUUID.WaitNodeUUID",
"... | [((2498, 2513), 'steps.firewallCheck.FirewallCheck', 'FirewallCheck', ([], {}), '()\n', (2511, 2513), False, 'from steps.firewallCheck import FirewallCheck\n'), ((2529, 2546), 'steps.systemPreConfig.SystemPreConfig', 'SystemPreConfig', ([], {}), '()\n', (2544, 2546), False, 'from steps.systemPreConfig import SystemPreC... |
import logging
from vosekast_control.Log import LOGGER
from vosekast_control.connectors.RelayControl import RelayControl
from vosekast_control.utils.Msg import StatusMessage
from vosekast_control.connectors import MQTTConnection
class Valve:
# regulations
BINARY = "BINARY"
ANALOG = "ANALOG"
# valve_t... | [
"vosekast_control.connectors.RelayControl.RelayControl.relays_on",
"vosekast_control.connectors.RelayControl.RelayControl.relays_off",
"vosekast_control.utils.Msg.StatusMessage",
"logging.getLogger"
] | [((830, 855), 'logging.getLogger', 'logging.getLogger', (['LOGGER'], {}), '(LOGGER)\n', (847, 855), False, 'import logging\n'), ((1086, 1129), 'vosekast_control.connectors.RelayControl.RelayControl.relays_off', 'RelayControl.relays_off', (['[self._relay_port]'], {}), '([self._relay_port])\n', (1109, 1129), False, 'from... |
from collections import deque
def get_vision(_map:list,start_pos:tuple,n_row:int,n_col:int):
q = deque()
visited = [[False]* n_col for _ in range(n_row)]
dist = [[0]* n_col for _ in range(n_row)]
q.append(start_pos)
visited[start_pos[0]][start_pos[1]] = True
ans = []
foods = []
monster =... | [
"collections.deque"
] | [((101, 108), 'collections.deque', 'deque', ([], {}), '()\n', (106, 108), False, 'from collections import deque\n')] |
# -*- coding: utf-8 -*-
from model.group import Group
import allure
def test_add_group(app, db, json_groups, check_ui):
group = json_groups
old_groups = given_group_list(db)
create_group(app, group)
new_groups = given_group_list(db)
check_groups(app, old_groups, new_groups, group, check_ui)
@all... | [
"allure.step"
] | [((317, 350), 'allure.step', 'allure.step', (['"""Given a group list"""'], {}), "('Given a group list')\n", (328, 350), False, 'import allure\n'), ((411, 468), 'allure.step', 'allure.step', (['"""When I add the group "{group}" to the list"""'], {}), '(\'When I add the group "{group}" to the list\')\n', (422, 468), Fals... |
from Src.Model import RNN
from Src.DataPrep import DataPrep
import time
import math
import argparse
from sys import argv
import matplotlib.pyplot as plt
import matplotlib.ticker as ticker
import torch
import torch.nn as nn
def time_since(s):
now = time.time()
s = now - s
m = math.floor(s / 60)
s -=... | [
"matplotlib.pyplot.show",
"argparse.ArgumentParser",
"Src.Model.RNN",
"torch.load",
"math.floor",
"time.time",
"Src.DataPrep.DataPrep",
"torch.nn.NLLLoss",
"torch.zeros",
"matplotlib.ticker.MultipleLocator",
"torch.no_grad",
"matplotlib.pyplot.subplots"
] | [((3172, 3197), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (3195, 3197), False, 'import argparse\n'), ((257, 268), 'time.time', 'time.time', ([], {}), '()\n', (266, 268), False, 'import time\n'), ((293, 311), 'math.floor', 'math.floor', (['(s / 60)'], {}), '(s / 60)\n', (303, 311), False, '... |
# Copyright (c) 2018-2019 ISciences, LLC.
# All rights reserved.
#
# WSIM is 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 app... | [
"datetime.datetime.utcnow",
"datetime.timedelta"
] | [((5671, 5697), 'datetime.datetime.utcnow', 'datetime.datetime.utcnow', ([], {}), '()\n', (5695, 5697), False, 'import datetime\n'), ((5700, 5744), 'datetime.timedelta', 'datetime.timedelta', ([], {'hours': 'forecast_lag_hours'}), '(hours=forecast_lag_hours)\n', (5718, 5744), False, 'import datetime\n')] |
# -*- coding: utf-8 -*-
import scrapy
import json
class ZhihuSpider(scrapy.Spider):
name = 'zhihu'
allowed_domains = ['www.zhihu.com']
start_urls = ['https://www.zhihu.com/']
loginUrl = 'https://www.zhihu.com/#signin'
siginUrl = 'https://www.zhihu.com/login/email'
feedUrl = 'https://www.zhihu... | [
"json.loads",
"scrapy.http.FormRequest"
] | [((3076, 3101), 'json.loads', 'json.loads', (['response.body'], {}), '(response.body)\n', (3086, 3101), False, 'import json\n'), ((4009, 4034), 'json.loads', 'json.loads', (['response.body'], {}), '(response.body)\n', (4019, 4034), False, 'import json\n'), ((4441, 4600), 'scrapy.http.FormRequest', 'scrapy.http.FormRequ... |
'''Code obtained from https://github.com/gitshanks/fer2013'''
# load json and create model
from __future__ import division
from keras.models import Sequential
from keras.layers import Dense
from keras.models import model_from_json
import numpy
import os
import numpy as np
json_file = open('web_app/keras_model.json', '... | [
"numpy.load",
"keras.models.model_from_json",
"numpy.save"
] | [((394, 428), 'keras.models.model_from_json', 'model_from_json', (['loaded_model_json'], {}), '(loaded_model_json)\n', (409, 428), False, 'from keras.models import model_from_json\n'), ((574, 608), 'numpy.load', 'np.load', (['"""data/keras_modXtest.npy"""'], {}), "('data/keras_modXtest.npy')\n", (581, 608), True, 'impo... |
import pandas as pd
import re
class Formatter:
"""Formatting Class.
This class contains method that are used for formatting the data fetched
from the pickle and sent to DataFilter class
"""
def get_projects_details(self, projects):
"""Method to process all details related to project
... | [
"pandas.DataFrame",
"pandas.cut",
"pandas.merge"
] | [((2786, 2834), 'pandas.DataFrame', 'pd.DataFrame', (['age_list'], {'columns': "['age', 'count']"}), "(age_list, columns=['age', 'count'])\n", (2798, 2834), True, 'import pandas as pd\n'), ((2860, 3060), 'pandas.cut', 'pd.cut', ([], {'x': "age_df['age']", 'bins': '[0, 10, 20, 30, 40, 50, 60, 70, 80, 90, 100, 130]', 'la... |
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
"""
RESTful endpoints for powering on/off/restarting VMs in vLab
"""
from setuptools import setup, find_packages
setup(name="vlab-power-api",
author="<NAME>,",
author_email='<EMAIL>',
version='2019.06.19',
packages=find_packages(),
include_pa... | [
"setuptools.find_packages"
] | [((287, 302), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (300, 302), False, 'from setuptools import setup, find_packages\n')] |
#!/usr/bin/python
# -*- coding: utf-8 -*-
"""Tests for the data range file-like object."""
import os
import unittest
from dfvfs.file_io import data_range_io
from dfvfs.file_io import os_file_io
from dfvfs.path import data_range_path_spec
from dfvfs.path import os_path_spec
from dfvfs.resolver import context
from test... | [
"unittest.main",
"dfvfs.file_io.data_range_io.DataRange",
"dfvfs.resolver.context.Context",
"dfvfs.path.os_path_spec.OSPathSpec",
"dfvfs.path.data_range_path_spec.DataRangePathSpec",
"dfvfs.file_io.os_file_io.OSFile",
"os.path.join"
] | [((2690, 2705), 'unittest.main', 'unittest.main', ([], {}), '()\n', (2703, 2705), False, 'import unittest\n'), ((564, 581), 'dfvfs.resolver.context.Context', 'context.Context', ([], {}), '()\n', (579, 581), False, 'from dfvfs.resolver import context\n'), ((598, 635), 'os.path.join', 'os.path.join', (['u"""test_data"""'... |
import FWCore.ParameterSet.Config as cms
# the clients
from DQM.TrackingMonitor.ClientTrackEfficiencySTACosmicMuons_cff import *
from DQM.TrackingMonitor.ClientTrackEfficiencyTkTracks_cff import *
from DQMOffline.Muon.trackResidualsTest_cfi import *
from DQMOffline.Muon.muonRecoTest_cfi import *
from DQMOffline.Muon.m... | [
"FWCore.ParameterSet.Config.Sequence",
"FWCore.ParameterSet.Config.untracked.int32",
"FWCore.ParameterSet.Config.untracked.FileInPath"
] | [((952, 1157), 'FWCore.ParameterSet.Config.Sequence', 'cms.Sequence', (['(ClientTrackEfficiencyTkTracks * ClientTrackEfficiencySTACosmicMuons *\n muonSourcesQualityTests * muTrackResidualsTest * muRecoTest *\n muonClientsQualityTests * muonCosmicTestSummary)'], {}), '(ClientTrackEfficiencyTkTracks *\n ClientTr... |
# -*- coding: utf-8 -*-
# Part of Odoo. See LICENSE file for full copyright and licensing details.
from odoo import api, fields, models
class MassMailingListMerge(models.TransientModel):
_name = 'mailing.list.merge'
_description = 'Merge Mass Mailing List'
src_list_ids = fields.Many2many('mailing.list',... | [
"odoo.fields.Selection",
"odoo.fields.Many2one",
"odoo.fields.Char",
"odoo.fields.Many2many",
"odoo.fields.Boolean"
] | [((288, 344), 'odoo.fields.Many2many', 'fields.Many2many', (['"""mailing.list"""'], {'string': '"""Mailing Lists"""'}), "('mailing.list', string='Mailing Lists')\n", (304, 344), False, 'from odoo import api, fields, models\n'), ((364, 430), 'odoo.fields.Many2one', 'fields.Many2one', (['"""mailing.list"""'], {'string': ... |
# ------------------------------------
# Copyright (c) Microsoft Corporation.
# Licensed under the MIT License.
# ------------------------------------
import asyncio
import os
from unittest.mock import Mock, patch
from urllib.parse import urlparse
from azure.core.credentials import AccessToken
from azure.identity impo... | [
"unittest.mock.patch.object",
"helpers.mock_response",
"test_shared_cache_credential.get_account_event",
"asyncio.coroutine",
"test_shared_cache_credential.build_aad_response",
"test_shared_cache_credential.populated_cache",
"unittest.mock.Mock",
"os.environ.get",
"unittest.mock.patch",
"azure.ide... | [((905, 1077), 'helpers.mock_response', 'mock_response', ([], {'json_payload': "{'access_token': expected_access_token, 'expires_in': 0, 'expires_on': 42,\n 'not_before': 0, 'resource': 'scope', 'token_type': 'Bearer'}"}), "(json_payload={'access_token': expected_access_token,\n 'expires_in': 0, 'expires_on': 42,... |
#!/usr/bin/env python3
import sys
sys.path.append("../")
import plotlib
import numpy
import pylab
import networkx
import pickle
import sys
G,pos=pickle.load(open("graph.pickle","rb"))
a_arr, m_hist, cor_hist=pickle.load(open("results.pickle","rb"))
e=numpy.loadtxt("eigenval.csv", delimiter=",")
v=numpy.loadtxt("eige... | [
"sys.path.append",
"numpy.sum",
"numpy.zeros",
"numpy.argsort",
"numpy.around",
"numpy.linalg.norm",
"numpy.loadtxt"
] | [((35, 57), 'sys.path.append', 'sys.path.append', (['"""../"""'], {}), "('../')\n", (50, 57), False, 'import sys\n'), ((254, 298), 'numpy.loadtxt', 'numpy.loadtxt', (['"""eigenval.csv"""'], {'delimiter': '""","""'}), "('eigenval.csv', delimiter=',')\n", (267, 298), False, 'import numpy\n'), ((301, 345), 'numpy.loadtxt'... |
from flask_restful import reqparse, Resource, fields, marshal_with
from flask_jwt_extended import jwt_required, get_jwt_identity
from mini_gplus.daos.user import find_user
from mini_gplus.daos.post import dangerously_get_post
from mini_gplus.daos.comment import create_comment, dangerously_get_comment, delete_comment
fr... | [
"flask_restful.fields.String",
"flask_restful.fields.Nested",
"flask_restful.fields.Integer",
"flask_jwt_extended.get_jwt_identity",
"mini_gplus.daos.comment.dangerously_get_comment",
"mini_gplus.daos.comment.delete_comment",
"flask_restful.reqparse.RequestParser",
"flask_jwt_extended.jwt_required",
... | [((583, 607), 'flask_restful.reqparse.RequestParser', 'reqparse.RequestParser', ([], {}), '()\n', (605, 607), False, 'from flask_restful import reqparse, Resource, fields, marshal_with\n'), ((887, 917), 'flask_restful.fields.String', 'fields.String', ([], {'attribute': '"""eid"""'}), "(attribute='eid')\n", (900, 917), ... |
from typing import Tuple, List
from webdnn.graph import traverse
from webdnn.graph.graph import Graph
from webdnn.graph.operators.elementwise import Elementwise
from webdnn.graph.operators.fused_elementwise import FusedElementwise
from webdnn.graph.optimize_rule import OptimizeRule
from webdnn.util import flags
def ... | [
"webdnn.graph.traverse.listup_operators",
"webdnn.graph.operators.fused_elementwise.FusedElementwise"
] | [((6157, 6193), 'webdnn.graph.traverse.listup_operators', 'traverse.listup_operators', (['sub_graph'], {}), '(sub_graph)\n', (6182, 6193), False, 'from webdnn.graph import traverse\n'), ((4544, 4576), 'webdnn.graph.traverse.listup_operators', 'traverse.listup_operators', (['graph'], {}), '(graph)\n', (4569, 4576), Fals... |
import pickle
import shutil
import re
import hashlib
import base64
from datetime import datetime
import pandas as pd
def df_to_records(df: pd.DataFrame, dataset: str, drop_columns = []):
"""
Convert dataframe to a list of record oriented dicts.
Parameters
----------
df : pd.DataFrame
Inp... | [
"pandas.DataFrame",
"pandas.read_csv",
"re.findall",
"shutil.rmtree",
"datetime.datetime.now",
"pandas.concat"
] | [((7076, 7102), 'pandas.read_csv', 'pd.read_csv', (['ingested_path'], {}), '(ingested_path)\n', (7087, 7102), True, 'import pandas as pd\n'), ((7556, 7621), 'pandas.DataFrame', 'pd.DataFrame', (["{'hash': data['_hash'], 'date_processed': date_now}"], {}), "({'hash': data['_hash'], 'date_processed': date_now})\n", (7568... |
from unittest.mock import patch
from django.contrib.auth import authenticate
from django.http import HttpRequest
from django.test import override_settings
from django.urls import reverse
from axes.apps import AppConfig
from axes.models import AccessAttempt, AccessLog
from axes.tests.base import AxesTestCase
@patch(... | [
"axes.models.AccessLog.objects.latest",
"axes.apps.AppConfig.initialize",
"unittest.mock.patch",
"axes.models.AccessLog.objects.count",
"django.urls.reverse",
"axes.models.AccessLog.objects.all",
"axes.models.AccessAttempt.objects.latest",
"django.test.override_settings"
] | [((314, 369), 'unittest.mock.patch', 'patch', (['"""axes.apps.AppConfig.logging_initialized"""', '(False)'], {}), "('axes.apps.AppConfig.logging_initialized', False)\n", (319, 369), False, 'from unittest.mock import patch\n'), ((371, 393), 'unittest.mock.patch', 'patch', (['"""axes.apps.log"""'], {}), "('axes.apps.log'... |
from django.contrib import admin
from django.contrib.admin.models import LogEntry
from django.utils.html import format_html
from django.utils.timesince import timesince
from tests.test_app.polls.models import Campaign, Cheese, AllFields
from .models import Poll, Choice, Vote
class ChoiceInline(admin.TabularInline):
... | [
"django.utils.timesince.timesince",
"django.contrib.admin.register"
] | [((370, 390), 'django.contrib.admin.register', 'admin.register', (['Poll'], {}), '(Poll)\n', (384, 390), False, 'from django.contrib import admin\n'), ((1124, 1146), 'django.contrib.admin.register', 'admin.register', (['Choice'], {}), '(Choice)\n', (1138, 1146), False, 'from django.contrib import admin\n'), ((1326, 134... |
import boto3
import logging
logger = logging.getLogger(__name__)
class Connection(object):
def __init__(self, type, service=None, region='us-west-2', profile='default'):
self.region = region
self.connection_type = type
self.service = service
self.client = None
self.resourc... | [
"boto3.Session",
"boto3.client",
"boto3.setup_default_session",
"boto3.resource",
"logging.getLogger"
] | [((38, 65), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (55, 65), False, 'import logging\n'), ((385, 439), 'boto3.setup_default_session', 'boto3.setup_default_session', ([], {'profile_name': 'self.profile'}), '(profile_name=self.profile)\n', (412, 439), False, 'import boto3\n'), ((808,... |
"""
Code adapted from: https://github.com/NVIDIA/semantic-segmentation
Copyright 2020 Nvidia Corporation
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright not... | [
"torch.nn.functional.interpolate",
"torch.nn.init.kaiming_normal_"
] | [((2631, 2721), 'torch.nn.functional.interpolate', 'nn.functional.interpolate', (['x'], {'size': 'size', 'mode': '"""bilinear"""', 'align_corners': 'align_corners'}), "(x, size=size, mode='bilinear', align_corners=\n align_corners)\n", (2656, 2721), True, 'import torch.nn as nn\n'), ((2858, 2953), 'torch.nn.function... |
from .helpers import dualLP, optimalLP, optimalLPConstant
import numpy as np
def computeCostMinPoA(n, B, f, options=None):
''' Authors: <NAME>, <NAME> and <NAME>
Copyright(c) 2020 <NAME>, <NAME>, <NAME>.
All rights reserved. See LICENSE file in the project root for full license information.
... | [
"numpy.pad",
"numpy.shape",
"numpy.zeros",
"numpy.arange"
] | [((4569, 4601), 'numpy.zeros', 'np.zeros', (['(m, n)'], {'dtype': 'np.float'}), '((m, n), dtype=np.float)\n', (4577, 4601), True, 'import numpy as np\n'), ((4628, 4640), 'numpy.arange', 'np.arange', (['m'], {}), '(m)\n', (4637, 4640), True, 'import numpy as np\n'), ((7957, 7989), 'numpy.zeros', 'np.zeros', (['(m, n)'],... |
import folium
import numpy as np
from folium.plugins import HeatMap, MarkerCluster
import pandas as pd
from math import sin, cos, acos, asin, atan2, radians, degrees
def plot_circle(lat, lon, radius, map=None, **kwargs):
"""
Plot a circle on a map (creating a new folium map instance if necessary).
Parame... | [
"folium.map.Marker",
"numpy.average",
"math.asin",
"math.atan2",
"pandas.read_csv",
"math.radians",
"folium.plugins.HeatMap",
"math.sin",
"folium.Circle",
"math.cos",
"folium.Map",
"folium.plugins.MarkerCluster",
"folium.PolyLine",
"math.degrees"
] | [((2603, 2610), 'math.asin', 'asin', (['z'], {}), '(z)\n', (2607, 2610), False, 'from math import sin, cos, acos, asin, atan2, radians, degrees\n'), ((2624, 2633), 'math.cos', 'cos', (['rlat'], {}), '(rlat)\n', (2627, 2633), False, 'from math import sin, cos, acos, asin, atan2, radians, degrees\n'), ((5734, 5790), 'pan... |
#
# Copyright (c) 2021 Nitric Technologies Pty Ltd.
#
# This file is part of Nitric Python 3 SDK.
# See https://github.com/nitrictech/python-sdk for further info.
#
# 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 cop... | [
"nitricapi.nitric.secret.v1.SecretServiceStub",
"nitric.utils.new_default_channel",
"nitricapi.nitric.secret.v1.Secret",
"nitric.api.exception.exception_from_grpc_error",
"dataclasses.dataclass"
] | [((1877, 1899), 'dataclasses.dataclass', 'dataclass', ([], {'frozen': '(True)'}), '(frozen=True)\n', (1886, 1899), False, 'from dataclasses import dataclass\n'), ((3421, 3443), 'dataclasses.dataclass', 'dataclass', ([], {'frozen': '(True)'}), '(frozen=True)\n', (3430, 3443), False, 'from dataclasses import dataclass\n'... |
# Skipping test_parser and test_all_fixers
# because of running
from lib2to3.tests import test_fixers, test_pytree, test_util
import unittest
from test.test_support import run_unittest
def suite():
tests = unittest.TestSuite()
loader = unittest.TestLoader()
for m in (test_fixers,test_pytree,test_util):
... | [
"unittest.TestLoader",
"unittest.TestSuite"
] | [((211, 231), 'unittest.TestSuite', 'unittest.TestSuite', ([], {}), '()\n', (229, 231), False, 'import unittest\n'), ((245, 266), 'unittest.TestLoader', 'unittest.TestLoader', ([], {}), '()\n', (264, 266), False, 'import unittest\n')] |
# Generated by Django 2.0.1 on 2018-02-16 12:00
from django.db import migrations, models
import django.db.models.manager
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
migrations.CreateModel(
name='FacultyCourses',
fields=[
... | [
"django.db.models.BigIntegerField",
"django.db.models.ForeignKey",
"django.db.models.BigAutoField",
"django.db.models.CharField",
"django.db.models.BooleanField",
"django.db.models.EmailField",
"django.db.models.IntegerField",
"django.db.models.DateTimeField"
] | [((2430, 2484), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'on_delete': '"""cascade"""', 'to': '"""User.User"""'}), "(on_delete='cascade', to='User.User')\n", (2447, 2484), False, 'from django.db import migrations, models\n'), ((344, 398), 'django.db.models.BigAutoField', 'models.BigAutoField', ([], {'pr... |
import builtins
import datetime
import hashlib
import secrets
from db import *
from swagger_server.models.default_error import DefaultError as swg_DefaultError
from swagger_server.models.default_message import DefaultMessage as swg_DefaultMessage
from swagger_server.models.account_definition import AccountDefinition a... | [
"flask.request.headers.get",
"swagger_server.models.account_definition_list.AccountDefinitionList",
"secrets.token_hex",
"secrets.token_urlsafe",
"swagger_server.models.default_message.DefaultMessage",
"swagger_server.models.account_definition.AccountDefinition",
"swagger_server.models.api_key.ApiKey",
... | [((744, 970), 'swagger_server.models.account_definition.AccountDefinition', 'swg_AccountDefinition', ([], {'name': 'db_account.name', 'permission': 'db_account.permission', 'tag': 'tags', 'domains': 'db_account.domains', 'create_date': 'db_account.creation_date', 'last_modification_date': 'db_account.last_modification_... |