code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
import pickle
from matplotlib import pyplot as plt
import torch
import seaborn as sns
import numpy as np
from src.src_vvCV_MD1P.stein_operators import *
from src.src_vvCV_MD1P.sv_CV import *
from src.src_vvCV_MD1P.vv_CV_MD1P import *
from src.src_vvCV_MD1P.vv_CV_FixB_MD1P import *
from src.src_vvCV_MD1P.vv_CV_unbalan... | [
"numpy.sqrt",
"torch.sqrt",
"seaborn.set_style",
"numpy.arange",
"seaborn.color_palette",
"torch.eye",
"numpy.linspace",
"torch.randn",
"torch.Tensor",
"pickle.load",
"torch.cat",
"matplotlib.pyplot.show",
"torch.manual_seed",
"torch.stack",
"torch.zeros",
"torch.no_grad",
"matplotli... | [((495, 515), 'torch.Tensor', 'torch.Tensor', (['[1, 1]'], {}), '([1, 1])\n', (507, 515), False, 'import torch\n'), ((9837, 9859), 'seaborn.set_style', 'sns.set_style', (['"""white"""'], {}), "('white')\n", (9850, 9859), True, 'import seaborn as sns\n'), ((9868, 9894), 'torch.cat', 'torch.cat', (['(X1, X2)'], {'dim': '... |
# -*- coding: utf-8 -*-
import datetime
import sqlalchemy
from sqlalchemy import orm
from sqlalchemy_serializer import SerializerMixin
from .db_session import SqlAlchemyBase
from .model import Model
class Games(SqlAlchemyBase, SerializerMixin, Model):
__tablename__ = 'games'
id = sqlalchemy.Column(sqlalchemy... | [
"datetime.datetime",
"sqlalchemy.orm.relationship",
"sqlalchemy.orm.relation",
"sqlalchemy.ForeignKey",
"datetime.datetime.now",
"sqlalchemy.Column"
] | [((292, 367), 'sqlalchemy.Column', 'sqlalchemy.Column', (['sqlalchemy.Integer'], {'primary_key': '(True)', 'autoincrement': '(True)'}), '(sqlalchemy.Integer, primary_key=True, autoincrement=True)\n', (309, 367), False, 'import sqlalchemy\n'), ((380, 444), 'sqlalchemy.Column', 'sqlalchemy.Column', (['sqlalchemy.String']... |
import re
import itertools
import os
import pandas as pd
import numpy as np
from prettytable import PrettyTable
from tqdm import tqdm
def get_char(seq):
"""split string int sequence of chars returned in pandas.Series"""
chars = list(seq)
return pd.Series(chars)
class SeqProcessConfig(object):
def __i... | [
"pandas.Series",
"prettytable.PrettyTable",
"numpy.where",
"itertools.product",
"tqdm.tqdm",
"os.path.join",
"pandas.DataFrame",
"pandas.concat"
] | [((259, 275), 'pandas.Series', 'pd.Series', (['chars'], {}), '(chars)\n', (268, 275), True, 'import pandas as pd\n'), ((1640, 1653), 'prettytable.PrettyTable', 'PrettyTable', ([], {}), '()\n', (1651, 1653), False, 'from prettytable import PrettyTable\n'), ((2618, 2631), 'prettytable.PrettyTable', 'PrettyTable', ([], {}... |
#!/usr/bin/env python3
# It does work with Python 2.7, too.
from __future__ import print_function
from __future__ import unicode_literals
try:
from SocketServer import TCPServer, BaseRequestHandler
except ImportError: # Python 3
from socketserver import TCPServer, BaseRequestHandler
class DummyHandler(BaseRe... | [
"socketserver.TCPServer"
] | [((953, 991), 'socketserver.TCPServer', 'TCPServer', (['listen_config', 'DummyHandler'], {}), '(listen_config, DummyHandler)\n', (962, 991), False, 'from socketserver import TCPServer, BaseRequestHandler\n')] |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Using CNN to create descriptors and neural layer to predict
object recognition in images.
By: <NAME>, <NAME>, and <NAME>.
MLDM Master's Year 2
Fall Semester 2017
"""
import os
###############################################################################
#Set Params... | [
"keras.preprocessing.image.img_to_array",
"keras.applications.inception_v3.preprocess_input",
"matplotlib.pyplot.imshow",
"os.listdir",
"xml.etree.ElementTree.parse",
"numpy.repeat",
"matplotlib.pyplot.barh",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.yticks",
"pandas.DataFrame",
"matplotlib... | [((331, 398), 'os.listdir', 'os.listdir', (['"""D:/GD/MLDM/Computer_Vision_Project/cnn5/data/training"""'], {}), "('D:/GD/MLDM/Computer_Vision_Project/cnn5/data/training')\n", (341, 398), False, 'import os\n'), ((8223, 8240), 'keras.models.load_model', 'load_model', (['model'], {}), '(model)\n', (8233, 8240), False, 'f... |
import os
import requests
import yaml
import re
import html
from dotenv import load_dotenv
from typing import List
# define config object
config = {
"api_key": "",
"api_url": "",
"output_dir": "",
"save_html": False,
"docs": [],
"increase_heading_levels": 1,
}
# load config from file
with open... | [
"yaml.full_load",
"os.getenv",
"re.compile",
"yaml.dump",
"html.unescape",
"os.path.join",
"requests.get",
"dotenv.load_dotenv",
"os.path.isdir",
"os.mkdir",
"re.sub"
] | [((410, 423), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (421, 423), False, 'from dotenv import load_dotenv\n'), ((444, 464), 'os.getenv', 'os.getenv', (['"""API_KEY"""'], {}), "('API_KEY')\n", (453, 464), False, 'import os\n'), ((928, 988), 're.compile', 're.compile', (['"""<br\\\\s?/>\\\\s?"""'], {'flags'... |
# -*- coding: utf-8 -*-
#
# Copyright (C) 2018 CERN.
#
# Invenio-Records-Editor
# is free software; you can redistribute it and/or modify
# it under the terms of the MIT License; see LICENSE file for more details.
"""Bundle definition for record editor."""
from __future__ import absolute_import, division, print_func... | [
"invenio_assets.NpmBundle",
"flask_assets.Bundle"
] | [((479, 823), 'invenio_assets.NpmBundle', 'NpmBundle', (["('%s/inline.bundle.js' % EDITOR_PATH)", "('%s/polyfills.bundle.js' % EDITOR_PATH)", "('%s/vendor.bundle.js' % EDITOR_PATH)", "('%s/main.bundle.js' % EDITOR_PATH)"], {'depends': "('%s/*.js' % EDITOR_PATH)", 'filters': '"""uglifyjs"""', 'output': '"""gen/invenio-r... |
import click
from omegaconf import OmegaConf
from mlad.cli import config
from mlad.cli.autocompletion import get_config_key_completion
from . import echo_exception
@click.command()
@click.option('--address', '-a', default='http://localhost:8440',
prompt='MLAppDeploy Service Address', help='Set service a... | [
"click.argument",
"click.option",
"click.group",
"omegaconf.OmegaConf.to_yaml",
"click.echo",
"mlad.cli.config.env",
"mlad.cli.config.set",
"mlad.cli.config.init",
"mlad.cli.config.get",
"click.command"
] | [((167, 182), 'click.command', 'click.command', ([], {}), '()\n', (180, 182), False, 'import click\n'), ((184, 319), 'click.option', 'click.option', (['"""--address"""', '"""-a"""'], {'default': '"""http://localhost:8440"""', 'prompt': '"""MLAppDeploy Service Address"""', 'help': '"""Set service address"""'}), "('--add... |
from typing import List,Dict
import torch
from torch import nn
import numpy as np
from torch.nn import functional as F
from functools import partial
from detectron2.config import configurable
from detectron2.layers import Conv2d, ConvTranspose2d, cat, interpolate, DeformConv
from detectron2.structures import ... | [
"numpy.tile",
"torch.nn.ReLU",
"torch.nn.GroupNorm",
"numpy.repeat",
"numpy.sqrt",
"torch.nn.init.constant_",
"numpy.arange",
"torch.nn.Sequential",
"detectron2.layers.DeformConv",
"numpy.log",
"torch.nn.Conv2d",
"numpy.stack",
"torch.tensor",
"detectron2.utils.registry.Registry",
"funct... | [((531, 556), 'detectron2.utils.registry.Registry', 'Registry', (['"""REPPOINT_HEAD"""'], {}), "('REPPOINT_HEAD')\n", (539, 556), False, 'from detectron2.utils.registry import Registry\n'), ((803, 844), 'torch.nn.init.normal_', 'nn.init.normal_', (['module.weight', 'mean', 'std'], {}), '(module.weight, mean, std)\n', (... |
"""handle requests relative to mu-calculus checking"""
from flask import Blueprint, Response, request
import json
from base.webserver_utils import apply_on_node
import flex
from flex.loading.schema.paths.path_item.operation.responses.single.schema\
import schema_validator
import os
import subprocess
mu_blueprin... | [
"json.dumps",
"flask.Blueprint"
] | [((324, 359), 'flask.Blueprint', 'Blueprint', (['"""mu_blueprint"""', '__name__'], {}), "('mu_blueprint', __name__)\n", (333, 359), False, 'from flask import Blueprint, Response, request\n'), ((663, 678), 'json.dumps', 'json.dumps', (['rep'], {}), '(rep)\n', (673, 678), False, 'import json\n')] |
import json
import random
import sys
import requests
from rich.console import Console
from piston.utils.constants import PistonQuery, SPINNERS
def query_piston(console: Console, payload: PistonQuery) -> dict:
"""Send a post request to the piston API with the code parameter."""
output_json = {
"langu... | [
"json.dumps",
"random.choice",
"sys.exit"
] | [((490, 513), 'random.choice', 'random.choice', (['SPINNERS'], {}), '(SPINNERS)\n', (503, 513), False, 'import random\n'), ((775, 852), 'sys.exit', 'sys.exit', (['"""Connection timed out. Please check your connection and try again."""'], {}), "('Connection timed out. Please check your connection and try again.')\n", (7... |
"""Enforce adding a pip install statement in the notebook.
In the `compwa-org repo <https://github.com/ComPWA/compwa-org>_`, notebooks
should specify which package versions should be used to run the notebook. This
hook checks whether a notebook has such install statements and whether they
comply with the expected form... | [
"nbformat.read",
"argparse.ArgumentParser"
] | [((574, 629), 'nbformat.read', 'nbformat.read', (['filename'], {'as_version': 'nbformat.NO_CONVERT'}), '(filename, as_version=nbformat.NO_CONVERT)\n', (587, 629), False, 'import nbformat\n'), ((3828, 3860), 'argparse.ArgumentParser', 'argparse.ArgumentParser', (['__doc__'], {}), '(__doc__)\n', (3851, 3860), False, 'imp... |
# -*- coding: utf-8 -*-
"""
Test and look for unknown tokens using PromQLLexer
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
:copyright: Copyright 2006-2020 by the Pygments team, see AUTHORS.
:license: BSD, see LICENSE for details.
"""
from pygments.lexers import get_lexer_by_name
from pygments.to... | [
"pygments.lexers.get_lexer_by_name"
] | [((443, 470), 'pygments.lexers.get_lexer_by_name', 'get_lexer_by_name', (['"""promql"""'], {}), "('promql')\n", (460, 470), False, 'from pygments.lexers import get_lexer_by_name\n')] |
from sqlalchemy import create_engine, MetaData, Table, Column, Integer, String, Text, DateTime, BigInteger
from sqlalchemy.orm import mapper, sessionmaker
class Solucion(object):
pass
class Resultado(object):
__tablename__ = 'resultados'
id = Column(Integer, primary_key=True)
numero_reinas = Column... | [
"sqlalchemy.orm.sessionmaker",
"sqlalchemy.Table",
"sqlalchemy.DateTime",
"sqlalchemy.orm.mapper",
"sqlalchemy.create_engine",
"sqlalchemy.MetaData",
"sqlalchemy.Column"
] | [((260, 293), 'sqlalchemy.Column', 'Column', (['Integer'], {'primary_key': '(True)'}), '(Integer, primary_key=True)\n', (266, 293), False, 'from sqlalchemy import create_engine, MetaData, Table, Column, Integer, String, Text, DateTime, BigInteger\n'), ((314, 329), 'sqlalchemy.Column', 'Column', (['Integer'], {}), '(Int... |
"""
####################
Create a low hydro scenario
Date applied: 2021-07-29
Description:
This script adds a scenario to the database for low hydro power.
The worst year for hydro is 2015. As such we use those values for every year unless a plant is missing
in 2015 in which case we use the lowest value in the other y... | [
"switch_model.wecc.utilities.connect",
"switch_model.utilities.query_yes_no",
"pandas.concat",
"time.time"
] | [((886, 895), 'switch_model.wecc.utilities.connect', 'connect', ([], {}), '()\n', (893, 895), False, 'from switch_model.wecc.utilities import connect\n'), ((3373, 3422), 'pandas.concat', 'pd.concat', (['[worst_year_data, missing_plants_data]'], {}), '([worst_year_data, missing_plants_data])\n', (3382, 3422), True, 'imp... |
"""
Python wrapper to download steam with arguments, or a CLI
Plans to make this interactable from a web client.
-----------------
Requirements
steamcmd installed and working (Probably needs the 32 bit libraries.
see:
https://developer.valvesoftware.com/wiki/SteamCMD#Linux.2FOS_X
"""
import logging
import pprin... | [
"logging.getLogger",
"json.load",
"logging.StreamHandler",
"pprint.pformat"
] | [((372, 408), 'logging.getLogger', 'logging.getLogger', (['"""SteamDownloader"""'], {}), "('SteamDownloader')\n", (389, 408), False, 'import logging\n'), ((450, 473), 'logging.StreamHandler', 'logging.StreamHandler', ([], {}), '()\n', (471, 473), False, 'import logging\n'), ((1049, 1075), 'json.load', 'json.load', (['c... |
# coding=utf-8
import os
from .base import *
DEBUG = True
THUMBNAIL_DEBUG = True
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(BASE_DIR, 'database.db'),
},
}
CACHES = {
'default': {
'BACKEND': 'django.core.cache.backends.locmem.LocMemCache... | [
"os.path.join"
] | [((346, 377), 'os.path.join', 'os.path.join', (['BASE_DIR', '"""media"""'], {}), "(BASE_DIR, 'media')\n", (358, 377), False, 'import os\n'), ((178, 215), 'os.path.join', 'os.path.join', (['BASE_DIR', '"""database.db"""'], {}), "(BASE_DIR, 'database.db')\n", (190, 215), False, 'import os\n')] |
"""Blog Controller
Controls backend functionality of the blog, including:
* create/edit/delete blog posts
* create/edit/delete blog post comments
* like and unlike blog posts
"""
from google.appengine.ext import db
from handler import Handler
from blog_model import *
class BlogHandler(Handler):
"""Generic web ... | [
"google.appengine.ext.db.get"
] | [((1420, 1431), 'google.appengine.ext.db.get', 'db.get', (['key'], {}), '(key)\n', (1426, 1431), False, 'from google.appengine.ext import db\n'), ((3194, 3205), 'google.appengine.ext.db.get', 'db.get', (['key'], {}), '(key)\n', (3200, 3205), False, 'from google.appengine.ext import db\n'), ((3769, 3780), 'google.appeng... |
import logging as log
from util.table import max_projection, projection
from operator import mul
#
# Performs the max marginal operation on a clique tree, using the clique with
# index clique_id as the root
#
def max_marginal(tree, assignment):
#root = tree.cliques[clique_id]
root_id = tree.root.index
root_belie... | [
"util.table.projection",
"util.table.max_projection"
] | [((2075, 2104), 'util.table.projection', 'projection', (['table', 'assignment'], {}), '(table, assignment)\n', (2085, 2104), False, 'from util.table import max_projection, projection\n'), ((1139, 1176), 'util.table.max_projection', 'max_projection', (['clique.belief', 'sepset'], {}), '(clique.belief, sepset)\n', (1153,... |
#
# Copyright 2022 DMetaSoul
#
# 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, ... | [
"pyarrow.BufferOutputStream",
"pyarrow.string",
"metaspore_pb2_grpc.PredictStub",
"pyarrow.BufferReader",
"grpc.insecure_channel",
"pyarrow.ipc.new_file",
"pyarrow.csv.ConvertOptions",
"metaspore_pb2.PredictRequest",
"pyarrow.ipc.read_tensor",
"pyarrow.csv.ReadOptions",
"pyarrow.csv.ParseOptions... | [((1214, 1252), 'grpc.insecure_channel', 'grpc.insecure_channel', (['"""0.0.0.0:50051"""'], {}), "('0.0.0.0:50051')\n", (1235, 1252), False, 'import grpc\n'), ((1276, 1315), 'metaspore_pb2_grpc.PredictStub', 'metaspore_pb2_grpc.PredictStub', (['channel'], {}), '(channel)\n', (1306, 1315), False, 'import metaspore_pb2_g... |
import random
from hathor.crypto.util import decode_address
from hathor.graphviz import GraphvizVisualizer
from hathor.simulator import FakeConnection
from tests import unittest
from tests.utils import add_blocks_unlock_reward
class BaseHathorSyncMempoolTestCase(unittest.TestCase):
__test__ = False
def setU... | [
"random.choice",
"hathor.crypto.util.decode_address",
"hathor.graphviz.GraphvizVisualizer",
"hathor.simulator.FakeConnection",
"tests.utils.add_blocks_unlock_reward"
] | [((2292, 2331), 'tests.utils.add_blocks_unlock_reward', 'add_blocks_unlock_reward', (['self.manager1'], {}), '(self.manager1)\n', (2316, 2331), False, 'from tests.utils import add_blocks_unlock_reward\n'), ((2929, 2968), 'hathor.simulator.FakeConnection', 'FakeConnection', (['self.manager1', 'manager2'], {}), '(self.ma... |
import math
import os
from collections import Counter, defaultdict
from json_to_timedict import json_to_timedict
import numpy as np
from centroid_history import get_centroid_area_history, displacement_history
from file_utils import basename
def analyze_centroid_area_history(files, num_frames_per_iteration=... | [
"centroid_history.displacement_history",
"centroid_history.get_centroid_area_history",
"file_utils.basename"
] | [((997, 1091), 'centroid_history.get_centroid_area_history', 'get_centroid_area_history', (['files[start_index:end_index]'], {'debug': '(False)', 'key_format': '"""from_to"""'}), "(files[start_index:end_index], debug=False,\n key_format='from_to')\n", (1022, 1091), False, 'from centroid_history import get_centroid_a... |
import re
def sam(args_query):
with args_query as f:
que_sam = [s.strip() for s in f]
return que_sam
def fasta(args_reference):
regex = re.compile("(>.*?)\n([ATGCNatgcn\n]*)", re.DOTALL)
with open(args_reference, 'r') as f:
content = f.read()
fasta_dict = {}
for i in ... | [
"re.findall",
"re.compile"
] | [((160, 212), 're.compile', 're.compile', (['"""(>.*?)\n([ATGCNatgcn\n]*)"""', 're.DOTALL'], {}), '("""(>.*?)\n([ATGCNatgcn\n]*)""", re.DOTALL)\n', (170, 212), False, 'import re\n'), ((320, 346), 're.findall', 're.findall', (['regex', 'content'], {}), '(regex, content)\n', (330, 346), False, 'import re\n')] |
import matplotlib.pyplot as plt
import tensorflow as tf
import numpy as np
import os
class Trainer(object):
def __init__(self, sess, epoch=None, print_every=100):
"""
Initialize Trainer variables
Input:
- sess: tf.sess declared outside Trainer
- epoch: the number of... | [
"tensorflow.summary.merge_all",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.plot",
"tensorflow.global_variables_initializer",
"tensorflow.train.GradientDescentOptimizer",
"tensorflow.summary.FileWriter"
] | [((1060, 1082), 'tensorflow.summary.merge_all', 'tf.summary.merge_all', ([], {}), '()\n', (1080, 1082), True, 'import tensorflow as tf\n'), ((1106, 1159), 'tensorflow.summary.FileWriter', 'tf.summary.FileWriter', (['"""logs/train/"""', 'self.sess.graph'], {}), "('logs/train/', self.sess.graph)\n", (1127, 1159), True, '... |
# -*- coding: utf-8 -*-
"""
Profile: http://hl7.org/fhir/StructureDefinition/ClinicalUseIssue
Release: R5
Version: 4.5.0
Build ID: 0d95498
Last updated: 2021-04-03T00:34:11.075+00:00
"""
from pydantic.validators import bytes_validator # noqa: F401
from fhir.resources import fhirtypes # noqa: F401
from fhir.resources ... | [
"fhir.resources.clinicaluseissue.ClinicalUseIssue.parse_file",
"fhir.resources.clinicaluseissue.ClinicalUseIssue"
] | [((1735, 1845), 'fhir.resources.clinicaluseissue.ClinicalUseIssue.parse_file', 'clinicaluseissue.ClinicalUseIssue.parse_file', (['filename'], {'content_type': '"""application/json"""', 'encoding': '"""utf-8"""'}), "(filename, content_type=\n 'application/json', encoding='utf-8')\n", (1779, 1845), False, 'from fhir.r... |
"""
The :mod:`pyfan.graph.example.scatterline3` generates a graprh with three lines.
This is the functionalized vesrion of `plot_randgrid Example <https://pyfan.readthedocs.io/en/latest/auto_examples/plot_randgrid.html#sphx-glr-auto-examples-plot-randgrid-py>`_.
Includes method :func:`gph_scatter_line_rand`.
"""
impo... | [
"matplotlib.pyplot.grid",
"pyfan.util.timer.timer.getDateTime",
"argparse.ArgumentParser",
"matplotlib.pyplot.ylabel",
"pyfan.aws.general.path.save_img",
"matplotlib.pyplot.xlabel",
"numpy.column_stack",
"pyfan.gen.rand.randgrid.ar_draw_random_normal",
"matplotlib.pyplot.title",
"matplotlib.pyplot... | [((611, 636), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (634, 636), False, 'import argparse\n'), ((3535, 3649), 'pyfan.gen.rand.randgrid.ar_draw_random_normal', 'pyfan_gen_rand.ar_draw_random_normal', (['fl_mu', 'fl_sd', 'it_draws', 'it_seed', 'it_draw_type', 'fl_lower_sd', 'fl_higher_sd']... |
import socket
print(" _____ _ _____ _ _ ")
print(" | __ \ | | / ____| (_) | ")
print(" | | | | __ _ _ __| |_ _____| (___ ___ ___ _ _ _ __ _| |_ _ _ ")
print(" | | | |/ _` | '__| __|______\___ \ / _ \/ __| | | | '__|... | [
"socket.gethostbyname_ex",
"socket.gethostbyname",
"socket.gethostname",
"socket.getfqdn"
] | [((887, 906), 'socket.getfqdn', 'socket.getfqdn', (['url'], {}), '(url)\n', (901, 906), False, 'import socket\n'), ((955, 980), 'socket.gethostbyname', 'socket.gethostbyname', (['url'], {}), '(url)\n', (975, 980), False, 'import socket\n'), ((1114, 1134), 'socket.gethostname', 'socket.gethostname', ([], {}), '()\n', (1... |
import torch
import torch.nn as nn
import torchvision.models as models
class EncoderCNN(nn.Module):
def __init__(self, embed_size):
super(EncoderCNN, self).__init__()
resnet = models.resnet50(pretrained=True)
for param in resnet.parameters():
param.requires_grad_(False)
... | [
"torch.nn.Sequential",
"torch.nn.LSTM",
"torch.nn.init.xavier_uniform_",
"torch.cat",
"torch.cuda.is_available",
"torch.nn.Linear",
"torchvision.models.resnet50",
"torch.zeros",
"torch.nn.Embedding"
] | [((197, 229), 'torchvision.models.resnet50', 'models.resnet50', ([], {'pretrained': '(True)'}), '(pretrained=True)\n', (212, 229), True, 'import torchvision.models as models\n'), ((390, 413), 'torch.nn.Sequential', 'nn.Sequential', (['*modules'], {}), '(*modules)\n', (403, 413), True, 'import torch.nn as nn\n'), ((435,... |
import os
import errno
import re
import dbt.clients.git
import dbt.clients.system
import dbt.project as project
from dbt.compat import basestring
from dbt.logger import GLOBAL_LOGGER as logger
from dbt.task.base_task import BaseTask
def folder_from_git_remote(remote_spec):
start = remote_spec.rfind('/') + 1
... | [
"dbt.compat.basestring",
"os.path.join"
] | [((1138, 1172), 'os.path.join', 'os.path.join', (['modules_path', 'folder'], {}), '(modules_path, folder)\n', (1150, 1172), False, 'import os\n'), ((3255, 3328), 'os.path.join', 'os.path.join', (["self.project['modules-path']", 'dep_folder', '"""dbt_project.yml"""'], {}), "(self.project['modules-path'], dep_folder, 'db... |
import gym
from gym import error, spaces, utils
from gym.utils import seeding
import numpy as np
import torch
import random
import sys
import os
class UDNEnv(gym.Env):
metadata = {}
def __init__(self):
self.BSposition = np.loadtxt('BSposition.csv', delimiter=',')
self.BSnum = len(self.BSpo... | [
"numpy.mean",
"numpy.log10",
"numpy.ones",
"numpy.log2",
"numpy.linalg.norm",
"gym.spaces.Discrete",
"numpy.sum",
"numpy.random.randint",
"numpy.zeros",
"numpy.cos",
"numpy.argmin",
"numpy.random.uniform",
"numpy.sin",
"numpy.loadtxt"
] | [((242, 285), 'numpy.loadtxt', 'np.loadtxt', (['"""BSposition.csv"""'], {'delimiter': '""","""'}), "('BSposition.csv', delimiter=',')\n", (252, 285), True, 'import numpy as np\n'), ((369, 424), 'numpy.loadtxt', 'np.loadtxt', (['"""InterferenceBSposition.csv"""'], {'delimiter': '""","""'}), "('InterferenceBSposition.csv... |
import csv
from .ParamGenerator import ParamGenerator
class CSVParamGenerator(ParamGenerator):
def __init__(self):
self.source = []
self.count = 0
def set_source(self, source):
try:
with open(source, newline='') as f:
reader = csv.reader(f)
... | [
"csv.reader"
] | [((291, 304), 'csv.reader', 'csv.reader', (['f'], {}), '(f)\n', (301, 304), False, 'import csv\n')] |
#!/usr/bin/env python
# -*- coding:utf-8 -*-
# @Author: <NAME>
from sonarqube.utils.rest_client import RestClient
from sonarqube.utils.config import (
API_PROJECT_BRANCHES_LIST_ENDPOINT,
API_PROJECT_BRANCHES_DELETE_ENDPOINT,
API_PROJECT_BRANCHES_RENAME_ENDPOINT,
API_PROJECT_BRANCHES_SET_PROTECTION_ENDPO... | [
"sonarqube.utils.common.POST",
"sonarqube.utils.common.GET"
] | [((630, 669), 'sonarqube.utils.common.GET', 'GET', (['API_PROJECT_BRANCHES_LIST_ENDPOINT'], {}), '(API_PROJECT_BRANCHES_LIST_ENDPOINT)\n', (633, 669), False, 'from sonarqube.utils.common import GET, POST\n'), ((860, 902), 'sonarqube.utils.common.POST', 'POST', (['API_PROJECT_BRANCHES_DELETE_ENDPOINT'], {}), '(API_PROJE... |
#!/usr/bin/env python
"""Functions to replace variables in a string with their values from a dict.
"""
import copy
import re
from astropy.io import fits
import despymisc.miscutils as miscutils
import intgutils.intgdefs as intgdefs
import despyfitsutils.fitsutils as fitsutils
def replace_vars_single(instr, valdict,... | [
"despymisc.miscutils.fwdebug_print",
"despymisc.miscutils.fwdebug_check",
"despymisc.miscutils.dynamically_load_class",
"copy.deepcopy",
"despymisc.miscutils.fwsplit",
"astropy.io.fits.open",
"despyfitsutils.fitsutils.get_hdr_value",
"re.sub",
"copy.copy",
"re.search"
] | [((1307, 1323), 'copy.copy', 'copy.copy', (['instr'], {}), '(instr)\n', (1316, 1323), False, 'import copy\n'), ((1440, 1465), 're.search', 're.search', (['varpat', 'newstr'], {}), '(varpat, newstr)\n', (1449, 1465), False, 'import re\n'), ((8993, 9033), 'despymisc.miscutils.fwdebug_check', 'miscutils.fwdebug_check', ([... |
"""
python app/app.py -> http://0.0.0.0:8080/
"""
from app.models.database import db, ma
from flask_session import Session
from flask_api import FlaskAPI, status
from flask_assets import Environment
from flask_cors import CORS
from flask import jsonify
import logging
import time
from routes.main_db import main_db_bp
f... | [
"flask_cors.CORS",
"flask.jsonify",
"flask_session.Session",
"flask_api.FlaskAPI",
"app.models.database.db.init_app",
"flask_assets.Environment",
"app.models.database.ma.init_app"
] | [((375, 393), 'flask_api.FlaskAPI', 'FlaskAPI', (['__name__'], {}), '(__name__)\n', (383, 393), False, 'from flask_api import FlaskAPI, status\n'), ((429, 485), 'flask_cors.CORS', 'CORS', (['app'], {'resources': '"""/api/*"""', 'supports_credentials': '(True)'}), "(app, resources='/api/*', supports_credentials=True)\n"... |
# Copyright 2020 PerfKitBenchmarker 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... | [
"mock.patch",
"mock.Mock",
"unittest.main",
"perfkitbenchmarker.traces.tcpdump._CreateCollector",
"absl.testing.flagsaver.flagsaver"
] | [((1613, 1652), 'absl.testing.flagsaver.flagsaver', 'flagsaver.flagsaver', ([], {'tcpdump_snaplen': '(10)'}), '(tcpdump_snaplen=10)\n', (1632, 1652), False, 'from absl.testing import flagsaver\n'), ((1731, 1769), 'absl.testing.flagsaver.flagsaver', 'flagsaver.flagsaver', ([], {'tcpdump_snaplen': '(0)'}), '(tcpdump_snap... |
from appengine_sessions.backends.db import SessionStore
from appengine_sessions.mapper import DeleteMapper
from appengine_sessions.models import Session
from datetime import datetime
from django.contrib.sessions.backends.base import SessionBase
from django.http import HttpResponse
from django.views.generic.base import ... | [
"django.http.HttpResponse",
"datetime.datetime.utcnow"
] | [((648, 694), 'django.http.HttpResponse', 'HttpResponse', (['"""Session cleaner mapper started"""'], {}), "('Session cleaner mapper started')\n", (660, 694), False, 'from django.http import HttpResponse\n'), ((580, 597), 'datetime.datetime.utcnow', 'datetime.utcnow', ([], {}), '()\n', (595, 597), False, 'from datetime ... |
"""A naive example of dependency injection on Python.
Example implementation of dependency injection in Python from Martin Fowler's
article about dependency injection and inversion of control:
http://www.martinfowler.com/articles/injection.html
This mini application uses ``movies`` library, that is configured to wor... | [
"dependency_injector.providers.Callable",
"dependency_injector.containers.override",
"dependency_injector.providers.Factory"
] | [((572, 612), 'dependency_injector.containers.override', 'containers.override', (['movies.MoviesModule'], {}), '(movies.MoviesModule)\n', (591, 612), True, 'import dependency_injector.containers as containers\n'), ((756, 901), 'dependency_injector.providers.Factory', 'providers.Factory', (['movies.finders.CsvMovieFinde... |
from glue.config import data_factory
from glue.core import Data
import pandas as pd
from pathlib import Path
from glue_genomics_viewers.data import BedPeData
__all__ = ['is_bedpe', 'read_bedpe']
def is_bedpe(filename, **kwargs):
return filename.endswith('.bedpe')
@data_factory('BEDPE data loader', is_bedpe, p... | [
"glue_genomics_viewers.data.BedPeData",
"glue.config.data_factory"
] | [((275, 332), 'glue.config.data_factory', 'data_factory', (['"""BEDPE data loader"""', 'is_bedpe'], {'priority': '(999)'}), "('BEDPE data loader', is_bedpe, priority=999)\n", (287, 332), False, 'from glue.config import data_factory\n'), ((781, 801), 'glue_genomics_viewers.data.BedPeData', 'BedPeData', (['file_name'], {... |
# Copyright 2016 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
import copy
import unittest
from analysis.linear import feature
from analysis.linear.feature import ChangedFile
from analysis.linear.feature import MetaFeat... | [
"libs.math.logarithms.log",
"analysis.linear.linear_testcase.Feature0",
"copy.deepcopy",
"analysis.linear.linear_testcase.Feature3",
"analysis.linear.feature.LogLinearlyScaled",
"analysis.linear.feature.ChangedFile",
"analysis.linear.feature.LinearlyScaled",
"analysis.linear.linear_testcase.Feature1",... | [((2331, 2358), 'copy.deepcopy', 'copy.deepcopy', (['self.feature'], {}), '(self.feature)\n', (2344, 2358), False, 'import copy\n'), ((2731, 2741), 'analysis.linear.linear_testcase.Feature0', 'Feature0', ([], {}), '()\n', (2739, 2741), False, 'from analysis.linear.linear_testcase import Feature0\n'), ((2757, 2767), 'an... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import json
import os
import regex as re
fontmap_directory = os.path.dirname(__file__) + '/fontmaps/'
fontmaps = {}
for font in ['JG_Pahawh_Third_Version', 'JG_Pahawh_Final_Version']:
fontmaps['{}.ttf'.format(font)] = json.load(open(fontmap_directory + '{}.json'.for... | [
"os.path.dirname",
"regex.sub"
] | [((110, 135), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (125, 135), False, 'import os\n'), ((592, 663), 'regex.sub', 're.sub', (['"""\\\\u1004\\\\u1039([\\\\u1000-\\\\u1021\\\\u1025])"""', '"""င်္\\\\g<1>"""', 'string'], {}), "('\\\\u1004\\\\u1039([\\\\u1000-\\\\u1021\\\\u1025])', 'င်္\\... |
from typing import NoReturn
import pytest
from lazycoco.stack import MyStack, EmptyStackException
def test_int_push_three_and_pop_one() -> NoReturn:
# Given
stack: MyStack[int] = MyStack()
stack.push(1)
stack.push(2)
stack.push(3)
# When
element: int = stack.pop()
# Then
assert... | [
"pytest.raises",
"lazycoco.stack.MyStack"
] | [((191, 200), 'lazycoco.stack.MyStack', 'MyStack', ([], {}), '()\n', (198, 200), False, 'from lazycoco.stack import MyStack, EmptyStackException\n'), ((518, 527), 'lazycoco.stack.MyStack', 'MyStack', ([], {}), '()\n', (525, 527), False, 'from lazycoco.stack import MyStack, EmptyStackException\n'), ((1665, 1674), 'lazyc... |
#!/usr/bin/env python
import socket
import sys
import time
message = ['This is the message. Send from client "127.0.0.1" on port "2016"',
'This is a second message. Send from client "127.0.0.1" on port "2016"']
i = 0
while True:
try:
# Create a TCP/IP socket
sock = socket.socket(s... | [
"time.sleep",
"socket.socket"
] | [((305, 354), 'socket.socket', 'socket.socket', (['socket.AF_INET', 'socket.SOCK_STREAM'], {}), '(socket.AF_INET, socket.SOCK_STREAM)\n', (318, 354), False, 'import socket\n'), ((753, 766), 'time.sleep', 'time.sleep', (['(2)'], {}), '(2)\n', (763, 766), False, 'import time\n')] |
import numpy as np
import sys
import qoi as qoi
import parallel as par
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ !
# ~~~~ Selection without replacement
# ~~~~ Sample K numbers from an array 0...N-1 and output them
# ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~... | [
"numpy.random.normal",
"numpy.mean",
"numpy.random.rand",
"parallel.printRoot",
"numpy.floor",
"parallel.partitionSim",
"numpy.exp",
"numpy.linspace",
"numpy.zeros",
"numpy.argwhere",
"numpy.sum",
"sys.exit",
"numpy.load",
"numpy.amax"
] | [((1027, 1056), 'parallel.partitionSim', 'par.partitionSim', (["Sim['NRep']"], {}), "(Sim['NRep'])\n", (1043, 1056), True, 'import parallel as par\n'), ((1855, 1895), 'numpy.linspace', 'np.linspace', (['minLevel', 'maxLevel', 'nLevels'], {}), '(minLevel, maxLevel, nLevels)\n', (1866, 1895), True, 'import numpy as np\n'... |
# -*- coding: utf-8 -*-
#
# Enteletaor - https://github.com/cr0hn/enteletaor
#
# Redistribution and use in source and binary forms, with or without modification, are permitted provided that the
# following conditions are met:
#
# 1. Redistributions of source code must retain the above copyright notice, this list of con... | [
"logging.getLogger",
"os.path.exists",
"os.path.join",
"os.path.dirname",
"os.path.abspath",
"logging.error"
] | [((1805, 1824), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (1822, 1824), False, 'import logging\n'), ((1758, 1783), 'logging.getLogger', 'logging.getLogger', (['"""amqp"""'], {}), "('amqp')\n", (1775, 1783), False, 'import logging\n'), ((2130, 2185), 'logging.error', 'logging.error', (['""" <!> target... |
"""
IP socket address
"""
import sys
import socket
import threading
import time
import socket
import lib_util
import lib_common
from lib_properties import pc
def EntityOntology():
return ( ["Id"],)
# TODO: Add the network card.
# This returns a nice name given the parameter of the object.
def EntityName(entity_ids... | [
"lib_common.gUriGen.AddrUri",
"threading.Thread.__init__",
"socket.getfqdn",
"threading.Lock",
"lib_util.GlobalGetHostByName",
"lib_common.NodeUrl",
"lib_common.NodeLiteral",
"lib_common.gUriGen.HostnameUri",
"socket.inet_aton",
"socket.getservbyname",
"socket.gethostbyaddr",
"lib_common.MakeP... | [((617, 628), 'time.time', 'time.time', ([], {}), '()\n', (626, 628), False, 'import time\n'), ((835, 875), 'lib_util.GlobalGetHostByName', 'lib_util.GlobalGetHostByName', (['socketAddr'], {}), '(socketAddr)\n', (863, 875), False, 'import lib_util\n'), ((887, 898), 'time.time', 'time.time', ([], {}), '()\n', (896, 898)... |
from torch import nn
from train_nn_single_GPU import train_nn
from utility import try_gpu, load_data_fashion_mnist
def vgg_block(num_convs, in_channels, out_channels):
layers = []
for _ in range(num_convs):
layers.append(
nn.Conv2d(in_channels, out_channels, kernel_size=3, padding=1))
... | [
"torch.nn.ReLU",
"torch.nn.Dropout",
"utility.load_data_fashion_mnist",
"torch.nn.Sequential",
"torch.nn.Flatten",
"torch.nn.Conv2d",
"utility.try_gpu",
"torch.nn.MaxPool2d",
"torch.nn.Linear"
] | [((452, 474), 'torch.nn.Sequential', 'nn.Sequential', (['*layers'], {}), '(*layers)\n', (465, 474), False, 'from torch import nn\n'), ((1359, 1417), 'utility.load_data_fashion_mnist', 'load_data_fashion_mnist', ([], {'batch_size': 'batch_size', 'resize': '(224)'}), '(batch_size=batch_size, resize=224)\n', (1382, 1417),... |
from re import search
from bs4 import BeautifulSoup
from requests import get
from integrations.uni import Uniswap
class Ether:
'''Etherscan adaptor.'''
def __init__(self, *args, **kwargs):
self.base_url = 'https://etherscan.io/tokens?p={}'
self.headers = {
"authority": "etherscan... | [
"bs4.BeautifulSoup",
"integrations.uni.Uniswap",
"re.search"
] | [((1274, 1313), 'integrations.uni.Uniswap', 'Uniswap', ([], {'address': 'None', 'private_key': 'None'}), '(address=None, private_key=None)\n', (1281, 1313), False, 'from integrations.uni import Uniswap\n'), ((1571, 1614), 'bs4.BeautifulSoup', 'BeautifulSoup', (['response.text', '"""html.parser"""'], {}), "(response.tex... |
import sys
class DynamicTerminalOutput:
def __init__(self, start_output):
self.last_output = start_output
print(start_output)
def update(self, new_output: str):
self._clear_previous()
print(new_output)
self.last_output = new_output
def clear(self):
self.up... | [
"sys.stdout.write"
] | [((465, 491), 'sys.stdout.write', 'sys.stdout.write', (['"""\x1b[F"""'], {}), "('\\x1b[F')\n", (481, 491), False, 'import sys\n'), ((526, 552), 'sys.stdout.write', 'sys.stdout.write', (['"""\x1b[K"""'], {}), "('\\x1b[K')\n", (542, 552), False, 'import sys\n')] |
#-*- coding: utf-8 -*-
from setuptools import setup, find_packages
import pip
def install(package):
pip.main(['install', package])
install('git+git://github.com/ernw/python-wcfbin.git')
setup(
name='openair',
version='0.1.17',
keywords = ('aqi', 'air', 'china'),
description='This project is to fe... | [
"setuptools.setup",
"pip.main"
] | [((193, 837), 'setuptools.setup', 'setup', ([], {'name': '"""openair"""', 'version': '"""0.1.17"""', 'keywords': "('aqi', 'air', 'china')", 'description': '"""This project is to fetch data from the official Silverlight application of Ministry of Environmental Protection of China (http://172.16.31.10:20035/), which publ... |
import functions.functions as functions
import os
from tkinter import messagebox
from tkinter import *
if __name__ == "__main__":
settings = functions.import_settings()
source = settings['source_directory']
root = Tk()
root.withdraw()
for subdir, dirs, files in os.walk(source):
for filena... | [
"functions.functions.convert_boxnote",
"tkinter.messagebox.showinfo",
"os.walk",
"functions.functions.import_settings"
] | [((146, 173), 'functions.functions.import_settings', 'functions.import_settings', ([], {}), '()\n', (171, 173), True, 'import functions.functions as functions\n'), ((285, 300), 'os.walk', 'os.walk', (['source'], {}), '(source)\n', (292, 300), False, 'import os\n'), ((526, 628), 'tkinter.messagebox.showinfo', 'messagebo... |
"""
Teamleader Helper functions
"""
from teamleader.api import Teamleader
from teamleader.exceptions import InvalidInputError
def vat_liability_to_invoice(customer_vat_liability, tariff='21', service=False):
'''Determine invoice line vat term based on default tariff and customer VAT liability.
'''
tariff... | [
"teamleader.exceptions.InvalidInputError"
] | [((406, 446), 'teamleader.exceptions.InvalidInputError', 'InvalidInputError', (['"""Invalid VAT tariff."""'], {}), "('Invalid VAT tariff.')\n", (423, 446), False, 'from teamleader.exceptions import InvalidInputError\n'), ((1388, 1460), 'teamleader.exceptions.InvalidInputError', 'InvalidInputError', (['"""Invalid conten... |
#!/usr/bin/env python
# coding: utf-8
"""
run consensus analysis to identify overall pattern
analysis method developed by <NAME> and <NAME>
"""
import os
import sys
import glob
import numpy
import nibabel
import nilearn.plotting
import nilearn.input_data
import matplotlib.pyplot as plt
from statsmodels.stats.multites... | [
"numpy.sqrt",
"nibabel.load",
"statsmodels.stats.multitest.multipletests",
"os.path.exists",
"numpy.mean",
"sys._getframe",
"matplotlib.pyplot.close",
"os.mkdir",
"numpy.eye",
"numpy.ones",
"numpy.corrcoef",
"numpy.triu_indices_from",
"nibabel.Nifti1Image",
"utils.log_to_file",
"narps.Na... | [((879, 900), 'numpy.ones', 'numpy.ones', (['(npts, 1)'], {}), '((npts, 1))\n', (889, 900), False, 'import numpy\n'), ((1653, 1691), 'utils.log_to_file', 'log_to_file', (['logfile', "('%s' % func_name)"], {}), "(logfile, '%s' % func_name)\n", (1664, 1691), False, 'from utils import log_to_file\n'), ((3597, 3635), 'util... |
import os
import sys
import time
sys.path.append(os.path.abspath('./utils'))
import argparse
from mai import *
from pmnet import *
parser = argparse.ArgumentParser(description='si2mu')
parser.add_argument('--backbone', default='resnet50', metavar='MODEL', help='vggnet16, inceptionv3, resnet50, nasnet (default: resnet... | [
"os.path.abspath",
"time.localtime",
"argparse.ArgumentParser"
] | [((142, 186), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""si2mu"""'}), "(description='si2mu')\n", (165, 186), False, 'import argparse\n'), ((49, 75), 'os.path.abspath', 'os.path.abspath', (['"""./utils"""'], {}), "('./utils')\n", (64, 75), False, 'import os\n'), ((3403, 3419), 'time.l... |
from tspec.loader import TGraph, TNode
from tspec.reporter import GenericReporter
from typing import List
from tspec.search.helpers import *
import signal
class GenericSearch:
def __init__(self, spec: str, reporter: GenericReporter, obj):
self.spec = spec
self._stop = False
self.best = Non... | [
"tspec.loader.TGraph",
"signal.signal"
] | [((422, 434), 'tspec.loader.TGraph', 'TGraph', (['spec'], {}), '(spec)\n', (428, 434), False, 'from tspec.loader import TGraph, TNode\n'), ((1411, 1446), 'signal.signal', 'signal.signal', (['signal.SIGTERM', 'hdlr'], {}), '(signal.SIGTERM, hdlr)\n', (1424, 1446), False, 'import signal\n'), ((1455, 1489), 'signal.signal... |
"""remove auth_token
Revision ID: 4753005aff55
Revises: <PASSWORD>
Create Date: 2014-10-14 19:25:01.267434
"""
# revision identifiers, used by Alembic.
revision = '4753005aff55'
down_revision = '<PASSWORD>'
from alembic import op
import sqlalchemy as sa
def upgrade():
op.drop_column('user', 'auth_token')
d... | [
"alembic.op.drop_column"
] | [((279, 315), 'alembic.op.drop_column', 'op.drop_column', (['"""user"""', '"""auth_token"""'], {}), "('user', 'auth_token')\n", (293, 315), False, 'from alembic import op\n')] |
from copy import deepcopy
from enum import Enum
class TokenTypes(Enum):
MAIN = -2 # temp token
QUOTATION_MARK = -1 # temp token
SKIP = 0
COMMENT = 1
OP = 2
NEWLINE = 3
ENDMARKER = 4
MISMATCH = 5
STRING = 6
... | [
"copy.deepcopy"
] | [((2226, 2240), 'copy.deepcopy', 'deepcopy', (['self'], {}), '(self)\n', (2234, 2240), False, 'from copy import deepcopy\n'), ((3893, 3907), 'copy.deepcopy', 'deepcopy', (['self'], {}), '(self)\n', (3901, 3907), False, 'from copy import deepcopy\n')] |
import scrapy
class ProjectsSpider(scrapy.Spider):
name = "group_person"
def start_requests(self):
urls = ['http://www.media.mit.edu/search/?page=1&filter=group',
'http://www.media.mit.edu/search/?page=2&filter=group']
for url in urls:
yield scrapy.Request(url=url,... | [
"scrapy.Request"
] | [((297, 341), 'scrapy.Request', 'scrapy.Request', ([], {'url': 'url', 'callback': 'self.parse'}), '(url=url, callback=self.parse)\n', (311, 341), False, 'import scrapy\n'), ((934, 1024), 'scrapy.Request', 'scrapy.Request', ([], {'url': 'group[1]', 'callback': 'self.parse_group', 'meta': "{'group_name': group[0]}"}), "(... |
import os
import socket
import time
from textwrap import dedent
def attack(ip, port):
global sent
global max
sock.sendto(str.encode(bytes), (ip, int(port)))
sent += 1
print(
"\033[36m%s пакетов убила сервер (остановка Ctrl+z) - %s:%s" % (sent, ip, port)
)
if mode == "y":
... | [
"os.system",
"time.sleep",
"socket.socket",
"textwrap.dedent"
] | [((397, 445), 'socket.socket', 'socket.socket', (['socket.AF_INET', 'socket.SOCK_DGRAM'], {}), '(socket.AF_INET, socket.SOCK_DGRAM)\n', (410, 445), False, 'import socket\n'), ((447, 465), 'os.system', 'os.system', (['"""clear"""'], {}), "('clear')\n", (456, 465), False, 'import os\n'), ((1317, 1335), 'os.system', 'os.s... |
import numpy as np
from multiprocessing import Process, Queue
from mxnet.io import DataIter, DataBatch
import mxnet as mx
import numpy as np
from mxnet.io import DataIter
from PIL import Image
import os
import preprocessing
import logging
import sys
#rgb_mean=(140.5192, 59.6655, 63.8419), #mean on tote trainval
cla... | [
"PIL.Image.fromarray",
"numpy.random.rand",
"preprocessing.calc_crop_params",
"multiprocessing.Process",
"os.path.join",
"mxnet.io.DataBatch",
"preprocessing.pad_image",
"numpy.array",
"preprocessing.random_flip",
"numpy.concatenate",
"numpy.expand_dims",
"mxnet.nd.array",
"multiprocessing.Q... | [((1715, 1734), 'multiprocessing.Queue', 'Queue', ([], {'maxsize': '(1000)'}), '(maxsize=1000)\n', (1720, 1734), False, 'from multiprocessing import Process, Queue\n'), ((1764, 1804), 'multiprocessing.Process', 'Process', ([], {'target': 'self._produce_flist_item'}), '(target=self._produce_flist_item)\n', (1771, 1804),... |
from tkinter import *
from tkinter import messagebox as MSG
from PIL import Image, ImageTk
count=0
def WithPc():
# Design the window
root1 = Tk()
root1.geometry("550x390")
root1.title('AI Tic Tac Toe ')
root1.resizable(False, False)
root1.config(bg="#CAFAFE")
root1.iconbitma... | [
"tkinter.messagebox.showwarning",
"PIL.Image.open",
"tkinter.messagebox.showinfo",
"PIL.ImageTk.PhotoImage"
] | [((362, 391), 'PIL.Image.open', 'Image.open', (['"""tic-tac-toe.png"""'], {}), "('tic-tac-toe.png')\n", (372, 391), False, 'from PIL import Image, ImageTk\n'), ((404, 430), 'PIL.ImageTk.PhotoImage', 'ImageTk.PhotoImage', (['image1'], {}), '(image1)\n', (422, 430), False, 'from PIL import Image, ImageTk\n'), ((5586, 565... |
from django import template
from core.models import Order
from django.contrib.auth.decorators import login_required
register = template.Library()
@login_required
@register.simple_tag
def product_cart_item_count(user,slug):
obj = Order.objects.filter(user__username=user,ordered=False)
if obj.exists():
... | [
"django.template.Library",
"core.models.Order.objects.filter"
] | [((129, 147), 'django.template.Library', 'template.Library', ([], {}), '()\n', (145, 147), False, 'from django import template\n'), ((236, 292), 'core.models.Order.objects.filter', 'Order.objects.filter', ([], {'user__username': 'user', 'ordered': '(False)'}), '(user__username=user, ordered=False)\n', (256, 292), False... |
# -*- coding: utf-8 -*-
"""
Created on Thu Aug 6 12:45:35 2020
@author: Abhilash
"""
import numpy as np
import pandas as pd
import tensorflow as tf
from tensorflow import keras
from keras import backend as k
from keras.layers import LSTM,Dense,Flatten,Bidirectional
from keras.activations import softmax,relu,elu,sigm... | [
"keras.backend.sum",
"keras.backend.dot",
"keras.backend.epsilon",
"keras.backend.tanh",
"keras.backend.expand_dims",
"keras.backend.exp"
] | [((817, 833), 'keras.backend.dot', 'k.dot', (['z', 'kernel'], {}), '(z, kernel)\n', (822, 833), True, 'from keras import backend as k\n'), ((4051, 4066), 'keras.backend.tanh', 'k.tanh', (['weights'], {}), '(weights)\n', (4057, 4066), True, 'from keras import backend as k\n'), ((4131, 4147), 'keras.backend.exp', 'k.exp'... |
from algo import Algorithms
import pathfinder_gui
import DataStructures
def main():
choice = pathfinder_gui.options()
pathfinder_gui.main()
alg = Algorithms()
if choice == "BF":
alg.Breadthfirst()
elif choice == "DF":
alg.Depthfirst()
elif choice == "A*":
... | [
"pathfinder_gui.main",
"pathfinder_gui.options",
"algo.Algorithms"
] | [((105, 129), 'pathfinder_gui.options', 'pathfinder_gui.options', ([], {}), '()\n', (127, 129), False, 'import pathfinder_gui\n'), ((135, 156), 'pathfinder_gui.main', 'pathfinder_gui.main', ([], {}), '()\n', (154, 156), False, 'import pathfinder_gui\n'), ((168, 180), 'algo.Algorithms', 'Algorithms', ([], {}), '()\n', (... |
#!/usr/bin/env python3
import argparse
import logging
import math
import os
import re
import sys
#class Chunk(object):
# def __init__(self, fname, offset, length):
# self.file = open(fname, 'rb')
# self.seek(offset)
# self.length = length
#
# def tell(self):
# actual_pos = self.file.... | [
"math.ceil",
"argparse.ArgumentParser",
"sys.stdout.write",
"os.path.realpath",
"sys.stderr.write",
"os.stat",
"sys.stdout.flush",
"re.search"
] | [((4098, 4123), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (4121, 4123), False, 'import argparse\n'), ((2862, 2902), 're.search', 're.search', (['self._search', 's', 're.MULTILINE'], {}), '(self._search, s, re.MULTILINE)\n', (2871, 2902), False, 'import re\n'), ((1429, 1443), 'os.stat', 'os... |
from .. import Utils
from SimPEG.EM.Base import BaseEMProblem
from .SurveyDC import Survey
from .FieldsDC import FieldsDC, Fields_CC, Fields_N
import numpy as np
import scipy as sp
from SimPEG.Utils import Zero
from .BoundaryUtils import getxBCyBC_CC
class BaseDCProblem(BaseEMProblem):
"""
Base DC Problem
... | [
"numpy.ones_like",
"numpy.hstack",
"numpy.zeros",
"scipy.sparse.find",
"SimPEG.Utils.Zero"
] | [((1663, 1676), 'numpy.hstack', 'np.hstack', (['Jv'], {}), '(Jv)\n', (1672, 1676), True, 'import numpy as np\n'), ((1934, 1950), 'numpy.zeros', 'np.zeros', (['m.size'], {}), '(m.size)\n', (1942, 1950), True, 'import numpy as np\n'), ((5010, 5016), 'SimPEG.Utils.Zero', 'Zero', ([], {}), '()\n', (5014, 5016), False, 'fro... |
import urllib.parse
from wikked.db.base import NoWantedPages
from wikked.page import WantedPage
from wikked.utils import get_absolute_url
from wikked.webimpl import (
get_page_meta, get_page_or_raise, make_page_title,
is_page_readable, get_redirect_target,
get_or_build_pagelist, get_generic_page... | [
"wikked.webimpl.make_page_title",
"wikked.webimpl.get_redirect_target",
"wikked.webimpl.is_page_readable",
"wikked.webimpl.get_page_or_raise",
"wikked.webimpl.get_page_meta",
"wikked.webimpl.get_generic_pagelist_builder",
"wikked.webimpl.get_or_build_pagelist",
"wikked.utils.get_absolute_url",
"wikk... | [((1724, 1784), 'wikked.webimpl.get_or_build_pagelist', 'get_or_build_pagelist', (['wiki', '"""orphans"""', 'builder_func', 'fields'], {}), "(wiki, 'orphans', builder_func, fields)\n", (1745, 1784), False, 'from wikked.webimpl import get_page_meta, get_page_or_raise, make_page_title, is_page_readable, get_redirect_targ... |
#
# Copyright 2018 Amazon.com, Inc. or its affiliates. All Rights Reserved.
#
# Permission is hereby granted, free of charge, to any person obtaining a copy of this
# software and associated documentation files (the "Software"), to deal in the Software
# without restriction, including without limitation the rights to ... | [
"logging.getLogger",
"json.dumps",
"projectdir.gremlin_python.structure.graph.Graph",
"bibot_helpers.increment_counter",
"projectdir.gremlin_python.driver.driver_remote_connection.DriverRemoteConnection"
] | [((1442, 1461), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (1459, 1461), False, 'import logging\n'), ((1550, 1691), 'projectdir.gremlin_python.driver.driver_remote_connection.DriverRemoteConnection', 'DriverRemoteConnection', (['"""ws://neptunedbcluster-cxu2i0c92g94.cluster-cryiyy1ygf5o.us-east-1.neptu... |
# -*- coding: utf-8 -*-
# Define your item pipelines here
#
# Don't forget to add your pipeline to the ITEM_PIPELINES setting
# See: https://doc.scrapy.org/en/latest/topics/item-pipeline.html
import pymysql
class MysqlpjtPipeline(object):
def __init__(self):
# 与数据库建立连接
self.conn = pymysql.connec... | [
"pymysql.connect"
] | [((306, 391), 'pymysql.connect', 'pymysql.connect', ([], {'host': '"""localhost"""', 'user': '"""root"""', 'passwd': '"""<PASSWORD>"""', 'db': '"""cobweb"""'}), "(host='localhost', user='root', passwd='<PASSWORD>', db='cobweb'\n )\n", (321, 391), False, 'import pymysql\n')] |
#!/opt/local/bin/python2.7
# -*- coding: utf-8 -*-
__author__ = 'naras_mg'
import wx
def detectLang(ch):
start_end = {0:[0x0900,0x097F],1:[0x980, 0x9ff],2:[0xa00, 0xa7f], 3:[0xa80, 0xaff], \
4:[0x0900,0x097F],5:[0xb00, 0xb7f],6:[0xb80, 0xbff],7:[0xc00, 0xc7f],8:[0xc80, 0xcff]}
for k,v in start_en... | [
"wx.ComboBox",
"wx.StaticText",
"wx.TextCtrl",
"wx.App",
"wx.Panel"
] | [((2674, 2682), 'wx.App', 'wx.App', ([], {}), '()\n', (2680, 2682), False, 'import wx\n'), ((1572, 1586), 'wx.Panel', 'wx.Panel', (['self'], {}), '(self)\n', (1580, 1586), False, 'import wx\n'), ((1600, 1648), 'wx.StaticText', 'wx.StaticText', (['pnl', '(-1)', '"""Transliterate Language"""'], {}), "(pnl, -1, 'Translite... |
"""MIT License
Copyright (c) 2021 veil-ctf
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distr... | [
"requests.Session",
"colorama.init"
] | [((1120, 1126), 'colorama.init', 'init', ([], {}), '()\n', (1124, 1126), False, 'from colorama import Fore, init\n'), ((2118, 2136), 'requests.Session', 'requests.Session', ([], {}), '()\n', (2134, 2136), False, 'import requests\n')] |
from turtle import Turtle, Screen
import colorgram
import random
color_list = []
def get_colors():
colors = colorgram.extract('image.jpg', 30)
for color in colors:
colour_tuple = (color.rgb.r, color.rgb.g, color.rgb.b)
color_list.append(colour_tuple)
def paint(my_turtle):
... | [
"turtle.Screen",
"random.choice",
"turtle.Turtle",
"colorgram.extract"
] | [((1015, 1023), 'turtle.Turtle', 'Turtle', ([], {}), '()\n', (1021, 1023), False, 'from turtle import Turtle, Screen\n'), ((1061, 1069), 'turtle.Screen', 'Screen', ([], {}), '()\n', (1067, 1069), False, 'from turtle import Turtle, Screen\n'), ((123, 157), 'colorgram.extract', 'colorgram.extract', (['"""image.jpg"""', '... |
# -*- coding: utf-8 -*-
import time
import functools
import logging
from flask_caching import Cache
from .lock import Lock
logger = logging.getLogger(__name__)
class GuldanCache(Cache):
def __init__(self, **kwargs):
super(GuldanCache, self).__init__(**kwargs)
def _make_cache_key(self, f, *args, **kw... | [
"logging.getLogger",
"time.time",
"functools.wraps"
] | [((133, 160), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (150, 160), False, 'import logging\n'), ((2596, 2614), 'functools.wraps', 'functools.wraps', (['f'], {}), '(f)\n', (2611, 2614), False, 'import functools\n'), ((2007, 2025), 'functools.wraps', 'functools.wraps', (['f'], {}), '(f... |
import unittest
from pydictdb import core
from pydictdb import storages
class DatabaseTestCase(unittest.TestCase):
def test_init_commit(self):
sto = storages.MemoryStorage()
sto._memory = {'User': {'name': 'Sam'}}
database = core.Database(storage=sto)
self.assertEqual(database._ta... | [
"pydictdb.core.Database",
"pydictdb.core.Table",
"pydictdb.storages.MemoryStorage"
] | [((164, 188), 'pydictdb.storages.MemoryStorage', 'storages.MemoryStorage', ([], {}), '()\n', (186, 188), False, 'from pydictdb import storages\n'), ((256, 282), 'pydictdb.core.Database', 'core.Database', ([], {'storage': 'sto'}), '(storage=sto)\n', (269, 282), False, 'from pydictdb import core\n'), ((577, 592), 'pydict... |
from googlefinance import getQuotes
from yahoo_finance import Share
from dateutil.parser import parse
import datetime
import csv
import os
import logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
MONGO_DB = 'tomastocks'
GOOGLE_TYPE = 'goog'
GOOGLE_FINAL_PRICE_FIELD = 'LastTra... | [
"logging.basicConfig",
"logging.getLogger",
"dateutil.parser.parse",
"datetime.datetime.fromtimestamp",
"googlefinance.getQuotes",
"csv.writer",
"os.path.isfile",
"datetime.datetime.now",
"os.mkdir",
"os.stat",
"datetime.timedelta",
"yahoo_finance.Share"
] | [((160, 199), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (179, 199), False, 'import logging\n'), ((209, 236), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (226, 236), False, 'import logging\n'), ((1848, 1881), 'logging.getLog... |
from datetime import datetime
import os
from os.path import join
import pandas as pd
from pathlib import Path
import pickle
import spacy
import sys
import torch
from torch import optim
from torch.nn import Embedding, LSTM
from torch.nn.functional import mse_loss
from torch.utils.data import TensorDataset
from torch.uti... | [
"notebooks.datatools.EqualOpDataLoader",
"notebooks.nets.EuclideanDiscriminator",
"notebooks.datatools.AuthorDataset",
"torch.seed",
"notebooks.pipes.PackSequence",
"notebooks.pipes.POSTokenize",
"os.path.exists",
"pathlib.Path",
"spacy.load",
"torch.nn.LSTM",
"torch.logical_not",
"os.path.isd... | [((394, 404), 'pathlib.Path', 'Path', (['""".."""'], {}), "('..')\n", (398, 404), False, 'from pathlib import Path\n'), ((755, 782), 'notebooks.utils.init_data_dir', 'init_data_dir', (['project_root'], {}), '(project_root)\n', (768, 782), False, 'from notebooks.utils import init_data_dir\n'), ((853, 868), 'torch.device... |
# /bin/python3.5
from math import fabs
class CipherExceptions(Exception):
def __init__(self, msg):
super(CipherExceptions, self).__init__(msg)
def gcd_by_euclid(a, b):
if a < 0 or b < 0:
a = fabs(a)
b = fabs(b)
if b == 0:
return int(a)
if b > a:
gcd_by_euclid... | [
"math.fabs"
] | [((220, 227), 'math.fabs', 'fabs', (['a'], {}), '(a)\n', (224, 227), False, 'from math import fabs\n'), ((240, 247), 'math.fabs', 'fabs', (['b'], {}), '(b)\n', (244, 247), False, 'from math import fabs\n')] |
from random import randint
itens = ('Papel', 'Tesoura', 'Pedra')
computador = randint(0, 2)
print('''Escolha uma opção abaixo:
[ 0 ] Papel
[ 1 ] Tesoura
[ 2 ] Pedra''')
opcao = int(input('Qual opção deseja: '))
print(f'O computador jogou {itens[computador]}!')
print(f'Você jogou {itens[opcao]}')
if computador == 0:
... | [
"random.randint"
] | [((78, 91), 'random.randint', 'randint', (['(0)', '(2)'], {}), '(0, 2)\n', (85, 91), False, 'from random import randint\n')] |
from tqdm import tqdm
from dirutility import DirPaths
def unique(list1, list2):
"""
Get unique items in list1 that are not in list2
:return: Unique items only in list 1
"""
set2 = set(list2)
list1_unique = [x for x in tqdm(list1, desc='Unique', total=len(list1)) if x not in set2]
return l... | [
"dirutility.gui.CompareTreesGUI",
"dirutility.DirPaths",
"databasetools.DictTools"
] | [((768, 785), 'dirutility.gui.CompareTreesGUI', 'CompareTreesGUI', ([], {}), '()\n', (783, 785), False, 'from dirutility.gui import CompareTreesGUI\n'), ((598, 612), 'dirutility.DirPaths', 'DirPaths', (['dir1'], {}), '(dir1)\n', (606, 612), False, 'from dirutility import DirPaths\n'), ((633, 647), 'dirutility.DirPaths'... |
#!/usr/bin/env python
# coding=utf-8
from flask import Blueprint
cms_bp = Blueprint('cms', __name__, subdomain='cms')
from . import views | [
"flask.Blueprint"
] | [((75, 118), 'flask.Blueprint', 'Blueprint', (['"""cms"""', '__name__'], {'subdomain': '"""cms"""'}), "('cms', __name__, subdomain='cms')\n", (84, 118), False, 'from flask import Blueprint\n')] |
import pytest
from typing import Tuple
import torch
import kornia as kornia
from torch.testing import assert_allclose
from torch.autograd import gradcheck
import utils # test utils
class TestBoxBlur:
def test_shape(self):
inp = torch.zeros(1, 3, 4, 4)
blur = kornia.filters.BoxBlur((3, 3))
... | [
"torch.testing.assert_allclose",
"kornia.filters.box_blur",
"torch.tensor",
"kornia.filters.BoxBlur",
"utils.tensor_to_gradcheck_var",
"torch.autograd.gradcheck",
"torch.zeros",
"torch.rand"
] | [((245, 268), 'torch.zeros', 'torch.zeros', (['(1)', '(3)', '(4)', '(4)'], {}), '(1, 3, 4, 4)\n', (256, 268), False, 'import torch\n'), ((284, 314), 'kornia.filters.BoxBlur', 'kornia.filters.BoxBlur', (['(3, 3)'], {}), '((3, 3))\n', (306, 314), True, 'import kornia as kornia\n'), ((409, 432), 'torch.zeros', 'torch.zero... |
"""
Mask R-CNN
Common utility functions and classes.
Copyright (c) 2017 Matterport, Inc.
Licensed under the MIT License (see LICENSE_MATTERPORT for details)
Written by <NAME>
Copyright (c) 2021 Skinet Team
Licensed under the MIT License (see LICENSE for details)
Updated/Modified by <NAME>
"""
import json
import loggi... | [
"zipfile.ZipFile",
"datasetTools.datasetDivider.getBWCount",
"numpy.argsort",
"numpy.array",
"scipy.ndimage.zoom",
"numpy.arange",
"numpy.divide",
"os.path.exists",
"numpy.multiply",
"numpy.where",
"numpy.delete",
"numpy.max",
"numpy.empty",
"numpy.concatenate",
"mrcnn.visualize.create_m... | [((2388, 2407), 'datasetTools.datasetDivider.getBWCount', 'dD.getBWCount', (['mask'], {}), '(mask)\n', (2401, 2407), True, 'from datasetTools import datasetDivider as dD\n'), ((3369, 3425), 'numpy.pad', 'np.pad', (['base_mask', '(1)'], {'mode': '"""constant"""', 'constant_values': '(0)'}), "(base_mask, 1, mode='constan... |
import unittest
import pandas as pd
class TestDataFrameStats(unittest.TestCase):
def setUp(self):
# initialize and load df
self.df = pd.DataFrame(data={'data': [0,1,2,3]})
def test_min(self):
self.assertGreaterEqual(self.df.min().values[0], 0)
def test_max(self):
... | [
"pandas.DataFrame"
] | [((159, 200), 'pandas.DataFrame', 'pd.DataFrame', ([], {'data': "{'data': [0, 1, 2, 3]}"}), "(data={'data': [0, 1, 2, 3]})\n", (171, 200), True, 'import pandas as pd\n')] |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sun Jul 22 19:39:10 2018
@author: michal
"""
import pandas as pd
import sys
from os import path
from time import time
try:
from pymol import cmd
except:
pass
if sys.version_info[0] < 3:
import Tkinter
import tkMessageBox, tkFileDialog
... | [
"pymol.cmd.deselect",
"pymol.cmd.load",
"pandas.read_csv",
"tkinter.Button",
"pymol.cmd.frame",
"tkinter.Label",
"pymol.cmd.zoom",
"tkinter.ttk.Treeview",
"tkinter.messagebox.showwarning",
"tkinter.Entry",
"pymol.cmd.select",
"pymol.cmd.fetch",
"pymol.cmd.center",
"tkinter.filedialog.askop... | [((2207, 2293), 'tkinter.Button', 'Tkinter.Button', (['self.page'], {'text': '"""Load log file"""', 'command': 'self.getLogFile', 'width': '(10)'}), "(self.page, text='Load log file', command=self.getLogFile,\n width=10)\n", (2221, 2293), True, 'import tkinter as Tkinter\n'), ((2375, 2409), 'tkinter.Entry', 'Tkinter... |
from flask_restful import Resource, reqparse
from application.models.todo import ToDoModel
class ToDo(Resource):
parser = reqparse.RequestParser()
parser.add_argument('name',
required=True,
help="ToDo needs a name!"
)
parser.add_argument('description',
required=True,
he... | [
"application.models.todo.ToDoModel",
"flask_restful.reqparse.RequestParser",
"application.models.todo.ToDoModel.find_by_id"
] | [((127, 151), 'flask_restful.reqparse.RequestParser', 'reqparse.RequestParser', ([], {}), '()\n', (149, 151), False, 'from flask_restful import Resource, reqparse\n'), ((501, 526), 'application.models.todo.ToDoModel.find_by_id', 'ToDoModel.find_by_id', (['_id'], {}), '(_id)\n', (521, 526), False, 'from application.mode... |
from lib.models import Person
from lib.models import Player
from lib.models import Coach
from lib.models import Team
from lib.config.locales import locales
from lib.config.modules import modules
from lib.generator.superfaker import SuperFaker
import random
class RandomFiller(object):
faker = None
locale = Non... | [
"lib.generator.superfaker.SuperFaker",
"lib.config.modules.modules.keys",
"lib.models.Person",
"random.randint"
] | [((492, 500), 'lib.models.Person', 'Person', ([], {}), '()\n', (498, 500), False, 'from lib.models import Person\n'), ((610, 633), 'random.randint', 'random.randint', (['(40)', '(100)'], {}), '(40, 100)\n', (624, 633), False, 'import random\n'), ((1581, 1599), 'lib.generator.superfaker.SuperFaker', 'SuperFaker', (['loc... |
from ray.rllib.utils import try_import_tf, try_import_torch
tf = try_import_tf()
torch, nn = try_import_torch()
def explained_variance(y, pred, framework="tf"):
if framework == "tf":
_, y_var = tf.nn.moments(y, axes=[0])
_, diff_var = tf.nn.moments(y - pred, axes=[0])
return tf.maximum(-1... | [
"ray.rllib.utils.try_import_tf",
"ray.rllib.utils.try_import_torch"
] | [((66, 81), 'ray.rllib.utils.try_import_tf', 'try_import_tf', ([], {}), '()\n', (79, 81), False, 'from ray.rllib.utils import try_import_tf, try_import_torch\n'), ((94, 112), 'ray.rllib.utils.try_import_torch', 'try_import_torch', ([], {}), '()\n', (110, 112), False, 'from ray.rllib.utils import try_import_tf, try_impo... |
# -*- coding: utf-8 -*-
# @Author: 何睿
# @Create Date: 2019-04-09 12:37:36
# @Last Modified by: 何睿
# @Last Modified time: 2019-04-09 15:57:00
from collections import Counter
class Solution:
def topKFrequent(self, nums: [int], k: int) -> [int]:
# 桶
bucket = dict()
# 构建字... | [
"collections.Counter"
] | [((355, 368), 'collections.Counter', 'Counter', (['nums'], {}), '(nums)\n', (362, 368), False, 'from collections import Counter\n')] |
from decimal import Decimal, getcontext
getcontext().prec = 8
class F(object):
def __init__(self, a, b, c):
self.a = Decimal(a)
self.b = Decimal(b)
self.c = Decimal(c)
def q(F1, F2):
assert type(F1) is F and type(F2) is F
assert F1.a * F2.b - F1.b * F2.a is not 0
x = (F1.c *... | [
"decimal.getcontext",
"decimal.Decimal"
] | [((41, 53), 'decimal.getcontext', 'getcontext', ([], {}), '()\n', (51, 53), False, 'from decimal import Decimal, getcontext\n'), ((132, 142), 'decimal.Decimal', 'Decimal', (['a'], {}), '(a)\n', (139, 142), False, 'from decimal import Decimal, getcontext\n'), ((160, 170), 'decimal.Decimal', 'Decimal', (['b'], {}), '(b)\... |
import argparse
import itertools
import string
def flags():
parser = argparse.ArgumentParser()
parser.add_argument("least_chars", help="The minimum amount characters in the password", type=int)
parser.add_argument("most_chars", help="The maximum amount characters in the password", type=int)
parser.add... | [
"itertools.product",
"argparse.ArgumentParser"
] | [((74, 99), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (97, 99), False, 'import argparse\n'), ((2017, 2050), 'itertools.product', 'itertools.product', (['char'], {'repeat': 'i'}), '(char, repeat=i)\n', (2034, 2050), False, 'import itertools\n'), ((2901, 2934), 'itertools.product', 'itertool... |
# Generated by Django 3.2.5 on 2021-07-31 19:49
from django.db import migrations, models
import django.utils.timezone
class Migration(migrations.Migration):
dependencies = [
('blog', '0001_initial'),
]
operations = [
migrations.CreateModel(
name='Category',
... | [
"django.db.models.TextField",
"django.db.models.IntegerField",
"django.db.models.BooleanField",
"django.db.migrations.AlterModelOptions",
"django.db.models.ImageField",
"django.db.models.SlugField",
"django.db.models.BigAutoField",
"django.db.models.DateTimeField",
"django.db.models.CharField"
] | [((1053, 1169), 'django.db.migrations.AlterModelOptions', 'migrations.AlterModelOptions', ([], {'name': '"""article"""', 'options': "{'verbose_name': 'مقاله', 'verbose_name_plural': 'مقالات'}"}), "(name='article', options={'verbose_name':\n 'مقاله', 'verbose_name_plural': 'مقالات'})\n", (1081, 1169), False, 'from dj... |
from __future__ import unicode_literals
import pytest # noqa
import sys
pytestmark = pytest.mark.skipif(sys.version_info[0] < 3,
reason="pyecore is not Python 2 compatible") # noqa
pyecore = pytest.importorskip("pyecore") # noqa
import textx
from textx.metamodel import metamodel_from... | [
"textx.export.model_export",
"pytest.mark.skip",
"textx.enable_pyecore_support",
"pytest.importorskip",
"pytest.mark.usefixtures",
"textx.export.metamodel_export",
"pytest.mark.skipif",
"pytest.fixture",
"textx.metamodel.metamodel_from_str"
] | [((86, 179), 'pytest.mark.skipif', 'pytest.mark.skipif', (['(sys.version_info[0] < 3)'], {'reason': '"""pyecore is not Python 2 compatible"""'}), "(sys.version_info[0] < 3, reason=\n 'pyecore is not Python 2 compatible')\n", (104, 179), False, 'import pytest\n'), ((225, 255), 'pytest.importorskip', 'pytest.importors... |
from src.config.appConfig import getJsonConfig
from src.dataFetchers.dataFetcherHandler import linesGenDataFetcherHandler
from src.typeDefs.stateConfig import IStateConfig
from src.repos.measData.measDataRepo import MeasDataRepo
from typing import List
def linesGenService(stateConfigSheet: List[IStateConfig], excelFi... | [
"src.dataFetchers.dataFetcherHandler.linesGenDataFetcherHandler",
"src.config.appConfig.getJsonConfig"
] | [((351, 410), 'src.dataFetchers.dataFetcherHandler.linesGenDataFetcherHandler', 'linesGenDataFetcherHandler', (['stateConfigSheet', 'excelFilePath'], {}), '(stateConfigSheet, excelFilePath)\n', (377, 410), False, 'from src.dataFetchers.dataFetcherHandler import linesGenDataFetcherHandler\n'), ((452, 467), 'src.config.a... |
from __future__ import print_function
import os
from shutil import copyfile
from IWat import iw_parser, \
get_image_list, check_or_make_dest_dir, \
is_marked, save_with_meta, \
water_mark_image, reduce_opacity, rotate_image, \
Image
iw_args = iw_parser.parse_args()
ext_list = []
if iw_args.png:
... | [
"IWat.get_image_list",
"IWat.reduce_opacity",
"IWat.iw_parser.parse_args",
"IWat.Image.open",
"IWat.rotate_image",
"IWat.is_marked",
"IWat.save_with_meta",
"os.path.dirname",
"shutil.copyfile",
"IWat.water_mark_image",
"IWat.check_or_make_dest_dir"
] | [((261, 283), 'IWat.iw_parser.parse_args', 'iw_parser.parse_args', ([], {}), '()\n', (281, 283), False, 'from IWat import iw_parser, get_image_list, check_or_make_dest_dir, is_marked, save_with_meta, water_mark_image, reduce_opacity, rotate_image, Image\n'), ((572, 612), 'IWat.check_or_make_dest_dir', 'check_or_make_de... |
# Copyright (c) OpenMMLab. All rights reserved.
import os
import os.path as osp
import sys
import tempfile
from unittest.mock import MagicMock, patch
import pytest
import mmcv
from mmcv.fileio.file_client import HTTPBackend, PetrelBackend
sys.modules['petrel_client'] = MagicMock()
sys.modules['petrel_client.client']... | [
"mmcv.register_handler",
"unittest.mock.MagicMock",
"mmcv.dump",
"os.path.isfile",
"mmcv.list_from_file",
"tempfile.NamedTemporaryFile",
"os.path.dirname",
"tempfile.gettempdir",
"pytest.raises",
"unittest.mock.patch.object",
"pickle.loads",
"mmcv.load",
"mmcv.dict_from_file",
"os.remove"
... | [((273, 284), 'unittest.mock.MagicMock', 'MagicMock', ([], {}), '()\n', (282, 284), False, 'from unittest.mock import MagicMock, patch\n'), ((323, 334), 'unittest.mock.MagicMock', 'MagicMock', ([], {}), '()\n', (332, 334), False, 'from unittest.mock import MagicMock, patch\n'), ((441, 485), 'mmcv.dump', 'mmcv.dump', ([... |
import sqlite3 as sql
#veritabanına bağlandıktan sonra sorgu göndermek icin bir nesneye ve buna bağlı bir cursor ihtiyacımız var
db = sql.connect(r"chinook\chinook.db")
#connect methodu veritabanına bağlamamızı sağlar. veritabanı belirtilen adreste yoksa sıfırdan oluşturur
#adres kısmına dikkat etmekte fayda var
cur = ... | [
"sqlite3.connect"
] | [((134, 168), 'sqlite3.connect', 'sql.connect', (['"""chinook\\\\chinook.db"""'], {}), "('chinook\\\\chinook.db')\n", (145, 168), True, 'import sqlite3 as sql\n')] |
# RUN: %{python} %s
from __future__ import print_function
import time
import sys
print("Running infinite loop")
sys.stdout.flush() # Make sure the print gets flushed so it appears in lit output.
while True:
pass
| [
"sys.stdout.flush"
] | [((114, 132), 'sys.stdout.flush', 'sys.stdout.flush', ([], {}), '()\n', (130, 132), False, 'import sys\n')] |
import hashlib
def file_sha1(file: str) -> str:
sha1 = hashlib.sha1()
with open(file, 'rb') as f:
buffer = f.read(65536)
while len(buffer) > 0:
sha1.update(buffer)
buffer = f.read(65536)
return sha1.hexdigest()
def str_sha1(s: str) -> str:
sha1 = hashlib.sha1(... | [
"hashlib.sha1"
] | [((61, 75), 'hashlib.sha1', 'hashlib.sha1', ([], {}), '()\n', (73, 75), False, 'import hashlib\n'), ((307, 321), 'hashlib.sha1', 'hashlib.sha1', ([], {}), '()\n', (319, 321), False, 'import hashlib\n')] |
import pytest
from siquant import SIUnit, si, make
from euclidean.constants import eta
from euclidean.siquant.factory import make_factory, V2Quantity, V3Quantity
from euclidean.R2 import V2
from euclidean.R3 import V3
SIUnit.factory = make_factory(V2Quantity, V3Quantity)
def test_create():
xyz = make(V3(1, 2... | [
"pytest.approx",
"euclidean.siquant.factory.make_factory",
"euclidean.R3.V3",
"pytest.raises",
"euclidean.R2.V2"
] | [((239, 275), 'euclidean.siquant.factory.make_factory', 'make_factory', (['V2Quantity', 'V3Quantity'], {}), '(V2Quantity, V3Quantity)\n', (251, 275), False, 'from euclidean.siquant.factory import make_factory, V2Quantity, V3Quantity\n'), ((313, 324), 'euclidean.R3.V3', 'V3', (['(1)', '(2)', '(3)'], {}), '(1, 2, 3)\n', ... |
#!/usr/bin/env python3
import MySQLdb
import getpass
# Generate configuration for the "umls2rdf" software, by querying which data sources are
# available in an installed UMLS mysql database; this script prints the configuration
# information as CSV to stdout.
password = getpass.getpass("Please enter the password for ... | [
"MySQLdb.connect",
"getpass.getpass"
] | [((273, 360), 'getpass.getpass', 'getpass.getpass', (['"""Please enter the password for accessing a UMLS mysql database: """'], {}), "(\n 'Please enter the password for accessing a UMLS mysql database: ')\n", (288, 360), False, 'import getpass\n'), ((364, 472), 'MySQLdb.connect', 'MySQLdb.connect', ([], {'host': '""... |
from copy import deepcopy
from typing import List
__doc__ = """
Sorting algorithm for arrays of numeric values
Functions:
sort(int[], bool) -> int[]
"""
def sort(incoming_bucket, duplicates=True):
'''
Sorts an array of numbers
Parameters:
incoming_bucket (int[]): An arra... | [
"copy.deepcopy"
] | [((2297, 2322), 'copy.deepcopy', 'deepcopy', (['incoming_bucket'], {}), '(incoming_bucket)\n', (2305, 2322), False, 'from copy import deepcopy\n')] |