code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
"""
Evaluate a musical composition represented as a `Piece` instance.
Author: <NAME>
"""
from collections import Counter
from typing import Any, Callable, Dict, Optional
import numpy as np
from scipy.stats import entropy
from rlmusician.environment.piece import Piece
from rlmusician.utils import rolling_aggregate
... | [
"collections.Counter",
"scipy.stats.entropy",
"numpy.array_equal",
"rlmusician.utils.rolling_aggregate"
] | [((1804, 1822), 'collections.Counter', 'Counter', (['positions'], {}), '(positions)\n', (1811, 1822), False, 'from collections import Counter\n'), ((2165, 2186), 'scipy.stats.entropy', 'entropy', (['distribution'], {}), '(distribution)\n', (2172, 2186), False, 'from scipy.stats import entropy\n'), ((2274, 2307), 'scipy... |
import os
import random
import itertools
vector_template = '''static uint64_t {}[{}] =
{{
{}
}};
'''
max_u64 = 0xffffffffffffffff
max_u64_str = str(hex(max_u64))
def get_random_u64 (size):
return '0x' + (os.urandom(size).hex() if size != 0 else '0')
def print_vectors (name, l):
return vector_template.f... | [
"os.urandom",
"itertools.product",
"random.randint"
] | [((392, 469), 'itertools.product', 'itertools.product', (["['0x0', max_u64_str]", "['0x0', max_u64_str]", "['0x0', '0x1']"], {}), "(['0x0', max_u64_str], ['0x0', max_u64_str], ['0x0', '0x1'])\n", (409, 469), False, 'import itertools\n'), ((218, 234), 'os.urandom', 'os.urandom', (['size'], {}), '(size)\n', (228, 234), F... |
# Copyright (c) Microsoft Corporation.
# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
import itertools
import os
from stl.test.format import STLTestFormat, TestStep
from stl.test.tests import TestType
class CustomTestFormat(STLTestFormat):
def getBuildSteps(self, test, litConfig, shared):
... | [
"itertools.chain",
"stl.test.format.TestStep",
"os.path.join"
] | [((2406, 2452), 'itertools.chain', 'itertools.chain', (['test.flags', 'test.compileFlags'], {}), '(test.flags, test.compileFlags)\n', (2421, 2452), False, 'import itertools\n'), ((2737, 2780), 'os.path.join', 'os.path.join', (['litConfig.cxx_headers', 'header'], {}), '(litConfig.cxx_headers, header)\n', (2749, 2780), F... |
import itertools
from rlp.sedes import (
big_endian_int,
CountableList,
binary,
)
from eth_bloom import BloomFilter
from typing import Iterable
from eth.abc import ReceiptAPI
from .sedes import (
uint256,
)
from .logs import Log
class Receipt(ReceiptAPI):
fields = [
('state_root', b... | [
"eth_bloom.BloomFilter.from_iterable",
"itertools.chain.from_iterable",
"rlp.sedes.CountableList",
"eth_bloom.BloomFilter"
] | [((1011, 1034), 'eth_bloom.BloomFilter', 'BloomFilter', (['self.bloom'], {}), '(self.bloom)\n', (1022, 1034), False, 'from eth_bloom import BloomFilter\n'), ((411, 429), 'rlp.sedes.CountableList', 'CountableList', (['Log'], {}), '(Log)\n', (424, 429), False, 'from rlp.sedes import big_endian_int, CountableList, binary\... |
from backtrader import indicators
from src.analyzer.backtrader_wrapper.base_screener import BaseScreener
from src.analyzer.backtrader_wrapper.base_strategy import BaseStrategy
from src.analyzer.backtrader_wrapper.interface_algo import AlgoInterface
class SimpleMovingAverageAlgo(AlgoInterface):
params = dict(maper... | [
"backtrader.indicators.MovingAverageSimple"
] | [((421, 486), 'backtrader.indicators.MovingAverageSimple', 'indicators.MovingAverageSimple', (['data'], {'period': 'self.params.maperiod'}), '(data, period=self.params.maperiod)\n', (451, 486), False, 'from backtrader import indicators\n')] |
from mitmproxy import http
import json
import os
import subprocess
import signal
# Enables or disables the mocking feature as a whole
isMockEnabled = True
# Setup onExit handler
def handler(signum, frame):
print("shutting down")
subprocess.Popen("sh proxy_off.sh".split(), stdout=subprocess.PIPE)
signal.sign... | [
"os.path.abspath",
"signal.signal"
] | [((309, 346), 'signal.signal', 'signal.signal', (['signal.SIGINT', 'handler'], {}), '(signal.SIGINT, handler)\n', (322, 346), False, 'import signal\n'), ((347, 385), 'signal.signal', 'signal.signal', (['signal.SIGTERM', 'handler'], {}), '(signal.SIGTERM, handler)\n', (360, 385), False, 'import signal\n'), ((666, 691), ... |
import functools
import time
import os
import logging
from inspect import getmembers,isfunction,ismethod
import sys
class ExecutionTime:
logFormatter = logging.Formatter("%(asctime)s [%(levelname)-5.5s] %(message)s")
rootLogger = logging.getLogger()
rootLogger.setLevel(logging.DEBUG)
def __init__(s... | [
"logging.getLogger",
"logging.StreamHandler",
"inspect.getmembers",
"logging.Formatter",
"time.perf_counter",
"functools.wraps"
] | [((159, 224), 'logging.Formatter', 'logging.Formatter', (['"""%(asctime)s [%(levelname)-5.5s] %(message)s"""'], {}), "('%(asctime)s [%(levelname)-5.5s] %(message)s')\n", (176, 224), False, 'import logging\n'), ((242, 261), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (259, 261), False, 'import logging\... |
#!/usr/bin/env python
import argparse
import platform
from os.path import abspath, dirname, join
import sys
import pytest
from robot.version import VERSION as rf_version
curdir = dirname(abspath(__file__))
atest_dir = join(curdir, '..', 'atest')
python_version = platform.python_version()
xunit_report = join(atest_dir... | [
"sys.path.insert",
"argparse.ArgumentParser",
"os.path.join",
"pytest.main",
"sys.exit",
"os.path.abspath",
"platform.python_version"
] | [((220, 247), 'os.path.join', 'join', (['curdir', '""".."""', '"""atest"""'], {}), "(curdir, '..', 'atest')\n", (224, 247), False, 'from os.path import abspath, dirname, join\n'), ((265, 290), 'platform.python_version', 'platform.python_version', ([], {}), '()\n', (288, 290), False, 'import platform\n'), ((306, 398), '... |
# coding=utf-8
# Copyright 2022 Head2Toe Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or a... | [
"absl.testing.parameterized.parameters",
"head2toe.input_pipeline.create_vtab_dataset",
"tensorflow.test.main"
] | [((813, 1035), 'absl.testing.parameterized.parameters', 'parameterized.parameters', (["(84, 2, 'train', 'test')", "(84, 2, 'eval', 'test')", "(84, 1000, 'train', 'test')", "(84, 1000, 'eval', 'test')", "(240, 2, 'train', 'test')", "(240, 2, 'train', 'valid')", "(240, 2, 'eval', 'valid')"], {}), "((84, 2, 'train', 'test... |
# flake8: noqa
# Test cases taken from:
# - Thomas Ho Company LTD: financial models,
# http://www.thomasho.com/mainpages/analysoln.asp
# - Analysis of Derivatives for the Chartered Financial Analyst® Program,
# <NAME>, PhD, CFA, ©2003 CFA Institute
import types
import numpy as np
import pandas as pd
from pyfina... | [
"numpy.array",
"numpy.random.seed"
] | [((342, 361), 'numpy.random.seed', 'np.random.seed', (['(123)'], {}), '(123)\n', (356, 361), True, 'import numpy as np\n'), ((2473, 2501), 'numpy.array', 'np.array', (['[2100, 2000, 1900]'], {}), '([2100, 2000, 1900])\n', (2481, 2501), True, 'import numpy as np\n'), ((2896, 2938), 'numpy.array', 'np.array', (['[1900.0,... |
## Copyright 2018-2021 Intel Corporation
## SPDX-License-Identifier: Apache-2.0
import os
from glob import glob
from collections import defaultdict
import numpy as np
import torch
from torch.utils.data import Dataset, DataLoader
from torch.utils.data.distributed import DistributedSampler
from config import *
from ut... | [
"numpy.clip",
"numpy.sqrt",
"torch.utils.data.distributed.DistributedSampler",
"numpy.flip",
"os.path.split",
"os.path.isdir",
"numpy.concatenate",
"numpy.maximum",
"os.path.relpath",
"numpy.square",
"os.path.isfile",
"tza.Reader",
"os.path.join",
"numpy.swapaxes",
"numpy.errstate",
"c... | [((457, 489), 'os.path.join', 'os.path.join', (['cfg.data_dir', 'name'], {}), '(cfg.data_dir, name)\n', (469, 489), False, 'import os\n'), ((4881, 4911), 'numpy.concatenate', 'np.concatenate', (['images'], {'axis': '(2)'}), '(images, axis=2)\n', (4895, 4911), True, 'import numpy as np\n'), ((5057, 5076), 'os.path.split... |
from gym.spaces import Box, Dict, Discrete, Tuple
import numpy as np
import unittest
import ray
import ray.rllib.algorithms.pg as pg
from ray.rllib.evaluation.postprocessing import Postprocessing
from ray.rllib.examples.env.random_env import RandomEnv
from ray.rllib.models.tf.tf_action_dist import Categorical
from ray... | [
"ray.rllib.utils.test_utils.check_compute_single_action",
"numpy.mean",
"ray.shutdown",
"ray.rllib.utils.test_utils.check_train_results",
"ray.rllib.utils.numpy.fc",
"gym.spaces.Discrete",
"gym.spaces.Box",
"pytest.main",
"numpy.array",
"ray.rllib.algorithms.pg.PGConfig",
"ray.rllib.utils.test_u... | [((723, 733), 'ray.init', 'ray.init', ([], {}), '()\n', (731, 733), False, 'import ray\n'), ((796, 810), 'ray.shutdown', 'ray.shutdown', ([], {}), '()\n', (808, 810), False, 'import ray\n'), ((937, 950), 'ray.rllib.algorithms.pg.PGConfig', 'pg.PGConfig', ([], {}), '()\n', (948, 950), True, 'import ray.rllib.algorithms.... |
from meta_policy_search.samplers.base import SampleProcessor
from meta_policy_search.samplers.dice_sample_processor import DiceSampleProcessor
from meta_policy_search.utils.rl2 import utils
import numpy as np
class MetaSampleProcessor(SampleProcessor):
def process_samples(self, paths_meta_batch, log=False, log_pr... | [
"numpy.concatenate"
] | [((1726, 1815), 'numpy.concatenate', 'np.concatenate', (["[samples_data['rewards'] for samples_data in samples_data_meta_batch]"], {}), "([samples_data['rewards'] for samples_data in\n samples_data_meta_batch])\n", (1740, 1815), True, 'import numpy as np\n'), ((1853, 1942), 'numpy.concatenate', 'np.concatenate', (["... |
import tensorflow as tf
from neupy import layers
from neupy.utils import tf_utils, as_tuple
from neupy.layers.base import BaseGraph
__all__ = ('mixture_of_experts',)
def check_if_network_is_valid(network, index):
if not isinstance(network, BaseGraph):
raise TypeError(
"Invalid input, Mixtur... | [
"neupy.utils.as_tuple",
"neupy.layers.Softmax",
"neupy.layers.GatedAverage",
"neupy.utils.tf_utils.shape_to_tuple",
"neupy.layers.Input",
"tensorflow.TensorShape"
] | [((4373, 4393), 'tensorflow.TensorShape', 'tf.TensorShape', (['None'], {}), '(None)\n', (4387, 4393), True, 'import tensorflow as tf\n'), ((4790, 4825), 'neupy.layers.Softmax', 'layers.Softmax', (['n_layers_to_combine'], {}), '(n_layers_to_combine)\n', (4804, 4825), False, 'from neupy import layers\n'), ((5038, 5062), ... |
# -*- coding: utf8 -*-
# Author: <NAME>
"""Coqtop interface with functions to send commands and parse responses."""
import datetime
import logging
import signal
import subprocess
import threading
import time
from concurrent import futures
from queue import Empty, Queue
from tempfile import NamedTemporaryFile
from typi... | [
"logging.NullHandler",
"logging.StreamHandler",
"xmlInterface.XMLInterface",
"subprocess.Popen",
"concurrent.futures.ThreadPoolExecutor",
"logging.Formatter",
"typing_extensions.TypedDict",
"time.sleep",
"datetime.datetime.now",
"xmlInterface.Ok",
"threading.Thread",
"queue.Queue",
"xmlInter... | [((865, 973), 'typing_extensions.TypedDict', 'TypedDict', (['"""VersionInfo"""', "{'version': Tuple[int, int, int], 'str_version': str, 'latest': Optional[str]}"], {}), "('VersionInfo', {'version': Tuple[int, int, int], 'str_version':\n str, 'latest': Optional[str]})\n", (874, 973), False, 'from typing_extensions im... |
# GNU MediaGoblin -- federated, autonomous media hosting
# Copyright (C) 2011, 2012 MediaGoblin contributors. See AUTHORS.
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License as published by
# the Free Software Foundation, either versio... | [
"mediagoblin.db.models.MediaEntry.query.filter",
"mediagoblin.tools.translate.lazy_pass_to_ugettext",
"mediagoblin.plugins.archivalook.models.FeaturedMedia.order.desc",
"mediagoblin.db.models.User.query.filter",
"mediagoblin.plugins.archivalook.models.FeaturedMedia.query.filter",
"mediagoblin.plugins.arch... | [((8313, 8385), 'mediagoblin.plugins.archivalook.models.FeaturedMedia', 'FeaturedMedia', ([], {'media_entry': 'media_entry', 'display_type': 'u"""primary"""', 'order': '(0)'}), "(media_entry=media_entry, display_type=u'primary', order=0)\n", (8326, 8385), False, 'from mediagoblin.plugins.archivalook.models import Featu... |
"""ASR Interface module."""
import argparse
from espnet.bin.asr_train import get_parser
from espnet.utils.dynamic_import import dynamic_import
from espnet.utils.fill_missing_args import fill_missing_args
class ASRInterface:
"""ASR Interface for ESPnet model implementation."""
@staticmethod
def add_argum... | [
"espnet.bin.asr_train.get_parser",
"argparse.Namespace",
"espnet.utils.fill_missing_args.fill_missing_args"
] | [((835, 863), 'argparse.Namespace', 'argparse.Namespace', ([], {}), '(**kwargs)\n', (853, 863), False, 'import argparse\n'), ((879, 908), 'espnet.utils.fill_missing_args.fill_missing_args', 'fill_missing_args', (['args', 'wrap'], {}), '(args, wrap)\n', (896, 908), False, 'from espnet.utils.fill_missing_args import fill... |
import asyncio
from pytest import fixture
from async_redis import ConnectionSettings, Redis, connect
from async_redis.connection import RawConnection, create_raw_connection
@fixture(name='settings')
def fix_settings(loop):
return ConnectionSettings()
@fixture(name='raw_connection')
def fix_raw_connection(loop... | [
"async_redis.connection.create_raw_connection",
"async_redis.connect",
"pytest.fixture",
"asyncio.set_event_loop",
"async_redis.ConnectionSettings"
] | [((178, 202), 'pytest.fixture', 'fixture', ([], {'name': '"""settings"""'}), "(name='settings')\n", (185, 202), False, 'from pytest import fixture\n'), ((262, 292), 'pytest.fixture', 'fixture', ([], {'name': '"""raw_connection"""'}), "(name='raw_connection')\n", (269, 292), False, 'from pytest import fixture\n'), ((553... |
# [START app]
from flask import Flask, request
import twilio.twiml
from src import translate
app = Flask(__name__)
@app.route("/", methods=['POST'])
def translate_text_message_and_respond():
""" A text message should contain a two language codes and a query payload.
e.g: 'en es How do I pay for my lunch?'
... | [
"src.translate.translate",
"src.translate.parse_body",
"flask.request.values.get",
"flask.Flask"
] | [((100, 115), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (105, 115), False, 'from flask import Flask, request\n'), ((435, 467), 'flask.request.values.get', 'request.values.get', (['"""Body"""', 'None'], {}), "('Body', None)\n", (453, 467), False, 'from flask import Flask, request\n'), ((513, 544), 'src... |
# -*- coding: utf-8 -*-
import io
from setuptools import setup, find_packages
with io.open("README.md", "r", encoding="utf-8") as f:
readme = f.read()
version = "0.0.4"
setup(
name="convolut",
version=version,
description="Distributed development and modularity for deep learning",
long_descripti... | [
"setuptools.find_packages",
"io.open"
] | [((85, 128), 'io.open', 'io.open', (['"""README.md"""', '"""r"""'], {'encoding': '"""utf-8"""'}), "('README.md', 'r', encoding='utf-8')\n", (92, 128), False, 'import io\n'), ((470, 485), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (483, 485), False, 'from setuptools import setup, find_packages\n')] |
import torch
from delira.models import AbstractPyTorchNetwork
from deliravision.models.gans.info.models import Discriminator, Generator
from deliravision.utils.tensor_ops import make_onehot_torch
from deliravision.models.gans.utils import weights_init_normal
class InfoGAN(AbstractPyTorchNetwork):
"""
Class im... | [
"deliravision.utils.tensor_ops.make_onehot_torch",
"torch.from_numpy",
"torch.argmax"
] | [((3898, 3950), 'deliravision.utils.tensor_ops.make_onehot_torch', 'make_onehot_torch', (['labels'], {'n_classes': 'self._n_classes'}), '(labels, n_classes=self._n_classes)\n', (3915, 3950), False, 'from deliravision.utils.tensor_ops import make_onehot_torch\n'), ((6970, 7012), 'torch.argmax', 'torch.argmax', (["preds[... |
import telebot
from configs import config
from internal import const, buttons, database, methods, task
bot = telebot.TeleBot(config.TOKEN)
@bot.message_handler(commands=['start'])
def send_wellcome(message):
if database.Database().if_user_exists(message.chat.id):
bot.send_message(
chat_id = me... | [
"internal.buttons.groups",
"internal.buttons.send_geo",
"internal.methods.loc_time",
"internal.buttons.start_button",
"internal.buttons.type_task",
"internal.methods.check_timezone",
"internal.buttons.input_tz",
"internal.methods.check_timezone_gps",
"internal.buttons.menu",
"internal.buttons.yes_... | [((110, 139), 'telebot.TeleBot', 'telebot.TeleBot', (['config.TOKEN'], {}), '(config.TOKEN)\n', (125, 139), False, 'import telebot\n'), ((2898, 2934), 'internal.methods.check_timezone', 'methods.check_timezone', (['message.text'], {}), '(message.text)\n', (2920, 2934), False, 'from internal import const, buttons, datab... |
"""
File used for defining all the models of the app
"""
from app import db
class Slide(db.Model):
object_id = db.Column(db.Integer, primary_key=True) #May need to add UUID for increased security
name = db.Column(db.String(80))
content = db.Column(db.Text)
def __init__(self, name, content):
self.name = name
s... | [
"app.db.String",
"app.db.Column"
] | [((113, 152), 'app.db.Column', 'db.Column', (['db.Integer'], {'primary_key': '(True)'}), '(db.Integer, primary_key=True)\n', (122, 152), False, 'from app import db\n'), ((242, 260), 'app.db.Column', 'db.Column', (['db.Text'], {}), '(db.Text)\n', (251, 260), False, 'from app import db\n'), ((216, 229), 'app.db.String', ... |
import numpy as np
from numpy.linalg import lstsq
from numpy.testing import (assert_allclose, assert_equal, assert_,
run_module_suite, assert_raises)
from scipy.sparse import rand
from scipy.sparse.linalg import aslinearoperator
from scipy.optimize import lsq_linear
A = np.array([
[0.17... | [
"scipy.sparse.rand",
"numpy.testing.assert_equal",
"numpy.testing.assert_allclose",
"scipy.sparse.linalg.aslinearoperator",
"numpy.testing.assert_",
"numpy.array",
"scipy.optimize.lsq_linear",
"numpy.dot",
"numpy.testing.run_module_suite",
"numpy.linalg.lstsq",
"numpy.random.RandomState"
] | [((300, 362), 'numpy.array', 'np.array', (['[[0.171, -0.057], [-0.049, -0.248], [-0.166, 0.054]]'], {}), '([[0.171, -0.057], [-0.049, -0.248], [-0.166, 0.054]])\n', (308, 362), True, 'import numpy as np\n'), ((382, 414), 'numpy.array', 'np.array', (['[0.074, 1.014, -0.383]'], {}), '([0.074, 1.014, -0.383])\n', (390, 41... |
"""add private key and csr to certificate, track certificate in operation
Revision ID: 0d14cc3a1cf1
Revises: <KEY>
Create Date: 2021-09-10 23:03:20.631787
"""
from alembic import op
import sqlalchemy as sa
import sqlalchemy_utils
# revision identifiers, used by Alembic.
revision = "0d14cc3a1cf1"
down_revision = "53... | [
"sqlalchemy_utils.types.encrypted.encrypted_type.StringEncryptedType",
"sqlalchemy.Text",
"alembic.op.f",
"alembic.op.drop_column",
"sqlalchemy.Integer"
] | [((1294, 1340), 'alembic.op.drop_column', 'op.drop_column', (['"""operations"""', '"""certificate_id"""'], {}), "('operations', 'certificate_id')\n", (1308, 1340), False, 'from alembic import op\n'), ((1345, 1386), 'alembic.op.drop_column', 'op.drop_column', (['"""certificates"""', '"""csr_pem"""'], {}), "('certificate... |
# Slate Macro Keypad
#
# UCF Senior Design Project - Group 8
# Summer - Fall '21
#
"""
This version runs on Feather nRF52840 Express with a 3.5" FeatherWing
"""
import time
import displayio
import terminalio
from adafruit_display_text import bitmap_label
from adafruit_displayio_layout.layouts.grid_layout import GridL... | [
"adafruit_hid.keyboard.Keyboard",
"adafruit_displayio_layout.layouts.grid_layout.GridLayout",
"adafruit_hid.consumer_control.ConsumerControl",
"displayio.Bitmap",
"displayio.release_displays",
"time.monotonic",
"time.sleep",
"displayio.Group",
"adafruit_hid.keyboard_layout_us.KeyboardLayoutUS",
"d... | [((814, 827), 'time.sleep', 'time.sleep', (['(2)'], {}), '(2)\n', (824, 827), False, 'import time\n'), ((870, 898), 'displayio.release_displays', 'displayio.release_displays', ([], {}), '()\n', (896, 898), False, 'import displayio\n'), ((917, 954), 'adafruit_featherwing.tft_featherwing_35.TFTFeatherWing35', 'tft_feathe... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Thu May 31 11:26:25 2018
@author: cadu
"""
print("66")
import pandas as pd
import numpy as np
from sklearn import datasets, svm, metrics
from sklearn import cross_validation
import matplotlib.pyplot as plt
import sys
sys.path.append("../src")
from data_pro... | [
"tensorflow.cast",
"tensorflow.InteractiveSession",
"tensorflow.placeholder",
"tensorflow.train.GradientDescentOptimizer",
"tensorflow.global_variables_initializer",
"tensorflow.argmax",
"numpy.empty",
"sklearn.cross_validation.train_test_split",
"tensorflow.matmul",
"data_prov2.get_tt",
"tensor... | [((281, 306), 'sys.path.append', 'sys.path.append', (['"""../src"""'], {}), "('../src')\n", (296, 306), False, 'import sys\n'), ((373, 381), 'data_prov2.get_tt', 'get_tt', ([], {}), '()\n', (379, 381), False, 'from data_prov2 import get_tt\n'), ((514, 587), 'sklearn.cross_validation.train_test_split', 'cross_validation... |
import os
import sys
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir)))
from datetime import datetime, timedelta
from time import time, sleep, strftime, localtime, strptime, mktime
from apscheduler.schedulers.background import BackgroundScheduler
from scheduled_task_verification_fram... | [
"time.strptime",
"datetime.timedelta",
"datetime.datetime.now",
"os.path.dirname",
"scheduled_task_verification_framework.scheduler_task_manager",
"sys_time_changer.change_sys_time",
"time.localtime",
"time.time",
"apscheduler.schedulers.background.BackgroundScheduler"
] | [((385, 409), 'scheduled_task_verification_framework.scheduler_task_manager', 'scheduler_task_manager', ([], {}), '()\n', (407, 409), False, 'from scheduled_task_verification_framework import scheduler_task_manager\n'), ((1546, 1567), 'apscheduler.schedulers.background.BackgroundScheduler', 'BackgroundScheduler', ([], ... |
from django.db import models
from django.contrib.auth.models import User
from phone_field import PhoneField
from django.db.models.signals import post_save
# Create your models here.
class Profile(models.Model):
user = models.OneToOneField(User, on_delete = models.CASCADE)
bio = models.CharField(max_length =2... | [
"django.db.models.EmailField",
"django.db.models.OneToOneField",
"django.db.models.signals.post_save.connect",
"django.db.models.ImageField",
"django.db.models.CharField"
] | [((872, 918), 'django.db.models.signals.post_save.connect', 'post_save.connect', (['create_profile'], {'sender': 'User'}), '(create_profile, sender=User)\n', (889, 918), False, 'from django.db.models.signals import post_save\n'), ((225, 277), 'django.db.models.OneToOneField', 'models.OneToOneField', (['User'], {'on_del... |
import pygame
import math
from roengine.util import Dummy
from roengine.config import PLAYER_KEYBINDS, USE_ROTOZOOM
__all__ = ["PlatformerPlayer"]
class PlatformerPlayer(pygame.sprite.Sprite):
keybinds = PLAYER_KEYBINDS
speed = 5
jump_power = 10
gravity = 0.5
climb_skill = 1
climb_velocity ... | [
"pygame.sprite.spritecollide",
"pygame.sprite.Group",
"pygame.sprite.Sprite.__init__",
"pygame.transform.rotate",
"pygame.math.Vector2",
"math.atan2",
"pygame.transform.rotozoom"
] | [((398, 419), 'pygame.sprite.Group', 'pygame.sprite.Group', ([], {}), '()\n', (417, 419), False, 'import pygame\n'), ((472, 507), 'pygame.sprite.Sprite.__init__', 'pygame.sprite.Sprite.__init__', (['self'], {}), '(self)\n', (501, 507), False, 'import pygame\n'), ((533, 558), 'pygame.math.Vector2', 'pygame.math.Vector2'... |
"""
Handle Twitter API rate limit error.
The newer version of tweepy accepts the following in tweepy.API object.
- wait_on_rate_limit: If the api until next rate limit window is reached
to continue. Default is False.
- wait_on_rate_limit_notify: Default is False. If the api prints a notification
when the rate... | [
"time.sleep"
] | [((2094, 2113), 'time.sleep', 'time.sleep', (['(15 * 60)'], {}), '(15 * 60)\n', (2104, 2113), False, 'import time\n')] |
#!/usr/bin/env python
#
# Copyright (C) 2007 British Broadcasting Corporation and Kamaelia Contributors(1)
# All Rights Reserved.
#
# You may only modify and redistribute this under the terms of any of the
# following licenses(2): Mozilla Public License, V1.1, GNU General
# Public License, V2.0, GNU Lesser General ... | [
"Axon.Ipc.producerFinished"
] | [((6455, 6473), 'Axon.Ipc.producerFinished', 'producerFinished', ([], {}), '()\n', (6471, 6473), False, 'from Axon.Ipc import producerFinished, shutdownMicroprocess\n')] |
# coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from ... import _utilities
fro... | [
"pulumi.getter",
"pulumi.set",
"pulumi.get"
] | [((2542, 2592), 'pulumi.getter', 'pulumi.getter', ([], {'name': '"""shouldFeatureDisplayInPortal"""'}), "(name='shouldFeatureDisplayInPortal')\n", (2555, 2592), False, 'import pulumi\n'), ((1977, 2008), 'pulumi.get', 'pulumi.get', (['self', '"""description"""'], {}), "(self, 'description')\n", (1987, 2008), False, 'imp... |
import numpy as np
import torch
import torch.nn.functional as F
from nnlib.nnlib import visualizations as vis
from nnlib.nnlib import losses, utils
from modules import nn_utils
from methods.predict import PredictGradBaseClassifier
class LIMIT(PredictGradBaseClassifier):
""" The main method of "Improving generali... | [
"nnlib.nnlib.losses.get_classification_loss",
"numpy.sqrt",
"modules.nn_utils.parse_network_from_config",
"modules.nn_utils.get_grad_replacement_class",
"nnlib.nnlib.losses.mse",
"nnlib.nnlib.losses.mae",
"torch.softmax",
"nnlib.nnlib.visualizations.plot_predictions",
"torch.nn.functional.one_hot",
... | [((4959, 5071), 'modules.nn_utils.parse_network_from_config', 'nn_utils.parse_network_from_config', ([], {'args': "self.architecture_args['classifier']", 'input_shape': 'self.input_shape'}), "(args=self.architecture_args['classifier'\n ], input_shape=self.input_shape)\n", (4993, 5071), False, 'from modules import nn... |
import os
import subprocess
import re
import ipaddress
import json
def runProcess(exe):
p = subprocess.Popen(exe, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)
while(True):
# returns None while subprocess is running
retcode = p.poll()
line = p.stdout.readline()
yield li... | [
"subprocess.Popen",
"ipaddress.IPv4Network",
"json.dump"
] | [((101, 172), 'subprocess.Popen', 'subprocess.Popen', (['exe'], {'stdout': 'subprocess.PIPE', 'stderr': 'subprocess.STDOUT'}), '(exe, stdout=subprocess.PIPE, stderr=subprocess.STDOUT)\n', (117, 172), False, 'import subprocess\n'), ((958, 980), 'json.dump', 'json.dump', (['ip_list', 'fp'], {}), '(ip_list, fp)\n', (967, ... |
import numpy as np
import os
import torch
import torch.nn as nn
import torch.nn.functional as F
import copy
import math
import ego_utils as utils
import hydra
class Encoder(nn.Module):
"""Convolutional encoder for image-based observations."""
def __init__(self, view, obs_shape, feature_dim):
super().... | [
"torch.tanh",
"torch.optim.Adam",
"torch.nn.functional.mse_loss",
"ego_utils.mlp",
"ego_utils.tie_weights",
"hydra.utils.instantiate",
"torch.load",
"torch.nn.LayerNorm",
"numpy.log",
"torch.min",
"torch.nn.Conv2d",
"ego_utils.to_np",
"torch.nn.Linear",
"ego_utils.soft_update_params",
"t... | [((3033, 3069), 'hydra.utils.instantiate', 'hydra.utils.instantiate', (['encoder_cfg'], {}), '(encoder_cfg)\n', (3056, 3069), False, 'import hydra\n'), ((3162, 3268), 'ego_utils.mlp', 'utils.mlp', (['(self.encoder.feature_dim + proprio_obs_shape)', 'hidden_dim', '(2 * action_shape[0])', 'hidden_depth'], {}), '(self.enc... |
#!/usr/bin/env python3
# Copyright (c) 2019 The Odinycoin developers
# Distributed under the MIT software license, see the accompanying
# file COPYING or http://www.opensource.org/licenses/mit-license.php.
'''
Covers the 'Wrapped Serials Attack' scenario for Zerocoin Spends
'''
import random
from time import sleep
f... | [
"test_framework.util.DecimalAmt",
"test_framework.util.assert_equal",
"test_framework.util.set_node_times",
"time.sleep",
"random.getrandbits",
"test_framework.util.sync_blocks",
"test_framework.util.assert_raises_rpc_error"
] | [((1743, 1771), 'test_framework.util.assert_equal', 'assert_equal', (['res', '"""success"""'], {}), "(res, 'success')\n", (1755, 1771), False, 'from test_framework.util import sync_blocks, assert_equal, assert_raises_rpc_error, set_node_times, DecimalAmt\n'), ((1780, 1788), 'time.sleep', 'sleep', (['(1)'], {}), '(1)\n'... |
#!/usr/bin/env python
import boto3
import clipboard
ec2 = boto3.resource('ec2')
def list_ec2():
for instance in ec2.instances.all():
instance.load()
print(instance.id, instance.state, instance.public_dns_name)
if instance.state['Name'] == 'running' or instance.state['Name'] == 'pending':... | [
"boto3.resource",
"clipboard.copy"
] | [((60, 81), 'boto3.resource', 'boto3.resource', (['"""ec2"""'], {}), "('ec2')\n", (74, 81), False, 'import boto3\n'), ((333, 373), 'clipboard.copy', 'clipboard.copy', (['instance.public_dns_name'], {}), '(instance.public_dns_name)\n', (347, 373), False, 'import clipboard\n')] |
#*nltk를 이용한 문장 토큰화*
from nltk.tokenize import sent_tokenize
text = "His barber kept his word. But keeping such a huge secret to himself was driving him crazy. Finally, the barber went up a mountain and almost to the edge of a cliff. He dug a hole in the midst of some reeds. He looked about, to mae sure no one was near.... | [
"kss.split_sentences",
"nltk.tokenize.sent_tokenize"
] | [((328, 347), 'nltk.tokenize.sent_tokenize', 'sent_tokenize', (['text'], {}), '(text)\n', (341, 347), False, 'from nltk.tokenize import sent_tokenize\n'), ((492, 511), 'nltk.tokenize.sent_tokenize', 'sent_tokenize', (['text'], {}), '(text)\n', (505, 511), False, 'from nltk.tokenize import sent_tokenize\n'), ((606, 631)... |
# Generated by Django 2.0 on 2017-12-18 14:17
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('website', '0001_initial'),
]
operations = [
migrations.CreateModel(
name='Tutorial',
fields=[
('id', m... | [
"django.db.models.TextField",
"django.db.models.IntegerField",
"django.db.models.ManyToManyField",
"django.db.models.DateTimeField",
"django.db.models.AutoField",
"django.db.models.URLField",
"django.db.models.CharField"
] | [((1908, 1960), 'django.db.models.ManyToManyField', 'models.ManyToManyField', ([], {'to': '"""website.TutorialComment"""'}), "(to='website.TutorialComment')\n", (1930, 1960), False, 'from django.db import migrations, models\n'), ((2081, 2130), 'django.db.models.ManyToManyField', 'models.ManyToManyField', ([], {'to': '"... |
"""
Copyright 2020 The Magma Authors.
This source code is licensed under the BSD-style license found in the
LICENSE file in the root directory of this source tree.
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES O... | [
"typing.NamedTuple"
] | [((527, 582), 'typing.NamedTuple', 'NamedTuple', (['"""ClientCert"""', "[('cert', str), ('key', str)]"], {}), "('ClientCert', [('cert', str), ('key', str)])\n", (537, 582), False, 'from typing import List, NamedTuple\n')] |
# -*- coding: utf-8 -*-
from __future__ import absolute_import, print_function
import abc
import os
import random
import pandas as pd
import pytest
from pandas.util.testing import assert_frame_equal
from pytest import fixture
import targets
import targets.errors
import targets.pipes
from dbnd.testing.helpers_pyte... | [
"targets.target.open",
"pandas.DataFrame",
"targets.target.exists",
"pytest.raises",
"gc.collect",
"pytest.fixture",
"random.randint",
"pandas.util.testing.assert_frame_equal"
] | [((622, 643), 'pytest.fixture', 'fixture', ([], {'autouse': '(True)'}), '(autouse=True)\n', (629, 643), False, 'from pytest import fixture\n'), ((1018, 1034), 'targets.target.open', 'target.open', (['"""w"""'], {}), "('w')\n", (1029, 1034), False, 'from targets import DataTarget, target\n'), ((1106, 1121), 'targets.tar... |
from __future__ import absolute_import
import json
import logging
from datetime import datetime
from tornado import web
from tornado import gen
from tornado.ioloop import IOLoop
from tornado.escape import json_decode
from tornado.web import HTTPError
from celery import states
from celery.result import AsyncResult
f... | [
"logging.getLogger",
"celery.contrib.abortable.AbortableAsyncResult",
"tornado.web.HTTPError",
"datetime.datetime.strptime",
"celery.result.AsyncResult",
"json.dumps",
"tornado.ioloop.IOLoop.current",
"tornado.escape.json_decode"
] | [((571, 598), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (588, 598), False, 'import logging\n'), ((8325, 8344), 'celery.result.AsyncResult', 'AsyncResult', (['taskid'], {}), '(taskid)\n', (8336, 8344), False, 'from celery.result import AsyncResult\n'), ((9463, 9491), 'celery.contrib.a... |
import FWCore.ParameterSet.Config as cms
## configuration to build fast L1 ME0 trigger stubs
## pseudo pads are created from pseudo digis with 192 strips instead of 384
## the rechits are a necessary intermediate step before the pseudo pads are used
## as input to build pseudo stubs
from SimMuon.GEMDigitizer.muonME0P... | [
"FWCore.ParameterSet.Config.Task",
"FWCore.ParameterSet.Config.InputTag",
"FWCore.ParameterSet.Config.double",
"FWCore.ParameterSet.Config.bool"
] | [((1158, 1176), 'FWCore.ParameterSet.Config.double', 'cms.double', (['maxPhi'], {}), '(maxPhi)\n', (1168, 1176), True, 'import FWCore.ParameterSet.Config as cms\n'), ((1237, 1255), 'FWCore.ParameterSet.Config.double', 'cms.double', (['maxPhi'], {}), '(maxPhi)\n', (1247, 1255), True, 'import FWCore.ParameterSet.Config a... |
# all the imports
# from __future__ import with_statement
# from contextlib import closing
from flask import (
Flask,
request,
session,
make_response,
g,
redirect,
url_for,
abort,
render_template,
flash,
)
import random
import os
import csv
import re
import blurbs
import result... | [
"flask.render_template",
"flask.session.keys",
"results.self_id_colors",
"datetime.datetime.utcnow",
"blurbs.pick_blurb",
"os.environ.get",
"results.skill_colors",
"results.compute_results",
"random.randint"
] | [((1914, 1947), 'flask.render_template', 'render_template', (['"""question1.html"""'], {}), "('question1.html')\n", (1929, 1947), False, 'from flask import Flask, request, session, make_response, g, redirect, url_for, abort, render_template, flash\n'), ((2099, 2132), 'flask.render_template', 'render_template', (['"""qu... |
from collections import namedtuple
import lasagne as nn
from lasagne.layers.dnn import Conv2DDNNLayer, MaxPool2DDNNLayer
import data_iterators
import numpy as np
import theano.tensor as T
from functools import partial
import utils_heart
import nn_heart
from pathfinder import PKL_TRAIN_DATA_PATH, TRAIN_LABELS_P... | [
"theano.tensor.mean",
"utils_heart.heaviside_function",
"numpy.random.RandomState",
"lasagne.layers.get_all_params",
"numpy.mean",
"lasagne.init.Orthogonal",
"lasagne.layers.dropout",
"lasagne.init.Constant",
"numpy.vstack",
"nn_heart.lb_softplus",
"nn_heart.NormalCDFLayer",
"collections.named... | [((428, 453), 'numpy.random.RandomState', 'np.random.RandomState', (['(42)'], {}), '(42)\n', (449, 453), True, 'import numpy as np\n'), ((1530, 1578), 'utils.get_train_valid_split', 'utils.get_train_valid_split', (['PKL_TRAIN_DATA_PATH'], {}), '(PKL_TRAIN_DATA_PATH)\n', (1557, 1578), False, 'import utils\n'), ((1604, 1... |
#!/usr/bin/env python
#
# Copyright 2017 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the 'License');
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law ... | [
"ez_setup.use_setuptools",
"setuptools.setup",
"os.getenv",
"platform.python_version_tuple"
] | [((792, 823), 'platform.python_version_tuple', 'platform.python_version_tuple', ([], {}), '()\n', (821, 823), False, 'import platform\n'), ((977, 994), 'os.getenv', 'os.getenv', (['"""HOME"""'], {}), "('HOME')\n", (986, 994), False, 'import os\n'), ((1524, 1935), 'setuptools.setup', 'setuptools.setup', ([], {'name': '"... |
import cv2
import numpy as np
n = 400
img = np.zeros((n, n, 3), np.uint8) * 255
(centerX, centerY) = (round(img.shape[1] / 2), round(img.shape[0] / 2))
# 将图像的中心作为圆心,实际值为d/2
red = (0, 0, 255)
for r in range(5, round(n / 2), 12):
cv2.circle(img, (centerX, centerY), r, red, 3)
winname = "Demo19.01"
cv2.namedWindow(w... | [
"cv2.imshow",
"numpy.zeros",
"cv2.circle",
"cv2.destroyAllWindows",
"cv2.waitKey",
"cv2.namedWindow"
] | [((303, 327), 'cv2.namedWindow', 'cv2.namedWindow', (['winname'], {}), '(winname)\n', (318, 327), False, 'import cv2\n'), ((328, 352), 'cv2.imshow', 'cv2.imshow', (['winname', 'img'], {}), '(winname, img)\n', (338, 352), False, 'import cv2\n'), ((353, 367), 'cv2.waitKey', 'cv2.waitKey', (['(0)'], {}), '(0)\n', (364, 36... |
# -*- coding: utf-8 -*-
from PySide2.QtCore import Signal
from PySide2.QtWidgets import QMessageBox, QWidget, QSizePolicy
from logging import getLogger
from .....loggers import GUI_LOG_NAME
from .....Classes.HoleM50 import HoleM50
from .....Classes.Material import Material
from .....GUI.Dialog.DMachineSetup.SMHoleMag... | [
"logging.getLogger",
"PySide2.QtWidgets.QWidget.__init__",
"PySide2.QtWidgets.QMessageBox",
"PySide2.QtCore.Signal"
] | [((715, 723), 'PySide2.QtCore.Signal', 'Signal', ([], {}), '()\n', (721, 723), False, 'from PySide2.QtCore import Signal\n'), ((1309, 1331), 'PySide2.QtWidgets.QWidget.__init__', 'QWidget.__init__', (['self'], {}), '(self)\n', (1325, 1331), False, 'from PySide2.QtWidgets import QMessageBox, QWidget, QSizePolicy\n'), ((... |
#################### Random Forest SemEval evaluation ####################
import pandas as pd
import numpy as np
from joblib import dump, load
from sklearn.metrics import f1_score, accuracy_score, precision_score, recall_score
### Loading SemEval 2019 variables
character_variables = np.load(f'non_dl_semeval_character... | [
"numpy.mean",
"sklearn.metrics.f1_score",
"numpy.std",
"numpy.sum",
"numpy.concatenate",
"joblib.load",
"pandas.DataFrame",
"numpy.load"
] | [((286, 336), 'numpy.load', 'np.load', (['f"""non_dl_semeval_character_variables.npy"""'], {}), "(f'non_dl_semeval_character_variables.npy')\n", (293, 336), True, 'import numpy as np\n'), ((360, 411), 'numpy.load', 'np.load', (['f"""non_dl_semeval_dict_count_variables.npy"""'], {}), "(f'non_dl_semeval_dict_count_variab... |
import os, subprocess
if __name__ == "__main__":
move_into_container = list()
if input("Do you want to move some of your local files into to container? This will overwrite files from origin/master. (y/n) ").startswith("y"):
for f in sorted(os.listdir()):
if input("Move %s into container (y/... | [
"os.path.exists",
"os.listdir",
"subprocess.call",
"os.remove"
] | [((822, 910), 'subprocess.call', 'subprocess.call', (["['sudo', 'singularity', 'build', image_name, 'scripts/Singularity']"], {}), "(['sudo', 'singularity', 'build', image_name,\n 'scripts/Singularity'])\n", (837, 910), False, 'import os, subprocess\n'), ((430, 519), 'subprocess.call', 'subprocess.call', (["(['tar',... |
"""
mcpython - a minecraft clone written in python licenced under the MIT-licence
(https://github.com/mcpython4-coding/core)
Contributors: uuk, xkcdjerry (inactive)
Based on the game of fogleman (https://github.com/fogleman/Minecraft), licenced under the MIT-licence
Original game "minecraft" by Mojang Studios (www.m... | [
"mcpython.engine.ResourceLoader.get_all_entries",
"mcpython.shared.registry.get_by_name",
"mcpython.shared.mod_loader.mods.keys"
] | [((715, 761), 'mcpython.shared.registry.get_by_name', 'shared.registry.get_by_name', (['"""minecraft:block"""'], {}), "('minecraft:block')\n", (742, 761), False, 'from mcpython import shared\n'), ((855, 884), 'mcpython.shared.mod_loader.mods.keys', 'shared.mod_loader.mods.keys', ([], {}), '()\n', (882, 884), False, 'fr... |
#! usr/bin/python3
# -*- coding: utf-8 -*-
#
# Flicket - copyright <NAME>: <EMAIL>
from datetime import datetime
from flask import redirect
from flask import request
from flask import make_response
from flask import render_template
from flask import Response
from flask import url_for
from flask_babel import gettext
f... | [
"flask.render_template",
"flask.request.args.get",
"application.flicket.models.flicket_models.FlicketTicket.form_redirect",
"application.flicket.models.flicket_models.FlicketTicket.my_tickets",
"application.flicket.models.flicket_models.FlicketTicket.query_tickets",
"flask.request.args.copy",
"flask.url... | [((824, 842), 'application.flicket.forms.search.SearchTicketForm', 'SearchTicketForm', ([], {}), '()\n', (840, 842), False, 'from application.flicket.forms.search import SearchTicketForm\n'), ((898, 924), 'flask.request.args.get', 'request.args.get', (['"""status"""'], {}), "('status')\n", (914, 924), False, 'from flas... |
from easydict import EasyDict as edict
import numpy as np
config = edict()
config.IMG_HEIGHT = 375
config.IMG_WIDTH = 1242
# TODO(shizehao): infer fea shape in run time
config.FEA_HEIGHT = 12
config.FEA_WIDTH = 39
config.EPSILON = 1e-16
config.LOSS_COEF_BBOX = 5.0
config.LOSS_COEF_CONF_POS = 75.0
config.LOSS_COEF_... | [
"numpy.reshape",
"easydict.EasyDict",
"numpy.array",
"numpy.concatenate",
"numpy.arange"
] | [((68, 75), 'easydict.EasyDict', 'edict', ([], {}), '()\n', (73, 75), True, 'from easydict import EasyDict as edict\n'), ((411, 451), 'numpy.array', 'np.array', (['[[[123.68, 116.779, 103.939]]]'], {}), '([[[123.68, 116.779, 103.939]]])\n', (419, 451), True, 'import numpy as np\n'), ((496, 645), 'numpy.array', 'np.arra... |
import logging
import emission.net.usercache.formatters.generic.userlabel as fgl
def format(entry):
return fgl.format(entry)
| [
"emission.net.usercache.formatters.generic.userlabel.format"
] | [((112, 129), 'emission.net.usercache.formatters.generic.userlabel.format', 'fgl.format', (['entry'], {}), '(entry)\n', (122, 129), True, 'import emission.net.usercache.formatters.generic.userlabel as fgl\n')] |
# Write your code here
import random
word2 = random.choice(['python', 'java', 'kotlin', 'javascript'])
word3 = word2
word3 = list(word3)
for i in range(len(word2)):
word3[i] = '-'
word3 = ''.join([str(elem) for elem in word3])
print("H A N G M A N")
input1 = []
i = 0
while i < 8:
word3 = ''.join([str(ele... | [
"random.choice"
] | [((46, 103), 'random.choice', 'random.choice', (["['python', 'java', 'kotlin', 'javascript']"], {}), "(['python', 'java', 'kotlin', 'javascript'])\n", (59, 103), False, 'import random\n')] |
#!/usr/bin/env python
# main runner of damba web
# ver. 1.6. run 2019-12-04
# <NAME>
version = '1.6'
params = {}
params['version'] = version
params['python_mode'] = "WSGI"
import datetime
import ulid
import redis
from tools import *
from bottle import get, post, route, run, debug, app, template, Bottle, static_fil... | [
"bottle.template",
"ulid.new",
"bottle.Bottle",
"bottle.app.get",
"redis.Redis",
"datetime.datetime.now",
"bottle.app.run"
] | [((329, 337), 'bottle.Bottle', 'Bottle', ([], {}), '()\n', (335, 337), False, 'from bottle import get, post, route, run, debug, app, template, Bottle, static_file\n'), ((375, 398), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (396, 398), False, 'import datetime\n'), ((1665, 1677), 'bottle.app.get... |
from osgeo import gdal
import os
import contextlib
import sys
from bigdatavoyant.raster_data import RasterData
from .netcdf_profiler import NetCDFProfiler
import geovaex
def read_file(file, type='vector', targetCRS=None, point_cols=None, **kwargs):
"""Reads a file into a DataFrame.
Parameters:
file (st... | [
"geovaex.read_file",
"osgeo.gdal.Open",
"bigdatavoyant.raster_data.RasterData",
"os.path.exists",
"os.makedirs",
"os.path.splitext",
"sys.exc_info",
"os.path.dirname",
"os.path.basename"
] | [((2090, 2112), 'os.path.basename', 'os.path.basename', (['file'], {}), '(file)\n', (2106, 2112), False, 'import os\n'), ((2405, 2458), 'geovaex.read_file', 'geovaex.read_file', (['file'], {'convert': 'arrow_file'}), '(file, convert=arrow_file, **kwargs)\n', (2422, 2458), False, 'import geovaex\n'), ((1559, 1592), 'osg... |
from pathlib import Path
from os.path import sep
from pkg_resources import require
from shutil import which
import frontmatter
from flask import (
render_template,
flash,
redirect,
request,
url_for,
send_file,
send_from_directory,
)
from flask_login import login_user, current_user, logout_u... | [
"flask.render_template",
"flask.request.args.get",
"pkg_resources.require",
"archivy.data.move_item",
"archivy.data.get_items",
"archivy.models.User.from_db",
"archivy.search.search_frontmatter_tags",
"frontmatter.dumps",
"archivy.models.DataObj",
"flask.flash",
"pathlib.Path",
"archivy.tags.g... | [((1420, 1434), 'archivy.app.route', 'app.route', (['"""/"""'], {}), "('/')\n", (1429, 1434), False, 'from archivy import data, app, forms, csrf\n'), ((1436, 1455), 'archivy.app.route', 'app.route', (['"""/index"""'], {}), "('/index')\n", (1445, 1455), False, 'from archivy import data, app, forms, csrf\n'), ((2081, 213... |
def forrest(self):
'''Random Forrest based reduction strategy. Somewhat more
aggressive than for example 'spearman' because there are no
negative values, but instead the highest positive correlation
is minused from all the values so that max value is 0, and then
values are turned into positive. The... | [
"numpy.array",
"wrangle.df_corr_randomforest"
] | [((806, 863), 'wrangle.df_corr_randomforest', 'wrangle.df_corr_randomforest', (['data', 'self.reduction_metric'], {}), '(data, self.reduction_metric)\n', (834, 863), False, 'import wrangle\n'), ((1333, 1350), 'numpy.array', 'np.array', (['[value]'], {}), '([value])\n', (1341, 1350), True, 'import numpy as np\n')] |
import os
import invoke
def get_pylint_args():
for root, dirs, files in os.walk("{}/deployer".format(os.getcwd())):
for file in files:
if file.endswith(".py"):
yield os.path.join(root, file)
@invoke.task
def pylint(ctx):
invoke.run("pylint " + " ".join(get_pylint_args()), echo=True)... | [
"os.path.join",
"invoke.run",
"os.getcwd"
] | [((356, 416), 'invoke.run', 'invoke.run', (['"""sphinx-build -b html . ./build/docs"""'], {'echo': '(True)'}), "('sphinx-build -b html . ./build/docs', echo=True)\n", (366, 416), False, 'import invoke\n'), ((106, 117), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (115, 117), False, 'import os\n'), ((198, 222), 'os.path.... |
from abc import ABC, abstractmethod
import numpy as np
import torch
from textattack.goal_function_results import GoalFunctionResultStatus
from textattack.search_methods import PopulationBasedSearch, PopulationMember
from textattack.shared.validators import transformation_consists_of_word_swaps
class GeneticAlgorith... | [
"numpy.random.choice",
"torch.Tensor",
"numpy.count_nonzero",
"numpy.sum",
"textattack.shared.validators.transformation_consists_of_word_swaps",
"numpy.random.uniform",
"textattack.search_methods.PopulationMember"
] | [((3304, 3346), 'numpy.count_nonzero', 'np.count_nonzero', (['word_select_prob_weights'], {}), '(word_select_prob_weights)\n', (3320, 3346), True, 'import numpy as np\n'), ((11528, 11581), 'textattack.shared.validators.transformation_consists_of_word_swaps', 'transformation_consists_of_word_swaps', (['transformation'],... |
import gym
import hydra
from ood_env import OODEnv
from util import ImageInputWrapper
import numpy as np
from stable_baselines3.common.vec_env.vec_frame_stack import VecFrameStack
from stable_baselines3.common.vec_env import DummyVecEnv
from stable_baselines3.common.monitor import Monitor
from stable_baselines3.common... | [
"ood_env.OODEnv",
"hydra.main",
"stable_baselines3.common.env_checker.check_env",
"stable_baselines3.common.vec_env.vec_frame_stack.VecFrameStack",
"wandb.init",
"os.getcwd",
"wandb.config.update",
"stable_baselines3.common.monitor.Monitor",
"wandb.integration.sb3.WandbCallback",
"stable_baselines... | [((766, 815), 'hydra.main', 'hydra.main', ([], {'config_path': '"""."""', 'config_name': '"""config"""'}), "(config_path='.', config_name='config')\n", (776, 815), False, 'import hydra\n'), ((2245, 2384), 'wandb.init', 'wandb.init', ([], {'project': 'cfg.wandb.project', 'entity': 'cfg.wandb.entity', 'config': 'config',... |
#!/usr/bin/env python
# encoding: utf-8
"""
VCF_HeteHomo.py
"""
import argparse
import sys
import logging
import os
import csv
import gzip
import re
def initialize_logger(logfile, logname, isDebug):
logger = logging.getLogger(logname)
loglevel = logging.DEBUG if isDebug else logging.INFO
logger.setLevel(logleve... | [
"logging.getLogger",
"logging.StreamHandler",
"argparse.ArgumentParser",
"gzip.open",
"logging.Formatter",
"logging.FileHandler"
] | [((851, 983), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""filter SV that produced by smoove"""', 'formatter_class': 'argparse.ArgumentDefaultsHelpFormatter'}), "(description='filter SV that produced by smoove',\n formatter_class=argparse.ArgumentDefaultsHelpFormatter)\n", (874, 983... |
import sublime
import sublime_plugin
# Related Reading:
# https://forum.sublimetext.com/t/keybinding-to-find-a-particular-set-of-characters/49064
#
# This command allows you to easily jump the cursor to the next or previous
# location of a specific "scope" in the file. This is a bit more advanced as a
# navigation... | [
"sublime.Region"
] | [((1934, 1955), 'sublime.Region', 'sublime.Region', (['point'], {}), '(point)\n', (1948, 1955), False, 'import sublime\n')] |
from django.db import models
from django.core.validators import RegexValidator
class TimeModel(models.Model):
""" Model that can be inherit to obtain fields like
create time and modified time"""
created = models.DateTimeField(
'created at', auto_now_add=True, help_text='Date time on which objec... | [
"django.db.models.DateTimeField",
"django.core.validators.RegexValidator",
"django.db.models.CharField"
] | [((222, 331), 'django.db.models.DateTimeField', 'models.DateTimeField', (['"""created at"""'], {'auto_now_add': '(True)', 'help_text': '"""Date time on which object was created"""'}), "('created at', auto_now_add=True, help_text=\n 'Date time on which object was created')\n", (242, 331), False, 'from django.db impor... |
from schematics.types import ModelType, StringType, PolyModelType, FloatType, DateTimeType
from spaceone.inventory.model.snapshot.data import Snapshot
from spaceone.inventory.libs.schema.metadata.dynamic_field import TextDyField, DateTimeDyField, EnumDyField, ListDyField, SizeField
from spaceone.inventory.libs.schema.... | [
"spaceone.inventory.libs.schema.metadata.dynamic_field.EnumDyField.data_source",
"spaceone.inventory.libs.schema.metadata.dynamic_field.SizeField.data_source",
"schematics.types.ModelType",
"spaceone.inventory.libs.schema.metadata.dynamic_field.TextDyField.data_source",
"schematics.types.DateTimeType",
"s... | [((1931, 2001), 'spaceone.inventory.libs.schema.cloud_service.CloudServiceMeta.set_layouts', 'CloudServiceMeta.set_layouts', (['[snapshot_info_meta, snapshot_info_tags]'], {}), '([snapshot_info_meta, snapshot_info_tags])\n', (1959, 2001), False, 'from spaceone.inventory.libs.schema.cloud_service import CloudServiceReso... |
import os, sys
import numpy as np
from csalt.synthesize import make_data
from csalt.dmr import *
make_data('simple2-default')
foo = img_cube('simple2-default')
#bar = dmr('simple2-default')
#poo = img_cube('simple2-default', cubetype='MOD', makemask=False)
#pee = img_cube('simple2-default', cubetype='RES', makemask=... | [
"csalt.synthesize.make_data"
] | [((99, 127), 'csalt.synthesize.make_data', 'make_data', (['"""simple2-default"""'], {}), "('simple2-default')\n", (108, 127), False, 'from csalt.synthesize import make_data\n')] |
# This file is to be used for testing only
from django.conf.urls import patterns, include, url
from django.contrib.staticfiles.urls import staticfiles_urlpatterns
from django.contrib import admin
admin.autodiscover()
urlpatterns = patterns('iprestrict.views',
url(r'^iprestrict/$', 'test_rules_page'),
url(r'^... | [
"django.conf.urls.include",
"django.contrib.staticfiles.urls.staticfiles_urlpatterns",
"django.conf.urls.url",
"django.contrib.admin.autodiscover"
] | [((198, 218), 'django.contrib.admin.autodiscover', 'admin.autodiscover', ([], {}), '()\n', (216, 218), False, 'from django.contrib import admin\n'), ((675, 700), 'django.contrib.staticfiles.urls.staticfiles_urlpatterns', 'staticfiles_urlpatterns', ([], {}), '()\n', (698, 700), False, 'from django.contrib.staticfiles.ur... |
import json
from pathlib import Path
import datetime, sys, getopt
import numpy as np
# python script to find .npy files and convert them to binary (int16),
# and deleting the .npy files (saving %50 of space)
# refer to python notebook for some QA checks on this conversion.
def session_entry(session_name,Files,sp):
... | [
"getopt.getopt",
"pathlib.Path",
"numpy.arange",
"sys.exc_info",
"sys.exit",
"datetime.date.today",
"json.dump"
] | [((754, 789), 'getopt.getopt', 'getopt.getopt', (['sys.argv[1:]', '"""a:v:"""'], {}), "(sys.argv[1:], 'a:v:')\n", (767, 789), False, 'import datetime, sys, getopt\n'), ((1044, 1062), 'pathlib.Path', 'Path', (['"""./TasksDir"""'], {}), "('./TasksDir')\n", (1048, 1062), False, 'from pathlib import Path\n'), ((1127, 1148)... |
# module
from __future__ import print_function
import argparse
from tqdm import tqdm
import torch
import torch.nn.functional as F
from torchvision import datasets, transforms
from torchvision.utils import save_image
import time
import torch.nn as nn
from SSGE import Attack,resnet18
import torchvision
from attack impor... | [
"torch.optim.lr_scheduler.MultiStepLR",
"matplotlib.pyplot.ylabel",
"torch.cuda.is_available",
"argparse.ArgumentParser",
"SSGE.Attack",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.xlabel",
"model.Wide_ResNet1",
"torchvision.transforms.ToTensor",
"torchsummary.summary",
"model.Wide_ResNet",
"... | [((587, 633), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""privaCY"""'}), "(description='privaCY')\n", (610, 633), False, 'import argparse\n'), ((2184, 2212), 'torch.manual_seed', 'torch.manual_seed', (['args.seed'], {}), '(args.seed)\n', (2201, 2212), False, 'import torch\n'), ((2222,... |
# Copyright (C) 2011, 2012 Nippon Telegraph and Telephone Corporation.
# Copyright (C) 2011, 2012 <NAME> <yamahata at valinux co jp>
# Copyright (C) 2012 <NAME> <horms ad verge net au>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
... | [
"logging.getLogger",
"struct.calcsize",
"ryu.lib.mac.haddr_bitand",
"itertools.izip",
"struct.unpack_from"
] | [((912, 953), 'logging.getLogger', 'logging.getLogger', (['"""ryu.ofproto.nx_match"""'], {}), "('ryu.ofproto.nx_match')\n", (929, 953), False, 'import logging\n'), ((3771, 3801), 'ryu.lib.mac.haddr_bitand', 'mac.haddr_bitand', (['dl_dst', 'mask'], {}), '(dl_dst, mask)\n', (3787, 3801), False, 'from ryu.lib import mac\n... |
from sql_alchemy import banco
import hashlib
class UserModel(banco.Model):
__tablename__ = 'users'
user_id = banco.Column(banco.Integer, primary_key=True)
login = banco.Column(banco.String(50))
password = banco.Column(banco.String(128))
def __init__(self,login,password):
self.logi... | [
"sql_alchemy.banco.session.delete",
"sql_alchemy.banco.String",
"sql_alchemy.banco.session.add",
"sql_alchemy.banco.Column",
"hashlib.sha512",
"sql_alchemy.banco.session.commit"
] | [((123, 168), 'sql_alchemy.banco.Column', 'banco.Column', (['banco.Integer'], {'primary_key': '(True)'}), '(banco.Integer, primary_key=True)\n', (135, 168), False, 'from sql_alchemy import banco\n'), ((194, 210), 'sql_alchemy.banco.String', 'banco.String', (['(50)'], {}), '(50)\n', (206, 210), False, 'from sql_alchemy ... |
from django.contrib import admin
from first_app.models import Topic, Webpage, AccessRecord
# Register your models here.
admin.site.register(Topic)
admin.site.register(Webpage)
admin.site.register(AccessRecord)
| [
"django.contrib.admin.site.register"
] | [((122, 148), 'django.contrib.admin.site.register', 'admin.site.register', (['Topic'], {}), '(Topic)\n', (141, 148), False, 'from django.contrib import admin\n'), ((149, 177), 'django.contrib.admin.site.register', 'admin.site.register', (['Webpage'], {}), '(Webpage)\n', (168, 177), False, 'from django.contrib import ad... |
import torch
from torch import nn
from torch.autograd import Variable
import random
print_shape_flag = True
class Seq2Seq(nn.Module):
def __init__(self, encoder, decoder, output_max_len, vocab_size):
super(Seq2Seq, self).__init__()
self.encoder = encoder
self.decoder = decoder
self... | [
"torch.eye",
"random.random",
"torch.zeros"
] | [((669, 734), 'torch.zeros', 'torch.zeros', (['(self.output_max_len - 1)', 'batch_size', 'self.vocab_size'], {}), '(self.output_max_len - 1, batch_size, self.vocab_size)\n', (680, 734), False, 'import torch\n'), ((1718, 1733), 'random.random', 'random.random', ([], {}), '()\n', (1731, 1733), False, 'import random\n'), ... |
import datetime
from django.db import models
from taggit.managers import TaggableManager
from django.conf import settings
from django.contrib.contenttypes.models import ContentType
from django.contrib.contenttypes.fields import GenericForeignKey
from django.contrib.auth.models import User
from django.urls import rever... | [
"django.db.models.DateField",
"django.db.models.Manager",
"django.db.models.TextField",
"dateutil.relativedelta.relativedelta",
"django.db.models.IntegerField",
"django.urls.reverse",
"datetime.datetime.today",
"django.db.models.ImageField",
"django.db.models.PositiveSmallIntegerField",
"django.db... | [((798, 831), 'django.db.models.BooleanField', 'models.BooleanField', ([], {'default': '(True)'}), '(default=True)\n', (817, 831), False, 'from django.db import models\n'), ((844, 862), 'django.db.models.TextField', 'models.TextField', ([], {}), '()\n', (860, 862), False, 'from django.db import models\n'), ((882, 900),... |
# This sample tests that a generic type alias can use
# a compatible bound TypeVar.
from typing import Generic, TypeVar
D = TypeVar("D", bool, int, float, object)
E = TypeVar("E", bool, int, float, object)
class Gen(Generic[D]):
pass
GenAlias = Gen[E]
| [
"typing.TypeVar"
] | [((126, 164), 'typing.TypeVar', 'TypeVar', (['"""D"""', 'bool', 'int', 'float', 'object'], {}), "('D', bool, int, float, object)\n", (133, 164), False, 'from typing import Generic, TypeVar\n'), ((169, 207), 'typing.TypeVar', 'TypeVar', (['"""E"""', 'bool', 'int', 'float', 'object'], {}), "('E', bool, int, float, object... |
import mythril.laser.ethereum.util as helper
from mythril.ethereum.evmcontract import EVMContract
from mythril.ethereum.util import get_solc_json
from mythril.exceptions import NoContractFoundError
class SourceMapping:
def __init__(self, solidity_file_idx, offset, length, lineno):
self.solidity_file_idx =... | [
"mythril.laser.ethereum.util.get_instruction_index",
"mythril.ethereum.util.get_solc_json"
] | [((795, 866), 'mythril.ethereum.util.get_solc_json', 'get_solc_json', (['input_file'], {'solc_args': 'solc_args', 'solc_binary': 'solc_binary'}), '(input_file, solc_args=solc_args, solc_binary=solc_binary)\n', (808, 866), False, 'from mythril.ethereum.util import get_solc_json\n'), ((1461, 1532), 'mythril.ethereum.util... |
import mysql.connector
cnx = mysql.connector.connect(user='nanostring', password = '<PASSWORD>', host='Loki', database='BISProd')
cursor = cnx.cursor()
import os,sys
from BIS_py import percentID,generate_coords
genome = 'hg38'
fname = sys.argv[1]
seqs = {}
f=open(fname,'r')
out = open('to_blat.fsa','w')
for line in f... | [
"os.system",
"BIS_py.generate_coords"
] | [((631, 736), 'os.system', 'os.system', (["('gfClient ' + server + ' ' + port +\n ' / to_blat.fsa blat_out.txt -out=blast8 -minScore=20')"], {}), "('gfClient ' + server + ' ' + port +\n ' / to_blat.fsa blat_out.txt -out=blast8 -minScore=20')\n", (640, 736), False, 'import os, sys\n'), ((1139, 1173), 'BIS_py.gener... |
from __future__ import unicode_literals
import frappe
from frappe.model.document import Document
from frappeclient import FrappeClient
import json
import os
import requests
import subprocess
from frappe.utils.background_jobs import enqueue
from frappe.utils import get_site_name
from frappe.utils import flt,... | [
"frappeclient.FrappeClient",
"frappe.whitelist",
"frappe.get_doc"
] | [((357, 375), 'frappe.whitelist', 'frappe.whitelist', ([], {}), '()\n', (373, 375), False, 'import frappe\n'), ((960, 978), 'frappe.whitelist', 'frappe.whitelist', ([], {}), '()\n', (976, 978), False, 'import frappe\n'), ((1570, 1588), 'frappe.whitelist', 'frappe.whitelist', ([], {}), '()\n', (1586, 1588), False, 'impo... |
import sys
sys.path.append("../myutil")
from input_filtered import int_input
def bit_flag(bit, index):
return bit >> index & 1
def next_generation(state, rule):
if len(state) == 1:
return [bit_flag(rule, state[0] * 2)]
next_gen = []
for i in range(len(state)):
index = 0
if i ... | [
"sys.path.append",
"input_filtered.int_input"
] | [((11, 39), 'sys.path.append', 'sys.path.append', (['"""../myutil"""'], {}), "('../myutil')\n", (26, 39), False, 'import sys\n'), ((803, 857), 'input_filtered.int_input', 'int_input', ([], {'min_val': '(0)', 'max_val': '(255)', 'description': '"""Rule:"""'}), "(min_val=0, max_val=255, description='Rule:')\n", (812, 857... |
# coding=utf-8
# *** WARNING: this file was generated by the Pulumi SDK Generator. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union
from ... import _utilities, _tables
from... | [
"pulumi.get",
"pulumi.Alias",
"pulumi.getter",
"warnings.warn",
"pulumi.ResourceOptions",
"pulumi.ResourceOptions.merge"
] | [((5912, 5946), 'pulumi.getter', 'pulumi.getter', ([], {'name': '"""lastModified"""'}), "(name='lastModified')\n", (5925, 5946), False, 'import pulumi\n'), ((4249, 4295), 'pulumi.ResourceOptions.merge', 'pulumi.ResourceOptions.merge', (['opts', 'alias_opts'], {}), '(opts, alias_opts)\n', (4277, 4295), False, 'import pu... |
#!/usr/bin/env python
import sys
import rospy
from geometry_msgs.msg import (Twist, Pose, Point, Quaternion, PoseStamped)
import tf.transformations as tf
import numpy
from threading import Lock
class Converter:
def __init__(self):
self.currentPose = None
self.pub = None
self.mutex = Lock()
def callbackOdom(... | [
"tf.transformations.quaternion_multiply",
"rospy.Subscriber",
"rospy.init_node",
"threading.Lock",
"tf.transformations.quaternion_matrix",
"rospy.myargv",
"numpy.matmul",
"rospy.spin",
"tf.transformations.quaternion_from_euler",
"geometry_msgs.msg.PoseStamped",
"rospy.Publisher"
] | [((1522, 1544), 'rospy.myargv', 'rospy.myargv', (['sys.argv'], {}), '(sys.argv)\n', (1534, 1544), False, 'import rospy\n'), ((1586, 1638), 'rospy.init_node', 'rospy.init_node', (['"""cmd_vel_converter"""'], {'anonymous': '(True)'}), "('cmd_vel_converter', anonymous=True)\n", (1601, 1638), False, 'import rospy\n'), ((16... |
import logging
import os
from collections import defaultdict
from datetime import datetime
from typing import Optional, List
from urllib.parse import urlparse
from uuid import uuid4
from great_expectations.checkpoint import ValidationAction
from great_expectations.core import ExpectationSuiteValidationResult
from grea... | [
"logging.getLogger",
"openlineage.client.OpenLineageClient.from_environment",
"sqlalchemy.Table",
"openlineage.client.facet.SourceCodeLocationJobFacet",
"sqlalchemy.MetaData",
"openlineage.client.facet.ParentRunFacet.create",
"openlineage.client.serde.Serde.to_dict",
"openlineage.common.provider.great... | [((4905, 4981), 'logging.getLogger', 'logging.getLogger', (["(self.__class__.__module__ + '.' + self.__class__.__name__)"], {}), "(self.__class__.__module__ + '.' + self.__class__.__name__)\n", (4922, 4981), False, 'import logging\n'), ((6921, 6945), 'openlineage.client.serde.Serde.to_dict', 'Serde.to_dict', (['run_eve... |
from django.urls import reverse
from django.contrib.admin.templatetags.admin_modify import submit_row
from django.utils.encoding import force_text
from django.template import Library
register = Library()
@register.inclusion_tag('subadmin/breadcrumbs.html', takes_context=True)
def subadmin_breadcrumbs(context):
r... | [
"django.utils.encoding.force_text",
"django.contrib.admin.templatetags.admin_modify.submit_row",
"django.template.Library",
"django.urls.reverse"
] | [((196, 205), 'django.template.Library', 'Library', ([], {}), '()\n', (203, 205), False, 'from django.template import Library\n'), ((1834, 1853), 'django.contrib.admin.templatetags.admin_modify.submit_row', 'submit_row', (['context'], {}), '(context)\n', (1844, 1853), False, 'from django.contrib.admin.templatetags.admi... |
from IPython.terminal.embed import InteractiveShellEmbed
from pylivetrader.data.bardata import BarData
import pandas as pd
def start_shell(algorithm, algomodule):
algomodule['context'] = algorithm
algomodule['data'] = BarData(
algorithm.data_portal,
algorithm.data_frequency)
algorithm.on_d... | [
"pylivetrader.data.bardata.BarData",
"IPython.terminal.embed.InteractiveShellEmbed",
"pandas.Timestamp.utcnow"
] | [((228, 284), 'pylivetrader.data.bardata.BarData', 'BarData', (['algorithm.data_portal', 'algorithm.data_frequency'], {}), '(algorithm.data_portal, algorithm.data_frequency)\n', (235, 284), False, 'from pylivetrader.data.bardata import BarData\n'), ((424, 447), 'IPython.terminal.embed.InteractiveShellEmbed', 'Interacti... |
"""importation"""
from plotly.offline import plot # pour travailler en offline!
import plotly.graph_objects as go
import numpy as np
from scipy.integrate import odeint
# Population totale, N.
N = 10000
# Nombre initial de sujets infectés et sauvés (immunisés, guéris, décédés).
I0, D0, R0 = 1, 0, 0
# Tous les autre... | [
"scipy.integrate.odeint",
"plotly.graph_objects.Figure",
"numpy.linspace",
"plotly.offline.plot"
] | [((519, 541), 'numpy.linspace', 'np.linspace', (['(0)', '(90)', '(90)'], {}), '(0, 90, 90)\n', (530, 541), True, 'import numpy as np\n'), ((843, 890), 'scipy.integrate.odeint', 'odeint', (['deriv', 'y0', 't'], {'args': '(N, beta, mu, theta)'}), '(deriv, y0, t, args=(N, beta, mu, theta))\n', (849, 890), False, 'from sci... |
from lithopscloud.modules.config_builder import ConfigBuilder, update_decorator, spinner
from typing import Any, Dict
from lithopscloud.modules.utils import find_obj, find_default
class ImageConfig(ConfigBuilder):
def __init__(self, base_config: Dict[str, Any]) -> None:
super().__init__(base_config)
... | [
"lithopscloud.modules.utils.find_obj",
"lithopscloud.modules.utils.find_default"
] | [((689, 825), 'lithopscloud.modules.utils.find_obj', 'find_obj', (['image_objects', '"""Please choose \x1b[92mUbuntu\x1b[0m 20.04 VM image, currently only Ubuntu supported"""'], {'default': 'default'}), "(image_objects,\n 'Please choose \\x1b[92mUbuntu\\x1b[0m 20.04 VM image, currently only Ubuntu supported'\n , ... |
import balanced
balanced.configure('ak-test-2eKlj1ZDfAcZSARMf3NMhBHywDej0avSY')
reversal = balanced.Reversal.fetch('/reversals/RV6AleFrrhNHBDpr9W9ozGmY')
reversal.description = 'update this description'
reversal.meta = {
'user.refund.count': '3',
'refund.reason': 'user not happy with product',
'user.notes': 've... | [
"balanced.configure",
"balanced.Reversal.fetch"
] | [((17, 80), 'balanced.configure', 'balanced.configure', (['"""ak-test-2eKlj1ZDfAcZSARMf3NMhBHywDej0avSY"""'], {}), "('ak-test-2eKlj1ZDfAcZSARMf3NMhBHywDej0avSY')\n", (35, 80), False, 'import balanced\n'), ((93, 155), 'balanced.Reversal.fetch', 'balanced.Reversal.fetch', (['"""/reversals/RV6AleFrrhNHBDpr9W9ozGmY"""'], {... |
# uncompyle6 version 3.2.4
# Python bytecode 2.7 (62211)
# Decompiled from: Python 2.7.15 (v2.7.15:ca079a3ea3, Apr 30 2018, 16:30:26) [MSC v.1500 64 bit (AMD64)]
# Embedded file name: lib.coginvasion.friends.FriendRequest
from direct.directnotify.DirectNotifyGlobal import directNotify
from direct.gui.DirectGui import D... | [
"direct.gui.DirectGui.DirectFrame.__init__",
"direct.directnotify.DirectNotifyGlobal.directNotify.newCategory",
"lib.coginvasion.toon.ToonDNA.ToonDNA"
] | [((448, 489), 'direct.directnotify.DirectNotifyGlobal.directNotify.newCategory', 'directNotify.newCategory', (['"""FriendRequest"""'], {}), "('FriendRequest')\n", (472, 489), False, 'from direct.directnotify.DirectNotifyGlobal import directNotify\n'), ((540, 566), 'direct.gui.DirectGui.DirectFrame.__init__', 'DirectFra... |
# -*- coding:utf-8 -*-
# email:<EMAIL>
# create: 2021/1/7
from utils.common_util import get_model_name
import models, datasets
from utils.log import logger
import time, torchvision
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
class Pix2pixTrainer(object):
def __init_... | [
"torch.utils.tensorboard.SummaryWriter",
"utils.log.logger.info",
"torch.utils.data.DataLoader",
"torchvision.utils.make_grid",
"time.time"
] | [((782, 815), 'utils.log.logger.info', 'logger.info', (['"""model init success"""'], {}), "('model init success')\n", (793, 815), False, 'from utils.log import logger\n'), ((898, 970), 'torch.utils.tensorboard.SummaryWriter', 'SummaryWriter', ([], {'log_dir': 'tensorboard_log_dir', 'comment': 'self.experiment_name'}), ... |
from django.db import models
from core.models import TimeStampedModel
# Create your models here.
class Subscribe(TimeStampedModel):
email = models.EmailField(unique=True)
| [
"django.db.models.EmailField"
] | [((147, 177), 'django.db.models.EmailField', 'models.EmailField', ([], {'unique': '(True)'}), '(unique=True)\n', (164, 177), False, 'from django.db import models\n')] |
import os
os.environ['CUDA_VISIBLE_DEVICES'] = ''
import numpy as np
import matplotlib.pyplot as plt
import sys
import warnings
warnings.filterwarnings("ignore", message=r"Passing", category=FutureWarning)
import tensorflow as tf
from tensorflow.contrib import slim
np.random.seed(0)
config = tf.ConfigProto(
devi... | [
"numpy.ones",
"tensorflow.Session",
"tensorflow.global_variables_initializer",
"tensorflow.constant",
"numpy.random.seed",
"tensorflow.constant_initializer",
"tensorflow.ConfigProto",
"warnings.filterwarnings"
] | [((130, 206), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {'message': '"""Passing"""', 'category': 'FutureWarning'}), "('ignore', message='Passing', category=FutureWarning)\n", (153, 206), False, 'import warnings\n'), ((269, 286), 'numpy.random.seed', 'np.random.seed', (['(0)'], {}), '(0)\n... |
import codecs
import itertools
import pytest
import time
import uuid
from eth_utils import (
is_integer,
to_tuple,
)
from client_sdk_python import Web3
from client_sdk_python.middleware import ( # noqa: F401
construct_error_generator_middleware,
construct_latest_block_based_cache_middleware,
cons... | [
"client_sdk_python.middleware.construct_result_generator_middleware",
"client_sdk_python.middleware.construct_latest_block_based_cache_middleware",
"uuid.uuid4",
"client_sdk_python.providers.base.BaseProvider",
"itertools.count",
"client_sdk_python.middleware.construct_error_generator_middleware",
"pyte... | [((3836, 4006), 'client_sdk_python.middleware.construct_latest_block_based_cache_middleware', 'construct_latest_block_based_cache_middleware', ([], {'cache_class': 'dict', 'average_block_time_sample_size': '(1)', 'default_average_block_time': '(0.1)', 'rpc_whitelist': "{'fake_endpoint'}"}), "(cache_class=dict,\n ave... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Mon Dec 26 16:40:05 2016
@author: pavel
"""
from gi.repository import GObject
from utils import logger, Singleton
class LogWindow(metaclass=Singleton):
def __init__(self, builder, parent_window):
self.builder = builder
self.visible = Fa... | [
"gi.repository.GObject.idle_add",
"utils.logger.tempfile.file.read",
"utils.logger.tempfile.file.seek",
"utils.logger.add_listener"
] | [((729, 766), 'utils.logger.add_listener', 'logger.add_listener', (['self._on_log_msg'], {}), '(self._on_log_msg)\n', (748, 766), False, 'from utils import logger, Singleton\n'), ((810, 838), 'utils.logger.tempfile.file.seek', 'logger.tempfile.file.seek', (['(0)'], {}), '(0)\n', (835, 838), False, 'from utils import lo... |
"""
Power sum symmetric functions
"""
#*****************************************************************************
# Copyright (C) 2007 <NAME> <<EMAIL>>
# 2012 <NAME> <<EMAIL>>
# 2012 <NAME> <anne at math.ucdavis.edu>
#
# Distributed under the terms of the GNU General Pu... | [
"sage.combinat.partition._Partitions",
"sage.combinat.partition.Partition",
"sage.structure.sage_object.register_unpickle_override",
"sfa.zee",
"classical.SymmetricFunctionAlgebra_classical.__init__"
] | [((22368, 22513), 'sage.structure.sage_object.register_unpickle_override', 'register_unpickle_override', (['"""sage.combinat.sf.powersum"""', '"""SymmetricFunctionAlgebraElement_power"""', 'SymmetricFunctionAlgebra_power.Element'], {}), "('sage.combinat.sf.powersum',\n 'SymmetricFunctionAlgebraElement_power', Symmet... |
from datetime import datetime
from os.path import dirname, join
from unittest.mock import MagicMock
import pytest
from city_scrapers_core.constants import BOARD, TENTATIVE
from city_scrapers_core.utils import file_response
from freezegun import freeze_time
from city_scrapers.spiders.chi_library import ChiLibrarySpide... | [
"datetime.datetime",
"unittest.mock.MagicMock",
"os.path.dirname",
"pytest.mark.parametrize",
"freezegun.freeze_time",
"city_scrapers.spiders.chi_library.ChiLibrarySpider"
] | [((333, 358), 'freezegun.freeze_time', 'freeze_time', (['"""2018-12-20"""'], {}), "('2018-12-20')\n", (344, 358), False, 'from freezegun import freeze_time\n'), ((385, 396), 'unittest.mock.MagicMock', 'MagicMock', ([], {}), '()\n', (394, 396), False, 'from unittest.mock import MagicMock\n'), ((408, 419), 'unittest.mock... |
from threading import Thread
from queue import Queue
import numpy as np
from ...libffcv import read
class PageReader(Thread):
def __init__(self, fname:str, queries: Queue, loaded: Queue,
memory: np.ndarray):
self.fname: str = fname
self.queries: Queue = queries
self.mem... | [
"numpy.uint64"
] | [((814, 853), 'numpy.uint64', 'np.uint64', (['(page_number * self.page_size)'], {}), '(page_number * self.page_size)\n', (823, 853), True, 'import numpy as np\n')] |
import os
import shutil
import winreg
import sys
import time
from elevate import elevate
elevate()
print("elevated")
curr_executable = sys.executable
print(curr_executable)
time.sleep(5)
app_data = os.getenv("APPDATA")
to_save_file = app_data +"\\"+"system32_data.exe"
time.sleep(5)
print(to_save_file)
if not os.pat... | [
"os.path.exists",
"winreg.CloseKey",
"winreg.OpenKey",
"os.getenv",
"time.sleep",
"shutil.copyfile",
"elevate.elevate",
"winreg.SetValueEx"
] | [((90, 99), 'elevate.elevate', 'elevate', ([], {}), '()\n', (97, 99), False, 'from elevate import elevate\n'), ((175, 188), 'time.sleep', 'time.sleep', (['(5)'], {}), '(5)\n', (185, 188), False, 'import time\n'), ((200, 220), 'os.getenv', 'os.getenv', (['"""APPDATA"""'], {}), "('APPDATA')\n", (209, 220), False, 'import... |
import SimpleITK as sitk
import numpy as np
#from segmentation.lungmask import mask
import glob
from tqdm import tqdm
import os
from segmentation.predict import predict,get_model
#from segmentation.unet import UNet
os.environ["CUDA_VISIBLE_DEVICES"] = '6'
lung_dir = '/mnt/data11/seg_of_XCT/lung/CAP/'
leision_dir = '/... | [
"segmentation.predict.get_model",
"SimpleITK.GetImageFromArray",
"os.makedirs",
"tqdm.tqdm",
"SimpleITK.GetArrayFromImage",
"numpy.array",
"segmentation.predict.predict",
"SimpleITK.ReadImage",
"glob.glob"
] | [((413, 432), 'glob.glob', 'glob.glob', (['root_dir'], {}), '(root_dir)\n', (422, 432), False, 'import glob\n'), ((433, 472), 'os.makedirs', 'os.makedirs', (['leision_dir'], {'exist_ok': '(True)'}), '(leision_dir, exist_ok=True)\n', (444, 472), False, 'import os\n'), ((514, 544), 'segmentation.predict.get_model', 'get_... |