code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
# -*- coding: utf-8 -*-
# 导入模块
import sys
from PyQt5.QtWidgets import QMainWindow , QApplication
from PyQt5.QtCore import Qt
### 自定义窗口类
class MyWindow( QMainWindow):
'''自定义窗口类'''
### 构造函数
def __init__(self,parent=None):
'''构造函数'''
# 调用父类构造函数
super(MyWindow,self).__init__(parent... | [
"PyQt5.QtWidgets.QApplication",
"PyQt5.QtWidgets.QApplication.desktop"
] | [((838, 860), 'PyQt5.QtWidgets.QApplication', 'QApplication', (['sys.argv'], {}), '(sys.argv)\n', (850, 860), False, 'from PyQt5.QtWidgets import QMainWindow, QApplication\n'), ((589, 611), 'PyQt5.QtWidgets.QApplication.desktop', 'QApplication.desktop', ([], {}), '()\n', (609, 611), False, 'from PyQt5.QtWidgets import ... |
# -*- coding: utf-8 -*-
# (C) Copyright IBM Corp. 2021.
#
# 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 l... | [
"io.BytesIO",
"uuid.uuid4",
"os.path.exists"
] | [((1839, 1866), 'os.path.exists', 'os.path.exists', (['config_file'], {}), '(config_file)\n', (1853, 1866), False, 'import os\n'), ((2196, 2223), 'os.path.exists', 'os.path.exists', (['config_file'], {}), '(config_file)\n', (2210, 2223), False, 'import os\n'), ((11914, 11989), 'io.BytesIO', 'io.BytesIO', (["b'This is a... |
import sympy
from sympy import Function, dsolve, Symbol
# symbols
t = Symbol('t', positive=True)
zeta = Symbol('\zeta', constant=True, positive=True)
# unknown function
u = Function('u')(t)
# assumed values
u0 = 1
v0 = 0
wn = 4.
wd = wn*sympy.sqrt(1-zeta**2)
ics = {u.subs(t, 0): u0, u.diff(t).subs(t, 0): v0}
sol = ... | [
"sympy.Symbol",
"sympy.sqrt",
"matplotlib.use",
"sympy.Function",
"sympy.plotting.plot3d"
] | [((71, 97), 'sympy.Symbol', 'Symbol', (['"""t"""'], {'positive': '(True)'}), "('t', positive=True)\n", (77, 97), False, 'from sympy import Function, dsolve, Symbol\n'), ((105, 151), 'sympy.Symbol', 'Symbol', (['"""\\\\zeta"""'], {'constant': '(True)', 'positive': '(True)'}), "('\\\\zeta', constant=True, positive=True)\... |
import datetime
from django.db import models
from django.utils.translation import ugettext as _
from django.core.validators import RegexValidator
from base.models import (Address, Center, Participant)
class EventCategory(models.Model):
category = models.CharField(max_length=50, default="", help_text=_("Event Categ... | [
"django.db.models.ForeignKey",
"django.utils.translation.ugettext",
"django.db.models.CharField",
"datetime.datetime.now"
] | [((946, 998), 'django.db.models.ForeignKey', 'models.ForeignKey', (['Address'], {'on_delete': 'models.CASCADE'}), '(Address, on_delete=models.CASCADE)\n', (963, 998), False, 'from django.db import models\n'), ((2049, 2115), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(6)', 'choices': 'GENDER_... |
#!/usr/bin/env python
# coding=utf-8
# pylint: disable=broad-except,unused-argument,line-too-long, unused-variable
# Copyright (c) 2016-2018, F5 Networks, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy ... | [
"ibm_boto3.s3.transfer.TransferManager",
"os.unlink",
"os.path.isdir",
"logging.StreamHandler",
"os.path.exists",
"json.dumps",
"time.time",
"logging.Formatter",
"ibm_botocore.client.Config",
"os.path.splitext",
"datetime.datetime.fromtimestamp",
"sys.exit",
"ibm_boto3.s3.transfer.TransferCo... | [((1255, 1303), 'logging.getLogger', 'logging.getLogger', (['"""ibmcloud_cos_image_uploader"""'], {}), "('ibmcloud_cos_image_uploader')\n", (1272, 1303), False, 'import logging\n'), ((1344, 1417), 'logging.Formatter', 'logging.Formatter', (['"""%(asctime)s - %(name)s - %(levelname)s - %(message)s"""'], {}), "('%(asctim... |
from qtpy.QtCore import Qt, Signal
from qtpy.QtWidgets import (
QHBoxLayout,
QLabel,
QPushButton,
QTableWidget,
QTableWidgetItem,
QVBoxLayout,
QWidget,
)
from ...settings import get_settings
from ...utils.translations import trans
class Extension2ReaderTable(QWidget):
"""Table showing... | [
"qtpy.QtWidgets.QHBoxLayout",
"qtpy.QtWidgets.QLabel",
"qtpy.QtWidgets.QTableWidget",
"qtpy.QtWidgets.QVBoxLayout",
"qtpy.QtWidgets.QWidget",
"qtpy.QtWidgets.QPushButton",
"qtpy.QtCore.Signal",
"qtpy.QtWidgets.QTableWidgetItem"
] | [((446, 457), 'qtpy.QtCore.Signal', 'Signal', (['int'], {}), '(int)\n', (452, 457), False, 'from qtpy.QtCore import Qt, Signal\n'), ((559, 573), 'qtpy.QtWidgets.QTableWidget', 'QTableWidget', ([], {}), '()\n', (571, 573), False, 'from qtpy.QtWidgets import QHBoxLayout, QLabel, QPushButton, QTableWidget, QTableWidgetIte... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sun Oct 11 14:03:30 2020
@author: acpotter
"""
#%% -- IMPORTS --
import sys
sys.path.append("..") # import one subdirectory up in files
# external packages
import numpy as np
import qiskit as qk
import networkx as nx
#import tenpy
# custom things
#import... | [
"sys.path.append",
"numpy.moveaxis",
"qiskit.QuantumCircuit",
"qiskit.execute",
"networkx.topological_sort",
"networkx.algorithms.dag.is_directed_acyclic_graph",
"networkx.DiGraph",
"qiskit.Aer.get_backend"
] | [((140, 161), 'sys.path.append', 'sys.path.append', (['""".."""'], {}), "('..')\n", (155, 161), False, 'import sys\n'), ((1513, 1552), 'qiskit.Aer.get_backend', 'qk.Aer.get_backend', (['"""unitary_simulator"""'], {}), "('unitary_simulator')\n", (1531, 1552), True, 'import qiskit as qk\n'), ((6841, 6880), 'qiskit.Aer.ge... |
from tkinter import Tk, Entry, Button
import threading
flag = True
master = Tk()
e = Entry(master)
e.pack()
e.focus_set()
def enterName():
print(e.get())
def stop():
global flag
flag = False
def exitApp():
master.destroy()
def cycle():
def callback():
global flag
a = 0
flag... | [
"tkinter.Button",
"threading.Thread",
"tkinter.Entry",
"tkinter.Tk"
] | [((77, 81), 'tkinter.Tk', 'Tk', ([], {}), '()\n', (79, 81), False, 'from tkinter import Tk, Entry, Button\n'), ((86, 99), 'tkinter.Entry', 'Entry', (['master'], {}), '(master)\n', (91, 99), False, 'from tkinter import Tk, Entry, Button\n'), ((455, 508), 'tkinter.Button', 'Button', (['master'], {'text': '"""start"""', '... |
import ipaddress
import os
import errno
import logging
import sys
from typing import List, Union
import csv, io, json
dir_path = os.path.dirname(os.path.realpath(__file__))
def is_ip(string: str) -> bool:
try:
ipaddress.ip_address(string)
return True
except ValueError:
return False
... | [
"io.StringIO",
"logging.FileHandler",
"csv.pop",
"os.path.realpath",
"logging.StreamHandler",
"os.path.dirname",
"ipaddress.ip_address",
"logging.Formatter",
"csv.append",
"os.listdir"
] | [((147, 173), 'os.path.realpath', 'os.path.realpath', (['__file__'], {}), '(__file__)\n', (163, 173), False, 'import os\n'), ((1168, 1201), 'logging.StreamHandler', 'logging.StreamHandler', (['sys.stdout'], {}), '(sys.stdout)\n', (1189, 1201), False, 'import logging\n'), ((1211, 1261), 'logging.FileHandler', 'logging.F... |
#-----------------------------------------------------
# Mimas: conference submission and review system
# (c) <NAME> 2016-2020 http://www.allankelly.net
# Licensed under MIT License, see LICENSE file
# -----------------------------------------------------
# schedule.py
#
# System imports
import datetime
# Google impo... | [
"google.appengine.ext.ndb.PickleProperty",
"google.appengine.ext.ndb.Key"
] | [((711, 731), 'google.appengine.ext.ndb.PickleProperty', 'ndb.PickleProperty', ([], {}), '()\n', (729, 731), False, 'from google.appengine.ext import ndb\n'), ((752, 772), 'google.appengine.ext.ndb.PickleProperty', 'ndb.PickleProperty', ([], {}), '()\n', (770, 772), False, 'from google.appengine.ext import ndb\n'), ((4... |
"""
Provide access to the tag definitions and utilities.
Reads and parses into a dict the json tag def file. Provides access to this dict.
Takes a key_dict and applies tags per the tag definations.
"""
import logging
import json
import os
import re
import sys
import stat_key_browser
KEY_TAG_DEFS_FILENAME = 'key_tags.... | [
"logging.error",
"json.load",
"logging.debug",
"re.search",
"os.path.join",
"sys.exit"
] | [((2208, 2260), 'os.path.join', 'os.path.join', (['basedir', '"""data"""', 'KEY_TAG_DEFS_FILENAME'], {}), "(basedir, 'data', KEY_TAG_DEFS_FILENAME)\n", (2220, 2260), False, 'import os\n'), ((2269, 2332), 'logging.debug', 'logging.debug', (['"""Expect key tag definitions at """'], {'path': 'defs_path'}), "('Expect key t... |
import movie_service
import requests.exceptions
def print_header():
print("------------------------------------------------")
print(" MOVIE SEARCH APP")
print("------------------------------------------------")
def run_search_loop():
exit_cmds = ['x', 'exit', 'quit', 'q']
search_ter... | [
"movie_service.search_movie",
"movie_service.print_movies"
] | [((544, 583), 'movie_service.search_movie', 'movie_service.search_movie', (['search_term'], {}), '(search_term)\n', (570, 583), False, 'import movie_service\n'), ((600, 634), 'movie_service.print_movies', 'movie_service.print_movies', (['movies'], {}), '(movies)\n', (626, 634), False, 'import movie_service\n')] |
import os.path
import threading
import wx
from ..dofile.do_file_collection import DoFileCollection
EVT_COMPLETE_ID = wx.NewId()
def evt_complete(win, func):
win.Connect(-1, -1, EVT_COMPLETE_ID, func)
class CompleteEvent(wx.PyEvent):
def __init__(self, message, success):
super().__init__()
... | [
"wx.NewId"
] | [((121, 131), 'wx.NewId', 'wx.NewId', ([], {}), '()\n', (129, 131), False, 'import wx\n')] |
import asyncio
from pubgate.crypto.key import get_key
from pubgate.utils.networking import deliver
class UserUtils:
@property
def key(self):
return get_key(self.uri)
@property
def following(self): return f"{self.uri}/following"
@property
def followers(self): return f"{self.uri}/fol... | [
"pubgate.crypto.key.get_key",
"pubgate.utils.networking.deliver"
] | [((168, 185), 'pubgate.crypto.key.get_key', 'get_key', (['self.uri'], {}), '(self.uri)\n', (175, 185), False, 'from pubgate.crypto.key import get_key\n'), ((693, 732), 'pubgate.utils.networking.deliver', 'deliver', (['self.key', 'activity', 'recipients'], {}), '(self.key, activity, recipients)\n', (700, 732), False, 'f... |
import pytest
from tests.tools.tools import load_test_images
from img_metadata_lib.image import fetch_image
from img_metadata_lib.image import extract_metadata
@pytest.fixture(params=load_test_images())
def image(request):
return request.param
def test_extract_metadata_returns_dict(image):
assert isinstanc... | [
"tests.tools.tools.load_test_images",
"img_metadata_lib.image.extract_metadata"
] | [((186, 204), 'tests.tools.tools.load_test_images', 'load_test_images', ([], {}), '()\n', (202, 204), False, 'from tests.tools.tools import load_test_images\n'), ((322, 345), 'img_metadata_lib.image.extract_metadata', 'extract_metadata', (['image'], {}), '(image)\n', (338, 345), False, 'from img_metadata_lib.image impo... |
from django.db import models
from django.utils.encoding import python_2_unicode_compatible
from v2x_solution.users import models as user_models
@python_2_unicode_compatible
class TimeStampedModel(models.Model):
created_at = models.DateTimeField(auto_now_add=True)
updated_at = models.DateTimeField(auto_now=Tru... | [
"django.db.models.CharField",
"django.db.models.ForeignKey",
"django.db.models.BooleanField",
"django.db.models.SmallIntegerField",
"django.db.models.DateTimeField"
] | [((230, 269), 'django.db.models.DateTimeField', 'models.DateTimeField', ([], {'auto_now_add': '(True)'}), '(auto_now_add=True)\n', (250, 269), False, 'from django.db import models\n'), ((287, 322), 'django.db.models.DateTimeField', 'models.DateTimeField', ([], {'auto_now': '(True)'}), '(auto_now=True)\n', (307, 322), F... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# nnutil2 - Tensorflow utilities for training neural networks
# Copyright (c) 2019, <NAME> <<EMAIL>>
#
# This file is part of 'nnutil2'.
#
# This file may be modified and distributed under the terms of the 3-clause BSD
# license. See the LICENSE file for details.
import ... | [
"tensorflow.test.main",
"tensorflow.random.normal",
"nnutil2.linalg.antisymmetrize",
"tensorflow.linalg.matrix_transpose",
"nnutil2.linalg.symmetrize"
] | [((1281, 1295), 'tensorflow.test.main', 'tf.test.main', ([], {}), '()\n', (1293, 1295), True, 'import tensorflow as tf\n'), ((582, 611), 'tensorflow.random.normal', 'tf.random.normal', ([], {'shape': 'shape'}), '(shape=shape)\n', (598, 611), True, 'import tensorflow as tf\n'), ((629, 668), 'nnutil2.linalg.symmetrize', ... |
import os
from pydantic.main import ModelMetaclass
from confme.utils.dict_util import flatten, InfiniteDict
from confme.utils.typing import get_schema
def env_overwrite(config_cls: ModelMetaclass):
# extract possible parameters
config_dict = get_schema(config_cls)
parameters, _ = flatten(config_dict)
... | [
"os.environ.items",
"confme.utils.typing.get_schema",
"confme.utils.dict_util.InfiniteDict",
"confme.utils.dict_util.flatten"
] | [((254, 276), 'confme.utils.typing.get_schema', 'get_schema', (['config_cls'], {}), '(config_cls)\n', (264, 276), False, 'from confme.utils.typing import get_schema\n'), ((297, 317), 'confme.utils.dict_util.flatten', 'flatten', (['config_dict'], {}), '(config_dict)\n', (304, 317), False, 'from confme.utils.dict_util im... |
import subprocess
from threading import Thread
import file_handler
class Worker(Thread):
def __init__(self, directory, parent):
Thread.__init__(self)
self.daemon = True
self.directory = directory
self.parent = parent
self.done = False
def run(self):
process = ... | [
"file_handler.File",
"threading.Thread.__init__",
"subprocess.Popen"
] | [((143, 164), 'threading.Thread.__init__', 'Thread.__init__', (['self'], {}), '(self)\n', (158, 164), False, 'from threading import Thread\n'), ((320, 420), 'subprocess.Popen', 'subprocess.Popen', (["['ls', '-lah', self.directory]"], {'stdout': 'subprocess.PIPE', 'stderr': 'subprocess.PIPE'}), "(['ls', '-lah', self.dir... |
from modules.Fastx import *
from subprocess import run
import argparse
import struct
import mmap
import sys
import os
def load_query_ids(query_ids_path):
ids = list()
with open(query_ids_path, 'r') as file:
for line in file:
if line == '\n':
continue
ids.appen... | [
"os.path.splitext",
"sys.stderr.write",
"argparse.ArgumentParser",
"os.path.basename"
] | [((700, 753), 'sys.stderr.write', 'sys.stderr.write', (["('Writing to: ' + output_path + '\\n')"], {}), "('Writing to: ' + output_path + '\\n')\n", (716, 753), False, 'import sys\n'), ((2270, 2295), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (2293, 2295), False, 'import argparse\n'), ((591,... |
import discord
from discord.ext import commands
import json
import datetime
import re
with open('Percorso specificato (usate il \)', 'r') as settings:
options = json.load(settings)
client = commands.Bot(command_prefix="!")
@client.event
async def on_ready():
print(f"SwapiTeams Automoderatio... | [
"json.load",
"discord.Embed",
"datetime.datetime.utcnow",
"discord.ext.commands.Bot",
"re.search"
] | [((210, 242), 'discord.ext.commands.Bot', 'commands.Bot', ([], {'command_prefix': '"""!"""'}), "(command_prefix='!')\n", (222, 242), False, 'from discord.ext import commands\n'), ((178, 197), 'json.load', 'json.load', (['settings'], {}), '(settings)\n', (187, 197), False, 'import json\n'), ((825, 862), 're.search', 're... |
# -*- coding: utf-8 -*-
""" Test Access to Fomabin
"""
from unittest import TestCase
import os
from wordweaver.data import data_dir
from wordweaver.fst.utils.foma_access import foma_access
from wordweaver.log import logger
class TestFoma_access_shell(TestCase):
path_to_foma = None
foma_shell = None
foma... | [
"os.path.join",
"wordweaver.log.logger.debug"
] | [((416, 450), 'os.path.join', 'os.path.join', (['data_dir', '"""fomabins"""'], {}), "(data_dir, 'fomabins')\n", (428, 450), False, 'import os\n'), ((489, 539), 'os.path.join', 'os.path.join', (['self.path_to_foma', 'self.fomabin_name'], {}), '(self.path_to_foma, self.fomabin_name)\n', (501, 539), False, 'import os\n'),... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import logging as log
import yaml
import os
def get_settings_yml_file():
yml_file = None
config_file = "configs/settings.yaml"
try:
with open(config_file, 'r') as yml:
yml_file = yaml.load(yml, Loader=yaml.SafeLoader)
except KeyError:... | [
"logging.info",
"yaml.load",
"logging.error",
"logging.basicConfig"
] | [((4369, 4399), 'logging.info', 'log.info', (['"""Configure settings"""'], {}), "('Configure settings')\n", (4377, 4399), True, 'import logging as log\n'), ((5258, 5320), 'logging.basicConfig', 'log.basicConfig', ([], {'level': 'log.DEBUG', 'format': 'LOG_FMT', 'filemode': '"""w"""'}), "(level=log.DEBUG, format=LOG_FMT... |
from importlib import import_module
import os
import re
from django.core.management.base import CommandError
from django.core.management.templates import TemplateCommand
class Command(TemplateCommand):
help = (
"Creates a Django app directory structure for the given app name in "
"the current dir... | [
"os.mkdir",
"importlib.import_module",
"os.getcwd",
"django.core.management.base.CommandError",
"os.path.join",
"re.compile"
] | [((1200, 1211), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (1209, 1211), False, 'import os\n'), ((1237, 1287), 'os.path.join', 'os.path.join', (['filepath_base', '"""templates"""', 'app_name'], {}), "(filepath_base, 'templates', app_name)\n", (1249, 1287), False, 'import os\n'), ((1307, 1361), 'os.path.join', 'os.path... |
import logging
from django.core.exceptions import ValidationError
from django.core.files.storage import default_storage
from rest_framework import serializers
from rest_framework.relations import PrimaryKeyRelatedField
from dora.structures.models import Structure, StructureMember
from .models import (
AccessCond... | [
"rest_framework.serializers.EmailField",
"dora.structures.models.Structure.objects.get",
"django.core.exceptions.ValidationError",
"rest_framework.serializers.SerializerMethodField",
"django.core.files.storage.default_storage.url",
"dora.structures.models.StructureMember.objects.filter",
"rest_framework... | [((543, 570), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (560, 570), False, 'import logging\n'), ((2223, 2258), 'rest_framework.serializers.SerializerMethodField', 'serializers.SerializerMethodField', ([], {}), '()\n', (2256, 2258), False, 'from rest_framework import serializers\n'), ... |
import versioneer
from setuptools import setup
with open('README.rst', 'r') as fh:
long_description = fh.read()
with open('requirements.txt') as fh:
requirements = fh.readlines()
setup(
name='docser',
packages=['docser'],
version=versioneer.get_version(),
cmdclass=versioneer.get_cmdclass(),
... | [
"versioneer.get_version",
"versioneer.get_cmdclass"
] | [((254, 278), 'versioneer.get_version', 'versioneer.get_version', ([], {}), '()\n', (276, 278), False, 'import versioneer\n'), ((293, 318), 'versioneer.get_cmdclass', 'versioneer.get_cmdclass', ([], {}), '()\n', (316, 318), False, 'import versioneer\n')] |
import flask
import threading
import requests
import json
import sshclient
import deployer_helper
from flask import request
from pathlib import Path
def req_handler(app,port):
@app.route('/deployment/dodeploy', methods=['POST'])
def dodeploy():
try :
req = request.get_json()
print(req)
ip = req["serverip"... | [
"threading.Thread",
"deployer_helper.getFileName",
"flask.Flask",
"deployer_helper.getSensorTopic",
"sshclient.deployService",
"flask.jsonify",
"deployer_helper.notifyActionManager",
"requests.post",
"deployer_helper.generateDokerFile",
"flask.request.get_json"
] | [((2567, 2600), 'flask.Flask', 'flask.Flask', (['"""Deoployment Manger"""'], {}), "('Deoployment Manger')\n", (2578, 2600), False, 'import flask\n'), ((2638, 2692), 'threading.Thread', 'threading.Thread', ([], {'target': 'req_handler', 'args': '(app, port)'}), '(target=req_handler, args=(app, port))\n', (2654, 2692), F... |
import binascii
import sys
from uuid import UUID
import msgpack
signed = 0x02
chained = 0x03
usage = " usage:\n" \
" python3 unpack.py [ <binary-file-name> | <UPP(hex)> | <UPP(base64)> ]"
if len(sys.argv) < 2:
print(usage)
sys.exit(1)
upp = b''
arg = sys.argv[1]
# try to get UPP from binary file
t... | [
"binascii.hexlify",
"msgpack.unpackb",
"binascii.unhexlify",
"binascii.b2a_base64",
"binascii.a2b_base64",
"sys.exit"
] | [((243, 254), 'sys.exit', 'sys.exit', (['(1)'], {}), '(1)\n', (251, 254), False, 'import sys\n'), ((919, 930), 'sys.exit', 'sys.exit', (['(1)'], {}), '(1)\n', (927, 930), False, 'import sys\n'), ((1012, 1032), 'msgpack.unpackb', 'msgpack.unpackb', (['upp'], {}), '(upp)\n', (1027, 1032), False, 'import msgpack\n'), ((50... |
import logging
from elram.config import load_config
from elram.repository.models import User, database, Event, Attendance, Account, Transaction
CONFIG = load_config()
logger = logging.getLogger('main')
def populate_db(data):
models_mapping = {
'users': User,
'accounts': Account,
}
for m... | [
"elram.repository.models.database.connect",
"elram.repository.models.database.init",
"elram.repository.models.database.create_tables",
"logging.getLogger",
"elram.config.load_config"
] | [((155, 168), 'elram.config.load_config', 'load_config', ([], {}), '()\n', (166, 168), False, 'from elram.config import load_config\n'), ((178, 203), 'logging.getLogger', 'logging.getLogger', (['"""main"""'], {}), "('main')\n", (195, 203), False, 'import logging\n'), ((843, 930), 'elram.repository.models.database.init'... |
from openalpr import Alpr
import re
import os
class Plate:
def __init__(self):
self.alpr = Alpr("eu","/etc/openalpr/conf", "/usr/share/openalpr/runtime_data")
if not self.alpr.is_loaded():
print("Erro ao carregar o ALPR..")
sys.exit(1)
self.alpr.set_top_n(10)... | [
"re.search",
"openalpr.Alpr"
] | [((112, 180), 'openalpr.Alpr', 'Alpr', (['"""eu"""', '"""/etc/openalpr/conf"""', '"""/usr/share/openalpr/runtime_data"""'], {}), "('eu', '/etc/openalpr/conf', '/usr/share/openalpr/runtime_data')\n", (116, 180), False, 'from openalpr import Alpr\n'), ((736, 789), 're.search', 're.search', (['"""^[A-Z]{3}[0-9]{1}[A-Z]{1}... |
# This is where the models go!
from django.db import models
from django.urls import reverse
from django.conf import settings
from django.contrib.contenttypes.models import ContentType
from django.contrib.contenttypes.fields import GenericForeignKey
# Using the user: user = models.ForeignKey(settings.AUTH_USER_MODEL)
C... | [
"django.db.models.TextField",
"django.db.models.ManyToManyField",
"django.contrib.contenttypes.fields.GenericForeignKey",
"django.db.models.CharField",
"django.db.models.ForeignKey",
"django.db.models.PositiveIntegerField",
"django.db.models.BooleanField",
"django.contrib.contenttypes.models.ContentTy... | [((397, 525), 'django.db.models.ManyToManyField', 'models.ManyToManyField', (['settings.AUTH_USER_MODEL'], {'blank': '(True)', 'through': '"""django_teams.TeamStatus"""', 'related_name': '"""team_member"""'}), "(settings.AUTH_USER_MODEL, blank=True, through=\n 'django_teams.TeamStatus', related_name='team_member')\n... |
from openpyxl.styles import colors, Font
from examples.c09_0_font_styles.openpyxl import index
from openpyxl import Workbook
from base_test_cases import ExcelTest
class TestOpenPyXLFontStyles(ExcelTest):
def test_font_color(self):
wb = Workbook()
ws = wb.active
a1 = ws['A1']
a1_fo... | [
"examples.c09_0_font_styles.openpyxl.index.set_font_size",
"openpyxl.Workbook",
"openpyxl.styles.Font",
"examples.c09_0_font_styles.openpyxl.index.set_font_color_red",
"openpyxl.styles.colors.Color",
"examples.c09_0_font_styles.openpyxl.index.set_font_style"
] | [((251, 261), 'openpyxl.Workbook', 'Workbook', ([], {}), '()\n', (259, 261), False, 'from openpyxl import Workbook\n'), ((357, 442), 'openpyxl.styles.colors.Color', 'colors.Color', ([], {'indexed': 'None', 'type': '"""theme"""', 'rgb': 'None', 'tint': '(0.0)', 'theme': '(1)', 'auto': 'None'}), "(indexed=None, type='the... |
"""
Script that trains Tensorflow singletask models on QM7 dataset.
"""
from __future__ import print_function
from __future__ import division
from __future__ import unicode_literals
import os
import deepchem as dc
import numpy as np
from qm7_datasets import load_qm7b_from_mat
np.random.seed(123)
qm7_tasks, datasets, ... | [
"numpy.random.seed",
"deepchem.trans.CoulombFitTransformer",
"qm7_datasets.load_qm7b_from_mat",
"deepchem.metrics.Metric",
"numpy.sqrt"
] | [((279, 298), 'numpy.random.seed', 'np.random.seed', (['(123)'], {}), '(123)\n', (293, 298), True, 'import numpy as np\n'), ((335, 373), 'qm7_datasets.load_qm7b_from_mat', 'load_qm7b_from_mat', ([], {'split': '"""stratified"""'}), "(split='stratified')\n", (353, 373), False, 'from qm7_datasets import load_qm7b_from_mat... |
# coding: utf-8
import unittest
from tapioca_asana import Asana
class TestTapiocaAsana(unittest.TestCase):
def setUp(self):
self.wrapper = Asana()
if __name__ == '__main__':
unittest.main()
| [
"unittest.main",
"tapioca_asana.Asana"
] | [((197, 212), 'unittest.main', 'unittest.main', ([], {}), '()\n', (210, 212), False, 'import unittest\n'), ((156, 163), 'tapioca_asana.Asana', 'Asana', ([], {}), '()\n', (161, 163), False, 'from tapioca_asana import Asana\n')] |
#!/usr/bin/env python3
import sys
from PyQt5.QtWidgets import QVBoxLayout,QWidget
from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
from matplotlib.backends.backend_qt5agg import NavigationToolbar2QT as NavigationToolbar
import matplotlib.pyplot as plt
import random
import numpy as np
... | [
"matplotlib.backends.backend_qt5agg.FigureCanvasQTAgg",
"PyQt5.QtWidgets.QVBoxLayout",
"matplotlib.pyplot.figure",
"numpy.array",
"matplotlib.backends.backend_qt5agg.NavigationToolbar2QT"
] | [((584, 596), 'matplotlib.pyplot.figure', 'plt.figure', ([], {}), '()\n', (594, 596), True, 'import matplotlib.pyplot as plt\n'), ((619, 644), 'matplotlib.backends.backend_qt5agg.FigureCanvasQTAgg', 'FigureCanvas', (['self.figure'], {}), '(self.figure)\n', (631, 644), True, 'from matplotlib.backends.backend_qt5agg impo... |
#!/usr/bin/python
import spacy
import json
import numpy as np
import rospy
from std_msgs.msg import String
from spacy.matcher import PhraseMatcher
from spacy.matcher import Matcher
from spacy.tokens import Span
from spacy.lang.en import English
class Greet_Visitors:
def __init__(self):
rospy.init_node('Gr... | [
"rospy.Subscriber",
"json.loads",
"rospy.Publisher",
"json.dumps",
"spacy.tokens.Span",
"spacy.load",
"rospy.init_node",
"rospy.spin",
"spacy.matcher.PhraseMatcher"
] | [((3704, 3716), 'rospy.spin', 'rospy.spin', ([], {}), '()\n', (3714, 3716), False, 'import rospy\n'), ((301, 334), 'rospy.init_node', 'rospy.init_node', (['"""Greet_Visitors"""'], {}), "('Greet_Visitors')\n", (316, 334), False, 'import rospy\n'), ((358, 425), 'rospy.Publisher', 'rospy.Publisher', (['"""/hri/tts_input""... |
# This script is to extract any files inside of a .unitypackage file.
# Please make sure you only use this on .unitypackage files you own.
# This will create a folder with the exact same name as the input file.
# Have fun!
# Used for creating the temp folder name.
from hashlib import md5
# Uncompressing .unityasset fil... | [
"argparse.ArgumentParser",
"pathlib.Path",
"tarfile.open",
"shutil.rmtree",
"sys.exit"
] | [((504, 529), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (527, 529), False, 'import argparse\n'), ((783, 798), 'pathlib.Path', 'Path', (['args.file'], {}), '(args.file)\n', (787, 798), False, 'from pathlib import Path\n'), ((1401, 1422), 'pathlib.Path', 'Path', (['unity_file_name'], {}), '(... |
#!/usr/bin/env python3
"""
Cross validator
Usage:
crossvalidator.py (--model=<model>) [--tub=<tub1,tub2,..tubn>] [--type=(linear|categorical)] [--output=<csv-filename>]
Options:
-h --help Show this screen.
--tub TUBPATHS List of paths to tubs. Comma separated. Use quotes to use wildcards. ie "~/... | [
"csv.writer",
"math.pow",
"docopt.docopt",
"statistics.stdev",
"donkeycar.parts.keras.KerasLinear",
"statistics.mean",
"donkeycar.parts.datastore.TubGroup",
"donkeycar.parts.keras.KerasCategorical"
] | [((718, 736), 'statistics.mean', 'statistics.mean', (['l'], {}), '(l)\n', (733, 736), False, 'import statistics\n'), ((749, 768), 'statistics.stdev', 'statistics.stdev', (['l'], {}), '(l)\n', (765, 768), False, 'import statistics\n'), ((1494, 1513), 'donkeycar.parts.datastore.TubGroup', 'TubGroup', (['tub_names'], {}),... |
###################################################
# Copyright (c) 2019 #
# Authors: @iArunava <<EMAIL>> #
# @AvivSham <<EMAIL>> #
# #
# License: BSD License 3.0 #
# ... | [
"torch.nn.PReLU",
"torch.nn.Conv2d",
"torch.cat",
"torch.nn.BatchNorm2d",
"torch.nn.MaxPool2d"
] | [((720, 768), 'torch.nn.MaxPool2d', 'nn.MaxPool2d', ([], {'kernel_size': '(2)', 'stride': '(2)', 'padding': '(0)'}), '(kernel_size=2, stride=2, padding=0)\n', (732, 768), True, 'import torch.nn as nn\n'), ((872, 944), 'torch.nn.Conv2d', 'nn.Conv2d', (['in_channels', 'out_channels'], {'kernel_size': '(3)', 'stride': '(2... |
# Generated by Django 3.1.4 on 2021-01-05 20:37
from django.db import migrations, models
import django.db.models.deletion
import uuid
class Migration(migrations.Migration):
initial = True
dependencies = [
('seller', '0003_auto_20210105_2035'),
]
operations = [
migrations.CreateMode... | [
"django.db.models.TextField",
"django.db.models.CharField",
"django.db.models.DateTimeField",
"django.db.models.ForeignKey",
"django.db.models.AutoField",
"django.db.models.DecimalField",
"django.db.models.UUIDField"
] | [((395, 488), 'django.db.models.AutoField', 'models.AutoField', ([], {'auto_created': '(True)', 'primary_key': '(True)', 'serialize': '(False)', 'verbose_name': '"""ID"""'}), "(auto_created=True, primary_key=True, serialize=False,\n verbose_name='ID')\n", (411, 488), False, 'from django.db import migrations, models\... |
import os
import click
ROOT_DIRECTORY = os.path.abspath(
os.path.join(os.path.dirname(__file__), os.pardir)
)
PLUGIN_DIRECTORY = os.path.join(ROOT_DIRECTORY, 'detectem/plugins')
PLUGIN_DIRECTORIES = [
d for d in os.listdir(PLUGIN_DIRECTORY)
if os.path.isdir(os.path.join(PLUGIN_DIRECTORY, d)) and d != '__p... | [
"click.argument",
"os.path.dirname",
"os.path.exists",
"click.command",
"click.Choice",
"os.path.join",
"os.listdir"
] | [((135, 183), 'os.path.join', 'os.path.join', (['ROOT_DIRECTORY', '"""detectem/plugins"""'], {}), "(ROOT_DIRECTORY, 'detectem/plugins')\n", (147, 183), False, 'import os\n'), ((335, 350), 'click.command', 'click.command', ([], {}), '()\n', (348, 350), False, 'import click\n'), ((628, 650), 'click.argument', 'click.argu... |
import torch
import torch.nn as nn
from utils.tools import transpose1323
from my_packages.DepthProjection.models.HG_model import HGModel
class DepthProjectionModule(nn.Module):
def __init__(self):
super(DepthProjectionModule, self).__init__()
self.model = HGModel("my_packages/DepthProjection/pretr... | [
"my_packages.DepthProjection.models.HG_model.HGModel",
"utils.tools.transpose1323",
"torch.stack",
"torch.squeeze"
] | [((278, 357), 'my_packages.DepthProjection.models.HG_model.HGModel', 'HGModel', (['"""my_packages/DepthProjection/pretrained/best_generalization_net_G.pth"""'], {}), "('my_packages/DepthProjection/pretrained/best_generalization_net_G.pth')\n", (285, 357), False, 'from my_packages.DepthProjection.models.HG_model import ... |
import urllib.parse as urlparse
from urllib.parse import parse_qs
import utils.helpers as hp
import pandas as pd
import model.queries as qrs
import view.templates as tmpl
import numpy as np
import plotly.graph_objects as go
import plotly as py
import plotly.express as px
from plotly.offline import download_plotlyjs, i... | [
"utils.helpers.getValueField",
"utils.helpers.GetTimeRanges",
"dash_html_components.H2",
"dash_html_components.Div",
"plotly.graph_objects.Figure",
"dash_html_components.Label",
"view.problematic_pairs.ProblematicPairsPage",
"dash_bootstrap_components.Col",
"model.DataLoader.GeneralDataLoader",
"p... | [((818, 840), 'view.problematic_pairs.ProblematicPairsPage', 'ProblematicPairsPage', ([], {}), '()\n', (838, 840), False, 'from view.problematic_pairs import ProblematicPairsPage\n'), ((868, 887), 'model.DataLoader.GeneralDataLoader', 'GeneralDataLoader', ([], {}), '()\n', (885, 887), False, 'from model.DataLoader impo... |
from tkinter import *
from chatbot import Botler
BG_COLOR = "#272727"
TEXT_COLOR = "#FAFAFA"
FONT = "Helvetica 14"
FONT_BOLD = "Helvetica 13 bold"
class ChatApplication:
"""Runs application """
def __init__(self):
"""Generates window GUI an initializes Chatbot"""
self._init_window()
... | [
"chatbot.Botler"
] | [((332, 340), 'chatbot.Botler', 'Botler', ([], {}), '()\n', (338, 340), False, 'from chatbot import Botler\n')] |
import logging
from pylons import request, response, session, tmpl_context as c
from pylons.controllers.util import abort
# added for auth
from authkit.authorize.pylons_adaptors import authorize
from authkit.permissions import RemoteUser, ValidAuthKitUser, UserIn
from pypesvds.lib.base import BaseController, render
... | [
"pypesvds.lib.base.render",
"authkit.permissions.ValidAuthKitUser",
"logging.getLogger"
] | [((327, 354), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (344, 354), False, 'import logging\n'), ((573, 597), 'pypesvds.lib.base.render', 'render', (['"""/pypesvds.mako"""'], {}), "('/pypesvds.mako')\n", (579, 597), False, 'from pypesvds.lib.base import BaseController, render\n'), ((4... |
import json
import pytest
from toucan_connectors.google_analytics.google_analytics_connector import (
GoogleAnalyticsConnector, GoogleAnalyticsDataSource)
def test_google_analytics(mocker):
gac = GoogleAnalyticsConnector(
type="GoogleAnalytics",
name="Test",
credentials={
... | [
"toucan_connectors.google_analytics.google_analytics_connector.GoogleAnalyticsDataSource",
"pytest.mark.skip",
"toucan_connectors.google_analytics.google_analytics_connector.GoogleAnalyticsConnector"
] | [((1363, 1415), 'pytest.mark.skip', 'pytest.mark.skip', ([], {'reason': '"""This uses a live instance"""'}), "(reason='This uses a live instance')\n", (1379, 1415), False, 'import pytest\n'), ((208, 544), 'toucan_connectors.google_analytics.google_analytics_connector.GoogleAnalyticsConnector', 'GoogleAnalyticsConnector... |
#! /usr/bin/env python3
#
# Authors: <NAME>, <NAME>, <NAME>
# (c) 2021
from pathlib import Path
from datetime import datetime
import os.path
import requests
import yaml
import json
from pyspectator.processor import Cpu
from crontab import CronTab
import sys
# constants
CONFIG_FILE = 'config.yaml'
MAX_CPU_TEMP = 'maxC... | [
"json.dump",
"yaml.load",
"pyspectator.processor.Cpu",
"json.load",
"crontab.CronTab",
"pathlib.Path",
"requests.get",
"datetime.datetime.now",
"sys.exit"
] | [((1902, 1920), 'crontab.CronTab', 'CronTab', ([], {'user': '(True)'}), '(user=True)\n', (1909, 1920), False, 'from crontab import CronTab\n'), ((2139, 2164), 'pyspectator.processor.Cpu', 'Cpu', ([], {'monitoring_latency': '(1)'}), '(monitoring_latency=1)\n', (2142, 2164), False, 'from pyspectator.processor import Cpu\... |
from bs4 import BeautifulSoup
# fix: InsecureRequestWarning: Unverified HTTPS request is being made to host
import requests.packages.urllib3
# 測試table
# import prettytable as pt
url = "https://rate.bot.com.tw/xrt?Lang=zh-TW"
herders = {
'User-Agent': 'Mozilla/5.0 (Macintosh Intel Mac OS X 10_15_7) AppleWebKit... | [
"bs4.BeautifulSoup"
] | [((1347, 1378), 'bs4.BeautifulSoup', 'BeautifulSoup', (['res.text', '"""lxml"""'], {}), "(res.text, 'lxml')\n", (1360, 1378), False, 'from bs4 import BeautifulSoup\n')] |
from __future__ import division
from __future__ import print_function
from __future__ import unicode_literals
import sys
from datetime import datetime, timedelta
import time
import io
import logging
from crea.blockchain import Blockchain
from crea.block import Block
from crea.account import Account
from crea.amount im... | [
"creabase.operations.Transfer",
"logging.basicConfig",
"creabase.transactions.getBlockParams",
"crea.crea.Crea",
"crea.transactionbuilder.TransactionBuilder",
"logging.getLogger"
] | [((741, 768), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (758, 768), False, 'import logging\n'), ((769, 808), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (788, 808), False, 'import logging\n'), ((884, 890), 'crea.crea.Crea',... |
"""Script containing the abstract policy class."""
import numpy as np
import tensorflow as tf
from hbaselines.utils.tf_util import get_trainable_vars
from hbaselines.utils.tf_util import get_target_updates
class ActorCriticPolicy(object):
"""Base Actor Critic Policy.
Attributes
----------
sess : tf.... | [
"hbaselines.utils.tf_util.get_trainable_vars",
"tensorflow.constant",
"numpy.concatenate"
] | [((7880, 7921), 'numpy.concatenate', 'np.concatenate', (['(obs, context)'], {'axis': 'axis'}), '((obs, context), axis=axis)\n', (7894, 7921), True, 'import numpy as np\n'), ((9920, 9951), 'hbaselines.utils.tf_util.get_trainable_vars', 'get_trainable_vars', (['model_scope'], {}), '(model_scope)\n', (9938, 9951), False, ... |
import numpy as np
import opt_prob
import scipy.optimize
# -- problem setup
name = '2.4 GOLDPR'
problem = opt_prob.Cons(name)
def cns(x):
g = -1.0*np.array(problem.cns(x))
return g.tolist()
# -- start optimization
x0 = ((np.array(problem.lb) + np.array(problem.ub)) / 2.0).tolist()
bounds = []
for lb_i, ub... | [
"numpy.array",
"opt_prob.Cons"
] | [((108, 127), 'opt_prob.Cons', 'opt_prob.Cons', (['name'], {}), '(name)\n', (121, 127), False, 'import opt_prob\n'), ((234, 254), 'numpy.array', 'np.array', (['problem.lb'], {}), '(problem.lb)\n', (242, 254), True, 'import numpy as np\n'), ((257, 277), 'numpy.array', 'np.array', (['problem.ub'], {}), '(problem.ub)\n', ... |
from tacotron2.text.vi_number_and_units import normalize_vi
from random import randrange
print("Start generate vietnamese number strings")
with open("training_data/vietnamese_number.txt", 'w', encoding='utf-8') as f:
for i in range(20000):
n = randrange(1000000000, 2000000000)
f.write(normalize_... | [
"random.randrange"
] | [((260, 293), 'random.randrange', 'randrange', (['(1000000000)', '(2000000000)'], {}), '(1000000000, 2000000000)\n', (269, 293), False, 'from random import randrange\n')] |
import re
import nltk
debug = False
list = ''
def tokenise(doc):
tokenized_doc = nltk.word_tokenize(doc)
tagged_sentences = nltk.pos_tag(tokenized_doc)
ne_chunked_sents = nltk.ne_chunk(tagged_sentences)
named_entities = []
for tagged_tree in ne_chunked_sents:
if hasattr(tagged_tree, 'label... | [
"nltk.ne_chunk",
"nltk.pos_tag",
"re.sub",
"nltk.word_tokenize",
"re.compile"
] | [((87, 110), 'nltk.word_tokenize', 'nltk.word_tokenize', (['doc'], {}), '(doc)\n', (105, 110), False, 'import nltk\n'), ((134, 161), 'nltk.pos_tag', 'nltk.pos_tag', (['tokenized_doc'], {}), '(tokenized_doc)\n', (146, 161), False, 'import nltk\n'), ((185, 216), 'nltk.ne_chunk', 'nltk.ne_chunk', (['tagged_sentences'], {}... |
"""OmegaConfParser example."""
import fromconfig
import random
def random_hex() -> str:
return hex(hash(random.random()))
if __name__ == "__main__":
config = {
"host": "localhost",
"port": "8008",
"url": "${host}:${port}",
"path": "models/${now:}/${random_hex:}", # Use def... | [
"random.random",
"fromconfig.parser.OmegaConfParser"
] | [((452, 487), 'fromconfig.parser.OmegaConfParser', 'fromconfig.parser.OmegaConfParser', ([], {}), '()\n', (485, 487), False, 'import fromconfig\n'), ((111, 126), 'random.random', 'random.random', ([], {}), '()\n', (124, 126), False, 'import random\n')] |
"""This module holds functions for miri data trending
All functions in this module are tailored for the miri datatrending application.
Detailed descriptions are given for every function individually.
-------
- <NAME>
Use
---
Dependencies
------------
MIRI_trend_requestsDRAFT1900201.docx
Referenc... | [
"collections.defaultdict",
"statistics.stdev",
"jwql.instrument_monitors.nirspec_monitors.data_trending.utils.condition.condition",
"statistics.mean"
] | [((1720, 1737), 'collections.defaultdict', 'defaultdict', (['list'], {}), '(list)\n', (1731, 1737), False, 'from collections import defaultdict\n'), ((4648, 4665), 'collections.defaultdict', 'defaultdict', (['list'], {}), '(list)\n', (4659, 4665), False, 'from collections import defaultdict\n'), ((6411, 6436), 'jwql.in... |
from __future__ import print_function
import argparse
import collections
from ete3 import PhyloTree
def printTSV(myDict, colList=None):
""" Pretty print a list of dictionaries (myDict) as a dynamically sized table.
If column names (colList) aren't specified, they will show in random order.
Author: <NAME... | [
"collections.Counter",
"ete3.PhyloTree",
"argparse.ArgumentParser"
] | [((674, 736), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Gene Copy Number Finder"""'}), "(description='Gene Copy Number Finder')\n", (697, 736), False, 'import argparse\n'), ((1381, 1396), 'ete3.PhyloTree', 'PhyloTree', (['line'], {}), '(line)\n', (1390, 1396), False, 'from ete3 impo... |
'''
Advent of Code - 2018
--- Day 4: Repose Record ---
Released under the MIT License <http://opensource.org/licenses/mit-license.php>
'''
import os
from collections import defaultdict
from datetime import datetime
import re
def sleep_pattern(events):
sleep = defaultdict(lambda: [0 for i in range(60)])
f... | [
"datetime.datetime.strptime",
"re.findall"
] | [((408, 449), 'datetime.datetime.strptime', 'datetime.strptime', (['time', '"""%Y-%m-%d %H:%M"""'], {}), "(time, '%Y-%m-%d %H:%M')\n", (425, 449), False, 'from datetime import datetime\n'), ((505, 533), 're.findall', 're.findall', (['"""[\\\\d]+"""', 'action'], {}), "('[\\\\d]+', action)\n", (515, 533), False, 'import ... |
"""Initialisation procedures."""
# pylint: disable=import-outside-toplevel
import numpy as np
import scipy.integrate as sci
import probnum.filtsmooth as pnfs
import probnum.statespace as pnss
from probnum import randvars
# In the initialisation-via-RK function below, this value is added to the marginal stds of the ... | [
"jax.config.config.update",
"jax.numpy.array",
"jax.numpy.ones_like",
"jax.numpy.reshape",
"jax.experimental.jet.jet",
"probnum.randvars.Normal",
"jax.numpy.concatenate",
"numpy.asarray",
"scipy.integrate.solve_ivp",
"numpy.zeros",
"numpy.arange",
"jax.numpy.ravel",
"numpy.diag",
"probnum.... | [((3620, 3634), 'numpy.asarray', 'np.asarray', (['y0'], {}), '(y0)\n', (3630, 3634), True, 'import numpy as np\n'), ((3762, 3779), 'numpy.zeros', 'np.zeros', (['ode_dim'], {}), '(ode_dim)\n', (3770, 3779), True, 'import numpy as np\n'), ((3796, 3824), 'numpy.zeros', 'np.zeros', (['(ode_dim, ode_dim)'], {}), '((ode_dim,... |
import os
import platform
import subprocess
# # Creation de l'environnement virtual Venv et activation
version = subprocess.run(["python", "--version"], capture_output=True, text=True)
if "python 3" in version.stdout.lower():
python = "python"
else:
python = "python3"
createvenv = os.system... | [
"platform.system",
"subprocess.run",
"os.system"
] | [((123, 194), 'subprocess.run', 'subprocess.run', (["['python', '--version']"], {'capture_output': '(True)', 'text': '(True)'}), "(['python', '--version'], capture_output=True, text=True)\n", (137, 194), False, 'import subprocess\n'), ((311, 346), 'os.system', 'os.system', (['f"""{python} -m venv venv"""'], {}), "(f'{p... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
# 序列化
# import pickle
# d = dict(name='Bob', age=20, score=88)
# print(pickle.dumps(d))
# f = open('dump.txt', 'wb')
# pickle.dump(d, f)
# f.close()
# f = open('dump.txt', 'rb')
# d = pickle.load(f)
# f.close()
# print(d)
# JSON
# import json
# d = dict(name='Bob', age=2... | [
"json.dumps"
] | [((1280, 1315), 'json.dumps', 'json.dumps', (['obj'], {'ensure_ascii': '(False)'}), '(obj, ensure_ascii=False)\n', (1290, 1315), False, 'import json\n')] |
# Solution of;
# Project Euler Problem 134: Prime pair connection
# https://projecteuler.net/problem=134
#
# Consider the consecutive primes p1 = 19 and p2 = 23. It can be verified that
# 1219 is the smallest number such that the last digits are formed by p1
# whilst also being divisible by p2. In fact, with the exc... | [
"timed.caller"
] | [((784, 818), 'timed.caller', 'timed.caller', (['dummy', 'n', 'i', 'prob_id'], {}), '(dummy, n, i, prob_id)\n', (796, 818), False, 'import timed\n')] |
# -*- coding: utf-8 -*-
"""
Created on Fri Nov 16 12:05:08 2018
@author: Alexandre
"""
###############################################################################
import numpy as np
###############################################################################
from pyro.dynamic import pendulum
from pyro.control ... | [
"pyro.control.nonlinear.ComputedTorqueController",
"pyro.control.nonlinear.SlidingModeController",
"pyro.analysis.simulation.CLosedLoopSimulation",
"pyro.control.robotcontrollers.JointPID",
"pyro.dynamic.pendulum.SinglePendulum",
"pyro.planning.plan.load_trajectory",
"numpy.array",
"pyro.planning.plan... | [((537, 562), 'pyro.dynamic.pendulum.SinglePendulum', 'pendulum.SinglePendulum', ([], {}), '()\n', (560, 562), False, 'from pyro.dynamic import pendulum\n'), ((666, 697), 'pyro.planning.plan.load_trajectory', 'plan.load_trajectory', (['"""rrt.npy"""'], {}), "('rrt.npy')\n", (686, 697), False, 'from pyro.planning import... |
"""Abstract datasource for recipes"""
from os import path
import json
class Datasource:
"""foo"""
def __init__(self, data):
self.name = data["name"]
self.text = data["text"]
self.url = data["url"]
self.local = data["local"]
def validate(self):
"""Prove that data ... | [
"os.path.exists"
] | [((350, 373), 'os.path.exists', 'path.exists', (['self.local'], {}), '(self.local)\n', (361, 373), False, 'from os import path\n')] |
import geoplot as gplt
import geopandas as gpd
import matplotlib.pyplot as plt
import pandas as pd
from src import constants
# data from cook county open data and us census
township_boundaries = gpd.read_file(constants.TOWNSHIP_POLYGONS_GEOJSON)
zip_code_data = gpd.read_file(constants.TOWNSHIP_POINTS_GEOJSON)
# call... | [
"matplotlib.pyplot.title",
"matplotlib.pyplot.show",
"geoplot.pointplot",
"geoplot.polyplot",
"geopandas.read_file"
] | [((197, 247), 'geopandas.read_file', 'gpd.read_file', (['constants.TOWNSHIP_POLYGONS_GEOJSON'], {}), '(constants.TOWNSHIP_POLYGONS_GEOJSON)\n', (210, 247), True, 'import geopandas as gpd\n'), ((264, 312), 'geopandas.read_file', 'gpd.read_file', (['constants.TOWNSHIP_POINTS_GEOJSON'], {}), '(constants.TOWNSHIP_POINTS_GE... |
import os
from mlflow_turing_scoring_server import scoring_server
from mlflow.pyfunc import load_model
app = scoring_server.init(load_model(os.environ[scoring_server._SERVER_MODEL_PATH]))
| [
"mlflow.pyfunc.load_model"
] | [((130, 187), 'mlflow.pyfunc.load_model', 'load_model', (['os.environ[scoring_server._SERVER_MODEL_PATH]'], {}), '(os.environ[scoring_server._SERVER_MODEL_PATH])\n', (140, 187), False, 'from mlflow.pyfunc import load_model\n')] |
import setuptools
with open("readme.md", "r") as fh:
long_description = fh.read()
setuptools.setup(
name="sharpcvi2",
version="1.0.0",
author="CVI2: Computer Vision, Imaging and Machine Intelligence Research Group",
author_email="<EMAIL>",
description="Routines for the SHARP Challenge, ECCV 20... | [
"setuptools.find_packages"
] | [((470, 496), 'setuptools.find_packages', 'setuptools.find_packages', ([], {}), '()\n', (494, 496), False, 'import setuptools\n')] |
# -*- coding: utf-8 -*-
"""
Spyder Editor
This is a temporary script file.
"""
import torch
from torch import nn
import torch.nn.functional as F
class ConvNet(nn.Module):
def __init__(self, input_shape=(1,3,28,28)):
super(ConvNet, self).__init__()
self.cnn = nn.Sequential(nn.Conv2d(in_channels=3,... | [
"torch.nn.ReLU",
"torch.nn.Conv2d",
"torch.nn.Linear",
"torch.rand",
"torch.nn.MaxPool2d",
"torch.no_grad"
] | [((1340, 1365), 'torch.rand', 'torch.rand', (['(10)', '(3)', '(28)', '(28)'], {}), '(10, 3, 28, 28)\n', (1350, 1365), False, 'import torch\n'), ((1187, 1210), 'torch.rand', 'torch.rand', (['input_shape'], {}), '(input_shape)\n', (1197, 1210), False, 'import torch\n'), ((1375, 1390), 'torch.no_grad', 'torch.no_grad', ([... |
import gzip
import Data_reader
##REQUIRES filename is a tabix file, names is the header of the file
##MODIFIES nothing
##EFFECTS finds the position of the minimum pvalue
def find_min_pvals(filename, filetype, num_minimums, region_buffer):
#create a file reader from the file
file_reader = Data_reader.Data_reade... | [
"Data_reader.Data_reader.factory"
] | [((298, 349), 'Data_reader.Data_reader.factory', 'Data_reader.Data_reader.factory', (['filename', 'filetype'], {}), '(filename, filetype)\n', (329, 349), False, 'import Data_reader\n'), ((5362, 5413), 'Data_reader.Data_reader.factory', 'Data_reader.Data_reader.factory', (['filename', 'filetype'], {}), '(filename, filet... |
"""
Classes for running lm inference
"""
import os
import torch
from torch.utils.data import (DataLoader, RandomSampler, SequentialSampler,
TensorDataset)
from reflex.models.reflex import Reflex
from dataclasses import dataclass
from reflex.utils import load_file, to_list
from reflex.struc... | [
"tqdm.tqdm",
"reflex.models.pmi_filter.WordEmbeddingsPMIFilter",
"reflex.metrics.calculate_relation_metrics",
"reflex.models.reflex.Reflex",
"reflex.utils.load_file",
"reflex.structs.Sample",
"os.path.join"
] | [((1043, 1092), 'reflex.models.pmi_filter.WordEmbeddingsPMIFilter', 'WordEmbeddingsPMIFilter', (['we_model', 'spacy_model', 'l'], {}), '(we_model, spacy_model, l)\n', (1066, 1092), False, 'from reflex.models.pmi_filter import WordEmbeddingsPMIFilter\n'), ((1114, 1179), 'reflex.models.reflex.Reflex', 'Reflex', (['model_... |
# testsqlite.py
import sqlite3
conn = sqlite3.connect('vocab.db')
c = conn.cursor()
c.execute("""CREATE TABLE IF NOT EXISTS vocab (
ID INTEGER PRIMARY KEY AUTOINCREMENT,
vocab text,
meaning text,
score int)""")
def insert_vocab(vocab,meaning):
ID = None
score = 0
with c... | [
"sqlite3.connect"
] | [((44, 71), 'sqlite3.connect', 'sqlite3.connect', (['"""vocab.db"""'], {}), "('vocab.db')\n", (59, 71), False, 'import sqlite3\n')] |
from collections import deque
class TreeNode(object):
def __init__(self,item):
self.val=item
self.left=None
self.right=None
# self.height=None
# Codec
class DFS_Serialize:
"""
基于 DFS 的 二叉树 的序列化 和 反序列化
递归实现
ref:
https://blog.csdn.net/Shenpibaipao/article/det... | [
"collections.deque"
] | [((1795, 1810), 'collections.deque', 'deque', (['preorder'], {}), '(preorder)\n', (1800, 1810), False, 'from collections import deque\n'), ((4838, 4845), 'collections.deque', 'deque', ([], {}), '()\n', (4843, 4845), False, 'from collections import deque\n'), ((5941, 5948), 'collections.deque', 'deque', ([], {}), '()\n'... |
import pytest
@pytest.fixture(scope='session')
def session_capabilities(session_capabilities):
session_capabilities['loggingPrefs'] = {'browser': 'ALL'}
session_capabilities['goog:loggingPrefs'] = {'browser': 'ALL'}
return session_capabilities
@pytest.fixture
def chrome_options(chrome_options):
chr... | [
"pytest.fixture"
] | [((17, 48), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""session"""'}), "(scope='session')\n", (31, 48), False, 'import pytest\n')] |
from rlberry.agents import A2CAgent
from rlberry.envs.classic_control import MountainCar
from rlberry.envs.benchmarks.ball_exploration import PBall2D
from rlberry.seeding import seeding
render = True
seeding.set_global_seed(1223)
for env, n_episodes, horizon in zip([PBall2D(), MountainCar()],
... | [
"rlberry.agents.A2CAgent",
"rlberry.seeding.seeding.set_global_seed",
"rlberry.envs.benchmarks.ball_exploration.PBall2D",
"rlberry.envs.classic_control.MountainCar"
] | [((201, 230), 'rlberry.seeding.seeding.set_global_seed', 'seeding.set_global_seed', (['(1223)'], {}), '(1223)\n', (224, 230), False, 'from rlberry.seeding import seeding\n'), ((413, 515), 'rlberry.agents.A2CAgent', 'A2CAgent', (['env'], {'n_episodes': 'n_episodes', 'horizon': 'horizon', 'gamma': '(0.99)', 'learning_rat... |
from collections import deque
rows, cols = [int(_) for _ in input().split()]
string = input()
matrix = [[0 for j in range(cols)] for i in range(rows)]
# matrix = []
#
# for i in range(rows):
# matrix.append([])
# for j in range(cols):
# matrix[i].append(0)
key_word = deque(string)
count = 0
for i in ... | [
"collections.deque"
] | [((287, 300), 'collections.deque', 'deque', (['string'], {}), '(string)\n', (292, 300), False, 'from collections import deque\n'), ((407, 420), 'collections.deque', 'deque', (['string'], {}), '(string)\n', (412, 420), False, 'from collections import deque\n')] |
import os
import sys
import django
PROJDIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
sys.path.insert(0, PROJDIR)
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "foodbank.settings")
django.setup()
| [
"os.path.abspath",
"django.setup",
"os.environ.setdefault",
"sys.path.insert"
] | [((107, 134), 'sys.path.insert', 'sys.path.insert', (['(0)', 'PROJDIR'], {}), '(0, PROJDIR)\n', (122, 134), False, 'import sys\n'), ((135, 203), 'os.environ.setdefault', 'os.environ.setdefault', (['"""DJANGO_SETTINGS_MODULE"""', '"""foodbank.settings"""'], {}), "('DJANGO_SETTINGS_MODULE', 'foodbank.settings')\n", (156,... |
import traceback
import pytest
from plenum.test.testing_utils import setupTestLogging
setupTestLogging()
def run(test, stopOnFail=True, maxTimes=None):
count = 0
passes = 0
fails = 0
while maxTimes is None or count < maxTimes:
exitcode = pytest.main(test)
count += 1
if exitc... | [
"plenum.test.testing_utils.setupTestLogging",
"traceback.print_exc",
"pytest.main"
] | [((89, 107), 'plenum.test.testing_utils.setupTestLogging', 'setupTestLogging', ([], {}), '()\n', (105, 107), False, 'from plenum.test.testing_utils import setupTestLogging\n'), ((267, 284), 'pytest.main', 'pytest.main', (['test'], {}), '(test)\n', (278, 284), False, 'import pytest\n'), ((394, 415), 'traceback.print_exc... |
from dataclasses import dataclass
from datasets import load_dataset
from torch.utils.data import DataLoader
from transformers import PreTrainedTokenizerBase
from bsmetadata.input_pipeline import DataConfig
@dataclass
class DataCollatorForCLM:
tokenizer: PreTrainedTokenizerBase
pad_to_multiple_of: int = 16
... | [
"datasets.load_dataset",
"torch.utils.data.DataLoader"
] | [((965, 1010), 'datasets.load_dataset', 'load_dataset', (['"""wikitext"""', '"""wikitext-2-raw-v1"""'], {}), "('wikitext', 'wikitext-2-raw-v1')\n", (977, 1010), False, 'from datasets import load_dataset\n'), ((1084, 1216), 'torch.utils.data.DataLoader', 'DataLoader', (["datasets['train']"], {'shuffle': '(True)', 'colla... |
import argparse
from tqdm import tqdm
from spacy.tokens import DocBin
import spacy_stanza
nlp = spacy_stanza.load_pipeline("en", use_gpu=True)
def swap_one(document, summary):
try:
source_doc = nlp(document)
except RecursionError:
source_doc = nlp(document[:2000])
summary_doc = nlp(summ... | [
"spacy_stanza.load_pipeline",
"argparse.ArgumentParser",
"spacy.tokens.DocBin"
] | [((98, 144), 'spacy_stanza.load_pipeline', 'spacy_stanza.load_pipeline', (['"""en"""'], {'use_gpu': '(True)'}), "('en', use_gpu=True)\n", (124, 144), False, 'import spacy_stanza\n'), ((388, 413), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (411, 413), False, 'import argparse\n'), ((745, 818)... |
from __future__ import absolute_import, division, print_function
from functools import partial
from ...external.qt import QtGui
from ...external.qt.QtCore import Qt
from ...core import message as msg
from ...clients.histogram_client import HistogramClient
from ..widget_properties import (connect_int_spin, ButtonProp... | [
"functools.partial"
] | [((3042, 3072), 'functools.partial', 'partial', (['setattr', 'cl', '"""normed"""'], {}), "(setattr, cl, 'normed')\n", (3049, 3072), False, 'from functools import partial\n'), ((3115, 3148), 'functools.partial', 'partial', (['setattr', 'cl', '"""autoscale"""'], {}), "(setattr, cl, 'autoscale')\n", (3122, 3148), False, '... |
from unittest import TestCase
from rec_to_nwb.processing.tools.file_sorter import FileSorter
class TestFilenameSorter(TestCase):
def setUp(self):
self.strings_to_sort = ['name01', 'name11', 'name10', 'name02', 'name21']
self.correct_order_of_strings = ['name01', 'name02', 'name10', 'name11', 'nam... | [
"rec_to_nwb.processing.tools.file_sorter.FileSorter"
] | [((563, 575), 'rec_to_nwb.processing.tools.file_sorter.FileSorter', 'FileSorter', ([], {}), '()\n', (573, 575), False, 'from rec_to_nwb.processing.tools.file_sorter import FileSorter\n')] |
import sqlite3
import io
import json
import os
import shutil
import nska_deserialize as nd
import scripts.artifacts.artGlobals
from packaging import version
from scripts.artifact_report import ArtifactHtmlReport
from scripts.ilapfuncs import logfunc, logdevinfo, timeline, kmlgen, tsv, is_platform_windows, op... | [
"scripts.ilapfuncs.open_sqlite_db_readonly",
"io.BytesIO",
"os.path.basename",
"scripts.ilapfuncs.tsv",
"scripts.ilapfuncs.timeline",
"shutil.copy2",
"scripts.ilapfuncs.logfunc",
"nska_deserialize.deserialize_plist",
"scripts.artifact_report.ArtifactHtmlReport"
] | [((576, 611), 'scripts.ilapfuncs.open_sqlite_db_readonly', 'open_sqlite_db_readonly', (['file_found'], {}), '(file_found)\n', (599, 611), False, 'from scripts.ilapfuncs import logfunc, logdevinfo, timeline, kmlgen, tsv, is_platform_windows, open_sqlite_db_readonly\n'), ((3587, 3631), 'scripts.artifact_report.ArtifactHt... |
from concurrent import futures
from functools import wraps
from typing import Callable, Optional
from executor_exporter.exporter import ExecutorExporter
from executor_exporter.proxy import InstrumentedExecutorProxy
class ThreadPoolExecutor(InstrumentedExecutorProxy, futures.ThreadPoolExecutor):
def __init__(
... | [
"concurrent.futures.ThreadPoolExecutor",
"concurrent.futures.ProcessPoolExecutor",
"executor_exporter.exporter.ExecutorExporter",
"functools.wraps"
] | [((1669, 1687), 'functools.wraps', 'wraps', (['initializer'], {}), '(initializer)\n', (1674, 1687), False, 'from functools import wraps\n'), ((512, 569), 'executor_exporter.exporter.ExecutorExporter', 'ExecutorExporter', (['futures.ThreadPoolExecutor', 'executor_id'], {}), '(futures.ThreadPoolExecutor, executor_id)\n',... |
#!/usr/bin/python3
import sys
import os
import time
import os as sistema
# Set color
R = '\033[31m' # Red
N = '\033[1;37m' # White
G = '\033[32m' # Green
O = '\033[0;33m' # Orange
B = '\033[1;34m' #Blue
print (""+O+"")
os.system('clear')
def pedirOpcionCorrecta():
correcto=False
num=0
while(... | [
"os.system",
"time.sleep"
] | [((222, 240), 'os.system', 'os.system', (['"""clear"""'], {}), "('clear')\n", (231, 240), False, 'import os\n'), ((1348, 1361), 'time.sleep', 'time.sleep', (['(6)'], {}), '(6)\n', (1358, 1361), False, 'import time\n'), ((1364, 1382), 'os.system', 'os.system', (['"""clear"""'], {}), "('clear')\n", (1373, 1382), False, '... |
import re
f = open("regex.txt", "r")
content = f.readlines()
# s = 'A message from <EMAIL> to <EMAIL>'
for i in range(len(content)):
if re.findall('[\w\.]+@[\w\.]+', content[i]):
print(content[i], end='') | [
"re.findall"
] | [((143, 188), 're.findall', 're.findall', (['"""[\\\\w\\\\.]+@[\\\\w\\\\.]+"""', 'content[i]'], {}), "('[\\\\w\\\\.]+@[\\\\w\\\\.]+', content[i])\n", (153, 188), False, 'import re\n')] |
from pysony import SonyAPI, ControlPoint
import time
flask_app = None
try:
import flask
from flask import Flask
flask_app = Flask(__name__)
except ImportError:
print("Cannot import `flask`, liveview on web is not available")
if flask_app:
flask_app.get_frame_handle = None
flask_app.config['D... | [
"flask.Flask",
"flask.render_template_string",
"time.sleep",
"pysony.SonyAPI",
"pysony.ControlPoint",
"pysony.SonyAPI.LiveviewStreamThread"
] | [((138, 153), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (143, 153), False, 'from flask import Flask\n'), ((1217, 1231), 'pysony.ControlPoint', 'ControlPoint', ([], {}), '()\n', (1229, 1231), False, 'from pysony import SonyAPI, ControlPoint\n'), ((1854, 1887), 'pysony.SonyAPI.LiveviewStreamThread', 'So... |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'ui/ui_remotesensing_dockwidget.ui'
#
# Created by: PyQt5 UI code generator 5.6
#
# WARNING! All changes made in this file will be lost!
from PyQt5 import QtCore, QtGui, QtWidgets
class Ui_RemoteSensingDockWidget(object):
def setupUi(se... | [
"PyQt5.QtWidgets.QComboBox",
"PyQt5.QtWidgets.QLabel",
"PyQt5.QtWidgets.QSizePolicy",
"PyQt5.QtWidgets.QHBoxLayout",
"PyQt5.QtWidgets.QPushButton",
"PyQt5.QtWidgets.QCheckBox",
"PyQt5.QtCore.QSize",
"PyQt5.QtWidgets.QSpacerItem",
"PyQt5.QtWidgets.QVBoxLayout",
"PyQt5.QtWidgets.QDoubleSpinBox",
"... | [((493, 585), 'PyQt5.QtWidgets.QSizePolicy', 'QtWidgets.QSizePolicy', (['QtWidgets.QSizePolicy.Preferred', 'QtWidgets.QSizePolicy.Preferred'], {}), '(QtWidgets.QSizePolicy.Preferred, QtWidgets.\n QSizePolicy.Preferred)\n', (514, 585), False, 'from PyQt5 import QtCore, QtGui, QtWidgets\n'), ((848, 894), 'PyQt5.QtWidg... |
"""py.test testing fixtures"""
import pytest
# Websauna
from websauna.blog.models import Post
from websauna.utils.time import now
@pytest.fixture
def unpublished_post(dbsession):
post = Post()
post.title = "Hello world"
post.body = "All roads lead to Toholampi"
post.tags = "mytag,mytag2"
post.en... | [
"websauna.blog.models.Post",
"websauna.utils.time.now"
] | [((194, 200), 'websauna.blog.models.Post', 'Post', ([], {}), '()\n', (198, 200), False, 'from websauna.blog.models import Post\n'), ((495, 500), 'websauna.utils.time.now', 'now', ([], {}), '()\n', (498, 500), False, 'from websauna.utils.time import now\n')] |
from ament_index_python.packages import get_package_prefix
from launch import LaunchDescription
from launch_ros.actions import Node
from os import environ as env
def generate_launch_description():
pkg_name = "phidget_spatial"
pkg_share_path = get_package_prefix(pkg_name)
return LaunchDescription([
... | [
"os.environ.get",
"ament_index_python.packages.get_package_prefix"
] | [((256, 284), 'ament_index_python.packages.get_package_prefix', 'get_package_prefix', (['pkg_name'], {}), '(pkg_name)\n', (274, 284), False, 'from ament_index_python.packages import get_package_prefix\n'), ((508, 523), 'os.environ.get', 'env.get', (['"""USER"""'], {}), "('USER')\n", (515, 523), True, 'from os import en... |
from typing import TYPE_CHECKING, Any, Dict, List
from aiopoke.objects.utility import Effect, NamedResource, VerboseEffect
from aiopoke.objects.utility.common_models import Name
from aiopoke.utils.minimal_resources import MinimalResource
from aiopoke.utils.resource import Resource
if TYPE_CHECKING:
from aiopoke.o... | [
"aiopoke.utils.minimal_resources.MinimalResource",
"aiopoke.objects.utility.common_models.Name",
"aiopoke.objects.utility.VerboseEffect",
"aiopoke.objects.utility.Effect"
] | [((1630, 1659), 'aiopoke.utils.minimal_resources.MinimalResource', 'MinimalResource', ([], {}), '(**generation)\n', (1645, 1659), False, 'from aiopoke.utils.minimal_resources import MinimalResource\n'), ((2113, 2139), 'aiopoke.utils.minimal_resources.MinimalResource', 'MinimalResource', ([], {}), '(**pokemon)\n', (2128... |
import coloredlogs
import logging
import os
logging.basicConfig(
filename="plex_doctor.log",
level=logging.DEBUG,
format='%(levelname)s: "%(asctime)s - %(message)s',
)
log = logging.getLogger("PLEX-DOCTOR")
log.setLevel(logging.DEBUG)
LOGLEVEL = os.environ.get("LOGLEVEL", "INFO").upper()
stream_handler =... | [
"logging.basicConfig",
"coloredlogs.install",
"logging.StreamHandler",
"logging.Formatter",
"os.environ.get",
"logging.getLogger"
] | [((45, 170), 'logging.basicConfig', 'logging.basicConfig', ([], {'filename': '"""plex_doctor.log"""', 'level': 'logging.DEBUG', 'format': '"""%(levelname)s: "%(asctime)s - %(message)s"""'}), '(filename=\'plex_doctor.log\', level=logging.DEBUG, format\n =\'%(levelname)s: "%(asctime)s - %(message)s\')\n', (64, 170), F... |
import unittest
import tohil
class TestMethods(unittest.TestCase):
def test_convert1(self):
"""exercise tohil.convert with no to= and with to=str"""
self.assertEqual(tohil.convert(10), "10")
self.assertEqual(tohil.convert(10, to=str), "10")
self.assertEqual(tohil.convert("10"), "1... | [
"unittest.main",
"tohil.convert"
] | [((2226, 2241), 'unittest.main', 'unittest.main', ([], {}), '()\n', (2239, 2241), False, 'import unittest\n'), ((189, 206), 'tohil.convert', 'tohil.convert', (['(10)'], {}), '(10)\n', (202, 206), False, 'import tohil\n'), ((239, 264), 'tohil.convert', 'tohil.convert', (['(10)'], {'to': 'str'}), '(10, to=str)\n', (252, ... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# Copyright 2018 <EMAIL>
# Licensed under the MIT license (http://opensource.org/licenses/MIT)
from sexpr import sexp
import pprint
import copy
import hexdump
DEBUG = 0
def u8(x):
return x & 0xff
def i16(x):
return x & 0xffff
class LEDVMError(Exception):
... | [
"sexpr.sexp.parseString",
"hexdump.hexdump",
"pprint.pprint"
] | [((8866, 8910), 'sexpr.sexp.parseString', 'sexp.parseString', (['program_str'], {'parseAll': '(True)'}), '(program_str, parseAll=True)\n', (8882, 8910), False, 'from sexpr import sexp\n'), ((13579, 13614), 'hexdump.hexdump', 'hexdump.hexdump', (['byte_code_as_bytes'], {}), '(byte_code_as_bytes)\n', (13594, 13614), Fals... |
from report_vitals import report_battery_vitals
from filter_values import filterOut_safe_vitals
from process_battery_data import process_data
from controller_actions import get_actions
def is_battery_ok(bms_attributes):
data = process_data(bms_attributes)
report_battery_vitals(data)
get_actions(data)... | [
"controller_actions.get_actions",
"process_battery_data.process_data",
"report_vitals.report_battery_vitals"
] | [((238, 266), 'process_battery_data.process_data', 'process_data', (['bms_attributes'], {}), '(bms_attributes)\n', (250, 266), False, 'from process_battery_data import process_data\n'), ((271, 298), 'report_vitals.report_battery_vitals', 'report_battery_vitals', (['data'], {}), '(data)\n', (292, 298), False, 'from repo... |
# -*- coding: utf-8 -*-
"""
MIT License
Copyright (c) 2017 <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, ... | [
"sys.stdout.write",
"paddle.v2.layer.mse_cost",
"sys.stdout.flush",
"data_provider.create_reader",
"paddle.v2.activation.Sigmoid",
"data_provider.fetch_testingset",
"paddle.v2.activation.Relu",
"paddle.v2.parameters.create",
"paddle.v2.init",
"numpy.save",
"paddle.v2.attr.Param",
"paddle.v2.da... | [((2494, 2537), 'paddle.v2.init', 'paddle.init', ([], {'use_gpu': '(False)', 'trainer_count': '(1)'}), '(use_gpu=False, trainer_count=1)\n', (2505, 2537), True, 'import paddle.v2 as paddle\n'), ((1207, 1258), 'paddle.v2.attr.Param', 'paddle.attr.Param', ([], {'initial_std': '(0.01)', 'initial_mean': '(0)'}), '(initial_... |
from mstrio.users_and_groups import list_users
from mstrio.api.projects import get_projects
from mstrio.distribution_services.subscription.subscription_manager import SubscriptionManager
from mstrio.connection import Connection
def delete_subscriptions_of_departed_users(connection: "Connection") -> None:
"""Delet... | [
"mstrio.api.projects.get_projects",
"mstrio.users_and_groups.list_users",
"mstrio.distribution_services.subscription.subscription_manager.SubscriptionManager"
] | [((604, 657), 'mstrio.api.projects.get_projects', 'get_projects', (['connection'], {'whitelist': "[('ERR014', 403)]"}), "(connection, whitelist=[('ERR014', 403)])\n", (616, 657), False, 'from mstrio.api.projects import get_projects\n'), ((754, 787), 'mstrio.users_and_groups.list_users', 'list_users', ([], {'connection'... |
from coverage import coverage
import unittest
cov = coverage(branch=True, include=['app/*'])
cov.set_option('report:show_missing', True)
cov.erase()
cov.start()
from .client_test import ClientTestCase
from .features_test import FeatureTestCase
from .product_area_test import ProductAreaTestCase
if __name__ == '__mai... | [
"unittest.TextTestRunner",
"unittest.TestLoader",
"coverage.coverage"
] | [((54, 94), 'coverage.coverage', 'coverage', ([], {'branch': '(True)', 'include': "['app/*']"}), "(branch=True, include=['app/*'])\n", (62, 94), False, 'from coverage import coverage\n'), ((338, 359), 'unittest.TestLoader', 'unittest.TestLoader', ([], {}), '()\n', (357, 359), False, 'import unittest\n'), ((404, 440), '... |
# -*- coding: utf-8 -*-
# @Time : 2020/9/26
# @Author : <NAME>
# @Email : 暂无
# @File : command.py
# @Project : Flask-Demo
import os
import logging
from logging.handlers import RotatingFileHandler
from flask import request
basedir = os.path.abspath(os.path.dirname(os.path.dirname(__file__)))
project_name = os.path.spl... | [
"os.mkdir",
"os.path.dirname",
"os.path.exists",
"logging.Formatter",
"os.path.join"
] | [((830, 903), 'logging.Formatter', 'logging.Formatter', (['"""%(asctime)s - %(name)s - %(levelname)s - %(message)s"""'], {}), "('%(asctime)s - %(name)s - %(levelname)s - %(message)s')\n", (847, 903), False, 'import logging\n'), ((920, 965), 'os.path.join', 'os.path.join', (['basedir', 'f"""logs/{project_name}"""'], {})... |
import csv
from django.http import HttpResponse
class ExportCsvMixin:
def export_as_csv(self, request, queryset):
meta = self.model._meta
field_names = [field.name for field in meta.fields]
response = HttpResponse(content_type="text/csv")
response["Content-Disposition"] = "attac... | [
"csv.writer",
"django.http.HttpResponse"
] | [((234, 271), 'django.http.HttpResponse', 'HttpResponse', ([], {'content_type': '"""text/csv"""'}), "(content_type='text/csv')\n", (246, 271), False, 'from django.http import HttpResponse\n'), ((374, 394), 'csv.writer', 'csv.writer', (['response'], {}), '(response)\n', (384, 394), False, 'import csv\n')] |
from datetime import datetime, timezone
from itertools import cycle
from .lame import LAME
from .mt import MT
def filetime_to_dt(timestamp: int) -> datetime:
return datetime.fromtimestamp(timestamp // 100000000, timezone.utc)
def bytes_to_bitstring(data: bytes) -> str:
return "".join(bin(x)[2:].zfill(8) fo... | [
"itertools.cycle",
"datetime.datetime.fromtimestamp"
] | [((172, 232), 'datetime.datetime.fromtimestamp', 'datetime.fromtimestamp', (['(timestamp // 100000000)', 'timezone.utc'], {}), '(timestamp // 100000000, timezone.utc)\n', (194, 232), False, 'from datetime import datetime, timezone\n'), ((667, 677), 'itertools.cycle', 'cycle', (['key'], {}), '(key)\n', (672, 677), False... |
#!/usr/bin/env python3
import sys
import os
import argparse
def parseArguments():
parser = argparse.ArgumentParser(description='transform file and header')
parser.add_argument("--list_file", help="", type=str,required=True)
parser.add_argument('--use_rs',type=str,help="if need to be limited at some rs", d... | [
"argparse.ArgumentParser",
"sys.exit"
] | [((97, 161), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""transform file and header"""'}), "(description='transform file and header')\n", (120, 161), False, 'import argparse\n'), ((2147, 2158), 'sys.exit', 'sys.exit', (['(3)'], {}), '(3)\n', (2155, 2158), False, 'import sys\n')] |