code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
import re
from typing import List
from collections import Counter
from data import Article
class Process:
def process(self, words: List[str]) -> List[str]:
pass
class Strategy:
_lastLetters = List[str]
_measure = List[int]
_containsVowel = False
_doubleConsonant = False
_endsWithPat... | [
"re.match",
"re.search",
"collections.Counter",
"re.sub",
"re.compile"
] | [((664, 716), 're.sub', 're.sub', (['self._applyRegex', 'self._replacement', 'word', '(0)'], {}), '(self._applyRegex, self._replacement, word, 0)\n', (670, 716), False, 'import re\n'), ((3718, 3748), 're.search', 're.search', (['self._pattern', 'text'], {}), '(self._pattern, text)\n', (3727, 3748), False, 'import re\n'... |
#!/usr/bin/env python3
import os
import urllib.parse
import urllib.request
from collections import OrderedDict
import xml.etree.ElementTree
class NameSilo(object):
def __init__(self, apikey):
self._apikey = apikey
def _make_url(self, op, **args):
x = OrderedDict(
version=1,
type='xml',
key=self._apike... | [
"collections.OrderedDict"
] | [((260, 312), 'collections.OrderedDict', 'OrderedDict', ([], {'version': '(1)', 'type': '"""xml"""', 'key': 'self._apikey'}), "(version=1, type='xml', key=self._apikey)\n", (271, 312), False, 'from collections import OrderedDict\n')] |
import unittest
from mock import mock
from capiq.capiq_client import CapIQClient
def mocked_gdsp_data_requests_post(*args, **kwargs):
class MockResponse:
def __init__(self, json_data, status_code):
self.json_data = json_data
self.status_code = status_code
def json(self):... | [
"mock.mock.patch",
"capiq.capiq_client.CapIQClient"
] | [((2385, 2480), 'mock.mock.patch', 'mock.patch', (['"""capiq.capiq_client.requests.post"""'], {'side_effect': 'mocked_gdsp_data_requests_post'}), "('capiq.capiq_client.requests.post', side_effect=\n mocked_gdsp_data_requests_post)\n", (2395, 2480), False, 'from mock import mock\n'), ((2749, 2847), 'mock.mock.patch',... |
from shutil import copyfile
import glob
import os
if not os.path.exists("config"):
os.mkdir("config")
for file in glob.glob("example-config/*.json"):
copyfile(file, os.path.join("config", file.split("example-")[-1]))
| [
"os.mkdir",
"os.path.exists",
"glob.glob"
] | [((120, 154), 'glob.glob', 'glob.glob', (['"""example-config/*.json"""'], {}), "('example-config/*.json')\n", (129, 154), False, 'import glob\n'), ((58, 82), 'os.path.exists', 'os.path.exists', (['"""config"""'], {}), "('config')\n", (72, 82), False, 'import os\n'), ((88, 106), 'os.mkdir', 'os.mkdir', (['"""config"""']... |
from enum import Enum
from numerous.engine.model import Model
from numerous.engine.simulation import Simulation
from numerous.engine.system import Subsystem, Item
from tests.test_equations import TestEq_ground, Test_Eq, TestEq_input
from enum import Enum
from numerous.engine.model import Model
from numerous.engine.s... | [
"tests.test_equations.TestEq_input",
"tests.test_equations.Test_Eq",
"numerous.engine.simulation.Simulation",
"tests.test_equations.TestEq_ground",
"numerous.engine.model.Model"
] | [((2351, 2386), 'numerous.engine.model.Model', 'Model', ([], {'system': 'ms', 'use_llvm': 'use_llvm'}), '(system=ms, use_llvm=use_llvm)\n', (2356, 2386), False, 'from numerous.engine.model import Model\n'), ((2396, 2462), 'numerous.engine.simulation.Simulation', 'Simulation', (['m1'], {'t_start': '(0)', 't_stop': '(100... |
from django.contrib.staticfiles.testing import StaticLiveServerTestCase
from selenium import webdriver
from selenium.common.exceptions import NoSuchElementException
from pyvirtualdisplay import Display
from tests.testing_utilities import populate_test_db
class FunctionalTest(StaticLiveServerTestCase):
def setUp... | [
"pyvirtualdisplay.Display",
"tests.testing_utilities.populate_test_db",
"selenium.webdriver.Firefox"
] | [((346, 381), 'pyvirtualdisplay.Display', 'Display', ([], {'visible': '(0)', 'size': '(800, 600)'}), '(visible=0, size=(800, 600))\n', (353, 381), False, 'from pyvirtualdisplay import Display\n'), ((431, 450), 'selenium.webdriver.Firefox', 'webdriver.Firefox', ([], {}), '()\n', (448, 450), False, 'from selenium import ... |
from abc import ABC, abstractmethod
from typing import TypeVar, Generic, List
from geniusweb.connection.ConnectionEnd import ConnectionEnd
INTYPE = TypeVar('INTYPE')
OUTTYPE = TypeVar('OUTTYPE')
class Connectable(ABC, Generic[INTYPE,OUTTYPE]):
'''
A Connectable is an object that can connect on request with a provi... | [
"typing.TypeVar"
] | [((150, 167), 'typing.TypeVar', 'TypeVar', (['"""INTYPE"""'], {}), "('INTYPE')\n", (157, 167), False, 'from typing import TypeVar, Generic, List\n'), ((178, 196), 'typing.TypeVar', 'TypeVar', (['"""OUTTYPE"""'], {}), "('OUTTYPE')\n", (185, 196), False, 'from typing import TypeVar, Generic, List\n')] |
import os
import pandas as pd
class MergeExcel(object):
def __init__(self, excel_filepath=None, folder_path=None, sheetname_lst=None):
"""
: df_dict: df组成的字典，key为sheetname
: sheetname_lst: 需要合并的sheetname列为，默认为空，即不指定则合并所有
"""
self.excel_filepath = excel_filepath
self... | [
"pandas.DataFrame",
"os.path.abspath",
"os.path.isabs",
"os.path.join",
"os.path.basename",
"os.path.dirname",
"os.walk",
"pandas.read_excel",
"pandas.ExcelWriter",
"pandas.concat"
] | [((1401, 1425), 'pandas.concat', 'pd.concat', (['df_sheet_dict'], {}), '(df_sheet_dict)\n', (1410, 1425), True, 'import pandas as pd\n'), ((2855, 2889), 'os.walk', 'os.walk', (['folder_path'], {'topdown': '(True)'}), '(folder_path, topdown=True)\n', (2862, 2889), False, 'import os\n'), ((4322, 4383), 'pandas.ExcelWrite... |
"""Experiments and corresponding analysis.
format adapted from https://github.com/gyyang/olfaction_evolution
Each experiment is described by a function that returns a list of configurations
function name is the experiment name
combinatorial mode:
config_ranges should not have repetitive values
sequential mode:
... | [
"utils.config_utils.vary_config",
"copy.deepcopy",
"numpy.zeros_like",
"analysis.plots.plot_gen",
"os.path.join",
"logging.basicConfig",
"evaluate.eval_total_acc",
"numpy.arange",
"analysis.train_analysis.plot_train_log",
"collections.OrderedDict",
"configs.configs.BaseConfig",
"analysis.plots... | [((857, 893), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'LOG_LEVEL'}), '(level=LOG_LEVEL)\n', (876, 893), False, 'import logging\n'), ((1048, 1093), 'analysis.train_analysis.plot_train_log', 'plot_train_log', (['[exp_path]'], {'exp_name': 'exp_name'}), '([exp_path], exp_name=exp_name)\n', (1062, 1093... |
from onnx_tf.handlers.backend_handler import BackendHandler
from onnx_tf.handlers.handler import onnx_op
from onnx_tf.handlers.handler import partial_support
from onnx_tf.handlers.handler import ps_description
from .conv_mixin import ConvMixin
@onnx_op("ConvTranspose")
@partial_support(True)
@ps_description("ConvTran... | [
"onnx_tf.handlers.handler.onnx_op",
"onnx_tf.handlers.handler.partial_support",
"onnx_tf.handlers.handler.ps_description"
] | [((247, 271), 'onnx_tf.handlers.handler.onnx_op', 'onnx_op', (['"""ConvTranspose"""'], {}), "('ConvTranspose')\n", (254, 271), False, 'from onnx_tf.handlers.handler import onnx_op\n'), ((273, 294), 'onnx_tf.handlers.handler.partial_support', 'partial_support', (['(True)'], {}), '(True)\n', (288, 294), False, 'from onnx... |
# 12.10
import pandas as pd
import seaborn as sns
from sklearn.datasets import load_iris
iris_dataset = load_iris()
# creamos un dataframe de los datos de flores
# etiquetamos las columnas usando las cadenas de iris_dataset.feature_names
iris_dataframe = pd.DataFrame(iris_dataset['data'], columns = iris_dataset.feat... | [
"pandas.DataFrame",
"sklearn.datasets.load_iris",
"seaborn.pairplot"
] | [((106, 117), 'sklearn.datasets.load_iris', 'load_iris', ([], {}), '()\n', (115, 117), False, 'from sklearn.datasets import load_iris\n'), ((258, 328), 'pandas.DataFrame', 'pd.DataFrame', (["iris_dataset['data']"], {'columns': 'iris_dataset.feature_names'}), "(iris_dataset['data'], columns=iris_dataset.feature_names)\n... |
from __future__ import annotations
from pyramid.config import Configurator
from wsgiref.simple_server import make_server
from zope.interface import Interface, implementer
from pyramid_services_viewmapper import ServiceInjector as SI, ServiceViewMapper
class IExampleService(Interface):
def example(self):
... | [
"zope.interface.implementer",
"pyramid.config.Configurator",
"pyramid_services_viewmapper.ServiceInjector"
] | [((329, 357), 'zope.interface.implementer', 'implementer', (['IExampleService'], {}), '(IExampleService)\n', (340, 357), False, 'from zope.interface import Interface, implementer\n'), ((1114, 1128), 'pyramid.config.Configurator', 'Configurator', ([], {}), '()\n', (1126, 1128), False, 'from pyramid.config import Configu... |
'''
Created on 22.09.2014
@author: markusfasel
'''
from PWGJE.EMCALJetTasks.Tracks.analysis.base.Graphics import SinglePanelPlot, GraphicsObject, Style, Frame
from PWGJE.EMCALJetTasks.Tracks.analysis.correction.TriggeredSpectrumScaler import TriggeredSpectrumScaler
from PWGJE.EMCALJetTasks.Tracks.analysis.correction.... | [
"PWGJE.EMCALJetTasks.Tracks.analysis.correction.TriggeredSpectrumScaler.TriggeredSpectrumScaler",
"PWGJE.EMCALJetTasks.Tracks.analysis.base.Graphics.Frame",
"PWGJE.EMCALJetTasks.Tracks.analysis.base.Graphics.Style",
"PWGJE.EMCALJetTasks.Tracks.analysis.base.Graphics.SinglePanelPlot.__init__"
] | [((596, 626), 'PWGJE.EMCALJetTasks.Tracks.analysis.base.Graphics.SinglePanelPlot.__init__', 'SinglePanelPlot.__init__', (['self'], {}), '(self)\n', (620, 626), False, 'from PWGJE.EMCALJetTasks.Tracks.analysis.base.Graphics import SinglePanelPlot, GraphicsObject, Style, Frame\n'), ((741, 800), 'PWGJE.EMCALJetTasks.Track... |
"""
Module Functions:
Plot King County House Rate data,
in the form of sale listing cluster map and density heat map.
"""
import os
import webbrowser
import pandas as pd
import folium
from folium import plugins
# Set global settings and macros.
MAX_SHOW = 1000
HOUSE_URL = 'houses.html'
HOUSE_HEAT_URL = "hou... | [
"pandas.read_csv",
"os.path.realpath",
"pandas.set_option",
"folium.MarkerCluster"
] | [((373, 415), 'pandas.set_option', 'pd.set_option', (['"""display.max_columns"""', 'None'], {}), "('display.max_columns', None)\n", (386, 415), True, 'import pandas as pd\n'), ((484, 549), 'pandas.read_csv', 'pd.read_csv', (['"""../../Data/kc_house_data.csv"""'], {'parse_dates': "['date']"}), "('../../Data/kc_house_dat... |
from pathlib import Path
import numpy as np
from PIL import Image
def load_light_distribution(name="lamp_spectrum.csv"):
sd_light_source = np.loadtxt(name, skiprows=1, dtype="float")
sd_light_source = sd_light_source[np.where(sd_light_source[:, 0] >= 400)]
# rindx = np.where(sd_light_source[:, 0] >= 400)... | [
"numpy.stack",
"numpy.uint8",
"numpy.sum",
"numpy.power",
"numpy.clip",
"pathlib.Path",
"numpy.where",
"numpy.array",
"numpy.loadtxt",
"numpy.dot"
] | [((146, 189), 'numpy.loadtxt', 'np.loadtxt', (['name'], {'skiprows': '(1)', 'dtype': '"""float"""'}), "(name, skiprows=1, dtype='float')\n", (156, 189), True, 'import numpy as np\n'), ((663, 706), 'numpy.loadtxt', 'np.loadtxt', (['name'], {'skiprows': '(1)', 'dtype': '"""float"""'}), "(name, skiprows=1, dtype='float')\... |
import pyaudio
import numpy as np
import sys
import time
import asyncio
from aiohttp import web, WSMsgType
import json
import os
import struct
import websocket
HOST = os.getenv('HOST', '0.0.0.0')
PORT = int(os.getenv('PORT', 8080))
SAMPLE_RATE = 44100
CHUNK_SIZE = 4096
AUDIO_FORMAT = pyaudio.paInt16
FORMAT = np.int... | [
"numpy.fft.rfft",
"numpy.average",
"aiohttp.web.Response",
"aiohttp.web.WebSocketResponse",
"asyncio.get_event_loop",
"numpy.abs",
"aiohttp.web.Application",
"json.dumps",
"numpy.max",
"numpy.reshape",
"aiohttp.web.run_app",
"pyaudio.PyAudio",
"os.getenv"
] | [((169, 197), 'os.getenv', 'os.getenv', (['"""HOST"""', '"""0.0.0.0"""'], {}), "('HOST', '0.0.0.0')\n", (178, 197), False, 'import os\n'), ((209, 232), 'os.getenv', 'os.getenv', (['"""PORT"""', '(8080)'], {}), "('PORT', 8080)\n", (218, 232), False, 'import os\n'), ((424, 441), 'numpy.fft.rfft', 'np.fft.rfft', (['data']... |
from django.contrib import admin
# Register your models here.
from .models import Movie
class MovieAdmin(admin.ModelAdmin):
list_display = ['id', 'movie_id', 'title', 'slug']
prepopulated_fields = {
"slug": ("title",)
}
admin.site.register(Movie, MovieAdmin) | [
"django.contrib.admin.site.register"
] | [((244, 282), 'django.contrib.admin.site.register', 'admin.site.register', (['Movie', 'MovieAdmin'], {}), '(Movie, MovieAdmin)\n', (263, 282), False, 'from django.contrib import admin\n')] |
import os
import boto3
TABLE_NAME = os.environ.get("TABLE_NAME", "filter-demo-data")
TABLE = boto3.resource("dynamodb").Table(TABLE_NAME)
CLIENT = boto3.client("dynamodb")
def lambda_handler(event, context):
# We can work on the assumption that we only get items
# in NewImage with a type of "VIEW", that me... | [
"os.environ.get",
"boto3.resource",
"boto3.client"
] | [((38, 86), 'os.environ.get', 'os.environ.get', (['"""TABLE_NAME"""', '"""filter-demo-data"""'], {}), "('TABLE_NAME', 'filter-demo-data')\n", (52, 86), False, 'import os\n'), ((150, 174), 'boto3.client', 'boto3.client', (['"""dynamodb"""'], {}), "('dynamodb')\n", (162, 174), False, 'import boto3\n'), ((96, 122), 'boto3... |
# Copyright (c) 2013, 2021, Oracle and/or its affiliates.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License, version 2.0, as
# published by the Free Software Foundation.
#
# This program is also distributed with certain software (including
# ... | [
"tests.foreach_cnx"
] | [((2072, 2091), 'tests.foreach_cnx', 'tests.foreach_cnx', ([], {}), '()\n', (2089, 2091), False, 'import tests\n'), ((2462, 2481), 'tests.foreach_cnx', 'tests.foreach_cnx', ([], {}), '()\n', (2479, 2481), False, 'import tests\n')] |
import logging
import yaml
import pprint
from settings.HeadConfiguration import HeadConfiguration
from settings.ConfigurationBaseClass import ConfigurationBaseClass
class ConfigurationHandler(ConfigurationBaseClass):
"""
This class handels the configuration file. After loading the content this class
prov... | [
"settings.HeadConfiguration.HeadConfiguration",
"pprint.pformat",
"logging.debug",
"logging.error",
"yaml.safe_load"
] | [((1911, 1978), 'logging.debug', 'logging.debug', (["('All section are found in file: ' + self.__mFilePath)"], {}), "('All section are found in file: ' + self.__mFilePath)\n", (1924, 1978), False, 'import logging\n'), ((633, 659), 'yaml.safe_load', 'yaml.safe_load', (['fileHandle'], {}), '(fileHandle)\n', (647, 659), F... |
# Copyright (c) Facebook, Inc. and its affiliates.
#
# 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 ... | [
"numpy.random.seed",
"torch.eye",
"torch.ByteTensor",
"torch.cat",
"torch.nn.InstanceNorm2d",
"torch.cos",
"numpy.arange",
"torch.nn.Softmax",
"torch.arange",
"torch.device",
"torch.nn.functional.normalize",
"torch.flatten",
"torch.nn.functional.grid_sample",
"logging.warning",
"torch.nn... | [((1022, 1047), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {}), '()\n', (1045, 1047), False, 'import torch\n'), ((1057, 1102), 'torch.device', 'torch.device', (["('cuda:0' if USE_CUDA else 'cpu')"], {}), "('cuda:0' if USE_CUDA else 'cpu')\n", (1069, 1102), False, 'import torch\n'), ((1103, 1121), 'numpy... |
# -*- coding: utf-8 -*-
import multiscale.bulk_img_processing as blk
from pathlib import Path
import unittest
class get_core_file_name_TestSuite(unittest.TestCase):
"""Basic test cases."""
def test_multiple_underscores(self):
testStr = 'This_name_has_multiple_underscores.extension'
self.asse... | [
"unittest.main",
"multiscale.bulk_img_processing.create_new_image_path",
"pathlib.Path",
"multiscale.bulk_img_processing.get_core_file_name",
"multiscale.bulk_img_processing.file_name_parts"
] | [((2633, 2659), 'unittest.main', 'unittest.main', ([], {'verbosity': '(2)'}), '(verbosity=2)\n', (2646, 2659), False, 'import unittest\n'), ((1484, 1515), 'pathlib.Path', 'Path', (['"""C:/Test/Folder/Test.tif"""'], {}), "('C:/Test/Folder/Test.tif')\n", (1488, 1515), False, 'from pathlib import Path\n'), ((1537, 1554), ... |
#!/usr/bin/env python3
import rospy
import os
from sensor_msgs.msg import CompressedImage
import numpy as np
import cv2
def streaming(msg, rate, stream, image_pub):
while not rospy.is_shutdown():
_, frame = stream.read()
msg.header.stamp = rospy.Time.now()
msg.format = 'jpeg'
... | [
"rospy.Time.now",
"rospy.Publisher",
"rospy.Rate",
"cv2.VideoCapture",
"os.environ.get",
"rospy.is_shutdown",
"rospy.init_node",
"sensor_msgs.msg.CompressedImage",
"cv2.imencode"
] | [((526, 547), 'cv2.VideoCapture', 'cv2.VideoCapture', (['src'], {}), '(src)\n', (542, 547), False, 'import cv2\n'), ((560, 586), 'os.environ.get', 'os.environ.get', (['"""HOSTNAME"""'], {}), "('HOSTNAME')\n", (574, 586), False, 'import os\n'), ((643, 715), 'rospy.Publisher', 'rospy.Publisher', (['f"""/nautilus/{hn}/usb... |
# -*- coding: utf-8 -*-
'''
PROJECT_NAME：login
FILE:serializers
USERNAME: 李宏伟
DATE:2020/1/15
TIME:上午10:13
PRODUCT_NAME:PyCharm
'''
import re
from rest_framework import serializers
from .models import User
class CreateUserSerializer(serializers.ModelSerializer):
"""
创建用户序列化器
"""
password2 = serializers.Char... | [
"rest_framework.serializers.CharField",
"re.match",
"rest_framework.serializers.ValidationError"
] | [((304, 356), 'rest_framework.serializers.CharField', 'serializers.CharField', ([], {'label': '"""确认密码"""', 'write_only': '(True)'}), "(label='确认密码', write_only=True)\n", (325, 356), False, 'from rest_framework import serializers\n'), ((366, 418), 'rest_framework.serializers.CharField', 'serializers.CharField', ([], {'... |
#!/usr/bin/env python3
# Copyright (c) Facebook, Inc. and its affiliates. All Rights Reserved
import unittest
import numpy as np
import torch
import mobile_cv.arch.fbnet_v2.basic_blocks as bb
import mobile_cv.arch.fbnet_v2.fbnet_builder as fbnet_builder
import mobile_cv.arch.utils.fuse_utils as fuse_utils
def run_... | [
"mobile_cv.arch.fbnet_v2.fbnet_builder.unify_arch_def",
"mobile_cv.arch.fbnet_v2.fbnet_builder.FBNetBuilder",
"torch.manual_seed",
"mobile_cv.arch.utils.fuse_utils.fuse_model",
"mobile_cv.arch.utils.fuse_utils.fuse_convbnrelu",
"mobile_cv.arch.fbnet_v2.basic_blocks.ConvBNRelu",
"torch.zeros"
] | [((385, 429), 'torch.zeros', 'torch.zeros', (['input_size'], {'requires_grad': '(False)'}), '(input_size, requires_grad=False)\n', (396, 429), False, 'import torch\n'), ((675, 725), 'mobile_cv.arch.fbnet_v2.fbnet_builder.unify_arch_def', 'fbnet_builder.unify_arch_def', (['arch_def', "['blocks']"], {}), "(arch_def, ['bl... |
# Copyright 2018 Iguazio
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, soft... | [
"nuclio.magic.print_handler_code",
"io.StringIO",
"nuclio.magic.build",
"contextlib.redirect_stdout",
"os.path.join"
] | [((752, 784), 'os.path.join', 'path.join', (['here', '"""handler.ipynb"""'], {}), "(here, 'handler.ipynb')\n", (761, 784), False, 'from os import path\n'), ((794, 804), 'io.StringIO', 'StringIO', ([], {}), '()\n', (802, 804), False, 'from io import StringIO\n'), ((950, 982), 'os.path.join', 'path.join', (['here', '"""h... |
from setuptools import find_packages, setup
with open("README.md", "r") as fh:
long_description = fh.read()
setup(
name='rac_es',
version='0.17.4',
description="Helpers for Rockefeller Archive Center's Elasticsearch implementation.",
long_description=long_description,
long_description_content_... | [
"setuptools.find_packages"
] | [((504, 519), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (517, 519), False, 'from setuptools import find_packages, setup\n')] |
# The MIT License (MIT)
# Copyright (c) 2022 by the xcube development team and contributors
#
# 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... | [
"typing.TypeVar"
] | [((1259, 1271), 'typing.TypeVar', 'TypeVar', (['"""T"""'], {}), "('T')\n", (1266, 1271), False, 'from typing import Optional, Tuple, Type, TypeVar, Union\n')] |
# -*- coding: utf-8 -*-
# vi:si:et:sw=4:sts=4:ts=4
from __future__ import unicode_literals
import logging
import platform
from cronman.monitor import Cronitor, Sentry, Slack
from cronman.utils import bool_param, config, ensure_dir, format_exception
logger = logging.getLogger("cronman.command")
class BaseCronObjec... | [
"platform.node",
"logging.getLogger",
"cronman.monitor.Slack",
"cronman.monitor.Sentry",
"cronman.utils.format_exception",
"cronman.monitor.Cronitor",
"cronman.utils.ensure_dir",
"cronman.utils.config"
] | [((262, 298), 'logging.getLogger', 'logging.getLogger', (['"""cronman.command"""'], {}), "('cronman.command')\n", (279, 298), False, 'import logging\n'), ((643, 653), 'cronman.monitor.Cronitor', 'Cronitor', ([], {}), '()\n', (651, 653), False, 'from cronman.monitor import Cronitor, Sentry, Slack\n'), ((676, 684), 'cron... |
# Csnake project configuration
import csnCilab
from csnAll import three
four = csnCilab.CilabModuleProject("Four", "third party")
four.pathsManager.useFilePath = "%s/Four/UseFour.cmake" % four.GetBuildFolder()
four.pathsManager.configFilePath = "%s/Four/FourConfig.cmake" % four.GetBuildFolder()
four.AddProjects([three... | [
"csnCilab.CilabModuleProject"
] | [((80, 130), 'csnCilab.CilabModuleProject', 'csnCilab.CilabModuleProject', (['"""Four"""', '"""third party"""'], {}), "('Four', 'third party')\n", (107, 130), False, 'import csnCilab\n')] |
import numpy as np
import pandas
from sklearn.preprocessing import MinMaxScaler, StandardScaler, Binarizer
#handle the missing values
data = pandas.DataFrame([
[4., 45., 984.],
[np.NAN, np.NAN, 5.],
[94., 23., 55.],
])
#print original data
print(data)
#fill the missing values with... | [
"pandas.DataFrame",
"sklearn.preprocessing.Binarizer",
"sklearn.preprocessing.MinMaxScaler",
"sklearn.preprocessing.StandardScaler"
] | [((145, 231), 'pandas.DataFrame', 'pandas.DataFrame', (['[[4.0, 45.0, 984.0], [np.NAN, np.NAN, 5.0], [94.0, 23.0, 55.0]]'], {}), '([[4.0, 45.0, 984.0], [np.NAN, np.NAN, 5.0], [94.0, 23.0, \n 55.0]])\n', (161, 231), False, 'import pandas\n'), ((466, 543), 'pandas.DataFrame', 'pandas.DataFrame', (['[[58.0, 1.0, 43.0],... |
from snakemake.io import load_configfile
from pathlib import Path
if __name__=='__main__':
import argparse
parser = argparse.ArgumentParser(description='Create an empty output file for failed integration runs')
parser.add_argument('-c', '--config', help='Snakemake config file', required=True)
parser... | [
"pathlib.Path",
"argparse.ArgumentParser",
"snakemake.io.load_configfile"
] | [((127, 226), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Create an empty output file for failed integration runs"""'}), "(description=\n 'Create an empty output file for failed integration runs')\n", (150, 226), False, 'import argparse\n'), ((801, 824), 'snakemake.io.load_configfi... |
from uuid import UUID, uuid4
from datetime import datetime
from typing import Optional
from pydantic import BaseModel, Field
class BaseCollection(BaseModel):
id: Optional[UUID] = Field(alias='_id', default=uuid4())
created_at: Optional[datetime] = datetime.now()
collection: Optional[str]
def __init_... | [
"uuid.uuid4",
"datetime.datetime.now"
] | [((259, 273), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (271, 273), False, 'from datetime import datetime\n'), ((416, 423), 'uuid.uuid4', 'uuid4', ([], {}), '()\n', (421, 423), False, 'from uuid import UUID, uuid4\n'), ((450, 464), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (462, 464), ... |
"""
Your chance to explore Loops and Turtles!
Authors: <NAME>, <NAME>, <NAME>, <NAME>,
<NAME>, their colleagues, and <NAME>.
"""
########################################################################
# DONE: 1.
# On Line 5 above, replace PUT_YOUR_NAME_HERE with your own name.
###########################... | [
"rosegraphics.TurtleWindow",
"rosegraphics.SimpleTurtle",
"rosegraphics.Pen"
] | [((1255, 1272), 'rosegraphics.TurtleWindow', 'rg.TurtleWindow', ([], {}), '()\n', (1270, 1272), True, 'import rosegraphics as rg\n'), ((1302, 1327), 'rosegraphics.SimpleTurtle', 'rg.SimpleTurtle', (['"""square"""'], {}), "('square')\n", (1317, 1327), True, 'import rosegraphics as rg\n'), ((1342, 1359), 'rosegraphics.Pe... |
# -*- coding: utf-8 -*-
from django.db import models
from django.utils.translation import ugettext_lazy as _
from jsonfield import JSONField
from behaviors.models import Timestampable, Versionable
from parlalize.settings import API_OUT_DATE_FORMAT
from datetime import datetime
class PopoloDateTimeField(models.DateTi... | [
"datetime.datetime.strftime",
"django.db.models.TextField",
"django.db.models.URLField",
"django.db.models.ManyToManyField",
"django.db.models.NullBooleanField",
"django.db.models.ForeignKey",
"django.db.models.CharField",
"jsonfield.JSONField",
"django.db.models.FloatField",
"django.db.models.Boo... | [((1746, 1884), 'django.db.models.ForeignKey', 'models.ForeignKey', (['"""parlaskupine.Organization"""'], {'blank': '(True)', 'null': '(True)', 'related_name': '"""session"""', 'help_text': '"""The organization in session"""'}), "('parlaskupine.Organization', blank=True, null=True,\n related_name='session', help_tex... |
## ____ _ ____
## / ___|__ _ ___| |_ _ _ ___ / ___|__ _ _ __ _ _ ___ _ __
## | | / _` |/ __| __| | | / __| | | / _` | '_ \| | | |/ _ \| '_ \
## | |__| (_| | (__| |_| |_| \__ \ | |__| (_| | | | | |_| | (_) | | | |
## \____\__,_|\___|\__|\__,_|___/ \____\__,_|_| |_|\__, |\___/|... | [
"procgame.dmd.GroupedLayer",
"ep.EP_Transition",
"procgame.dmd.AnimatedLayer",
"ep.EP_AnimatedLayer",
"random.choice",
"ep.EP_TextLayer",
"ep.format_score",
"procgame.dmd.FrameLayer",
"procgame.dmd.ScriptedLayer"
] | [((1560, 1632), 'procgame.dmd.FrameLayer', 'dmd.FrameLayer', ([], {'opaque': '(False)', 'frame': 'self.game.assets.dmd_blank.frames[0]'}), '(opaque=False, frame=self.game.assets.dmd_blank.frames[0])\n', (1574, 1632), False, 'from procgame import dmd, game\n'), ((1794, 1828), 'procgame.dmd.ScriptedLayer', 'dmd.ScriptedL... |
import subprocess
import numpy as np
import os
import pathlib
import multiprocessing as mp
import sys
def test_mp_serial():
#gets current path
path = pathlib.Path(__file__).parents[0].absolute()
sys.path.insert(1, str(path.parents[0]))
if not (path / "MP_Serial").exists():
subprocess.check_out... | [
"subprocess.check_output",
"os.path.isfile",
"pathlib.Path",
"os.chdir",
"os.scandir"
] | [((300, 358), 'subprocess.check_output', 'subprocess.check_output', (["['vspace', 'vspace.in']"], {'cwd': 'path'}), "(['vspace', 'vspace.in'], cwd=path)\n", (323, 358), False, 'import subprocess\n'), ((434, 508), 'subprocess.check_output', 'subprocess.check_output', (["['multiplanet', 'vspace.in', '-c', '1']"], {'cwd':... |
import platform
import os
import sys
def install(package):
print("""Colorama er ikke installert. Du trenger Colorama for å spille Pokus med farger.
For å spille må du installere Colorama og starte spillet på nytt.""")
if input("Vil du installere colorama nå?\n> ").lower() in {"ja", "j"}:
osys = platfor... | [
"platform.system",
"os.system",
"sys.exit"
] | [((564, 608), 'sys.exit', 'sys.exit', (['"""Du må starte spillet på nytt nå."""'], {}), "('Du må starte spillet på nytt nå.')\n", (572, 608), False, 'import sys\n'), ((313, 330), 'platform.system', 'platform.system', ([], {}), '()\n', (328, 330), False, 'import platform\n'), ((391, 432), 'os.system', 'os.system', (['""... |
import tensorflow as tf
def attach_GNAP(x : tf.Tensor):
out = x
norm = tf.norm(out, ord=2, axis=3, keepdims=True)
norm = tf.math.maximum(norm, 1e-12)
mean = tf.math.reduce_mean(norm)
out = tf.keras.layers.BatchNormalization(scale=False)(out)
out = tf.math.divide(out, norm)
out = tf.multipl... | [
"tensorflow.math.reduce_mean",
"tensorflow.keras.layers.BatchNormalization",
"tensorflow.multiply",
"tensorflow.math.maximum",
"tensorflow.keras.layers.GlobalAveragePooling2D",
"tensorflow.norm",
"tensorflow.math.l2_normalize",
"tensorflow.math.divide",
"tensorflow.keras.regularizers.l2"
] | [((81, 123), 'tensorflow.norm', 'tf.norm', (['out'], {'ord': '(2)', 'axis': '(3)', 'keepdims': '(True)'}), '(out, ord=2, axis=3, keepdims=True)\n', (88, 123), True, 'import tensorflow as tf\n'), ((135, 163), 'tensorflow.math.maximum', 'tf.math.maximum', (['norm', '(1e-12)'], {}), '(norm, 1e-12)\n', (150, 163), True, 'i... |
from riotwrapper.lor import LoRWrapper
from riotwrapper.const.lor_const import REGION_URL
import pytest
import re
@pytest.fixture
def environment():
import os
api_key = os.environ.get('API_KEY')
account_id = os.environ.get('ACCOUNT_ID')
env = {
'api_key': api_key,
'account_id': accou... | [
"riotwrapper.const.lor_const.REGION_URL.keys",
"os.environ.get",
"riotwrapper.lor.LoRWrapper",
"pytest.raises",
"re.compile"
] | [((180, 205), 'os.environ.get', 'os.environ.get', (['"""API_KEY"""'], {}), "('API_KEY')\n", (194, 205), False, 'import os\n'), ((223, 251), 'os.environ.get', 'os.environ.get', (['"""ACCOUNT_ID"""'], {}), "('ACCOUNT_ID')\n", (237, 251), False, 'import os\n'), ((406, 459), 'riotwrapper.lor.LoRWrapper', 'LoRWrapper', (["e... |
"""
Constants and defaults values
"""
import datetime
import django
SECONDARY = 10
PRIMARY = 20
INFO = 30
SUCCESS = 40
WARNING = 50
ERROR = 60
DEFAULT_TAGS = {
SECONDARY: 'secondary',
PRIMARY: 'primary',
INFO: 'info',
SUCCESS: 'success',
WARNING: 'warning',
ERROR: 'danger',
}
DEFAULT_LEVELS ... | [
"datetime.datetime"
] | [((854, 883), 'datetime.datetime', 'datetime.datetime', (['(1900)', '(1)', '(1)'], {}), '(1900, 1, 1)\n', (871, 883), False, 'import datetime\n')] |
#!/usr/bin/python3
# 2019-05-29
import re
import requests
from chatterbot import ChatBot
from chatterbot.trainers import ChatterBotCorpusTrainer
class Bot:
def __init__(self, name, bot_id, group_id, api_token):
self.name = name
self.bot_id = bot_id
self.group_id = group_id
self.api... | [
"requests.session",
"chatterbot.ChatBot",
"chatterbot.trainers.ChatterBotCorpusTrainer",
"re.match",
"re.sub"
] | [((423, 441), 'requests.session', 'requests.session', ([], {}), '()\n', (439, 441), False, 'import requests\n'), ((545, 563), 'chatterbot.ChatBot', 'ChatBot', (['self.name'], {}), '(self.name)\n', (552, 563), False, 'from chatterbot import ChatBot\n'), ((582, 619), 'chatterbot.trainers.ChatterBotCorpusTrainer', 'Chatte... |
# Copyright (c) 2012 <NAME> http://garnaat.org/
# Copyright (c) 2012 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 restri... | [
"json.loads",
"json.dumps",
"boto.exception.BotoServerError",
"boto.log.error",
"requests.post"
] | [((2934, 3035), 'requests.post', 'requests.post', (['url'], {'data': 'sdf', 'config': 'request_config', 'headers': "{'Content-Type': 'application/json'}"}), "(url, data=sdf, config=request_config, headers={'Content-Type':\n 'application/json'})\n", (2947, 3035), False, 'import requests\n'), ((2097, 2129), 'json.dump... |
from django.contrib import admin
from django.urls import path, re_path, include, reverse_lazy
from rest_framework.routers import DefaultRouter
from users.views import LoginViewCustom
from accounts.views import CardSerializerViewSet
router = DefaultRouter()
router.register(r'card', CardSerializerViewSet)
urlpattern... | [
"django.urls.path",
"users.views.LoginViewCustom.as_view",
"rest_framework.routers.DefaultRouter",
"django.urls.include"
] | [((245, 260), 'rest_framework.routers.DefaultRouter', 'DefaultRouter', ([], {}), '()\n', (258, 260), False, 'from rest_framework.routers import DefaultRouter\n'), ((366, 397), 'django.urls.path', 'path', (['"""admin/"""', 'admin.site.urls'], {}), "('admin/', admin.site.urls)\n", (370, 397), False, 'from django.urls imp... |
#!python3
# -*- coding:utf-8 -*-
# 『Pythonで始めるOpenCV4プログラミング』
# 北山尚洋
import cv2
import sys, traceback
import numpy as np
def add(imgName1, imgName2):
try:
img1 = cv2.imread(imgName1)
img2 = cv2.imread(imgName2)
if img1 is None or img2 is None:
print("no file reading..... | [
"cv2.waitKey",
"cv2.destroyAllWindows",
"numpy.zeros",
"cv2.imread",
"sys.exc_info",
"sys.exit",
"cv2.imshow",
"cv2.add",
"cv2.resize"
] | [((177, 197), 'cv2.imread', 'cv2.imread', (['imgName1'], {}), '(imgName1)\n', (187, 197), False, 'import cv2\n'), ((213, 233), 'cv2.imread', 'cv2.imread', (['imgName2'], {}), '(imgName2)\n', (223, 233), False, 'import cv2\n'), ((466, 494), 'cv2.resize', 'cv2.resize', (['img1', '(500, 500)'], {}), '(img1, (500, 500))\n'... |
"""
pgxnclient -- tar file utilities
"""
# Copyright (C) 2011-2020 <NAME>
# This file is part of the PGXN client
import os
import tarfile
from pgxnclient.i18n import _
from pgxnclient.errors import PgxnClientException
from pgxnclient.archive import Archive
import logging
logger = logging.getLogger('pgxnclient.tar... | [
"pgxnclient.i18n._",
"os.path.abspath",
"tarfile.is_tarfile",
"tarfile.open",
"os.path.join",
"logging.getLogger"
] | [((287, 322), 'logging.getLogger', 'logging.getLogger', (['"""pgxnclient.tar"""'], {}), "('pgxnclient.tar')\n", (304, 322), False, 'import logging\n'), ((441, 474), 'tarfile.is_tarfile', 'tarfile.is_tarfile', (['self.filename'], {}), '(self.filename)\n', (459, 474), False, 'import tarfile\n'), ((1255, 1279), 'os.path.a... |
import sys
from src.krpsim.utils import split_need_result_delay, build_process_dic
class Parser:
"""
Parsing Class, heart of the parsing is here.
-> stocks is a list of Stock class instances
-> content is a list of Process class instances
-> optimize is a list of Optimize class instances
-> de... | [
"src.krpsim.utils.split_need_result_delay",
"src.krpsim.utils.build_process_dic",
"sys.exit"
] | [((2013, 2050), 'sys.exit', 'sys.exit', (['"""Missing optimize content."""'], {}), "('Missing optimize content.')\n", (2021, 2050), False, 'import sys\n'), ((2093, 2128), 'sys.exit', 'sys.exit', (['"""Missing initial stocks."""'], {}), "('Missing initial stocks.')\n", (2101, 2128), False, 'import sys\n'), ((3834, 3868)... |
import datetime
import pickle
from enum import Enum
from decorator import decorator
def time_this(fn):
"""
This decorator time the input function :func:`fn`
"""
def timed_fn(fn, *args, **kwargs):
time1 = datetime.datetime.now()
result = fn(*args, **kwargs)
calc_time = datetime... | [
"decorator.decorator",
"pickle.dump",
"pickle.load",
"datetime.datetime.now"
] | [((449, 472), 'decorator.decorator', 'decorator', (['timed_fn', 'fn'], {}), '(timed_fn, fn)\n', (458, 472), False, 'from decorator import decorator\n'), ((231, 254), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (252, 254), False, 'import datetime\n'), ((1803, 1835), 'pickle.dump', 'pickle.dump', ... |
from .abstract_machine import AutoNormalizedAutoregressiveMachine
from ..deepar.layers import ToFloat32, DownShiftLayer, ExpandInputDim, WeightNormalization
from ..layers import VectorToComplexNumber
from tensorflow.keras.layers import Activation, Conv1D, ZeroPadding1D, Activation, Add
def causal_conv_1d(x, filters,... | [
"tensorflow.keras.layers.Conv1D",
"tensorflow.keras.layers.Add",
"tensorflow.keras.layers.ZeroPadding1D",
"tensorflow.keras.layers.Activation"
] | [((574, 667), 'tensorflow.keras.layers.Conv1D', 'Conv1D', ([], {'filters': 'filters', 'kernel_size': 'kernel_size', 'strides': '(1)', 'dilation_rate': 'dilation_rate'}), '(filters=filters, kernel_size=kernel_size, strides=1, dilation_rate=\n dilation_rate)\n', (580, 667), False, 'from tensorflow.keras.layers import ... |
"""
Command to:
- load all fixtures named 'demo-*.*'
- create copy the demo media files
This should only be called in a clean database, such as after
`resetdb` is run. This should generally only be used in
development environments.
"""
import os
import shutil
from django.conf import settings
from django.core.managem... | [
"os.walk",
"os.path.exists",
"django.core.management.call_command",
"physionet.utility.get_project_apps",
"os.symlink",
"os.path.join",
"os.listdir"
] | [((3198, 3244), 'os.path.join', 'os.path.join', (['settings.DEMO_FILE_ROOT', '"""media"""'], {}), "(settings.DEMO_FILE_ROOT, 'media')\n", (3210, 3244), False, 'import os\n'), ((3263, 3290), 'os.listdir', 'os.listdir', (['demo_media_root'], {}), '(demo_media_root)\n', (3273, 3290), False, 'import os\n'), ((3729, 3784), ... |
#!/usr/bin/env python3
import argparse
import re
def main(args):
with open(args.source) as file:
content = file.read()
for pattern, filename in re.findall(r'(\{!(.*)!\})', content):
with open(filename) as file:
match_content = file.read()
dest_content = re.sub(pattern, m... | [
"re.findall",
"re.sub",
"argparse.ArgumentParser"
] | [((164, 201), 're.findall', 're.findall', (['"""(\\\\{!(.*)!\\\\})"""', 'content'], {}), "('(\\\\{!(.*)!\\\\})', content)\n", (174, 201), False, 'import re\n'), ((545, 633), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Replace placeholders with it\'s file contents"""'}), '(description=... |
from django.urls import path
from . import views
urlpatterns = [
path('member_view', views.api_member_view, name='test_api_member_view'),
path('manager_view', views.api_manager_view, name='test_api_manager_view'),
path('owner_view', views.api_owner_view, name='test_api_owner_view'),
path('base_org_vie... | [
"django.urls.path"
] | [((71, 142), 'django.urls.path', 'path', (['"""member_view"""', 'views.api_member_view'], {'name': '"""test_api_member_view"""'}), "('member_view', views.api_member_view, name='test_api_member_view')\n", (75, 142), False, 'from django.urls import path\n'), ((148, 222), 'django.urls.path', 'path', (['"""manager_view"""'... |
import time
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import transforms, datasets, models
from collections import OrderedDict
from PIL import Image
import matplotlib.pyplot as plt
import json
import argparse
def load_checkpoint(checkpoint_path, model):
chec... | [
"torch.topk",
"argparse.ArgumentParser",
"torchvision.models.vgg11",
"torch.nn.ReLU",
"torch.nn.LogSoftmax",
"torch.load",
"torchvision.models.densenet121",
"PIL.Image.open",
"torch.exp",
"numpy.array",
"torch.nn.Linear",
"torch.zeros",
"torch.no_grad",
"torch.from_numpy"
] | [((329, 356), 'torch.load', 'torch.load', (['checkpoint_path'], {}), '(checkpoint_path)\n', (339, 356), False, 'import torch\n'), ((1656, 1673), 'PIL.Image.open', 'Image.open', (['image'], {}), '(image)\n', (1666, 1673), False, 'from PIL import Image\n'), ((2036, 2067), 'numpy.array', 'np.array', (['[0.485, 0.456, 0.40... |
# Ad Soyad: <NAME> No: 180401041
#import numpy.matlib #Matrislerde kullanılabilir
from matrix_operations import matrix_transpose # gerekli matris işlemleri için fonksiyonların dahil edilmesi.
# D=A^T --> D= np.transpose(A) --> transpose kullanımı
from matrix... | [
"matrix_operations.matrix_transpose",
"os.getcwd",
"numpy.zeros",
"copy.copy",
"matrix_operations.matrix_inverse",
"matrix_operations.matrix_multiplication"
] | [((8209, 8220), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (8218, 8220), False, 'import os\n'), ((4313, 4357), 'numpy.zeros', 'np.zeros', ([], {'shape': '(derece + 1, 1)', 'dtype': 'float'}), '(shape=(derece + 1, 1), dtype=float)\n', (4321, 4357), True, 'import numpy as np\n'), ((4392, 4465), 'numpy.zeros', 'np.zeros'... |
"""yieldfx plot"""
import calendar
from collections import OrderedDict
import datetime
import pandas as pd
from pyiem.meteorology import gdd
from pyiem.plot.use_agg import plt
from pyiem.datatypes import temperature, distance
from pyiem.util import get_autoplot_context
STATIONS = OrderedDict([
('ames', 'Centr... | [
"pandas.DataFrame",
"pyiem.datatypes.temperature",
"pyiem.datatypes.distance",
"datetime.date",
"datetime.date.today",
"datetime.datetime.strptime",
"collections.OrderedDict",
"pyiem.plot.use_agg.plt.subplots",
"pandas.to_numeric"
] | [((283, 643), 'collections.OrderedDict', 'OrderedDict', (["[('ames', 'Central (Ames)'), ('cobs', 'Central (COBS)'), ('crawfordsville',\n 'Southeast (Crawfordsville)'), ('kanawha', 'Northern (Kanawha)'), (\n 'lewis', 'Southwest (Lewis)'), ('mcnay', 'Southern (Chariton/McNay)'),\n ('muscatine', 'Southeast (Musca... |
from quart import jsonify
from providers.BlueprintProvider import BlueprintProvider
class Friends(BlueprintProvider):
def __craftSummary(self, data):
return jsonify(
{
"following": data.target_following_count,
"followers": data.target_follower_count,
... | [
"quart.jsonify"
] | [((172, 269), 'quart.jsonify', 'jsonify', (["{'following': data.target_following_count, 'followers': data.\n target_follower_count}"], {}), "({'following': data.target_following_count, 'followers': data.\n target_follower_count})\n", (179, 269), False, 'from quart import jsonify\n')] |
from task import Task
from tasks import Tasks
from status import Status
import redis
import datetime
import json
from json_extension import check_update_list
from converter import datetime_converter
class TaskManager:
_redis = None
_task_management_key = None
def __redis():
server = "localhost"
... | [
"redis.Redis",
"json.loads",
"json.dumps",
"tasks.Tasks",
"datetime.datetime.now",
"task.Task"
] | [((382, 411), 'redis.Redis', 'redis.Redis', (['server', 'port', 'db'], {}), '(server, port, db)\n', (393, 411), False, 'import redis\n'), ((2690, 2728), 'tasks.Tasks', 'Tasks', (["tasks_obj_as_dict['conditions']"], {}), "(tasks_obj_as_dict['conditions'])\n", (2695, 2728), False, 'from tasks import Tasks\n'), ((586, 602... |
from utils import *
import pandas as pd
import sys
import csv
GP = []
MPG = []
WS = []
WSP48 = []
BPM = []
VORP = []
PLUSMINUS = []
NBA_STATS = [GP, MPG, WS, WSP48, BPM, VORP, PLUSMINUS]
def main():
all = get_csv_file("add NBA stats? ")
all = populate_NBA_all_statistics(all)
addNBAStatsToMasterList(pd.rea... | [
"pandas.read_csv"
] | [((314, 344), 'pandas.read_csv', 'pd.read_csv', (['"""temp_master.csv"""'], {}), "('temp_master.csv')\n", (325, 344), True, 'import pandas as pd\n')] |
from train_utils import train_model
from sample_models import custom_rnn_model
from keras.layers import SimpleRNN, GRU, LSTM
import argparse
import sys
import os
from os.path import join
if __name__ == '__main__':
from keras.backend.tensorflow_backend import set_session
import tensorflow as tf
config = tf... | [
"train_utils.train_model",
"argparse.ArgumentParser",
"tensorflow.Session",
"tensorflow.ConfigProto",
"sample_models.custom_rnn_model"
] | [((318, 334), 'tensorflow.ConfigProto', 'tf.ConfigProto', ([], {}), '()\n', (332, 334), True, 'import tensorflow as tf\n'), ((644, 693), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""ASR Driver"""'}), "(description='ASR Driver')\n", (667, 693), False, 'import argparse\n'), ((3021, 3518)... |
'''Create entry point to init everything and start Dolphin.'''
import argparse
# import sys
from pathlib import Path
import melee
from .interact import LiveInputsThread
def start_game(ports, cmds={}, log=True):
'''Main method to fully start game.
Command-line first needs dolphin path and iso path, then game s... | [
"argparse.ArgumentParser",
"pathlib.Path",
"melee.Controller",
"melee.Console",
"melee.Logger"
] | [((1063, 1097), 'melee.Console', 'melee.Console', ([], {'path': 'dolphin_folder'}), '(path=dolphin_folder)\n', (1076, 1097), False, 'import melee\n'), ((2188, 2213), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (2211, 2213), False, 'import argparse\n'), ((1456, 1470), 'melee.Logger', 'melee.L... |
# -*- coding: utf-8 -*-
"""
Class for storing supply curves and calculating marginal costs
Created on Thu Feb 7 15:34:33 2019
@author: elisn
"""
import pickle
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
class SupplyCurve():
""" Has panda dataframe with list of bids
One or ... | [
"pandas.DataFrame",
"matplotlib.pyplot.title",
"matplotlib.pyplot.show",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.legend",
"pickle.load",
"numpy.array",
"numpy.linspace",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.grid"
] | [((9079, 9128), 'pandas.DataFrame', 'pd.DataFrame', ([], {'columns': "['cap', 'mc_min', 'mc_max']"}), "(columns=['cap', 'mc_min', 'mc_max'])\n", (9091, 9128), True, 'import pandas as pd\n'), ((9860, 9874), 'matplotlib.pyplot.plot', 'plt.plot', (['x', 'y'], {}), '(x, y)\n', (9868, 9874), True, 'import matplotlib.pyplot ... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import os
import codecs
from setuptools import setup
setup(
name='pytest-packagetree',
version='0.0.1',
author='<NAME>',
author_email='<EMAIL>',
maintainer='<NAME>',
maintainer_email='<EMAIL>',
license='MIT',
url='https://github.com/jsfehl... | [
"setuptools.setup"
] | [((102, 934), 'setuptools.setup', 'setup', ([], {'name': '"""pytest-packagetree"""', 'version': '"""0.0.1"""', 'author': '"""<NAME>"""', 'author_email': '"""<EMAIL>"""', 'maintainer': '"""<NAME>"""', 'maintainer_email': '"""<EMAIL>"""', 'license': '"""MIT"""', 'url': '"""https://github.com/jsfehler/pytest-packagetree""... |
# -*- coding: utf-8 -*-
from sklearn.metrics import classification_report
from keras.callbacks import ModelCheckpoint
from keras.utils import plot_model
import matplotlib.pyplot as plt
import numpy as np
import os
from tnmlearn.callbacks import TrainingMonitor
# %%
class BaseLearningModel:
def __init__(self):
... | [
"matplotlib.pyplot.title",
"matplotlib.pyplot.show",
"os.getpid",
"keras.callbacks.ModelCheckpoint",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.figure",
"keras.utils.plot_model",
"matplotlib.pyplot.style.use",
"numpy.arange",
"tnmlearn.callbacks.TrainingMonitor",
"matplotlib.pyplot.ylabel",
... | [((829, 902), 'os.path.sep.join', 'os.path.sep.join', (["[weightpath, 'weights-{epoch:03d}-{val_loss:.4f}.hdf5']"], {}), "([weightpath, 'weights-{epoch:03d}-{val_loss:.4f}.hdf5'])\n", (845, 902), False, 'import os\n'), ((927, 1017), 'keras.callbacks.ModelCheckpoint', 'ModelCheckpoint', (['fname'], {'monitor': '"""val_l... |
# ABC073b
import sys
input = sys.stdin.readline
sys.setrecursionlimit(10**6)
n = int(input())
l = [list(map(int, input().split())) for _ in range(n)]
ans = 0
for i in l:
ans += i[1]-i[0]+1
print(ans)
| [
"sys.setrecursionlimit"
] | [((48, 78), 'sys.setrecursionlimit', 'sys.setrecursionlimit', (['(10 ** 6)'], {}), '(10 ** 6)\n', (69, 78), False, 'import sys\n')] |
# Generated by Django 1.11.12 on 2018-04-25 12:00
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('email_marketing', '0009_remove_emailmarketingconfiguration_sailthru_activation_template'),
]
operations = [
migrations.AddField(
... | [
"django.db.models.CharField"
] | [((442, 560), 'django.db.models.CharField', 'models.CharField', ([], {'blank': '(True)', 'help_text': '"""Sailthru send template to use on failed ID verification."""', 'max_length': '(20)'}), "(blank=True, help_text=\n 'Sailthru send template to use on failed ID verification.', max_length=20)\n", (458, 560), False, ... |
import numpy as np
import tensorflow as tf
import csv
def classify_state(X, n_state):
up = 80
if (0 <= X <= 2.5):
return n_state - 1, 2.5
for i in range(n_state - 1):
if (up - (i + 1) * 2.5 < X <= up - i * 2.5):
return i, up - i * 2.5
def GA(max_prob_index, n_actions):
valu... | [
"tensorflow.contrib.layers.xavier_initializer",
"tensorflow.nn.softmax",
"csv.writer",
"tensorflow.train.Saver",
"numpy.argmax",
"tensorflow.nn.dynamic_rnn",
"tensorflow.reset_default_graph",
"tensorflow.constant_initializer",
"numpy.zeros",
"tensorflow.Session",
"tensorflow.placeholder",
"ten... | [((325, 344), 'numpy.zeros', 'np.zeros', (['n_actions'], {}), '(n_actions)\n', (333, 344), True, 'import numpy as np\n'), ((531, 550), 'numpy.zeros', 'np.zeros', (['n_actions'], {}), '(n_actions)\n', (539, 550), True, 'import numpy as np\n'), ((655, 674), 'numpy.zeros', 'np.zeros', (['n_actions'], {}), '(n_actions)\n',... |
# (c) 2005 <NAME>
# This module is part of the Python Paste Project and is released under
# the MIT License: http://www.opensource.org/licenses/mit-license.php
# This code was written with funding by http://prometheusresearch.com
"""
Authentication via Multiple Methods
In some environments, the choice of authenticatio... | [
"doctest.testmod"
] | [((2987, 3032), 'doctest.testmod', 'doctest.testmod', ([], {'optionflags': 'doctest.ELLIPSIS'}), '(optionflags=doctest.ELLIPSIS)\n', (3002, 3032), False, 'import doctest\n')] |
#!/usr/bin/env python
# -*- encoding: utf-8 -*-
"""
Topic: 临时文件和目录
Desc :
"""
from tempfile import TemporaryFile
from tempfile import TemporaryDirectory
from tempfile import NamedTemporaryFile
import tempfile
def temp_file():
with TemporaryFile('w+t') as f:
# Read/write to the file
f.write('Hello... | [
"tempfile.NamedTemporaryFile",
"tempfile.TemporaryDirectory",
"tempfile.mkstemp",
"tempfile.gettempdir",
"tempfile.TemporaryFile",
"tempfile.mkdtemp"
] | [((238, 258), 'tempfile.TemporaryFile', 'TemporaryFile', (['"""w+t"""'], {}), "('w+t')\n", (251, 258), False, 'from tempfile import TemporaryFile\n'), ((484, 509), 'tempfile.NamedTemporaryFile', 'NamedTemporaryFile', (['"""w+t"""'], {}), "('w+t')\n", (502, 509), False, 'from tempfile import NamedTemporaryFile\n'), ((56... |
#===============================================================================
# Command-line interface
#===============================================================================
import argparse
from .Titles import Titles
class Parser():
"""
Methods for parsing CLI arguments.... | [
"argparse.ArgumentParser"
] | [((1898, 2050), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': 'self._description', 'epilog': 'self._epilog', 'formatter_class': 'argparse.RawDescriptionHelpFormatter', 'usage': 'self._usage'}), '(description=self._description, epilog=self._epilog,\n formatter_class=argparse.RawDescriptio... |
"""
Uses class Config to define all type conversion functions for main config.yaml file
"""
from utils.config import Config
import discord
config = Config("./config.yaml")
status_converter_dict = {"online": discord.Status.online,
"offline": discord.Status.offline,
"id... | [
"utils.config.Config"
] | [((149, 172), 'utils.config.Config', 'Config', (['"""./config.yaml"""'], {}), "('./config.yaml')\n", (155, 172), False, 'from utils.config import Config\n')] |
import os
import pdb
import numpy as np
from fastestimator.summary.logs import parse_log_file
from scipy.stats import ttest_ind
from tabulate import tabulate
def get_best_step(objective, eval_steps, result, mode, train_history):
obj_step = 0
for idx, value in enumerate(result):
if (mode == "max" and ... | [
"fastestimator.summary.logs.parse_log_file",
"numpy.median",
"numpy.std",
"scipy.stats.ttest_ind",
"numpy.mean",
"tabulate.tabulate",
"os.path.splitext",
"os.path.join",
"os.listdir"
] | [((3104, 3219), 'tabulate.tabulate', 'tabulate', (['table'], {'headers': "['scheduler', 'metric mean', 'metric std', 'step mean', 'step std']", 'tablefmt': '"""github"""'}), "(table, headers=['scheduler', 'metric mean', 'metric std',\n 'step mean', 'step std'], tablefmt='github')\n", (3112, 3219), False, 'from tabul... |
import FWCore.ParameterSet.Config as cms
# First register all the hit matching algorithms, then specify preferred ones at end.
# The stub windows used has been optimized for for PU200 events
# We use by default the tight tuning
#
# Definition is presented here:
#
# https://indico.cern.ch/event/681577/#4-update-of-the... | [
"FWCore.ParameterSet.Config.ESPrefer",
"FWCore.ParameterSet.Config.bool",
"FWCore.ParameterSet.Config.vdouble"
] | [((3478, 3537), 'FWCore.ParameterSet.Config.ESPrefer', 'cms.ESPrefer', (['"""TTStubAlgorithm_official_Phase2TrackerDigi_"""'], {}), "('TTStubAlgorithm_official_Phase2TrackerDigi_')\n", (3490, 3537), True, 'import FWCore.ParameterSet.Config as cms\n'), ((601, 615), 'FWCore.ParameterSet.Config.bool', 'cms.bool', (['(True... |
from django.db import models
from wagtail.core.models import Page
from wagtail.core.fields import StreamField
from wagtail.core import blocks
from wagtail.admin.edit_handlers import FieldPanel, StreamFieldPanel
from wagtail.images.blocks import ImageChooserBlock
class HomePage(Page):
body = StreamField([
... | [
"wagtail.images.blocks.ImageChooserBlock",
"wagtail.core.blocks.RichTextBlock",
"wagtail.core.blocks.RawHTMLBlock",
"wagtail.admin.edit_handlers.StreamFieldPanel",
"wagtail.core.blocks.CharBlock"
] | [((426, 450), 'wagtail.admin.edit_handlers.StreamFieldPanel', 'StreamFieldPanel', (['"""body"""'], {}), "('body')\n", (442, 450), False, 'from wagtail.admin.edit_handlers import FieldPanel, StreamFieldPanel\n'), ((860, 884), 'wagtail.admin.edit_handlers.StreamFieldPanel', 'StreamFieldPanel', (['"""body"""'], {}), "('bo... |
import json
import os
import random
import iso8601
import shutil
numberOfFiles = 1000
creatorAddress = "BjLKxBKRUjFX3WyfyTcTtotC5TfRaPJgVjEeMn1MuzPd"
# Build Blockchain JSON
for x in range(numberOfFiles):
nftNumber = x + 1
niftyRecordNFTData = {
"name" : "NiftyRecord #" + str(nftNumber),
"sym... | [
"iso8601.parse_date",
"json.dump",
"os.path.dirname",
"random.randint"
] | [((1223, 1255), 'json.dump', 'json.dump', (['niftyRecordNFTData', 'f'], {}), '(niftyRecordNFTData, f)\n', (1232, 1255), False, 'import json\n'), ((2966, 2988), 'random.randint', 'random.randint', (['(1)', '(100)'], {}), '(1, 100)\n', (2980, 2988), False, 'import random\n'), ((5509, 5534), 'os.path.dirname', 'os.path.di... |
import numpy as np
def filter_ids(array, clinical_ids):
# list of array indices that need to be deleted
del_indices = []
i = 0
for img in array:
id = img[-1]
if id not in clinical_ids:
del_indices.append(i)
i = i + 1
array = np.delete(array, del_indices, axis... | [
"numpy.delete"
] | [((286, 323), 'numpy.delete', 'np.delete', (['array', 'del_indices'], {'axis': '(0)'}), '(array, del_indices, axis=0)\n', (295, 323), True, 'import numpy as np\n')] |
import os
from typing import Dict, List, Tuple
from urllib.parse import urlparse, urlunparse
from astro.constants import FileLocation
from astro.files.locations.base import BaseFileLocation
from astro.utils.dependencies import s3
class S3Location(BaseFileLocation):
"""Handler S3 object store operations"""
l... | [
"astro.utils.dependencies.s3.S3Hook",
"urllib.parse.urlparse",
"urllib.parse.urlunparse"
] | [((1013, 1032), 'urllib.parse.urlparse', 'urlparse', (['self.path'], {}), '(self.path)\n', (1021, 1032), False, 'from urllib.parse import urlparse, urlunparse\n'), ((748, 783), 'astro.utils.dependencies.s3.S3Hook', 's3.S3Hook', ([], {'aws_conn_id': 'self.conn_id'}), '(aws_conn_id=self.conn_id)\n', (757, 783), False, 'f... |
import uuid
from django.db import models
from django.forms import model_to_dict
# Create your models here.
class DemurageSize(models.Model):
SIZES = (('Dry 20 ft', 'Dry 20 ft'),
('Reefer 20 ft', 'Reefer 20 ft'),
('Special 20 ft', 'Special 20 ft'),
('Dry 40 ft', 'Dry 40 ft'),... | [
"django.db.models.CharField",
"django.db.models.DateTimeField",
"django.db.models.ForeignKey",
"django.db.models.FloatField",
"django.db.models.BooleanField",
"django.db.models.IntegerField",
"django.db.models.UUIDField",
"django.forms.model_to_dict"
] | [((521, 609), 'django.db.models.UUIDField', 'models.UUIDField', ([], {'primary_key': '(True)', 'unique': '(True)', 'editable': '(False)', 'default': 'uuid.uuid4'}), '(primary_key=True, unique=True, editable=False, default=\n uuid.uuid4)\n', (537, 609), False, 'from django.db import models\n'), ((616, 676), 'django.d... |
import cdutil
import cdat_info
import cdms2
import cdms2,cdutil,sys,MV2,numpy,os,cdat_info
import unittest
import numpy
import tempfile
class CDUTIL(unittest.TestCase):
def testRegions(self):
regionNA = cdutil.region.domain(latitude=(-50.,50.,'ccb'))
f=cdms2.open(cdat_info.get_sampledata_path()+'... | [
"unittest.main",
"cdutil.region.domain",
"numpy.array",
"cdat_info.get_sampledata_path"
] | [((809, 824), 'unittest.main', 'unittest.main', ([], {}), '()\n', (822, 824), False, 'import unittest\n'), ((218, 269), 'cdutil.region.domain', 'cdutil.region.domain', ([], {'latitude': "(-50.0, 50.0, 'ccb')"}), "(latitude=(-50.0, 50.0, 'ccb'))\n", (238, 269), False, 'import cdms2, cdutil, sys, MV2, numpy, os, cdat_inf... |
from assemblyline import odm
from assemblyline.common import forge
Classification = forge.get_classification()
@odm.model(index=True, store=False)
class SubmissionTree(odm.Model):
classification = odm.Classification(default=Classification.UNRESTRICTED) # Classification of the cache
filtered = odm.Boolean(def... | [
"assemblyline.odm.Date",
"assemblyline.odm.Text",
"assemblyline.common.forge.get_classification",
"assemblyline.odm.Classification",
"assemblyline.odm.model",
"assemblyline.odm.Boolean"
] | [((84, 110), 'assemblyline.common.forge.get_classification', 'forge.get_classification', ([], {}), '()\n', (108, 110), False, 'from assemblyline.common import forge\n'), ((114, 148), 'assemblyline.odm.model', 'odm.model', ([], {'index': '(True)', 'store': '(False)'}), '(index=True, store=False)\n', (123, 148), False, '... |
import time
import tensorflow as tf
from datasets.scripts.fra_eng import datasets_fra_eng
from transformer.text.tokenizer import TokenizerBert
from transformer.architecture.transfo import TransformerNLP
from transformer.train.metrics import MaskedAccuracy
from transformer.train.metrics import MaskedSparseCategoricalC... | [
"transformer.text.tokenizer.TokenizerBert",
"transformer.architecture.transfo.TransformerNLP",
"tensorflow.keras.metrics.Mean",
"tensorflow.TensorSpec",
"time.time",
"transformer.train.optimizer.ScheduleLR",
"tensorflow.shape",
"transformer.train.metrics.MaskedAccuracy",
"tensorflow.keras.optimizers... | [((487, 505), 'datasets.scripts.fra_eng.datasets_fra_eng', 'datasets_fra_eng', ([], {}), '()\n', (503, 505), False, 'from datasets.scripts.fra_eng import datasets_fra_eng\n'), ((754, 784), 'transformer.text.tokenizer.TokenizerBert', 'TokenizerBert', ([], {'lower_case': '(True)'}), '(lower_case=True)\n', (767, 784), Fal... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# Copyright 2020 Alibaba Group Holding Limited. 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... | [
"os.path.abspath",
"os.makedirs",
"os.path.isdir",
"os.path.realpath",
"shutil.which",
"glob.glob",
"sys.exit",
"os.path.join",
"os.chdir",
"subprocess.check_call"
] | [((800, 831), 'os.path.join', 'os.path.join', (['proto_dir', 'suffix'], {}), '(proto_dir, suffix)\n', (812, 831), False, 'import os\n'), ((844, 864), 'glob.glob', 'glob.glob', (['directory'], {}), '(directory)\n', (853, 864), False, 'import glob\n'), ((959, 978), 'os.path.isdir', 'os.path.isdir', (['path'], {}), '(path... |
# Software License Agreement (BSD License)
#
# Copyright (c) 2012, <NAME>, Inc.
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# * Redistributions of source code must retain the above copyri... | [
"rostopic.get_topic_class",
"roslaunch.RLException",
"genmsg.resource_name",
"os.path.isdir",
"rospkg.RosPack",
"os.path.isfile",
"rospy.logdebug",
"os.path.join",
"os.listdir",
"roslaunch.launch._unify_clear_params"
] | [((4015, 4061), 'rospy.logdebug', 'rospy.logdebug', (['"""... load_parameters complete"""'], {}), "('... load_parameters complete')\n", (4029, 4061), False, 'import rospy\n'), ((4513, 4529), 'rospkg.RosPack', 'rospkg.RosPack', ([], {}), '()\n', (4527, 4529), False, 'import rospkg\n'), ((5351, 5367), 'rospkg.RosPack', '... |
from leapp.cli import main
import leapp.utils.i18n # noqa: F401; pylint: disable=unused-import
main()
| [
"leapp.cli.main"
] | [((98, 104), 'leapp.cli.main', 'main', ([], {}), '()\n', (102, 104), False, 'from leapp.cli import main\n')] |
from django.conf import settings
from django.db import models
from django.db.models.signals import post_save
from django.dispatch import receiver
from django.utils.translation import ugettext_lazy as _
from .assignee import GroupAssignee, UserProfileAssignee
class PublicInfo(models.Model):
email = models.EmailFi... | [
"django.db.models.TextField",
"django.db.models.ManyToManyField",
"django.db.models.CharField",
"django.db.models.ForeignKey",
"django.dispatch.receiver",
"django.db.models.DateTimeField",
"django.utils.translation.ugettext_lazy"
] | [((1918, 1970), 'django.dispatch.receiver', 'receiver', (['post_save'], {'sender': 'settings.AUTH_USER_MODEL'}), '(post_save, sender=settings.AUTH_USER_MODEL)\n', (1926, 1970), False, 'from django.dispatch import receiver\n'), ((2346, 2401), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(20)', ... |
from twitter.pants.base import ParseContext
__author__ = '<NAME>'
from collections import defaultdict
from twitter.pants.targets import InternalTarget, TargetWithSources
class MockTarget(InternalTarget, TargetWithSources):
def __init__(self, name, dependencies=None, num_sources=0, exclusives=None):
with Parse... | [
"collections.defaultdict",
"twitter.pants.targets.TargetWithSources.__init__",
"twitter.pants.base.ParseContext.temp",
"twitter.pants.targets.InternalTarget.__init__"
] | [((549, 565), 'collections.defaultdict', 'defaultdict', (['set'], {}), '(set)\n', (560, 565), False, 'from collections import defaultdict\n'), ((315, 334), 'twitter.pants.base.ParseContext.temp', 'ParseContext.temp', ([], {}), '()\n', (332, 334), False, 'from twitter.pants.base import ParseContext\n'), ((342, 414), 'tw... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
COS method
==========
The method comes from [1]_
The original code is found at
http://www.wilmott.com/messageview.cfm?catid=34&threadid=78554
References
----------
.. [1] <NAME>., & <NAME>. (2009).
A Novel Pricing Method for European Options
Based on Fourier... | [
"numpy.ones_like",
"numpy.logical_not",
"numpy.ones",
"numexpr.evaluate",
"numpy.arange",
"numpy.exp",
"numpy.dot"
] | [((2168, 2188), 'numpy.logical_not', 'np.logical_not', (['call'], {}), '(call)\n', (2182, 2188), True, 'import numpy as np\n'), ((2387, 2428), 'numpy.exp', 'np.exp', (['(-1.0j * kvec * (moneyness + alim))'], {}), '(-1.0j * kvec * (moneyness + alim))\n', (2393, 2428), True, 'import numpy as np\n'), ((3045, 3190), 'numex... |
# WEB-SERVER RESPONSE STATUS LOGGER
# MIT License
# Copyright (c) 2021 jaggiJ
# Checks and logs server response status
import requests, sys
import time, datetime
########################################################################
# PRINTS HELP IF REQUESTED by --help argument and such
helpRequest = ['--help', ... | [
"requests.get",
"datetime.datetime.now",
"sys.exit",
"time.sleep"
] | [((715, 725), 'sys.exit', 'sys.exit', ([], {}), '()\n', (723, 725), False, 'import requests, sys\n'), ((1153, 1176), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (1174, 1176), False, 'import time, datetime\n'), ((1904, 1914), 'sys.exit', 'sys.exit', ([], {}), '()\n', (1912, 1914), False, 'import ... |
# This is a troll indeed ffs *facepalm*
import asyncio
from telethon import events
from telethon.tl.functions.users import GetFullUserRequest
from telethon.tl.types import ChannelParticipantsAdmins
from userbot.utils import admin_cmd
@borg.on(admin_cmd("gbun"))
async def gbun(event):
if event.fwd_from:
... | [
"userbot.utils.admin_cmd",
"asyncio.sleep",
"telethon.tl.functions.users.GetFullUserRequest"
] | [((575, 591), 'asyncio.sleep', 'asyncio.sleep', (['(4)'], {}), '(4)\n', (588, 591), False, 'import asyncio\n'), ((253, 270), 'userbot.utils.admin_cmd', 'admin_cmd', (['"""gbun"""'], {}), "('gbun')\n", (262, 270), False, 'from userbot.utils import admin_cmd\n'), ((899, 940), 'telethon.tl.functions.users.GetFullUserReque... |
"""时间序列计算层、神经网络模型定义.
复现华泰金工 alpha net V2、V3 版本.
V2:
```
input: (batch_size, history time steps, features)
stride = 5
input -> expand features -> BN -> LSTM -> BN -> Dense(linear)
```
V3:
```
input: (batch_size, history time steps, features)
stride = 5
+-> expand features ... | [
"tensorflow.einsum",
"tensorflow.reduce_sum",
"tensorflow.keras.layers.Dense",
"tensorflow.math.reduce_std",
"tensorflow.reshape",
"tensorflow.sqrt",
"tensorflow.repeat",
"tensorflow.keras.regularizers.l2",
"tensorflow.keras.layers.BatchNormalization",
"tensorflow.subtract",
"tensorflow.keras.la... | [((25733, 25837), 'tensorflow.keras.models.load_model', '_tf.keras.models.load_model', (['filepath'], {'custom_objects': 'object_dict', 'compile': 'compile', 'options': 'options'}), '(filepath, custom_objects=object_dict, compile=\n compile, options=options)\n', (25760, 25837), True, 'import tensorflow as _tf\n'), (... |
import os
from django.db import models
def upload_path(user, filename):
extension = os.path.splitext(filename)[1]
return 'avatar_%s%s' % (user.pk, extension)
class UserProfile(models.Model):
user = models.OneToOneField('auth.User', on_delete=models.CASCADE)
avatar = models.ImageField(upload_to=uplo... | [
"django.db.models.ImageField",
"django.db.models.OneToOneField",
"django.db.models.TextField",
"os.path.splitext"
] | [((215, 274), 'django.db.models.OneToOneField', 'models.OneToOneField', (['"""auth.User"""'], {'on_delete': 'models.CASCADE'}), "('auth.User', on_delete=models.CASCADE)\n", (235, 274), False, 'from django.db import models\n'), ((288, 340), 'django.db.models.ImageField', 'models.ImageField', ([], {'upload_to': 'upload_p... |
import re
#import logbook
from inspect import isroutine, getmro
from itertools import chain
import unittest
_CAMEL_RE = re.compile(r'(?<=[a-z])([A-Z])')
def _normalize(name):
return _CAMEL_RE.sub(lambda x: '_' + x.group(1).lower(), name).lower()
def _defined_in(obj, name, value):
if hasattr(obj, '__bases__... | [
"unittest.main",
"inspect.isroutine",
"inspect.getmro",
"pdb.set_trace",
"re.compile"
] | [((122, 153), 're.compile', 're.compile', (['"""(?<=[a-z])([A-Z])"""'], {}), "('(?<=[a-z])([A-Z])')\n", (132, 153), False, 'import re\n'), ((5396, 5411), 'unittest.main', 'unittest.main', ([], {}), '()\n', (5409, 5411), False, 'import unittest\n'), ((338, 349), 'inspect.getmro', 'getmro', (['obj'], {}), '(obj)\n', (344... |
import json
import networkx as nx
from pyquil.quil import Program
from pyquil.api import get_qc, LocalQVMCompiler
from pyquil.device import NxDevice
from pyquil.gates import CNOT, H
from qiskit import transpiler
from qiskit.wrapper import load_qasm_file
from qiskit.dagcircuit import DAGCircuit
def quil_compile(inpu... | [
"pyquil.device.NxDevice",
"qiskit.wrapper.load_qasm_file",
"json.dumps",
"qiskit.transpiler.transpile",
"pyquil.api.LocalQVMCompiler",
"qiskit.dagcircuit.DAGCircuit.fromQuantumCircuit",
"networkx.Graph"
] | [((363, 373), 'networkx.Graph', 'nx.Graph', ([], {}), '()\n', (371, 373), True, 'import networkx as nx\n'), ((420, 431), 'pyquil.device.NxDevice', 'NxDevice', (['g'], {}), '(g)\n', (428, 431), False, 'from pyquil.device import NxDevice\n'), ((501, 546), 'pyquil.api.LocalQVMCompiler', 'LocalQVMCompiler', (['"""http://lo... |
import numpy as np
from glob import glob
from scipy import ndimage
from keras import callbacks
from keras.optimizers import Adamax, SGD, RMSprop
import resnet50
def convert_to_one_hot(Y, C):
'''Converts array with labels to one-hot encoding
Keyword Arguments:
Y -- 1-dimensional numpy array containing... | [
"keras.optimizers.SGD",
"keras.callbacks.TerminateOnNaN",
"numpy.eye",
"keras.callbacks.ModelCheckpoint",
"numpy.asarray",
"glob.glob",
"keras.callbacks.CSVLogger",
"scipy.ndimage.imread"
] | [((676, 699), 'glob.glob', 'glob', (["('%s/*' % datapath)"], {}), "('%s/*' % datapath)\n", (680, 699), False, 'from glob import glob\n'), ((1609, 1646), 'keras.optimizers.SGD', 'SGD', ([], {'lr': 'learning_rate', 'decay': 'lr_decay'}), '(lr=learning_rate, decay=lr_decay)\n', (1612, 1646), False, 'from keras.optimizers ... |
"""Settings for tests."""
import os
from pathlib import Path
import pkg_resources as pkg
###################################################################################################
###################################################################################################
# Set paths for test files
T... | [
"pkg_resources.resource_filename"
] | [((341, 386), 'pkg_resources.resource_filename', 'pkg.resource_filename', (['__name__', '"""test_files"""'], {}), "(__name__, 'test_files')\n", (362, 386), True, 'import pkg_resources as pkg\n')] |
#!/usr/bin/env python2.7
"""
app_config.py will be storing all the module configs.
Here the db uses mysql.
"""
import os
_basedir = os.path.abspath(os.path.dirname(__file__))
DEBUG = False
ADMINS = frozenset(['<EMAIL>'])
SECRET_KEY = ''
SQLALCHEMY_DATABASE_URI = 'DATABASE://USERNAME:PASSWORD@localhost/YOUR_DB_NAME'... | [
"os.path.dirname"
] | [((149, 174), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (164, 174), False, 'import os\n')] |
from setuptools import find_packages, setup
setup(name='sentiment_analysis',
packages=['sentiment_analysis'],
version='0.2.0',
description="sentiment analysis library",
author='<NAME>',
package_data={'sentiment_analysis': ['data/*'],},
include_package_data=True,
install_... | [
"setuptools.setup"
] | [((45, 470), 'setuptools.setup', 'setup', ([], {'name': '"""sentiment_analysis"""', 'packages': "['sentiment_analysis']", 'version': '"""0.2.0"""', 'description': '"""sentiment analysis library"""', 'author': '"""<NAME>"""', 'package_data': "{'sentiment_analysis': ['data/*']}", 'include_package_data': '(True)', 'instal... |
# -*- coding: utf-8 -*-
'''
Python CLI wrapper for Amazon Workspaces API
Usage:
workspaces.py get
workspaces.py getallwsids
workspaces.py reboot <WorkspaceId>
workspaces.py test
workspaces.py nuke
Arguments:
WorkspaceId use 'get' to identify a workspace
Options:
-h --help Show t... | [
"rich.panel.Panel",
"boto3.client",
"docopt.docopt",
"botocore.config.Config",
"rich.console.Console",
"configparser.ConfigParser"
] | [((1134, 1219), 'docopt.docopt', 'docopt', (['__doc__'], {'version': '"""Python CLI wrapper for Amazon Workspaces API - v0.1.0"""'}), "(__doc__, version='Python CLI wrapper for Amazon Workspaces API - v0.1.0'\n )\n", (1140, 1219), False, 'from docopt import docopt\n'), ((1702, 1729), 'configparser.ConfigParser', 'co... |
#!/usr/bin/env python
from copy import deepcopy
import torch.nn as nn
from yacs.config import CfgNode as CN
from ..layers import ConvBNA, MBConv, FusedMBConv
class EfficientNetV2(nn.Module):
def __init__(self, cfg: CN, in_channels: int = 3):
super(EfficientNetV2, self).__init__()
... | [
"copy.deepcopy",
"torch.nn.Sequential"
] | [((576, 598), 'torch.nn.Sequential', 'nn.Sequential', (['*layers'], {}), '(*layers)\n', (589, 598), True, 'import torch.nn as nn\n'), ((1390, 1404), 'copy.deepcopy', 'deepcopy', (['node'], {}), '(node)\n', (1398, 1404), False, 'from copy import deepcopy\n'), ((737, 759), 'torch.nn.Sequential', 'nn.Sequential', (['*laye... |
import colorsys
import pkgutil
from dataclasses import dataclass
import pandas as pd
from pylighter import config
def text_parser(file_name, **kwargs):
"""Parse text and replace <% variable %> by the value of variable.
Parameters
----------
file_name : str
Path to the file
Returns
... | [
"pandas.DataFrame",
"pkgutil.get_data",
"colorsys.rgb_to_hls",
"pylighter.config.DISPLAY_ELEMENTS.keys",
"pandas.concat"
] | [((1350, 1407), 'pandas.DataFrame', 'pd.DataFrame', ([], {'data': "{'document': corpus, 'labels': labels}"}), "(data={'document': corpus, 'labels': labels})\n", (1362, 1407), True, 'import pandas as pd\n'), ((2460, 2485), 'colorsys.rgb_to_hls', 'colorsys.rgb_to_hls', (['*rgb'], {}), '(*rgb)\n', (2479, 2485), False, 'im... |
#!/usr/bin/env python3
"""Class interacts with devices supporting IfMIB. (32 Bit Counters)."""
from collections import defaultdict
from switchmap.snmp.base_query import Query
from switchmap.utils import general
def get_query():
"""Return this module's Query class."""
return IfQuery
def init_query(snmp_ob... | [
"collections.defaultdict",
"switchmap.utils.general.octetstr_2_string"
] | [((4035, 4052), 'collections.defaultdict', 'defaultdict', (['dict'], {}), '(dict)\n', (4046, 4052), False, 'from collections import defaultdict\n'), ((4889, 4906), 'collections.defaultdict', 'defaultdict', (['dict'], {}), '(dict)\n', (4900, 4906), False, 'from collections import defaultdict\n'), ((5858, 5875), 'collect... |