code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
from yelpfusion.endpoints.events import Events
def test_events_get(requests_mock):
mock_api = requests_mock.get("https://api.yelp.com/v3/events/abc", json={})
Events("test-key").get("abc", locale="en_US")
assert mock_api.called is True
def test_events_search(requests_mock):
mock_api = requests_moc... | [
"yelpfusion.endpoints.events.Events"
] | [((170, 188), 'yelpfusion.endpoints.events.Events', 'Events', (['"""test-key"""'], {}), "('test-key')\n", (176, 188), False, 'from yelpfusion.endpoints.events import Events\n'), ((374, 392), 'yelpfusion.endpoints.events.Events', 'Events', (['"""test-key"""'], {}), "('test-key')\n", (380, 392), False, 'from yelpfusion.e... |
import unittest, sys, os, hashlib, subprocess, shlex
from creators_py import creators_api
# This is a demo user key. These tests are written specifically
# for this user. They will fail if the API key is changed.
creators_api.api_key = '<KEY>'
api_username = 'cr_api_demo'
api_password = '<PASSWORD>='
class TestAPI(... | [
"creators_py.creators_api.get_releases",
"creators_py.creators_api.syn",
"creators_py.creators_api.download_zip",
"creators_py.creators_api.get_features",
"creators_py.creators_api.authenticate",
"unittest.main",
"creators_py.creators_api.download_file",
"creators_py.creators_api.get_feature_details",... | [((4099, 4114), 'unittest.main', 'unittest.main', ([], {}), '()\n', (4112, 4114), False, 'import unittest, sys, os, hashlib, subprocess, shlex\n'), ((1071, 1098), 'creators_py.creators_api.get_features', 'creators_api.get_features', ([], {}), '()\n', (1096, 1098), False, 'from creators_py import creators_api\n'), ((120... |
import argparse
import glob
import os
import random
import logging
import numpy as np
import math
from tqdm import tqdm
import time
import torch
from transformers import AutoTokenizer, AutoModelForMaskedLM
from transformers import DataCollatorForLanguageModeling
from transformers.optimization import AdamW, get_linear_s... | [
"logging.getLogger",
"torch.exp",
"math.log",
"torch.utils.data.distributed.DistributedSampler",
"torch.cuda.is_available",
"transformers.AutoTokenizer.from_pretrained",
"torch_xla.core.xla_model.all_reduce",
"logging.info",
"pytorch_lightning.logging.test_tube.TestTubeLogger",
"transformers.optim... | [((563, 602), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (582, 602), False, 'import logging\n'), ((612, 639), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (629, 639), False, 'import logging\n'), ((19355, 19382), 'random.seed'... |
#!/usr/bin/env python
import sys
import os
sys.path.append('../')
from logparser import Drain
from createSessonLog.createSessionLog import LogParser
from shutil import copyfile
from preprocess.preprocessLog import preprocess
type = sys.argv[1]
if len(sys.argv) < 2:
print("usage:python Drain_openstack.py {normal|ab... | [
"logparser.Drain.LogParser",
"shutil.copyfile",
"sys.path.append",
"os.path.split"
] | [((43, 65), 'sys.path.append', 'sys.path.append', (['"""../"""'], {}), "('../')\n", (58, 65), False, 'import sys\n'), ((695, 735), 'os.path.split', 'os.path.split', (['input_path_list[curIndex]'], {}), '(input_path_list[curIndex])\n', (708, 735), False, 'import os\n'), ((736, 794), 'shutil.copyfile', 'copyfile', (['inp... |
# coding=utf-8
import logging
LOGGER = logging.getLogger('tinify-cli')
def tracecall(func):
''' 在日志上打出函数呼叫和返回的情况 '''
def new_func(*args, **kwargs):
''' 待返回的函数 '''
LOGGER.debug(u'进入 ' + func.__name__)
ret = func(*args, **kwargs)
LOGGER.debug(u'离开 ' + func.__name__)
retu... | [
"logging.getLogger"
] | [((41, 72), 'logging.getLogger', 'logging.getLogger', (['"""tinify-cli"""'], {}), "('tinify-cli')\n", (58, 72), False, 'import logging\n')] |
from decimal import Decimal
import operator
_MININT = -(2 ** 64 - 1)
_MAXINT = 2 ** 64 - 1
class Metadata(dict):
"""
Represents Cardano transaction metadata. Inherits from :class:`dict` but passes all keys
and values through validity check.
:param mapping: a sequence of (key, value) pairs
... | [
"operator.itemgetter",
"operator.methodcaller"
] | [((582, 604), 'operator.itemgetter', 'operator.itemgetter', (['(0)'], {}), '(0)\n', (601, 604), False, 'import operator\n'), ((636, 666), 'operator.methodcaller', 'operator.methodcaller', (['"""items"""'], {}), "('items')\n", (657, 666), False, 'import operator\n'), ((6238, 6260), 'operator.itemgetter', 'operator.itemg... |
# ==================================================================================================
# A minimal example that renders a triangle mesh into a depth image using predefined perspective projection matrix
# Copyright 2021 <NAME>
#
# Please run script from repository root, i.e.:
# python3 ./tsdf_management/re... | [
"pytorch3d.renderer.mesh.MeshRasterizer",
"cv2.imread",
"pytorch3d.renderer.mesh.TexturesVertex",
"pytorch3d.renderer.mesh.SoftPhongShader",
"os.path.join",
"settings.process_arguments",
"torch.from_numpy",
"cv2.imshow",
"numpy.array",
"cv2.waitKey",
"data.camera.load_intrinsic_matrix_entries_fr... | [((1166, 1257), 'os.path.join', 'os.path.join', (['Parameters.path.dataset_base_directory.value', '"""val/seq014/intrinsics.txt"""'], {}), "(Parameters.path.dataset_base_directory.value,\n 'val/seq014/intrinsics.txt')\n", (1178, 1257), False, 'import os\n'), ((1274, 1296), 'torch.device', 'torch.device', (['"""cuda:... |
import argparse
def get_args():
parser = argparse.ArgumentParser(description='RL')
parser.add_argument('--server', action='store_true', default=False,
help='Defines current program as a server!')
parser.add_argument('--host', type=str, default='0.0.0.0',
hel... | [
"argparse.ArgumentParser"
] | [((47, 88), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""RL"""'}), "(description='RL')\n", (70, 88), False, 'import argparse\n')] |
import sqlite3
import requests
import json
__all__=["bot","_DB_NAME","_time_out","_chunk_size","_no_api_exception"]
_BASE_ADDRESS='https://api.telegram.org/bot'
_DB_NAME="Pytbot_data.db"
_time_out=None
_chunk_size = 2048
_no_api_exception=True
###################### GLOBAL INTERNAL FUNCTIONS #####################... | [
"json.loads",
"requests.post",
"sqlite3.connect",
"json.dumps",
"requests.get"
] | [((351, 376), 'sqlite3.connect', 'sqlite3.connect', (['_DB_NAME'], {}), '(_DB_NAME)\n', (366, 376), False, 'import sqlite3\n'), ((622, 646), 'json.loads', 'json.loads', (['response_str'], {}), '(response_str)\n', (632, 646), False, 'import json\n'), ((841, 865), 'json.loads', 'json.loads', (['response_str'], {}), '(res... |
import cv2
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.image as mping
import time
import imutils
import os
focalLength = None
def load_custom_names():
"load names of custom text file"
# create epmty list
class_list = []
# open coco txt file
with open("./object_detection... | [
"cv2.dnn.blobFromImage",
"cv2.rectangle",
"matplotlib.image.imread",
"numpy.argmax",
"time.sleep",
"cv2.putText",
"cv2.minAreaRect",
"os.getcwd",
"matplotlib.pyplot.figure",
"imutils.grab_contours",
"cv2.cvtColor",
"cv2.dnn.readNet",
"cv2.dnn.NMSBoxes",
"cv2.Canny",
"cv2.waitKey",
"cv2... | [((747, 860), 'cv2.dnn.readNet', 'cv2.dnn.readNet', (['"""./object_detection/yolov3-tiny-custom.weights"""', '"""./object_detection/yolov3-tiny-custom.cfg"""'], {}), "('./object_detection/yolov3-tiny-custom.weights',\n './object_detection/yolov3-tiny-custom.cfg')\n", (762, 860), False, 'import cv2\n'), ((3537, 3556)... |
from typing import Optional
import pytest
from time_manager.db.exceptions import IntegrityError, ItemNotFound
from time_manager.db.sql.base import session_scope
from time_manager.db.sql.models.user import User
from time_manager.db.sql.user import UserDao
from time_manager.schemas.user import UserDBBase
@pytest.mark... | [
"time_manager.schemas.user.UserDBBase.from_orm",
"time_manager.db.sql.base.session_scope",
"time_manager.db.sql.models.user.User",
"pytest.mark.parametrize",
"pytest.raises",
"time_manager.schemas.user.UserDBBase"
] | [((309, 403), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""username, password, email"""', "[('user', 'password', '<PASSWORD>')]"], {}), "('username, password, email', [('user', 'password',\n '<PASSWORD>')])\n", (332, 403), False, 'import pytest\n'), ((1497, 1615), 'pytest.mark.parametrize', 'pytest.ma... |
from __future__ import print_function
from googleapiclient.discovery import build
from httplib2 import Http
from oauth2client import file, client, tools
import re
import urllib
import requests
import sys
# If modifying these scopes, delete the file token.json.
SCOPES = 'https://www.googleapis.com/auth/spreadsheets'
... | [
"oauth2client.file.Storage",
"oauth2client.client.flow_from_clientsecrets",
"sys.exit",
"httplib2.Http",
"oauth2client.tools.run_flow"
] | [((442, 468), 'oauth2client.file.Storage', 'file.Storage', (['"""token.json"""'], {}), "('token.json')\n", (454, 468), False, 'from oauth2client import file, client, tools\n'), ((543, 601), 'oauth2client.client.flow_from_clientsecrets', 'client.flow_from_clientsecrets', (['"""credentials.json"""', 'SCOPES'], {}), "('cr... |
# SPDX-FileCopyrightText: Copyright (c) 2021 NVIDIA CORPORATION & AFFILIATES. All rights reserved.
# SPDX-License-Identifier: BSD-3-Clause
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# 1. Redistributions of source... | [
"torch.zeros"
] | [((3704, 3719), 'torch.zeros', 'torch.zeros', (['(12)'], {}), '(12)\n', (3715, 3719), False, 'import torch\n')] |
import torch
import torch.nn as nn
class RNN(nn.Module):
def __init__(self, rnn_layer, vocab_size):
super(RNN, self).__init__()
self.rnn = rnn_layer
self.hidden_size = rnn_layer.hidden_size * (2 if rnn_layer.bidirectional else 1)
self.vocab_size = vocab_size
self.dense = nn.... | [
"torch.stack",
"torch.zeros",
"torch.nn.Linear"
] | [((317, 356), 'torch.nn.Linear', 'nn.Linear', (['self.hidden_size', 'vocab_size'], {}), '(self.hidden_size, vocab_size)\n', (326, 356), True, 'import torch.nn as nn\n'), ((768, 830), 'torch.zeros', 'torch.zeros', (['x.shape[0]', 'n_class'], {'dtype': 'dtype', 'device': 'x.device'}), '(x.shape[0], n_class, dtype=dtype, ... |
import logging
import asyncio
from msilib import sequence
from nextcord import Client
from nextcord.gateway import ResumeWebSocket
from .config import Configuration
logger = logging.getLogger(__name__)
class Astronaut(Client):
def __init__(self, *args, **kwargs):
self.config: Configuration = kwargs.pop(... | [
"logging.getLogger",
"asyncio.wait_for"
] | [((177, 204), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (194, 204), False, 'import logging\n'), ((1637, 1675), 'asyncio.wait_for', 'asyncio.wait_for', (['mason'], {'timeout': '(180.0)'}), '(mason, timeout=180.0)\n', (1653, 1675), False, 'import asyncio\n'), ((2127, 2165), 'asyncio.wa... |
import tensorflow as tf
import numpy as np
from model import poly2poly
sess = tf.Session()
model = poly2poly(sess, 'archpoly2poly', '../../../data/processed/train/',
'../../../data/processed/test/',
'../../../data/processed/val/')
model.train(10)
| [
"tensorflow.Session",
"model.poly2poly"
] | [((80, 92), 'tensorflow.Session', 'tf.Session', ([], {}), '()\n', (90, 92), True, 'import tensorflow as tf\n'), ((101, 236), 'model.poly2poly', 'poly2poly', (['sess', '"""archpoly2poly"""', '"""../../../data/processed/train/"""', '"""../../../data/processed/test/"""', '"""../../../data/processed/val/"""'], {}), "(sess,... |
import torch
from torch.autograd import Variable
from .convert import to_var
from .vocab import PAD_TOKEN, SOS_TOKEN, EOS_TOKEN
def pad(tensor, length, dtype=None):
if isinstance(tensor, Variable):
var = tensor
if length > var.size(0):
return torch.cat(
[var, torch.zero... | [
"torch.stack"
] | [((864, 886), 'torch.stack', 'torch.stack', (['padded', '(0)'], {}), '(padded, 0)\n', (875, 886), False, 'import torch\n')] |
import numpy as np
import numba as nb
from Bio import pairwise2
from Bio.Seq import Seq
from Bio.SubsMat import MatrixInfo
from Bio.Alphabet import generic_dna
from Bio import SeqUtils
def initialStep(V0, V1, InSeq, In, M, Dir, isLocal = False):
d = 8
for i in range(V0.shape[0]):
top = np.iinfo(np.int1... | [
"Bio.Seq.Seq",
"numpy.iinfo",
"numpy.chararray.tostring",
"numpy.zeros",
"numpy.chararray"
] | [((5095, 5154), 'Bio.Seq.Seq', 'Seq', (['"""GTGGCCATTGTAATGGGCCGCTGAAAGGGTGCCCGATAG"""', 'generic_dna'], {}), "('GTGGCCATTGTAATGGGCCGCTGAAAGGGTGCCCGATAG', generic_dna)\n", (5098, 5154), False, 'from Bio.Seq import Seq\n'), ((5162, 5212), 'Bio.Seq.Seq', 'Seq', (['"""GTGGCCATTGTAATGGAAAGGGTGAAAGAT"""', 'generic_dna'], {}... |
import web.test as test
import web.water_bill as water_bill
import web.cable_bill as cable_bill
import web.gas_bill as gas_bill
import web.electric_bill as electric_bill
import sys
if sys.argv[1] == "test":
test.run()
elif sys.argv[1] == "waterBill":
water_bill.run()
elif sys.argv[1] == "cableBill":
cable_... | [
"web.electric_bill.run",
"web.gas_bill.run",
"web.test.run",
"web.cable_bill.run",
"web.water_bill.run"
] | [((212, 222), 'web.test.run', 'test.run', ([], {}), '()\n', (220, 222), True, 'import web.test as test\n'), ((260, 276), 'web.water_bill.run', 'water_bill.run', ([], {}), '()\n', (274, 276), True, 'import web.water_bill as water_bill\n'), ((314, 330), 'web.cable_bill.run', 'cable_bill.run', ([], {}), '()\n', (328, 330)... |
from typing import List, Dict, Callable, Tuple
from math import sqrt
import random
import gym
from regym.rl_algorithms.MCTS.selection_strategies import UCB1, PUCT
from regym.rl_algorithms.MCTS.simultaneous_open_loop_node import SimultaneousOpenLoopNode
from regym.rl_algorithms.MCTS.util import random_rollout_policy
... | [
"random.choice",
"regym.rl_algorithms.MCTS.simultaneous_open_loop_node.SimultaneousOpenLoopNode"
] | [((7121, 7184), 'regym.rl_algorithms.MCTS.simultaneous_open_loop_node.SimultaneousOpenLoopNode', 'SimultaneousOpenLoopNode', ([], {'state': 'rootstate', 'perspective_player': 'i'}), '(state=rootstate, perspective_player=i)\n', (7145, 7184), False, 'from regym.rl_algorithms.MCTS.simultaneous_open_loop_node import Simult... |
from my_app import db
class Fact(db.Model):
id = db.Column(db.Integer, primary_keys = True)
name = db.Column(db.String(100))
value = db.Column(db.String(100)) | [
"my_app.db.String",
"my_app.db.Column"
] | [((54, 94), 'my_app.db.Column', 'db.Column', (['db.Integer'], {'primary_keys': '(True)'}), '(db.Integer, primary_keys=True)\n', (63, 94), False, 'from my_app import db\n'), ((116, 130), 'my_app.db.String', 'db.String', (['(100)'], {}), '(100)\n', (125, 130), False, 'from my_app import db\n'), ((152, 166), 'my_app.db.St... |
# ikb/urls.py
from django.conf.urls import url
# from django.urls import path
from . import views
app_name = 'ikb'
urlpatterns = [
url(r'^$', views.ikb_index, name='ikb_index'),
]
| [
"django.conf.urls.url"
] | [((136, 180), 'django.conf.urls.url', 'url', (['"""^$"""', 'views.ikb_index'], {'name': '"""ikb_index"""'}), "('^$', views.ikb_index, name='ikb_index')\n", (139, 180), False, 'from django.conf.urls import url\n')] |
import time
import random
import staticdict
random.seed(123)
d = {}
d[b'a'] = b'b'
d[b'c'] = b'd'
d[b'1' * 200] = b'd' * 200
d = staticdict.StaticHashDict(d)
print('get a')
print(d[b'a'])
print('get b')
print(d[b'b'])
print('get c')
print(d[b'c'])
print('get 1111*')
print(len(d[b'1' * 200]))
def m_test():
"""
... | [
"staticdict.StaticHashDict",
"time.time",
"random.randint",
"random.seed"
] | [((44, 60), 'random.seed', 'random.seed', (['(123)'], {}), '(123)\n', (55, 60), False, 'import random\n'), ((131, 159), 'staticdict.StaticHashDict', 'staticdict.StaticHashDict', (['d'], {}), '(d)\n', (156, 159), False, 'import staticdict\n'), ((654, 682), 'staticdict.StaticHashDict', 'staticdict.StaticHashDict', (['d']... |
"""
Contains routes for main purpose of app
"""
from datetime import datetime
from flask import render_template, flash, redirect, url_for, request, current_app
from flask_login import current_user, login_required
from app import db
from app.main.forms import EditProfileForm, PostForm
from app.models import User, Post
f... | [
"flask.render_template",
"app.db.session.commit",
"flask_login.current_user.followed_posts",
"app.models.Post",
"flask.flash",
"datetime.datetime.utcnow",
"flask_login.current_user.unfollow",
"flask.url_for",
"app.main.forms.EditProfileForm",
"app.db.session.add",
"flask_login.current_user.follo... | [((655, 693), 'app.main.bp.route', 'bp.route', (['"""/"""'], {'methods': "['GET', 'POST']"}), "('/', methods=['GET', 'POST'])\n", (663, 693), False, 'from app.main import bp\n'), ((695, 738), 'app.main.bp.route', 'bp.route', (['"""/index"""'], {'methods': "['GET', 'POST']"}), "('/index', methods=['GET', 'POST'])\n", (7... |
from ..gui.main_window import Ui_EditorMainWindow
from PySide.QtGui import QApplication, QMainWindow, QPixmap
from PySide import QtGui, QtCore
from PySide.QtCore import QObject
import sys
import numpy as np
from .. import util
from .brush_dialog import BrushDialog
from .about_dialog import AboutDialog
from .new_image_d... | [
"numpy.clip",
"PySide.QtGui.QPixmap.fromImage",
"PySide.QtGui.QFileDialog.getOpenFileName",
"numpy.absolute",
"numpy.fft.fft2",
"numpy.angle",
"numpy.zeros",
"PySide.QtGui.QDesktopServices.openUrl",
"PySide.QtGui.QFileDialog.getSaveFileName",
"PySide.QtGui.QApplication",
"PySide.QtGui.QImage",
... | [((16472, 16494), 'PySide.QtGui.QApplication', 'QApplication', (['sys.argv'], {}), '(sys.argv)\n', (16484, 16494), False, 'from PySide.QtGui import QApplication, QMainWindow, QPixmap\n'), ((3087, 3106), 'numpy.fft.fft2', 'np.fft.fft2', (['garray'], {}), '(garray)\n', (3098, 3106), True, 'import numpy as np\n'), ((3124,... |
"""
Database models for umnoc.
"""
from django.conf import settings
from django.contrib.auth import get_user_model
from django.core.exceptions import ValidationError
from django.db import models
from django.utils.translation import ugettext_lazy as _
from model_utils.models import TimeStampedModel
from simple_history.m... | [
"django.contrib.auth.get_user_model",
"django.utils.translation.ugettext_lazy",
"simple_history.models.HistoricalRecords",
"user_util.user_util.get_retired_external_key",
"django.db.models.CharField",
"django.db.models.UUIDField"
] | [((1304, 1362), 'django.db.models.CharField', 'models.CharField', ([], {'db_index': '(True)', 'max_length': '(255)', 'null': '(True)'}), '(db_index=True, max_length=255, null=True)\n', (1320, 1362), False, 'from django.db import models\n'), ((1412, 1455), 'django.db.models.UUIDField', 'models.UUIDField', ([], {'db_inde... |
from torch import nn
import torchvision.models.segmentation as models
import torchvision.models as allmodels
from src2.nnet.abstract_network import AbstractNet
from .blocks.core import ConvLayer
def _get_network(network):
return {
"deeplabv3_resnet101": models.deeplabv3_resnet101,
"fcn_resnet101": ... | [
"torchvision.models.inception_v3",
"torch.nn.Linear"
] | [((1784, 1831), 'torch.nn.Linear', 'nn.Linear', (['input_main', "self.config['n_classes']"], {}), "(input_main, self.config['n_classes'])\n", (1793, 1831), False, 'from torch import nn\n'), ((363, 420), 'torchvision.models.inception_v3', 'allmodels.inception_v3', ([], {'pretrained': '(True)', 'aux_logits': '(False)'}),... |
import requests
from functools import wraps
import inspect
def paginate(func):
@wraps(func)
def func_wrapper(*args, **kwargs):
# Get default parameters
default_params = inspect.signature(func).bind(*args, **kwargs)
default_params.apply_defaults()
# Set new kwargs based on defau... | [
"inspect.signature",
"functools.wraps"
] | [((85, 96), 'functools.wraps', 'wraps', (['func'], {}), '(func)\n', (90, 96), False, 'from functools import wraps\n'), ((194, 217), 'inspect.signature', 'inspect.signature', (['func'], {}), '(func)\n', (211, 217), False, 'import inspect\n')] |
"""
Copyright (c) 2021 SolarLiner, jdrprod, Arxaqapi
This software is released under the MIT License.
https://opensource.org/licenses/MIT
"""
import logging
import json
from textwrap import wrap
from functools import partial
from typing import List, Literal, Optional, Union
from pathlib import Path
from argparse ... | [
"argparse.ArgumentParser",
"pathlib.Path",
"argparse.ArgumentTypeError",
"functools.partial",
"textwrap.wrap",
"json.load"
] | [((1057, 1064), 'pathlib.Path', 'Path', (['s'], {}), '(s)\n', (1061, 1064), False, 'from pathlib import Path\n'), ((1443, 1459), 'argparse.ArgumentParser', 'ArgumentParser', ([], {}), '()\n', (1457, 1459), False, 'from argparse import ArgumentParser, ArgumentTypeError, Namespace\n'), ((1289, 1359), 'argparse.ArgumentTy... |
'''
Created on 2020-07-11
@author: wf
'''
import os
from ptp.titleparser import TitleParser
from ptp.event import EventManager, Event
class WikiData(object):
'''
WikiData proceedings titles event source
'''
defaultEndpoint="https://query.wikidata.org/sparql"
def __init__(self, config=None):
... | [
"ptp.event.Event",
"os.path.dirname",
"ptp.titleparser.TitleParser.getDefault",
"ptp.event.EventManager"
] | [((458, 580), 'ptp.event.EventManager', 'EventManager', (['"""wikidata"""'], {'url': '"""https://www.wikidata.org/wiki/Wikidata:Main_Page"""', 'title': '"""Wikidata"""', 'config': 'config'}), "('wikidata', url=\n 'https://www.wikidata.org/wiki/Wikidata:Main_Page', title='Wikidata',\n config=config)\n", (470, 580)... |
# Copyright (c) 2019 PaddlePaddle Authors. All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by appli... | [
"paddle.fluid.framework._test_eager_guard",
"numpy.random.rand",
"paddle.fluid.CPUPlace",
"numpy.random.randint",
"paddle.to_tensor",
"paddle.linalg.cov",
"paddle.fluid.CUDAPlace",
"unittest.main",
"paddle.fluid.core.is_compiled_with_cuda",
"paddle.set_device"
] | [((11390, 11405), 'unittest.main', 'unittest.main', ([], {}), '()\n', (11403, 11405), False, 'import unittest\n'), ((1256, 1290), 'paddle.fluid.core.is_compiled_with_cuda', 'fluid.core.is_compiled_with_cuda', ([], {}), '()\n', (1288, 1290), True, 'import paddle.fluid as fluid\n'), ((2398, 2432), 'paddle.fluid.core.is_c... |
from __future__ import absolute_import
from functools import partial
from asyncio import get_event_loop
from typing import Callable, Any, Dict
from .global_executor import executor
async def run_sync(function: Callable, *args: Any, **kwargs: Dict[Any, Any]) -> Any:
"""
Run non-asynchronous as async using ex... | [
"asyncio.get_event_loop",
"functools.partial"
] | [((397, 431), 'functools.partial', 'partial', (['function', '*args'], {}), '(function, *args, **kwargs)\n', (404, 431), False, 'from functools import partial\n'), ((354, 370), 'asyncio.get_event_loop', 'get_event_loop', ([], {}), '()\n', (368, 370), False, 'from asyncio import get_event_loop\n')] |
from selenium import webdriver
from configs import parse_args
import time
from datetime import datetime
def run(args):
driver = webdriver.Chrome()
driver.get(args.url)
time.sleep(1)
# 姓名
driver.find_element_by_id('q1').clear()
driver.find_element_by_id('q1').send_keys(args.name)
#... | [
"configs.parse_args",
"selenium.webdriver.Chrome",
"datetime.datetime.now",
"time.sleep"
] | [((133, 151), 'selenium.webdriver.Chrome', 'webdriver.Chrome', ([], {}), '()\n', (149, 151), False, 'from selenium import webdriver\n'), ((181, 194), 'time.sleep', 'time.sleep', (['(1)'], {}), '(1)\n', (191, 194), False, 'import time\n'), ((1180, 1192), 'configs.parse_args', 'parse_args', ([], {}), '()\n', (1190, 1192)... |
#!/usr/bin/env python
"""Common CLI commands."""
import logging
import sys
from functools import wraps
import asyncio
import click
from docker_sign_verify import __version__
LOGGING_DEFAULT = 2
def async_command(func):
"""Asynchronous command wrapper that allows click commands to be async."""
@wraps(fu... | [
"logging.basicConfig",
"logging.getLogger",
"asyncio.run",
"click.option",
"functools.wraps",
"asyncio._get_running_loop",
"click.command"
] | [((2745, 2760), 'click.command', 'click.command', ([], {}), '()\n', (2758, 2760), False, 'import click\n'), ((312, 323), 'functools.wraps', 'wraps', (['func'], {}), '(func)\n', (317, 323), False, 'from functools import wraps\n'), ((2594, 2707), 'logging.basicConfig', 'logging.basicConfig', ([], {'datefmt': '"""%Y-%m-%d... |
"""
Handles errors encountered by the PowerToken Flask app.\n
Created by <NAME> on 3/12/2018.\n
Last modified by <NAME> on 3/26/2018.
"""
from flask import render_template
from app import app, db
@app.errorhandler(404)
def not_found_error(error):
return render_template("404.html"), 404
@app.errorhandler(500)
def in... | [
"flask.render_template",
"app.app.errorhandler",
"app.db.session.rollback"
] | [((199, 220), 'app.app.errorhandler', 'app.errorhandler', (['(404)'], {}), '(404)\n', (215, 220), False, 'from app import app, db\n'), ((292, 313), 'app.app.errorhandler', 'app.errorhandler', (['(500)'], {}), '(500)\n', (308, 313), False, 'from app import app, db\n'), ((342, 363), 'app.db.session.rollback', 'db.session... |
import logging
from protocols.protocol_7_2_1.reports import Assembly, Program, InterpretationRequestRD, CancerInterpretationRequest, \
InterpretedGenome as InterpretedGenomeGelModel
from protocols.protocol_7_7.participant import Referral as ReferralGelModel
class PreviousData(Exception):
pass
class Workspa... | [
"protocols.protocol_7_7.participant.Referral.fromJsonDict",
"logging.warning",
"protocols.protocol_7_2_1.reports.InterpretedGenome.fromJsonDict",
"protocols.protocol_7_7.participant.Referral.validate",
"protocols.protocol_7_2_1.reports.InterpretationRequestRD.fromJsonDict",
"protocols.protocol_7_2_1.repor... | [((4922, 4980), 'protocols.protocol_7_7.participant.Referral.fromJsonDict', 'ReferralGelModel.fromJsonDict', (['self._referral_payload_json'], {}), '(self._referral_payload_json)\n', (4951, 4980), True, 'from protocols.protocol_7_7.participant import Referral as ReferralGelModel\n'), ((1533, 1601), 'protocols.protocol_... |
"""
Description: A python 2.7 implementation of gcForest proposed in [1]. A demo implementation of gcForest library as well as some demo client scripts to demostrate how to use the code. The implementation is flexible enough for modifying the model or
fit your own datasets.
Reference: [1] <NAME> and <NAME>. Deep Fores... | [
"matplotlib.pylab.savefig",
"sklearn.ensemble.ExtraTreesClassifier",
"matplotlib.pylab.show",
"numpy.mean",
"matplotlib.pylab.clf",
"matplotlib.pylab.grid",
"matplotlib.pylab.title",
"json.dumps",
"numpy.asarray",
"numpy.concatenate",
"matplotlib.pylab.axes",
"sklearn.ensemble.RandomForestClas... | [((1582, 1611), 'numpy.concatenate', 'np.concatenate', (['datas'], {'axis': '(1)'}), '(datas, axis=1)\n', (1596, 1611), True, 'import numpy as np\n'), ((1658, 1682), 'numpy.mean', 'np.mean', (['X_train'], {'axis': '(0)'}), '(X_train, axis=0)\n', (1665, 1682), True, 'import numpy as np\n'), ((1695, 1718), 'numpy.std', '... |
# -*- coding: utf-8 -*-
#
# Copyright (C) 2020 Centre National d'Etudes Spatiales (CNES)
#
# 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
#
# ... | [
"orchestrator.common.logger.maja_logging.configure_logger"
] | [((1635, 1661), 'orchestrator.common.logger.maja_logging.configure_logger', 'configure_logger', (['__name__'], {}), '(__name__)\n', (1651, 1661), False, 'from orchestrator.common.logger.maja_logging import configure_logger\n')] |
import theano.tensor as T
from pylearn2.models import mlp
from pylearn2.space import VectorSpace
from pylearn2.utils import sharedX
from pylearn2.utils import safe_zip
from pylearn2.linear.matrixmul import MatrixMul
from collections import OrderedDict
class MLP(mlp.MLP):
def inv_prop(self, state_above):
se... | [
"pylearn2.utils.safe_zip",
"pylearn2.space.VectorSpace",
"pylearn2.linear.matrixmul.MatrixMul",
"theano.tensor.zeros_like",
"pylearn2.utils.sharedX"
] | [((4073, 4094), 'pylearn2.space.VectorSpace', 'VectorSpace', (['self.dim'], {}), '(self.dim)\n', (4084, 4094), False, 'from pylearn2.space import VectorSpace\n'), ((4556, 4568), 'pylearn2.utils.sharedX', 'sharedX', (['W.T'], {}), '(W.T)\n', (4563, 4568), False, 'from pylearn2.utils import sharedX\n'), ((4636, 4648), 'p... |
import time
from Algorithms.Opt2_Algorithm.algorithm import Opt2
# 2Opt Algorithm requires no configurations
def opt2Algorithm():
opt2 = Opt2()
startTime = time.time()
route, _ = opt2.findSolution()
endTime = time.time()
time_taken = endTime - startTime
solution = route
distance = opt2.... | [
"Algorithms.Opt2_Algorithm.algorithm.Opt2",
"time.time"
] | [((144, 150), 'Algorithms.Opt2_Algorithm.algorithm.Opt2', 'Opt2', ([], {}), '()\n', (148, 150), False, 'from Algorithms.Opt2_Algorithm.algorithm import Opt2\n'), ((168, 179), 'time.time', 'time.time', ([], {}), '()\n', (177, 179), False, 'import time\n'), ((229, 240), 'time.time', 'time.time', ([], {}), '()\n', (238, 2... |
from dataclasses import dataclass
from typing import Optional
# Source: https://cloud.google.com/vertex-ai/docs/reference/rest/v1/PipelineState
class PipelineStatus:
PIPELINE_STATE_UNSPECIFIED = "PIPELINE_STATE_UNSPECIFIED"
PIPELINE_STATE_QUEUED = "PIPELINE_STATE_QUEUED"
PIPELINE_STATE_PENDING = "PIPELINE... | [
"dataclasses.dataclass"
] | [((673, 695), 'dataclasses.dataclass', 'dataclass', ([], {'frozen': '(True)'}), '(frozen=True)\n', (682, 695), False, 'from dataclasses import dataclass\n')] |
# Copyright (c) 2019 <NAME>
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, publish, distrib... | [
"uxy.base.launch",
"uxy.base.encode_field",
"argparse.ArgumentParser",
"re.compile",
"uxy.base.Format",
"uxy.base.check_args"
] | [((1197, 1254), 'argparse.ArgumentParser', 'argparse.ArgumentParser', (['"""__main__.py du"""'], {'add_help': '(False)'}), "('__main__.py du', add_help=False)\n", (1220, 1254), False, 'import argparse\n'), ((2199, 2228), 'uxy.base.check_args', 'base.check_args', (['args', 'parser'], {}), '(args, parser)\n', (2214, 2228... |
# Databricks notebook source
from utils.load_functions import enrich_source
# COMMAND ----------
df = spark.createDataFrame([
('Bob', 'Dole'),
('Tony', 'Stark')
])
display(df)
# COMMAND ----------
from datetime import datetime
df = enrich_source(df, datetime.now(), "Try_Local")
display(df)
| [
"datetime.datetime.now"
] | [((259, 273), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (271, 273), False, 'from datetime import datetime\n')] |
from __future__ import annotations
import math
class Hysteresis:
def __init__(self, amount: float, initial_value: float):
self._amount = amount
self._at = round(initial_value)
def __call__(self, value: float) -> int:
i, j = math.floor(value), math.ceil(value)
if self._at != i ... | [
"math.ceil",
"math.floor"
] | [((259, 276), 'math.floor', 'math.floor', (['value'], {}), '(value)\n', (269, 276), False, 'import math\n'), ((278, 294), 'math.ceil', 'math.ceil', (['value'], {}), '(value)\n', (287, 294), False, 'import math\n')] |
"""
Created on May 08, 2019
@author: msanchez
"""
from logs.SVWLogs import SVWLogs
from utils.FileUtils import FileUtils
class Logs(object):
""" Sets the main structure to follow, to modify it in a future with other Log structures.
Attributes:
svw_logs specific, encapsulated solution to c... | [
"utils.FileUtils.FileUtils.write_file",
"utils.FileUtils.FileUtils.read_file_lines",
"logs.SVWLogs.SVWLogs",
"utils.FileUtils.FileUtils.construct_csv"
] | [((455, 464), 'logs.SVWLogs.SVWLogs', 'SVWLogs', ([], {}), '()\n', (462, 464), False, 'from logs.SVWLogs import SVWLogs\n'), ((533, 570), 'utils.FileUtils.FileUtils.read_file_lines', 'FileUtils.read_file_lines', (['input_file'], {}), '(input_file)\n', (558, 570), False, 'from utils.FileUtils import FileUtils\n'), ((156... |
#!/usr/bin/env python
# coding: utf-8
# <b> Run below cells from the folder that contains ads16_dataset/ unzipped </b>
# In[1]:
import pandas as pd
import glob
import pathlib
import re
# In[2]:
pd.set_option('display.max_colwidth', -1)
# In[3]:
# Global constants
g_userPart1PathPrefix = "./ads16-dataset/ADS... | [
"pandas.MultiIndex.from_product",
"pandas.read_csv",
"pathlib.Path",
"pandas.merge",
"pandas.set_option",
"pandas.DataFrame",
"pandas.concat"
] | [((202, 243), 'pandas.set_option', 'pd.set_option', (['"""display.max_colwidth"""', '(-1)'], {}), "('display.max_colwidth', -1)\n", (215, 243), True, 'import pandas as pd\n'), ((9138, 9198), 'pandas.concat', 'pd.concat', (['[allUsers_And_Ads_df, allUsersRatings_df]'], {'axis': '(1)'}), '([allUsers_And_Ads_df, allUsersR... |
# Generated by Django 2.2.4 on 2019-11-16 19:44
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('register', '0001_initial'),
]
operations = [
migrations.CreateModel(
... | [
"django.db.models.DateField",
"django.db.models.TimeField",
"django.db.models.ForeignKey",
"django.db.models.BooleanField",
"django.db.migrations.CreateModel",
"django.db.models.AutoField",
"django.db.models.CharField"
] | [((1737, 1886), 'django.db.migrations.CreateModel', 'migrations.CreateModel', ([], {'name': '"""Competitor"""', 'fields': '[]', 'options': "{'proxy': True, 'indexes': [], 'constraints': []}", 'bases': "('register.participants',)"}), "(name='Competitor', fields=[], options={'proxy': True,\n 'indexes': [], 'constraint... |
import pytest
from tokki.enums import Status
@pytest.mark.asyncio
async def test_all_values():
assert Status.from_name("created") == Status.InProgress
assert Status.from_name("received") == Status.InProgress
assert Status.from_name("started") == Status.InProgress
assert Status.from_name("passed") == S... | [
"pytest.raises",
"tokki.enums.Status.from_name"
] | [((108, 135), 'tokki.enums.Status.from_name', 'Status.from_name', (['"""created"""'], {}), "('created')\n", (124, 135), False, 'from tokki.enums import Status\n'), ((168, 196), 'tokki.enums.Status.from_name', 'Status.from_name', (['"""received"""'], {}), "('received')\n", (184, 196), False, 'from tokki.enums import Sta... |
#!/usr/bin/env python
# encoding: utf-8
""" """
from common.decorators import exception_wrapper
__author__ = 'adonis'
import re
import httplib
import urllib
import web
import requests
import requests_unixsocket
import logging
from teslafaas.common.const import ALL_HEADERS, NON_WSGI_HEADER
from teslafaas.common.util_... | [
"logging.getLogger",
"re.search",
"teslafaas.common.util_func.get_cur_time_ms",
"urllib.quote",
"web.input",
"httplib.responses.get",
"requests_unixsocket.monkeypatch",
"web.data",
"web.header",
"web.ctx.env.get"
] | [((351, 384), 'requests_unixsocket.monkeypatch', 'requests_unixsocket.monkeypatch', ([], {}), '()\n', (382, 384), False, 'import requests_unixsocket\n'), ((393, 420), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (410, 420), False, 'import logging\n'), ((1268, 1304), 're.search', 're.sea... |
from app import db, login_manager
from flask_login import UserMixin
from werkzeug.security import generate_password_hash, check_password_hash
from hashlib import md5
"""This is the model for Upvote class"""
class Upvote(db.Model):
__tablename__ = "upvotes"
vote_id = db.Column(db.Integer, primary_key = True)
user_id... | [
"app.db.Column",
"app.db.ForeignKey"
] | [((270, 309), 'app.db.Column', 'db.Column', (['db.Integer'], {'primary_key': '(True)'}), '(db.Integer, primary_key=True)\n', (279, 309), False, 'from app import db, login_manager\n'), ((769, 808), 'app.db.Column', 'db.Column', (['db.Integer'], {'primary_key': '(True)'}), '(db.Integer, primary_key=True)\n', (778, 808), ... |
# Copyright 2016, Ericsson AB
#
# 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 ag... | [
"json.loads",
"gluon.shim.utils.compute_gateway",
"uuid.UUID",
"log.LOG.debug",
"oslo_config.cfg.StrOpt",
"log.LOG.error",
"requests.request",
"log.LOG.info",
"log.for_all_methods",
"oslo_config.cfg.IntOpt",
"oslo_config.cfg.OptGroup",
"oslo_serialization.jsonutils.dumps",
"gluon.shim.utils.... | [((1414, 1485), 'oslo_config.cfg.OptGroup', 'cfg.OptGroup', ([], {'name': '"""shim_odl"""', 'title': '"""Options for the ODL shim service"""'}), "(name='shim_odl', title='Options for the ODL shim service')\n", (1426, 1485), False, 'from oslo_config import cfg\n'), ((1606, 1637), 'log.for_all_methods', 'for_all_methods'... |
#!/usr/bin/env python
# coding: utf-8
"""
Need to save the final breast contour and also images of the breast contour and contour dilate
"""
#import modules
import SimpleITK as sitk
from platipy.imaging import ImageVisualiser
from platipy.imaging.label.utils import get_com
from platipy.imaging.registration.linear ... | [
"SimpleITK.BinaryDilate",
"SimpleITK.BinaryThreshold",
"platipy.imaging.registration.deformable.fast_symmetric_forces_demons_registration",
"SimpleITK.GetImageFromArray",
"SimpleITK.BinaryMorphologicalClosing",
"SimpleITK.GetArrayFromImage",
"SimpleITK.WriteImage",
"SimpleITK.ConnectedComponent",
"p... | [((582, 659), 'SimpleITK.ReadImage', 'sitk.ReadImage', (['"""/home/alicja//Downloads/PET-LAB Nifti files/L-breast.nii.gz"""'], {}), "('/home/alicja//Downloads/PET-LAB Nifti files/L-breast.nii.gz')\n", (596, 659), True, 'import SimpleITK as sitk\n'), ((774, 886), 'SimpleITK.ReadImage', 'sitk.ReadImage', (['"""/home/alic... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
'''test replication of depots in svn repository.
'''
import os
import unittest
import tempfile
from testcommon import (obliterate_all_depots,
BuildTestException,
get_p4d_from_docker,
set_p4d_unicode_... | [
"SvnP4BranchDetection.detect_branch_point",
"testcommon.obliterate_all_depots",
"testcommon_svnp4.replicate_SvnP4Replicate",
"testcommon.set_p4d_unicode_mode",
"os.makedirs",
"testcommon_svnp4.get_svn_from_docker",
"subprocess.Popen",
"os.path.join",
"unittest.main",
"os.path.split",
"testcommon... | [((803, 822), 'lib.buildlogger.getLogger', 'getLogger', (['__name__'], {}), '(__name__)\n', (812, 822), False, 'from lib.buildlogger import getLogger\n'), ((38597, 38612), 'unittest.main', 'unittest.main', ([], {}), '()\n', (38610, 38612), False, 'import unittest\n'), ((1060, 1097), 'testcommon.obliterate_all_depots', ... |
from __future__ import print_function
import unittest
import numpy as np
from simpegEM1D import (
GlobalEM1DProblemFD, GlobalEM1DSurveyFD,
get_vertical_discretization_frequency
)
from SimPEG import (
regularization, Inversion, InvProblem,
DataMisfit, Utils, Mesh, Maps, Optimization,
Tests
)
np.rand... | [
"numpy.random.rand",
"SimPEG.Maps.ExpMap",
"numpy.log",
"SimPEG.DataMisfit.l2_DataMisfit",
"numpy.array",
"unittest.main",
"numpy.arange",
"simpegEM1D.get_vertical_discretization_frequency",
"numpy.random.seed",
"SimPEG.Optimization.InexactGaussNewton",
"SimPEG.Inversion.BaseInversion",
"numpy... | [((313, 331), 'numpy.random.seed', 'np.random.seed', (['(41)'], {}), '(41)\n', (327, 331), True, 'import numpy as np\n'), ((6276, 6291), 'unittest.main', 'unittest.main', ([], {}), '()\n', (6289, 6291), False, 'import unittest\n'), ((430, 471), 'numpy.array', 'np.array', (['[900, 7200, 56000]'], {'dtype': 'float'}), '(... |
from gensim.models import Word2Vec, KeyedVectors
# Class for a memory-friendly iterator over the dataset
class MemoryFriendlyFileIterator(object):
def __init__(self, filename):
self.filename = filename
def __iter__(self):
for line in open(self.filename):
yield line.split()
def c... | [
"gensim.models.Word2Vec"
] | [((2601, 2742), 'gensim.models.Word2Vec', 'Word2Vec', (['sentences'], {'min_count': 'min_count', 'sg': 'sg', 'size': 'dim_rho', 'iter': 'iters', 'workers': 'workers', 'negative': 'negative_samples', 'window': 'window_size'}), '(sentences, min_count=min_count, sg=sg, size=dim_rho, iter=iters,\n workers=workers, negat... |
import prefect
from prefect import task, Flow
from prefect.run_configs import DockerRun
from prefect.storage import GitHub
@task
def hello_task():
logger = prefect.context.get("logger")
logger.info("Hello world!")
with Flow(
"hello-flow",
storage=GitHub(repo="kvnkho/demos", path="prefect/... | [
"prefect.context.get",
"prefect.storage.GitHub",
"prefect.run_configs.DockerRun"
] | [((162, 191), 'prefect.context.get', 'prefect.context.get', (['"""logger"""'], {}), "('logger')\n", (181, 191), False, 'import prefect\n'), ((278, 367), 'prefect.storage.GitHub', 'GitHub', ([], {'repo': '"""kvnkho/demos"""', 'path': '"""prefect/docker_error.py"""', 'add_default_labels': '(False)'}), "(repo='kvnkho/demo... |
import asyncio
import logging
import os
import string
from urllib.parse import urljoin
import aiohttp
from cockatiel.utils.filenames import get_hash_from_name
from . import config, version
from .queue import FSQueue
running = True
logger = logging.getLogger(__name__)
MIN_INTERVAL = 0.5
MAX_INTERVAL = 60
DEFAULTHEADE... | [
"logging.getLogger",
"aiohttp.ClientSession",
"os.path.exists",
"cockatiel.utils.filenames.get_hash_from_name",
"aiohttp.ProxyConnector",
"os.path.join",
"urllib.parse.urljoin",
"asyncio.sleep"
] | [((243, 270), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (260, 270), False, 'import logging\n'), ((1255, 1305), 'os.path.join', 'os.path.join', (['config.args.storage', "obj['filename']"], {}), "(config.args.storage, obj['filename'])\n", (1267, 1305), False, 'import os\n'), ((3057, 31... |
#!/usr/bin/python
# -*- coding: utf-8 -*-
#
# Air quality monitoring
# Science project based on RaspberryPi, GrovePi and Grove sensors and actuators
#
#
## License: The MIT License (MIT)
#
# LIBRARIES WE ARE USING
import os
import time
from ISStreamer.Streamer import Streamer
import atexit
import datetime
# graphical... | [
"grove_sensor_oo_lib.AirQualitySensor",
"grove_sensor_oo_lib.CO2SensorSerial",
"tkFont.Font",
"grovepi.digitalWrite",
"datetime.datetime.utcnow",
"time.sleep",
"grove_sensor_oo_lib.DustSensor",
"grove_sensor_oo_lib.GasSensor",
"ISStreamer.Streamer.Streamer"
] | [((1464, 1503), 'grove_sensor_oo_lib.AirQualitySensor', 'grove_sensor_oo_lib.AirQualitySensor', (['(0)'], {}), '(0)\n', (1500, 1503), False, 'import grove_sensor_oo_lib\n'), ((1565, 1597), 'grove_sensor_oo_lib.GasSensor', 'grove_sensor_oo_lib.GasSensor', (['(2)'], {}), '(2)\n', (1594, 1597), False, 'import grove_sensor... |
from collections import deque
import numpy as np
from gym.spaces import Box
from gym import ObservationWrapper
class FrameStack(ObservationWrapper):
def __init__(self, env, num_frames):
super(FrameStack, self).__init__(env)
self._env = env
self.num_frames = num_frames
self.frames ... | [
"collections.deque",
"numpy.repeat",
"gym.spaces.Box",
"cv2.cvtColor",
"numpy.expand_dims"
] | [((322, 346), 'collections.deque', 'deque', ([], {'maxlen': 'num_frames'}), '(maxlen=num_frames)\n', (327, 346), False, 'from collections import deque\n'), ((362, 455), 'numpy.repeat', 'np.repeat', (["self.observation_space['observation'].low[np.newaxis, ...]", 'num_frames'], {'axis': '(0)'}), "(self.observation_space[... |
# pylint: disable-all
import pytest
from cloudwatchiter.abc_expression import AbstractExpression
def abc(cls):
cls.__abstractmethods__ = set()
cls.element_count = 2
cls.valid_types = ('cron', 'rate')
return cls
def test_invalid_init():
cls = abc(AbstractExpression)
with pytest.raises(ValueErr... | [
"pytest.raises",
"cloudwatchiter.abc_expression.AbstractExpression.validate_elements"
] | [((782, 839), 'cloudwatchiter.abc_expression.AbstractExpression.validate_elements', 'AbstractExpression.validate_elements', ([], {'elements': "['1', '2']"}), "(elements=['1', '2'])\n", (818, 839), False, 'from cloudwatchiter.abc_expression import AbstractExpression\n'), ((298, 323), 'pytest.raises', 'pytest.raises', ([... |
import os
import discord
import requests
import json
import random
from replit import db
from keep_alive import keep_alive
my_secret = os.environ['token']
client = discord.Client()
sad_words = ["sad", "angry", "depressed", "unhappy", "misrable", "lonely"]
encougarement_words = ["Cheer Up!",
"Hang In There!!",
"Yo... | [
"json.loads",
"random.choice",
"keep_alive.keep_alive",
"requests.get",
"discord.Client",
"replit.db.keys"
] | [((166, 182), 'discord.Client', 'discord.Client', ([], {}), '()\n', (180, 182), False, 'import discord\n'), ((2702, 2714), 'keep_alive.keep_alive', 'keep_alive', ([], {}), '()\n', (2712, 2714), False, 'from keep_alive import keep_alive\n'), ((365, 374), 'replit.db.keys', 'db.keys', ([], {}), '()\n', (372, 374), False, ... |
import logging
import os
import subprocess
from pathlib import Path
from typing import Dict, Optional, Union
from qaz import settings
logger = logging.getLogger(__name__)
class CommandNotFound(Exception):
"""
The given command was not found.
"""
pass
def run(
command: str,
*,
cwd: Op... | [
"logging.getLogger",
"os.environ.update",
"qaz.settings.get_root_dir"
] | [((146, 173), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (163, 173), False, 'import logging\n'), ((548, 585), 'os.environ.update', 'os.environ.update', (['(env if env else {})'], {}), '(env if env else {})\n', (565, 585), False, 'import os\n'), ((1023, 1060), 'os.environ.update', 'os.... |
"""BMS URL Configuration
The `urlpatterns` list routes URLs to views. For more information please see:
https://docs.djangoproject.com/en/1.11/topics/http/urls/
Examples:
Function views
1. Add an import: from my_app import views
2. Add a URL to urlpatterns: url(r'^$', views.home, name='home')
Class-based ... | [
"django.conf.urls.url"
] | [((747, 778), 'django.conf.urls.url', 'url', (['"""^admin/"""', 'admin.site.urls'], {}), "('^admin/', admin.site.urls)\n", (750, 778), False, 'from django.conf.urls import url\n'), ((796, 841), 'django.conf.urls.url', 'url', (['"""^show_publisher/"""', 'views.show_publisher'], {}), "('^show_publisher/', views.show_publ... |
from torchvision import datasets, transforms
from customImageLoader import CustomImageFolder
from torch.utils.data import SubsetRandomSampler, DataLoader
import numpy as np
class Data:
"""
Class for managing and preparing data for training, validation and testing phases.
"""
def __init__(self, train_p... | [
"torchvision.transforms.CenterCrop",
"torchvision.transforms.RandomRotation",
"numpy.floor",
"torch.utils.data.SubsetRandomSampler",
"torchvision.transforms.RandomHorizontalFlip",
"customImageLoader.CustomImageFolder",
"torchvision.transforms.Normalize",
"torch.utils.data.DataLoader",
"torchvision.t... | [((1515, 1581), 'customImageLoader.CustomImageFolder', 'CustomImageFolder', (['self.train_path'], {'transform': 'self.train_transform'}), '(self.train_path, transform=self.train_transform)\n', (1532, 1581), False, 'from customImageLoader import CustomImageFolder\n'), ((1757, 1786), 'numpy.random.shuffle', 'np.random.sh... |
#!/usr/bin/env python
# -*- encoding=utf8 -*-
__copyright__ = """
Tramet, a sftp/ftp client
Copyright (C) 2020 <NAME> <<EMAIL>>
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... | [
"tkinter.messagebox.showwarning",
"tkinter.filedialog.askdirectory",
"os.path.getsize",
"time.sleep",
"os.path.dirname",
"tkinter.filedialog.askopenfilenames",
"os.path.basename",
"sys.exit",
"queue.Queue",
"Connection.Connection",
"tkinter.messagebox.showinfo"
] | [((1857, 1864), 'queue.Queue', 'Queue', ([], {}), '()\n', (1862, 1864), False, 'from queue import Queue, Empty\n'), ((22515, 22587), 'tkinter.filedialog.askopenfilenames', 'filedialog.askopenfilenames', ([], {'title': '"""Choose files to upload"""', 'parent': 'self'}), "(title='Choose files to upload', parent=self)\n",... |
import requests
import time
from prometheus_client import start_http_server, Gauge
from urllib3.exceptions import InsecureRequestWarning
server_port = 10000
def start_monitoring():
trueconf_units = Gauge('trueconf_units', 'Number of active units', ['unit'])
update_interval = 15
api_endpoint_users = "ht... | [
"requests.packages.urllib3.disable_warnings",
"prometheus_client.Gauge",
"requests.get",
"time.sleep",
"prometheus_client.start_http_server"
] | [((206, 265), 'prometheus_client.Gauge', 'Gauge', (['"""trueconf_units"""', '"""Number of active units"""', "['unit']"], {}), "('trueconf_units', 'Number of active units', ['unit'])\n", (211, 265), False, 'from prometheus_client import start_http_server, Gauge\n'), ((1488, 1563), 'requests.packages.urllib3.disable_warn... |
#!/usr/bin/env python
from __future__ import print_function
from setuptools import setup
import sys
setup_args = dict(
name='yam_sort',
version='1.0',
author='<NAME>',
author_email='<EMAIL>',
url='https://github.com/Crawfishpress/yam_sort',
description='does basic diff-ing of YAML files while ... | [
"setuptools.setup",
"sys.exit"
] | [((1380, 1399), 'setuptools.setup', 'setup', ([], {}), '(**setup_args)\n', (1385, 1399), False, 'from setuptools import setup\n'), ((1600, 1611), 'sys.exit', 'sys.exit', (['(1)'], {}), '(1)\n', (1608, 1611), False, 'import sys\n')] |
import os
from flask import Flask, jsonify, send_file
from flask_cors import CORS
from flask_jwt_extended import JWTManager
from api.login import blueprint as login_blueprint
from api.odoo import blueprint as odoo_blueprint
app = Flask(__name__)
ALLOW_ALL_ORIGINS = os.getenv("ALLOW_ALL_ORIGINS")
if ALLOW_ALL_ORIGINS... | [
"flask_jwt_extended.JWTManager",
"flask_cors.CORS",
"os.getenv",
"flask.Flask",
"os.environ.get",
"os.path.join",
"os.path.isfile",
"flask.send_file",
"flask.jsonify"
] | [((233, 248), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (238, 248), False, 'from flask import Flask, jsonify, send_file\n'), ((269, 299), 'os.getenv', 'os.getenv', (['"""ALLOW_ALL_ORIGINS"""'], {}), "('ALLOW_ALL_ORIGINS')\n", (278, 299), False, 'import os\n'), ((367, 399), 'os.environ.get', 'os.enviro... |
"""Main file for converting RedBrick format to coco format."""
import asyncio
from typing import Dict, List, Optional, Tuple
import aiohttp
from yarl import URL
import tenacity
from redbrick.utils.async_utils import gather_with_concurrency
from redbrick.utils import aioimgspy
from redbrick.utils.logging import print_... | [
"aiohttp.ClientSession",
"redbrick.utils.logging.print_warning",
"redbrick.utils.aioimgspy.probe",
"tenacity.retry_if_not_exception_type",
"redbrick.utils.async_utils.gather_with_concurrency",
"asyncio.sleep",
"yarl.URL",
"aiohttp.TCPConnector",
"tenacity.wait_exponential",
"tenacity.stop_after_at... | [((1586, 1629), 'aiohttp.TCPConnector', 'aiohttp.TCPConnector', ([], {'limit': 'MAX_CONCURRENCY'}), '(limit=MAX_CONCURRENCY)\n', (1606, 1629), False, 'import aiohttp\n'), ((1645, 1682), 'aiohttp.ClientSession', 'aiohttp.ClientSession', ([], {'connector': 'conn'}), '(connector=conn)\n', (1666, 1682), False, 'import aioh... |
# Weaver: A Spiderling that can alter existing Webs by weaving to add or remove silk from the Webs, thus altering its strength.
# DO NOT MODIFY THIS FILE
# Never try to directly create an instance of this class, or modify its member variables.
# Instead, you should only be reading its variables and calling its functio... | [
"games.spiders.spiderling.Spiderling.__init__"
] | [((924, 949), 'games.spiders.spiderling.Spiderling.__init__', 'Spiderling.__init__', (['self'], {}), '(self)\n', (943, 949), False, 'from games.spiders.spiderling import Spiderling\n')] |
import os
import time
import sys
import paho.mqtt.client as mqtt
import json
from subprocess import check_output
from re import findall
def get_temp():
temp = check_output(["vcgencmd","measure_temp"]).decode("UTF-8")
return(findall("\d+\.\d+",temp)[0])
THINGSBOARD_HOST = '192.168.1.2'
ACCESS_TOKEN = '<KEY>'
... | [
"subprocess.check_output",
"paho.mqtt.client.Client",
"json.dumps",
"time.sleep",
"re.findall",
"time.time"
] | [((477, 488), 'time.time', 'time.time', ([], {}), '()\n', (486, 488), False, 'import time\n'), ((500, 513), 'paho.mqtt.client.Client', 'mqtt.Client', ([], {}), '()\n', (511, 513), True, 'import paho.mqtt.client as mqtt\n'), ((233, 261), 're.findall', 'findall', (['"""\\\\d+\\\\.\\\\d+"""', 'temp'], {}), "('\\\\d+\\\\.\... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import numpy as np
from gym import spaces
from pycolab.examples import (better_scrolly_maze,
deepmind_maze,
deepmind_5room,
... | [
"pycolab.examples.deepmind_5room_moveable.make_game",
"pycolab.examples.deepmind_8room_v1.make_game",
"pycolab.examples.deepmind_5room_moveable_v1.make_game",
"gym.spaces.Discrete",
"pycolab.examples.deepmind_5room_brownian.make_game",
"pycolab.examples.deepmind_maze.make_game",
"pycolab.cropping.Scroll... | [((1529, 1570), 'pycolab.examples.better_scrolly_maze.make_game', 'better_scrolly_maze.make_game', (['self.level'], {}), '(self.level)\n', (1558, 1570), False, 'from pycolab.examples import better_scrolly_maze, deepmind_maze, deepmind_5room, deepmind_5room_randomfixed, deepmind_5room_bouncing, deepmind_5room_brownian, ... |
import numpy as np
from IMLearn.learners.classifiers import Perceptron, LDA, GaussianNaiveBayes
from typing import Tuple
from utils import *
from os import path
import plotly.graph_objects as go
from plotly.subplots import make_subplots
from matplotlib import pyplot as plt
from math import atan2, pi
def load_dataset... | [
"IMLearn.learners.classifiers.Perceptron",
"matplotlib.pyplot.ylabel",
"IMLearn.learners.classifiers.GaussianNaiveBayes",
"matplotlib.pyplot.xlabel",
"os.path.join",
"numpy.diag",
"numpy.linalg.eigvalsh",
"plotly.graph_objects.Scatter",
"numpy.linspace",
"numpy.random.seed",
"math.atan2",
"num... | [((885, 902), 'numpy.load', 'np.load', (['filename'], {}), '(filename)\n', (892, 902), True, 'import numpy as np\n'), ((2656, 2683), 'numpy.linspace', 'np.linspace', (['(0)', '(2 * pi)', '(100)'], {}), '(0, 2 * pi, 100)\n', (2667, 2683), True, 'import numpy as np\n'), ((2849, 2923), 'plotly.graph_objects.Scatter', 'go.... |
import sys
read = sys.stdin.buffer.read
readline = sys.stdin.readline
readlines = sys.stdin.buffer.readlines
sys.setrecursionlimit(10 ** 7)
from operator import or_
class SegmentTree:
def __init__(self, orig, func, unit):
_len = len(orig)
self.func = func
self.size = 1 << (_len - 1).bit_l... | [
"sys.setrecursionlimit"
] | [((109, 139), 'sys.setrecursionlimit', 'sys.setrecursionlimit', (['(10 ** 7)'], {}), '(10 ** 7)\n', (130, 139), False, 'import sys\n')] |
import re
import sys
from zttf.ttfile import TTFile
from struct import unpack
def glyphBox(f,g):
data = f.get_glyph_data(g)
if not len(data):
return (0,0,0,0)
return unpack(">hhhhh", data[:10])[1:]
def describeChar(c):
if c >= 32 and c<127 and c != ord('\\') and c != ord('"'):
return '... | [
"re.sub",
"zttf.ttfile.TTFile",
"struct.unpack",
"sys.exit"
] | [((519, 538), 'zttf.ttfile.TTFile', 'TTFile', (['sys.argv[1]'], {}), '(sys.argv[1])\n', (525, 538), False, 'from zttf.ttfile import TTFile\n'), ((547, 566), 'zttf.ttfile.TTFile', 'TTFile', (['sys.argv[1]'], {}), '(sys.argv[1])\n', (553, 566), False, 'from zttf.ttfile import TTFile\n'), ((1332, 1367), 're.sub', 're.sub'... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Copyright(c) 2014 <NAME>
#
#
# Example:
# Portscan hosta, hostb, hostc (a->a, a->b, a->c, b->a, b->b, ...)
# on all tcp port numbers listening on at least one of hosta, hostb, hostc:
#
# $ fab -H hosta,hostb,hostc list_open_ports > ports.txt
# $ plist="`grep out:.. po... | [
"fabric.api.run",
"fabric.api.hide"
] | [((1028, 1043), 'fabric.api.hide', 'hide', (['"""running"""'], {}), "('running')\n", (1032, 1043), False, 'from fabric.api import hide\n'), ((1057, 1065), 'fabric.api.run', 'run', (['cmd'], {}), '(cmd)\n', (1060, 1065), False, 'from fabric.api import run\n'), ((1318, 1333), 'fabric.api.hide', 'hide', (['"""running"""']... |
import torch
from .strategy import Strategy
class BALDDropout(Strategy):
"""
Implements Bayesian Active Learning by Disagreement (BALD) Strategy :footcite:`houlsby2011bayesian`,
which assumes a Basiyan setting and selects points which maximise the mutual information
between the predicted ... | [
"torch.log"
] | [((1967, 1980), 'torch.log', 'torch.log', (['pb'], {}), '(pb)\n', (1976, 1980), False, 'import torch\n'), ((2017, 2033), 'torch.log', 'torch.log', (['probs'], {}), '(probs)\n', (2026, 2033), False, 'import torch\n')] |
import FINE as fn
import pandas as pd
import numpy as np
"""
Here we are testing differnt inputs for time-invariant conversion factors that are
not covered in the minimal test system or other tests.
"""
def create_core_esm():
"""
We create a core esm that only consists of a source and a sink in one location.
... | [
"pandas.Series",
"FINE.Sink",
"numpy.array",
"FINE.EnergySystemModel",
"FINE.Source"
] | [((437, 760), 'FINE.EnergySystemModel', 'fn.EnergySystemModel', ([], {'locations': "{'ElectrolyzerLocation'}", 'commodities': "{'electricity', 'hydrogen'}", 'numberOfTimeSteps': 'numberOfTimeSteps', 'commodityUnitsDict': "{'electricity': 'kW$_{el}$', 'hydrogen': 'kW$_{H_{2},LHV}$'}", 'hoursPerTimeStep': 'hoursPerTimeSt... |
from unittest.mock import patch
from nose.tools import assert_in, eq_
from pyecharts import options as opts
from pyecharts.charts import Grid, Liquid
from pyecharts.commons.utils import JsCode
@patch("pyecharts.render.engine.write_utf8_html_file")
def test_liquid_base(fake_writer):
c = Liquid().add("lq", [0.6, ... | [
"nose.tools.eq_",
"pyecharts.options.TitleOpts",
"pyecharts.charts.Liquid",
"pyecharts.commons.utils.JsCode",
"nose.tools.assert_in",
"pyecharts.charts.Grid",
"unittest.mock.patch",
"pyecharts.options.GridOpts"
] | [((198, 251), 'unittest.mock.patch', 'patch', (['"""pyecharts.render.engine.write_utf8_html_file"""'], {}), "('pyecharts.render.engine.write_utf8_html_file')\n", (203, 251), False, 'from unittest.mock import patch\n'), ((442, 495), 'unittest.mock.patch', 'patch', (['"""pyecharts.render.engine.write_utf8_html_file"""'],... |
# --------------------------------------------------------------------------
#
# Copyright (c) Microsoft Corporation. All rights reserved.
#
# The MIT License (MIT)
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the ""Software""), ... | [
"asyncio.sleep",
"typing.TypeVar"
] | [((2130, 2162), 'typing.TypeVar', 'TypeVar', (['"""AsyncHTTPResponseType"""'], {}), "('AsyncHTTPResponseType')\n", (2137, 2162), False, 'from typing import AsyncIterator as AsyncIteratorType, TypeVar, Generic, Any\n'), ((2182, 2209), 'typing.TypeVar', 'TypeVar', (['"""HTTPResponseType"""'], {}), "('HTTPResponseType')\n... |
import os, hashlib, binascii as ba
import base64, re
import time, math
from colors import *
# from functools import lru_cache
from numba import jit
from cachetools.func import *
from cachy import *
def iif(a,b,c):return b if a else c
import json
def obj2json(obj):
return json.dumps(obj, ensure_ascii=False, sort_... | [
"timeit.Timer",
"zlib.adler32",
"os.urandom",
"base64.b64encode",
"json.dumps",
"binascii.b2a_hex",
"time.sleep",
"os.mkdir",
"re.findall",
"os.remove"
] | [((279, 340), 'json.dumps', 'json.dumps', (['obj'], {'ensure_ascii': '(False)', 'sort_keys': '(True)', 'indent': '(2)'}), '(obj, ensure_ascii=False, sort_keys=True, indent=2)\n', (289, 340), False, 'import json\n'), ((3119, 3133), 'os.urandom', 'os.urandom', (['(32)'], {}), '(32)\n', (3129, 3133), False, 'import os, ha... |
"""
Copyright (c) 2013, SMART Technologies ULC
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 an... | [
"log.Logger",
"os.getcwd"
] | [((3771, 3779), 'log.Logger', 'Logger', ([], {}), '()\n', (3777, 3779), False, 'from log import Logger\n'), ((2051, 2062), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (2060, 2062), False, 'import os\n')] |
#!/usr/bin/env python3
# imports go here
import pandas as pd
import plotly.plotly as py
from plotly.graph_objs import *
#
# Free Coding session for 2015-05-24
# Written by <NAME>
#
years = list(range(2015, 2045))
YEARS_TO_SIMULATE = 30
INFLATION_RATE = 0.02
KWH_PRICE = 0.10 # 2015 dollars
INSTALL_COST_PER_WATT =... | [
"plotly.plotly.plot"
] | [((1134, 1172), 'plotly.plotly.plot', 'py.plot', (['fig'], {'filename': '"""Cost Per watt"""'}), "(fig, filename='Cost Per watt')\n", (1141, 1172), True, 'import plotly.plotly as py\n')] |
from __future__ import print_function # Python2 support
import josepy
from cryptography.hazmat.primitives import serialization
def jwk_to_pem(pkey_jwk):
"""
LetsEncrypt uses RSA Private Keys as Account Keys.
Certbot stores the Account Keys as a JWK (JSON Web Key) encoded string.
Many non-certbot cli... | [
"cryptography.hazmat.primitives.serialization.NoEncryption",
"json.loads",
"josepy.JWKRSA.load",
"josepy.JWKRSA.json_loads"
] | [((693, 727), 'josepy.JWKRSA.json_loads', 'josepy.JWKRSA.json_loads', (['pkey_jwk'], {}), '(pkey_jwk)\n', (717, 727), False, 'import josepy\n'), ((1769, 1797), 'josepy.JWKRSA.load', 'josepy.JWKRSA.load', (['pkey_pem'], {}), '(pkey_pem)\n', (1787, 1797), False, 'import josepy\n'), ((902, 930), 'cryptography.hazmat.primi... |
import os
import shutil
import sys
MEDCOMMON_ROOT = os.path.join(os.path.dirname(os.path.abspath(__file__)), os.path.pardir, os.path.pardir)
sys.path.append(MEDCOMMON_ROOT)
sys.path.append(os.path.join(MEDCOMMON_ROOT, 'external_lib'))
from utils.data_io_utils import DataIO
from utils.mask_bounding_utils import MaskBo... | [
"os.path.exists",
"os.listdir",
"utils.datasets_utils.DatasetsUtils.resample_image_mask_unsame_resolution_multiprocess",
"json.dumps",
"os.path.join",
"SimpleITK.GetArrayFromImage",
"utils.detection_utils.DETECTION_UTILS.point_coordinate_resampled",
"torch.from_numpy",
"utils.mask_bounding_utils.Mas... | [((142, 173), 'sys.path.append', 'sys.path.append', (['MEDCOMMON_ROOT'], {}), '(MEDCOMMON_ROOT)\n', (157, 173), False, 'import sys\n'), ((190, 234), 'os.path.join', 'os.path.join', (['MEDCOMMON_ROOT', '"""external_lib"""'], {}), "(MEDCOMMON_ROOT, 'external_lib')\n", (202, 234), False, 'import os\n'), ((1317, 1350), 'os... |
from django.contrib import admin
from .models import Category, Company, JobPost
admin.site.register(Category)
admin.site.register(Company)
admin.site.register(JobPost)
| [
"django.contrib.admin.site.register"
] | [((82, 111), 'django.contrib.admin.site.register', 'admin.site.register', (['Category'], {}), '(Category)\n', (101, 111), False, 'from django.contrib import admin\n'), ((112, 140), 'django.contrib.admin.site.register', 'admin.site.register', (['Company'], {}), '(Company)\n', (131, 140), False, 'from django.contrib impo... |
from bs4 import BeautifulSoup
import json
file = open('input', 'r')
contents = ''
if file.mode == 'r':
contents = file.read()
file.close()
if not contents:
exit
output = []
soup = BeautifulSoup(contents)
trs = soup.find('aside' , {'class' : 'inline inline-table'}).find('table').findAll('tr')
currentWeek =... | [
"bs4.BeautifulSoup",
"json.dumps"
] | [((194, 217), 'bs4.BeautifulSoup', 'BeautifulSoup', (['contents'], {}), '(contents)\n', (207, 217), False, 'from bs4 import BeautifulSoup\n'), ((1103, 1121), 'json.dumps', 'json.dumps', (['output'], {}), '(output)\n', (1113, 1121), False, 'import json\n')] |
#!/usr/bin/env python
# Copyright (2013) JDSU T&M Pte Ltd. All rights reserved.
"""
This script calls the PI XML-API to get the card and port status of the PI hardware
and writes the result to a temporary file. The IWF reads the result and set the
IWF/traffic-hardware config parameter, which is read by the Job-manag... | [
"os.path.abspath",
"xml.etree.ElementTree.Element",
"tempfile.gettempdir"
] | [((397, 422), 'os.path.abspath', 'os.path.abspath', (['__file__'], {}), '(__file__)\n', (412, 422), False, 'import os, sys, tempfile\n'), ((3664, 3683), 'xml.etree.ElementTree.Element', 'Element', (['"""hardware"""'], {}), "('hardware')\n", (3671, 3683), False, 'from xml.etree.ElementTree import Element\n'), ((3738, 37... |
from rest_framework import generics
from rest_framework import permissions
from cms.models.Player import Player, PlayerSerializer
class PlayerList(generics.ListCreateAPIView):
queryset = Player.objects.all()
serializer_class = PlayerSerializer
class PlayerDetail(generics.RetrieveUpdateDestroyAPIView):
queryset = ... | [
"cms.models.Player.Player.objects.all"
] | [((189, 209), 'cms.models.Player.Player.objects.all', 'Player.objects.all', ([], {}), '()\n', (207, 209), False, 'from cms.models.Player import Player, PlayerSerializer\n'), ((320, 340), 'cms.models.Player.Player.objects.all', 'Player.objects.all', ([], {}), '()\n', (338, 340), False, 'from cms.models.Player import Pla... |
from django.contrib.auth.models import AbstractUser
from django.core.validators import RegexValidator
from django.db import models
class UserProfile(AbstractUser):
phone_validator = RegexValidator(
regex=r'^\+?1?\d{9, 15}$',
message=('Введите номер до 15 знаков')
)
phone_number = models.Ch... | [
"django.core.validators.RegexValidator",
"django.db.models.CharField",
"django.db.models.BooleanField"
] | [((188, 273), 'django.core.validators.RegexValidator', 'RegexValidator', ([], {'regex': '"""^\\\\+?1?\\\\d{9, 15}$"""', 'message': '"""Введите номер до 15 знаков"""'}), "(regex='^\\\\+?1?\\\\d{9, 15}$', message='Введите номер до 15 знаков'\n )\n", (202, 273), False, 'from django.core.validators import RegexValidator... |
from .constants import *
from multiprocessing import Queue
from typing import Iterator
from redis import Redis
from time import perf_counter
import socket
import ssl
import brotli
context = ssl.create_default_context()
def parse_chunked_body(data):
temp = b""
while True:
size, data = data.split(b"\r\n... | [
"ssl.create_default_context",
"brotli.decompress",
"socket.socket"
] | [((191, 219), 'ssl.create_default_context', 'ssl.create_default_context', ([], {}), '()\n', (217, 219), False, 'import ssl\n'), ((450, 473), 'brotli.decompress', 'brotli.decompress', (['temp'], {}), '(temp)\n', (467, 473), False, 'import brotli\n'), ((1592, 1607), 'socket.socket', 'socket.socket', ([], {}), '()\n', (16... |
# --------------
import pandas as pd
import numpy as np
from sklearn.cross_validation import train_test_split
# code starts here
df = pd.read_csv(path)
df.head()
X = df.drop('list_price',axis=1)
y = df['list_price']
X_train, X_test, y_train, y_test = train_test_split(X, y,test_size=0.3,random_state=6)
# code ends here
... | [
"sklearn.linear_model.LinearRegression",
"pandas.read_csv",
"sklearn.metrics.mean_squared_error",
"sklearn.cross_validation.train_test_split",
"sklearn.metrics.r2_score",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.show"
] | [((134, 151), 'pandas.read_csv', 'pd.read_csv', (['path'], {}), '(path)\n', (145, 151), True, 'import pandas as pd\n'), ((251, 304), 'sklearn.cross_validation.train_test_split', 'train_test_split', (['X', 'y'], {'test_size': '(0.3)', 'random_state': '(6)'}), '(X, y, test_size=0.3, random_state=6)\n', (267, 304), False,... |
# Generated by Django 2.0.7 on 2018-08-21 23:31
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('core', '0004_auto_20180821_2328'),
]
operations = [
migrations.AlterField(
model_name='cliente',
name='key',
... | [
"django.db.migrations.DeleteModel",
"django.db.models.IntegerField"
] | [((373, 407), 'django.db.migrations.DeleteModel', 'migrations.DeleteModel', ([], {'name': '"""Key"""'}), "(name='Key')\n", (395, 407), False, 'from django.db import migrations, models\n'), ((331, 352), 'django.db.models.IntegerField', 'models.IntegerField', ([], {}), '()\n', (350, 352), False, 'from django.db import mi... |
"""Factory for Python Protocol API instances."""
import asyncio
from opentrons.protocol_engine import ProtocolEngine
from opentrons.protocol_engine.clients import SyncClient, ChildThreadTransport
from opentrons.protocol_api_experimental import ProtocolContext
class ContextCreator:
"""A factory to build Python Pro... | [
"opentrons.protocol_engine.clients.SyncClient",
"opentrons.protocol_api_experimental.ProtocolContext",
"opentrons.protocol_engine.clients.ChildThreadTransport"
] | [((896, 954), 'opentrons.protocol_engine.clients.ChildThreadTransport', 'ChildThreadTransport', ([], {'engine': 'self._engine', 'loop': 'self._loop'}), '(engine=self._engine, loop=self._loop)\n', (916, 954), False, 'from opentrons.protocol_engine.clients import SyncClient, ChildThreadTransport\n'), ((972, 1003), 'opent... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# Copyright 2020-2022 F4PGA Authors
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unl... | [
"edalize.get_edatool",
"os.makedirs",
"os.path.join",
"os.path.realpath",
"glob.glob"
] | [((802, 839), 'os.makedirs', 'os.makedirs', (['work_root'], {'exist_ok': '(True)'}), '(work_root, exist_ok=True)\n', (813, 839), False, 'import os\n'), ((870, 886), 'glob.glob', 'glob.glob', (['"""*.v"""'], {}), "('*.v')\n", (879, 886), False, 'import glob\n'), ((764, 799), 'os.path.join', 'os.path.join', (['work_root'... |
# Copyright (c) 2020 MeetKai Inc. All rights reserved.
import os
import re
import json
from typing import Dict, Tuple
from rapidfuzz import fuzz, process
from glob import glob
def url_to_qvalue(url: str) -> str:
"""Get q value from Wikidata url.
http://www.wikidata.org/entity/Q494 -> Q494
"""
return... | [
"rapidfuzz.process.extractOne",
"os.path.join",
"os.path.isdir",
"json.load",
"re.findall"
] | [((423, 446), 'os.path.isdir', 'os.path.isdir', (['data_dir'], {}), '(data_dir)\n', (436, 446), False, 'import os\n'), ((503, 551), 'os.path.join', 'os.path.join', (['data_dir', '"""*-5k-preprocessed.json"""'], {}), "(data_dir, '*-5k-preprocessed.json')\n", (515, 551), False, 'import os\n'), ((1558, 1654), 'rapidfuzz.p... |
""""
Code for keyboard manipulation to read user data and interact with the Brother
editor to print a label.
Authors: <NAME> and <NAME>
"""
import time
import pyautogui
import csv
def print_label(id):
fields = []
rows = []
#read student data from a CSV
data = open("sample_student_data_read.... | [
"pyautogui.press",
"pyautogui.hotkey",
"csv.reader",
"time.sleep"
] | [((347, 363), 'csv.reader', 'csv.reader', (['data'], {}), '(data)\n', (357, 363), False, 'import csv\n'), ((556, 569), 'time.sleep', 'time.sleep', (['(5)'], {}), '(5)\n', (566, 569), False, 'import time\n'), ((955, 968), 'time.sleep', 'time.sleep', (['(5)'], {}), '(5)\n', (965, 968), False, 'import time\n'), ((973, 100... |
from katana.utils import Node, Pair, prepare
from katana.term import null
def sequence(*terms):
def fn(pair):
for each in terms:
pair = each(pair)
return pair
return fn
def group(expr):
def fn(pair):
# we use an empty pair to 'capture' the nodes
# produced by ... | [
"katana.utils.Node",
"katana.utils.prepare",
"katana.utils.Pair"
] | [((352, 370), 'katana.utils.prepare', 'prepare', (['pair.tail'], {}), '(pair.tail)\n', (359, 370), False, 'from katana.utils import Node, Pair, prepare\n'), ((408, 426), 'katana.utils.Node', 'Node', (['fn', 'p2.nodes'], {}), '(fn, p2.nodes)\n', (412, 426), False, 'from katana.utils import Node, Pair, prepare\n'), ((442... |
from django.forms import widgets
from django.template.defaultfilters import filesizeformat
from django.utils.safestring import mark_safe
class BlobWidget(widgets.FileInput):
def render(self, name, value, attrs=None):
try:
blob_size = len(value)
except:
blob_size = 0
... | [
"django.template.defaultfilters.filesizeformat",
"django.utils.safestring.mark_safe"
] | [((333, 358), 'django.template.defaultfilters.filesizeformat', 'filesizeformat', (['blob_size'], {}), '(blob_size)\n', (347, 358), False, 'from django.template.defaultfilters import filesizeformat\n'), ((449, 511), 'django.utils.safestring.mark_safe', 'mark_safe', (["('%s<p>Current size: %s</p>' % (original, blob_size)... |
import SimpleITK as sitk
import os
from pathlib import Path
from lama import common
import nrrd
import numpy as np
from scipy import ndimage
target_dir = Path(os.getcwd())
volpaths = common.get_file_paths(target_dir)
scaled = "scaled"
print(target_dir)
print('zooming')
for path in volpaths:
vol, v_head = nrrd.r... | [
"lama.common.get_file_paths",
"nrrd.read",
"os.getcwd",
"os.path.basename",
"lama.common.LoadImage",
"scipy.ndimage.zoom"
] | [((185, 218), 'lama.common.get_file_paths', 'common.get_file_paths', (['target_dir'], {}), '(target_dir)\n', (206, 218), False, 'from lama import common\n'), ((160, 171), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (169, 171), False, 'import os\n'), ((314, 329), 'nrrd.read', 'nrrd.read', (['path'], {}), '(path)\n', (32... |