code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
# -*- coding: utf-8 -*-
from django.contrib.contenttypes.models import ContentType
from django.db import models
import django
if (hasattr(django,"version") and django.version > 1.8) or (hasattr(django,"get_version") and django.get_version()):
from django.contrib.contenttypes.fields import GenericForeignKey
from... | [
"django.db.models.IPAddressField",
"django.db.models.ForeignKey",
"django.db.models.CharField",
"django.db.models.PositiveIntegerField",
"django.contrib.contenttypes.models.ContentType.objects.get_for_model",
"django.db.models.GenericIPAddressField",
"django.db.models.F",
"datetime.timedelta",
"djan... | [((2020, 2061), 'django.db.models.ForeignKey', 'models.ForeignKey', (['ContentType'], {'null': '(True)'}), '(ContentType, null=True)\n', (2037, 2061), False, 'from django.db import models\n'), ((2078, 2109), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(50)'}), '(max_length=50)\n', (2094, 2109... |
#!/usr/bin/env python
# stdlib imports
import urllib.request as request
import tempfile
import os.path
import sys
from datetime import datetime
# third party imports
import numpy as np
# local imports
from losspager.utils.expocat import ExpoCat
def commify(value):
if np.isnan(value):
return 'NaN'
r... | [
"losspager.utils.expocat.ExpoCat.fromDefault",
"numpy.array",
"numpy.isnan",
"datetime.datetime"
] | [((277, 292), 'numpy.isnan', 'np.isnan', (['value'], {}), '(value)\n', (285, 292), True, 'import numpy as np\n'), ((509, 550), 'numpy.array', 'np.array', (['[tdict[idx] for idx in indices]'], {}), '([tdict[idx] for idx in indices])\n', (517, 550), True, 'import numpy as np\n'), ((756, 777), 'losspager.utils.expocat.Exp... |
#!/usr/bin/env python
# encoding: utf-8
"""
AutomaticSeeding_t.py
Created by <NAME> on 2010-08-30.
Copyright (c) 2010 Fermilab. All rights reserved.
"""
from __future__ import print_function
import sys
import os
import unittest
from WMCore.JobSplitting.Generators.AutomaticSeeding import AutomaticSeeding
from WMCore... | [
"unittest.main",
"WMCore.JobSplitting.Generators.AutomaticSeeding.AutomaticSeeding",
"WMCore.DataStructs.Job.Job",
"PSetTweaks.PSetTweak.PSetTweak"
] | [((1731, 1746), 'unittest.main', 'unittest.main', ([], {}), '()\n', (1744, 1746), False, 'import unittest\n'), ((797, 811), 'WMCore.DataStructs.Job.Job', 'Job', (['"""TestJob"""'], {}), "('TestJob')\n", (800, 811), False, 'from WMCore.DataStructs.Job import Job\n'), ((829, 847), 'WMCore.JobSplitting.Generators.Automati... |
#!/usr/bin/env python2
"""
This script extracts crackable hashes from krb5's credential cache files (e.g.
/tmp/krb5cc_1000).
NOTE: This attack technique only works against MS Active Directory servers.
This was tested with CentOS 7.4 client running krb5-1.15.1 software against a
Windows 2012 R2 Active Directory serve... | [
"struct.pack",
"datetime.datetime",
"time.sleep",
"datetime.datetime.utcfromtimestamp",
"datetime.datetime.strptime",
"pyasn1.codec.ber.decoder.decode",
"sys.stderr.write",
"sys.exit"
] | [((1545, 1586), 'struct.pack', 'struct.pack', (['""">HH"""', 'self.tag', 'self.taglen'], {}), "('>HH', self.tag, self.taglen)\n", (1556, 1586), False, 'import struct\n'), ((1973, 2027), 'struct.pack', 'struct.pack', (['""">LL"""', 'self.time_offset', 'self.usec_offset'], {}), "('>LL', self.time_offset, self.usec_offset... |
import configparser
def get_base_url():
parser = configparser.ConfigParser()
parser.read('token.cfg')
token = parser.get('creds', 'token')
return f"https://api.telegram.org/bot{token}/"
| [
"configparser.ConfigParser"
] | [((55, 82), 'configparser.ConfigParser', 'configparser.ConfigParser', ([], {}), '()\n', (80, 82), False, 'import configparser\n')] |
import os
from flask import Flask
from flask import request
try:
from SimpleHTTPServer import SimpleHTTPRequestHandler as Handler
from SocketServer import TCPServer as Server
except ImportError:
from http.server import SimpleHTTPRequestHandler as Handler
from http.server import HTTPServer as Server
# Read por... | [
"flask.Flask",
"os.getenv"
] | [((711, 726), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (716, 726), False, 'from flask import Flask\n'), ((375, 398), 'os.getenv', 'os.getenv', (['"""PORT"""', '(8000)'], {}), "('PORT', 8000)\n", (384, 398), False, 'import os\n')] |
# -*- coding: utf-8 -*-
import networkx as nx
from networkx.readwrite import json_graph
import json
def read_json_file(filename: object) -> object:
# from http://stackoverflow.com/a/34665365
"""
:type filename: object
"""
with open(filename.name) as f:
js_graph = json.load(f)
return jso... | [
"networkx.readwrite.json_graph.node_link_graph",
"networkx.DiGraph",
"json.load",
"networkx.get_node_attributes"
] | [((317, 353), 'networkx.readwrite.json_graph.node_link_graph', 'json_graph.node_link_graph', (['js_graph'], {}), '(js_graph)\n', (343, 353), False, 'from networkx.readwrite import json_graph\n'), ((631, 644), 'networkx.DiGraph', 'nx.DiGraph', (['w'], {}), '(w)\n', (641, 644), True, 'import networkx as nx\n'), ((660, 67... |
import numpy as np
import pandas as pd
import fasttext
from sklearn.preprocessing import MultiLabelBinarizer
from skmultilearn.model_selection import IterativeStratification, \
iterative_train_test_split
from functools import reduce
CIP_TAGS = list(map(lambda x: x.strip(),
"gratis, mat, musik, ... | [
"pandas.DataFrame",
"pandas.read_csv",
"fasttext.train_unsupervised",
"os.getcwd",
"sklearn.preprocessing.MultiLabelBinarizer",
"tagger._preprocessing.characterset.CharacterSet",
"tagger._preprocessing.html.HTMLToText",
"skmultilearn.model_selection.IterativeStratification",
"numpy.array",
"pandas... | [((1601, 1738), 'pandas.read_csv', 'pd.read_csv', (['path'], {'header': 'None', 'names': "['id', 'weekday', 'time', 'title', 'description', 'tag_status', 'tag']", 'na_values': "['-01:00:00']"}), "(path, header=None, names=['id', 'weekday', 'time', 'title',\n 'description', 'tag_status', 'tag'], na_values=['-01:00:00... |
#!/usr/bin/env python
import rospy
from std_msgs.msg import String
class MessageSubscriber:
def __init__(
self,
node_name,
topic_name
):
rospy.init_node(node_name)
self._topic_name = topic_name
self._subscriber = rospy.Subscriber(
sel... | [
"rospy.spin",
"rospy.Subscriber",
"rospy.init_node"
] | [((631, 643), 'rospy.spin', 'rospy.spin', ([], {}), '()\n', (641, 643), False, 'import rospy\n'), ((194, 220), 'rospy.init_node', 'rospy.init_node', (['node_name'], {}), '(node_name)\n', (209, 220), False, 'import rospy\n'), ((287, 372), 'rospy.Subscriber', 'rospy.Subscriber', (['self._topic_name', 'String'], {'callbac... |
import gym
import rlkit.torch.pytorch_util as ptu
from rlkit.data_management.obs_dict_replay_buffer import ObsDictRelabelingBuffer, WeightedObsDictRelabelingBuffer
from rlkit.launchers.launcher_util import setup_logger
from rlkit.samplers.data_collector import GoalConditionedPathCollector
from rlkit.torch.her.her impo... | [
"rlkit.torch.sac.sac.SACTrainer",
"rlkit.torch.sac.policies.MakeDeterministic",
"rlkit.torch.torch_rl_algorithm.TorchBatchRLAlgorithm",
"numpy.concatenate",
"rlkit.samplers.data_collector.GoalConditionedPathCollector",
"robosuite.make",
"numpy.random.seed",
"rlkit.torch.her.her.HERTrainer",
"numpy.z... | [((7709, 7762), 'robosuite.load_controller_config', 'load_controller_config', ([], {'default_controller': '"""OSC_POSE"""'}), "(default_controller='OSC_POSE')\n", (7731, 7762), False, 'from robosuite import load_controller_config\n'), ((9648, 9745), 'rlkit.torch.networks.ConcatMlp', 'ConcatMlp', ([], {'input_size': '(o... |
# Copyright 2021, Google LLC.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing... | [
"absl.testing.absltest.main",
"dual_encoder.keras_layers.EmbeddingSpreadoutRegularizer.from_config",
"tensorflow.debugging.assert_equal",
"dual_encoder.keras_layers.MaskedReshape",
"tensorflow.constant",
"dual_encoder.keras_layers.MaskedAverage",
"tensorflow.keras.backend.l2_normalize",
"tensorflow.de... | [((704, 745), 'tensorflow.keras.backend.l2_normalize', 'tf.keras.backend.l2_normalize', (['x'], {'axis': '(-1)'}), '(x, axis=-1)\n', (733, 745), True, 'import tensorflow as tf\n'), ((11535, 11550), 'absl.testing.absltest.main', 'absltest.main', ([], {}), '()\n', (11548, 11550), False, 'from absl.testing import absltest... |
from typing import (
Any,
Callable,
cast,
Generic,
Mapping,
NoReturn,
Optional,
TypeVar,
Union,
)
from abc import ABC, abstractmethod
from functools import wraps
import math
import collections
from util import *
__all__ = ["Maybe", "Some", "Nothing", "maybe"]
class Maybe(Generic[... | [
"functools.wraps"
] | [((4287, 4298), 'functools.wraps', 'wraps', (['func'], {}), '(func)\n', (4292, 4298), False, 'from functools import wraps\n')] |
# программа сортировки файлов по папкам по их типу или расширению
import os
from watchdog.observers import Observer
from watchdog.events import FileSystemEventHandler
from conf import conf_ext
print( ' PythonSorter by SI ver 0.5' )
print( '-----------------------------------------------------------' )
... | [
"os.getlogin",
"conf.conf_ext.sort",
"os.makedirs",
"os.rename",
"os.chdir",
"os.listdir",
"watchdog.observers.Observer"
] | [((4334, 4344), 'watchdog.observers.Observer', 'Observer', ([], {}), '()\n', (4342, 4344), False, 'from watchdog.observers import Observer\n'), ((4716, 4731), 'conf.conf_ext.sort', 'conf_ext.sort', ([], {}), '()\n', (4729, 4731), False, 'from conf import conf_ext\n'), ((359, 372), 'os.getlogin', 'os.getlogin', ([], {})... |
import glob
import logging
import platform
import re
import socket
from typing import Any
logger = logging.getLogger("hepynet")
def get_current_platform_name() -> str:
"""Returns the name of the current platform.
Returns:
str: name of current platform
"""
return platform.platform()
def get... | [
"platform.platform",
"socket.gethostname",
"logging.getLogger",
"re.compile"
] | [((100, 128), 'logging.getLogger', 'logging.getLogger', (['"""hepynet"""'], {}), "('hepynet')\n", (117, 128), False, 'import logging\n'), ((291, 310), 'platform.platform', 'platform.platform', ([], {}), '()\n', (308, 310), False, 'import platform\n'), ((458, 478), 'socket.gethostname', 'socket.gethostname', ([], {}), '... |
# Copyright (C) 2019 by eHealth Africa : http://www.eHealthAfrica.org
#
# See the NOTICE file distributed with this work for additional information
# regarding copyright ownership.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with
# the License. Y... | [
"aether.sdk.multitenancy.utils.get_current_realm",
"django.contrib.auth.get_user_model",
"aether.sdk.multitenancy.utils.add_user_to_realm"
] | [((871, 887), 'django.contrib.auth.get_user_model', 'get_user_model', ([], {}), '()\n', (885, 887), False, 'from django.contrib.auth import get_user_model\n'), ((1632, 1658), 'aether.sdk.multitenancy.utils.get_current_realm', 'get_current_realm', (['request'], {}), '(request)\n', (1649, 1658), False, 'from aether.sdk.m... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import logging
import time
import paddle
from paddle.amp import auto_cast
from .mixup import Mixup
from core.evaluate import accuracy
from utils.comm import comm
def train_one_epoch(config,... | [
"core.evaluate.accuracy",
"paddle.argmax",
"paddle.no_grad",
"paddle.amp.auto_cast",
"time.time",
"logging.info",
"utils.comm.comm.synchronize",
"paddle.distributed.reduce",
"utils.comm.comm.is_main_process",
"paddle.to_tensor"
] | [((3523, 3539), 'paddle.no_grad', 'paddle.no_grad', ([], {}), '()\n', (3537, 3539), False, 'import paddle\n'), ((598, 637), 'logging.info', 'logging.info', (['"""=> switch to train mode"""'], {}), "('=> switch to train mode')\n", (610, 637), False, 'import logging\n'), ((1108, 1119), 'time.time', 'time.time', ([], {}),... |
from localtileserver import examples
def test_get_blue_marble():
client = examples.get_blue_marble()
assert client.metadata()
def test_get_virtual_earth():
client = examples.get_virtual_earth()
assert client.metadata()
def test_get_arcgis():
client = examples.get_arcgis()
assert client.met... | [
"localtileserver.examples.get_bahamas",
"localtileserver.examples.get_elevation_us",
"localtileserver.examples.get_blue_marble",
"localtileserver.examples.get_san_francisco",
"localtileserver.examples.get_oam2",
"localtileserver.examples.get_elevation",
"localtileserver.examples.get_pine_gulch",
"loca... | [((80, 106), 'localtileserver.examples.get_blue_marble', 'examples.get_blue_marble', ([], {}), '()\n', (104, 106), False, 'from localtileserver import examples\n'), ((181, 209), 'localtileserver.examples.get_virtual_earth', 'examples.get_virtual_earth', ([], {}), '()\n', (207, 209), False, 'from localtileserver import ... |
"""Added location to proposal
Revision ID: 4dbf686f4380
Revises: <PASSWORD>
Create Date: 2013-11-08 23:35:43.433963
"""
# revision identifiers, used by Alembic.
revision = '<KEY>'
down_revision = '1<PASSWORD>'
from alembic import op
import sqlalchemy as sa
def upgrade():
### commands auto generated by Alembic... | [
"alembic.op.drop_column",
"alembic.op.alter_column",
"sqlalchemy.text",
"sqlalchemy.Unicode"
] | [((469, 529), 'alembic.op.alter_column', 'op.alter_column', (['"""proposal"""', '"""location"""'], {'server_default': 'None'}), "('proposal', 'location', server_default=None)\n", (484, 529), False, 'from alembic import op\n'), ((650, 688), 'alembic.op.drop_column', 'op.drop_column', (['"""proposal"""', '"""location"""'... |
import functools
from typing import List
class TreeNode:
def __init__(self, x):
self.val = x
self.left = None
self.right = None
class Solution:
"""
Same thought as LC96, we can generate trees recursively.
If the root of tree is i
The left subtree has a sequenc... | [
"functools.lru_cache"
] | [((604, 629), 'functools.lru_cache', 'functools.lru_cache', (['None'], {}), '(None)\n', (623, 629), False, 'import functools\n')] |
import os
from pipeline_tools.shared import http_requests
from pipeline_tools.tests.http_requests_manager import HttpRequestsManager
class TestHttpRequestsManager(object):
def test_enter_creates_directory(self):
with HttpRequestsManager() as temp_dir:
assert os.path.isdir(temp_dir) is True
... | [
"os.path.isdir",
"pipeline_tools.tests.http_requests_manager.HttpRequestsManager"
] | [((232, 253), 'pipeline_tools.tests.http_requests_manager.HttpRequestsManager', 'HttpRequestsManager', ([], {}), '()\n', (251, 253), False, 'from pipeline_tools.tests.http_requests_manager import HttpRequestsManager\n'), ((375, 396), 'pipeline_tools.tests.http_requests_manager.HttpRequestsManager', 'HttpRequestsManager... |
"""
Faça um programa que mostre na tela uma contagem regressiva para o estouro de fogos de
artifício, indo de 10 até 0, com uma pausa de 1 segundo entre eles.
"""
#importar a bliblioteca para esperar
from time import sleep
print("contagem regressiva para os fogos!!!!")
for a in range(10,0,-1):
print(a)
sleep... | [
"time.sleep"
] | [((315, 323), 'time.sleep', 'sleep', (['(1)'], {}), '(1)\n', (320, 323), False, 'from time import sleep\n')] |
from __future__ import unicode_literals
from django import forms
from django.contrib.auth.models import User
from django.db import models
from ckeditor_uploader.fields import RichTextUploadingField
# Create your models here.
from django.utils.safestring import mark_safe
class Main(models.Model):
STATUS = (
... | [
"django.db.models.TextField",
"django.db.models.OneToOneField",
"django.db.models.CharField",
"ckeditor_uploader.fields.RichTextUploadingField",
"django.db.models.ImageField",
"django.db.models.IntegerField",
"django.db.models.DateTimeField"
] | [((387, 430), 'django.db.models.CharField', 'models.CharField', ([], {'default': '""""""', 'max_length': '(40)'}), "(default='', max_length=40)\n", (403, 430), False, 'from django.db import models\n'), ((444, 503), 'django.db.models.CharField', 'models.CharField', ([], {'default': '""""""', 'max_length': '(40)', 'choic... |
import numpy as np
from PIL import Image
import time
import cv2
global img
global point1, point2
global min_x, min_y, width, height, max_x, max_y
def on_mouse(event, x, y, flags, param):
global img, point1, point2, min_x, min_y, width, height, max_x, max_y
img2 = img.copy()
if event == cv2.EVENT_LBUTTOND... | [
"numpy.nan_to_num",
"numpy.isnan",
"numpy.random.randint",
"cv2.rectangle",
"cv2.imshow",
"numpy.zeros_like",
"numpy.copy",
"cv2.setMouseCallback",
"cv2.destroyAllWindows",
"cv2.resize",
"numpy.size",
"cv2.circle",
"cv2.waitKey",
"numpy.zeros",
"time.time",
"PIL.Image.open",
"cv2.imr... | [((1982, 1995), 'numpy.size', 'np.size', (['A', '(0)'], {}), '(A, 0)\n', (1989, 1995), True, 'import numpy as np\n'), ((2006, 2019), 'numpy.size', 'np.size', (['A', '(1)'], {}), '(A, 1)\n', (2013, 2019), True, 'import numpy as np\n'), ((2030, 2043), 'numpy.size', 'np.size', (['B', '(0)'], {}), '(B, 0)\n', (2037, 2043),... |
# Author: <NAME>
# Created: 2019-01-25
# Copyright (C) 2018, <NAME>
# License: MIT
import math
class Tween():
'''
Tweening class for scalar values
Initial value is set on construction.
wait() maintains the current value for the requested number of frames
pad() similar to wait, but pads until ... | [
"math.sin"
] | [((5275, 5300), 'math.sin', 'math.sin', (['(math.pi * x / 2)'], {}), '(math.pi * x / 2)\n', (5283, 5300), False, 'import math\n'), ((5197, 5230), 'math.sin', 'math.sin', (['(math.pi * (x / 2 - 0.5))'], {}), '(math.pi * (x / 2 - 0.5))\n', (5205, 5230), False, 'import math\n'), ((5436, 5468), 'math.sin', 'math.sin', (['(... |
import requests
class MoneyAPI():
def __init__(self):
self.API_URL = "https://economia.awesomeapi.com.br/json/all/CAD"
self.SUCESS_STATUS_CODE = 200
def request_money(self):
resp = requests.get(self.API_URL)
if resp.status_code != self.SUCESS_STATUS_CODE:
raise Exc... | [
"requests.get"
] | [((216, 242), 'requests.get', 'requests.get', (['self.API_URL'], {}), '(self.API_URL)\n', (228, 242), False, 'import requests\n')] |
from hydra.experimental import compose, initialize
from random import randint
from random import seed
from soundbay.data import ClassifierDataset
import numpy as np
def test_dataloader() -> None:
seed(1)
with initialize(config_path="../soundbay/conf"):
# config is relative to a module
cfg = co... | [
"hydra.experimental.compose",
"random.randint",
"soundbay.data.ClassifierDataset",
"random.seed",
"hydra.experimental.initialize",
"numpy.issubdtype"
] | [((202, 209), 'random.seed', 'seed', (['(1)'], {}), '(1)\n', (206, 209), False, 'from random import seed\n'), ((219, 261), 'hydra.experimental.initialize', 'initialize', ([], {'config_path': '"""../soundbay/conf"""'}), "(config_path='../soundbay/conf')\n", (229, 261), False, 'from hydra.experimental import compose, ini... |
# -*- coding: utf-8 -*-
import json, os, requests
from dotenv import load_dotenv
from telegram import Bot, InlineKeyboardButton, InlineKeyboardMarkup, Update
from telegram.ext import (CallbackContext, CallbackQueryHandler,
CommandHandler, Filters, MessageHandler, Updater)
load_dotenv()
TEL... | [
"json.load",
"telegram.ext.CallbackQueryHandler",
"telegram.InlineKeyboardButton",
"dotenv.load_dotenv",
"telegram.ext.Updater",
"telegram.Bot",
"telegram.InlineKeyboardMarkup",
"telegram.ext.MessageHandler",
"requests.post",
"telegram.ext.CommandHandler",
"os.getenv"
] | [((301, 314), 'dotenv.load_dotenv', 'load_dotenv', ([], {}), '()\n', (312, 314), False, 'from dotenv import load_dotenv\n'), ((334, 361), 'os.getenv', 'os.getenv', (['"""TELEGRAM_TOKEN"""'], {}), "('TELEGRAM_TOKEN')\n", (343, 361), False, 'import json, os, requests\n'), ((372, 401), 'os.getenv', 'os.getenv', (['"""TELE... |
import sys
import json
import os.path
import requests
def posts_at_url(url):
current_page = 1
max_page = sys.maxint
while current_page <= max_page:
url = os.path.expandvars(url)
resp = requests.get(url, params={'page':current_page, 'count': '-1'})
results = json.loads(resp.co... | [
"json.loads",
"requests.get"
] | [((221, 284), 'requests.get', 'requests.get', (['url'], {'params': "{'page': current_page, 'count': '-1'}"}), "(url, params={'page': current_page, 'count': '-1'})\n", (233, 284), False, 'import requests\n'), ((302, 326), 'json.loads', 'json.loads', (['resp.content'], {}), '(resp.content)\n', (312, 326), False, 'import ... |
import os
CMD = 'docker ps'
os.system(CMD)
ls = os.popen(CMD).read().split('\n')[1:-1]
zombies = []
for line in ls:
container, image = line.split()[:2]
if 'bigga' not in image and ':' not in image:
print(container, image)
zombies.append(container)
print("Zombies: ", " ".join(zombies))
# docke... | [
"os.popen",
"os.system"
] | [((30, 44), 'os.system', 'os.system', (['CMD'], {}), '(CMD)\n', (39, 44), False, 'import os\n'), ((50, 63), 'os.popen', 'os.popen', (['CMD'], {}), '(CMD)\n', (58, 63), False, 'import os\n')] |
import sqlite3
from sqlite3 import IntegrityError
import logging
from typing import List
from datetime import datetime
from togglcmder.toggl.types.workspace import Workspace
from togglcmder.toggl.builders.workspace_builder import WorkspaceBuilder
from togglcmder.toggl.types.time_entry import TimeEntry
from togglcmder... | [
"togglcmder.toggl.builders.tag_builder.TagBuilder",
"togglcmder.toggl.builders.workspace_builder.WorkspaceBuilder",
"togglcmder.toggl.builders.project_builder.ProjectBuilder",
"togglcmder.toggl.builders.user_builder.UserBuilder",
"sqlite3.connect",
"togglcmder.toggl.builders.time_entry_builder.TimeEntryBu... | [((2782, 2809), 'sqlite3.connect', 'sqlite3.connect', (['cache_name'], {}), '(cache_name)\n', (2797, 2809), False, 'import sqlite3\n'), ((2855, 2882), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (2872, 2882), False, 'import logging\n'), ((7221, 7235), 'datetime.datetime.now', 'datetime... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import logging
def init_logger() -> None:
logging.basicConfig(
level=logging.INFO,
format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
)
| [
"logging.basicConfig"
] | [((96, 203), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO', 'format': '"""%(asctime)s - %(name)s - %(levelname)s - %(message)s"""'}), "(level=logging.INFO, format=\n '%(asctime)s - %(name)s - %(levelname)s - %(message)s')\n", (115, 203), False, 'import logging\n')] |
import boto3
exceptions = boto3.client('discovery').exceptions
AuthorizationErrorException = exceptions.AuthorizationErrorException
ConflictErrorException = exceptions.ConflictErrorException
InvalidParameterException = exceptions.InvalidParameterException
InvalidParameterValueException = exceptions.InvalidParameterVa... | [
"boto3.client"
] | [((27, 52), 'boto3.client', 'boto3.client', (['"""discovery"""'], {}), "('discovery')\n", (39, 52), False, 'import boto3\n')] |
#!/usr/bin/env python
import os
import subprocess
import sys
from pathlib import Path
basedir = Path(__file__).parent.parent
os.chdir(basedir)
deps = {
"flake8": [
"darglint",
"flake8-bugbear",
"flake8-builtins",
"flake8-comprehensions",
"flake8-datetimez",
"flake... | [
"pathlib.Path",
"subprocess.call",
"os.chdir"
] | [((128, 145), 'os.chdir', 'os.chdir', (['basedir'], {}), '(basedir)\n', (136, 145), False, 'import os\n'), ((749, 810), 'subprocess.call', 'subprocess.call', (["['pip', 'install', '-U', *deps[sys.argv[1]]]"], {}), "(['pip', 'install', '-U', *deps[sys.argv[1]]])\n", (764, 810), False, 'import subprocess\n'), ((99, 113),... |
import yaml
import os
import numpy as np
class DataOrganizer:
def __init__(self,parameter_file_path):
self.base_path = parameter_file_path
self.load_params()
def load_params(self):
params_file = os.path.join(self.base_path,'params.yaml')
with open(params_file) as yamlstream:
... | [
"numpy.abs",
"yaml.load",
"os.path.join"
] | [((229, 272), 'os.path.join', 'os.path.join', (['self.base_path', '"""params.yaml"""'], {}), "(self.base_path, 'params.yaml')\n", (241, 272), False, 'import os\n'), ((344, 389), 'yaml.load', 'yaml.load', (['yamlstream'], {'Loader': 'yaml.SafeLoader'}), '(yamlstream, Loader=yaml.SafeLoader)\n', (353, 389), False, 'impor... |
from flask import Blueprint, abort, current_app, render_template, request
from flask.json import jsonify
from jinja2 import TemplateNotFound
from .constants import EXTENSION_NAME
from .extension import FlaskPancake
bp = Blueprint("pancake", __name__, template_folder="templates")
def aggregate_data(ext: FlaskPancake... | [
"flask.Blueprint",
"flask.abort",
"flask.json.jsonify",
"flask.current_app.extensions.get",
"flask.render_template"
] | [((222, 281), 'flask.Blueprint', 'Blueprint', (['"""pancake"""', '__name__'], {'template_folder': '"""templates"""'}), "('pancake', __name__, template_folder='templates')\n", (231, 281), False, 'from flask import Blueprint, abort, current_app, render_template, request\n'), ((2473, 2508), 'flask.current_app.extensions.g... |
import torch
import torch.nn as nn
from torch.autograd import Variable
import numpy as np
import os
import os.path as osp
def save_network(model, network_label, epoch, iteration, args):
dataset = args.data_path.split(os.sep)[-1]
save_filename = "{0}_net_{1}_{2}_{3}.pth".format(network_label, args.model, epoch... | [
"torch.nn.Dropout",
"torch.nn.MSELoss",
"torch.nn.ReLU",
"os.makedirs",
"torch.nn.BCELoss",
"torch.nn.Sequential",
"torch.nn.Tanh",
"numpy.ceil",
"torch.load",
"torch.nn.Conv2d",
"os.path.exists",
"torch.autograd.Variable",
"torch.nn.Sigmoid",
"torch.save",
"torch.cuda.is_available",
"... | [((355, 387), 'os.path.join', 'osp.join', (['args.save_dir', 'dataset'], {}), '(args.save_dir, dataset)\n', (363, 387), True, 'import os.path as osp\n'), ((484, 527), 'os.path.join', 'os.path.join', (['model_save_dir', 'save_filename'], {}), '(model_save_dir, save_filename)\n', (496, 527), False, 'import os\n'), ((839,... |
from .loaders.loader import DatasetLoader
from omegaconf import OmegaConf
class DatasetSuite:
def __init__(self, name, cache_dir, datasets):
self.name = name
self.cache_dir = cache_dir
self.datasets = datasets
def fetch_and_cache_dataset(self, dataset_index):
loader_type = sel... | [
"omegaconf.OmegaConf.to_container"
] | [((637, 678), 'omegaconf.OmegaConf.to_container', 'OmegaConf.to_container', (['cfg'], {'resolve': '(True)'}), '(cfg, resolve=True)\n', (659, 678), False, 'from omegaconf import OmegaConf\n')] |
from collections import namedtuple
ImageBuilderResult = namedtuple(
"ImageBuilderResult",
("consumed_files", "file_errors_map", "new_images", "new_image_files"),
)
| [
"collections.namedtuple"
] | [((57, 165), 'collections.namedtuple', 'namedtuple', (['"""ImageBuilderResult"""', "('consumed_files', 'file_errors_map', 'new_images', 'new_image_files')"], {}), "('ImageBuilderResult', ('consumed_files', 'file_errors_map',\n 'new_images', 'new_image_files'))\n", (67, 165), False, 'from collections import namedtupl... |
"""ESCALATE Capture
Main point of entry for for EscalateCAPTURE
"""
import os
import sys
import ast
import xlrd
import logging
import argparse as ap
from log import init
from capture import specify
from capture import devconfig
from utils import globals, data_handling
def escalatecapture(rxndict, vardict):
"""... | [
"os.mkdir",
"os.remove",
"argparse.ArgumentParser",
"xlrd.open_workbook",
"utils.globals.set_lab",
"os.path.exists",
"log.init.initialize",
"log.init.buildlogger",
"log.init.runuidgen",
"ast.literal_eval",
"logging.getLogger",
"capture.specify.datapipeline"
] | [((595, 639), 'logging.getLogger', 'logging.getLogger', (['"""capture.escalatecapture"""'], {}), "('capture.escalatecapture')\n", (612, 639), False, 'import logging\n'), ((684, 722), 'capture.specify.datapipeline', 'specify.datapipeline', (['rxndict', 'vardict'], {}), '(rxndict, vardict)\n', (704, 722), False, 'from ca... |
""" CSE Partial Factorization and Post-Processing
The following script will perform partial factorization on SymPy expressions,
which should occur before common subexpression elimination (CSE) to prevent the
identification of undesirable patterns, and perform post-processing on the
the resulting replaced/reduced expre... | [
"sympy.Symbol",
"sympy.collect",
"SIMDExprTree.ExprTree",
"sympy.simplify",
"sympy.Mul",
"sympy.preorder_traversal"
] | [((1318, 1353), 'sympy.Symbol', 'sp.Symbol', (["(prefix + '_NegativeOne_')"], {}), "(prefix + '_NegativeOne_')\n", (1327, 1353), True, 'import sympy as sp\n'), ((1454, 1468), 'SIMDExprTree.ExprTree', 'ExprTree', (['expr'], {}), '(expr)\n', (1462, 1468), False, 'from SIMDExprTree import ExprTree\n'), ((1140, 1168), 'sym... |
# coding=utf-8
from aip import AipOcr
import re
opt_aux_word = ['《', '》']
def get_file_content(file):
with open(file, 'rb') as fp:
return fp.read()
def image_to_str(name, client):
image = get_file_content(name)
text_result = client.basicGeneral(image)
print(text_result)
result = get_que... | [
"aip.AipOcr",
"re.sub"
] | [((473, 508), 'aip.AipOcr', 'AipOcr', (['app_id', 'api_key', 'secret_key'], {}), '(app_id, api_key, secret_key)\n', (479, 508), False, 'from aip import AipOcr\n'), ((1145, 1174), 're.sub', 're.sub', (['"""^\\\\d+\\\\.*"""', '""""""', 'word'], {}), "('^\\\\d+\\\\.*', '', word)\n", (1151, 1174), False, 'import re\n')] |
import torch, os
from os import path as osp
from math import ceil
import sys
from yaml import load
from basicsr.data import build_dataloader, build_dataset
from basicsr.utils.options import parse_options
import torch.nn as nn
import torch.nn.functional as F
import torch
from torch.autograd import Variable
import cv2
fr... | [
"copy.deepcopy",
"math.ceil",
"os.path.basename",
"cv2.cvtColor",
"basicsr.data.build_dataset",
"basicsr.archs.edvr_arch.EDVR",
"os.path.exists",
"torch.device",
"basicsr.utils.options.parse_options",
"torch.no_grad",
"os.path.join",
"basicsr.data.build_dataloader",
"torch.cuda.current_devic... | [((2310, 2350), 'basicsr.utils.options.parse_options', 'parse_options', (['root_path'], {'is_train': '(False)'}), '(root_path, is_train=False)\n', (2323, 2350), False, 'from basicsr.utils.options import parse_options\n'), ((2976, 2996), 'basicsr.archs.edvr_arch.EDVR', 'EDVR', ([], {}), '(**model_config)\n', (2980, 2996... |
from pydeck_carto import load_carto_credentials
def test_load_carto_credentials(requests_mock):
requests_mock.post(
"https://auth.carto.com/oauth/token", text='{"access_token":"asdf1234"}'
)
creds = load_carto_credentials("tests/fixtures/mock_credentials.json")
assert creds == {
"apiVe... | [
"pydeck_carto.load_carto_credentials"
] | [((221, 283), 'pydeck_carto.load_carto_credentials', 'load_carto_credentials', (['"""tests/fixtures/mock_credentials.json"""'], {}), "('tests/fixtures/mock_credentials.json')\n", (243, 283), False, 'from pydeck_carto import load_carto_credentials\n')] |
"""Regular few-shot episode sampler.
Author: <NAME> (<EMAIL>)
"""
from __future__ import (absolute_import, division, print_function,
unicode_literals)
from fewshot.data.registry import RegisterSampler
from fewshot.data.samplers.incremental_sampler import IncrementalSampler
@RegisterSampler(... | [
"fewshot.data.registry.RegisterSampler"
] | [((304, 330), 'fewshot.data.registry.RegisterSampler', 'RegisterSampler', (['"""fewshot"""'], {}), "('fewshot')\n", (319, 330), False, 'from fewshot.data.registry import RegisterSampler\n')] |
# -*- coding: utf-8 -*-
"""Wrapper to run RCSCON from the command line.
:copyright: Copyright (c) 2019 RadiaSoft LLC. All Rights Reserved.
:license: http://www.apache.org/licenses/LICENSE-2.0.html
"""
from __future__ import absolute_import, division, print_function
from pykern.pkcollections import PKDict
from pykern.... | [
"sirepo.template.template_common.exec_parameters",
"numpy.asarray",
"numpy.savetxt",
"sirepo.simulation_db.read_json",
"sirepo.template.sdds_util.read_sdds_pages",
"pykern.pkcollections.PKDict"
] | [((569, 602), 'sirepo.template.template_common.exec_parameters', 'template_common.exec_parameters', ([], {}), '()\n', (600, 602), False, 'from sirepo.template import template_common\n'), ((783, 839), 'sirepo.simulation_db.read_json', 'simulation_db.read_json', (['template_common.INPUT_BASE_NAME'], {}), '(template_commo... |
# Generated by Django 2.2.10 on 2020-02-05 01:57
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('dcim', '0092_fix_rack_outer_unit'),
]
operations = [
migrations.AddField(
model_name='device',
name='cpus',
... | [
"django.db.models.PositiveIntegerField",
"django.db.models.PositiveSmallIntegerField"
] | [((331, 386), 'django.db.models.PositiveSmallIntegerField', 'models.PositiveSmallIntegerField', ([], {'blank': '(True)', 'null': '(True)'}), '(blank=True, null=True)\n', (363, 386), False, 'from django.db import migrations, models\n'), ((504, 554), 'django.db.models.PositiveIntegerField', 'models.PositiveIntegerField',... |
from django import forms
from django.core.exceptions import ValidationError
from django_select2.forms import Select2MultipleWidget
from tracker.models import Track, Tracker
class TrackerForm(forms.ModelForm):
class Meta:
model = Tracker
fields = ('nom', 'icone', 'color')
widgets = {
... | [
"django.core.exceptions.ValidationError",
"django.forms.DateTimeField",
"django.forms.TextInput",
"django_select2.forms.Select2MultipleWidget",
"django.forms.HiddenInput",
"tracker.models.Tracker.objects.all"
] | [((444, 512), 'django.forms.DateTimeField', 'forms.DateTimeField', ([], {'required': '(True)', 'input_formats': "['%Y-%m-%dT%H:%M']"}), "(required=True, input_formats=['%Y-%m-%dT%H:%M'])\n", (463, 512), False, 'from django import forms\n'), ((334, 382), 'django.forms.TextInput', 'forms.TextInput', ([], {'attrs': "{'cla... |
import datetime as dt
from datetime import datetime
import numpy as np
import pandas as pd
import sqlalchemy
from sqlalchemy.ext.automap import automap_base
from sqlalchemy.orm import Session
from sqlalchemy import create_engine, func
from sqlalchemy import inspect
from dateutil.relativedelta import relativedelta
fro... | [
"sqlalchemy.func.avg",
"flask.Flask",
"dateutil.relativedelta.relativedelta",
"sqlalchemy.orm.Session",
"flask.jsonify",
"datetime.datetime.strptime",
"sqlalchemy.func.min",
"sqlalchemy.func.count",
"sqlalchemy.create_engine",
"sqlalchemy.ext.automap.automap_base",
"sqlalchemy.func.max"
] | [((360, 410), 'sqlalchemy.create_engine', 'create_engine', (['"""sqlite:///Resources/hawaii.sqlite"""'], {}), "('sqlite:///Resources/hawaii.sqlite')\n", (373, 410), False, 'from sqlalchemy import create_engine, func\n'), ((467, 481), 'sqlalchemy.ext.automap.automap_base', 'automap_base', ([], {}), '()\n', (479, 481), F... |
import seaborn as sns
import matplotlib.pyplot as plt
import matplotlib.patches as mpatches
import pandas as pd
import os
dam_cols_ap2 = ['co2_dam', 'so2_dam_ap2', 'nox_dam_ap2', 'pm25_dam_ap2']
dam_cols_eas = ['co2_dam', 'so2_dam_eas', 'nox_dam_eas', 'pm25_dam_eas']
# Plotting total damage stacked plot
def plot_tota... | [
"matplotlib.pyplot.tight_layout",
"seaborn.set",
"os.makedirs",
"matplotlib.patches.Rectangle",
"os.path.exists",
"pandas.CategoricalDtype",
"seaborn.color_palette",
"matplotlib.patches.Patch",
"matplotlib.pyplot.gcf",
"os.path.join",
"seaborn.FacetGrid"
] | [((465, 509), 'seaborn.set', 'sns.set', ([], {'style': '"""whitegrid"""', 'color_codes': '(True)'}), "(style='whitegrid', color_codes=True)\n", (472, 509), True, 'import seaborn as sns\n'), ((1239, 1295), 'seaborn.FacetGrid', 'sns.FacetGrid', ([], {'data': 'df_cum', 'col': '"""spat"""', 'size': '(3)', 'aspect': '(1)'})... |
# Main.py - Pixels Fighting #
# Author: <NAME> #
# ---------------------#
# Imports #
import pygame
from pygame.locals import *
from helpers import *
import random
import numpy as np
import time
# ---------------------#
# Initialize number of rows/columns
INT = 100
INT_SQ = INT*INT
# Initialize size of arrays
SIZE... | [
"random.randint",
"pygame.Surface",
"pygame.event.get",
"pygame.display.set_mode",
"numpy.zeros",
"numpy.ones",
"pygame.init",
"time.sleep",
"pygame.display.update",
"pygame.font.Font",
"pygame.time.Clock",
"numpy.concatenate"
] | [((346, 359), 'pygame.init', 'pygame.init', ([], {}), '()\n', (357, 359), False, 'import pygame\n'), ((408, 468), 'pygame.display.set_mode', 'pygame.display.set_mode', (['(80 + INT * SIZE, 160 + INT * SIZE)'], {}), '((80 + INT * SIZE, 160 + INT * SIZE))\n', (431, 468), False, 'import pygame\n'), ((483, 502), 'pygame.ti... |
#!/usr/bin/env python3
# Copyright (c) 2019-2021, Dr.-Ing. <NAME>
# All rights reserved.
# This source code is licensed under the BSD-style license found in the
# LICENSE file in the root directory of this source tree.
import sys
import sympy as sp
# coronary model with a 3-element Windkessel (ZCR, proximal part) i... | [
"sympy.Symbol",
"sys.stdout.flush"
] | [((2717, 2744), 'sympy.Symbol', 'sp.Symbol', (['"""q_corp_sys_in_"""'], {}), "('q_corp_sys_in_')\n", (2726, 2744), True, 'import sympy as sp\n'), ((2770, 2794), 'sympy.Symbol', 'sp.Symbol', (['"""q_corp_sys_"""'], {}), "('q_corp_sys_')\n", (2779, 2794), True, 'import sympy as sp\n'), ((2820, 2844), 'sympy.Symbol', 'sp.... |
import genism
from genism.models.doc2vec import Doc2Vec , TaggedDocument
from sklearn.metrics.pairwise import cosine_similarity
f= open('dataset.txt','r')
print(f.read)
corpus = [
"This is first Sentence",
"This is second Sentence",
"This is third Sentence",
"This is fourth Sentence",
... | [
"genism.models.doc2vec.Doc2Vec",
"sklearn.metrics.pairwise.cosine_similarity",
"genism.models.doc2vec.TaggedDocument"
] | [((431, 499), 'genism.models.doc2vec.Doc2Vec', 'Doc2Vec', (['documents'], {'vector_size': '(10)', 'window': '(2)', 'min_count': '(1)', 'workers': '(4)'}), '(documents, vector_size=10, window=2, min_count=1, workers=4)\n', (438, 499), False, 'from genism.models.doc2vec import Doc2Vec, TaggedDocument\n'), ((365, 389), 'g... |
from helper import unittest, PillowTestCase, hopper
from PIL import Image, BmpImagePlugin
import io
class TestFileBmp(PillowTestCase):
def roundtrip(self, im):
outfile = self.tempfile("temp.bmp")
im.save(outfile, 'BMP')
reloaded = Image.open(outfile)
reloaded.load()
sel... | [
"io.BytesIO",
"helper.unittest.main",
"PIL.Image.open",
"PIL.BmpImagePlugin.DibImageFile",
"helper.hopper"
] | [((2252, 2267), 'helper.unittest.main', 'unittest.main', ([], {}), '()\n', (2265, 2267), False, 'from helper import unittest, PillowTestCase, hopper\n'), ((265, 284), 'PIL.Image.open', 'Image.open', (['outfile'], {}), '(outfile)\n', (275, 284), False, 'from PIL import Image, BmpImagePlugin\n'), ((914, 926), 'io.BytesIO... |
from keras.layers.convolutional import Convolution2D
from keras import backend as K
import tensorflow as tf
permutation = [[1, 0], [0, 0], [0, 1], [2, 0], [1, 1], [0, 2], [2, 1], [2, 2], [1, 2]]
def shift_rotate(w, shift=1):
shape = w.get_shape()
for i in range(shift):
w = tf.reshape(tf.gather_nd(w,... | [
"tensorflow.gather_nd",
"keras.backend.reshape",
"keras.backend.conv2d",
"keras.backend.max"
] | [((871, 888), 'keras.backend.max', 'K.max', (['outputs', '(0)'], {}), '(outputs, 0)\n', (876, 888), True, 'from keras import backend as K\n'), ((1805, 1822), 'keras.backend.max', 'K.max', (['outputs', '(0)'], {}), '(outputs, 0)\n', (1810, 1822), True, 'from keras import backend as K\n'), ((305, 333), 'tensorflow.gather... |
import kahoot
import threading
import utils
class Flooder:
def __init__(self, gamepin, botname, amount, delay, window):
self.gamepin = gamepin
self.botname = botname
self.amount = amount
self.delay = delay
self.window = window
self.suffix = 0
self.bot = kaho... | [
"utils.Notifier",
"kahoot.client"
] | [((316, 331), 'kahoot.client', 'kahoot.client', ([], {}), '()\n', (329, 331), False, 'import kahoot\n'), ((653, 669), 'utils.Notifier', 'utils.Notifier', ([], {}), '()\n', (667, 669), False, 'import utils\n')] |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import json as jsn
import os
import sys
import unicodedata
from utils import six
def read_json(filename):
def _convert_from_unicode(data):
new_data = dict()
for name, value in six.iterite... | [
"unicodedata.normalize",
"utils.six.iteritems",
"os.makedirs",
"os.path.dirname",
"os.path.exists",
"utils.six.itersorteditems",
"os.path.splitext",
"sys.exc_info"
] | [((2698, 2723), 'os.path.dirname', 'os.path.dirname', (['filename'], {}), '(filename)\n', (2713, 2723), False, 'import os\n'), ((309, 328), 'utils.six.iteritems', 'six.iteritems', (['data'], {}), '(data)\n', (322, 328), False, 'from utils import six\n'), ((2047, 2073), 'utils.six.itersorteditems', 'six.itersorteditems'... |
import json
import numpy as np
import os
import pkg_resources
import re
from typing import Any, AnyStr, Dict, List, Optional, Tuple
def load_peripheral(pdata, templates=None):
"""Load a peripheral from a dict
This loads a peripheral with support for templates, as used in the board
definition file format
... | [
"pkg_resources.resource_listdir",
"json.loads",
"os.path.basename",
"os.path.isdir",
"os.path.isfile",
"numpy.sin",
"numpy.array",
"pkg_resources.resource_string",
"numpy.cos",
"numpy.dot",
"os.path.expanduser",
"os.listdir"
] | [((8557, 8606), 'os.path.expanduser', 'os.path.expanduser', (['"""~/.config/purpledrop/boards"""'], {}), "('~/.config/purpledrop/boards')\n", (8575, 8606), False, 'import os\n'), ((8627, 8681), 'pkg_resources.resource_listdir', 'pkg_resources.resource_listdir', (['"""purpledrop"""', '"""boards"""'], {}), "('purpledrop'... |
from multiprocessing import Queue, Process
from threading import Thread
import numpy as np
import utils
from agent import PPOAgent
from policy import get_policy
from worker import Worker
import environments
class SimpleMaster:
def __init__(self, env_producer):
self.env_name = env_producer.get_env_name()... | [
"policy.get_policy",
"environments.get_config",
"utils.create_session",
"tensorflow.train.Saver",
"tensorflow.Summary",
"tensorflow.get_collection",
"tensorflow.global_variables_initializer",
"worker.Worker",
"tensorflow.variable_scope",
"tensorflow.summary.FileWriter",
"numpy.mean",
"agent.PP... | [((8593, 8631), 'worker.Worker', 'Worker', (['env_producer', 'i', 'q', 'w_in_queue'], {}), '(env_producer, i, q, w_in_queue)\n', (8599, 8631), False, 'from worker import Worker\n'), ((343, 381), 'environments.get_config', 'environments.get_config', (['self.env_name'], {}), '(self.env_name)\n', (366, 381), False, 'impor... |
import os
from flask import abort
from flask import request
from flask import send_from_directory
from app import app
from app.main.RequestParameters import RequestParameters
from app.main.Session import Session
from app.main.Session import Status
from app.main.exceptions.exceptions import InvalidSessionIdError
API_... | [
"app.app.route",
"app.main.Session.Session",
"flask.abort",
"app.main.RequestParameters.RequestParameters.parse"
] | [((655, 712), 'app.app.route', 'app.route', (["(API_PATH_PREFIX + '/process')"], {'methods': "['POST']"}), "(API_PATH_PREFIX + '/process', methods=['POST'])\n", (664, 712), False, 'from app import app\n'), ((1175, 1213), 'app.app.route', 'app.route', (["(API_PATH_PREFIX + '/health')"], {}), "(API_PATH_PREFIX + '/health... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""Tests for the Windows Event Log message resource extractor class."""
import unittest
from dfvfs.helpers import fake_file_system_builder
from dfvfs.helpers import windows_path_resolver
from dfvfs.lib import definitions as dfvfs_definitions
from dfvfs.path import factory... | [
"unittest.main",
"dfvfs.helpers.windows_path_resolver.WindowsPathResolver",
"winevtrc.resources.EventLogProvider",
"dfvfs.helpers.fake_file_system_builder.FakeFileSystemBuilder",
"winevtrc.extractor.EventMessageStringRegistryFileReader",
"tests.test_lib.skipUnlessHasTestFile",
"dfvfs.path.factory.Factor... | [((2358, 2409), 'tests.test_lib.skipUnlessHasTestFile', 'shared_test_lib.skipUnlessHasTestFile', (["['SOFTWARE']"], {}), "(['SOFTWARE'])\n", (2395, 2409), True, 'from tests import test_lib as shared_test_lib\n'), ((2411, 2460), 'tests.test_lib.skipUnlessHasTestFile', 'shared_test_lib.skipUnlessHasTestFile', (["['SYSTEM... |
# Copyright (c) Facebook, Inc. and its affiliates.
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import os
import rospkg
import threading
import yaml
from copy import deepcopy
import message_filters
import numpy as np
import pyrobot.utils.... | [
"sys.path.append",
"numpy.stack",
"cv_bridge.CvBridge",
"sys.path.remove",
"rospy.Subscriber",
"copy.deepcopy",
"numpy.multiply",
"rospy.logerr",
"threading.RLock",
"message_filters.ApproximateTimeSynchronizer",
"numpy.ones",
"numpy.linalg.inv",
"numpy.array",
"message_filters.Subscriber",... | [((627, 652), 'sys.path.append', 'sys.path.append', (['ros_path'], {}), '(ros_path)\n', (642, 652), False, 'import sys\n'), ((586, 611), 'sys.path.remove', 'sys.path.remove', (['ros_path'], {}), '(ros_path)\n', (601, 611), False, 'import sys\n'), ((1101, 1111), 'cv_bridge.CvBridge', 'CvBridge', ([], {}), '()\n', (1109,... |
import matplotlib.pyplot as plt
import numpy as np
from typing import List, Union
from ..storage import History
from .util import to_lists_or_default
def plot_sample_numbers(
histories: Union[List, History],
labels: Union[List, str] = None,
rotation: int = 0,
title: str = "Total requi... | [
"numpy.zeros",
"numpy.sum",
"matplotlib.pyplot.subplots",
"numpy.arange"
] | [((1238, 1252), 'matplotlib.pyplot.subplots', 'plt.subplots', ([], {}), '()\n', (1250, 1252), True, 'import matplotlib.pyplot as plt\n'), ((1682, 1706), 'numpy.zeros', 'np.zeros', (['(n_pop, n_run)'], {}), '((n_pop, n_run))\n', (1690, 1706), True, 'import numpy as np\n'), ((2019, 2035), 'numpy.arange', 'np.arange', (['... |
# Copyright 2015 The Chromium Authors. All rights reserved.
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""
Manages a debugging session with GDB.
This module is meant to be imported from inside GDB. Once loaded, the
|DebugSession| attaches GDB to a running Moj... | [
"glob.glob",
"os.path.join",
"urllib2.urlopen",
"subprocess.check_call",
"sys.path.append",
"os.path.abspath",
"traceback.print_exc",
"os.path.exists",
"gdb.newest_frame",
"shutil.copyfileobj",
"subprocess.Popen",
"subprocess.check_output",
"android_gdb.remote_file_connection.RemoteFileConne... | [((1069, 1105), 'gdb.execute', 'gdb.execute', (['command'], {'to_string': '(True)'}), '(command, to_string=True)\n', (1080, 1105), False, 'import gdb\n'), ((956, 975), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (973, 975), False, 'import logging\n'), ((2991, 3031), 'android_gdb.remote_file_connection.R... |
import setuptools
with open("README.md", "r") as fh:
long_description = fh.read()
setuptools.setup(
name="norma43parser",
version="1.1.2",
license="MIT",
author="<NAME>",
author_email="<EMAIL>",
description="Parser for Bank Account information files formatted in Norma 43",
long_descrip... | [
"setuptools.find_packages"
] | [((459, 485), 'setuptools.find_packages', 'setuptools.find_packages', ([], {}), '()\n', (483, 485), False, 'import setuptools\n')] |
"""
Search for a good model for the
[MNIST](https://keras.io/datasets/#mnist-database-of-handwritten-digits) dataset.
"""
import argparse
import os
import autokeras as ak
import tensorflow_cloud as tfc
from tensorflow.keras.datasets import mnist
parser = argparse.ArgumentParser(description="Model save path arguments... | [
"argparse.ArgumentParser",
"autokeras.ImageClassifier",
"tensorflow.keras.datasets.mnist.load_data",
"os.path.join",
"tensorflow_cloud.run"
] | [((258, 323), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Model save path arguments."""'}), "(description='Model save path arguments.')\n", (281, 323), False, 'import argparse\n'), ((437, 548), 'tensorflow_cloud.run', 'tfc.run', ([], {'chief_config': "tfc.COMMON_MACHINE_CONFIGS['V100_... |
from flask_restful import Resource, reqparse, request
from flask_restful import fields, marshal_with, marshal
from sqlalchemy.exc import IntegrityError
from sqlalchemy import or_, and_, text
from flask_jwt_extended import jwt_required
from models.course import Course
from app import db
from utils.util import max_res
... | [
"utils.util.max_res",
"models.course.Course.query.filter",
"sqlalchemy.text",
"app.db.session.commit",
"models.course.Course",
"flask_restful.marshal",
"models.course.Course.find_by_id"
] | [((1993, 2007), 'models.course.Course', 'Course', ([], {}), '(**args)\n', (1999, 2007), False, 'from models.course import Course\n'), ((2247, 2275), 'models.course.Course.find_by_id', 'Course.find_by_id', (['course_id'], {}), '(course_id)\n', (2264, 2275), False, 'from models.course import Course\n'), ((2500, 2519), 'a... |
import random
import math
import numpy as np
import matplotlib.pyplot as plt
# Calculating Pi using Monte Carlo algorithm.
def montecarlo_pi(times:int):
inside = 0
total = times
for i in range(times):
x_i = random.random()
y_i = random.random()
delta = x_i ** 2 + y_i **2 - 1
... | [
"matplotlib.pyplot.show",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.yticks",
"random.random",
"matplotlib.pyplot.figure",
"numpy.arange",
"matplotlib.pyplot.ylabel",
"numpy.log10",
"matplotlib.pyplot.xlabel"
] | [((816, 828), 'matplotlib.pyplot.figure', 'plt.figure', ([], {}), '()\n', (826, 828), True, 'import matplotlib.pyplot as plt\n'), ((927, 978), 'matplotlib.pyplot.plot', 'plt.plot', (['x_list', 'pi_', '"""b.-"""'], {'label': '"""approximation"""'}), "(x_list, pi_, 'b.-', label='approximation')\n", (935, 978), True, 'imp... |
# Licensed under a 3-clause BSD style license - see LICENSE.rst
#
# TODO: Remove this when https://github.com/parejkoj/astropy/tree/luptonRGB
# is in Astropy.
"""
Combine 3 images to produce a properly-scaled RGB image following Lupton et al. (2004).
For details, see : http://adsabs.harvard.edu/abs/2004PASP..116... | [
"matplotlib.pyplot.title",
"matplotlib.pyplot.show",
"matplotlib.pyplot.imshow",
"numpy.iinfo",
"numpy.errstate",
"numpy.where",
"numpy.array",
"numpy.arcsinh"
] | [((1660, 1699), 'numpy.array', 'np.array', (['intensity'], {'dtype': 'imageR.dtype'}), '(intensity, dtype=imageR.dtype)\n', (1668, 1699), True, 'import numpy as np\n'), ((16626, 16682), 'matplotlib.pyplot.imshow', 'plt.imshow', (['rgb'], {'interpolation': '"""nearest"""', 'origin': '"""lower"""'}), "(rgb, interpolation... |
import os
import re
from mendeley.response import SessionResponseObject
class File(SessionResponseObject):
"""
A file attached to a document.
.. attribute:: id
.. attribute:: size
.. attribute:: file_name
.. attribute:: mime_type
.. attribute:: filehash
.. attribute:: download_url
... | [
"os.path.join",
"re.compile"
] | [((405, 436), 're.compile', 're.compile', (['"""filename="(\\\\S+)\\""""'], {}), '(\'filename="(\\\\S+)"\')\n', (415, 436), False, 'import re\n'), ((1789, 1822), 'os.path.join', 'os.path.join', (['directory', 'filename'], {}), '(directory, filename)\n', (1801, 1822), False, 'import os\n')] |
import tensorflow as tf
from . tf_net import TFNet
class Resnet(TFNet):
"""
"""
def __init__(self, data, data_format, num_classes, is_train=True):
dtype = data.dtype.base_dtype
super(Resnet, self).__init__(dtype, data_format, train=is_train)
self.net_out = tf.identity(data, name='da... | [
"tensorflow.identity"
] | [((294, 324), 'tensorflow.identity', 'tf.identity', (['data'], {'name': '"""data"""'}), "(data, name='data')\n", (305, 324), True, 'import tensorflow as tf\n')] |
import copy
import typing
import splendor_sim.interfaces.action.i_action as i_action
import splendor_sim.interfaces.card.i_card as i_card
import splendor_sim.interfaces.coin.i_coin_type as i_coin_type
import splendor_sim.interfaces.game_state.i_game_state as i_game_state
import splendor_sim.interfaces.player.i_player ... | [
"copy.copy"
] | [((721, 737), 'copy.copy', 'copy.copy', (['coins'], {}), '(coins)\n', (730, 737), False, 'import copy\n')] |
import re
HUEVELS = {
'у': 'хую',
'У': 'хую',
'е': 'хуе',
'Е': 'хуе',
'ё': 'хуё',
'Ё': 'хуё',
'а': 'хуя',
'А': 'хуя',
'о': 'хуё',
'О': 'хуё',
'э': 'хуе',
'Э': 'хуе',
'я': 'хуя',
'Я': 'хуя',
'и': 'хуи',
'И': 'хуи',
'ы': 'хуы',
'Ы': 'хуы',
'ю': ... | [
"re.search"
] | [((748, 794), 're.search', 're.search', (['"""[уеёыаоэяию]"""', 'word', 're.IGNORECASE'], {}), "('[уеёыаоэяию]', word, re.IGNORECASE)\n", (757, 794), False, 'import re\n')] |
import model
import tensorflow as tf
import utils
def train(target,
num_param_servers,
is_chief,
lstm_size=64,
input_filenames=None,
sentence_length=128,
vocab_size=2**15,
learning_rate=0.01,
output_dir=None,
batch_size=1024,
... | [
"model.get_inputs",
"utils.base_parser",
"tensorflow.contrib.learn.train",
"model.BasicRegressionLSTM",
"tensorflow.Graph",
"tensorflow.train.replica_device_setter"
] | [((386, 396), 'tensorflow.Graph', 'tf.Graph', ([], {}), '()\n', (394, 396), True, 'import tensorflow as tf\n'), ((869, 1037), 'tensorflow.contrib.learn.train', 'tf.contrib.learn.train', (['graph', 'output_dir', 'lstm.train_op', 'lstm.loss'], {'global_step_tensor': 'lstm.global_step', 'supervisor_is_chief': 'is_chief', ... |
"""The main Klaxer server"""
import logging
import json
import hug
from falcon import HTTP_400, HTTP_500
from klaxer.rules import Rules
from klaxer.errors import AuthorizationError, NoRouteFoundError, ServiceNotDefinedError
from klaxer.lib import classify, enrich, filtered, route, send, validate
from klaxer.models i... | [
"klaxer.lib.send",
"klaxer.rules.Rules",
"hug.get",
"hug.post",
"logging.exception",
"klaxer.models.Alert.from_service",
"klaxer.users.is_existing_user",
"hug.startup",
"klaxer.users.create_user",
"klaxer.lib.filtered",
"klaxer.lib.validate",
"klaxer.users.bootstrap"
] | [((467, 474), 'klaxer.rules.Rules', 'Rules', ([], {}), '()\n', (472, 474), False, 'from klaxer.rules import Rules\n'), ((477, 518), 'hug.post', 'hug.post', (['"""/alert/{service_name}/{token}"""'], {}), "('/alert/{service_name}/{token}')\n", (485, 518), False, 'import hug\n'), ((2101, 2127), 'hug.post', 'hug.post', (['... |
# Copyright 2016, Google 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 copyright
# notice, this list of conditions and the f... | [
"logging.error",
"argparse.ArgumentParser",
"logging.basicConfig",
"logging.info",
"twisted.internet.reactor.run",
"twisted.internet.endpoints.TCP4ServerEndpoint"
] | [((2906, 3030), 'logging.basicConfig', 'logging.basicConfig', ([], {'format': '"""%(levelname) -10s %(asctime)s %(module)s:%(lineno)s | %(message)s"""', 'level': 'logging.INFO'}), "(format=\n '%(levelname) -10s %(asctime)s %(module)s:%(lineno)s | %(message)s',\n level=logging.INFO)\n", (2925, 3030), False, 'impor... |
"""This module implements the QFactor class."""
from __future__ import annotations
import logging
from typing import Any
from typing import TYPE_CHECKING
import numpy as np
import numpy.typing as npt
from bqskitrs import QFactorInstantiatorNative
from bqskit.ir.opt.instantiater import Instantiater
from bqskit.qis.st... | [
"logging.getLogger"
] | [((538, 565), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (555, 565), False, 'import logging\n')] |
import tensorflow as tf
def create_pb_model(pb_path, sz, bs):
def load_graph(frozen_graph_filename):
# We load the protobuf file from the disk and parse it to retrieve the
# unserialized graph_def
with tf.compat.v1.gfile.GFile(frozen_graph_filename, "rb") as f:
graph_def = tf.co... | [
"tensorflow.compat.v1.wrap_function",
"tensorflow.compat.v1.gfile.GFile",
"tensorflow.keras.models.Model",
"tensorflow.nest.map_structure",
"tensorflow.keras.layers.Input",
"tensorflow.Graph",
"tensorflow.import_graph_def",
"tensorflow.compat.v1.GraphDef",
"tensorflow.keras.layers.Lambda",
"tensor... | [((1285, 1317), 'tensorflow.keras.layers.Lambda', 'tf.keras.layers.Lambda', (['model_fn'], {}), '(model_fn)\n', (1307, 1317), True, 'import tensorflow as tf\n'), ((1330, 1370), 'tensorflow.keras.layers.Input', 'tf.keras.layers.Input', (['sz'], {'batch_size': 'bs'}), '(sz, batch_size=bs)\n', (1351, 1370), True, 'import ... |
"""
Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
SPDX-License-Identifier: MIT-0
"""
from urllib.parse import urlparse
from cfn_policy_validator.application_error import ApplicationError
from cfn_policy_validator.parsers.output import Policy, Resource
class SqsQueuePolicyParser:
""" AWS::SQS... | [
"cfn_policy_validator.application_error.ApplicationError",
"cfn_policy_validator.parsers.output.Policy",
"urllib.parse.urlparse",
"cfn_policy_validator.parsers.output.Resource"
] | [((713, 728), 'urllib.parse.urlparse', 'urlparse', (['queue'], {}), '(queue)\n', (721, 728), False, 'from urllib.parse import urlparse\n'), ((976, 1014), 'cfn_policy_validator.parsers.output.Policy', 'Policy', (['"""QueuePolicy"""', 'policy_document'], {}), "('QueuePolicy', policy_document)\n", (982, 1014), False, 'fro... |
import torch
import torch.nn as nn
from torch.functional import F
from utils import *
class SequenceModel(nn.Module):
"""docstring for SequenceModel"""
def __init__(self, input_size, hidden_size, n_layers, **kwargs):
super(SequenceModel, self).__init__()
self.rnn = nn.LSTM(input_size, hidden_size, n_layers, ... | [
"torch.nn.LSTM",
"torch.nn.Linear"
] | [((277, 329), 'torch.nn.LSTM', 'nn.LSTM', (['input_size', 'hidden_size', 'n_layers'], {}), '(input_size, hidden_size, n_layers, **kwargs)\n', (284, 329), True, 'import torch.nn as nn\n'), ((472, 499), 'torch.nn.Linear', 'nn.Linear', (['hidden_size', '(128)'], {}), '(hidden_size, 128)\n', (481, 499), True, 'import torch... |
import pytest
import numpy as np
import pandas as pd
from .stats import IV, WOE, gini, gini_cond, entropy_cond, quality, _IV, VIF
np.random.seed(1)
feature = np.random.rand(500)
target = np.random.randint(2, size = 500)
A = np.random.randint(100, size = 500)
B = np.random.randint(100, size = 500)
mask = np.random.r... | [
"pandas.DataFrame",
"numpy.random.seed",
"numpy.isnan",
"numpy.random.randint",
"numpy.array",
"numpy.random.rand"
] | [((133, 150), 'numpy.random.seed', 'np.random.seed', (['(1)'], {}), '(1)\n', (147, 150), True, 'import numpy as np\n'), ((162, 181), 'numpy.random.rand', 'np.random.rand', (['(500)'], {}), '(500)\n', (176, 181), True, 'import numpy as np\n'), ((191, 221), 'numpy.random.randint', 'np.random.randint', (['(2)'], {'size': ... |
# *****************************************************************************
#
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this fi... | [
"subprocess.Popen",
"paramiko.SSHClient",
"os.getcwd",
"six.add_metaclass",
"paramiko.AutoAddPolicy",
"time.sleep",
"dlab_core.domain.helper.break_after",
"shutil.copyfile",
"os.chdir"
] | [((1183, 1213), 'six.add_metaclass', 'six.add_metaclass', (['abc.ABCMeta'], {}), '(abc.ABCMeta)\n', (1200, 1213), False, 'import six\n'), ((4171, 4187), 'dlab_core.domain.helper.break_after', 'break_after', (['(180)'], {}), '(180)\n', (4182, 4187), False, 'from dlab_core.domain.helper import break_after\n'), ((2424, 25... |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'acq4/modules/MultiPatch/pipetteTemplate.ui'
#
# Created by: PyQt5 UI code generator 5.8.2
#
# WARNING! All changes made in this file will be lost!
from PyQt5 import QtCore, QtGui, QtWidgets
class Ui_PipetteControl(object):
def setupUi(... | [
"PyQt5.QtWidgets.QComboBox",
"PyQt5.QtWidgets.QSizePolicy",
"PyQt5.QtWidgets.QWidget",
"PyQt5.QtWidgets.QGridLayout",
"PyQt5.QtWidgets.QPushButton",
"PyQt5.QtWidgets.QHBoxLayout"
] | [((458, 550), 'PyQt5.QtWidgets.QSizePolicy', 'QtWidgets.QSizePolicy', (['QtWidgets.QSizePolicy.Expanding', 'QtWidgets.QSizePolicy.Expanding'], {}), '(QtWidgets.QSizePolicy.Expanding, QtWidgets.\n QSizePolicy.Expanding)\n', (479, 550), False, 'from PyQt5 import QtCore, QtGui, QtWidgets\n'), ((791, 828), 'PyQt5.QtWidg... |
import sys
import string
import datetime
import logging
from nltk.tokenize import word_tokenize
from transformers import BertTokenizer
logger = logging.getLogger(__name__)
def decode_preprocessing(dataset, output_file, tokenizer, max_len, mode):
with open(dataset, 'r') as fin:
input_lines = fin.readl... | [
"datetime.datetime.now",
"logging.getLogger"
] | [((145, 172), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (162, 172), False, 'import logging\n'), ((343, 366), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (364, 366), False, 'import datetime\n'), ((1844, 1867), 'datetime.datetime.now', 'datetime.datetime.now', (... |
import socket
class VMUDPBase:
def __init__(self):
self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
self.sock.settimeout(2.0)
| [
"socket.socket"
] | [((77, 125), 'socket.socket', 'socket.socket', (['socket.AF_INET', 'socket.SOCK_DGRAM'], {}), '(socket.AF_INET, socket.SOCK_DGRAM)\n', (90, 125), False, 'import socket\n')] |
# -*- coding: utf-8 -*-
# Generated by Django 1.11.1 on 2017-06-10 17:25
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('locations', '0001_initial'),
]
operations = [
migrations.AlterField(
... | [
"django.db.models.CharField"
] | [((409, 673), 'django.db.models.CharField', 'models.CharField', ([], {'help_text': '"""Determine the character position definition where alpha=\'\\\\a\', numeric=\'\\\\d\', punctuation=\'\\\\p\', or any hard coded character. ex. \\\\a\\\\d\\\\d\\\\d could be B001 or \\\\a@\\\\d\\\\d could be D@99."""', 'max_length': '(... |
# This file will implement images
import os
from skimage.io import imsave
def visualize_image(image, image_name):
"""Given an image, will save the image to the figures directory
Parameters:
image: a [N,M,3] tensor
filename (str): name of the image
"""
image_path = os.path.join("../fi... | [
"os.path.join",
"skimage.io.imsave"
] | [((301, 348), 'os.path.join', 'os.path.join', (['"""../figures"""', "(image_name + '.jpg')"], {}), "('../figures', image_name + '.jpg')\n", (313, 348), False, 'import os\n'), ((376, 401), 'skimage.io.imsave', 'imsave', (['image_path', 'image'], {}), '(image_path, image)\n', (382, 401), False, 'from skimage.io import im... |
import pickle
import numpy as np
with open('data/fake.pkl', 'rb') as f:
points, labels, scores, keys = pickle.load(f)
with open('data/fake_gt.pkl', 'rb') as f:
gt_points, gt_bboxes, gt_labels, gt_areas, gt_crowdeds = pickle.load(f)
gt_points_yx = []
gt_point_is_valids = []
for gt_point in gt_points:
gt_... | [
"numpy.savez",
"pickle.load"
] | [((700, 884), 'numpy.savez', 'np.savez', (['"""eval_point_coco_dataset_2019_02_18.npz"""'], {'points': 'gt_points_yx', 'is_valids': 'gt_point_is_valids', 'bboxes': 'gt_bboxes', 'labels': 'gt_labels', 'areas': 'gt_areas', 'crowdeds': 'gt_crowdeds'}), "('eval_point_coco_dataset_2019_02_18.npz', points=gt_points_yx,\n ... |
import pytest
from reggol import strip_prefix
from testfixtures import LogCapture
from ravestate import *
DEFAULT_MODULE_NAME = 'module'
DEFAULT_PROPERTY_NAME = 'property'
DEFAULT_PROPERTY_ID = f"{DEFAULT_MODULE_NAME}:{DEFAULT_PROPERTY_NAME}"
DEFAULT_PROPERTY_VALUE = 'Kruder'
DEFAULT_PROPERTY_CHANGED = f"{DEFAULT_PR... | [
"ravestate_nlp.Triple"
] | [((3237, 3279), 'ravestate_nlp.Triple', 'Triple', (['token_mock', 'token_mock', 'token_mock'], {}), '(token_mock, token_mock, token_mock)\n', (3243, 3279), False, 'from ravestate_nlp import Triple\n')] |
from scipy.ndimage.filters import maximum_filter as _max_filter
from scipy.ndimage.morphology import binary_erosion as _binary_erosion
from skimage.feature import peak_local_max
def detect_skimage(image, neighborhood, threshold=1e-12):
"""Detect peaks using a local maximum filter (via skimage)
Parameters
... | [
"scipy.ndimage.filters.maximum_filter",
"skimage.feature.peak_local_max"
] | [((839, 928), 'skimage.feature.peak_local_max', 'peak_local_max', (['image'], {'footprint': 'neighborhood', 'threshold_abs': 'threshold', 'indices': '(False)'}), '(image, footprint=neighborhood, threshold_abs=threshold,\n indices=False)\n', (853, 928), False, 'from skimage.feature import peak_local_max\n'), ((1856, ... |
# -*- coding: utf-8 -*-
import random
"""
折半插入排序 O(n) = n^2
"""
class BinaryInsertion(object):
def __init__(self, original_list):
self.original_list = original_list
def sort(self):
length = len(self.original_list)
for i in range(1, length):
self.binary(start=0, end=i-1, cu... | [
"random.randint"
] | [((1127, 1149), 'random.randint', 'random.randint', (['(0)', '(100)'], {}), '(0, 100)\n', (1141, 1149), False, 'import random\n')] |
"""models.py - Contains class definitions for Datastore entities
used by the Concentration Game API. Definitions for User, Game, and
Score classes, with associated methods. Additionally, contains
definitions for Forms used in transmitting messages to users."""
### Imports
import random
import pickle
from datetime im... | [
"google.appengine.ext.ndb.FloatProperty",
"protorpc.messages.FloatField",
"datetime.date.today",
"protorpc.messages.IntegerField",
"protorpc.messages.StringField",
"game.constructBoard",
"google.appengine.ext.ndb.PickleProperty",
"google.appengine.ext.ndb.IntegerProperty",
"google.appengine.ext.ndb.... | [((568, 601), 'google.appengine.ext.ndb.StringProperty', 'ndb.StringProperty', ([], {'required': '(True)'}), '(required=True)\n', (586, 601), False, 'from google.appengine.ext import ndb\n'), ((614, 634), 'google.appengine.ext.ndb.StringProperty', 'ndb.StringProperty', ([], {}), '()\n', (632, 634), False, 'from google.... |
import os
import sys
import shutil
from io import BytesIO
from functools import wraps
from textwrap import dedent
from random import choice, shuffle
from collections import defaultdict
import urllib.request
required = ["locmaker.py","locmaker_README.txt","Run.cmd"]
for item in required:
print('Downloading '+ite... | [
"os.path.isfile"
] | [((531, 551), 'os.path.isfile', 'os.path.isfile', (['item'], {}), '(item)\n', (545, 551), False, 'import os\n')] |
'''
This contains tests for the parse and get_bad_paths methods.
'''
import unittest
import parser
class TestParser(unittest.TestCase):
'''
This contains tests for the parse and get_bad_paths methods.
'''
def test_empty(self):
''' Parse an empty string.'''
self.assertEqual(par... | [
"unittest.main",
"parser.parse",
"parser.get_bad_paths"
] | [((2541, 2556), 'unittest.main', 'unittest.main', ([], {}), '()\n', (2554, 2556), False, 'import unittest\n'), ((317, 333), 'parser.parse', 'parser.parse', (['""""""'], {}), "('')\n", (329, 333), False, 'import parser\n'), ((447, 480), 'parser.parse', 'parser.parse', (['"""Disallow: /stuff/"""'], {}), "('Disallow: /stu... |
from datetime import datetime
time_now = datetime.now()
print(time_now.strftime('%B/%d/%Y:%H/%M')) | [
"datetime.datetime.now"
] | [((42, 56), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (54, 56), False, 'from datetime import datetime\n')] |
"""
Test module for the Fedex Tools.
"""
import unittest
import logging
import sys
sys.path.insert(0, '..')
import fedex.config
import fedex.services.ship_service as service # Any request object will do.
import fedex.tools.conversion
logging.getLogger('suds').setLevel(logging.ERROR)
logging.getLogger('fedex').setL... | [
"unittest.main",
"logging.basicConfig",
"sys.path.insert",
"fedex.services.ship_service.FedexProcessShipmentRequest",
"logging.getLogger"
] | [((85, 109), 'sys.path.insert', 'sys.path.insert', (['(0)', '""".."""'], {}), "(0, '..')\n", (100, 109), False, 'import sys\n'), ((1540, 1598), 'logging.basicConfig', 'logging.basicConfig', ([], {'stream': 'sys.stdout', 'level': 'logging.INFO'}), '(stream=sys.stdout, level=logging.INFO)\n', (1559, 1598), False, 'import... |
from .algo import Algo
from .algo_code import AlgoCode
from .entity_slot import Slot
from .entity_space import Space
from . import log, show_adding_box_log
from .exception import DistributionException
import time
class AlgoSingle(Algo):
"""
pack items into a single
bin
for single bin packing we merely
need ... | [
"time.time"
] | [((1717, 1728), 'time.time', 'time.time', ([], {}), '()\n', (1726, 1728), False, 'import time\n'), ((2598, 2609), 'time.time', 'time.time', ([], {}), '()\n', (2607, 2609), False, 'import time\n')] |
import numpy as np
import time
from unityagents import UnityEnvironment
from agent_utils import env_initialize, env_reset, state_reward_done_unpack
from dqn_agent import DQN_Agent
from agent_utils import load_dqn
from agent_utils import load_params, load_weights
def demo_agent(env, agent, n_episodes, epsilon=0.05, ... | [
"agent_utils.env_initialize",
"agent_utils.state_reward_done_unpack",
"agent_utils.load_dqn",
"dqn_agent.DQN_Agent",
"time.time",
"numpy.min",
"numpy.max",
"numpy.mean",
"numpy.random.randint",
"agent_utils.env_reset"
] | [((1355, 1397), 'agent_utils.env_initialize', 'env_initialize', (['env'], {'train_mode': 'train_mode'}), '(env, train_mode=train_mode)\n', (1369, 1397), False, 'from agent_utils import env_initialize, env_reset, state_reward_done_unpack\n'), ((1496, 1533), 'agent_utils.load_dqn', 'load_dqn', (['agent_name'], {'verbose'... |
# Copyright (c) 2020 BlenderNPR and contributors. MIT license.
import os, time
import bpy
from BlenderMalt import MaltMaterial, MaltMeshes, MaltTextures
__BRIDGE = None
__PIPELINE_PARAMETERS = None
__INITIALIZED = False
TIMESTAMP = time.time()
def get_bridge(world=None):
global __BRIDGE
bridge = __BRIDGE
... | [
"BlenderMalt.MaltTextures.unload_texture",
"BlenderMalt.MaltMaterial.reset_materials",
"os.path.join",
"bpy.app.handlers.load_post.append",
"bpy.props.PointerProperty",
"BlenderMalt.MaltMaterial.track_shader_changes",
"bpy.context.scene.world.malt.update_pipeline",
"os.path.abspath",
"bpy.path.abspa... | [((237, 248), 'time.time', 'time.time', ([], {}), '()\n', (246, 248), False, 'import os, time\n'), ((2152, 2248), 'bpy.props.StringProperty', 'bpy.props.StringProperty', ([], {'name': '"""Malt Pipeline"""', 'subtype': '"""FILE_PATH"""', 'update': 'update_pipeline'}), "(name='Malt Pipeline', subtype='FILE_PATH', update=... |
import os
from time import sleep
from datetime import datetime
MESSAGE_COUNT = int(os.getenv("MESSAGE_COUNT", 10000))
SIZE = int(os.getenv("SIZE", 128))
FREQ = float(os.getenv("FREQ", "1"))
MESSAGE_COUNT = max(MESSAGE_COUNT, 5)
MY_HOST = os.getenv("MY_HOST", os.uname()[1])
def print_beginning():
print("---begin... | [
"os.uname",
"datetime.datetime.now",
"os.getenv",
"time.sleep"
] | [((789, 803), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (801, 803), False, 'from datetime import datetime\n'), ((84, 117), 'os.getenv', 'os.getenv', (['"""MESSAGE_COUNT"""', '(10000)'], {}), "('MESSAGE_COUNT', 10000)\n", (93, 117), False, 'import os\n'), ((130, 152), 'os.getenv', 'os.getenv', (['"""SIZ... |
#!/usr/bin/python
# coding: utf8
from __future__ import absolute_import
import logging
from geocoder.base import OneResult, MultipleResultsQuery
class GeolyticaResult(OneResult):
def __init__(self, json_content):
# create safe shortcuts
self._standard = json_content.get('standard', {})
... | [
"logging.basicConfig"
] | [((2385, 2424), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (2404, 2424), False, 'import logging\n')] |