code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
#!/usr/bin/env python
""" runsinglehap.py - Module to control processing of single-visit mosaics
:License: :doc:`LICENSE`
USAGE:
>>> runsinglehap [-cdl] inputFilename
- The '-c' option allows the user to specify a customized configuration JSON file which has been tuned for
specialized processing. Thi... | [
"drizzlepac.hapsequencer.run_hap_processing",
"stsci.tools.logutil.create_logger",
"argparse.ArgumentParser"
] | [((1666, 1798), 'stsci.tools.logutil.create_logger', 'logutil.create_logger', (['__name__'], {'level': 'logutil.logging.NOTSET', 'stream': 'sys.stdout', 'format': 'SPLUNK_MSG_FORMAT', 'datefmt': 'MSG_DATEFMT'}), '(__name__, level=logutil.logging.NOTSET, stream=sys.\n stdout, format=SPLUNK_MSG_FORMAT, datefmt=MSG_DAT... |
#!/usr/bin/python
# Copyright 2020 The KNIX Authors
#
# 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 appl... | [
"json.dumps",
"logging_helpers.setup_logger",
"LocalQueueClientMessage.LocalQueueClientMessage",
"os.path.join",
"json.loads",
"os.path.exists",
"process_utils.terminate_and_wait_child",
"socket.gethostname",
"LocalQueueClient.LocalQueueClient",
"requests.get",
"logging_helpers.setup_fluentbit_a... | [((1344, 1371), 'py3utils.ensure_long', 'py3utils.ensure_long', (['(60000)'], {}), '(60000)\n', (1364, 1371), False, 'import py3utils\n'), ((842, 895), 'os.path.join', 'os.path.join', (['sys.path[0]', '"""../FunctionWorker/python"""'], {}), "(sys.path[0], '../FunctionWorker/python')\n", (854, 895), False, 'import os\n'... |
# Copyright (c) 2019 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... | [
"yaml.load",
"yaml.dump",
"ppdet.core.workspace.get_registered_modules",
"re.sub"
] | [((2805, 2829), 'ppdet.core.workspace.get_registered_modules', 'get_registered_modules', ([], {}), '()\n', (2827, 2829), False, 'from ppdet.core.workspace import get_registered_modules\n'), ((5134, 5195), 'yaml.dump', 'yaml.dump', (['styled'], {'default_flow_style': '(False)', 'default_style': '""""""'}), "(styled, def... |
import sys
import argparse
from os.path import join, abspath, dirname
sys.path.append(dirname(dirname(join(abspath(__file__)))))
from map import generate
NODES_RANGE = [8, 8]
COST_RANGE = [10, 500]
OBJECTS_RANGE = [4, 4]
OCCURRENCES_RANGE = [1, 4]
if __name__ == "__main__":
parser = argparse.ArgumentParser()
... | [
"os.path.abspath",
"argparse.ArgumentParser",
"map.generate"
] | [((291, 316), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (314, 316), False, 'import argparse\n'), ((475, 549), 'map.generate', 'generate', (['fname', 'NODES_RANGE', 'COST_RANGE', 'OBJECTS_RANGE', 'OCCURRENCES_RANGE'], {}), '(fname, NODES_RANGE, COST_RANGE, OBJECTS_RANGE, OCCURRENCES_RANGE)\... |
import sys
sys.path.append('/usr/lib/python3.6/site-packages/')
import argparse
import base64
from datetime import datetime
import os
import shutil
import numpy as np
import socketio
import eventlet.wsgi
from PIL import Image
from flask import Flask
from io import BytesIO
from keras.models import load_model
from util... | [
"sys.path.append",
"keras.models.load_model",
"socketio.Middleware",
"utils.parse_position",
"numpy.load",
"argparse.ArgumentParser",
"os.makedirs",
"socketio.Server",
"flask.Flask",
"numpy.asarray",
"os.path.exists",
"base64.b64decode",
"datetime.datetime.utcnow",
"shutil.rmtree",
"util... | [((11, 63), 'sys.path.append', 'sys.path.append', (['"""/usr/lib/python3.6/site-packages/"""'], {}), "('/usr/lib/python3.6/site-packages/')\n", (26, 63), False, 'import sys\n'), ((369, 386), 'socketio.Server', 'socketio.Server', ([], {}), '()\n', (384, 386), False, 'import socketio\n'), ((393, 408), 'flask.Flask', 'Fla... |
from prol import db
#from sqlalchemy.ext.mutable import MutableDict
class Goal(db.Model):
id = db.Column(db.Integer,primary_key=True)
goal = db.Column(db.Text)
priority = db.Column(db.String(80))
todo = db.Column(db.Text)
#todo = db.Column(db.PickleType)
#todo = db.Column(db.JsonEncodedDict)
user_id = db.Colu... | [
"prol.db.Column",
"prol.db.String",
"prol.db.ForeignKey"
] | [((98, 137), 'prol.db.Column', 'db.Column', (['db.Integer'], {'primary_key': '(True)'}), '(db.Integer, primary_key=True)\n', (107, 137), False, 'from prol import db\n'), ((145, 163), 'prol.db.Column', 'db.Column', (['db.Text'], {}), '(db.Text)\n', (154, 163), False, 'from prol import db\n'), ((210, 228), 'prol.db.Colum... |
# -*- coding: utf-8 -*-
from mock import patch
from tests import TestCase
from yarn_api_client.node_manager import NodeManager
from yarn_api_client.errors import IllegalArgumentError
@patch('yarn_api_client.node_manager.NodeManager.request')
class NodeManagerTestCase(TestCase):
def setUp(self):
self.nm =... | [
"yarn_api_client.node_manager.NodeManager",
"mock.patch"
] | [((187, 244), 'mock.patch', 'patch', (['"""yarn_api_client.node_manager.NodeManager.request"""'], {}), "('yarn_api_client.node_manager.NodeManager.request')\n", (192, 244), False, 'from mock import patch\n'), ((321, 345), 'yarn_api_client.node_manager.NodeManager', 'NodeManager', (['"""localhost"""'], {}), "('localhost... |
import pypika.terms
from pypika import *
from pypika import Field
from pypika.utils import ignore_copy
from frappe.query_builder.terms import ParameterizedFunction, ParameterizedValueWrapper
from frappe.query_builder.utils import (
Column,
DocType,
get_query_builder,
patch_query_aggregation,
patch_query_execute,
... | [
"pypika.Field"
] | [((592, 613), 'pypika.Field', 'Field', (['x'], {'table': 'table'}), '(x, table=table)\n', (597, 613), False, 'from pypika import Field\n'), ((684, 705), 'pypika.Field', 'Field', (['x'], {'table': 'table'}), '(x, table=table)\n', (689, 705), False, 'from pypika import Field\n')] |
import json
f = open('FlyMission.json','r+')
l = json.load(f)
print(l)
| [
"json.load"
] | [((50, 62), 'json.load', 'json.load', (['f'], {}), '(f)\n', (59, 62), False, 'import json\n')] |
# This file is used to configure the behavior of pytest when using the Astropy
# test infrastructure. It needs to live inside the package in order for it to
# get picked up when running the tests inside an interpreter using
# packagename.test
from copy import copy
import numpy as np
import pytest
from astropy import ... | [
"numpy.random.seed",
"astropy.modeling.models.Linear1D",
"numpy.random.randn",
"astropy.modeling.models.Gaussian1D",
"importlib.util.find_spec",
"specutils.spectra.Spectrum1D",
"copy.copy",
"numpy.random.random",
"numpy.linspace",
"pytest_astropy_header.display.PYTEST_HEADER_MODULES.pop"
] | [((845, 886), 'pytest_astropy_header.display.PYTEST_HEADER_MODULES.pop', 'PYTEST_HEADER_MODULES.pop', (['"""Pandas"""', 'None'], {}), "('Pandas', None)\n", (870, 886), False, 'from pytest_astropy_header.display import PYTEST_HEADER_MODULES, TESTED_VERSIONS\n'), ((2986, 3013), 'numpy.linspace', 'np.linspace', (['(0.4)',... |
'''
Deep Q-learning approach to the cartpole problem
using OpenAI's gym environment.
As part of the basic series on reinforcement learning @
https://github.com/vmayoral/basic_reinforcement_learning
Inspired by https://github.com/VinF/deer
@author: <NAME> <<EMAIL>>
'''
import gym
import random
import pandas
... | [
"deer.experiment.base_controllers.LearningRateController",
"numpy.argmax",
"keras.models.Model",
"numpy.arange",
"keras.layers.Input",
"keras.layers.Reshape",
"deer.experiment.base_controllers.InterleavedTestEpochController",
"keras.optimizers.SGD",
"deer.experiment.base_controllers.TrainerControlle... | [((15309, 15348), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (15328, 15348), False, 'import logging\n'), ((15398, 15434), 'deer.default_parser.process_args', 'process_args', (['sys.argv[1:]', 'Defaults'], {}), '(sys.argv[1:], Defaults)\n', (15410, 15434), Fa... |
#!/usr/bin/env python
import sys
sys.exit(0)
| [
"sys.exit"
] | [((34, 45), 'sys.exit', 'sys.exit', (['(0)'], {}), '(0)\n', (42, 45), False, 'import sys\n')] |
from Agent import Agent
from Gaussian_Reward import Gaussian_Reward
from erdos_renyl_model_without_duplicate import MAMAB
import matplotlib.pyplot as plt
import numpy as np
from math import sqrt, log
import networkx as nx
no_iterations = 20000
no_agents = 5
no_bandits = 20
#mean = [5.2, 4.1, 9.5, 2.... | [
"numpy.flip",
"networkx.erdos_renyi_graph",
"matplotlib.pyplot.close",
"numpy.argsort",
"Gaussian_Reward.Gaussian_Reward",
"matplotlib.pyplot.figure",
"numpy.array",
"erdos_renyl_model_without_duplicate.MAMAB",
"numpy.add",
"matplotlib.pyplot.subplots"
] | [((1089, 1105), 'numpy.argsort', 'np.argsort', (['mean'], {}), '(mean)\n', (1099, 1105), True, 'import numpy as np\n'), ((1119, 1145), 'numpy.flip', 'np.flip', (['maxi_mean'], {'axis': '(0)'}), '(maxi_mean, axis=0)\n', (1126, 1145), True, 'import numpy as np\n'), ((1387, 1423), 'matplotlib.pyplot.subplots', 'plt.subplo... |
# -*- coding: utf-8 -*-
"""
ctypes type universe.
"""
from __future__ import print_function, division, absolute_import
import ctypes
from numba.typesystem.itypesystem import consing, tyname
from numba.typesystem import universe
from numba.typesystem import numbatypes as ts
domain_name = "ctypes"
# _______________... | [
"ctypes.CFUNCTYPE",
"numba.typesystem.itypesystem.consing",
"numba.typesystem.itypesystem.tyname",
"ctypes.POINTER"
] | [((1601, 1650), 'numba.typesystem.itypesystem.consing', 'consing', (['(lambda base_type, size: base_type * size)'], {}), '(lambda base_type, size: base_type * size)\n', (1608, 1650), False, 'from numba.typesystem.itypesystem import consing, tyname\n'), ((1406, 1442), 'ctypes.CFUNCTYPE', 'ctypes.CFUNCTYPE', (['rettype',... |
import time
from PyQt5.QtCore import QTimer, pyqtSignal
from PyQt5.QtGui import QPixmap, QFont
from PyQt5.QtWidgets import QMainWindow, QDialog, QApplication, QLabel
from lsl.mbl_lsl_receiver import MBL_LSLReceiver
from visuals.gui import Ui_MainWindow
from threading import Thread
class MBL_GuiWindow(QMainWindow):
... | [
"PyQt5.QtCore.pyqtSignal",
"PyQt5.QtWidgets.QLabel",
"PyQt5.QtCore.QTimer",
"lsl.mbl_lsl_receiver.MBL_LSLReceiver",
"visuals.gui.Ui_MainWindow",
"PyQt5.QtGui.QFont",
"time.time",
"PyQt5.QtGui.QPixmap"
] | [((435, 450), 'visuals.gui.Ui_MainWindow', 'Ui_MainWindow', ([], {}), '()\n', (448, 450), False, 'from visuals.gui import Ui_MainWindow\n'), ((542, 559), 'lsl.mbl_lsl_receiver.MBL_LSLReceiver', 'MBL_LSLReceiver', ([], {}), '()\n', (557, 559), False, 'from lsl.mbl_lsl_receiver import MBL_LSLReceiver\n'), ((615, 626), 't... |
import os
import glob
import pickle
import zipfile
import warnings
import numpy as np
import pandas as pd
from urllib import request
def trim_eol_whitespace(data_file):
with open(data_file, 'r') as f:
lines = f.readlines()
lines = [line.replace(' \n', '\n') for line in lines]
with open(data_file, ... | [
"numpy.random.uniform",
"os.mkdir",
"pickle.dump",
"numpy.abs",
"os.remove",
"zipfile.ZipFile",
"numpy.float32",
"os.path.exists",
"urllib.request.urlretrieve",
"numpy.sin",
"os.path.splitext",
"numpy.linspace",
"warnings.warn",
"os.path.join"
] | [((6613, 6655), 'numpy.random.uniform', 'np.random.uniform', (['(0)', '(10)'], {'size': 'num_samples'}), '(0, 10, size=num_samples)\n', (6630, 6655), True, 'import numpy as np\n'), ((6832, 6856), 'numpy.linspace', 'np.linspace', (['(-4)', '(14)', '(250)'], {}), '(-4, 14, 250)\n', (6843, 6856), True, 'import numpy as np... |
# -*- coding: utf-8 -*-
# Define your item pipelines here
#
# Don't forget to add your pipeline to the ITEM_PIPELINES setting
# See: http://doc.scrapy.org/en/latest/topics/item-pipeline.html
import subprocess
import scrapy.pipelines.files
from scrapy.exceptions import DropItem
import os
import scrapy
import errno
SY... | [
"os.mkdir",
"os.unlink",
"scrapy.Request",
"os.getcwd",
"os.path.dirname",
"subprocess.call",
"scrapy.exceptions.DropItem",
"os.path.join"
] | [((644, 692), 'subprocess.call', 'subprocess.call', (["['del', '/Q', path]"], {'shell': '(True)'}), "(['del', '/Q', path], shell=True)\n", (659, 692), False, 'import subprocess\n'), ((1044, 1120), 'subprocess.call', 'subprocess.call', (["([symchk_path, '/r', path, '/s', sym_path] + output_dir_args)"], {}), "([symchk_pa... |
import folium
VANCOUVER = (49.2511587, -123.1344104)
def vancouver():
m = folium.Map(location=VANCOUVER, zoom_start=12)
| [
"folium.Map"
] | [((80, 125), 'folium.Map', 'folium.Map', ([], {'location': 'VANCOUVER', 'zoom_start': '(12)'}), '(location=VANCOUVER, zoom_start=12)\n', (90, 125), False, 'import folium\n')] |
#!/usr/bin/env python
# coding: utf-8
# In[1]:
# import tensorflow as tf
import tensorflow.keras.backend as K
from tensorflow.keras.models import Sequential, Model
import cv2
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
# In[2]:
path_all_tfrecord = "fp56.tfrecord"
# In[3]:
dir_fro... | [
"numpy.fmax",
"fp_tensorflow.create_vgg_5y_model",
"numpy.argmax",
"pandas.read_csv",
"matplotlib.pyplot.axes",
"numpy.ones",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.tight_layout",
"floorplan_analysis.read_mono_from_image_unicode",
"cv2.cvtColor",
"matplotlib.pyplot.imshow",
"numpy.cums... | [((598, 619), 'fp_tensorflow.create_vgg_5y_model', 'create_vgg_5y_model', ([], {}), '()\n', (617, 619), False, 'from fp_tensorflow import create_vgg_5y_model\n'), ((1659, 1693), 'numpy.loadtxt', 'np.loadtxt', (['"""biclust_col.txt"""', 'int'], {}), "('biclust_col.txt', int)\n", (1669, 1693), True, 'import numpy as np\n... |
#!/usr/bin/env python
#
# <NAME> <<EMAIL>>
#
from __future__ import print_function
standalone = True
import unittestX as unittest
import journal
debug = journal.debug( "scattererxml_TestCase" )
warning = journal.warning( "scattererxml_TestCase" )
scattererxml = 'scatterers/fccNi/Ni-scatterer-SQEkernel.xml'
cla... | [
"os.remove",
"journal.debug",
"mccomponents.sample.kernelxml.parse_file",
"unittestX.main",
"os.path.exists",
"unittestX.makeSuite",
"mccomponents.sample.kernelxml.render",
"os.path.isfile",
"journal.warning",
"unittestX.TestSuite"
] | [((158, 196), 'journal.debug', 'journal.debug', (['"""scattererxml_TestCase"""'], {}), "('scattererxml_TestCase')\n", (171, 196), False, 'import journal\n'), ((209, 249), 'journal.warning', 'journal.warning', (['"""scattererxml_TestCase"""'], {}), "('scattererxml_TestCase')\n", (224, 249), False, 'import journal\n'), (... |
from sklearn import linear_model as lm
import scipy
import numpy as np
import pandas as pd
from skorecard.utils import convert_sparse_matrix
from sklearn.utils.validation import check_is_fitted
class LogisticRegression(lm.LogisticRegression):
"""Extended Logistic Regression.
Extends [sklearn.linear_model.Log... | [
"pandas.DataFrame",
"numpy.ones",
"sklearn.utils.validation.check_is_fitted",
"numpy.product",
"numpy.linalg.inv",
"numpy.array",
"numpy.diag",
"skorecard.utils.convert_sparse_matrix"
] | [((4592, 4616), 'skorecard.utils.convert_sparse_matrix', 'convert_sparse_matrix', (['X'], {}), '(X)\n', (4613, 4616), False, 'from skorecard.utils import convert_sparse_matrix\n'), ((5146, 5175), 'numpy.product', 'np.product', (['predProbs'], {'axis': '(1)'}), '(predProbs, axis=1)\n', (5156, 5175), True, 'import numpy ... |
import os
import unittest
from imdetector.image import SuspiciousImage
from imdetector.clipping import Clipping
DIR = os.getcwd()
class TestClipping(unittest.TestCase):
def test_paintout1(self):
expected = 1
img1 = SuspiciousImage(os.path.join(DIR, 'test/image/yrc_5_po.png'))
detector = ... | [
"os.getcwd",
"unittest.main",
"os.path.join",
"imdetector.clipping.Clipping"
] | [((120, 131), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (129, 131), False, 'import os\n'), ((796, 811), 'unittest.main', 'unittest.main', ([], {}), '()\n', (809, 811), False, 'import unittest\n'), ((320, 330), 'imdetector.clipping.Clipping', 'Clipping', ([], {}), '()\n', (328, 330), False, 'from imdetector.clipping i... |
import FWCore.ParameterSet.Config as cms
METSignificanceParams = cms.PSet(
# jet resolutions
jetThreshold = cms.double(15),
#jet-lepton matching dR
dRMatch = cms.double(0.4),
# eta bins for jet resolution tuning
jeta = cms.vdouble(0.8, 1.3, 1.9, 2.5),
# tuning parame... | [
"FWCore.ParameterSet.Config.double",
"FWCore.ParameterSet.Config.vdouble"
] | [((122, 136), 'FWCore.ParameterSet.Config.double', 'cms.double', (['(15)'], {}), '(15)\n', (132, 136), True, 'import FWCore.ParameterSet.Config as cms\n'), ((191, 206), 'FWCore.ParameterSet.Config.double', 'cms.double', (['(0.4)'], {}), '(0.4)\n', (201, 206), True, 'import FWCore.ParameterSet.Config as cms\n'), ((265, ... |
from django.conf.urls import include, url
from rest_framework import routers
from .views import LinkViewSet, DownloadView, IndexView
router = routers.DefaultRouter()
router.register(r'', LinkViewSet, base_name='files')
urlpatterns = [
url(r'^files/', include(router.urls)),
url(r'^files/(?P<pk>\d+)/download/(... | [
"django.conf.urls.include",
"rest_framework.routers.DefaultRouter"
] | [((144, 167), 'rest_framework.routers.DefaultRouter', 'routers.DefaultRouter', ([], {}), '()\n', (165, 167), False, 'from rest_framework import routers\n'), ((258, 278), 'django.conf.urls.include', 'include', (['router.urls'], {}), '(router.urls)\n', (265, 278), False, 'from django.conf.urls import include, url\n')] |
#!/usr/bin/env python
#http://code.activestate.com/recipes/528878-ordered-set/
import weakref
class oset(object):
"""
A linked-list with a uniqueness constraint and O(1) lookups/removal.
Modification during iteration is partially supported. If you
remove the just yielded element, it will go on to w... | [
"weakref.ref",
"doctest.testmod"
] | [((6355, 6372), 'doctest.testmod', 'doctest.testmod', ([], {}), '()\n', (6370, 6372), False, 'import doctest\n'), ((5309, 5327), 'weakref.ref', 'weakref.ref', (['value'], {}), '(value)\n', (5320, 5327), False, 'import weakref\n')] |
"""
Implements deep maxent IRL (Wulfmeier et. all) in a general, feature-type
agnostic way.
"""
import sys
import random
from pathlib import Path
import torch
import torch.nn as nn
import torch.nn.functional as F
from torch.optim import Adam
from tensorboardX import SummaryWriter
sys.path.insert(0, "..")
from neural_n... | [
"irlmethods.irlUtils.play_features",
"torch.stack",
"rlmethods.rlutils.play_complete",
"random.sample",
"sys.path.insert",
"utils.DataTable",
"irlmethods.irlUtils.monotonic_regularizer",
"torch.cat",
"torch.exp",
"pathlib.Path",
"torch.cuda.is_available",
"torch.max",
"irlmethods.irlUtils.lc... | [((282, 306), 'sys.path.insert', 'sys.path.insert', (['(0)', '""".."""'], {}), "(0, '..')\n", (297, 306), False, 'import sys\n'), ((553, 578), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {}), '()\n', (576, 578), False, 'import torch\n'), ((760, 794), 'torch.nn.Linear', 'nn.Linear', (['state_dims', 'hidde... |
"""
Provides concrete tools for dealing with two of the most useful types of surfaces we have
"""
import numpy as np
from collections import namedtuple
from McUtils.GaussianInterface import GaussianLogReader, GaussianFChkReader
from McUtils.Zachary import Surface, MultiSurface, InterpolatedSurface, TaylorSeriesSurface... | [
"McUtils.GaussianInterface.GaussianFChkReader",
"numpy.asarray",
"numpy.floor",
"numpy.transpose",
"McUtils.Zachary.Surface",
"numpy.argsort",
"numpy.product",
"McUtils.GaussianInterface.GaussianLogReader",
"numpy.array",
"collections.namedtuple",
"numpy.diff",
"numpy.where"
] | [((1430, 1459), 'numpy.array', 'np.array', (['parse_data[keys[1]]'], {}), '(parse_data[keys[1]])\n', (1438, 1459), True, 'import numpy as np\n'), ((3252, 3279), 'numpy.floor', 'np.floor', (['(scan_coords / tol)'], {}), '(scan_coords / tol)\n', (3260, 3279), True, 'import numpy as np\n'), ((5657, 5679), 'numpy.asarray',... |
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch import from_numpy
from collections import namedtuple
import pandas as pd
Action = namedtuple('Action', ['position', 'action'])
Perspective = namedtuple('Perspective', ['perspective', 'position... | [
"torch.cat",
"collections.namedtuple",
"torch.from_numpy"
] | [((209, 253), 'collections.namedtuple', 'namedtuple', (['"""Action"""', "['position', 'action']"], {}), "('Action', ['position', 'action'])\n", (219, 253), False, 'from collections import namedtuple\n'), ((269, 323), 'collections.namedtuple', 'namedtuple', (['"""Perspective"""', "['perspective', 'position']"], {}), "('... |
#
# Copyright: 2017 Red Hat, Inc.
# Author: <NAME> <<EMAIL>>
#
# 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 t... | [
"whitfield.ast.ARG.parseString",
"whitfield.ast.FLD.parseString",
"whitfield.ast.FNC.parseString",
"whitfield.ast.ASN.parseString",
"whitfield.ast.BDY.parseString",
"whitfield.ast.EXP.parseString",
"whitfield.ast.WHT.parseString",
"whitfield.ast.HEX.parseString",
"whitfield.ast.NUM.parseString",
"... | [((5402, 5434), 'pytest.mark.parametrize', 'mark.parametrize', (['"""tst,exp"""', 'hex'], {}), "('tst,exp', hex)\n", (5418, 5434), False, 'from pytest import mark\n'), ((5508, 5540), 'pytest.mark.parametrize', 'mark.parametrize', (['"""tst,exp"""', 'dec'], {}), "('tst,exp', dec)\n", (5524, 5540), False, 'from pytest im... |
import cases.templates.flying_wings as wings
import sharpy.sharpy_main
aero_type = 'lin'
ws = wings.Goland(M=4,
N=12,
Mstar_fact=10,
u_inf=50,
alpha=1.,
rho=1.225,
sweep=0,
physical_time=2,
... | [
"cases.templates.flying_wings.Goland"
] | [((95, 282), 'cases.templates.flying_wings.Goland', 'wings.Goland', ([], {'M': '(4)', 'N': '(12)', 'Mstar_fact': '(10)', 'u_inf': '(50)', 'alpha': '(1.0)', 'rho': '(1.225)', 'sweep': '(0)', 'physical_time': '(2)', 'n_surfaces': '(2)', 'route': '"""cases"""', 'case_name': "('goland_' + aero_type + '_newsolver_pred')"}),... |
import pyaudio
import wave
import os
import numpy as np
from sys import byteorder
from array import array
#CHUNK = 1024
CHUNK = 2048
FORMAT = pyaudio.paInt16
CHANNELS = 1
#RATE = 44100
RATE = 16000
RECORD_SECONDS = 10
WAVE_OUTPUT_FILENAME = "output.wav"
p = pyaudio.PyAudio()
stream = p.open(format=FORMAT,
... | [
"wave.open",
"os.system",
"array.array",
"pyaudio.PyAudio"
] | [((262, 279), 'pyaudio.PyAudio', 'pyaudio.PyAudio', ([], {}), '()\n', (277, 279), False, 'import pyaudio\n'), ((526, 536), 'array.array', 'array', (['"""h"""'], {}), "('h')\n", (531, 536), False, 'from array import array\n'), ((905, 942), 'wave.open', 'wave.open', (['WAVE_OUTPUT_FILENAME', '"""wb"""'], {}), "(WAVE_OUTP... |
# -*- coding: utf-8 -*-
from __future__ import print_function
import logging
import re
import unicodedata
from website import settings
logger = logging.getLogger(__name__)
if settings.SEARCH_ANALYZER == settings.SEARCH_ANALYZER_JAPANESE:
DEFAULT_OPERATOR = 'AND'
else:
DEFAULT_OPERATOR = 'OR'
TITLE_WEIGHT = ... | [
"unicodedata.normalize",
"re.sub",
"re.match",
"logging.getLogger"
] | [((146, 173), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (163, 173), False, 'import logging\n'), ((2408, 2478), 're.sub', 're.sub', (['"""(?P<ES>[+\\\\-=&|!(){}\\\\[\\\\]^"~*?:\\\\\\\\/])"""', '"""\\\\\\\\\\\\g<ES>"""', 'text'], {}), '(\'(?P<ES>[+\\\\-=&|!(){}\\\\[\\\\]^"~*?:\\\\\\\\/... |
from flask import current_app
from werkzeug.local import LocalProxy
if False:
import flask_taxonomies.api
current_flask_taxonomies = LocalProxy( # type: flask_taxonomies.api.Api
lambda: current_app.extensions['flask-taxonomies'])
| [
"werkzeug.local.LocalProxy"
] | [((139, 202), 'werkzeug.local.LocalProxy', 'LocalProxy', (["(lambda : current_app.extensions['flask-taxonomies'])"], {}), "(lambda : current_app.extensions['flask-taxonomies'])\n", (149, 202), False, 'from werkzeug.local import LocalProxy\n')] |
# coding=utf-8
# Copyright 2021 The Edward2 Authors.
#
# 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... | [
"jax.random.PRNGKey",
"jax.numpy.reshape",
"jax.numpy.transpose",
"jax.numpy.tile",
"jax.random.normal",
"jax.numpy.einsum",
"flax.linen.initializers.variance_scaling",
"jax.numpy.expand_dims",
"jax.numpy.matmul",
"flax.linen.initializers.uniform",
"jax.numpy.broadcast_to",
"functools.partial"... | [((1946, 1989), 'flax.linen.initializers.uniform', 'nn.initializers.uniform', ([], {'scale': '(2.0 * jnp.pi)'}), '(scale=2.0 * jnp.pi)\n', (1969, 1989), True, 'import flax.linen as nn\n'), ((2315, 2401), 'flax.linen.initializers.variance_scaling', 'nn.initializers.variance_scaling', ([], {'scale': '(2.0)', 'mode': '"""... |
# Copyright 2020 Silicon Compiler Authors. All Rights Reserved.
import os
import sys
import multiprocessing
import siliconcompiler
import time
# Shared setup routine
def run_design(design, M, job):
chip = siliconcompiler.Chip(loglevel='INFO')
chip.set('design', design)
chip.add('source', design+'.v')
... | [
"multiprocessing.Process",
"siliconcompiler.Chip",
"time.time"
] | [((212, 249), 'siliconcompiler.Chip', 'siliconcompiler.Chip', ([], {'loglevel': '"""INFO"""'}), "(loglevel='INFO')\n", (232, 249), False, 'import siliconcompiler\n'), ((905, 916), 'time.time', 'time.time', ([], {}), '()\n', (914, 916), False, 'import time\n'), ((1059, 1070), 'time.time', 'time.time', ([], {}), '()\n', ... |
import json
import os
import pint
from . import _ureg
from .data import nist
from .state import State, StateRegistry
from .transition import Transition, TransitionRegistry
_directory = os.path.dirname(os.path.realpath(__file__))
_periodic_table = os.path.join(_directory, "data", "PeriodicTableJSON.json")
with open(_... | [
"os.path.realpath",
"json.load",
"os.path.join"
] | [((250, 308), 'os.path.join', 'os.path.join', (['_directory', '"""data"""', '"""PeriodicTableJSON.json"""'], {}), "(_directory, 'data', 'PeriodicTableJSON.json')\n", (262, 308), False, 'import os\n'), ((204, 230), 'os.path.realpath', 'os.path.realpath', (['__file__'], {}), '(__file__)\n', (220, 230), False, 'import os\... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
@author: <NAME>
@email: <EMAIL>
@time: 2021/12/12 22:30
"""
from typing import Any, Callable, Dict, List, Optional
from urllib import parse
from requests import Response, Session
from mussel.scheme.api import Interface
class MakeRequest(object):
def __init__(s... | [
"requests.Session",
"urllib.parse.urljoin"
] | [((438, 447), 'requests.Session', 'Session', ([], {}), '()\n', (445, 447), False, 'from requests import Response, Session\n'), ((1398, 1437), 'urllib.parse.urljoin', 'parse.urljoin', (['self.host', 'interface.url'], {}), '(self.host, interface.url)\n', (1411, 1437), False, 'from urllib import parse\n')] |
from urllib.parse import quote_plus
from openai import api_requestor, error, util
from openai.openai_object import OpenAIObject
class APIResource(OpenAIObject):
api_prefix = ""
@classmethod
def retrieve(cls, id, api_key=None, request_id=None, **params):
instance = cls(id, api_key, **params)
... | [
"urllib.parse.quote_plus",
"openai.api_requestor.APIRequestor",
"openai.util.convert_to_openai_object"
] | [((1556, 1570), 'urllib.parse.quote_plus', 'quote_plus', (['id'], {}), '(id)\n', (1566, 1570), False, 'from urllib.parse import quote_plus\n'), ((2008, 2119), 'openai.api_requestor.APIRequestor', 'api_requestor.APIRequestor', (['api_key'], {'api_version': 'api_version', 'organization': 'organization', 'api_base': 'api_... |
from shutil import move
import glob, os
original_path = "training"
all_paths = sorted(glob.glob(original_path+'/*'))
if not os.path.exists("ImageSets"):
os.makedirs("ImageSets")
write_txt_flag = 1
for path_item in all_paths:
items = sorted(glob.glob(path_item + '/*'))
target_path_item = path_item.replace('... | [
"os.path.exists",
"os.makedirs",
"glob.glob"
] | [((87, 118), 'glob.glob', 'glob.glob', (["(original_path + '/*')"], {}), "(original_path + '/*')\n", (96, 118), False, 'import glob, os\n'), ((125, 152), 'os.path.exists', 'os.path.exists', (['"""ImageSets"""'], {}), "('ImageSets')\n", (139, 152), False, 'import glob, os\n'), ((158, 182), 'os.makedirs', 'os.makedirs', ... |
# Copyright (C) 2018-2021 Intel Corporation
# SPDX-License-Identifier: Apache-2.0
import argparse
import shutil
from pathlib import Path
def copy_images(input_dir: Path, output_dir: Path):
"""
Copy images from doxygen xml folder to sphinx folder
"""
output_dir.mkdir(parents=True, exist_ok=True)
e... | [
"argparse.ArgumentParser",
"shutil.copy"
] | [((554, 579), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (577, 579), False, 'import argparse\n'), ((497, 526), 'shutil.copy', 'shutil.copy', (['file', 'output_dir'], {}), '(file, output_dir)\n', (508, 526), False, 'import shutil\n')] |
import FWCore.ParameterSet.Config as cms
from DQMOffline.JetMET.jetMETDQMCleanup_cff import *
from DQMOffline.JetMET.metDiagnosticParameterSet_cfi import *
from DQMOffline.JetMET.metDiagnosticParameterSetMiniAOD_cfi import *
#jet corrector defined in jetMETDQMOfflineSource python file
pfCandidateDQMAnalyzer = cms.ED... | [
"FWCore.ParameterSet.Config.string",
"FWCore.ParameterSet.Config.double",
"FWCore.ParameterSet.Config.untracked.string",
"FWCore.ParameterSet.Config.untracked.bool",
"FWCore.ParameterSet.Config.int32",
"FWCore.ParameterSet.Config.bool",
"FWCore.ParameterSet.Config.InputTag"
] | [((370, 400), 'FWCore.ParameterSet.Config.untracked.string', 'cms.untracked.string', (['"""PFCand"""'], {}), "('PFCand')\n", (390, 400), True, 'import FWCore.ParameterSet.Config as cms\n'), ((425, 457), 'FWCore.ParameterSet.Config.InputTag', 'cms.InputTag', (['"""particleFlow"""', '""""""'], {}), "('particleFlow', '')\... |
from flask import Blueprint
auth = Blueprint("auth", __name__, url_prefix="/user")
from bolo.auth import endpoints | [
"flask.Blueprint"
] | [((36, 83), 'flask.Blueprint', 'Blueprint', (['"""auth"""', '__name__'], {'url_prefix': '"""/user"""'}), "('auth', __name__, url_prefix='/user')\n", (45, 83), False, 'from flask import Blueprint\n')] |
from cvdatasetutils.dnnutils import load_json
import os
import pandas as pd
ANNOTATION_FOLDER = 'annotations'
INSTANCES_FILE = 'instances_train2017.json'
def parse_labels(instances):
return { category['id']: category['name'] for category in instances['categories']}
def parse_images(instances):
def to_arra... | [
"os.path.join"
] | [((902, 965), 'os.path.join', 'os.path.join', (['self.base_path', 'ANNOTATION_FOLDER', 'INSTANCES_FILE'], {}), '(self.base_path, ANNOTATION_FOLDER, INSTANCES_FILE)\n', (914, 965), False, 'import os\n')] |
"""Send command to iTerm2 active tab."""
import os
import sys
import json
import shlex
import AppKit
import iterm2
FILE, *ARGS = sys.argv
TAB_ID_FILENAME = os.path.join(os.path.dirname(FILE), 'tabs_id.json')
def _launch_iterm(_id): # type: (dict) -> None
"""Launch Iterm2 if is not running already.
Args:
... | [
"AppKit.NSWorkspace.sharedWorkspace",
"json.dump",
"iterm2.async_get_app",
"json.load",
"iterm2.Window.async_create",
"os.path.basename",
"shlex.join",
"os.path.dirname",
"AppKit.NSRunningApplication.runningApplicationsWithBundleIdentifier_",
"iterm2.run_until_complete"
] | [((2973, 3010), 'iterm2.run_until_complete', 'iterm2.run_until_complete', (['main', '(True)'], {}), '(main, True)\n', (2998, 3010), False, 'import iterm2\n'), ((172, 193), 'os.path.dirname', 'os.path.dirname', (['FILE'], {}), '(FILE)\n', (187, 193), False, 'import os\n'), ((2002, 2032), 'os.path.basename', 'os.path.bas... |
from django.shortcuts import render, redirect
from .forms import EmployeeForm
from .models import Employee
# Create your views here.
def employee_list(request):
context = {'employee_list': Employee.objects.all()}
return render(request, "employee_register/employee_list.html", context)
def employee... | [
"django.shortcuts.render",
"django.shortcuts.redirect"
] | [((240, 304), 'django.shortcuts.render', 'render', (['request', '"""employee_register/employee_list.html"""', 'context'], {}), "(request, 'employee_register/employee_list.html', context)\n", (246, 304), False, 'from django.shortcuts import render, redirect\n'), ((985, 1011), 'django.shortcuts.redirect', 'redirect', (['... |
import json
from django.core.urlresolvers import reverse
import pytest
pytestmark = pytest.mark.django_db
from seahub.options.models import UserOptions
from seahub.test_utils import BaseTestCase
class LibrariesTest(BaseTestCase):
def setUp(self):
self.url = reverse('libraries')
from constance imp... | [
"seahub.options.models.UserOptions.objects.is_user_guide_enabled",
"seahub.options.models.UserOptions.objects.get_default_repo",
"django.core.urlresolvers.reverse"
] | [((273, 293), 'django.core.urlresolvers.reverse', 'reverse', (['"""libraries"""'], {}), "('libraries')\n", (280, 293), False, 'from django.core.urlresolvers import reverse\n'), ((478, 524), 'seahub.options.models.UserOptions.objects.get_default_repo', 'UserOptions.objects.get_default_repo', (['username'], {}), '(userna... |
from _pytest.fixtures import fixture
import pytest
from ..nway_callback import NWayCallback
from pytest_mock import mocker
from mock import patch, call
from mock import MagicMock
from icecream import ic
class mock_model:
def __init__(self):
pass
def predict_on_batch(*args, **kwargs):
return True
c... | [
"mock.call.predict_on_batch",
"pytest.mark.parametrize",
"mock.MagicMock",
"pytest.raises"
] | [((947, 986), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""count"""', '[128]'], {}), "('count', [128])\n", (970, 986), False, 'import pytest\n'), ((988, 1024), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""freq"""', '[7]'], {}), "('freq', [7])\n", (1011, 1024), False, 'import pytest\n'), ((... |
from whatthefood.graph.node import Node
from collections.abc import Sequence
import numpy as np
class Grad(Node):
def __init__(self, y, xs):
self.unwrap = False
if not isinstance(xs, Sequence):
xs = [xs]
self.unwrap = True
self.outputs_graph = self._build_outputs... | [
"numpy.ones_like"
] | [((805, 833), 'numpy.ones_like', 'np.ones_like', (['values[self.y]'], {}), '(values[self.y])\n', (817, 833), True, 'import numpy as np\n')] |
from collections import OrderedDict
from .objects import (
PID_DEFAULT
)
from .widgets import NexPage
from .exceptions import (
NexComponentException,
NexComponentIdException,
NexComponentNameException
)
from .factory import WidgetFactory
class NexComponents:
def __init__(self, nexserial):
... | [
"collections.OrderedDict"
] | [((379, 392), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (390, 392), False, 'from collections import OrderedDict\n'), ((423, 436), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (434, 436), False, 'from collections import OrderedDict\n')] |
from django.db import models
from django.utils.translation import gettext_lazy as _
from wagtail.contrib.settings.models import BaseSetting, register_setting
from wagtail.admin.edit_handlers import FieldPanel
from wagtail.core.fields import RichTextField
@register_setting
class SiteSetting(BaseSetting):
gtm_id = ... | [
"django.db.models.CharField",
"wagtail.admin.edit_handlers.FieldPanel",
"django.utils.translation.gettext_lazy"
] | [((320, 363), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(50)', 'blank': '(True)'}), '(max_length=50, blank=True)\n', (336, 363), False, 'from django.db import models\n'), ((395, 439), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(255)', 'blank': '(True)'}), '(max_l... |
from iota import Iota, Seed
from pprint import pprint
import time
# Put your seed from Tutorial 4.a here
my_seed = Seed(b'YOURSEEDFROMTHEPREVIOUSTUTORIAL99999999999999999999999999999999999999999999999999')
# Declare an API object
api = Iota(
adapter='https://nodes.devnet.iota.org:443',
seed=my_seed,
testn... | [
"iota.Seed",
"pprint.pprint",
"iota.Iota",
"time.sleep"
] | [((116, 216), 'iota.Seed', 'Seed', (["b'YOURSEEDFROMTHEPREVIOUSTUTORIAL99999999999999999999999999999999999999999999999999'"], {}), "(\n b'YOURSEEDFROMTHEPREVIOUSTUTORIAL99999999999999999999999999999999999999999999999999'\n )\n", (120, 216), False, 'from iota import Iota, Seed\n'), ((238, 315), 'iota.Iota', 'Iota'... |
# Generated by Django 3.0.5 on 2020-05-06 13:38
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('Entradas', '0003_auto_20200506_1352'),
]
operations = [
migrations.AddField(
model_name='entradas_blog',
name='contr... | [
"django.db.models.CharField"
] | [((342, 400), 'django.db.models.CharField', 'models.CharField', ([], {'default': '"""<PASSWORD>aseña"""', 'max_length': '(10)'}), "(default='<PASSWORD>aseña', max_length=10)\n", (358, 400), False, 'from django.db import migrations, models\n')] |
from datetime import datetime, timedelta
import pytest
from utils import (
get_permissions_for_group,
PermissionsMissing,
get_os_config,
get_params_for_region,
get_stackset_state_data,
update_stackset,
get_owned_stacksets,
CrossAccountStackSetException,
get_instance_details,
)
def... | [
"utils.get_os_config",
"utils.get_instance_details",
"utils.get_stackset_state_data",
"utils.get_params_for_region",
"utils.get_permissions_for_group",
"utils.update_stackset",
"pytest.raises",
"datetime.timedelta",
"utils.get_owned_stacksets",
"datetime.datetime.now",
"pytest.mark.xfail"
] | [((4022, 4142), 'pytest.mark.xfail', 'pytest.mark.xfail', ([], {'reason': '"""Cloudformation StackSet instance mocking in moto lacks depth to simulate this test"""'}), "(reason=\n 'Cloudformation StackSet instance mocking in moto lacks depth to simulate this test'\n )\n", (4039, 4142), False, 'import pytest\n'), ... |
# -*- coding: utf-8 -*-
# Copyright 2022, SERTIT-ICube - France, https://sertit.unistra.fr/
# This file is part of eoreader project
# https://github.com/sertit/eoreader
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may ob... | [
"eoreader.bands.to_str",
"eoreader.exceptions.InvalidTypeError",
"sertit.rasters.vectorize",
"eoreader.exceptions.InvalidProductError",
"geopandas.GeoDataFrame",
"sertit.rasters.read_bit_array",
"sertit.files.get_archived_rio_path",
"logging.getLogger",
"eoreader.utils.read"
] | [((1732, 1764), 'logging.getLogger', 'logging.getLogger', (['EOREADER_NAME'], {}), '(EOREADER_NAME)\n', (1749, 1764), False, 'import logging\n'), ((11220, 11284), 'geopandas.GeoDataFrame', 'gpd.GeoDataFrame', ([], {'geometry': 'footprint.geometry', 'crs': 'footprint.crs'}), '(geometry=footprint.geometry, crs=footprint.... |
from mongoengine import DynamicDocument, Document, StringField, ReferenceField, ListField, IntField, DateTimeField, BooleanField, DictField
from datetime import datetime
from Models.User import User
from Models.Dataset import Dataset
class AgriWatchView(DynamicDocument):
author = ReferenceField(User, required=Tru... | [
"mongoengine.StringField",
"mongoengine.ReferenceField",
"datetime.datetime.now"
] | [((287, 322), 'mongoengine.ReferenceField', 'ReferenceField', (['User'], {'required': '(True)'}), '(User, required=True)\n', (301, 322), False, 'from mongoengine import DynamicDocument, Document, StringField, ReferenceField, ListField, IntField, DateTimeField, BooleanField, DictField\n'), ((393, 431), 'mongoengine.Refe... |
# -*- coding: utf-8 -*-
# Copyright 2020 <NAME>
#
# Licensed under the Apache License, Version 2.0 (the "License").
# You may not use this file except in compliance with the License.
# A copy of the License is located at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# or in the "license" file accompanying th... | [
"aws_lambda_powertools.logging.Logger",
"ask_sdk_core.utils.get_slot_value",
"uuid.uuid4",
"ask_sdk_core.utils.is_intent_name",
"aws_lambda_powertools.tracing.Tracer",
"ask_sdk_model.dialog.delegate_directive.DelegateDirective",
"ask_sdk_core.utils.get_dialog_state",
"ask_sdk_model.er.dynamic.EntityVa... | [((1364, 1410), 'aws_lambda_powertools.logging.Logger', 'Logger', ([], {'service': '"""Favorite line intent handler"""'}), "(service='Favorite line intent handler')\n", (1370, 1410), False, 'from aws_lambda_powertools.logging import Logger\n'), ((1420, 1466), 'aws_lambda_powertools.tracing.Tracer', 'Tracer', ([], {'ser... |
__author__ = 'andrewapperley'
import database
from sqlalchemy import exc
from video import FlaggedVideoModel, VideoFavourite
import sys
from boto.s3.connection import S3Connection, Bucket, Key
from datetime import datetime
import calendar
def process(access_key=None, secret_key=None, bucket_name=None, video_path=Non... | [
"database.DBSession",
"boto.s3.connection.Bucket",
"database.createDatabase",
"datetime.datetime.utcnow",
"boto.s3.connection.S3Connection"
] | [((743, 779), 'boto.s3.connection.S3Connection', 'S3Connection', (['ACCESS_KEY', 'SECRET_KEY'], {}), '(ACCESS_KEY, SECRET_KEY)\n', (755, 779), False, 'from boto.s3.connection import S3Connection, Bucket, Key\n'), ((800, 838), 'boto.s3.connection.Bucket', 'Bucket', (['aws_s3_connection', 'BUCKET_NAME'], {}), '(aws_s3_co... |
# -*- coding: utf-8 -*-
# Generated by Django 1.10.5 on 2017-03-09 08:20
from __future__ import unicode_literals
from django.db import migrations
def update_price_calculator(apps, schema_editor):
PaymentMethod = apps.get_model("payment", "PaymentMethod")
for payment_method in PaymentMethod.objects.all():
... | [
"django.db.migrations.RunPython"
] | [((625, 670), 'django.db.migrations.RunPython', 'migrations.RunPython', (['update_price_calculator'], {}), '(update_price_calculator)\n', (645, 670), False, 'from django.db import migrations\n')] |
import os
import time
import shutil
import numpy as np
import tensorflow as tf
from config import cfg
import mynet
from VRDatasetC import NpDataset
size = cfg.TRAIN.INPUT_SIZE
inputs = tf.keras.Input(shape=(size, size,1))
imgDeconv, imgLab = mynet.Mynet(inputs)
model = tf.keras.Model(inputs, [imgDeconv, imgLab])
keras... | [
"tensorflow.nn.l2_loss",
"tensorflow.keras.losses.mean_squared_error",
"shutil.rmtree",
"tensorflow.print",
"tensorflow.keras.Input",
"os.path.exists",
"tensorflow.reduce_mean",
"tensorflow.keras.Model",
"tensorflow.cast",
"tensorflow.stack",
"tensorflow.keras.optimizers.Adam",
"mynet.Mynet",
... | [((186, 223), 'tensorflow.keras.Input', 'tf.keras.Input', ([], {'shape': '(size, size, 1)'}), '(shape=(size, size, 1))\n', (200, 223), True, 'import tensorflow as tf\n'), ((243, 262), 'mynet.Mynet', 'mynet.Mynet', (['inputs'], {}), '(inputs)\n', (254, 262), False, 'import mynet\n'), ((271, 314), 'tensorflow.keras.Model... |
# Generated by Django 3.1.7 on 2021-07-26 11:22
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
("eventreg", "0001_initial"),
]
operations = [
migrations.AlterField(
model_name="eventuserdata",
name="studentName",
... | [
"django.db.models.CharField"
] | [((338, 369), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(50)'}), '(max_length=50)\n', (354, 369), False, 'from django.db import migrations, models\n'), ((502, 533), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(12)'}), '(max_length=12)\n', (518, 533), False, 'from ... |
import datetime
import pandas as pd
import numpy as np
import subprocess
import pickle
from numpy import array
import seaborn as sn
import tensorflow as tf
import matplotlib.pyplot as plt
#combining predicitions and generating plot for pred. representation
def predict(data):
with open('rolf.pickle', 'rb') as hand... | [
"matplotlib.pyplot.title",
"matplotlib.pyplot.savefig",
"tensorflow.keras.models.load_model",
"pandas.DataFrame.from_dict",
"numpy.zeros",
"pickle.load",
"numpy.array",
"numpy.arange",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"numpy.unique"
] | [((394, 422), 'pandas.DataFrame.from_dict', 'pd.DataFrame.from_dict', (['data'], {}), '(data)\n', (416, 422), True, 'import pandas as pd\n'), ((634, 669), 'tensorflow.keras.models.load_model', 'tf.keras.models.load_model', (['"""model"""'], {}), "('model')\n", (660, 669), True, 'import tensorflow as tf\n'), ((681, 709)... |
import ast
import argparse
import logging
import warnings
import os
import json
import glob
import subprocess
import sys
import boto3
import pickle
import pandas as pd
from collections import Counter
from timeit import default_timer as timer
import numpy as np
import seaborn as sns
import matplotlib.pyplot as plt
impo... | [
"matplotlib.pyplot.title",
"sklearn.metrics.confusion_matrix",
"pickle.dump",
"seaborn.heatmap",
"argparse.ArgumentParser",
"autogluon.TabularPrediction.fit",
"pandas.read_csv",
"sklearn.metrics.classification_report",
"matplotlib.pyplot.figure",
"itertools.cycle",
"os.path.join",
"pandas.set_... | [((358, 383), 'warnings.catch_warnings', 'warnings.catch_warnings', ([], {}), '()\n', (381, 383), False, 'import warnings\n'), ((389, 451), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {'category': 'DeprecationWarning'}), "('ignore', category=DeprecationWarning)\n", (412, 451), False, 'impor... |
'''
Adjusted Kapre Spectrogram and Melspectrogram classes which don't
apply range compression in the case that melgram=True
'''
from kapre.time_frequency import Spectrogram, Melspectrogram
#from __future__ import absolute_import
import numpy as np
from keras import backend as K
def amplitude_to_decibel(x, amin=... | [
"keras.backend.dot",
"keras.backend.sqrt",
"numpy.log",
"keras.backend.floatx",
"keras.backend.maximum",
"keras.backend.permute_dimensions"
] | [((2148, 2187), 'keras.backend.dot', 'K.dot', (['power_spectrogram', 'self.freq2mel'], {}), '(power_spectrogram, self.freq2mel)\n', (2153, 2187), True, 'from keras import backend as K\n'), ((636, 646), 'keras.backend.floatx', 'K.floatx', ([], {}), '()\n', (644, 646), True, 'from keras import backend as K\n'), ((1897, 1... |
# Generated by Django 3.1.2 on 2020-11-05 05:59
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
migrations.swappable_dependency(settings.AUTH_USER_MODEL),
]
ope... | [
"django.db.models.TextField",
"django.db.migrations.swappable_dependency",
"django.db.models.CharField",
"django.db.models.ForeignKey",
"django.db.models.AutoField"
] | [((247, 304), 'django.db.migrations.swappable_dependency', 'migrations.swappable_dependency', (['settings.AUTH_USER_MODEL'], {}), '(settings.AUTH_USER_MODEL)\n', (278, 304), False, 'from django.db import migrations, models\n'), ((446, 539), 'django.db.models.AutoField', 'models.AutoField', ([], {'auto_created': '(True)... |
# -*- encoding: utf-8 -*-
#
# Copyright (c) 2016 Intel
#
# Authors: <NAME> <<EMAIL>>
#
# 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 ... | [
"watcher.common.service.prepare_service",
"oslo_log.log.getLogger",
"watcher.decision_engine.sync.Syncer"
] | [((807, 830), 'oslo_log.log.getLogger', 'log.getLogger', (['__name__'], {}), '(__name__)\n', (820, 830), False, 'from oslo_log import log\n'), ((905, 944), 'watcher.common.service.prepare_service', 'service.prepare_service', (['sys.argv', 'CONF'], {}), '(sys.argv, CONF)\n', (928, 944), False, 'from watcher.common impor... |
# Copyright (c) Microsoft Corporation.
# Licensed under the MIT license.
"""
LightGBM/Python inferencing script
"""
import os
import sys
import argparse
from lightgbm import Booster, Dataset
from subprocess import PIPE
from subprocess import run as subprocess_run
from subprocess import TimeoutExpired
# let's add the ... | [
"os.makedirs",
"argparse.ArgumentParser",
"os.path.dirname",
"common.metrics.LogTimeBlock",
"os.path.isfile",
"os.path.join"
] | [((398, 423), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (413, 423), False, 'import os\n'), ((1083, 1115), 'argparse.ArgumentParser', 'argparse.ArgumentParser', (['__doc__'], {}), '(__doc__)\n', (1106, 1115), False, 'import argparse\n'), ((2001, 2040), 'os.makedirs', 'os.makedirs', (['arg... |
#!/usr/bin/env python2
# -*- coding: utf-8 -*-
"""
Created on Sun Dec 24 18:01:21 2017
@author: johnkenny
"""
from django.conf.urls import url
from django.conf import settings
from django.conf.urls.static import static
from . import views
#from rest_framework import routers
urlpatterns = [
url(r'^hello',... | [
"django.conf.urls.static.static",
"django.conf.urls.url"
] | [((701, 764), 'django.conf.urls.static.static', 'static', (['settings.STATIC_URL'], {'document_root': 'settings.STATIC_ROOT'}), '(settings.STATIC_URL, document_root=settings.STATIC_ROOT)\n', (707, 764), False, 'from django.conf.urls.static import static\n'), ((306, 358), 'django.conf.urls.url', 'url', (['"""^hello"""',... |
import numpy
import joblib
import json
from azureml.core.model import Model
# from inference_schema.schema_decorators import input_schema, output_schema
def init():
# load the model from file into a global object
global model
# we assume that we have just one model
# AZUREML_MODEL_DIR is an environm... | [
"joblib.load",
"numpy.array",
"json.loads",
"azureml.core.model.Model.get_model_path"
] | [((464, 524), 'azureml.core.model.Model.get_model_path', 'Model.get_model_path', ([], {'model_name': '"""driver_training_model.pkl"""'}), "(model_name='driver_training_model.pkl')\n", (484, 524), False, 'from azureml.core.model import Model\n'), ((546, 569), 'joblib.load', 'joblib.load', (['model_path'], {}), '(model_p... |
from core.db.decorator import query
@query.delete("delete from parse_data_details")
def clear_all():
pass
@query.insert("insert into parse_data_details(pid,binding_key,routing_keys,status) values({pid},{binding_key},"
"{routing_keys},{status})")
def insert_one(pid, binding_key, routing_keys, statu... | [
"core.db.decorator.query.insert",
"core.db.decorator.query.delete"
] | [((39, 85), 'core.db.decorator.query.delete', 'query.delete', (['"""delete from parse_data_details"""'], {}), "('delete from parse_data_details')\n", (51, 85), False, 'from core.db.decorator import query\n'), ((115, 260), 'core.db.decorator.query.insert', 'query.insert', (['"""insert into parse_data_details(pid,binding... |
import subprocess
import yaml
import os
import sys
import shutil
import datetime
from attrdict import AttrDict
import itertools
import atexit
from .utils import save_yaml, load_yaml
import argparse
import kfp
from ray.util.multiprocessing import Pool
import ray.util.multiprocessing
ALL_CONFIGS = []
LOG_DIR = ""
FAILED... | [
"atexit.register",
"subprocess.run",
"os.getpid",
"argparse.ArgumentParser",
"os.makedirs",
"os.path.basename",
"os.path.isdir",
"os.path.realpath",
"os.path.exists",
"datetime.datetime.now",
"ray.util.multiprocessing.Pool",
"kfp.Client",
"attrdict.AttrDict",
"os.path.join",
"os.listdir"... | [((1571, 1595), 'attrdict.AttrDict', 'AttrDict', (['ALL_CONFIGS[0]'], {}), '(ALL_CONFIGS[0])\n', (1579, 1595), False, 'from attrdict import AttrDict\n'), ((2108, 2157), 'shutil.copy', 'shutil.copy', (['config.python_path', 'python_path_copy'], {}), '(config.python_path, python_path_copy)\n', (2119, 2157), False, 'impor... |
import subprocess
from pydantic.main import BaseModel
from morpho.consumer import RestWorkConsumer
from morpho.rest.models import (
PipeService,
TransformDocumentPipeRequest,
TransformDocumentResponse,
)
from morpho.client import Client, ClientConfig
import sys
import pytest
from threading import Thread
fro... | [
"morpho.rest.models.PipeService",
"morpho.client.ClientConfig",
"pytest.fixture",
"time.sleep",
"morpho.client.Client",
"pathlib.Path",
"requests.get",
"requests.post",
"multiprocessing.Process",
"morpho.server.Service"
] | [((1392, 1422), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""module"""'}), "(scope='module')\n", (1406, 1422), False, 'import pytest\n'), ((3744, 3774), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""module"""'}), "(scope='module')\n", (3758, 3774), False, 'import pytest\n'), ((4070, 4156), 'multiproc... |
from nose.tools import eq_
from mock import MagicMock, patch
from bufferapp.models.profile import Profile, PATHS
mocked_response = {
'name': 'me',
'service': 'twiter',
'id': 1
}
def test_profile_schedules_getter():
'''
Test schedules gettering from buffer api
'''
mocked_api = MagicMock()
mocked_ap... | [
"mock.MagicMock",
"nose.tools.eq_",
"bufferapp.models.profile.Profile",
"mock.patch"
] | [((297, 308), 'mock.MagicMock', 'MagicMock', ([], {}), '()\n', (306, 308), False, 'from mock import MagicMock, patch\n'), ((360, 396), 'bufferapp.models.profile.Profile', 'Profile', (['mocked_api', 'mocked_response'], {}), '(mocked_api, mocked_response)\n', (367, 396), False, 'from bufferapp.models.profile import Profi... |
from typing import List
from trescope.config import Config, AnchorType, AnchorCM
from trescope.core.Utils import toListIfNumpyOrTensorArray
class VectorField3DConfig(Config):
"""Config for :py:meth:`trescope.Output.plotVectorField3D`"""
def __init__(self):
super().__init__()
self.__sizeFacto... | [
"trescope.core.Utils.toListIfNumpyOrTensorArray"
] | [((2103, 2139), 'trescope.core.Utils.toListIfNumpyOrTensorArray', 'toListIfNumpyOrTensorArray', (['self.__x'], {}), '(self.__x)\n', (2129, 2139), False, 'from trescope.core.Utils import toListIfNumpyOrTensorArray\n'), ((2166, 2202), 'trescope.core.Utils.toListIfNumpyOrTensorArray', 'toListIfNumpyOrTensorArray', (['self... |
# -*- coding: utf-8 -*-
from south.utils import datetime_utils as datetime
from south.db import db
from south.v2 import SchemaMigration
from django.db import models
class Migration(SchemaMigration):
def forwards(self, orm):
# Adding field 'Faq.index'
db.add_column(u'home_faq', 'index',
... | [
"south.db.db.delete_column"
] | [((523, 561), 'south.db.db.delete_column', 'db.delete_column', (['u"""home_faq"""', '"""index"""'], {}), "(u'home_faq', 'index')\n", (539, 561), False, 'from south.db import db\n')] |
# Copyright 2020 <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, softw... | [
"obm.exceptions.NodeError",
"collections.defaultdict",
"aiohttp.BasicAuth"
] | [((1896, 1941), 'aiohttp.BasicAuth', 'aiohttp.BasicAuth', (['rpc_username', 'rpc_password'], {}), '(rpc_username, rpc_password)\n', (1913, 1941), False, 'import aiohttp\n'), ((5481, 5509), 'obm.exceptions.NodeError', 'exceptions.NodeError', (['errors'], {}), '(errors)\n', (5501, 5509), False, 'from obm import exception... |
#! /usr/bin/env python3
"""
Option parser and the main function
"""
from __future__ import print_function, absolute_import
import argparse
from trashtalk.generate_trashs import generate_trashs
import sys
from trashtalk.tools import print_files
__all__ = ["trashtalk"]
def parse_option(args=None):
parser = argpars... | [
"trashtalk.generate_trashs.generate_trashs",
"argparse.ArgumentParser"
] | [((313, 380), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Taking out your trash easily"""'}), "(description='Taking out your trash easily')\n", (336, 380), False, 'import argparse\n'), ((2784, 2843), 'trashtalk.generate_trashs.generate_trashs', 'generate_trashs', (['options.u', 'optio... |
import paho.mqtt.client as mqtt
from store_Sensor_data import sensor_Data_Handler
# MQTT Settings
MQTT_Broker = "192.168.127.12"
MQTT_Port = 1883
Keep_Alive_Interval = 45
MQTT_Topic = "Home/Control"
#Subscribe to all Sensors at Base Topic
def on_connect(mosq, obj, rc):
mqttc.subscribe(MQTT_Topic, 0)
#Save ... | [
"paho.mqtt.client.Client",
"store_Sensor_data.sensor_Data_Handler"
] | [((485, 498), 'paho.mqtt.client.Client', 'mqtt.Client', ([], {}), '()\n', (496, 498), True, 'import paho.mqtt.client as mqtt\n'), ((374, 417), 'store_Sensor_data.sensor_Data_Handler', 'sensor_Data_Handler', (['msg.topic', 'msg.payload'], {}), '(msg.topic, msg.payload)\n', (393, 417), False, 'from store_Sensor_data impo... |
import frontend as fe
import backend as be
import sys
#Does the transactions and saves the summary in separate files
#filename - unique name for each summary file
#actions - list of actions to perform, start with login and ending with logout
#passes transaction summary file back to main
def transactions(filename, act... | [
"backend.main",
"frontend.automatedInput",
"frontend.main"
] | [((2331, 2405), 'backend.main', 'be.main', (['"""master_accounts_file.txt"""', '"""merged_transaction_summary_file.txt"""'], {}), "('master_accounts_file.txt', 'merged_transaction_summary_file.txt')\n", (2338, 2405), True, 'import backend as be\n'), ((2956, 3030), 'backend.main', 'be.main', (['"""master_accounts_file.t... |
# Copyright (C) 2012 Linaro Limited
#
# Author: <NAME> <<EMAIL>>
#
# This file is part of versiontools.
#
# versiontools is free software: you can redistribute it and/or modify
# it under the terms of the GNU Lesser General Public License version 3
# as published by the Free Software Foundation
#
# versiontoo... | [
"versiontools.Version.from_expression"
] | [((4973, 5020), 'versiontools.Version.from_expression', 'versiontools.Version.from_expression', (['self.name'], {}), '(self.name)\n', (5009, 5020), False, 'import versiontools\n')] |
import unittest
from min_max import max, min # noqa
class Tests(unittest.TestCase):
TESTS = {
"1. Basics": [
{'input': "max(3, 2)", 'answer': 3},
{'input': "min(3, 2)", 'answer': 2},
{'input': "max([1, 2, 0, 3, 4])", 'answer': 4},
{'input': "min('hello')",... | [
"unittest.main"
] | [((1836, 1851), 'unittest.main', 'unittest.main', ([], {}), '()\n', (1849, 1851), False, 'import unittest\n')] |
'''modules
SUMMARY OF APIs
l2():
output(theta) --> number
gradient(theta) --> vector
linear():
output(theta, x) --> scores
gradient(x) --> vector
linear_n(num_inputs, num_outputs):
output(theta, x) --> scores
gradient(x) --> vector
negative_likelihood():
output(probs, y) --> ... | [
"module_softmax.softmax",
"module_linear_n.linear_n",
"module_negative_likelihood.negative_likelihood",
"module_linear.linear"
] | [((767, 775), 'module_linear.linear', 'linear', ([], {}), '()\n', (773, 775), False, 'from module_linear import linear\n'), ((780, 790), 'module_linear_n.linear_n', 'linear_n', ([], {}), '()\n', (788, 790), False, 'from module_linear_n import linear_n\n'), ((795, 816), 'module_negative_likelihood.negative_likelihood', ... |
import itertools
from pint import pi_theorem
from pint.testsuite import QuantityTestCase
class TestPiTheorem(QuantityTestCase):
FORCE_NDARRAY = False
def test_simple(self):
# simple movement
with self.capture_log() as buffer:
self.assertEqual(
pi_theorem({"V": "... | [
"pint.pi_theorem",
"itertools.product"
] | [((941, 970), 'itertools.product', 'itertools.product', (['fs', 'fs', 'fs'], {}), '(fs, fs, fs)\n', (958, 970), False, 'import itertools\n'), ((302, 346), 'pint.pi_theorem', 'pi_theorem', (["{'V': 'm/s', 'T': 's', 'L': 'm'}"], {}), "({'V': 'm/s', 'T': 's', 'L': 'm'})\n", (312, 346), False, 'from pint import pi_theorem\... |
#!/usr/bin/env python3
# This file provides an interface between Thunderbird and Cultured
# Code's Things, by implementing the Mozilla native Messaging
# interface and using Apple Script to tell Things what to do.
# Code is derived from
# https://github.com/mdn/webextensions-examples/blob/master/native-messaging/app/... | [
"subprocess.Popen",
"sys.stdin.read",
"json.loads",
"sys.stdout.buffer.flush",
"struct.unpack",
"json.dumps",
"sys.stdin.buffer.read",
"sys.stdout.buffer.write",
"sys.exit"
] | [((849, 868), 'json.loads', 'json.loads', (['message'], {}), '(message)\n', (859, 868), False, 'import json\n'), ((1224, 1273), 'sys.stdout.buffer.write', 'sys.stdout.buffer.write', (["encodedMessage['length']"], {}), "(encodedMessage['length'])\n", (1247, 1273), False, 'import sys\n'), ((1278, 1328), 'sys.stdout.buffe... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#import re
import os
import argparse
import string
import json
import json_schema_generator
from json_schema_generator import Recorder, Validator
def record(args):
if(os.path.isfile(args.json_source)):
rec = Recorder.from_file(args.json_source... | [
"json_schema_generator.Validator.from_path",
"os.mkdir",
"argparse.ArgumentParser",
"json.loads",
"os.path.dirname",
"json_schema_generator.Recorder.from_url",
"os.path.exists",
"json_schema_generator.Recorder.from_file",
"six.moves.urllib.request.urlopen",
"os.path.isfile",
"os.path.join"
] | [((235, 267), 'os.path.isfile', 'os.path.isfile', (['args.json_source'], {}), '(args.json_source)\n', (249, 267), False, 'import os\n'), ((594, 626), 'os.path.isfile', 'os.path.isfile', (['args.json_source'], {}), '(args.json_source)\n', (608, 626), False, 'import os\n'), ((910, 957), 'json_schema_generator.Validator.f... |
import os, os.path, discord
from discord.ext import commands
from colorama import Fore
os.system('cls' if os.name == 'nt' else 'clear')
cleardmtitle()
print(f"""{y}[{w}+{y}]{w} Enter your token""")
token = input(f"""{y}[{b}#{y}]{w} Token: """)
print(f"""\n{y}[{b}#{y}]{w} Write "!clear" in one of your DMs to de... | [
"os.system",
"discord.ext.commands.Bot"
] | [((92, 140), 'os.system', 'os.system', (["('cls' if os.name == 'nt' else 'clear')"], {}), "('cls' if os.name == 'nt' else 'clear')\n", (101, 140), False, 'import os, os.path, discord\n'), ((364, 411), 'discord.ext.commands.Bot', 'commands.Bot', ([], {'command_prefix': '"""!"""', 'self_bot': '(True)'}), "(command_prefix... |
"""The Poincaré ball model."""
import tensorflow as tf
from tensorflow_riemopt.manifolds.manifold import Manifold
from tensorflow_riemopt.manifolds import utils
class Poincare(Manifold):
"""Manifold of `math:`n`-dimensional hyperbolic space as embedded in the
Poincaré ball model.
Nickel, Maximillian, an... | [
"tensorflow.math.tanh",
"tensorflow.reduce_sum",
"tensorflow.clip_by_value",
"tensorflow.random.uniform",
"tensorflow.math.atanh",
"tensorflow.constant",
"tensorflow.ones_like",
"tensorflow.cast",
"tensorflow.math.square",
"tensorflow_riemopt.manifolds.utils.get_eps",
"tensorflow.linalg.norm"
] | [((1041, 1065), 'tensorflow.cast', 'tf.cast', (['self.k', 'x.dtype'], {}), '(self.k, x.dtype)\n', (1048, 1065), True, 'import tensorflow as tf\n'), ((1084, 1128), 'tensorflow.reduce_sum', 'tf.reduce_sum', (['(x * x)'], {'axis': '(-1)', 'keepdims': '(True)'}), '(x * x, axis=-1, keepdims=True)\n', (1097, 1128), True, 'im... |
"""
:class:`.Photon` geocoder.
"""
from geopy.compat import urlencode, string_compare
from geopy.geocoders.base import (
Geocoder,
DEFAULT_FORMAT_STRING,
DEFAULT_TIMEOUT,
DEFAULT_SCHEME
)
from geopy.location import Location
from geopy.util import logger
__all__ = ("Photon", )
class Photon(Geocoder)... | [
"geopy.util.logger.debug",
"geopy.location.Location",
"geopy.compat.urlencode"
] | [((5098, 5158), 'geopy.util.logger.debug', 'logger.debug', (['"""%s.geocode: %s"""', 'self.__class__.__name__', 'url'], {}), "('%s.geocode: %s', self.__class__.__name__, url)\n", (5110, 5158), False, 'from geopy.util import logger\n'), ((6971, 7031), 'geopy.util.logger.debug', 'logger.debug', (['"""%s.reverse: %s"""', ... |
# coding: UTF-8
'''
Created on Jun 17, 2014
@author: hernan
'''
import re
from usig_normalizador_amba.StringDireccion import StringDireccion
from usig_normalizador_amba.Callejero import Callejero
from usig_normalizador_amba.Calle import Calle
from usig_normalizador_amba.Errors import ErrorTextoSinDireccion, ErrorCal... | [
"usig_normalizador_amba.Calle.Calle",
"usig_normalizador_amba.Direccion.Direccion",
"usig_normalizador_amba.commons.matcheaTexto",
"re.finditer",
"usig_normalizador_amba.Errors.ErrorTextoSinDireccion",
"usig_normalizador_amba.Callejero.Callejero",
"usig_normalizador_amba.Errors.ErrorCalleInexistente",
... | [((1367, 1390), 'usig_normalizador_amba.settings.default_settings.copy', 'default_settings.copy', ([], {}), '()\n', (1388, 1390), False, 'from usig_normalizador_amba.settings import default_settings\n'), ((2501, 2527), 'usig_normalizador_amba.StringDireccion.StringDireccion', 'StringDireccion', (['direccion'], {}), '(d... |
import re
import json
import webbrowser
import sublime
import sublime_plugin
import mdpopups
SCOPES = [
"support.function.builtin.scr",
"keyword.control.flow.scr",
"keyword.control.loop.scr",
"keyword.control.scr"
]
VERSION = {
"AA": "Medal of Honor: Allied Assault",
"SH": "Medal of Honor: Al... | [
"re.split",
"sublime.save_settings",
"sublime.decode_value",
"sublime.Region",
"mdpopups.syntax_highlight",
"webbrowser.open_new_tab",
"mdpopups.get_language_from_view",
"sublime.load_settings",
"sublime.set_clipboard",
"sublime.load_resource"
] | [((4518, 4592), 'sublime.load_resource', 'sublime.load_resource', (['"""Packages/MOHAA/tooltips/lang_map.sublime-settings"""'], {}), "('Packages/MOHAA/tooltips/lang_map.sublime-settings')\n", (4539, 4592), False, 'import sublime\n'), ((4722, 4775), 'sublime.load_settings', 'sublime.load_settings', (['"""Preferences.sub... |
from setuptools import find_packages, setup
setup(
name="Klimawatch",
description="Ein Open Data-Plattform zur Darstellung von kommunalen CO2-Emissionen und Schutzkonzepten",
version="0.1.0",
author="<NAME>",
author_email="<EMAIL>",
url="https://klimawatch.de/",
classifiers=[
"Progr... | [
"setuptools.find_packages"
] | [((459, 474), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (472, 474), False, 'from setuptools import find_packages, setup\n')] |
'''
The whole reading model.
CNN + LSTM + A classifier with multinomial distribution.
'''
import torch
from torch import optim
from torch import nn
import torch.nn.functional as F
from torch.distributions import Bernoulli, Categorical
from torchtext import datasets
from torchtext import data
import os
import time
imp... | [
"numpy.random.seed",
"argparse.ArgumentParser",
"torch.distributions.Categorical",
"torchtext.datasets.IMDB.splits",
"torch.manual_seed",
"sklearn.metrics.accuracy_score",
"torch.cuda.manual_seed",
"torch.nn.CrossEntropyLoss",
"torch.nn.functional.softmax",
"torchtext.data.LabelField",
"torch.op... | [((795, 836), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': 'desc'}), '(description=desc)\n', (818, 836), False, 'import argparse\n'), ((1238, 1311), 'torchtext.data.Field', 'data.Field', ([], {'sequential': '(True)', 'tokenize': '"""spacy"""', 'lower': '(True)', 'fix_length': '(400)'}), "(... |
#!/usr/bin/env python3
"""Script to verify if a manual migration to upgrade from CrateDB 0.57 to 1.0
is required.
`blobs.path` filesystem layout changes:
From
<blobs.path>/indices/<indexName>/<shard>/blobs
To
<blobs.path>/nodes/<node_lock>/indices/<indexName>/<shard>/blobs
`path.data` h... | [
"argparse.ArgumentParser",
"doctest.testmod",
"pathlib.Path",
"crate.client.connect",
"re.findall",
"collections.OrderedDict",
"sys.exit"
] | [((2040, 2082), 're.findall', 're.findall', (['"""/nodes/(\\\\d+)/indices/"""', 'path'], {}), "('/nodes/(\\\\d+)/indices/', path)\n", (2050, 2082), False, 'import re\n'), ((6279, 6400), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'prog': '"""migrate.py"""', 'description': '__doc__', 'formatter_class': '... |
""" Read the manually-curated xlink xlsx file and export it to an xlink ontology
:Author: <NAME> <<EMAIL>>
:Date: 2019-08-05
:Copyright: 2019, Karr Lab
:License: MIT
"""
import pandas as pd
from ruamel import yaml
XLSX_PATH = './xlink.xlsx'
YML_PATH = './xlink.yml'
def main():
df = pd.read_excel(XLSX_PATH)
... | [
"pandas.read_excel",
"pandas.isnull",
"ruamel.yaml.YAML"
] | [((292, 316), 'pandas.read_excel', 'pd.read_excel', (['XLSX_PATH'], {}), '(XLSX_PATH)\n', (305, 316), True, 'import pandas as pd\n'), ((1332, 1343), 'ruamel.yaml.YAML', 'yaml.YAML', ([], {}), '()\n', (1341, 1343), False, 'from ruamel import yaml\n'), ((518, 552), 'pandas.isnull', 'pd.isnull', (["row['bond_common_name']... |
# DISTRIBUTION STATEMENT A. Approved for public release: distribution unlimited.
#
# This material is based upon work supported by the Assistant Secretary of Defense for Research and
# Engineering under Air Force Contract No. FA8721-05-C-0002 and/or FA8702-15-D-0001. Any opinions,
# findings, conclusions or recommendat... | [
"h5py.File",
"json.load",
"numpy.copy",
"numpy.asarray",
"numpy.expand_dims",
"pickle.load",
"numpy.array",
"numpy.concatenate",
"torch.from_numpy"
] | [((1444, 1456), 'json.load', 'json.load', (['f'], {}), '(f)\n', (1453, 1456), False, 'import json\n'), ((2111, 2138), 'numpy.asarray', 'np.asarray', (['q_image_indices'], {}), '(q_image_indices)\n', (2121, 2138), True, 'import numpy as np\n'), ((3505, 3552), 'numpy.concatenate', 'np.concatenate', (['[scene_feat, node_f... |
# coding: utf-8
import re
import six
from huaweicloudsdkcore.utils.http_utils import sanitize_for_serialization
class ShowResourceHistoryRequest:
"""
Attributes:
openapi_types (dict): The key is attribute name
and the value is attribute type.
attribute_map (dict):... | [
"huaweicloudsdkcore.utils.http_utils.sanitize_for_serialization",
"six.iteritems",
"sys.setdefaultencoding"
] | [((5413, 5446), 'six.iteritems', 'six.iteritems', (['self.openapi_types'], {}), '(self.openapi_types)\n', (5426, 5446), False, 'import six\n'), ((6431, 6462), 'sys.setdefaultencoding', 'sys.setdefaultencoding', (['"""utf-8"""'], {}), "('utf-8')\n", (6453, 6462), False, 'import sys\n'), ((6489, 6521), 'huaweicloudsdkcor... |
# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except jin compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by appl... | [
"os.getenv"
] | [((843, 880), 'os.getenv', 'os.getenv', (['"""PADDLE_TRAINERS_NUM"""', '"""1"""'], {}), "('PADDLE_TRAINERS_NUM', '1')\n", (852, 880), False, 'import os\n')] |
"""
Create a .csv file that contains the Sentinel-2 values
with the bands as columns and the indivual pixel as rows.
Call script as
python 06_create_full_csv.py DATE LEVEL
with
DATE: date of Sentinel-2 image as YYYYMMDD
LEVEL: processing level of Sentinel-2 image (either L1C or L2A)
"""
import sys
import numpy as... | [
"pandas.DataFrame",
"skimage.io.imread"
] | [((568, 630), 'skimage.io.imread', 'imread', (['f"""data/new_data/{date}_data/{date}_{level}_merged.tif"""'], {}), "(f'data/new_data/{date}_data/{date}_{level}_merged.tif')\n", (574, 630), False, 'from skimage.io import imread\n'), ((1383, 1443), 'pandas.DataFrame', 'pd.DataFrame', ([], {'data': 'data_flat', 'columns':... |
import datetime
from decimal import Decimal
import factory
import pytest
from mquery import HistoryEntry, filter_history, group_history_by_date, read_history
class HistoryEntryFactory(factory.Factory):
class Meta:
model = HistoryEntry
date = factory.Faker("past_date", start_date="-7d")
descript... | [
"factory.Faker",
"mquery.group_history_by_date",
"mquery.filter_history",
"decimal.Decimal",
"datetime.date",
"mquery.read_history"
] | [((263, 307), 'factory.Faker', 'factory.Faker', (['"""past_date"""'], {'start_date': '"""-7d"""'}), "('past_date', start_date='-7d')\n", (276, 307), False, 'import factory\n'), ((326, 363), 'factory.Faker', 'factory.Faker', (['"""sentence"""'], {'nb_words': '(8)'}), "('sentence', nb_words=8)\n", (339, 363), False, 'imp... |
'''
DS1307 RTC drive
Author: shaoziyang
Date: 2018.3
http://www.micropython.org.cn
'''
from micropython import const
DS1307_I2C_ADDRESS = const(104)
DS1307_REG_SECOND = const(0)
DS1307_REG_MINUTE = const(1)
DS1307_REG_HOUR = const(2)
DS1307_REG_WEEKDAY = const(3)
DS1307_REG_DAY = con... | [
"micropython.const"
] | [((160, 170), 'micropython.const', 'const', (['(104)'], {}), '(104)\n', (165, 170), False, 'from micropython import const\n'), ((193, 201), 'micropython.const', 'const', (['(0)'], {}), '(0)\n', (198, 201), False, 'from micropython import const\n'), ((224, 232), 'micropython.const', 'const', (['(1)'], {}), '(1)\n', (229... |
"""Config flow for NuHeat integration."""
import logging
import nuheat
import requests.exceptions
import voluptuous as vol
from homeassistant import config_entries, core, exceptions
from homeassistant.const import (
CONF_PASSWORD,
CONF_USERNAME,
HTTP_BAD_REQUEST,
HTTP_INTERNAL_SERVER_ERROR,
)
from .c... | [
"nuheat.NuHeat",
"voluptuous.Required",
"logging.getLogger"
] | [((420, 447), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (437, 447), False, 'import logging\n'), ((825, 880), 'nuheat.NuHeat', 'nuheat.NuHeat', (['data[CONF_USERNAME]', 'data[CONF_PASSWORD]'], {}), '(data[CONF_USERNAME], data[CONF_PASSWORD])\n', (838, 880), False, 'import nuheat\n'), ... |