code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
"""
dolbyio_rest_apis.media.models.webhook
~~~~~~~~~~~~~~~
This module contains the Webhook model.
"""
from dolbyio_rest_apis.core.helpers import get_value_or_default
class Webhook(dict):
"""The :class:`Webhook` object, which represents a webhook."""
def __init__(self, dictionary: dict):
dict.__init... | [
"dolbyio_rest_apis.core.helpers.get_value_or_default"
] | [((368, 414), 'dolbyio_rest_apis.core.helpers.get_value_or_default', 'get_value_or_default', (['self', '"""webhook_id"""', 'None'], {}), "(self, 'webhook_id', None)\n", (388, 414), False, 'from dolbyio_rest_apis.core.helpers import get_value_or_default\n'), ((561, 604), 'dolbyio_rest_apis.core.helpers.get_value_or_defa... |
import asyncio
import logging
import traceback
from collections import namedtuple
from datetime import datetime
from enum import Enum
from typing import Optional, Union
from aioredis import RedisError
from async_rediscache import RedisCache
from dateutil.relativedelta import relativedelta
from discord import Colour, E... | [
"datetime.datetime.fromisoformat",
"bot.utils.time.discord_timestamp",
"bot.utils.time.parse_duration_string",
"bot.utils.time.relativedelta_to_timedelta",
"bot.utils.time.humanize_delta",
"async_rediscache.RedisCache",
"discord.ext.commands.has_any_role",
"discord.ext.commands.Cog.listener",
"disco... | [((889, 916), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (906, 916), False, 'import logging\n'), ((1624, 1692), 'collections.namedtuple', 'namedtuple', (['"""LogInfoDetails"""', "['icon', 'emoji', 'color', 'template']"], {}), "('LogInfoDetails', ['icon', 'emoji', 'color', 'template'])... |
from django.contrib import messages
from django.http import HttpResponse, JsonResponse
from django.shortcuts import get_object_or_404, redirect, render, reverse
from django.utils.translation import ugettext_lazy as _
import simplejson
from rest_framework.decorators import api_view, throttle_classes
from rest_framework... | [
"django.shortcuts.redirect",
"django.utils.translation.ugettext_lazy",
"django.http.JsonResponse",
"django.shortcuts.get_object_or_404",
"rest_framework.response.Response",
"django.shortcuts.render",
"rest_framework.decorators.api_view"
] | [((1260, 1277), 'rest_framework.decorators.api_view', 'api_view', (["['GET']"], {}), "(['GET'])\n", (1268, 1277), False, 'from rest_framework.decorators import api_view, throttle_classes\n'), ((1469, 1486), 'rest_framework.decorators.api_view', 'api_view', (["['GET']"], {}), "(['GET'])\n", (1477, 1486), False, 'from re... |
from sklearn.model_selection import KFold
from sklearn.metrics import classification_report, accuracy_score, matthews_corrcoef
from sklearn import svm
from feature import Feature
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import ExtraTreesClassifier
import numpy as np
... | [
"sklearn.metrics.accuracy_score",
"sklearn.model_selection.KFold",
"sklearn.metrics.classification_report",
"sklearn.ensemble.ExtraTreesClassifier",
"sklearn.linear_model.LogisticRegression",
"sklearn.metrics.matthews_corrcoef",
"numpy.array",
"sklearn.svm.SVC",
"feature.Feature",
"numpy.concatena... | [((6598, 6634), 'sklearn.ensemble.ExtraTreesClassifier', 'ExtraTreesClassifier', ([], {'random_state': '(0)'}), '(random_state=0)\n', (6618, 6634), False, 'from sklearn.ensemble import ExtraTreesClassifier\n'), ((6649, 6685), 'sklearn.ensemble.ExtraTreesClassifier', 'ExtraTreesClassifier', ([], {'random_state': '(0)'})... |
# Copyright 2019 <NAME>.
#
# 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, soft... | [
"unittest.TextTestRunner",
"flask.Flask",
"re.match",
"time.sleep",
"flask_ipban.ip_ban.IpBan"
] | [((10897, 10935), 'unittest.TextTestRunner', 'unittest.TextTestRunner', ([], {'failfast': '(True)'}), '(failfast=True)\n', (10920, 10935), False, 'import unittest\n'), ((911, 932), 'flask.Flask', 'flask.Flask', (['__name__'], {}), '(__name__)\n', (922, 932), False, 'import flask\n'), ((984, 1081), 'flask_ipban.ip_ban.I... |
"""
Tensorflow implementation of DeepFM [1]
Reference:
[1] DeepFM: A Factorization-Machine based Neural Network for CTR Prediction,
<NAME>, <NAME>, <NAME>, <NAME>, <NAME>.
"""
import numpy as np
import tensorflow as tf
import os
import example.config as config
from sklearn.base import BaseEstimator, TransformerM... | [
"tensorflow.cond",
"tensorflow.reduce_sum",
"tensorflow.contrib.layers.l2_regularizer",
"tensorflow.reshape",
"numpy.random.set_state",
"tensorflow.train.AdamOptimizer",
"tensorflow.ConfigProto",
"tensorflow.multiply",
"tensorflow.matmul",
"tensorflow.losses.log_loss",
"numpy.random.normal",
"... | [((2513, 2523), 'tensorflow.Graph', 'tf.Graph', ([], {}), '()\n', (2521, 2523), True, 'import tensorflow as tf\n'), ((8938, 8977), 'tensorflow.ConfigProto', 'tf.ConfigProto', ([], {'device_count': "{'gpu': 0}"}), "(device_count={'gpu': 0})\n", (8952, 8977), True, 'import tensorflow as tf\n'), ((9040, 9065), 'tensorflow... |
#!/usr/bin/env python3
from KorAPClient import KorAPClient, KorAPConnection
import plotly.express as px
QUERY = "Hello World"
YEARS = range(2010, 2019)
COUNTRIES = ["DE", "CH"]
kcon = KorAPConnection(verbose=True)
vcs = ["textType=/Zeit.*/ & pubPlaceKey=" + c + " & pubDate in " + str(y) for c in COUNTRIES for y in Y... | [
"plotly.express.line",
"KorAPClient.KorAPConnection"
] | [((186, 215), 'KorAPClient.KorAPConnection', 'KorAPConnection', ([], {'verbose': '(True)'}), '(verbose=True)\n', (201, 215), False, 'from KorAPClient import KorAPClient, KorAPConnection\n'), ((503, 615), 'plotly.express.line', 'px.line', (['df'], {'title': 'QUERY', 'x': '"""Year"""', 'y': '"""ipm"""', 'color': '"""Coun... |
import traceback
import mysql.connector
from ..database.database import *
from ..model.Book import *
class BorrowTools:
def BookData(self, idReader):
db = DatabaseTools()
conn = db.getConn()
result_set = None
ls = []
try :
sql = "select book.idBook,nameBook,price... | [
"traceback.print_exc"
] | [((1081, 1102), 'traceback.print_exc', 'traceback.print_exc', ([], {}), '()\n', (1100, 1102), False, 'import traceback\n'), ((2003, 2024), 'traceback.print_exc', 'traceback.print_exc', ([], {}), '()\n', (2022, 2024), False, 'import traceback\n'), ((2563, 2584), 'traceback.print_exc', 'traceback.print_exc', ([], {}), '(... |
# coding: utf-8
"""
Idomoo API
OpenAPI spec version: 2.0
Contact: <EMAIL>
"""
import pprint
import six
class JPGOutput(object):
"""NOTE: This class is auto generated by the swagger code generator program.
Do not edit the class manually.
"""
"""
Attributes:
swagger_types... | [
"six.iteritems"
] | [((8785, 8818), 'six.iteritems', 'six.iteritems', (['self.swagger_types'], {}), '(self.swagger_types)\n', (8798, 8818), False, 'import six\n')] |
import os
from os import listdir
from os.path import isfile
from ScriptComponent.ScriptConfig import ScriptConfig
class PythonInstaller(object):
script_config = ScriptConfig()
def install(self, eigenschap):
self.upgradePip()
self.installTarball()
self.installLocalLibrary(eigenschap)
... | [
"os.system",
"os.path.isfile",
"os.path.splitext",
"ScriptComponent.ScriptConfig.ScriptConfig",
"os.listdir"
] | [((168, 182), 'ScriptComponent.ScriptConfig.ScriptConfig', 'ScriptConfig', ([], {}), '()\n', (180, 182), False, 'from ScriptComponent.ScriptConfig import ScriptConfig\n'), ((425, 473), 'os.system', 'os.system', (['"""python -m pip install --upgrade pip"""'], {}), "('python -m pip install --upgrade pip')\n", (434, 473),... |
#!/usr/bin/python
from cobra.internal.codec.jsoncodec import (parseJSONError, fromJSONStr, toJSONStr)
from cobra.mit.access import MoDirectory
from cobra.mit.session import LoginSession
from cobra.mit.request import ClassQuery
import os
import re
import sys
import six
import json
import urllib3
import ... | [
"argparse.ArgumentParser",
"json.loads",
"shortuuid.uuid",
"getpass.getpass",
"socket.socket",
"cobra.mit.access.MoDirectory",
"re.match",
"json.dumps",
"urllib3.disable_warnings",
"socket.gethostbyname",
"cobra.mit.request.ClassQuery",
"requests.get",
"cobra.mit.session.LoginSession",
"re... | [((492, 535), 'os.getenv', 'os.getenv', (['"""BRAHMA_URL"""', '"""brahma.cisco.com"""'], {}), "('BRAHMA_URL', 'brahma.cisco.com')\n", (501, 535), False, 'import os\n'), ((551, 581), 'os.getenv', 'os.getenv', (['"""BRAHMA_PORT"""', 'None'], {}), "('BRAHMA_PORT', None)\n", (560, 581), False, 'import os\n'), ((2609, 2635)... |
'''
DIO using a serial port + microcontroller instead of the NIDAQ card
'''
import serial
from collections import defaultdict
import struct
from numpy import binary_repr
from .dio.parse import MSG_TYPE_ROWBYTE, MSG_TYPE_REGISTER
import time
import threading
import pyfirmata
def construct_word(aux, msg_type, data, n_bi... | [
"serial.Serial",
"collections.defaultdict",
"numpy.binary_repr",
"struct.pack"
] | [((1347, 1405), 'serial.Serial', 'serial.Serial', (['"""/dev/arduino_neurosync"""'], {'baudrate': 'baudrate'}), "('/dev/arduino_neurosync', baudrate=baudrate)\n", (1360, 1405), False, 'import serial\n'), ((1457, 1473), 'collections.defaultdict', 'defaultdict', (['int'], {}), '(int)\n', (1468, 1473), False, 'from collec... |
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
# import argparse
# import itertools
import json
import os
import subprocess
# import sys
# import time
import unittest
import uuid
import torch
# import datasets
# import hparams_registry
# import algorithms
# import networks
# from parameterize... | [
"subprocess.run",
"uuid.uuid4",
"os.makedirs",
"json.loads",
"os.path.join"
] | [((569, 607), 'os.makedirs', 'os.makedirs', (['output_dir'], {'exist_ok': '(True)'}), '(output_dir, exist_ok=True)\n', (580, 607), False, 'import os\n'), ((617, 788), 'subprocess.run', 'subprocess.run', (['f"""python -m domainbed.scripts.train --dataset RotatedMNIST --data_dir={os.environ[\'DATA_DIR\']} --output_dir={o... |
import torch
import torch.nn as nn
import torch.nn.init as nn_init
from .misc import conv, deconv, predict_flow
'Parameter count : 38,676,504 '
class FlowNetS(nn.Module):
def __init__(self, input_channels=12, with_bn=True):
super(FlowNetS, self).__init__()
self.with_bn = with_bn
self.... | [
"torch.nn.ConvTranspose2d",
"torch.cat",
"torch.nn.init.xavier_uniform",
"torch.nn.Upsample",
"torch.nn.init.uniform"
] | [((1412, 1457), 'torch.nn.ConvTranspose2d', 'nn.ConvTranspose2d', (['(2)', '(2)', '(4)', '(2)', '(1)'], {'bias': '(False)'}), '(2, 2, 4, 2, 1, bias=False)\n', (1430, 1457), True, 'import torch.nn as nn\n'), ((1507, 1552), 'torch.nn.ConvTranspose2d', 'nn.ConvTranspose2d', (['(2)', '(2)', '(4)', '(2)', '(1)'], {'bias': '... |
# -*- coding: utf-8 -*-
#
# Copyright 2012 <NAME> (http://jamesthornton.com)
# BSD License (see LICENSE for details)
#
"""
An interface for interacting with indices on Rexster.
"""
from bulbs.utils import initialize_element, initialize_elements, get_one_result
class IndexProxy(object):
"""Abstract base class the... | [
"bulbs.utils.initialize_element",
"bulbs.utils.initialize_elements",
"bulbs.utils.get_one_result"
] | [((7595, 7633), 'bulbs.utils.initialize_elements', 'initialize_elements', (['self.client', 'resp'], {}), '(self.client, resp)\n', (7614, 7633), False, 'from bulbs.utils import initialize_element, initialize_elements, get_one_result\n'), ((8471, 8491), 'bulbs.utils.get_one_result', 'get_one_result', (['resp'], {}), '(re... |
# -*- coding: utf-8 -*-
from os import getcwd, path, environ, makedirs
from yaml import safe_load
basedir = path.abspath(path.dirname(__file__))
SETTINGS = safe_load(open(path.join(basedir, 'server', 'ops_settings.yml')))
TILES_DIR = path.join(getcwd(), 'tiles')
if "TESTING" in environ:
SETTINGS['provider_param... | [
"os.makedirs",
"os.getcwd",
"os.path.dirname",
"os.path.exists",
"os.path.join"
] | [((123, 145), 'os.path.dirname', 'path.dirname', (['__file__'], {}), '(__file__)\n', (135, 145), False, 'from os import getcwd, path, environ, makedirs\n'), ((247, 255), 'os.getcwd', 'getcwd', ([], {}), '()\n', (253, 255), False, 'from os import getcwd, path, environ, makedirs\n'), ((416, 451), 'os.path.join', 'path.jo... |
import sonnet as snt
import tensorflow as tf
from luminoth.utils.bbox_transform_tf import decode, clip_boxes, change_order
class RPNProposal(snt.AbstractModule):
"""Transforms anchors and RPN predictions into object proposals.
Using the fixed anchors and the RPN predictions for both classification
and r... | [
"luminoth.utils.bbox_transform_tf.change_order",
"tensorflow.logical_and",
"tensorflow.summary.scalar",
"tensorflow.gather",
"tensorflow.boolean_mask",
"tensorflow.nn.top_k",
"tensorflow.reshape",
"tensorflow.identity",
"tensorflow.maximum",
"tensorflow.less",
"tensorflow.cast",
"tensorflow.sh... | [((3099, 3127), 'tensorflow.reshape', 'tf.reshape', (['all_scores', '[-1]'], {}), '(all_scores, [-1])\n', (3109, 3127), True, 'import tensorflow as tf\n'), ((4193, 4227), 'luminoth.utils.bbox_transform_tf.decode', 'decode', (['all_anchors', 'rpn_bbox_pred'], {}), '(all_anchors, rpn_bbox_pred)\n', (4199, 4227), False, '... |
import json
from django.core.urlresolvers import reverse
from rest_framework import serializers
from olympia import amo
from olympia.amo.helpers import absolutify
from olympia.files.models import FileUpload
class FileUploadSerializer(serializers.ModelSerializer):
guid = serializers.CharField(source='addon.guid... | [
"rest_framework.serializers.UUIDField",
"django.core.urlresolvers.reverse",
"rest_framework.serializers.SerializerMethodField",
"json.loads",
"rest_framework.serializers.CharField",
"rest_framework.serializers.BooleanField"
] | [((280, 322), 'rest_framework.serializers.CharField', 'serializers.CharField', ([], {'source': '"""addon.guid"""'}), "(source='addon.guid')\n", (301, 322), False, 'from rest_framework import serializers\n'), ((336, 371), 'rest_framework.serializers.SerializerMethodField', 'serializers.SerializerMethodField', ([], {}), ... |
from runner.run_description import RunDescription, Experiment, ParamGrid
from runner.runs.quad_multi_mix_baseline import QUAD_BASELINE_CLI
_params = ParamGrid([
('quads_local_obs', [2, 4]),
('seed', [0000, 1111, 2222, 3333]),
])
_experiment = Experiment(
'quad_mix_baseline-8_mixed_local_obs',
QUAD_BAS... | [
"runner.run_description.ParamGrid",
"runner.run_description.RunDescription"
] | [((150, 223), 'runner.run_description.ParamGrid', 'ParamGrid', (["[('quads_local_obs', [2, 4]), ('seed', [0, 1111, 2222, 3333])]"], {}), "([('quads_local_obs', [2, 4]), ('seed', [0, 1111, 2222, 3333])])\n", (159, 223), False, 'from runner.run_description import RunDescription, Experiment, ParamGrid\n'), ((398, 495), 'r... |
#!/usr/bin/env python3
from .cluster import cluster_down, cluster_stop, cluster_up, cluster_check
from .commands import vlan_ifname
from .db import DB, Address
from .listener import Listener
from .veth import veth_up
from .vlan import vlan_link_bridge, vlan_link_up
from redis import Redis
from signal import signal, SI... | [
"redis.Redis",
"functools.partial",
"logging.debug",
"logging.basicConfig",
"sys.exit",
"os.getenv",
"logging.getLogger"
] | [((407, 434), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (424, 434), False, 'import logging\n'), ((492, 528), 'os.getenv', 'os.getenv', (['"""REDIS_HOSTNAME"""', '"""redis"""'], {}), "('REDIS_HOSTNAME', 'redis')\n", (501, 528), False, 'import os\n'), ((607, 638), 'os.getenv', 'os.gete... |
import sys
from PyQt5.QtWidgets import QMainWindow, QApplication
from PyQt5.QtGui import QIcon
class FirstMainWin(QMainWindow):
def __init__(self, parent=None):
super(FirstMainWin, self).__init__(parent)
self.setWindowTitle('1')
self.resize(400, 300)
self.status = self.statusBar(... | [
"PyQt5.QtWidgets.QApplication"
] | [((411, 433), 'PyQt5.QtWidgets.QApplication', 'QApplication', (['sys.argv'], {}), '(sys.argv)\n', (423, 433), False, 'from PyQt5.QtWidgets import QMainWindow, QApplication\n')] |
import RPi.GPIO as GPIO
import time
import threading
import json
import pins
import commands
import settings
def main(action):
try:
servo = _setup()
if action == commands.LOCK:
_lock(servo)
elif action == commands.UNLOCK:
_unlock(servo)
elif action == commands.BUZZ:
# buzz_thread = threading.Thread(... | [
"RPi.GPIO.setmode",
"json.loads",
"RPi.GPIO.setup",
"json.dumps",
"time.sleep",
"RPi.GPIO.PWM",
"RPi.GPIO.output",
"RPi.GPIO.setwarnings"
] | [((644, 667), 'RPi.GPIO.setwarnings', 'GPIO.setwarnings', (['(False)'], {}), '(False)\n', (660, 667), True, 'import RPi.GPIO as GPIO\n'), ((669, 693), 'RPi.GPIO.setmode', 'GPIO.setmode', (['GPIO.BOARD'], {}), '(GPIO.BOARD)\n', (681, 693), True, 'import RPi.GPIO as GPIO\n'), ((695, 731), 'RPi.GPIO.setup', 'GPIO.setup', ... |
import os
import signal
import time
import unittest
import stomp
from stomp import exception
from stomp.backward import monotonic
from stomp.listener import TestListener
from stomp.test.testutils import *
from concurrent.futures import ThreadPoolExecutor
executor = ThreadPoolExecutor()
def create_thread(fc):
f... | [
"concurrent.futures.ThreadPoolExecutor",
"stomp.listener.TestListener.__init__",
"time.strftime"
] | [((269, 289), 'concurrent.futures.ThreadPoolExecutor', 'ThreadPoolExecutor', ([], {}), '()\n', (287, 289), False, 'from concurrent.futures import ThreadPoolExecutor\n'), ((497, 531), 'stomp.listener.TestListener.__init__', 'TestListener.__init__', (['self', '"""123"""'], {}), "(self, '123')\n", (518, 531), False, 'from... |
import copy
import os
import pickle
import numpy as np
from numpy.linalg import inv
from numpy.matlib import repmat
import pylot.utils
class DepthFrame(object):
"""Class that stores depth frames.
Args:
frame: A numpy array storing the depth frame.
camera_setup (:py:class:`~pylot.drivers.sen... | [
"copy.deepcopy",
"numpy.ones_like",
"numpy.dtype",
"numpy.transpose",
"pygame.display.flip",
"pygame.surfarray.blit_array",
"numpy.linalg.inv",
"numpy.reshape",
"numpy.dot",
"numpy.matlib.repmat",
"cv2.resize"
] | [((2098, 2148), 'numpy.reshape', 'np.reshape', (['_frame', '(frame.height, frame.width, 4)'], {}), '(_frame, (frame.height, frame.width, 4))\n', (2108, 2148), True, 'import numpy as np\n'), ((2370, 2416), 'numpy.dot', 'np.dot', (['frame[:, :, :3]', '[65536.0, 256.0, 1.0]'], {}), '(frame[:, :, :3], [65536.0, 256.0, 1.0]... |
"""
Coordinate Transformation Functions
This module contains the functions for converting one
`sunpy.coordinates.frames` object to another.
.. warning::
The functions in this submodule should never be called directly, transforming
between coordinate frames should be done using the ``.transform_to`` methods
on ... | [
"astropy.coordinates.ConvertError",
"astropy.coordinates.matrix_utilities.matrix_product",
"sunpy.sun.constants.get",
"astropy.coordinates.HeliocentricMeanEcliptic",
"astropy.units.allclose",
"astropy.coordinates.representation.CartesianRepresentation",
"astropy.coordinates.HCRS",
"astropy.coordinates... | [((15927, 16049), 'astropy.coordinates.baseframe.frame_transform_graph.transform', 'frame_transform_graph.transform', (['FunctionTransformWithFiniteDifference', 'HeliographicStonyhurst', 'HeliographicCarrington'], {}), '(FunctionTransformWithFiniteDifference,\n HeliographicStonyhurst, HeliographicCarrington)\n', (15... |
import os
import glob
import sys
sys.path.append('C:\\3DUnetCNN-master\\')
from unet3d.data import write_data_to_file, open_data_file
from unet3d.generator import get_training_and_validation_generators
from unet3d.model import unet_model_3d
from unet3d.training import load_old_model, train_model
config = dict()
con... | [
"sys.path.append",
"os.path.abspath",
"os.path.dirname",
"os.path.exists",
"unet3d.data.open_data_file",
"unet3d.model.unet_model_3d",
"unet3d.generator.get_training_and_validation_generators",
"unet3d.training.load_old_model",
"unet3d.training.train_model",
"os.path.join",
"unet3d.data.write_da... | [((34, 75), 'sys.path.append', 'sys.path.append', (['"""C:\\\\3DUnetCNN-master\\\\"""'], {}), "('C:\\\\3DUnetCNN-master\\\\')\n", (49, 75), False, 'import sys\n'), ((2546, 2578), 'os.path.abspath', 'os.path.abspath', (['"""brats_data.h5"""'], {}), "('brats_data.h5')\n", (2561, 2578), False, 'import os\n'), ((2602, 2648... |
# pylint: skip-file
# type: ignore
# -*- coding: utf-8 -*-
#
# tests.views.gtk3.widgets.test_combo.py is part of The RAMSTK Project
#
# All rights reserved.
"""Test class for the GTK3 combo module algorithms and models."""
# Third Party Imports
import pytest
# RAMSTK Package Imports
from ramstk.views.gtk3 impor... | [
"pytest.raises",
"ramstk.views.gtk3.widgets.RAMSTKComboBox"
] | [((579, 595), 'ramstk.views.gtk3.widgets.RAMSTKComboBox', 'RAMSTKComboBox', ([], {}), '()\n', (593, 595), False, 'from ramstk.views.gtk3.widgets import RAMSTKComboBox\n'), ((1095, 1132), 'ramstk.views.gtk3.widgets.RAMSTKComboBox', 'RAMSTKComboBox', ([], {'index': '(2)', 'simple': '(False)'}), '(index=2, simple=False)\n... |
from setuptools import setup
from os import path
import io
here = path.abspath(path.dirname(__file__))
with io.open(path.join(here, 'requirements.txt'), encoding='utf-8') as f:
requires = f.read().split()
setup(
name='cufflinks',
version='0.17.1',
description='Productivity Tools for Plotly + Pandas',
... | [
"os.path.dirname",
"os.path.join",
"setuptools.setup"
] | [((211, 755), 'setuptools.setup', 'setup', ([], {'name': '"""cufflinks"""', 'version': '"""0.17.1"""', 'description': '"""Productivity Tools for Plotly + Pandas"""', 'author': '"""<NAME>"""', 'author_email': '"""<EMAIL>"""', 'license': '"""MIT"""', 'keywords': "['pandas', 'plotly', 'plotting']", 'url': '"""https://gith... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
###############################################################################
# #
# RMG Website - A Django-powered website for Reaction Mechanism Generator #
# ... | [
"django.db.models.CharField",
"django.db.models.OneToOneField",
"django.db.models.TextField"
] | [((3210, 3262), 'django.db.models.OneToOneField', 'models.OneToOneField', (['User'], {'on_delete': 'models.CASCADE'}), '(User, on_delete=models.CASCADE)\n', (3230, 3262), False, 'from django.db import models\n'), ((3282, 3314), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(100)'}), '(max_lengt... |
import sys
import os
# sys.path.append('C:\\Users\\Lynn\\Desktop\\instrument_control\\libraries')
sys.path.append(os.getcwd()[:os.getcwd().find("instrument_control")+len("instrument_control")]+'\\libraries')
from libraries import *
class tlb6700(object):
def __init__(self, **kwargs):
super(tlb6700,self).__i... | [
"os.getcwd"
] | [((117, 128), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (126, 128), False, 'import os\n'), ((130, 141), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (139, 141), False, 'import os\n')] |
__extras__ = []
from .environment import Environment, MDPInfo
try:
Atari = None
from .atari import Atari
__extras__.append('Atari')
except ImportError as imp_e:
print("Could not import Atari environment")
import ipdb; ipdb.set_trace()
pass
try:
Gym = None
from .gym_env import Gym
_... | [
"ipdb.set_trace"
] | [((239, 255), 'ipdb.set_trace', 'ipdb.set_trace', ([], {}), '()\n', (253, 255), False, 'import ipdb\n')] |
import logging
import sys
import requests
from requests import RequestException
logging.basicConfig(stream=sys.stdout, level=logging.INFO)
BASE_URL = 'https://19ba7tbxn5-dsn.algolia.net/1/indexes/*/queries'
params = {
'x-algolia-agent': 'Algolia%20for%20JavaScript%20(3.34.0)%3B%20Browser',
'x-algolia-applic... | [
"logging.error",
"logging.basicConfig"
] | [((82, 140), 'logging.basicConfig', 'logging.basicConfig', ([], {'stream': 'sys.stdout', 'level': 'logging.INFO'}), '(stream=sys.stdout, level=logging.INFO)\n', (101, 140), False, 'import logging\n'), ((1810, 1872), 'logging.error', 'logging.error', (['"""Could not save data. Please choose a database"""'], {}), "('Coul... |
from keras.callbacks import Callback
import keras.backend as K
import numpy as np
class SGDRScheduler(Callback):
'''Cosine annealing learning rate scheduler with periodic restarts.
# Usage
```python
schedule = SGDRScheduler(min_lr=1e-5,
max_lr=1e-2,
... | [
"keras.backend.set_value",
"keras.backend.get_value",
"numpy.ceil",
"numpy.cos"
] | [((2345, 2394), 'keras.backend.set_value', 'K.set_value', (['self.model.optimizer.lr', 'self.max_lr'], {}), '(self.model.optimizer.lr, self.max_lr)\n', (2356, 2394), True, 'import keras.backend as K\n'), ((2592, 2628), 'keras.backend.get_value', 'K.get_value', (['self.model.optimizer.lr'], {}), '(self.model.optimizer.l... |
import hashlib
import os
import json
import random
import collections
from operator import itemgetter
import warnings
import jinja2
from docutils import nodes
from docutils.statemachine import ViewList
from docutils.parsers.rst import Directive
from docutils.parsers.rst.directives import flag
from sphinx.util.nodes ... | [
"jinja2.Template",
"json.dump",
"json.load",
"os.makedirs",
"random.shuffle",
"os.path.exists",
"docutils.nodes.paragraph",
"sphinx.util.nodes.nested_parse_with_titles",
"altair.examples.iter_examples",
"docutils.statemachine.ViewList",
"random.seed",
"collections.OrderedDict",
"warnings.war... | [((617, 1895), 'jinja2.Template', 'jinja2.Template', (['"""\n.. This document is auto-generated by the altair-gallery extension. Do not modify directly.\n\n.. _{{ gallery_ref }}:\n\n{{ title }}\n{% for char in title %}-{% endfor %}\n\nThis gallery contains a selection of examples of the plots Altair can create.\n\nSome... |
#!/usr/local/bin/python
# coding=utf-8
# Some minor code fixup and Hungarian translation by Czompi.
# smartmirror.py
# requirements
# requests, feedparser, traceback, Pillow
import os, sys
import config
from tkinter import *
import locale
import threading
import time
import requests
import json
import traceback
imp... | [
"feedparser.parse",
"PIL.ImageTk.PhotoImage",
"traceback.print_exc",
"json.loads",
"time.strftime",
"PIL.Image.open",
"threading.Lock",
"requests.get",
"locale.setlocale"
] | [((420, 436), 'threading.Lock', 'threading.Lock', ([], {}), '()\n', (434, 436), False, 'import threading\n'), ((556, 587), 'locale.setlocale', 'locale.setlocale', (['locale.LC_ALL'], {}), '(locale.LC_ALL)\n', (572, 587), False, 'import locale\n'), ((9487, 9521), 'PIL.Image.open', 'Image.open', (['"""assets/Newspaper.pn... |
import unittest
from datetime import date
from fincalendar.foreign_exchange_config import get_settlement_day_convention
class FxSettlementDateConvention(unittest.TestCase):
def setUp(self):
pass
def tearDown(self):
pass
def test_t_plus_2(self):
basecurrency = 'SGD'
... | [
"unittest.main",
"fincalendar.foreign_exchange_config.get_settlement_day_convention"
] | [((1143, 1158), 'unittest.main', 'unittest.main', ([], {}), '()\n', (1156, 1158), False, 'import unittest\n'), ((369, 429), 'fincalendar.foreign_exchange_config.get_settlement_day_convention', 'get_settlement_day_convention', (['basecurrency', 'pricingcurrency'], {}), '(basecurrency, pricingcurrency)\n', (398, 429), Fa... |
__author__ = 'Harsh'
import tweepy
import json
from pymongo import MongoClient
import re
#extracting twitter data
def twitter_extract():
auth=tweepy.OAuthHandler('vXcbdBd5ajXqTVwdJEDknvPg1','<KEY>vOUVCmJ2JuZ9iLy9AsDogqhyJM521qDMtVoL49ZO9H')
auth.set_access_token('<KEY>','<KEY>')
api=tweepy.API(auth,wait_... | [
"pymongo.MongoClient",
"json.dump",
"json.load",
"tweepy.API",
"tweepy.Cursor",
"tweepy.OAuthHandler",
"re.sub"
] | [((148, 251), 'tweepy.OAuthHandler', 'tweepy.OAuthHandler', (['"""vXcbdBd5ajXqTVwdJEDknvPg1"""', '"""<KEY>vOUVCmJ2JuZ9iLy9AsDogqhyJM521qDMtVoL49ZO9H"""'], {}), "('vXcbdBd5ajXqTVwdJEDknvPg1',\n '<KEY>vOUVCmJ2JuZ9iLy9AsDogqhyJM521qDMtVoL49ZO9H')\n", (167, 251), False, 'import tweepy\n'), ((299, 340), 'tweepy.API', 'tw... |
from flask import Blueprint
web = Blueprint('web', __name__)
from . import views, errors
| [
"flask.Blueprint"
] | [((35, 61), 'flask.Blueprint', 'Blueprint', (['"""web"""', '__name__'], {}), "('web', __name__)\n", (44, 61), False, 'from flask import Blueprint\n')] |
import cv2
import numpy as np
from PIL import Image
import os
path = "./photo/myobject"
filelist = os.listdir(path)
total_num = len(filelist)
n = 6
for i in range(1,total_num):
n = 6 - len(str(i))
filepath = "./photo/myobject/"+str(0)*n + str(i)+".jpg"
imgsize = Image.open(filepath)#開啟圖片
print('開啟檔案：... | [
"cv2.grabCut",
"numpy.zeros",
"PIL.Image.open",
"cv2.imread",
"numpy.where",
"os.listdir"
] | [((101, 117), 'os.listdir', 'os.listdir', (['path'], {}), '(path)\n', (111, 117), False, 'import os\n'), ((278, 298), 'PIL.Image.open', 'Image.open', (['filepath'], {}), '(filepath)\n', (288, 298), False, 'from PIL import Image\n'), ((471, 491), 'cv2.imread', 'cv2.imread', (['filepath'], {}), '(filepath)\n', (481, 491)... |
# factories.py
import factory
from factory.django import DjangoModelFactory
from test_data.models import Person, Thread, Comment, Club
# Defining a factory
class UserFactory(DjangoModelFactory):
class Meta:
model = Person
name = factory.Faker("first_name")
class ThreadFactory(DjangoModelFactory):
... | [
"factory.SubFactory",
"factory.Faker"
] | [((248, 275), 'factory.Faker', 'factory.Faker', (['"""first_name"""'], {}), "('first_name')\n", (261, 275), False, 'import factory\n'), ((371, 432), 'factory.Faker', 'factory.Faker', (['"""sentence"""'], {'nb_words': '(5)', 'variable_nb_words': '(True)'}), "('sentence', nb_words=5, variable_nb_words=True)\n", (384, 432... |
from service import formatter
from . import GeorefMockTest
class FormattingTest(GeorefMockTest):
def test_fields_list_to_dict(self):
"""El resultado de fields_list_to_dict debería ser un diccionario
equivalente a los valores de una lista, desaplanados."""
fields = (
'id',
... | [
"service.formatter.flatten_dict",
"service.formatter.value_to_xml",
"service.formatter.fields_list_to_dict"
] | [((547, 584), 'service.formatter.fields_list_to_dict', 'formatter.fields_list_to_dict', (['fields'], {}), '(fields)\n', (576, 584), False, 'from service import formatter\n'), ((1301, 1333), 'service.formatter.flatten_dict', 'formatter.flatten_dict', (['original'], {}), '(original)\n', (1323, 1333), False, 'from service... |
import random, math, flag
from functions import *
class Robot:
def __init__(self, screen, color, name):
self.screen = screen
self.name = name
self.row = 0
self.col = 0
self.color = color
self.sides = 3
self.radius = 40*scaling
self.direction = 'east'
... | [
"flag.Flag",
"random.randint",
"math.sin",
"math.cos"
] | [((3963, 3983), 'random.randint', 'random.randint', (['(0)', '(4)'], {}), '(0, 4)\n', (3977, 3983), False, 'import random, math, flag\n'), ((8352, 8397), 'flag.Flag', 'flag.Flag', (['self.screen', 'self.row', 'self.col', 'f'], {}), '(self.screen, self.row, self.col, f)\n', (8361, 8397), False, 'import random, math, fla... |
# https://leetcode.com/problems/pseudo-palindromic-paths-in-a-binary-tree/
# idea: DFS
# Definition for a binary tree node.
# class TreeNode:
# def __init__(self, val=0, left=None, right=None):
# self.val = val
# self.left = left
# self.right = right
class Solution:
from collections imp... | [
"collections.Counter"
] | [((608, 621), 'collections.Counter', 'Counter', (['path'], {}), '(path)\n', (615, 621), False, 'from collections import Counter\n')] |
import logging
class Watcher:
"""
A basic Watcher
Users can register a Listener to this Watcher to get updates when the
object the Watcher watches is updated.
"""
def __init__(self):
"Initialize the watcher with an empty set of listeners"
# When Watcher is subclassed, this nee... | [
"logging.getLogger"
] | [((406, 448), 'logging.getLogger', 'logging.getLogger', (['"""bitey.watcher.Watcher"""'], {}), "('bitey.watcher.Watcher')\n", (423, 448), False, 'import logging\n')] |
import clr, os.path
from sys import path
path.append(os.path.abspath(__file__ + "\\..\\..\\..\\bin"))
clr.AddReference("NationalInstruments.RFToolkits.Interop.Fx40")
clr.AddReference("NationalInstruments.ModularInstruments.Interop.Fx40")
import NationalInstruments.RFToolkits.Interop as Toolkits
import Nationa... | [
"NationalInstruments.ModularInstruments.Interop.niRFSG",
"System.Runtime.InteropServices.HandleRef",
"clr.AddReference",
"NationalInstruments.RFToolkits.Interop.niWLANA",
"NationalInstruments.ModularInstruments.Interop.niRFSA"
] | [((107, 170), 'clr.AddReference', 'clr.AddReference', (['"""NationalInstruments.RFToolkits.Interop.Fx40"""'], {}), "('NationalInstruments.RFToolkits.Interop.Fx40')\n", (123, 170), False, 'import clr, os.path\n'), ((172, 243), 'clr.AddReference', 'clr.AddReference', (['"""NationalInstruments.ModularInstruments.Interop.F... |
"""
Math Utilities
"""
import collections
import numpy as np
from nnlib.utils.functional import not_none
__all__ = ['FNVHash', 'ceil_div', 'normalize', 'pow', 'prod', 'sum', 'random_subset', 'softmax']
class FNVHash:
hval = 0x811c9dc5
fnv_32_prime = 0x01000193
uint32_max = 2 ** 32
@staticmethod
... | [
"numpy.arange",
"numpy.asarray",
"numpy.sum",
"numpy.log"
] | [((657, 687), 'numpy.asarray', 'np.asarray', (['xs'], {'dtype': 'np.float'}), '(xs, dtype=np.float)\n', (667, 687), True, 'import numpy as np\n'), ((705, 716), 'numpy.sum', 'np.sum', (['arr'], {}), '(arr)\n', (711, 716), True, 'import numpy as np\n'), ((4282, 4293), 'numpy.sum', 'np.sum', (['arr'], {}), '(arr)\n', (428... |
"""Beat-synchronous chroma feature calculation with LabROSA.
<NAME> <EMAIL> 2016-04-08
"""
from __future__ import print_function
import cPickle as pickle
import getopt
import os
import sys
import time
import numpy as np
import scipy
import sklearn.mixture
import librosa
def read_iso_label_file(filename):
""... | [
"numpy.maximum",
"getopt.getopt",
"numpy.argmax",
"time.ctime",
"cPickle.load",
"librosa.feature.sync",
"os.path.join",
"os.path.dirname",
"os.path.exists",
"numpy.maximum.outer",
"librosa.feature.chroma_cqt",
"numpy.hstack",
"librosa.load",
"sys.exit",
"os.makedirs",
"cPickle.dump",
... | [((864, 912), 'numpy.maximum.outer', 'np.maximum.outer', (['ranges_a[:, 0]', 'ranges_b[:, 0]'], {}), '(ranges_a[:, 0], ranges_b[:, 0])\n', (880, 912), True, 'import numpy as np\n'), ((935, 983), 'numpy.minimum.outer', 'np.minimum.outer', (['ranges_a[:, 1]', 'ranges_b[:, 1]'], {}), '(ranges_a[:, 1], ranges_b[:, 1])\n', ... |
# Software Name: AIVC
# SPDX-FileCopyrightText: Copyright (c) 2021 Orange
# SPDX-License-Identifier: BSD 3-Clause "New"
#
# This software is distributed under the BSD-3-Clause license.
#
# Authors: <NAME> <<EMAIL>>
# <NAME> <<EMAIL>>
"""
This module contains all the methods needed to train a model:
- Trai... | [
"func_util.nn_util.get_value",
"real_life.bitstream.ArithmeticCoder",
"func_util.console_display.print_log_msg",
"model_mngt.loss_function.compute_metrics_one_GOP",
"math.ceil",
"torch.load",
"os.system",
"func_util.result_logging.generate_header_file",
"torch.cuda.empty_cache",
"torch.device",
... | [((2891, 2931), 'func_util.nn_util.get_value', 'get_value', (['"""model"""', 'param', 'DEFAULT_PARAM'], {}), "('model', param, DEFAULT_PARAM)\n", (2900, 2931), False, 'from func_util.nn_util import crop_dic, get_value\n'), ((2949, 2994), 'func_util.nn_util.get_value', 'get_value', (['"""GOP_struct"""', 'param', 'DEFAUL... |
import telepot
from telepot.loop import MessageLoop
import sys
from control_bot import control
from bot_command import *
from time import sleep
TOKEN = sys.argv[1]
bot = telepot.Bot(TOKEN)
def handle(msg):
main = control(msg, bot)
inst_commnand_user = command_user(msg=msg, bot=bot)
inst_command_admin = command_adm... | [
"telepot.Bot",
"time.sleep",
"telepot.loop.MessageLoop",
"control_bot.control"
] | [((171, 189), 'telepot.Bot', 'telepot.Bot', (['TOKEN'], {}), '(TOKEN)\n', (182, 189), False, 'import telepot\n'), ((216, 233), 'control_bot.control', 'control', (['msg', 'bot'], {}), '(msg, bot)\n', (223, 233), False, 'from control_bot import control\n'), ((1834, 1844), 'time.sleep', 'sleep', (['(100)'], {}), '(100)\n'... |
import logging
import numpy as np
from amset.constants import defaults
from amset.deformation.common import desymmetrize_deformation_potentials
from amset.deformation.io import load_deformation_potentials
from amset.electronic_structure.kpoints import get_mesh_from_kpoint_numbers
from amset.electronic_structure.symme... | [
"amset.deformation.common.desymmetrize_deformation_potentials",
"amset.electronic_structure.kpoints.get_mesh_from_kpoint_numbers",
"numpy.product",
"amset.electronic_structure.symmetry.expand_kpoints",
"logging.getLogger",
"amset.deformation.io.load_deformation_potentials"
] | [((495, 522), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (512, 522), False, 'import logging\n'), ((703, 740), 'amset.deformation.io.load_deformation_potentials', 'load_deformation_potentials', (['filename'], {}), '(filename)\n', (730, 740), False, 'from amset.deformation.io import loa... |
# Copyright 2014 Novo Nordisk Foundation Center for Biosustainability, DTU.
#
# 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 requi... | [
"six.iteritems",
"cameo.core.result.MetaInformation",
"sympy.RealNumber",
"collections.Counter",
"cobra.DictList",
"cameo.phenotypic_phase_plane",
"functools.partial",
"cameo.strain_design.pathway_prediction.util.display_pathway",
"cameo.strain_design.pathway_prediction.util.create_adapter_reactions... | [((1612, 1639), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1629, 1639), False, 'import logging\n'), ((1852, 1869), 'cameo.core.result.MetaInformation', 'MetaInformation', ([], {}), '()\n', (1867, 1869), False, 'from cameo.core.result import Result, MetaInformation\n'), ((2408, 2443),... |
from machine import Pin
from neopixel import NeoPixel
from Blocky.Pin import getPin
from Blocky.Timer import *
from time import sleep_ms
class Indicator :
def __init__ (self):
self.animation = ''
self.color = (0,0,0) # color that user set
self.fcolor = [0,0,0] # color that the handler use
self.rgb = NeoPixel(... | [
"time.sleep_ms",
"machine.Pin"
] | [((461, 472), 'time.sleep_ms', 'sleep_ms', (['(1)'], {}), '(1)\n', (469, 472), False, 'from time import sleep_ms\n'), ((320, 326), 'machine.Pin', 'Pin', (['(5)'], {}), '(5)\n', (323, 326), False, 'from machine import Pin\n')] |
"""
Utilities for working with videos, pulling out patches, etc.
"""
import numpy
from pylearn2.compat import OrderedDict
from pylearn2.utils.rng import make_np_rng
__author__ = "<NAME>"
__copyright__ = "Copyright 2011, <NAME> / Universite de Montreal"
__license__ = "BSD"
__maintainer__ = "<NAME>"
__email__ = "<EMAIL... | [
"pylearn2.utils.rng.make_np_rng",
"pylearn2.compat.OrderedDict",
"pyffmpeg.FFMpegReader",
"numpy.cumsum",
"numpy.random.random_integers"
] | [((930, 953), 'pyffmpeg.FFMpegReader', 'pyffmpeg.FFMpegReader', ([], {}), '()\n', (951, 953), False, 'import pyffmpeg\n'), ((3701, 3725), 'pylearn2.compat.OrderedDict', 'OrderedDict', (['file_tuples'], {}), '(file_tuples)\n', (3712, 3725), False, 'from pylearn2.compat import OrderedDict\n'), ((3801, 3849), 'pylearn2.ut... |
import colorful as cf
from dbmanagement.manager.category_manager import CategoryManager
from dbmanagement.manager.favorite_manager import favorite_manager
from dbmanagement.manager.product_manager import product_manager
from .state import State
class StartMenu(State):
"""The first State with the main menu. Two o... | [
"dbmanagement.manager.favorite_manager.favorite_manager.get_all_favorite",
"dbmanagement.manager.product_manager.product_manager.get_healthier_product_by_category",
"dbmanagement.manager.favorite_manager.favorite_manager.save_healthy_product_to_favorite",
"colorful.red",
"dbmanagement.manager.category_manag... | [((1371, 1396), 'dbmanagement.manager.category_manager.CategoryManager.get_cat', 'CategoryManager.get_cat', ([], {}), '()\n', (1394, 1396), False, 'from dbmanagement.manager.category_manager import CategoryManager\n'), ((2168, 2233), 'dbmanagement.manager.product_manager.product_manager.get_unhealthy_prod_by_category',... |
#/u/GoldenSights
import sys
import traceback
import time
import datetime
import sqlite3
import json
import praw
'''USER CONFIGURATION'''
"""GENERAL"""
APP_ID = ""
APP_SECRET = ""
APP_URI = ""
APP_REFRESH = ""
# https://www.reddit.com/comments/3cm1p8/how_to_make_your_bot_use_oauth2/
USERAGENT = "/r/Excel Clippy Office... | [
"threading.Thread",
"traceback.print_exc",
"praw.helpers.flatten_tree",
"winsound.PlaySound",
"time.sleep",
"sqlite3.connect",
"sys.stdout.flush",
"praw.Reddit",
"datetime.datetime.now"
] | [((18652, 18696), 'datetime.datetime.now', 'datetime.datetime.now', (['datetime.timezone.utc'], {}), '(datetime.timezone.utc)\n', (18673, 18696), False, 'import datetime\n'), ((19260, 19293), 'sqlite3.connect', 'sqlite3.connect', (['"""superclippy.db"""'], {}), "('superclippy.db')\n", (19275, 19293), False, 'import sql... |
from code.BestBuyScraper import BestBuyScraper
import re
# Unit tests for BestBuyScraper.py
# Tests the object construction, In stock and out stock cases
# @author qchen59
InStockUrl = "https://www.bestbuy.com/site/dell-s2721dgf-27-gaming-ips-qhd-freesync-and-g-sync-compatible-monitor-with-hdr-displayport-hdmi/642162... | [
"code.BestBuyScraper.BestBuyScraper"
] | [((462, 488), 'code.BestBuyScraper.BestBuyScraper', 'BestBuyScraper', (['InStockUrl'], {}), '(InStockUrl)\n', (476, 488), False, 'from code.BestBuyScraper import BestBuyScraper\n'), ((922, 948), 'code.BestBuyScraper.BestBuyScraper', 'BestBuyScraper', (['InStockUrl'], {}), '(InStockUrl)\n', (936, 948), False, 'from code... |
import json
from rest_framework.request import Request
from django.template.loader import get_template
from rest_framework import generics
from api.pdf import render as render_pdf
from django.http import (
HttpResponse
)
class SurveyPdfView(generics.GenericAPIView):
# FIXME - restore authentication?
permi... | [
"api.pdf.render",
"django.http.HttpResponse",
"json.loads",
"django.template.loader.get_template"
] | [((555, 587), 'json.loads', 'json.loads', (["request.POST['data']"], {}), "(request.POST['data'])\n", (565, 587), False, 'import json\n'), ((658, 680), 'django.template.loader.get_template', 'get_template', (['tpl_name'], {}), '(tpl_name)\n', (670, 680), False, 'from django.template.loader import get_template\n'), ((10... |
# flake8: noqa
import os
from os.path import join
from rastervision2.core.pipeline import *
from rastervision2.core.backend import *
from rastervision2.core.data import *
from rastervision2.core.analyzer import *
from rastervision2.pytorch_backend import *
from rastervision2.pytorch_learner import *
from rastervision... | [
"os.path.basename",
"rastervision2.examples.utils.save_image_crop"
] | [((1971, 2096), 'rastervision2.examples.utils.save_image_crop', 'save_image_crop', (['raster_uri', 'crop_uri'], {'label_uri': 'label_uri', 'label_crop_uri': 'label_crop_uri', 'size': '(600)', 'vector_labels': '(False)'}), '(raster_uri, crop_uri, label_uri=label_uri, label_crop_uri=\n label_crop_uri, size=600, vector... |
import numpy as np
import pickle, os, ntpath, cv2
tot_list = []
img_list = []
label_list = []
pickle_dict = {}
load_path = ''
def _load_data(path):
count = 0
for root, dirs, files in os.walk(path):
for file in files:
imgpath = os.path.join(root, file)
tot_list.append(imgpath)
... | [
"pickle.dump",
"numpy.random.shuffle",
"ntpath.basename",
"cv2.cvtColor",
"numpy.asarray",
"os.walk",
"cv2.imread",
"os.path.join",
"cv2.resize"
] | [((193, 206), 'os.walk', 'os.walk', (['path'], {}), '(path)\n', (200, 206), False, 'import pickle, os, ntpath, cv2\n'), ((324, 351), 'numpy.random.shuffle', 'np.random.shuffle', (['tot_list'], {}), '(tot_list)\n', (341, 351), True, 'import numpy as np\n'), ((747, 767), 'numpy.asarray', 'np.asarray', (['img_list'], {}),... |
from pathlib import Path
import decouple
import django_heroku
import psycopg2
import dj_database_url
from corsheaders.defaults import default_headers
# Build paths inside the project like this: BASE_DIR / 'subdir'.
BASE_DIR = Path(__file__).resolve().parent.parent
# SECURITY WARNING: don't run with debug turned on ... | [
"decouple.config",
"dj_database_url.config",
"pathlib.Path"
] | [((343, 374), 'decouple.config', 'decouple.config', (['"""DJANGO_DEBUG"""'], {}), "('DJANGO_DEBUG')\n", (358, 374), False, 'import decouple\n'), ((2216, 2256), 'dj_database_url.config', 'dj_database_url.config', ([], {'conn_max_age': '(600)'}), '(conn_max_age=600)\n', (2238, 2256), False, 'import dj_database_url\n'), (... |
from flask import Flask, json
companies = [{"id": 1, "name": "Company One"}, {"id": 2, "name": "Company Two"}]
# initialize Flask
# create a Flask object, and assign it to the variable name api.
api = Flask(__name__)
# declare a route for endpoint.
# When a consumer visits /companies using a GET request, the list o... | [
"flask.json.dumps",
"flask.Flask"
] | [((203, 218), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (208, 218), False, 'from flask import Flask, json\n'), ((426, 447), 'flask.json.dumps', 'json.dumps', (['companies'], {}), '(companies)\n', (436, 447), False, 'from flask import Flask, json\n'), ((587, 616), 'flask.json.dumps', 'json.dumps', (["{... |
import numpy as np
from . import _colormixer
from . import _histograms
import threading
from ...util import img_as_ubyte
# utilities to make life easier for plugin writers.
import multiprocessing
CPU_COUNT = multiprocessing.cpu_count()
class GuiLockError(Exception):
def __init__(self, msg):
self.msg = m... | [
"numpy.empty",
"multiprocessing.cpu_count"
] | [((210, 237), 'multiprocessing.cpu_count', 'multiprocessing.cpu_count', ([], {}), '()\n', (235, 237), False, 'import multiprocessing\n'), ((3854, 3898), 'numpy.empty', 'np.empty', (['(height, width, 3)'], {'dtype': 'np.uint8'}), '((height, width, 3), dtype=np.uint8)\n', (3862, 3898), True, 'import numpy as np\n')] |
# Copyright 2013 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Utilities for dealing with the python unittest module."""
import fnmatch
import re
import sys
import unittest
class _TextTestResult(unittest._TextTestR... | [
"unittest.TestResult.startTest",
"unittest.TestResult.addSuccess",
"unittest.TextTestRunner.__init__",
"unittest.TestResult.addError",
"unittest._TextTestResult.__init__",
"fnmatch.translate",
"unittest.TestResult.addFailure",
"fnmatch.fnmatch"
] | [((940, 1012), 'unittest._TextTestResult.__init__', 'unittest._TextTestResult.__init__', (['self', 'stream', 'descriptions', 'verbosity'], {}), '(self, stream, descriptions, verbosity)\n', (973, 1012), False, 'import unittest\n'), ((1361, 1402), 'unittest.TestResult.startTest', 'unittest.TestResult.startTest', (['self'... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
feign blocks module
zs. elter, a. cserkaszky 2019
"""
import os
import math
import re
import numpy as np
import matplotlib.pyplot as plt
from feign.geometry import *
def isFloat(s):
try:
float(s)
return True
except ValueError:
return... | [
"numpy.sum",
"numpy.ravel",
"numpy.empty",
"numpy.mean",
"numpy.sin",
"matplotlib.pyplot.gca",
"numpy.interp",
"numpy.std",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.show",
"matplotlib.pyplot.ylim",
"matplotlib.pyplot.Circle",
"numpy.cos",
"matplotlib.pyplot.Polygon",
"re.compile"... | [((1225, 1250), 'numpy.interp', 'np.interp', (['energy', 'en', 'mu'], {}), '(energy, en, mu)\n', (1234, 1250), True, 'import numpy as np\n'), ((1853, 1880), 're.compile', 're.compile', (['HEX_COLOR_REGEX'], {}), '(HEX_COLOR_REGEX)\n', (1863, 1880), False, 'import re\n'), ((14130, 14147), 'numpy.array', 'np.array', (['f... |
import os
from subprocess import STDOUT, check_call, CalledProcessError
class Apt:
def __init__(self, stdout=open(os.devnull, 'wb'), stderr=STDOUT):
self.stdout = stdout
self.stderr = stderr
def command(self, structure):
try:
return check_call(structure, stdout=self.stdout... | [
"subprocess.check_call"
] | [((280, 341), 'subprocess.check_call', 'check_call', (['structure'], {'stdout': 'self.stdout', 'stderr': 'self.stderr'}), '(structure, stdout=self.stdout, stderr=self.stderr)\n', (290, 341), False, 'from subprocess import STDOUT, check_call, CalledProcessError\n')] |
import requests
from backend.interfaces import DataSender
class TelegramSender(DataSender):
def __init__(self, api_token: str, chat_id: str) -> None:
self.api_token = api_token
self.chat_id = chat_id
def send_message(self, msg) -> None:
if self.api_token and self.chat_id:
... | [
"requests.get"
] | [((582, 604), 'requests.get', 'requests.get', (['sent_msg'], {}), '(sent_msg)\n', (594, 604), False, 'import requests\n')] |
import numpy as np
import numpy_financial as npf
import numpy.linalg as linalg
from datetime import date
from workalendar.america import Brazil
cal = Brazil()
class Titulos:
def __init__(self, taxa, start, end, c=0):
"""
:param fv: Face Value
:param c: coupon
:param start: settleme... | [
"workalendar.america.Brazil",
"numpy.sum",
"numpy_financial.irr",
"numpy.zeros",
"datetime.date",
"numpy.transpose",
"numpy.insert",
"numpy.append",
"numpy.max",
"numpy.array",
"numpy.column_stack",
"numpy.linalg.solve",
"numpy.vstack"
] | [((150, 158), 'workalendar.america.Brazil', 'Brazil', ([], {}), '()\n', (156, 158), False, 'from workalendar.america import Brazil\n'), ((1621, 1645), 'datetime.date', 'date', (['start.year', '(12)', '(31)'], {}), '(start.year, 12, 31)\n', (1625, 1645), False, 'from datetime import date\n'), ((1672, 1698), 'datetime.da... |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'ROI_label_window_dark.ui'
#
# Created by: PyQt5 UI code generator 5.15.4
#
# WARNING: Any manual changes made to this file will be lost when pyuic5 is
# run again. Do not edit this file unless you know what you are doing.
from PyQt5 impor... | [
"PyQt5.QtWidgets.QLabel",
"PyQt5.QtWidgets.QWidget",
"PyQt5.QtCore.QRect",
"PyQt5.QtWidgets.QPushButton",
"PyQt5.QtWidgets.QDialog",
"PyQt5.QtGui.QFont",
"PyQt5.QtWidgets.QScrollArea",
"PyQt5.QtCore.QMetaObject.connectSlotsByName",
"PyQt5.QtWidgets.QApplication"
] | [((2381, 2413), 'PyQt5.QtWidgets.QApplication', 'QtWidgets.QApplication', (['sys.argv'], {}), '(sys.argv)\n', (2403, 2413), False, 'from PyQt5 import QtCore, QtGui, QtWidgets\n'), ((2428, 2447), 'PyQt5.QtWidgets.QDialog', 'QtWidgets.QDialog', ([], {}), '()\n', (2445, 2447), False, 'from PyQt5 import QtCore, QtGui, QtWi... |
# Copyright 2019 Huawei Technologies Co., Ltd
#
# 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... | [
"akg.utils.custom_tiling.reg_set_dim_func",
"akg.lang.cce.iou"
] | [((1016, 1058), 'akg.utils.custom_tiling.reg_set_dim_func', 'ct_util.reg_set_dim_func', (['iou_set_dim_func'], {}), '(iou_set_dim_func)\n', (1040, 1058), True, 'from akg.utils import custom_tiling as ct_util\n'), ((2637, 2694), 'akg.lang.cce.iou', 'dav.iou', (['anchor_box[bs, i, k]', 'ground_truth_box[bs, j, k]'], {}),... |
import os
from configs.Configurations import Configurations
configs = Configurations().configs
print(len(configs))
| [
"configs.Configurations.Configurations"
] | [((71, 87), 'configs.Configurations.Configurations', 'Configurations', ([], {}), '()\n', (85, 87), False, 'from configs.Configurations import Configurations\n')] |
# Plot (and write to table?) autocorrelation and ESS for samplers with different
# stepsizes on some standard functions (no noise?). See also MCMCVisualizer
# plots and pymc3 plots.
# Plot the following:
# vs NUTS with different initial stepsizes
# vs HMC with different initial stepsizes
# vs SGHMC with different ini... | [
"pymc3.sample",
"pysgmcmc.samplers.energy_functions.Gmm1",
"numpy.isnan",
"numpy.random.rand",
"os.path.dirname",
"keras.backend.random_normal_variable",
"itertools.product",
"pymc3.step_methods.HamiltonianMC",
"pymc3.sampling.init_nuts",
"pysgmcmc.samplers.energy_functions.MoGL2HMC",
"keras.bac... | [((3859, 4112), 'collections.OrderedDict', 'OrderedDict', (["(('SGHMC', SGHMCSampler), ('SGHMCHD', SGHMCHDSampler), ('SGLD', SGLDSampler\n ), ('NUTS', pm.step_methods.NUTS), ('HMC', pm.step_methods.\n HamiltonianMC), ('Metropolis', pm.step_methods.Metropolis), ('Slice',\n pm.step_methods.Slice))"], {}), "((('S... |
import logging
import time
import unittest
from neurolib.models.aln import ALNModel
from neurolib.models.fhn import FHNModel
from neurolib.models.hopf import HopfModel
from neurolib.models.thalamus import ThalamicMassModel
from neurolib.models.wc import WCModel
from neurolib.models.subdivwc import SubDivWCModel
from n... | [
"unittest.main",
"neurolib.models.fhn.FHNModel",
"neurolib.models.subdivwc.SubDivWCModel",
"neurolib.models.wc.WCModel",
"time.time",
"logging.info",
"neurolib.models.aln.ALNModel",
"neurolib.models.thalamus.ThalamicMassModel",
"neurolib.utils.loadData.Dataset",
"neurolib.models.hopf.HopfModel"
] | [((6055, 6070), 'unittest.main', 'unittest.main', ([], {}), '()\n', (6068, 6070), False, 'import unittest\n'), ((541, 590), 'logging.info', 'logging.info', (['"""\t > ALN: Testing single node ..."""'], {}), "('\\t > ALN: Testing single node ...')\n", (553, 590), False, 'import logging\n'), ((607, 618), 'time.time', 'ti... |
from django.db import models
# Create your models here.
class Note(models.Model):
title = models.CharField(
max_length= 30,
)
content = models.TextField()
image_url = models.URLField()
| [
"django.db.models.CharField",
"django.db.models.TextField",
"django.db.models.URLField"
] | [((95, 126), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(30)'}), '(max_length=30)\n', (111, 126), False, 'from django.db import models\n'), ((157, 175), 'django.db.models.TextField', 'models.TextField', ([], {}), '()\n', (173, 175), False, 'from django.db import models\n'), ((192, 209), 'dja... |
# 1. import Flask
from flask import Flask
# 2. Create an app, being sure to pass __name__
app = Flask(__name__)
# 3. Define what to do when a user hits the index route
@app.route("/")
def home():
print("Hello World")
return "Hello World!"
@app.route("/about")
def home():
print("Krys - Phoenix")
retu... | [
"flask.Flask"
] | [((97, 112), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (102, 112), False, 'from flask import Flask\n')] |
"""
Copyright (c) 2022 Huawei Technologies Co.,Ltd.
openGauss is licensed under Mulan PSL v2.
You can use this software according to the terms and conditions of the Mulan PSL v2.
You may obtain a copy of Mulan PSL v2 at:
http://license.coscl.org.cn/MulanPSL2
THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, W... | [
"testcase.utils.CommonSH.CommonSH",
"testcase.utils.Logger.Logger",
"testcase.utils.Constant.Constant",
"testcase.utils.Common.Common",
"time.sleep",
"yat.test.Node",
"testcase.utils.ComThread.ComThread"
] | [((1629, 1654), 'testcase.utils.CommonSH.CommonSH', 'CommonSH', (['"""PrimaryDbUser"""'], {}), "('PrimaryDbUser')\n", (1637, 1654), False, 'from testcase.utils.CommonSH import CommonSH\n'), ((1799, 1807), 'testcase.utils.Logger.Logger', 'Logger', ([], {}), '()\n', (1805, 1807), False, 'from testcase.utils.Logger import... |
#!/usr/bin/env python
from __future__ import print_function
import pycreate2
import argparse
import time
DESCRIPTION = """
Shuts down the Create 2.
"""
def handleArgs():
parser = argparse.ArgumentParser(description=DESCRIPTION, formatter_class=argparse.RawTextHelpFormatter)
# parser.add_argument('-m', '--max', h... | [
"pycreate2.Create2",
"argparse.ArgumentParser",
"time.sleep"
] | [((185, 285), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': 'DESCRIPTION', 'formatter_class': 'argparse.RawTextHelpFormatter'}), '(description=DESCRIPTION, formatter_class=argparse.\n RawTextHelpFormatter)\n', (208, 285), False, 'import argparse\n'), ((813, 852), 'pycreate2.Create2', 'py... |
from auth.gateio_auth import *
from gate_api import ApiClient, Configuration, Order, SpotApi
client = load_gateio_creds('auth/auth.yml')
spot_api = SpotApi(ApiClient(client))
def get_last_price(base,quote):
"""
Args:
'DOT', 'USDT'
"""
tickers = spot_api.list_tickers(currency_pair=f'{base}_{quote}... | [
"gate_api.ApiClient"
] | [((157, 174), 'gate_api.ApiClient', 'ApiClient', (['client'], {}), '(client)\n', (166, 174), False, 'from gate_api import ApiClient, Configuration, Order, SpotApi\n')] |
"""
Supernet for differentiable rollouts.
"""
import contextlib
import torch
from torch.nn import functional as F
from aw_nas import assert_rollout_type, utils
from aw_nas.rollout.base import DartsArch, DifferentiableRollout, BaseRollout
from aw_nas.utils import data_parallel, use_params
from aw_nas.weights_manager.... | [
"aw_nas.assert_rollout_type",
"aw_nas.utils.data_parallel",
"torch.split",
"torch.cat",
"aw_nas.utils.use_params",
"torch.nn.functional.max_pool2d",
"aw_nas.rollout.base.DartsArch"
] | [((3318, 3423), 'aw_nas.utils.data_parallel', 'data_parallel', (['self.super_net', '(inputs, arch)', 'self.gpus'], {'module_kwargs': "{'detach_arch': detach_arch}"}), "(self.super_net, (inputs, arch), self.gpus, module_kwargs={\n 'detach_arch': detach_arch})\n", (3331, 3423), False, 'from aw_nas.utils import data_pa... |
# Generated by Django 2.0.7 on 2018-07-21 00:15
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('publicbanking', '0007_auto_20180719_0113'),
]
operations = [
migrations.AlterField(
model_name=... | [
"django.db.models.ForeignKey"
] | [((397, 532), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'on_delete': 'django.db.models.deletion.CASCADE', 'related_name': '"""transaction_destination"""', 'to': '"""publicbanking.Account"""'}), "(on_delete=django.db.models.deletion.CASCADE, related_name\n ='transaction_destination', to='publicbanking... |
# -*- coding: utf-8 -*-
"""
Node Classes.
* :any:`Node`: a simple tree node
* :any:`NodeMixin`: extends any python class to a tree node.
"""
from __future__ import print_function
from .iterators import PreOrderIter
import warnings
class NodeMixin(object):
separator = "/"
u"""
The :any:`NodeMixin` clas... | [
"warnings.warn"
] | [((6822, 6922), 'warnings.warn', 'warnings.warn', (['""".anchestors was a typo and will be removed in version 3.0.0"""', 'DeprecationWarning'], {}), "('.anchestors was a typo and will be removed in version 3.0.0',\n DeprecationWarning)\n", (6835, 6922), False, 'import warnings\n')] |
import argparse
from itertools import combinations
from typing import Dict
import json
import os
import pandas as pd
from scirex.metrics.clustering_metrics import match_predicted_clusters_to_gold
from scirex.metrics.f1 import compute_f1
from scirex.predictors.utils import map_predicted_spans_to_gold, merge_method_sub... | [
"pandas.DataFrame",
"scirex_utilities.json_utilities.load_jsonl",
"argparse.ArgumentParser",
"scirex.metrics.clustering_metrics.match_predicted_clusters_to_gold",
"scirex.predictors.utils.map_predicted_spans_to_gold",
"scirex.metrics.f1.compute_f1",
"json.dumps",
"scirex.predictors.utils.merge_method_... | [((451, 476), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (474, 476), False, 'import argparse\n'), ((4872, 4913), 'scirex.metrics.f1.compute_f1', 'compute_f1', (['predicted', 'gold', 'matched'], {'m': '(1)'}), '(predicted, gold, matched, m=1)\n', (4882, 4913), False, 'from scirex.metrics.f1 ... |
# -*- coding: utf-8 -*-
# Generated by Django 1.9.7 on 2016-06-07 11:22
import django.db.models.deletion
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
("modeladmintest", "0003_publisher"),
]
operations = [
migrations.CreateModel(
... | [
"django.db.models.CharField",
"django.db.models.OneToOneField",
"django.db.models.IntegerField"
] | [((434, 604), 'django.db.models.OneToOneField', 'models.OneToOneField', ([], {'auto_created': '(True)', 'on_delete': 'django.db.models.deletion.CASCADE', 'parent_link': '(True)', 'primary_key': '(True)', 'serialize': '(False)', 'to': '"""wagtailcore.Page"""'}), "(auto_created=True, on_delete=django.db.models.deletion\n... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# vim:ts=4:sw=4:expandtab
#
# ==================================================================
#
# Copyright (c) 2016, Parallels IP Holdings GmbH
# Released under the terms of MIT license (see LICENSE for details)
#
# ======================================================... | [
"logging.error",
"logging.debug",
"hookutil.parse_git_log",
"textwrap.wrap",
"hookutil.send_mail",
"re.findall",
"itertools.groupby"
] | [((1182, 1245), 'hookutil.parse_git_log', 'hookutil.parse_git_log', (['self.repo_dir', 'branch', 'old_sha', 'new_sha'], {}), '(self.repo_dir, branch, old_sha, new_sha)\n', (1204, 1245), False, 'import hookutil\n'), ((1608, 1659), 'itertools.groupby', 'itertools.groupby', (['users'], {'key': "(lambda ko: ko['user'])"}),... |
#-------------------------------------------------------------------------------------------------------------------
# Packages & Settings
#-------------------------------------------------------------------------------------------------------------------
# General packages
import time
import sys
import os
import date... | [
"sys.path.append",
"lib.model.Model",
"os.listdir",
"shutil.rmtree"
] | [((1006, 1044), 'sys.path.append', 'sys.path.append', (['"""/home/rettenls/code"""'], {}), "('/home/rettenls/code')\n", (1021, 1044), False, 'import sys\n'), ((1849, 1867), 'os.listdir', 'os.listdir', (['folder'], {}), '(folder)\n', (1859, 1867), False, 'import os\n'), ((2096, 2114), 'os.listdir', 'os.listdir', (['fold... |
import mysql.connector
mydb = mysql.connector.connect(
host="localhost",
user="root",
password="",
database="PUCCR"
)
mycursor = mydb.cursor()
#mycursor.execute("SELECT * FROM users")
#myresult = mycursor.fetchall()
#for x in myresult:
# print(x)
import sys, os, dlib, glob, numpy
import cv2
from skimage i... | [
"os.path.basename",
"dlib.face_recognition_model_v1",
"numpy.array",
"dlib.get_frontal_face_detector",
"dlib.shape_predictor",
"os.path.join",
"skimage.io.imread"
] | [((354, 386), 'dlib.get_frontal_face_detector', 'dlib.get_frontal_face_detector', ([], {}), '()\n', (384, 386), False, 'import sys, os, dlib, glob, numpy\n'), ((602, 638), 'dlib.shape_predictor', 'dlib.shape_predictor', (['predictor_path'], {}), '(predictor_path)\n', (622, 638), False, 'import sys, os, dlib, glob, nump... |
"""
Affine `n` space over a ring
"""
#*****************************************************************************
# Copyright (C) 2006 <NAME> <<EMAIL>>
#
# Distributed under the terms of the GNU General Public License (GPL)
#
# http://www.gnu.org/licenses/
#***********************************... | [
"sage.schemes.affine.affine_point.SchemeMorphism_point_affine",
"sage.structure.category_object.normalize_names",
"sage.schemes.generic.ambient_space.AmbientSpace.__init__",
"sage.schemes.affine.affine_subscheme.AlgebraicScheme_subscheme_affine",
"sage.schemes.affine.affine_homset.SchemeHomset_points_affine... | [((920, 928), 'sage.categories.fields.Fields', 'Fields', ([], {}), '()\n', (926, 928), False, 'from sage.categories.fields import Fields\n'), ((36739, 36850), 'sage.misc.persist.register_unpickle_override', 'register_unpickle_override', (['"""sage.schemes.generic.affine_space"""', '"""AffineSpace_generic"""', 'AffineSp... |
# Copyright 2017 IBM
#
# 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, software
... | [
"devstack.dsconf.LocalConf",
"fixtures.TempDir"
] | [((2212, 2240), 'devstack.dsconf.LocalConf', 'dsconf.LocalConf', (['self._path'], {}), '(self._path)\n', (2228, 2240), False, 'from devstack import dsconf\n'), ((2434, 2462), 'devstack.dsconf.LocalConf', 'dsconf.LocalConf', (['self._path'], {}), '(self._path)\n', (2450, 2462), False, 'from devstack import dsconf\n'), (... |
from flask_restplus import Namespace, Resource, fields
from flask_login import current_user
api = Namespace("checkout", description="Checkout related operations")
cart = api.model(
"CartLine",
{
"id": fields.Integer(required=True, description="The checkout cartline id"),
"quantity": fields.In... | [
"flask_restplus.fields.Float",
"flask_restplus.fields.String",
"flask_restplus.Namespace",
"flask_restplus.fields.Integer"
] | [((100, 164), 'flask_restplus.Namespace', 'Namespace', (['"""checkout"""'], {'description': '"""Checkout related operations"""'}), "('checkout', description='Checkout related operations')\n", (109, 164), False, 'from flask_restplus import Namespace, Resource, fields\n'), ((220, 289), 'flask_restplus.fields.Integer', 'f... |
from __future__ import unicode_literals
import collections
from django.utils.encoding import force_text
from rest_framework.compat import OrderedDict, unicode_to_repr
class ReturnDict(OrderedDict):
"""
Return object from `serialier.data` for the `Serializer` class.
Includes a backlink to the serializer... | [
"rest_framework.compat.OrderedDict",
"rest_framework.compat.unicode_to_repr",
"django.utils.encoding.force_text"
] | [((2131, 2231), 'rest_framework.compat.unicode_to_repr', 'unicode_to_repr', (["('<%s value=%s errors=%s>' % (self.__class__.__name__, self.value, self.errors)\n )"], {}), "('<%s value=%s errors=%s>' % (self.__class__.__name__, self.\n value, self.errors))\n", (2146, 2231), False, 'from rest_framework.compat impor... |
# --------------------------------------------------------
# Flow-Guided Feature Aggregation
# Copyright (c) 2017 Microsoft
# Licensed under The MIT License [see LICENSE for details]
# Written by <NAME>
# --------------------------------------------------------
"""
given a imagenet vid imdb, compute mAP
"""
import nu... | [
"xml.etree.ElementTree.parse",
"numpy.sum",
"numpy.maximum",
"numpy.zeros",
"cPickle.load",
"numpy.argsort",
"numpy.cumsum",
"numpy.min",
"numpy.where",
"numpy.array",
"os.path.isfile",
"cPickle.dump",
"numpy.max",
"numpy.finfo",
"numpy.concatenate"
] | [((619, 637), 'xml.etree.ElementTree.parse', 'ET.parse', (['filename'], {}), '(filename)\n', (627, 637), True, 'import xml.etree.ElementTree as ET\n'), ((1799, 1834), 'numpy.concatenate', 'np.concatenate', (['([0.0], rec, [1.0])'], {}), '(([0.0], rec, [1.0]))\n', (1813, 1834), True, 'import numpy as np\n'), ((1844, 188... |
#!/usr/bin/env python
#
# Copyright 2020, Data61, CSIRO (ABN 41 687 119 230)
#
# SPDX-License-Identifier: BSD-2-Clause
#
from __future__ import absolute_import, division, print_function, \
unicode_literals
import unittest
from capdl import ELF
from tests import CapdlTestCase
class TestElf(CapdlTestCase):
... | [
"unittest.main",
"capdl.ELF"
] | [((1270, 1285), 'unittest.main', 'unittest.main', ([], {}), '()\n', (1283, 1285), False, 'import unittest\n'), ((354, 384), 'capdl.ELF', 'ELF', (['"""resources/arm-hello.bin"""'], {}), "('resources/arm-hello.bin')\n", (357, 384), False, 'from capdl import ELF\n'), ((507, 538), 'capdl.ELF', 'ELF', (['"""resources/ia32-h... |
# lshash/lshash.py
# Copyright 2012 <NAME> (a.k.a <NAME>) and contributors (see CONTRIBUTORS.txt)
#
# This module is part of lshash and is released under
# the MIT License: http://www.opensource.org/licenses/mit-license.php
# wiki:https://yongyuan.name/blog/ann-search.html
import os
import json
import numpy as np
fr... | [
"storage.storage",
"numpy.load",
"json.loads",
"numpy.random.randn",
"numpy.asarray",
"os.path.isfile",
"numpy.mean",
"numpy.array",
"numpy.savez_compressed",
"numpy.dot",
"bitarray.bitarray"
] | [((4758, 4805), 'numpy.random.randn', 'np.random.randn', (['self.hash_size', 'self.input_dim'], {}), '(self.hash_size, self.input_dim)\n', (4773, 4805), True, 'import numpy as np\n'), ((12575, 12593), 'numpy.dot', 'np.dot', (['diff', 'diff'], {}), '(diff, diff)\n', (12581, 12593), True, 'import numpy as np\n'), ((12780... |
# -*- coding: utf-8 -*-
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import numpy as np
import unittest
from network import TargetNetwork, Network
class TargetNetworkTest(unittest.TestCase):
def test_init(self):
np.random.seed(seed=0)
... | [
"unittest.main",
"network.TargetNetwork",
"numpy.random.seed"
] | [((829, 844), 'unittest.main', 'unittest.main', ([], {}), '()\n', (842, 844), False, 'import unittest\n'), ((292, 314), 'numpy.random.seed', 'np.random.seed', ([], {'seed': '(0)'}), '(seed=0)\n', (306, 314), True, 'import numpy as np\n'), ((340, 355), 'network.TargetNetwork', 'TargetNetwork', ([], {}), '()\n', (353, 35... |
# Python3 program to print DFS traversal
from collections import defaultdict
# This class represents a directed graph using
# adjacency list representation
class Graph:
# Constructor
def __init__(self):
# default dictionary to store graph
self.graph = defaultdict(list)
... | [
"collections.defaultdict"
] | [((295, 312), 'collections.defaultdict', 'defaultdict', (['list'], {}), '(list)\n', (306, 312), False, 'from collections import defaultdict\n')] |
from mpvr.datamodule.manager import Manager as dm
from mpvr.utils.process import *
from scipy.signal import savgol_filter
import numpy as np
import pandas as pd
dm = dm.from_config(dm.section_list()[1])
max_val = 0
for scenario in dm.get_scenarios():
dm.set_scenario(scenario)
df = dm.get_processed_data('mpe')... | [
"numpy.abs",
"mpvr.datamodule.manager.Manager.fig_finalize",
"mpvr.datamodule.manager.Manager.get_incidence_data",
"numpy.arange",
"mpvr.datamodule.manager.Manager.get_scenarios",
"mpvr.datamodule.manager.Manager.set_scenario",
"mpvr.datamodule.manager.Manager.section_list",
"mpvr.datamodule.manager.M... | [((233, 251), 'mpvr.datamodule.manager.Manager.get_scenarios', 'dm.get_scenarios', ([], {}), '()\n', (249, 251), True, 'from mpvr.datamodule.manager import Manager as dm\n'), ((463, 481), 'mpvr.datamodule.manager.Manager.get_scenarios', 'dm.get_scenarios', ([], {}), '()\n', (479, 481), True, 'from mpvr.datamodule.manag... |
"""
Read agg.pt
"""
import sys
import torch
if __name__ == '__main__':
if len(sys.argv) != 2:
quit("Usage: python read_results.py <log_directory>")
fn = 'logs/' + sys.argv[1] + '/agg.pt'
d = torch.load(fn)
print(len(d['test_mll_epoch']))
for i, epoch in enumerate(d['test_mll_epoch']):
valid_mll = d['valid... | [
"torch.load"
] | [((201, 215), 'torch.load', 'torch.load', (['fn'], {}), '(fn)\n', (211, 215), False, 'import torch\n')] |
# -*- coding: UTF-8 -*-
# A part of NonVisual Desktop Access (NVDA)
# Copyright (C) 2006-2017 NV Access Limited, <NAME>, <NAME>
# This file is covered by the GNU General Public License.
# See the file COPYING for more details.
import locale
from collections import OrderedDict
import threading
import time
imp... | [
"logHandler.log.warning",
"logHandler.log.debug",
"synthDriverHandler.VoiceInfo",
"nvwave.outputDeviceNameToID",
"audioDucking.isAudioDuckingSupported",
"NVDAHelper.localLib.dllImportTableHooks_unhookSingle",
"synthDriverHandler.synthIndexReached.notify",
"weakref.ref",
"synthDriverHandler.SynthDriv... | [((2203, 2229), 'audioDucking.AudioDucker', 'audioDucking.AudioDucker', ([], {}), '()\n', (2227, 2229), False, 'import audioDucking\n'), ((2615, 2653), 'audioDucking.isAudioDuckingSupported', 'audioDucking.isAudioDuckingSupported', ([], {}), '()\n', (2651, 2653), False, 'import audioDucking\n'), ((3591, 3646), 'synthDr... |
"""
File: 349.py
Title: Intersection of Two Arrays
Difficulty: Easy
URL: https://leetcode.com/problems/intersection-of-two-arrays/
"""
import unittest
from typing import List
class Solution:
def intersection(self, nums1: List[int], nums2: List[int]) -> List[int]:
return list(set(nums1).i... | [
"unittest.main"
] | [((905, 920), 'unittest.main', 'unittest.main', ([], {}), '()\n', (918, 920), False, 'import unittest\n')] |
from __future__ import absolute_import
from ..base import BaseObj, FieldMeta, Context
import six
import copy
class BaseObj_v1_2(BaseObj):
__swagger_version__ = '1.2'
class Items(six.with_metaclass(FieldMeta, BaseObj_v1_2)):
""" Items Object
"""
__swagger_fields__ = {
'$ref': No... | [
"six.with_metaclass"
] | [((196, 239), 'six.with_metaclass', 'six.with_metaclass', (['FieldMeta', 'BaseObj_v1_2'], {}), '(FieldMeta, BaseObj_v1_2)\n', (214, 239), False, 'import six\n'), ((1291, 1334), 'six.with_metaclass', 'six.with_metaclass', (['FieldMeta', 'BaseObj_v1_2'], {}), '(FieldMeta, BaseObj_v1_2)\n', (1309, 1334), False, 'import si... |
from setuptools import setup, find_packages
import os
setup(
# Needed to silence warnings (and to be a worthwhile package)
name='Livy-Submit',
url='https://github.com/gdiepen/livy-submit',
author='<NAME>',
author_email='<EMAIL>',
# Needed to actually package something
packages=find_packages... | [
"setuptools.find_packages"
] | [((307, 322), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (320, 322), False, 'from setuptools import setup, find_packages\n')] |