code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
from materials_commons.api import get_project_by_id
class MetadataVerification:
def __init__(self):
pass
def verify(self, metadata, apikey):
verified = True
project = get_project_by_id(metadata.project_id, apikey=apikey)
if not project:
print("Could not find projec... | [
"materials_commons.api.get_project_by_id"
] | [((202, 255), 'materials_commons.api.get_project_by_id', 'get_project_by_id', (['metadata.project_id'], {'apikey': 'apikey'}), '(metadata.project_id, apikey=apikey)\n', (219, 255), False, 'from materials_commons.api import get_project_by_id\n')] |
"""
.. warning::
ServerCredentials should not be imported directly from this module as the
organisation may change in the future, please use the :mod:`mbed_cloud.foundation` module to import entities.
Foundation Entity: ServerCredentials
====================================
Entities normally contain methods t... | [
"mbed_cloud.foundation.common.fields.StringField",
"builtins.super",
"mbed_cloud.foundation.common.fields.DateTimeField"
] | [((3182, 3220), 'mbed_cloud.foundation.common.fields.DateTimeField', 'fields.DateTimeField', ([], {'value': 'created_at'}), '(value=created_at)\n', (3202, 3220), False, 'from mbed_cloud.foundation.common import fields\n'), ((3240, 3268), 'mbed_cloud.foundation.common.fields.StringField', 'fields.StringField', ([], {'va... |
import os
import sys
from setuptools import setup
from setuptools.command.test import test as TestCommand
py_version = sys.version_info[:2]
here = os.path.abspath(os.path.dirname(__file__))
PROJECT_NAME = "django-dev-commands"
PROJECT_URL = "https://github.com/ikame/django-dev-commands"
PROJECT_VERSION = "1.1.1"
PR... | [
"setuptools.setup",
"setuptools.command.test.test.finalize_options",
"os.path.join",
"pytest.main",
"os.path.dirname",
"sys.exit"
] | [((885, 1969), 'setuptools.setup', 'setup', ([], {'name': 'PROJECT_NAME', 'version': 'PROJECT_VERSION', 'description': 'PROJECT_DESCRIPTION', 'long_description': 'README', 'author': 'AUTHOR', 'author_email': 'AUTHOR_EMAIL', 'url': 'PROJECT_URL', 'license': '"""MIT"""', 'packages': "['django_dev_commands', 'django_dev_c... |
import itertools
import sys
id_list = [''.join(sorted(x.rstrip())) for x in open(sys.argv[1]).readlines()]
twos = 0
threes = 0
for ids in id_list:
counts = [len(''.join(g)) for k, g in itertools.groupby(ids)]
if 2 in counts:
twos += 1
if 3 in counts:
threes += 1
print(twos * threes)
| [
"itertools.groupby"
] | [((191, 213), 'itertools.groupby', 'itertools.groupby', (['ids'], {}), '(ids)\n', (208, 213), False, 'import itertools\n')] |
""" The file downloads are sent to different threads.
These are the workers that get those requests. """
from io import BytesIO
from threading import Thread
from PIL import Image
import requests
class DownloadWorker(Thread):
""" Download images on a separate thread """
def __init__(self, queue):
Thre... | [
"threading.Thread.__init__",
"io.BytesIO",
"requests.get"
] | [((316, 337), 'threading.Thread.__init__', 'Thread.__init__', (['self'], {}), '(self)\n', (331, 337), False, 'from threading import Thread\n'), ((484, 518), 'requests.get', 'requests.get', (['url'], {'cookies': 'cookies'}), '(url, cookies=cookies)\n', (496, 518), False, 'import requests\n'), ((571, 595), 'io.BytesIO', ... |
'''
Keep track of document and topic priors. Gradient updates performed by Theano.
<NAME>
'''
from functools import reduce
from scipy.special import digamma
import theano
from theano import config
import theano.tensor as T
import numpy as np
import mlp, opt
from _sample import _loglikelihood_marginalizeTopics
... | [
"numpy.random.normal",
"mlp.MLP",
"theano.shared",
"theano.tensor.psi",
"theano.function",
"numpy.ones",
"theano.tensor.sum",
"theano.tensor.matrix",
"opt.AdadeltaOptimizer",
"numpy.array",
"numpy.zeros",
"theano.tensor.cast",
"theano.tensor.set_subtensor",
"opt.SGDOptimizer",
"theano.te... | [((17220, 17241), 'numpy.zeros', 'np.zeros', (['(Cin, Cout)'], {}), '((Cin, Cout))\n', (17228, 17241), True, 'import numpy as np\n'), ((17776, 17792), 'numpy.zeros', 'np.zeros', (['(Z, W)'], {}), '((Z, W))\n', (17784, 17792), True, 'import numpy as np\n'), ((18017, 18044), 'opt.AdadeltaOptimizer', 'opt.AdadeltaOptimize... |
#!/usr/bin/env python3
# encoding: utf-8
"""
Nanoci, a minimalist continuous integration server
:copyright: 2015 <NAME>.
:license: BSD.
"""
import os
from setuptools import setup
import nanoci
DESCRIPTION = 'Minimalist continuous integration server'
setup(name=nanoci.__appname__,
version=nanoci.__version__,
... | [
"setuptools.setup"
] | [((256, 743), 'setuptools.setup', 'setup', ([], {'name': 'nanoci.__appname__', 'version': 'nanoci.__version__', 'description': 'DESCRIPTION', 'author': '"""<NAME>"""', 'author_email': '"""<EMAIL>"""', 'license': 'nanoci.__license__', 'platforms': "['any']", 'url': '"""http://github.com/agateau/nanoci"""', 'install_requ... |
# SPDX-FileCopyrightText: Copyright (c) 2019-2021 <NAME>
#
# SPDX-License-Identifier: MIT
# This is example is for the SparkFun Qwiic Single Twist.
# SparkFun sells these at its website: www.sparkfun.com
# Do you like this library? Help support SparkFun. Buy a board!
# https://www.sparkfun.com/products/15083
"""
... | [
"sparkfun_qwiictwist.Sparkfun_QwiicTwist",
"board.I2C",
"time.sleep",
"sys.exit"
] | [((1215, 1226), 'board.I2C', 'board.I2C', ([], {}), '()\n', (1224, 1226), False, 'import board\n'), ((1258, 1302), 'sparkfun_qwiictwist.Sparkfun_QwiicTwist', 'sparkfun_qwiictwist.Sparkfun_QwiicTwist', (['i2c'], {}), '(i2c)\n', (1297, 1302), False, 'import sparkfun_qwiictwist\n'), ((1501, 1511), 'sys.exit', 'sys.exit', ... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# IkaLog
# ======
# Copyright (C) 2015 <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/L... | [
"os.path.exists",
"numpy.fromstring"
] | [((754, 778), 'os.path.exists', 'os.path.exists', (['filename'], {}), '(filename)\n', (768, 778), False, 'import os\n'), ((893, 932), 'numpy.fromstring', 'np.fromstring', (['img_bytes'], {'dtype': '"""uint8"""'}), "(img_bytes, dtype='uint8')\n", (906, 932), True, 'import numpy as np\n')] |
import FWCore.ParameterSet.Config as cms
#
# tracker
#
from RecoLocalTracker.Configuration.RecoLocalTracker_Cosmics_cff import *
from RecoTracker.Configuration.RecoTrackerP5_cff import *
from RecoVertex.BeamSpotProducer.BeamSpot_cff import *
from RecoTracker.Configuration.RecoTrackerBHM_cff import *
from RecoTracker.D... | [
"FWCore.ParameterSet.Config.Sequence"
] | [((758, 806), 'FWCore.ParameterSet.Config.Sequence', 'cms.Sequence', (['(offlineBeamSpot * trackerlocalreco)'], {}), '(offlineBeamSpot * trackerlocalreco)\n', (770, 806), True, 'import FWCore.ParameterSet.Config as cms\n'), ((819, 846), 'FWCore.ParameterSet.Config.Sequence', 'cms.Sequence', (['calolocalreco'], {}), '(c... |
from concurrent.futures import ThreadPoolExecutor, wait, as_completed
import inspect
from urllib.parse import urljoin, urlsplit, urlparse
from collections import deque
import logging
import sys
import time
import traceback
from tqdm import tqdm
import requests
from bs4 import BeautifulSoup
from .models import Page, J... | [
"traceback.format_tb",
"concurrent.futures.ThreadPoolExecutor",
"tqdm.tqdm",
"time.sleep",
"inspect.isgenerator",
"requests.request"
] | [((571, 614), 'concurrent.futures.ThreadPoolExecutor', 'ThreadPoolExecutor', ([], {'max_workers': 'max_threads'}), '(max_workers=max_threads)\n', (589, 614), False, 'from concurrent.futures import ThreadPoolExecutor, wait, as_completed\n'), ((3070, 3132), 'requests.request', 'requests.request', (['job.method', 'job.url... |
from fusion.points2heatmap import *
from fusion.calcAffine import *
from fusion.warper import warping as warp
import matplotlib.pyplot as plt
from fusion.parts2lms import parts2lms
import time
from tqdm import *
import random
import multiprocessing
import sys
def gammaTrans(img, gamma):
gamma_table = [np.power(x/255... | [
"fusion.parts2lms.parts2lms",
"fusion.warper.warping"
] | [((1946, 1966), 'fusion.parts2lms.parts2lms', 'parts2lms', (['partsList'], {}), '(partsList)\n', (1955, 1966), False, 'from fusion.parts2lms import parts2lms\n'), ((2010, 2050), 'fusion.warper.warping', 'warp', (['img', '(src_pt[:106] * 256)', 'lms[:106]'], {}), '(img, src_pt[:106] * 256, lms[:106])\n', (2014, 2050), T... |
import numpy as np
import pandas as pd
from pathlib import Path
import libs.dirs as dirs
import libs.utils as utils
import libs.dataset_utils as dutils
from libs.index import IndexManager
''' Add FrameHash and FramePath to a interface-style... | [
"libs.index.IndexManager",
"pathlib.Path"
] | [((839, 869), 'libs.index.IndexManager', 'IndexManager', (['sampledIndexPath'], {}), '(sampledIndexPath)\n', (851, 869), False, 'from libs.index import IndexManager\n'), ((369, 391), 'pathlib.Path', 'Path', (['dirs.iter_folder'], {}), '(dirs.iter_folder)\n', (373, 391), False, 'from pathlib import Path\n'), ((457, 479)... |
# Production settings
from Squest.settings.development import *
import os
# update default secret key if provided
from_env_secret_key = os.environ.get('SECRET_KEY', None)
if from_env_secret_key is not None:
SECRET_KEY = from_env_secret_key
DEBUG = False
STATICFILES_DIRS = [
os.path.join(BASE_DIR, '../project-st... | [
"os.path.join",
"os.environ.get"
] | [((136, 170), 'os.environ.get', 'os.environ.get', (['"""SECRET_KEY"""', 'None'], {}), "('SECRET_KEY', None)\n", (150, 170), False, 'import os\n'), ((363, 398), 'os.path.join', 'os.path.join', (['BASE_DIR', '"""../static"""'], {}), "(BASE_DIR, '../static')\n", (375, 398), False, 'import os\n'), ((283, 327), 'os.path.joi... |
#Imports
from scipy.stats import linregress
import matplotlib.pyplot as plt
import numpy as np
import random
import sys
from math import *
from PrimesArray import primes
na = np.array
#Collatz Function
def c(n):
if n % 2 == 0:
return n / 2
else:
return 3 * n + 1
#Collatz Seq... | [
"matplotlib.pyplot.show",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"numpy.array",
"random.random",
"matplotlib.pyplot.title",
"sys.stdout.flush",
"sys.stdout.write"
] | [((1410, 1432), 'sys.stdout.write', 'sys.stdout.write', (['text'], {}), '(text)\n', (1426, 1432), False, 'import sys\n'), ((1438, 1456), 'sys.stdout.flush', 'sys.stdout.flush', ([], {}), '()\n', (1454, 1456), False, 'import sys\n'), ((2462, 2500), 'matplotlib.pyplot.title', 'plt.title', (['"""Collatz of 2*n +1 numbers"... |
from torch.nn import Sequential, Linear, ReLU, GRU
from torch_geometric.data import Dataset, Data, DataLoader
# from torch_geometric.datasets import QM9
from torch_geometric.nn import NNConv, Set2Set
from torch.nn import BCELoss, BCEWithLogitsLoss
from torch_geometric.utils import remove_self_loops
import numpy as np... | [
"sklearn.metrics.precision_score",
"sklearn.metrics.recall_score",
"torch.cuda.is_available",
"torch.arange",
"matrixFormation.oneHotEncoder",
"torch.utils.tensorboard.SummaryWriter",
"itertools.chain.from_iterable",
"torch_geometric.utils.remove_self_loops",
"baseLineModel.Net",
"numpy.random.see... | [((1750, 1791), 'matrixFormation.oneHotEncoder', 'oneHotEncoder', (['astOfProgram', 'languageType'], {}), '(astOfProgram, languageType)\n', (1763, 1791), False, 'from matrixFormation import oneHotEncoder, adjacencyMatrixCreator\n'), ((1823, 1859), 'matrixFormation.adjacencyMatrixCreator', 'adjacencyMatrixCreator', (['a... |
import logging
class ColoredFormatter(logging.Formatter):
RESET_SEQ = "\033[0m"
COLOR_SEQ = "\033[%sm"
color_map = {
'DEBUG': '32',
'INFO': '34',
'WARNING': '33',
'ERROR': '31',
'CRITICAL': '34'
}
def __init__(self, *args, **kwargs):
super(Colored... | [
"logging.getLogger",
"logging.StreamHandler",
"logging.Formatter",
"logging.getLevelName",
"logging.FileHandler"
] | [((900, 927), 'logging.getLogger', 'logging.getLogger', (['log_name'], {}), '(log_name)\n', (917, 927), False, 'import logging\n'), ((948, 979), 'logging.getLevelName', 'logging.getLevelName', (['log_level'], {}), '(log_level)\n', (968, 979), False, 'import logging\n'), ((1132, 1155), 'logging.StreamHandler', 'logging.... |
from dataclasses import asdict
import os
from elasticsearch import Elasticsearch
from books.entities import Author, Book
from books.use_cases.repositories import BaseElasticRepository
class ElasticRepository(BaseElasticRepository):
def add_book(self, book: Book) -> None:
es = self._get_elastic()
... | [
"elasticsearch.Elasticsearch",
"dataclasses.asdict"
] | [((743, 778), 'elasticsearch.Elasticsearch', 'Elasticsearch', (["os.environ['ES_URL']"], {}), "(os.environ['ES_URL'])\n", (756, 778), False, 'from elasticsearch import Elasticsearch\n'), ((528, 542), 'dataclasses.asdict', 'asdict', (['author'], {}), '(author)\n', (534, 542), False, 'from dataclasses import asdict\n'), ... |
import context # Remove this import if running with pip installed version.
from pypsqueak.api import qReg, qOp
from pypsqueak.gates import X, Z, I, ROT_Y, CNOT
from pypsqueak.noise import b_flip_map
import numpy as np
import sys
if len(sys.argv) > 1 and int(sys.argv[1]) > 0:
n_trials = int(sys.argv[1])
else:
... | [
"pypsqueak.api.qReg",
"pypsqueak.gates.ROT_Y",
"numpy.eye",
"pypsqueak.gates.CNOT.on",
"numpy.sqrt",
"pypsqueak.gates.I.kron",
"pypsqueak.gates.X.on",
"pypsqueak.noise.b_flip_map",
"pypsqueak.gates.Z.kron"
] | [((603, 612), 'numpy.eye', 'np.eye', (['(2)'], {}), '(2)\n', (609, 612), True, 'import numpy as np\n'), ((934, 940), 'pypsqueak.api.qReg', 'qReg', ([], {}), '()\n', (938, 940), False, 'from pypsqueak.api import qReg, qOp\n'), ((1808, 1815), 'pypsqueak.api.qReg', 'qReg', (['(1)'], {}), '(1)\n', (1812, 1815), False, 'fro... |
import json
import yake
kw_extractor = yake.KeywordExtractor()
with open('med_robo_papers.json', 'r', encoding='utf-8') as data_file:
data = json.load(data_file)
language = "en"
max_ngram_size = 2
deduplication_threshold = 0.9
numOfKeywords = 20
custom_kw_extractor = yake.KeywordExtractor(lan=languag... | [
"json.load",
"yake.KeywordExtractor"
] | [((43, 66), 'yake.KeywordExtractor', 'yake.KeywordExtractor', ([], {}), '()\n', (64, 66), False, 'import yake\n'), ((287, 413), 'yake.KeywordExtractor', 'yake.KeywordExtractor', ([], {'lan': 'language', 'n': 'max_ngram_size', 'dedupLim': 'deduplication_threshold', 'top': 'numOfKeywords', 'features': 'None'}), '(lan=lan... |
"""Test cases for the base environment class."""
import pytest
from predicators.src.envs import BaseEnv, create_env, get_cached_env_instance
from predicators.src import utils
def test_create_env():
"""Tests for create_env() and get_cached_env_instance()."""
utils.reset_config()
for name in [
... | [
"predicators.src.envs.create_env",
"predicators.src.envs.get_cached_env_instance",
"pytest.raises",
"predicators.src.utils.reset_config"
] | [((269, 289), 'predicators.src.utils.reset_config', 'utils.reset_config', ([], {}), '()\n', (287, 289), False, 'from predicators.src import utils\n'), ((697, 713), 'predicators.src.envs.create_env', 'create_env', (['name'], {}), '(name)\n', (707, 713), False, 'from predicators.src.envs import BaseEnv, create_env, get_c... |
from django.db import models
class Network(models.Model):
number = models.CharField(
max_length=35,
verbose_name=u'Номер сети')
class Meta:
verbose_name = 'Защищенная сеть'
verbose_name_plural = 'Защищенные сети'
def __str__(self):
return f'{self.number}'
class ... | [
"django.db.models.DateField",
"django.db.models.CharField",
"django.db.models.ForeignKey"
] | [((73, 132), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(35)', 'verbose_name': 'u"""Номер сети"""'}), "(max_length=35, verbose_name=u'Номер сети')\n", (89, 132), False, 'from django.db import models\n'), ((363, 432), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(35)... |
from flask import Blueprint, Response
from Behavior import Behavior
from DataHandler import DataHandler
class Indexable(Behavior):
"""
Behavior for data that can be accessed
via enumerable indices
"""
def __init__(self, route: str, data_handler: type[DataHandler], **args):
self.data_handl... | [
"flask.Response"
] | [((995, 1015), 'flask.Response', 'Response', ([], {'status': '(404)'}), '(status=404)\n', (1003, 1015), False, 'from flask import Blueprint, Response\n'), ((676, 696), 'flask.Response', 'Response', ([], {'status': '(404)'}), '(status=404)\n', (684, 696), False, 'from flask import Blueprint, Response\n')] |
# -*- coding: utf-8 -*-
"""
triangulate
===========
Script : triangulate.py
Author : <EMAIL>
Modified : 2018-08-24
Purpose: triangulate poly* features
Useage :
References
----------
`<http://pro.arcgis.com/en/pro-app/arcpy/data-access/numpyarraytotable.htm>`_.
`<http://pro.arcgis.com/en/pro... | [
"numpy.mean",
"arcpy.CopyFeatures_management",
"arcpy.management.SelectLayerByLocation",
"numpy.unique",
"arcpy.MakeFeatureLayer_management",
"numpy.where",
"arcpytools_plt.fc_info",
"numpy.set_printoptions",
"arcpy.Point",
"arcpy.da.SearchCursor",
"arcpy.Polygon",
"numpy.array",
"arcpy.Exis... | [((870, 978), 'numpy.set_printoptions', 'np.set_printoptions', ([], {'edgeitems': '(10)', 'linewidth': '(80)', 'precision': '(2)', 'suppress': '(True)', 'threshold': '(100)', 'formatter': 'ft'}), '(edgeitems=10, linewidth=80, precision=2, suppress=True,\n threshold=100, formatter=ft)\n', (889, 978), True, 'import nu... |
from WMCore.Configuration import Configuration
config = Configuration()
config.section_('Agent')
# Agent:
config.Agent.hostName = None
config.Agent.contact = None
config.Agent.teamName = "team_usa"
config.Agent.agentName = None
config.section_('General')
# General: General Settings Section
config.General.workDir = '/ho... | [
"WMCore.Configuration.Configuration"
] | [((56, 71), 'WMCore.Configuration.Configuration', 'Configuration', ([], {}), '()\n', (69, 71), False, 'from WMCore.Configuration import Configuration\n')] |
import pickle
from typing import Callable, Optional
from omegaconf import DictConfig
from pytorch_lightning import LightningDataModule
from torch.utils.data import DataLoader, Dataset
from ..data import MTATDataset
class DataPipeline(LightningDataModule):
def __init__(self, pipline_config: DictConfig) -> None:
... | [
"torch.utils.data.DataLoader"
] | [((2751, 2871), 'torch.utils.data.DataLoader', 'DataLoader', (['dataset'], {'batch_size': 'batch_size', 'num_workers': 'num_workers', 'shuffle': 'shuffle', 'drop_last': 'drop_last'}), '(dataset, batch_size=batch_size, num_workers=num_workers, shuffle\n =shuffle, drop_last=drop_last, **kwargs)\n', (2761, 2871), False... |
import pymongo as pm
def connectDB():
conn = pm.MongoClient('localhost', 27017)
db = conn.get_database('report_db')
return db
def getColList(db):
return db.collection_names()
def getDocNum(col):
return col.find().count()
def match(col, matchDict):
return list(col.find(matchDict))
def main():
db = connectDB(... | [
"pymongo.MongoClient"
] | [((47, 81), 'pymongo.MongoClient', 'pm.MongoClient', (['"""localhost"""', '(27017)'], {}), "('localhost', 27017)\n", (61, 81), True, 'import pymongo as pm\n')] |
from django.contrib import admin
from random_api.models import RandomApi
class RandomAdmin(admin.ModelAdmin):
list_display = ('title', 'language', 'style')
admin.site.register(RandomApi, RandomAdmin)
| [
"django.contrib.admin.site.register"
] | [((159, 202), 'django.contrib.admin.site.register', 'admin.site.register', (['RandomApi', 'RandomAdmin'], {}), '(RandomApi, RandomAdmin)\n', (178, 202), False, 'from django.contrib import admin\n')] |
from torch import nn
import torch
import torch.nn.functional as F
from .base_model import BaseModel
from ..layers import EmbeddingLayer
class BiasMF(BaseModel):
def __init__(self,
feature_map,
model_id="BiasMF",
gpu=-1,
learning_rate=1e-3,
... | [
"torch.nn.functional.normalize",
"torch.nn.Dropout",
"torch.zeros"
] | [((1965, 1994), 'torch.nn.Dropout', 'nn.Dropout', (['embedding_dropout'], {}), '(embedding_dropout)\n', (1975, 1994), False, 'from torch import nn\n'), ((3137, 3158), 'torch.nn.functional.normalize', 'F.normalize', (['user_vec'], {}), '(user_vec)\n', (3148, 3158), True, 'import torch.nn.functional as F\n'), ((3540, 356... |
from django.shortcuts import render, redirect
from django.http import HttpResponse
from reveal.models import Reveal, get_content_object
from reveal import app_settings
from reveal import cipher
def reveal_info(request, info_attr,
app_label=None, model=None, object_id=None,
no_js=None):... | [
"reveal.models.get_content_object",
"django.shortcuts.render",
"reveal.models.Reveal",
"django.http.HttpResponse",
"django.shortcuts.redirect",
"reveal.cipher.decrypt"
] | [((608, 655), 'reveal.models.get_content_object', 'get_content_object', (['app_label', 'model', 'object_id'], {}), '(app_label, model, object_id)\n', (626, 655), False, 'from reveal.models import Reveal, get_content_object\n'), ((705, 756), 'reveal.models.Reveal', 'Reveal', ([], {'enquiring': 'request.user', 'info_attr... |
from resistor import Resistor
from resistor_data import ResistorData
class ResistorSolver:
"""
find a solution to for the non-standard resistor values
"""
_target = Resistor()
_dataset_list = list()
def __init__(self, target, tolerance=0.05, extension=".resistor"):
"""
create ... | [
"resistor_data.ResistorData",
"resistor.Resistor"
] | [((183, 193), 'resistor.Resistor', 'Resistor', ([], {}), '()\n', (191, 193), False, 'from resistor import Resistor\n'), ((508, 549), 'resistor.Resistor', 'Resistor', ([], {'val': 'target', 'tolerance': 'tolerance'}), '(val=target, tolerance=tolerance)\n', (516, 549), False, 'from resistor import Resistor\n'), ((663, 68... |
from __future__ import print_function
import json
import random as rd
def read_dict(filename):
f = open(filename, "r")
rs = f.read()
if rs.find("\n") >= 0:
rules = rs.split("\n")
else:
rules = rs.split("\r")
out_rule = []
for rule in rules:
if len(rule) < 1:
continue
details = rule.split("|")
flat_... | [
"json.dump"
] | [((5594, 5626), 'json.dump', 'json.dump', (['clean_result_dict', 'f1'], {}), '(clean_result_dict, f1)\n', (5603, 5626), False, 'import json\n')] |
import pandas as pd
import numpy as np
from sklearn import tree
from sklearn.externals.six import StringIO
from IPython.display import Image, display
from sklearn.tree import export_graphviz
import pydotplus
import matplotlib.pyplot as plt
import matplotlib.image as mpimg
def remap_data(data_row,values) :
row_val... | [
"pandas.Series",
"matplotlib.pyplot.imshow",
"numpy.int64",
"pandas.read_csv",
"sklearn.tree.DecisionTreeClassifier",
"matplotlib.image.imread",
"sklearn.tree.export_graphviz",
"sklearn.externals.six.StringIO",
"matplotlib.pyplot.show"
] | [((942, 978), 'pandas.read_csv', 'pd.read_csv', (['"""../../input/train.csv"""'], {}), "('../../input/train.csv')\n", (953, 978), True, 'import pandas as pd\n'), ((1484, 1513), 'pandas.Series', 'pd.Series', (['embarked_row_value'], {}), '(embarked_row_value)\n', (1493, 1513), True, 'import pandas as pd\n'), ((1736, 176... |
# Generated by Django 3.2.5 on 2021-08-01 23:32
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('users', '0013_auto_20180705_0348'),
]
operations = [
migrations.AlterField(
model_name='membership',
name='psf_annou... | [
"django.db.models.BooleanField"
] | [((349, 471), 'django.db.models.BooleanField', 'models.BooleanField', ([], {'blank': '(True)', 'null': '(True)', 'verbose_name': '"""I would like to receive occasional PSF email announcements"""'}), "(blank=True, null=True, verbose_name=\n 'I would like to receive occasional PSF email announcements')\n", (368, 471),... |
import pyautogui
from time import sleep
accept=None
f= None
r= None
c=None
l=None
lockin=None
test=None
champ= input("Which champ:")
secondary=input("Which secondary:")
secondary=secondary.lower()
secondary=secondary.strip()
champ=champ.lower()
champ=champ.strip()
ban= input("Which ban:")
ba... | [
"pyautogui.locateCenterOnScreen",
"pyautogui.moveTo",
"pyautogui.scroll",
"time.sleep",
"pyautogui.click"
] | [((659, 734), 'pyautogui.locateCenterOnScreen', 'pyautogui.locateCenterOnScreen', (['"""bans.png"""'], {'grayscale': '(False)', 'confidence': '(0.5)'}), "('bans.png', grayscale=False, confidence=0.5)\n", (689, 734), False, 'import pyautogui\n'), ((816, 884), 'pyautogui.locateCenterOnScreen', 'pyautogui.locateCenterOnSc... |
import cv2
img = cv2.imread(r"..\cat.jpg", 0)
# 测试读取,修改单个像素值
print("读取像素点img.item(3,2)=", img.item(3, 2))
img.itemset((3, 2), 255)
print("修改后像素点img.item(3,2)=", img.item(3, 2))
# 测试修改一个区域的像素值
cv2.imshow("before", img)
for i in range(10, 100):
for j in range(80, 100):
img.itemset((i, j), 255)
cv2.imshow("af... | [
"cv2.waitKey",
"cv2.imread",
"cv2.imshow"
] | [((18, 46), 'cv2.imread', 'cv2.imread', (['"""..\\\\cat.jpg"""', '(0)'], {}), "('..\\\\cat.jpg', 0)\n", (28, 46), False, 'import cv2\n'), ((193, 218), 'cv2.imshow', 'cv2.imshow', (['"""before"""', 'img'], {}), "('before', img)\n", (203, 218), False, 'import cv2\n'), ((306, 330), 'cv2.imshow', 'cv2.imshow', (['"""after"... |
#!/usr/bin/env python
# Copyright (C) 2018 phdphuc
# This software may be modified and distributed under the terms
# of the MIT license. See the LICENSE file for details.
from os import system, path
from lib.core.packages import Package
from plistlib import readPlist
class App(Package):
""" OS X application anal... | [
"os.system"
] | [((370, 415), 'os.system', 'system', (['(\'/bin/chmod -R +x "%s"\' % self.target)'], {}), '(\'/bin/chmod -R +x "%s"\' % self.target)\n', (376, 415), False, 'from os import system, path\n')] |
''' Progetto di programmazione di reti - <NAME> - Python Web Server '''
import http.server
import socketserver
import sys
import signal
# Struttura dati che mappa il nome dei file .html nei percorsi relativi
files = [("chisiamo.html","html/chisiamo.html"),
("contatti.html", "html/contatti.html")... | [
"socketserver.ThreadingTCPServer",
"signal.signal",
"sys.exit"
] | [((1861, 1913), 'socketserver.ThreadingTCPServer', 'socketserver.ThreadingTCPServer', (["('', port)", 'handler'], {}), "(('', port), handler)\n", (1892, 1913), False, 'import socketserver\n'), ((2565, 2609), 'signal.signal', 'signal.signal', (['signal.SIGINT', 'signal_handler'], {}), '(signal.SIGINT, signal_handler)\n'... |
"""
Random table generator module.
"""
from collections import OrderedDict
import logging
import numpy as np
from ..utils.errors import ProgressiveError, ProgressiveStopIteration
from ..table.module import TableModule
from ..table.table import Table
from ..table.constant import Constant
from ..utils.psdict import Ps... | [
"logging.getLogger",
"collections.OrderedDict",
"numpy.random.rand",
"numpy.min"
] | [((374, 401), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (391, 401), False, 'import logging\n'), ((2141, 2154), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (2152, 2154), False, 'from collections import OrderedDict\n'), ((2730, 2753), 'numpy.random.rand', 'np.random.ran... |
import sys
import os
import pip
import logging
from shutil import copy, rmtree
from .helpers import get_rhino_ironpython_path
logging.basicConfig(format='%(levelname)s:%(message)s', level=logging.INFO)
if __name__ == '__main__':
location = None
if len(sys.argv) > 1:
location = sys.argv[1]
rhino_i... | [
"logging.basicConfig",
"os.getenv",
"os.path.join",
"logging.warning",
"os.path.realpath",
"os.path.isdir",
"os.mkdir",
"shutil.copy",
"shutil.rmtree",
"pip.main"
] | [((127, 202), 'logging.basicConfig', 'logging.basicConfig', ([], {'format': '"""%(levelname)s:%(message)s"""', 'level': 'logging.INFO'}), "(format='%(levelname)s:%(message)s', level=logging.INFO)\n", (146, 202), False, 'import logging\n'), ((839, 856), 'pip.main', 'pip.main', (['pip_cmd'], {}), '(pip_cmd)\n', (847, 856... |
"""
工具函数
"""
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# @Time : 2019-11-01 17:07
# @Site :
# @File : tools.py
# @Software: PyCharm
from pydub import AudioSegment
def mp3_to_wav(mp3_path, wav_path):
"""
MP3转wav
:param mp3_path:
:param wav_path:
:return:
"""
sound = AudioSegm... | [
"pydub.AudioSegment.from_mp3"
] | [((311, 342), 'pydub.AudioSegment.from_mp3', 'AudioSegment.from_mp3', (['mp3_path'], {}), '(mp3_path)\n', (332, 342), False, 'from pydub import AudioSegment\n')] |
# -*- coding: utf-8 -*-
# Copyright (c) 2012 <NAME> <<EMAIL>>
# License: MIT (see LICENSE.TXT file)
from django.core.exceptions import PermissionDenied
from django.utils.translation import ugettext as _
from apps.common.shortcuts import render_response
from apps.page.models import Page
from apps.co... | [
"django.utils.translation.ugettext",
"apps.common.shortcuts.render_response",
"apps.team.control.is_member"
] | [((423, 432), 'django.utils.translation.ugettext', '_', (['"""BLOG"""'], {}), "('BLOG')\n", (424, 432), True, 'from django.utils.translation import ugettext as _\n'), ((448, 458), 'django.utils.translation.ugettext', '_', (['"""BIKES"""'], {}), "('BIKES')\n", (449, 458), True, 'from django.utils.translation import uget... |
import random
from discord.ext import commands
from lucid_bot import config
from lucid_bot.lucid_embed import lucid_embed
class Info(commands.Cog):
def __init__(self, bot):
self.bot = bot
self.config = config.config
@commands.command(name="info")
@commands.cooldown(1, 30, commands.Bucke... | [
"lucid_bot.lucid_embed.lucid_embed",
"discord.ext.commands.cooldown",
"discord.ext.commands.command"
] | [((246, 275), 'discord.ext.commands.command', 'commands.command', ([], {'name': '"""info"""'}), "(name='info')\n", (262, 275), False, 'from discord.ext import commands\n'), ((281, 331), 'discord.ext.commands.cooldown', 'commands.cooldown', (['(1)', '(30)', 'commands.BucketType.user'], {}), '(1, 30, commands.BucketType.... |
import docker
from dataclasses import dataclass, field
from jinja2 import Template
import os
import subprocess
import time
def resolve_pattern(format):
if format == 'json':
return '{ \
"@timestamp": "$time_iso8601", \
"@version": "1", \
"system-type": "ingress", \
"message": "$request [Status: $status]",... | [
"os.path.join",
"jinja2.Template",
"os.path.isfile",
"subprocess.call",
"docker.DockerClient",
"dataclasses.field"
] | [((1337, 1392), 'docker.DockerClient', 'docker.DockerClient', ([], {'base_url': "os.environ['DOCKER_HOST']"}), "(base_url=os.environ['DOCKER_HOST'])\n", (1356, 1392), False, 'import docker\n'), ((2261, 2288), 'dataclasses.field', 'field', ([], {'default_factory': 'dict'}), '(default_factory=dict)\n', (2266, 2288), Fals... |
"""
At work I had this requirement: log messages and warnings to stdout, errors
and above to stderr.
This is one way to achieve this with a logging.Filter-like function.
"""
import sys
import logging
def upper_bound(level):
"""Filter logrecords by level.
Allow only records with level number LE to level.
... | [
"logging.getLogger",
"logging.Formatter",
"logging.StreamHandler"
] | [((453, 481), 'logging.getLogger', 'logging.getLogger', (['"""default"""'], {}), "('default')\n", (470, 481), False, 'import logging\n'), ((548, 581), 'logging.StreamHandler', 'logging.StreamHandler', (['sys.stderr'], {}), '(sys.stderr)\n', (569, 581), False, 'import logging\n'), ((747, 780), 'logging.StreamHandler', '... |
from setuptools import setup
setup(name='dxl',
version='0.1',
description='dxl library',
url='http://github.com/TheAlakazam/dynamixel',
author='<NAME>',
author_email='<EMAIL>',
license='MIT',
packages=['dxl'],
zip_safe=False)
| [
"setuptools.setup"
] | [((30, 235), 'setuptools.setup', 'setup', ([], {'name': '"""dxl"""', 'version': '"""0.1"""', 'description': '"""dxl library"""', 'url': '"""http://github.com/TheAlakazam/dynamixel"""', 'author': '"""<NAME>"""', 'author_email': '"""<EMAIL>"""', 'license': '"""MIT"""', 'packages': "['dxl']", 'zip_safe': '(False)'}), "(na... |
import serial
import time
from squid import *
import os.path
import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
import Adafruit_GPIO.SPI as SPI
import Adafruit_SSD1306
from PIL import Image
from PIL import ImageDraw
from PIL import ImageFont
RST = None
disp = Adafruit_SSD1306.SSD1306_128_32(rst=RST)
disp.begin()
# Clear ... | [
"RPi.GPIO.add_event_detect",
"PIL.ImageFont.load_default",
"PIL.Image.new",
"RPi.GPIO.setup",
"Adafruit_SSD1306.SSD1306_128_32",
"time.sleep",
"PIL.ImageDraw.Draw",
"serial.Serial",
"RPi.GPIO.setmode"
] | [((85, 107), 'RPi.GPIO.setmode', 'GPIO.setmode', (['GPIO.BCM'], {}), '(GPIO.BCM)\n', (97, 107), True, 'import RPi.GPIO as GPIO\n'), ((257, 297), 'Adafruit_SSD1306.SSD1306_128_32', 'Adafruit_SSD1306.SSD1306_128_32', ([], {'rst': 'RST'}), '(rst=RST)\n', (288, 297), False, 'import Adafruit_SSD1306\n'), ((499, 530), 'PIL.I... |
import matplotlib
matplotlib.use("Agg")
from core import config
from core.conv import PneumoniaNet
from core.utils.helper import info
from core.callbacks import TrainingMonitor
from tensorflow.keras.layers.experimental import preprocessing
from tensorflow.keras.models import Sequential
from tensorflow.data import AUTO... | [
"core.callbacks.TrainingMonitor",
"tensorflow.data.Dataset.zip",
"core.utils.helper.info",
"matplotlib.use",
"tensorflow.keras.layers.experimental.preprocessing.RandomRotation",
"tensorflow.keras.layers.experimental.preprocessing.RandomZoom",
"tensorflow.keras.layers.experimental.preprocessing.Rescaling... | [((18, 39), 'matplotlib.use', 'matplotlib.use', (['"""Agg"""'], {}), "('Agg')\n", (32, 39), False, 'import matplotlib\n'), ((2200, 2229), 'core.utils.helper.info', 'info', (['"""Initializing model..."""'], {}), "('Initializing model...')\n", (2204, 2229), False, 'from core.utils.helper import info\n'), ((2238, 2272), '... |
# Generated by Django 2.2.6 on 2019-11-12 13:07
from django.conf import settings
import django.contrib.postgres.fields.jsonb
from django.db import migrations, models
import django.db.models.deletion
import uuid
class Migration(migrations.Migration):
dependencies = [
migrations.swappable_dependency(setti... | [
"django.db.models.TextField",
"django.db.models.ForeignKey",
"django.db.models.DateTimeField",
"django.db.migrations.swappable_dependency",
"django.db.models.UUIDField"
] | [((283, 340), 'django.db.migrations.swappable_dependency', 'migrations.swappable_dependency', (['settings.AUTH_USER_MODEL'], {}), '(settings.AUTH_USER_MODEL)\n', (314, 340), False, 'from django.db import migrations, models\n'), ((526, 597), 'django.db.models.UUIDField', 'models.UUIDField', ([], {'default': 'uuid.uuid1'... |
import contextlib
import os
import pickle
import sys
import time
from collections import Counter
from pathlib import Path
from typing import Dict, List, Optional, Union
import joblib
import numpy as np
import pandas as pd
import rdkit.Chem as Chem
import rdkit.Chem.AllChem as AllChem
from joblib import Parallel, delay... | [
"numpy.argsort",
"os.cpu_count",
"pathlib.Path",
"rdkit.Chem.MolToSmiles",
"rdchiral.main.rdchiralRun",
"pandas.DataFrame",
"rdchiral.main.rdchiralReaction",
"rdchiral.main.rdchiralReactants",
"pickle.load",
"rdkit.DataStructs.BulkTverskySimilarity",
"rdkit.DataStructs.BulkDiceSimilarity",
"rx... | [((1573, 1599), 'rdkit.Chem.MolFromSmiles', 'Chem.MolFromSmiles', (['smiles'], {}), '(smiles)\n', (1591, 1599), True, 'import rdkit.Chem as Chem\n'), ((1671, 1708), 'rdkit.Chem.MolToSmiles', 'Chem.MolToSmiles', (['mol', 'isomericSmiles'], {}), '(mol, isomericSmiles)\n', (1687, 1708), True, 'import rdkit.Chem as Chem\n'... |
import tkinter as tk
import tkinter.font as font
from tkinter import *
from tkinter import messagebox
from PIL import ImageTk, Image
import random
import tkinter.ttk as ttk
import mysql.connector
from mysql.connector import Error
from mysql.connector import errorcode
from time import strftime
pagenum = 1
win = Tk()
wi... | [
"tkinter.messagebox.showerror",
"random.randrange",
"time.strftime",
"tkinter.Button",
"tkinter.font.Font",
"tkinter.Label",
"tkinter.messagebox.showinfo",
"PIL.ImageTk.PhotoImage"
] | [((482, 523), 'PIL.ImageTk.PhotoImage', 'ImageTk.PhotoImage', ([], {'file': '"""background.png"""'}), "(file='background.png')\n", (500, 523), False, 'from PIL import ImageTk, Image\n'), ((531, 591), 'tkinter.font.Font', 'font.Font', ([], {'family': '"""alternate sans"""', 'size': '"""10"""', 'weight': '"""bold"""'}), ... |
from sentencias import *
from storageManager import jsonMode as jBase
import TablaSimbolos as TS
import Error as Error
import re
consola = ""
useActual = ""
listaSemanticos = []
listaConstraint = []
listaFK = []
def interpretar_sentencias(arbol, tablaSimbolos):
jBase.dropAll()
global consola
for nodo in ... | [
"storageManager.jsonMode.alterDatabase",
"storageManager.jsonMode.alterTable",
"storageManager.jsonMode.dropDatabase",
"storageManager.jsonMode.alterAddColumn",
"storageManager.jsonMode.showDatabases",
"re.compile",
"Error.ErrorS",
"storageManager.jsonMode.showTables",
"storageManager.jsonMode.dropT... | [((269, 284), 'storageManager.jsonMode.dropAll', 'jBase.dropAll', ([], {}), '()\n', (282, 284), True, 'from storageManager import jsonMode as jBase\n'), ((30865, 30891), 'TablaSimbolos.SimboloTabla', 'TS.SimboloTabla', (['val', 'None'], {}), '(val, None)\n', (30880, 30891), True, 'import TablaSimbolos as TS\n'), ((3635... |
#!/bin/env python
"""
Displays revision information on the specified git-controlled repository
Path
----
hlapipeline/hlapipeline/utils/get_git_rev_info.py
Dependencies
------------
None.
Inputs
------
* Required input
1: *code_path*
* Path to query for git revision information.
Example
-------
Get git r... | [
"os.getcwd",
"os.chdir",
"os.popen",
"sys.exit",
"os.system"
] | [((973, 984), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (982, 984), False, 'import os, sys\n'), ((2054, 2065), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (2063, 2065), False, 'import os, sys\n'), ((1052, 1075), 'os.chdir', 'os.chdir', (['localRepoPath'], {}), '(localRepoPath)\n', (1060, 1075), False, 'import os, sys... |
from datetime import datetime
from time import mktime
def micro_time():
"""
Returns the current time since epoch, accurate to the
value returned by gettimeofday(), usually ~1microsecond.
Datetime is more accurate than time.clock
"""
now = datetime.now()
return long(mktime(now.timetuple()) ... | [
"datetime.datetime.now"
] | [((265, 279), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (277, 279), False, 'from datetime import datetime\n'), ((433, 447), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (445, 447), False, 'from datetime import datetime\n')] |
import re
import requests
from bs4 import BeautifulSoup as bs
from jfr_playoff.logger import PlayoffLogger
class RemoteUrl:
url_cache = {}
@classmethod
def fetch_raw(cls, url):
PlayoffLogger.get('remote').info(
'fetching content for: %s', url)
if url not in cls.url_cache:
... | [
"jfr_playoff.logger.PlayoffLogger.get",
"requests.get",
"re.search"
] | [((340, 357), 'requests.get', 'requests.get', (['url'], {}), '(url)\n', (352, 357), False, 'import requests\n'), ((387, 462), 're.search', 're.search', (['"""content=".*;( )?charset=(.*?)\\""""', 'request.content', 're.IGNORECASE'], {}), '(\'content=".*;( )?charset=(.*?)"\', request.content, re.IGNORECASE)\n', (396, 46... |
# Copyright 2018 Google LLC
#
# 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
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, ... | [
"numpy.mean",
"numpy.abs",
"numpy.median",
"numpy.asarray",
"moonlight.structure.barlines.assign_barlines_to_staves"
] | [((2920, 3116), 'moonlight.structure.barlines.assign_barlines_to_staves', 'barlines.assign_barlines_to_staves', ([], {'barline_x': 'component_center_x', 'barline_y0': 'self.components[:, COLUMNS.Y0]', 'barline_y1': 'self.components[:, COLUMNS.Y1]', 'staff_detector': 'self.staff_detector'}), '(barline_x=component_center... |
import serial
from pymodbus.factory import ClientDecoder
from pymodbus.factory import ServerDecoder
from pymodbus.transaction import ModbusRtuFramer
#import pymodbus
#from pymodbus.transaction import ModbusRtuFramer
#from pymodbus.utilities import hexlify_packets
#from binascii import b2a_hex
from time import sleep
imp... | [
"logging.basicConfig",
"logging.getLogger",
"pymodbus.factory.ClientDecoder",
"sys.exit",
"pymodbus.factory.ServerDecoder"
] | [((457, 491), 'logging.basicConfig', 'logging.basicConfig', ([], {'format': 'FORMAT'}), '(format=FORMAT)\n', (476, 491), False, 'import logging\n'), ((498, 517), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (515, 517), False, 'import logging\n'), ((4077, 4088), 'sys.exit', 'sys.exit', (['(0)'], {}), '(0)... |
from collections import defaultdict
from typing import Optional
import asyncpg
import discord
from discord.ext import commands
from clam.utils import db, cache, checks, colors
class CommandPermissionsTable(db.Table, table_name="command_permissions"):
id = db.PrimaryKeyColumn()
guild_id = db.Column(db.Inte... | [
"clam.utils.db.PrimaryKeyColumn",
"clam.utils.checks.has_permissions",
"discord.ext.commands.DisabledCommand",
"discord.ext.commands.group",
"clam.utils.db.Integer",
"collections.defaultdict",
"discord.ext.commands.TextChannelConverter",
"discord.ext.commands.BadArgument",
"discord.Embed",
"clam.u... | [((265, 286), 'clam.utils.db.PrimaryKeyColumn', 'db.PrimaryKeyColumn', ([], {}), '()\n', (284, 286), False, 'from clam.utils import db, cache, checks, colors\n'), ((398, 418), 'clam.utils.db.Column', 'db.Column', (['db.String'], {}), '(db.String)\n', (407, 418), False, 'from clam.utils import db, cache, checks, colors\... |
# Generated by Django 2.0.7 on 2018-07-09 09:33
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [("importer", "0002_auto_20180709_0833")]
operations = [
migrations.AlterField(
model_name="campaignitemassetcount",
name="campaign_... | [
"django.db.models.IntegerField"
] | [((357, 410), 'django.db.models.IntegerField', 'models.IntegerField', ([], {'blank': '(True)', 'default': '(0)', 'null': '(True)'}), '(blank=True, default=0, null=True)\n', (376, 410), False, 'from django.db import migrations, models\n'), ((559, 612), 'django.db.models.IntegerField', 'models.IntegerField', ([], {'blank... |
from django.shortcuts import render
from django.views.generic import TemplateView
# Create your views here.
class HomePageView(TemplateView):
def get(self, request, **kwargs):
return render(request, 'index.html', context=None)
class AboutPageView(TemplateView):
template_name = "about.html"
class Menu... | [
"django.shortcuts.render"
] | [((196, 239), 'django.shortcuts.render', 'render', (['request', '"""index.html"""'], {'context': 'None'}), "(request, 'index.html', context=None)\n", (202, 239), False, 'from django.shortcuts import render\n')] |
import datetime
import re
from pyasn1.codec.der import decoder
from ldap_shell.krb5 import constants, asn1
class KerberosException(Exception):
pass
def _asn1_decode(data, asn1Spec):
if isinstance(data, str) or isinstance(data, bytes):
data, substrate = decoder.decode(data, asn1Spec=asn1Spec)
... | [
"datetime.datetime",
"re.match",
"ldap_shell.krb5.asn1.EncryptedData",
"pyasn1.codec.der.decoder.decode",
"ldap_shell.krb5.asn1.Ticket",
"re.sub",
"ldap_shell.krb5.asn1.seq_set"
] | [((5908, 5946), 'datetime.datetime', 'datetime.datetime', (['(1970)', '(1)', '(1)', '(0)', '(0)', '(0)'], {}), '(1970, 1, 1, 0, 0, 0)\n', (5925, 5946), False, 'import datetime\n'), ((275, 314), 'pyasn1.codec.der.decoder.decode', 'decoder.decode', (['data'], {'asn1Spec': 'asn1Spec'}), '(data, asn1Spec=asn1Spec)\n', (289... |
from gym import spaces
import numpy as np
from pettingzoo.utils.env import ParallelEnv
from pettingzoo.utils.agent_selector import agent_selector
from gym.utils import seeding
from gym import spaces
from pettingzoo.utils import wrappers
def make_env(raw_env):
def env(**kwargs):
env = raw_env(**kwargs)
... | [
"pettingzoo.utils.wrappers.NanNoOpWrapper",
"pettingzoo.utils.wrappers.OrderEnforcingWrapper",
"pettingzoo.utils.wrappers.AssertOutOfBoundsWrapper",
"gym.spaces.Discrete",
"gym.spaces.Box",
"numpy.array",
"numpy.zeros",
"numpy.concatenate"
] | [((331, 369), 'pettingzoo.utils.wrappers.AssertOutOfBoundsWrapper', 'wrappers.AssertOutOfBoundsWrapper', (['env'], {}), '(env)\n', (364, 369), False, 'from pettingzoo.utils import wrappers\n'), ((460, 506), 'pettingzoo.utils.wrappers.NanNoOpWrapper', 'wrappers.NanNoOpWrapper', (['env', '(4)', 'backup_policy'], {}), '(e... |
#!/usr/bin/env python3
# Copyright © 2014 <NAME>
# [This program is licensed under the "MIT License"]
# Please see the file COPYING in the source
# distribution of this software for license terms.
# Sudoku solver
from sudoku_color import *
from sys import setrecursionlimit
setrecursionlimit(100)
read_puzzle()
for sol... | [
"sys.setrecursionlimit"
] | [((276, 298), 'sys.setrecursionlimit', 'setrecursionlimit', (['(100)'], {}), '(100)\n', (293, 298), False, 'from sys import setrecursionlimit\n')] |
#!/usr/bin/python
# coding=utf-8
# ------------------------------------------------------------------------------
#
# Common utility functions
#
# Author: <NAME> <<EMAIL>>
#
# ------------------------------------------------------------------------------
import time
import subprocess
# print a string to a file
def f... | [
"time.localtime"
] | [((624, 640), 'time.localtime', 'time.localtime', ([], {}), '()\n', (638, 640), False, 'import time\n'), ((562, 578), 'time.localtime', 'time.localtime', ([], {}), '()\n', (576, 578), False, 'import time\n')] |
import streamlit as st, pandas_profiling
from streamlit_pandas_profiling import st_profile_report
from extractreq.modul_ekspart import partOf, pd
def app():
st.header("Visualize Statistic Module")
st.markdown("Modul ini digunakan untuk mengolah data secara statistik")
dataset1 = st.file_uploader("Choose ... | [
"streamlit.markdown",
"streamlit.table",
"extractreq.modul_ekspart.partOf",
"extractreq.modul_ekspart.pd.ExcelFile",
"streamlit.warning",
"streamlit.file_uploader",
"streamlit.sidebar.header",
"streamlit_pandas_profiling.st_profile_report",
"streamlit.sidebar.selectbox",
"streamlit.header"
] | [((163, 202), 'streamlit.header', 'st.header', (['"""Visualize Statistic Module"""'], {}), "('Visualize Statistic Module')\n", (172, 202), True, 'import streamlit as st, pandas_profiling\n'), ((207, 278), 'streamlit.markdown', 'st.markdown', (['"""Modul ini digunakan untuk mengolah data secara statistik"""'], {}), "('M... |
from django.db.models.signals import post_save
from django.contrib.auth.models import User
from django.dispatch import receiver
from .models import Profile
@receiver(post_save,sender=User)
def create_profile(sender, instance, created, *args,**kwargs):
if created:
Profile.objects.create(user=instance)
@receiver(... | [
"django.dispatch.receiver"
] | [((160, 192), 'django.dispatch.receiver', 'receiver', (['post_save'], {'sender': 'User'}), '(post_save, sender=User)\n', (168, 192), False, 'from django.dispatch import receiver\n'), ((311, 343), 'django.dispatch.receiver', 'receiver', (['post_save'], {'sender': 'User'}), '(post_save, sender=User)\n', (319, 343), False... |
import os, time
from telegram import InlineKeyboardButton, InlineKeyboardMarkup, Poll
from telegram.ext import Updater, CommandHandler, MessageHandler, Filters, CallbackQueryHandler, PollHandler, \
PollAnswerHandler
import telegram
from config import DefaultConfig
from conversation.flow_manager import *
CHANNEL ... | [
"telegram.InlineKeyboardMarkup",
"telegram.InlineKeyboardButton",
"telegram.ext.PollHandler",
"time.sleep",
"config.DefaultConfig.init_logging",
"telegram.ext.MessageHandler",
"telegram.ext.CallbackQueryHandler",
"telegram.ext.CommandHandler",
"telegram.ext.Updater"
] | [((2672, 2685), 'time.sleep', 'time.sleep', (['(1)'], {}), '(1)\n', (2682, 2685), False, 'import os, time\n'), ((3014, 3045), 'telegram.InlineKeyboardMarkup', 'InlineKeyboardMarkup', (['[options]'], {}), '([options])\n', (3034, 3045), False, 'from telegram import InlineKeyboardButton, InlineKeyboardMarkup, Poll\n'), ((... |
from torch import nn
import torch
import torch.nn.functional as F
class MultiLevelNet(nn.Module):
"""
Convolutional network generating deformation field with different scales.
"""
def __init__(self,inshape, in_channels=2, levels=3,features=16):
super().__init__()
print('Initializing Mu... | [
"torch.nn.BatchNorm2d",
"torch.nn.Tanh",
"torch.nn.ModuleList",
"torch.nn.Conv2d",
"torch.nn.Upsample",
"torch.cat"
] | [((678, 754), 'torch.nn.Conv2d', 'nn.Conv2d', (['(in_channels * (levels + 1))', 'in_channels'], {'kernel_size': '(3)', 'padding': '(1)'}), '(in_channels * (levels + 1), in_channels, kernel_size=3, padding=1)\n', (687, 754), False, 'from torch import nn\n'), ((827, 842), 'torch.nn.ModuleList', 'nn.ModuleList', ([], {}),... |
import json
import random
from argparse import ArgumentParser
from collections import Counter, defaultdict
import itertools
import os
import sys
sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
from datasets import utils
from datasets.wsd_dataset import SemCorWSDDataset
def shuffle_list... | [
"itertools.chain",
"random.sample",
"random.shuffle",
"argparse.ArgumentParser",
"os.makedirs",
"os.path.join",
"random.seed",
"collections.Counter",
"datasets.wsd_dataset.SemCorWSDDataset",
"collections.defaultdict",
"datasets.utils.write_json",
"os.path.abspath",
"json.dump"
] | [((354, 371), 'random.shuffle', 'random.shuffle', (['l'], {}), '(l)\n', (368, 371), False, 'import random\n'), ((1380, 1389), 'collections.Counter', 'Counter', ([], {}), '()\n', (1387, 1389), False, 'from collections import Counter, defaultdict\n'), ((1410, 1427), 'collections.defaultdict', 'defaultdict', (['list'], {}... |
# Copyright 2016 The TensorFlow Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applica... | [
"tensorflow.python.util.decorator_utils.validate_callable",
"functools.wraps"
] | [((1351, 1411), 'tensorflow.python.util.decorator_utils.validate_callable', 'decorator_utils.validate_callable', (['func', '"""keyword_args_only"""'], {}), "(func, 'keyword_args_only')\n", (1384, 1411), False, 'from tensorflow.python.util import decorator_utils\n'), ((1415, 1436), 'functools.wraps', 'functools.wraps', ... |
import unicodedata
import re
import difflib
import pprint
_controlChars = None
_invalidCharForFileName = None
def toFileName(s):
"""
Elimina caracteres inválidos de un string para que pueda ser utilizado como nombre de
archivo en windows y linux.
"""
global _invalidCharForFileName
if _invali... | [
"unicodedata.normalize",
"re.sub",
"difflib.Differ",
"pprint.pformat"
] | [((770, 794), 're.sub', 're.sub', (['"""<[^>]*>"""', '""""""', 's'], {}), "('<[^>]*>', '', s)\n", (776, 794), False, 'import re\n'), ((1034, 1072), 're.sub', 're.sub', (['"""(</\\\\w+>)"""', '"""\\\\1\\\\n"""', 'normal1'], {}), "('(</\\\\w+>)', '\\\\1\\\\n', normal1)\n", (1040, 1072), False, 'import re\n'), ((1102, 114... |
import setuptools
import io
fh = io.open("README.md",mode="r",encoding="utf-8")
long_description = fh.read()
setuptools.setup(
name='ConfigEnv',
version='1.2.4',
author="Théo \"<NAME>",
author_email="<EMAIL>",
description="Gestionnaire de configuration en json, ini avec overide possible en varia... | [
"setuptools.find_packages",
"io.open"
] | [((34, 82), 'io.open', 'io.open', (['"""README.md"""'], {'mode': '"""r"""', 'encoding': '"""utf-8"""'}), "('README.md', mode='r', encoding='utf-8')\n", (41, 82), False, 'import io\n'), ((494, 537), 'setuptools.find_packages', 'setuptools.find_packages', ([], {'exclude': "['tests']"}), "(exclude=['tests'])\n", (518, 537... |
import os
import julian
import datetime
import math
import pandas as pd
import numpy as np
from numpy import *
import pickle
from sklearn.model_selection import train_test_split
from sklearn.decomposition import PCA
import matplotlib.pyplot as plt
import warnings
from sklearn.cluster import KMeans
import matplotlib.col... | [
"matplotlib.pyplot.grid",
"matplotlib.pyplot.ylabel",
"numpy.sin",
"numpy.arange",
"pandas.read_pickle",
"numpy.where",
"sklearn.decomposition.PCA",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"numpy.asarray",
"numpy.linspace",
"mpl_toolkits.axes_grid1.make_axes_locatable",
"numpy.... | [((813, 846), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {}), "('ignore')\n", (836, 846), False, 'import warnings\n'), ((2614, 2654), 'pandas.read_pickle', 'pd.read_pickle', (["(root + '\\\\data\\\\' + file)"], {}), "(root + '\\\\data\\\\' + file)\n", (2628, 2654), True, 'import pandas as ... |
import pandas as pd
import numpy as np
import os, glob, logging, sys, time
import dev_capacity_calculation_module
NOW = time.strftime("%Y_%m%d_%H%M")
today = time.strftime('%Y_%m_%d')
## set up the directories
if os.getenv('USERNAME') =='ywang':
BOX_DIR = 'C:\\Users\\{}\\Box\\Modeling and Su... | [
"logging.getLogger",
"logging.StreamHandler",
"os.getenv",
"pandas.read_csv",
"logging.Formatter",
"pandas.merge",
"time.strftime",
"os.path.join",
"dev_capacity_calculation_module.set_allow_dev_type",
"logging.FileHandler",
"pandas.to_numeric"
] | [((122, 151), 'time.strftime', 'time.strftime', (['"""%Y_%m%d_%H%M"""'], {}), "('%Y_%m%d_%H%M')\n", (135, 151), False, 'import os, glob, logging, sys, time\n'), ((160, 185), 'time.strftime', 'time.strftime', (['"""%Y_%m_%d"""'], {}), "('%Y_%m_%d')\n", (173, 185), False, 'import os, glob, logging, sys, time\n'), ((1248,... |
import torch.nn as nn
import hypergan as hg
class Residual(hg.Layer):
"""
---
description: 'layer residual for configurable component'
---
# residual layer
`residual` adds one or more residual blocks https://paperswithcode.com/method/residual-block
## optional arg... | [
"torch.nn.Sequential",
"torch.nn.ReLU",
"torch.nn.Conv2d"
] | [((1135, 1157), 'torch.nn.Sequential', 'nn.Sequential', (['*layers'], {}), '(*layers)\n', (1148, 1157), True, 'import torch.nn as nn\n'), ((869, 940), 'torch.nn.Conv2d', 'nn.Conv2d', (['self.size.channels', 'self.size.channels', '(3)', '(1)'], {'padding': '(1, 1)'}), '(self.size.channels, self.size.channels, 3, 1, padd... |
import gnupg
import json
import os
import time
from django.conf import settings
from django.core.serializers.json import DjangoJSONEncoder
gpg = gnupg.GPG(gnupghome=settings.GPG_HOME_DIRECTORY)
gpg.encoding = 'utf-8'
class PersistenceError(Exception):
pass
def clear_user_data():
"""
Empty the user da... | [
"os.listdir",
"os.close",
"json.dumps",
"os.path.join",
"os.open",
"time.time",
"gnupg.GPG"
] | [((148, 196), 'gnupg.GPG', 'gnupg.GPG', ([], {'gnupghome': 'settings.GPG_HOME_DIRECTORY'}), '(gnupghome=settings.GPG_HOME_DIRECTORY)\n', (157, 196), False, 'import gnupg\n'), ((358, 398), 'os.listdir', 'os.listdir', (['settings.USER_DATA_DIRECTORY'], {}), '(settings.USER_DATA_DIRECTORY)\n', (368, 398), False, 'import o... |
from abc import ABC, abstractmethod
import numpy as np
from .activations import NoActivation
from .constants import EPSILON
from .initializers import Constant
from .optimizers import Momentum
class Layer(ABC):
@abstractmethod
def init_weights(self, num_input, optimizer, initializer):
pass
@abstrac... | [
"numpy.mean",
"numpy.sqrt",
"numpy.square",
"numpy.sum",
"numpy.dot",
"numpy.full"
] | [((1232, 1250), 'numpy.mean', 'np.mean', (['z'], {'axis': '(0)'}), '(z, axis=0)\n', (1239, 1250), True, 'import numpy as np\n'), ((1706, 1752), 'numpy.sum', 'np.sum', (['(self._z_norm * last_derivative)'], {'axis': '(0)'}), '(self._z_norm * last_derivative, axis=0)\n', (1712, 1752), True, 'import numpy as np\n'), ((176... |
#!/usr/bin/python3
# gdacs.py
import os
import json
from subprocess import Popen
from datetime import datetime
from selenium import webdriver
from time import sleep
from selenium.webdriver.firefox.options import Options
def download_geojson():
options = Options()
options.headless = True
profile = webdriv... | [
"datetime.datetime.strptime",
"selenium.webdriver.Firefox",
"time.sleep",
"os.path.dirname",
"selenium.webdriver.firefox.options.Options",
"selenium.webdriver.FirefoxProfile"
] | [((261, 270), 'selenium.webdriver.firefox.options.Options', 'Options', ([], {}), '()\n', (268, 270), False, 'from selenium.webdriver.firefox.options import Options\n'), ((313, 381), 'selenium.webdriver.FirefoxProfile', 'webdriver.FirefoxProfile', (['"""/root/.mozilla/firefox/hct90kvg.selenium"""'], {}), "('/root/.mozil... |
# -*- coding: utf-8 -*-
import graphene
import six
from django.db.models import Prefetch
from django.utils.encoding import force_text
from graphene_django import DjangoObjectType
from shuup.core.models import ProductAttribute, ProductMode, ShopProduct, ShopStatus, get_person_contact
from shuup.core.pricing._context imp... | [
"graphene.String",
"shuup.core.models.ProductAttribute.objects.all",
"graphene.Field",
"graphene.List",
"shuup.core.pricing._context.PricingContext",
"shuup.core.utils.prices.convert_taxness",
"shuup.core.shop_provider.get_shop",
"shuup.core.models.ShopProduct.objects.select_related",
"django.utils.... | [((1330, 1344), 'graphene.Int', 'graphene.Int', ([], {}), '()\n', (1342, 1344), False, 'import graphene\n'), ((1362, 1390), 'graphene.Field', 'graphene.Field', (['PricefulType'], {}), '(PricefulType)\n', (1376, 1390), False, 'import graphene\n'), ((1405, 1432), 'graphene.Field', 'graphene.Field', (['ProductType'], {}),... |
import socket
def getfromhostname(hostname):
print ("AS info for hostname :"+hostname)
ip = socket.gethostbyname(hostname)
from cymruwhois import Client
c=Client()
r=c.lookup(ip)
print (r.asn)
print (r.owner)
def getfromip(ip):
print ("AS info for IP : "+ip)
from cymruwhois import ... | [
"cymruwhois.Client",
"socket.gethostbyname"
] | [((101, 131), 'socket.gethostbyname', 'socket.gethostbyname', (['hostname'], {}), '(hostname)\n', (121, 131), False, 'import socket\n'), ((172, 180), 'cymruwhois.Client', 'Client', ([], {}), '()\n', (178, 180), False, 'from cymruwhois import Client\n'), ((333, 341), 'cymruwhois.Client', 'Client', ([], {}), '()\n', (339... |
import unittest
from mdiff.block_extractor import ConsecutiveIntegerBlockExtractor, NonIntegersBlockExtractor, \
OpCodeDeleteThenInsertBlockExtractor, ConsecutiveVectorBlockExtractor, extraction_inversion
from mdiff.utils import OpCode
class TestConsecutiveIntegerBlockExtractor(unittest.TestCase):
def test_... | [
"mdiff.utils.OpCode",
"mdiff.block_extractor.NonIntegersBlockExtractor",
"mdiff.block_extractor.ConsecutiveVectorBlockExtractor",
"mdiff.block_extractor.OpCodeDeleteThenInsertBlockExtractor",
"mdiff.block_extractor.extraction_inversion",
"mdiff.block_extractor.ConsecutiveIntegerBlockExtractor"
] | [((395, 432), 'mdiff.block_extractor.ConsecutiveIntegerBlockExtractor', 'ConsecutiveIntegerBlockExtractor', (['seq'], {}), '(seq)\n', (427, 432), False, 'from mdiff.block_extractor import ConsecutiveIntegerBlockExtractor, NonIntegersBlockExtractor, OpCodeDeleteThenInsertBlockExtractor, ConsecutiveVectorBlockExtractor, ... |
from typing import Sequence
import pytest
from faker import Faker
from overhave.entities import (
FeatureExtractor,
FeatureTypeExtractionError,
OverhaveFileSettings,
ScenariosTestFileNotFound,
)
from tests.objects import FeatureTestContainer, get_test_feature_extractor
from tests.unit.feature.conftest... | [
"tests.objects.get_test_feature_extractor",
"overhave.entities.FeatureExtractor",
"pytest.raises",
"tests.unit.feature.conftest.get_incorrect_test_file_settings"
] | [((1038, 1088), 'overhave.entities.FeatureExtractor', 'FeatureExtractor', ([], {'file_settings': 'test_file_settings'}), '(file_settings=test_file_settings)\n', (1054, 1088), False, 'from overhave.entities import FeatureExtractor, FeatureTypeExtractionError, OverhaveFileSettings, ScenariosTestFileNotFound\n'), ((663, 7... |
from happytransformer import HappyTextClassification
import json
def predict(text):
happy_tc = HappyTextClassification("DISTILBERT", "distilbert-base-uncased", num_labels=2)
result = happy_tc.classify_text(text)
#print(result) # TextClassificationResult(label='LABEL_0', score=0.9998761415481567)
... | [
"json.dumps",
"happytransformer.HappyTextClassification"
] | [((101, 179), 'happytransformer.HappyTextClassification', 'HappyTextClassification', (['"""DISTILBERT"""', '"""distilbert-base-uncased"""'], {'num_labels': '(2)'}), "('DISTILBERT', 'distilbert-base-uncased', num_labels=2)\n", (124, 179), False, 'from happytransformer import HappyTextClassification\n'), ((327, 432), 'js... |
import logging
import math
import torch
import torch.nn.functional as F
from torch import nn, Tensor
from .net import Generator
from metrics.lpips import PNetLin
log = logging.getLogger(__name__)
def preproc_image(image: Tensor) -> Tensor:
image = image.clamp(-1, 1)
# convert image to pixel range
# (-1... | [
"logging.getLogger",
"torch.manual_seed",
"torch.optim.Adam",
"torch.mean",
"metrics.lpips.PNetLin",
"torch.nn.functional.avg_pool2d",
"math.cos",
"torch.randn_like",
"torch.sum",
"torch.nn.functional.interpolate",
"torch.no_grad",
"torch.randn",
"torch.roll"
] | [((171, 198), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (188, 198), False, 'import logging\n'), ((483, 539), 'torch.nn.functional.interpolate', 'F.interpolate', (['image'], {'scale_factor': 'scale', 'mode': '"""nearest"""'}), "(image, scale_factor=scale, mode='nearest')\n", (496, 539... |
import datetime
import logging
import traceback
import aiohttp
import discord
from discord.ext import commands
from utils import formatting
log = logging.getLogger(__name__)
initial_extensions = [
'cogs.ants',
'cogs.autorole',
'cogs.joinleavelog',
'cogs.lobby',
'cogs.meta',
'cogs.moderation'... | [
"logging.getLogger",
"aiohttp.ClientSession",
"traceback.format_exc",
"utils.formatting.codeblock",
"datetime.datetime.utcnow",
"discord.Colour.red",
"utils.formatting.truncate"
] | [((149, 176), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (166, 176), False, 'import logging\n'), ((710, 747), 'aiohttp.ClientSession', 'aiohttp.ClientSession', ([], {'loop': 'self.loop'}), '(loop=self.loop)\n', (731, 747), False, 'import aiohttp\n'), ((1897, 1919), 'traceback.format_e... |
import tensorflow as tf
import numpy as np
class MultiHeadSelfAttention(tf.keras.layers.Layer):
def __init__(self, emb_dim = 768, n_head = 12, out_dim = None, relative_window_size = None, dropout_rate = 0., kernel_initializer = tf.keras.initializers.RandomNormal(mean = 0, stddev = 0.01), **kwargs):
#Scaled... | [
"tensorflow.equal",
"tensorflow.shape",
"tensorflow.keras.backend.epsilon",
"tensorflow.transpose",
"numpy.sqrt",
"tensorflow.keras.layers.Dense",
"tensorflow.nn.dropout",
"tensorflow.nn.softmax",
"tensorflow.cast",
"numpy.arange",
"tensorflow.keras.layers.Input",
"numpy.reshape",
"tensorflo... | [((12137, 12206), 'tensorflow.keras.layers.Input', 'tf.keras.layers.Input', ([], {'shape': '(None,)', 'name': '"""y_true"""', 'dtype': 'tf.float32'}), "(shape=(None,), name='y_true', dtype=tf.float32)\n", (12158, 12206), True, 'import tensorflow as tf\n'), ((12600, 12630), 'tensorflow.cast', 'tf.cast', (['_y_true', 'lo... |
from itertools import product
from pyramid.view import view_config
from sqlalchemy.orm import joinedload
from clld.db.meta import DBSession
from grammaticon.models import ConceptRelation
@view_config(route_name='relations', renderer='json')
def relations(req):
res = dict(edges=[], nodes=[])
nodes = {}
f... | [
"sqlalchemy.orm.joinedload",
"clld.db.meta.DBSession.query",
"pyramid.view.view_config"
] | [((192, 244), 'pyramid.view.view_config', 'view_config', ([], {'route_name': '"""relations"""', 'renderer': '"""json"""'}), "(route_name='relations', renderer='json')\n", (203, 244), False, 'from pyramid.view import view_config\n'), ((403, 437), 'sqlalchemy.orm.joinedload', 'joinedload', (['ConceptRelation.parent'], {}... |
# -*- coding: utf-8 -*-
import numpy as np
import taft
import shelve
from network import Network
from calcdata import CalcData
import utils
# Переменная для записи сообщений о ошибках
logMessage = ""
def getLastError():
global logMessage
return logMessage
# end of def getLastError()
# Загружает веса сети и... | [
"utils.createScale",
"taft.normalize",
"numpy.max",
"network.Network",
"numpy.array",
"numpy.zeros",
"shelve.open",
"taft.readFinam",
"numpy.min",
"numpy.shape"
] | [((4293, 4326), 'numpy.array', 'np.array', (['nnInputs'], {'dtype': '"""float"""'}), "(nnInputs, dtype='float')\n", (4301, 4326), True, 'import numpy as np\n'), ((4359, 4377), 'numpy.shape', 'np.shape', (['nnInputs'], {}), '(nnInputs)\n', (4367, 4377), True, 'import numpy as np\n'), ((4395, 4428), 'numpy.array', 'np.ar... |
version = '5.0'
import math
import pygame
import random
import time
from pygame.locals import Rect
from math import pi
import vectores
from vectores import Vector2
SIZE = WIDTH, HEIGHT = 800, 600 # Tamaño de pantalla
CENTER = (WIDTH//2, HEIGHT//2)
BLACK = (0, 0, 0) # Colores
WHITE = (255, 255, 255)
... | [
"pygame.init",
"pygame.quit",
"pygame.font.Font",
"pygame.draw.polygon",
"pygame.display.set_mode",
"pygame.mixer.Sound",
"pygame.draw.rect",
"pygame.image.load",
"pygame.display.update",
"vectores.Vector2",
"pygame.sprite.Group",
"pygame.time.Clock",
"vectores.Vector2.Right",
"vectores.Ve... | [((8710, 8723), 'pygame.init', 'pygame.init', ([], {}), '()\n', (8721, 8723), False, 'import pygame\n'), ((571, 586), 'vectores.Vector2', 'Vector2', (['origin'], {}), '(origin)\n', (578, 586), False, 'from vectores import Vector2\n'), ((591, 647), 'pygame.draw.line', 'pygame.draw.line', (['screen', 'color', 'origin', '... |
# Generated by Django 3.2.8 on 2021-10-31 13:32
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('ticket', '0009_auto_20211030_1947'),
]
operations = [
migrations.AddField(
model_name='ticket',
name='archived',
... | [
"django.db.models.BooleanField"
] | [((335, 401), 'django.db.models.BooleanField', 'models.BooleanField', ([], {'default': '(False)', 'verbose_name': '"""Ticket Archived"""'}), "(default=False, verbose_name='Ticket Archived')\n", (354, 401), False, 'from django.db import migrations, models\n')] |
import unittest
import prog
class TestClient(unittest.TestCase):
def test_insertion_sort(self):
parameters = (
([3], [3]),
([3, 4, 1, 2], [1, 2, 3, 4]),
([2, 5, 4, 1, 3, 2, 3], [1, 2, 2, 3, 3, 4, 5]),
)
for a, expected in parameters:
with s... | [
"unittest.main",
"prog.merge",
"prog.insertion_sort"
] | [((1453, 1479), 'unittest.main', 'unittest.main', ([], {'verbosity': '(2)'}), '(verbosity=2)\n', (1466, 1479), False, 'import unittest\n'), ((368, 390), 'prog.insertion_sort', 'prog.insertion_sort', (['a'], {}), '(a)\n', (387, 390), False, 'import prog\n'), ((974, 996), 'prog.merge', 'prog.merge', (['a', 'p', 'q', 'r']... |
import ast, collections, dis, types, sys
from functools import reduce
from itertools import chain
from check_subset import check_conformity
def Instruction(opcode, arg):
return bytes([opcode] if arg is None else [opcode, arg % 256, arg // 256])
def concat(assemblies): return b''.join(assemblies)
def SetLineNo... | [
"ast.parse",
"dis.opmap.items",
"ast.get_docstring",
"sys.argv.pop"
] | [((4331, 4346), 'sys.argv.pop', 'sys.argv.pop', (['(0)'], {}), '(0)\n', (4343, 4346), False, 'import ast, collections, dis, types, sys\n'), ((1054, 1071), 'ast.parse', 'ast.parse', (['source'], {}), '(source)\n', (1063, 1071), False, 'import ast, collections, dis, types, sys\n'), ((1217, 1237), 'ast.get_docstring', 'as... |
"""
test_search.py
Unit test the search.py script.
"""
import json
import os
import unittest
from py4web import request, response
from unittest.mock import Mock, patch
from scripts.search import search_for, validate_and_search
ERR_SEARCH_FOR_NULL = "(search_for) error: search_string null or empty"
ERR_VALIDATE_SEARCH_... | [
"scripts.search.search_for",
"unittest.mock.Mock",
"scripts.search.validate_and_search",
"os.path.dirname",
"json.load",
"unittest.mock.patch"
] | [((958, 983), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (973, 983), False, 'import os\n'), ((1055, 1080), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (1070, 1080), False, 'import os\n'), ((1241, 1284), 'unittest.mock.patch', 'patch', (['"""scripts.search.cal... |
from typing import Protocol
import numpy as np
class EmissionFunction(Protocol):
def __call__(
self,
distance_to_shell: np.ndarray,
observer_position: np.ndarray,
earth_position: np.ndarray,
unit_vectors: np.ndarray,
freq: float,
) -> np.ndarray:
"""Int... | [
"numpy.zeros",
"numpy.diff"
] | [((1698, 1723), 'numpy.diff', 'np.diff', (['radial_distances'], {}), '(radial_distances)\n', (1705, 1723), True, 'import numpy as np\n'), ((1751, 1783), 'numpy.zeros', 'np.zeros', (['unit_vectors.shape[-1]'], {}), '(unit_vectors.shape[-1])\n', (1759, 1783), True, 'import numpy as np\n')] |
"""
Draw Figures - Chapter 4
This script generates all of the figures that appear in Chapter 4 of the textbook.
Ported from MATLAB Code
<NAME>
24 March 2021
"""
import utils
from utils.unit_conversions import lin_to_db, db_to_lin
import matplotlib.pyplot as plt
from matplotlib.patches import Ellipse
import numpy as... | [
"matplotlib.pyplot.grid",
"numpy.sqrt",
"numpy.random.default_rng",
"examples.chapter4.example2",
"matplotlib.pyplot.ylabel",
"numpy.array",
"utils.unit_conversions.lin_to_db",
"scipy.stats.chi2.ppf",
"detector.xcorr.det_test",
"numpy.arange",
"seaborn.set",
"detector.squareLaw.det_test",
"s... | [((801, 822), 'matplotlib.pyplot.get_cmap', 'plt.get_cmap', (['"""tab10"""'], {}), "('tab10')\n", (813, 822), True, 'import matplotlib.pyplot as plt\n'), ((901, 925), 'numpy.random.default_rng', 'np.random.default_rng', (['(0)'], {}), '(0)\n', (922, 925), True, 'import numpy as np\n'), ((972, 1005), 'utils.init_output_... |
from .compression.compressfile import CompressFile
from .encryption.encryptedfile import EncryptedFile
import os
from ..cli import cli_library
class BackupFile:
def __init__(self, title, path_to_backup, ignores=None, intermediate_path='/tmp/'):
self.title = title
self.path = path_to_backup
... | [
"os.remove"
] | [((1479, 1515), 'os.remove', 'os.remove', (['self.saved_encrypted_path'], {}), '(self.saved_encrypted_path)\n', (1488, 1515), False, 'import os\n')] |
from dataclasses import replace
from collections import deque
from typing import Tuple, Iterable, Union
from .base import BarDataFeed
from ..utils import granularity_in_num
from ..dtypes import Bar, Tick, Timer, BAR_EMPTY
def fill_up(bars: BarDataFeed, interval):
bars = iter(bars)
curr = next(bars)
while ... | [
"dataclasses.replace"
] | [((579, 694), 'dataclasses.replace', 'replace', (['prev'], {'timestamp': '(prev.timestamp + interval)', 'open': '(0)', 'close': '(0)', 'high': '(0)', 'low': '(0)', 'volume': '(0)', 'currency_volume': '(0)'}), '(prev, timestamp=prev.timestamp + interval, open=0, close=0, high=0,\n low=0, volume=0, currency_volume=0)\... |
from typing import NamedTuple
Cast = NamedTuple(
"Cast",
hash=str,
content=str,
)
Caster = NamedTuple(
"Caster",
hash=str,
display_name=str,
activity_url=str,
)
| [
"typing.NamedTuple"
] | [((38, 79), 'typing.NamedTuple', 'NamedTuple', (['"""Cast"""'], {'hash': 'str', 'content': 'str'}), "('Cast', hash=str, content=str)\n", (48, 79), False, 'from typing import NamedTuple\n'), ((105, 171), 'typing.NamedTuple', 'NamedTuple', (['"""Caster"""'], {'hash': 'str', 'display_name': 'str', 'activity_url': 'str'}),... |
from werkzeug.wrappers import Request, Response
from indy import did,wallet,crypto
from indy_agent import Indy
import cgi
import json
import random
import asyncio
import base64
import sys
import jwt
conf = {}
wallet_handle = ""
pool_handle = ""
class PDSAdminHandler():
def __init__(self, wallet_handle = None):
... | [
"asyncio.new_event_loop",
"json.dumps",
"indy_agent.Indy.add_did_to_wallet",
"werkzeug.serving.run_simple",
"indy_agent.Indy.get_did_metadata",
"json.load",
"asyncio.set_event_loop",
"asyncio.get_event_loop",
"werkzeug.wrappers.Request"
] | [((2032, 2064), 'werkzeug.serving.run_simple', 'run_simple', (['"""0.0.0.0"""', '(9002)', 'app'], {}), "('0.0.0.0', 9002, app)\n", (2042, 2064), False, 'from werkzeug.serving import run_simple\n'), ((411, 435), 'asyncio.get_event_loop', 'asyncio.get_event_loop', ([], {}), '()\n', (433, 435), False, 'import asyncio\n'),... |
"""
Sample Python/Pygame Programs
Simpson College Computer Science
http://programarcadegames.com/
"""
import pygame
# Define some colors
BLACK = (0, 0, 0)
WHITE = (255, 255, 255)
GREEN = (0, 255, 0)
RED = (255, 0, 0)
# This sets the WIDTH and HEIGHT of each grid location
WIDTH = 40
HEIGHT = 40
# This sets the... | [
"pygame.display.set_caption",
"pygame.quit",
"pygame.init",
"pygame.event.get",
"pygame.display.set_mode",
"pygame.display.flip",
"pygame.mouse.get_pos",
"pygame.draw.rect",
"pygame.time.Clock"
] | [((1218, 1231), 'pygame.init', 'pygame.init', ([], {}), '()\n', (1229, 1231), False, 'import pygame\n'), ((1390, 1426), 'pygame.display.set_mode', 'pygame.display.set_mode', (['WINDOW_SIZE'], {}), '(WINDOW_SIZE)\n', (1413, 1426), False, 'import pygame\n'), ((1451, 1498), 'pygame.display.set_caption', 'pygame.display.se... |