code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
from unittest import TestCase
from CTCI.Ch2_Linked_Lists.common.SinglyLinkedList import Empty, Node
from CTCI.Ch2_Linked_Lists.exercises.CTCI_Ch2_Ex6 import PalindromeSinglyLinkedList, is_palindrome_brute_force
from CTCI.Ch2_Linked_Lists.exercises.CTCI_Ch2_Ex6 import is_palindrome_reverse
class TestPalindromeSinglyLi... | [
"CTCI.Ch2_Linked_Lists.common.SinglyLinkedList.Node",
"CTCI.Ch2_Linked_Lists.exercises.CTCI_Ch2_Ex6.is_palindrome_brute_force",
"CTCI.Ch2_Linked_Lists.exercises.CTCI_Ch2_Ex6.PalindromeSinglyLinkedList",
"CTCI.Ch2_Linked_Lists.exercises.CTCI_Ch2_Ex6.is_palindrome_reverse"
] | [((381, 409), 'CTCI.Ch2_Linked_Lists.exercises.CTCI_Ch2_Ex6.PalindromeSinglyLinkedList', 'PalindromeSinglyLinkedList', ([], {}), '()\n', (407, 409), False, 'from CTCI.Ch2_Linked_Lists.exercises.CTCI_Ch2_Ex6 import PalindromeSinglyLinkedList, is_palindrome_brute_force\n'), ((1752, 1759), 'CTCI.Ch2_Linked_Lists.common.Si... |
# utils for working with 3d-protein structures
import os
import numpy as np
import torch
from functools import wraps
from einops import rearrange, repeat
# import torch_sparse # only needed for sparse nth_deg adj calculation
# bio
from Bio import SeqIO
import itertools
import string
# sidechainnet
from sidechainnet... | [
"numpy.random.rand",
"torch.sin",
"torch.det",
"torch.searchsorted",
"torch.cdist",
"torch.min",
"numpy.array",
"torch.cos",
"numpy.linalg.norm",
"numpy.arange",
"torch.logical_or",
"numpy.mean",
"numpy.cross",
"torch.mean",
"einops.repeat",
"torch.logical_not",
"functools.wraps",
... | [((641, 660), 'sidechainnet.utils.sequence.ProteinVocabulary', 'ProteinVocabulary', ([], {}), '()\n', (658, 660), False, 'from sidechainnet.utils.sequence import ProteinVocabulary, ONE_TO_THREE_LETTER_MAP\n'), ((842, 898), 'torch.linspace', 'torch.linspace', (['(2)', '(20)'], {'steps': 'constants.DISTOGRAM_BUCKETS'}), ... |
"""
Interfaces with Verisure sensors.
For more details about this platform, please refer to the documentation at
documentation at https://home-assistant.io/components/verisure/
"""
import logging
from homeassistant.components.verisure import HUB as hub
from homeassistant.const import TEMP_CELSIUS
from homeassistant.h... | [
"logging.getLogger",
"homeassistant.components.verisure.HUB.climate_status.values",
"homeassistant.components.verisure.HUB.mouse_status.values",
"homeassistant.components.verisure.HUB.config.get",
"homeassistant.components.verisure.HUB.update_climate",
"homeassistant.components.verisure.HUB.update_mousede... | [((359, 386), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (376, 386), False, 'import logging\n'), ((525, 560), 'homeassistant.components.verisure.HUB.config.get', 'hub.config.get', (['"""thermometers"""', '"""1"""'], {}), "('thermometers', '1')\n", (539, 560), True, 'from homeassistant... |
import factory
from factory.django import DjangoModelFactory as Factory
from django.contrib.auth.models import Permission
from ..models import Blog
from articles.users.tests.factories import UserFactory
class Blogfactory(Factory):
user = user = factory.SubFactory(UserFactory)
title = factory.Faker('sentence... | [
"factory.SubFactory",
"factory.Faker",
"django.contrib.auth.models.Permission.objects.filter",
"articles.users.tests.factories.UserFactory"
] | [((253, 284), 'factory.SubFactory', 'factory.SubFactory', (['UserFactory'], {}), '(UserFactory)\n', (271, 284), False, 'import factory\n'), ((297, 334), 'factory.Faker', 'factory.Faker', (['"""sentence"""'], {'nb_words': '(3)'}), "('sentence', nb_words=3)\n", (310, 334), False, 'import factory\n'), ((353, 395), 'factor... |
import sqlite3
class Database:
# create book always if not exists
def __init__(self,db):
self.conn = sqlite3.connect(db)
self.cur = self.conn.execute("CREATE TABLE IF NOT EXISTS book (id INTEGER PRIMARY KEY, " +
"title TEXT, author TEXT, year INTEGER, isbn INTEGER)"... | [
"sqlite3.connect"
] | [((119, 138), 'sqlite3.connect', 'sqlite3.connect', (['db'], {}), '(db)\n', (134, 138), False, 'import sqlite3\n')] |
#!/usr/bin/env python
# ----------------------------------------------------------------------------
# Copyright 2018 ARM Ltd.
#
# SPDX-License-Identifier: Apache-2.0
#
# 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 ... | [
"os.path.isfile",
"pyclibrary.CParser",
"collections.namedtuple",
"cbor2.dump"
] | [((2216, 2259), 'collections.namedtuple', 'namedtuple', (['"""ConfigParam"""', "['Data', 'Name']"], {}), "('ConfigParam', ['Data', 'Name'])\n", (2226, 2259), False, 'from collections import namedtuple\n'), ((2274, 2327), 'collections.namedtuple', 'namedtuple', (['"""Certificate"""', "['Data', 'Format', 'Name']"], {}), ... |
from django.db import models
# Create your models here.
class Owner(models.Model):
Owner_id = models.AutoField
Owner_firstname = models.CharField(max_length=60)
Owner_lastname = models.CharField(max_length=60)
Owner_address = models.CharField(max_length=600)
Owner_email = models.CharField(max_lengt... | [
"django.db.models.DateField",
"django.db.models.IntegerField",
"django.db.models.BooleanField",
"django.db.models.ImageField",
"django.db.models.CharField"
] | [((138, 169), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(60)'}), '(max_length=60)\n', (154, 169), False, 'from django.db import models\n'), ((191, 222), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(60)'}), '(max_length=60)\n', (207, 222), False, 'from django.db im... |
import numpy as np
import tectosaur.util.gpu as gpu
from tectosaur.fmm.c2e import build_c2e
import logging
logger = logging.getLogger(__name__)
def make_tree(m, cfg, max_pts_per_cell):
tri_pts = m[0][m[1]]
centers = np.mean(tri_pts, axis = 1)
pt_dist = tri_pts - centers[:,np.newaxis,:]
Rs = np.max(np... | [
"logging.getLogger",
"numpy.mean",
"tectosaur.fmm.c2e.build_c2e",
"tectosaur.util.gpu.to_gpu",
"numpy.array",
"numpy.empty_like",
"numpy.linalg.norm"
] | [((118, 145), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (135, 145), False, 'import logging\n'), ((227, 251), 'numpy.mean', 'np.mean', (['tri_pts'], {'axis': '(1)'}), '(tri_pts, axis=1)\n', (234, 251), True, 'import numpy as np\n'), ((318, 349), 'numpy.linalg.norm', 'np.linalg.norm', ... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
# Project: Fable Input Output
# https://github.com/silx-kit/fabio
#
# Copyright (C) European Synchrotron Radiation Facility, Grenoble, France
#
# Principal author: <NAME> (<EMAIL>)
#
# This program is free software: you can redistribute it an... | [
"logging.getLogger",
"unittest.TestSuite",
"unittest.TextTestRunner",
"fabio.mpaimage.MpaImage"
] | [((1074, 1101), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1091, 1101), False, 'import logging\n'), ((2354, 2374), 'unittest.TestSuite', 'unittest.TestSuite', ([], {}), '()\n', (2372, 2374), False, 'import unittest\n'), ((2480, 2505), 'unittest.TextTestRunner', 'unittest.TextTestRunn... |
# -*- coding: utf-8 -*-
import scrapy
import codecs
import sys
#리눅스상에서 utf-8 로 파일에 내용을 기록하려면 시스템 기본 인코딩으 ㄹutf-8 로 설정해야함
reload(sys)
sys.setdefaultencoding('utf8')
# scrapy 에서 spider 는 crawling/scrapping을 담당하는 핵심부분
#crawling/scrapping 절차에 대한 정의를 하는 부분
class CurrSpider(scrapy.Spider):
name = 'currSpider'
start_... | [
"codecs.open",
"sys.setdefaultencoding"
] | [((132, 162), 'sys.setdefaultencoding', 'sys.setdefaultencoding', (['"""utf8"""'], {}), "('utf8')\n", (154, 162), False, 'import sys\n'), ((565, 602), 'codecs.open', 'codecs.open', (['"""curr.csv"""', '"""w"""', '"""utf-8"""'], {}), "('curr.csv', 'w', 'utf-8')\n", (576, 602), False, 'import codecs\n')] |
import __init__
import os
#os.environ['LD_LIBRARY_PATH'] += ':/usr/local/cuda-11.1/bin64:/usr/local/cuda-11.2/bin64'
import numpy as np
import torch
import torch.multiprocessing as mp
import torch_geometric.datasets as GeoData
from torch_geometric.loader import DenseDataLoader
import torch_geometric.transforms as T... | [
"utils.metrics.AverageMeter",
"torch.nn.CrossEntropyLoss",
"torch.utils.data.distributed.DistributedSampler",
"logging.info",
"torch.utils.tensorboard.SummaryWriter",
"numpy.mean",
"config.OptInit",
"comm.is_main_process",
"comm.get_local_rank",
"numpy.isnan",
"parallel_wrapper.launch",
"utils... | [((799, 832), 'torch.utils.tensorboard.SummaryWriter', 'SummaryWriter', ([], {'log_dir': '"""log/mlp4"""'}), "(log_dir='log/mlp4')\n", (812, 832), False, 'from torch.utils.tensorboard import SummaryWriter\n'), ((2714, 2727), 'numpy.mean', 'np.mean', (['ious'], {}), '(ious)\n', (2721, 2727), True, 'import numpy as np\n'... |
import tkinter as tk
from tkinter import ttk
win = tk.Tk()
win.title("Python GUI")
win.resizable(False, False)
win.configure(background = "grey94")
a_label = ttk.Label(win, text = "Gib Deinen Namen ein:")
a_label.grid(column = 0, row = 0)
a_label.grid_configure(padx = 8, pady = 8)
def clickMe():
action.configure... | [
"tkinter.ttk.Button",
"tkinter.ttk.Entry",
"tkinter.ttk.Label",
"tkinter.StringVar",
"tkinter.Tk"
] | [((52, 59), 'tkinter.Tk', 'tk.Tk', ([], {}), '()\n', (57, 59), True, 'import tkinter as tk\n'), ((160, 204), 'tkinter.ttk.Label', 'ttk.Label', (['win'], {'text': '"""Gib Deinen Namen ein:"""'}), "(win, text='Gib Deinen Namen ein:')\n", (169, 204), False, 'from tkinter import ttk\n'), ((363, 377), 'tkinter.StringVar', '... |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'src/gui/ui_paste_dialog.ui'
#
# Created by: PyQt5 UI code generator 5.11.2
#
# WARNING! All changes made in this file will be lost!
from PyQt5 import QtCore, QtGui, QtWidgets
class Ui_PasteDialog(object):
def setupUi(self, PasteDialog)... | [
"PyQt5.QtCore.QMetaObject.connectSlotsByName",
"PyQt5.QtWidgets.QRadioButton",
"PyQt5.QtCore.QRect",
"PyQt5.QtWidgets.QGridLayout",
"PyQt5.QtWidgets.QGroupBox",
"PyQt5.QtWidgets.QVBoxLayout",
"PyQt5.QtWidgets.QPushButton"
] | [((434, 468), 'PyQt5.QtWidgets.QGridLayout', 'QtWidgets.QGridLayout', (['PasteDialog'], {}), '(PasteDialog)\n', (455, 468), False, 'from PyQt5 import QtCore, QtGui, QtWidgets\n'), ((649, 681), 'PyQt5.QtWidgets.QGroupBox', 'QtWidgets.QGroupBox', (['PasteDialog'], {}), '(PasteDialog)\n', (668, 681), False, 'from PyQt5 im... |
from yalul.interpreters.environment import Environment
from yalul.interpreters.expressions.var_assignment_interpreter import VarAssignmentInterpreter
from yalul.interpreters.interpreter_errors import InterpreterErrors
class TestVarAssignmentInterpreter:
"""Test var assignment expression interpreter"""
def te... | [
"yalul.interpreters.expressions.var_assignment_interpreter.VarAssignmentInterpreter",
"yalul.interpreters.environment.Environment",
"yalul.interpreters.interpreter_errors.InterpreterErrors"
] | [((485, 504), 'yalul.interpreters.interpreter_errors.InterpreterErrors', 'InterpreterErrors', ([], {}), '()\n', (502, 504), False, 'from yalul.interpreters.interpreter_errors import InterpreterErrors\n'), ((519, 538), 'yalul.interpreters.environment.Environment', 'Environment', (['{}', '{}'], {}), '({}, {})\n', (530, 5... |
import boto3
from django.conf import settings
from backend.models import CloudWatchEvent
import json
class Events:
def __init__(self):
self.client = boto3.client('events', region_name=settings.NARUKO_REGION)
def list_rules(self):
response = []
for rules in self._list_rul... | [
"boto3.client",
"backend.models.CloudWatchEvent"
] | [((173, 231), 'boto3.client', 'boto3.client', (['"""events"""'], {'region_name': 'settings.NARUKO_REGION'}), "('events', region_name=settings.NARUKO_REGION)\n", (185, 231), False, 'import boto3\n'), ((2363, 2500), 'backend.models.CloudWatchEvent', 'CloudWatchEvent', ([], {'name': "response['Name']", 'schedule_expressio... |
#!/usr/bin/env python
# Manipulate sys.path to be able to import converscript from this local git
# repository.
import os
import sys
sys.path.append(os.path.join(os.path.dirname(__file__), "..", ".."))
from converscript import RiveScript
import json
bot = RiveScript()
bot.load_file("example.rive")
dep = bot.deparse... | [
"os.path.dirname",
"json.dumps",
"converscript.RiveScript"
] | [((259, 271), 'converscript.RiveScript', 'RiveScript', ([], {}), '()\n', (269, 271), False, 'from converscript import RiveScript\n'), ((329, 354), 'json.dumps', 'json.dumps', (['dep'], {'indent': '(2)'}), '(dep, indent=2)\n', (339, 354), False, 'import json\n'), ((163, 188), 'os.path.dirname', 'os.path.dirname', (['__f... |
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
class Migration(migrations.Migration):
dependencies = [
('modules', '0002_module_floor'),
]
operations = [
migrations.AddField(
model_name='module',
name='sho... | [
"django.db.models.BooleanField"
] | [((346, 380), 'django.db.models.BooleanField', 'models.BooleanField', ([], {'default': '(False)'}), '(default=False)\n', (365, 380), False, 'from django.db import models, migrations\n')] |
import abc
import argparse
import logging
import pathlib
from collections import namedtuple
from operator import itemgetter
import toml
class NotConfiguredError(Exception):
pass
class ParseError(Exception):
pass
class Model(abc.ABC):
"""Interface for model that can save/load parameters.
Each mod... | [
"logging.getLogger",
"collections.namedtuple",
"pathlib.Path",
"logging.Formatter",
"operator.itemgetter"
] | [((2561, 2579), 'pathlib.Path', 'pathlib.Path', (['path'], {}), '(path)\n', (2573, 2579), False, 'import pathlib\n'), ((5102, 5125), 'logging.getLogger', 'logging.getLogger', (['name'], {}), '(name)\n', (5119, 5125), False, 'import logging\n'), ((5258, 5360), 'logging.Formatter', 'logging.Formatter', (['"""%(levelname)... |
import os
import subprocess
import threading
mutex = threading.Lock()
def render_appleseed(target_file, base_color_tex, normal_tex, roughness_tex, metallic_tex, resolution, appleseed_path):
mutex.acquire()
try:
# Read the template file from disk.
with open("scene_template.appleseed", "r") as... | [
"threading.Lock",
"os.path.splitext",
"os.path.join",
"subprocess.check_call"
] | [((54, 70), 'threading.Lock', 'threading.Lock', ([], {}), '()\n', (68, 70), False, 'import threading\n'), ((1189, 1289), 'os.path.join', 'os.path.join', (['appleseed_path', '"""bin"""', "('appleseed.cli.exe' if os.name == 'nt' else 'appleseed.cli')"], {}), "(appleseed_path, 'bin', 'appleseed.cli.exe' if os.name == 'nt'... |
from ubuntui.utils import Padding
from ubuntui.widgets.hr import HR
from conjureup.app_config import app
from conjureup.ui.views.base import BaseView, SchemaFormView
from conjureup.ui.widgets.selectors import MenuSelectButtonList
class NewCredentialView(SchemaFormView):
title = "New Credential Creation"
def... | [
"ubuntui.widgets.hr.HR",
"conjureup.ui.widgets.selectors.MenuSelectButtonList",
"ubuntui.utils.Padding.line_break",
"conjureup.app_config.app.provider.cloud_type.upper"
] | [((375, 406), 'conjureup.app_config.app.provider.cloud_type.upper', 'app.provider.cloud_type.upper', ([], {}), '()\n', (404, 406), False, 'from conjureup.app_config import app\n'), ((1051, 1103), 'conjureup.ui.widgets.selectors.MenuSelectButtonList', 'MenuSelectButtonList', (['self.credentials', 'self.default'], {}), '... |
#!/usr/bin/env python3
import transactions
import taxmap
import db
import settings
import datetime
import argparse
import uuid
import pickle
import jsonpickle
import logging
import logging.handlers
import traceback
def main():
handler = logging.handlers.RotatingFileHandler('../main.log', maxBytes=33554432, backup... | [
"transactions.getTransactionCount",
"logging.info",
"db.findReport",
"argparse.ArgumentParser",
"transactions.getTransactionList",
"db.updateReportError",
"traceback.print_exc",
"jsonpickle.loads",
"logging.handlers.RotatingFileHandler",
"pickle.load",
"logging.warning",
"db.ReportOptions",
... | [((243, 333), 'logging.handlers.RotatingFileHandler', 'logging.handlers.RotatingFileHandler', (['"""../main.log"""'], {'maxBytes': '(33554432)', 'backupCount': '(10)'}), "('../main.log', maxBytes=33554432,\n backupCount=10)\n", (279, 333), False, 'import logging\n'), ((334, 494), 'logging.basicConfig', 'logging.basi... |
"""データセットをダウンロードするためのスクリプトです."""
# default packages
import logging
import pathlib
import traceback
import urllib.request as request
# third party
import pandas as pd
import tqdm as tqdm_std
# my packages
import src.data.directory as directory
# logger
logger = logging.getLogger(__name__)
class TqdmUpTo(tqdm_std.tq... | [
"logging.getLogger",
"logging.basicConfig",
"traceback.format_exc",
"pandas.read_csv",
"urllib.request.urlretrieve",
"src.data.directory.get_raw"
] | [((264, 291), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (281, 291), False, 'import logging\n'), ((1292, 1331), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (1311, 1331), False, 'import logging\n'), ((1833, 1854), 'pandas.rea... |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'F:\work\code\pyqt5\ui\main.ui'
#
# Created by: PyQt5 UI code generator 5.9
#
# WARNING! All changes made in this file will be lost!
from PyQt5 import QtCore, QtGui, QtWidgets
class Ui_MainWindow(object):
def setupUi(self, MainWindow):
... | [
"PyQt5.QtWidgets.QWidget",
"PyQt5.QtWidgets.QTextEdit",
"PyQt5.QtWidgets.QMainWindow",
"PyQt5.QtWidgets.QComboBox",
"PyQt5.QtCore.QMetaObject.connectSlotsByName",
"PyQt5.QtWidgets.QHBoxLayout",
"PyQt5.QtWidgets.QVBoxLayout",
"PyQt5.QtWidgets.QGridLayout",
"PyQt5.QtWidgets.QStatusBar",
"PyQt5.QtWid... | [((7848, 7880), 'PyQt5.QtWidgets.QApplication', 'QtWidgets.QApplication', (['sys.argv'], {}), '(sys.argv)\n', (7870, 7880), False, 'from PyQt5 import QtCore, QtGui, QtWidgets\n'), ((7898, 7921), 'PyQt5.QtWidgets.QMainWindow', 'QtWidgets.QMainWindow', ([], {}), '()\n', (7919, 7921), False, 'from PyQt5 import QtCore, QtG... |
# Copyright 2018 ZTE Corporation.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in ... | [
"logging.getLogger",
"lcm.ns.serializers.deprecated.ns_serializers._CreateNsReqSerializer",
"lcm.pub.utils.values.ignore_case_get",
"lcm.ns.biz.ns_create.CreateNSService",
"lcm.ns.serializers.deprecated.ns_serializers._CreateNsRespSerializer",
"lcm.ns.serializers.deprecated.ns_serializers._QueryNsRespSeri... | [((1305, 1332), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (1322, 1332), False, 'import logging\n'), ((1853, 1896), 'lcm.ns.serializers.deprecated.ns_serializers._QueryNsRespSerializer', '_QueryNsRespSerializer', ([], {'data': 'ret', 'many': '(True)'}), '(data=ret, many=True)\n', (187... |
#!/usr/bin/env python3
import javalang
def isPrimitive(obj):
return not hasattr(obj, '__dict__')
def extract_bad_function_from_text(src):
return extract_function_from_text(src, criterion='bad')
def extract_function_from_text(src, criterion='bad'):
def recursive_find_deepest_child_position(node_body, ... | [
"javalang.parse.parse"
] | [((2088, 2113), 'javalang.parse.parse', 'javalang.parse.parse', (['src'], {}), '(src)\n', (2108, 2113), False, 'import javalang\n')] |
import torch
import torch.nn as nn
from torchvision.datasets.vision import VisionDataset
from PIL import Image
import os, sys, math
import os.path
import torch
import json
import torch.utils.model_zoo as model_zoo
from Yolo_v2_pytorch.src.utils import *
from Yolo_v2_pytorch.src.yolo_net import Yolo
from Yolo_v2_pytorc... | [
"torch.nn.ReLU",
"torch.nn.Dropout",
"torch.sin",
"torch.exp",
"math.log",
"numpy.array",
"torch.cos",
"torch.sum",
"torch.nn.AvgPool2d",
"torch.nn.functional.softmax",
"torch.arange",
"torch.nn.BatchNorm2d",
"Yolo_v2_pytorch.src.yolo_tunning.YoloD",
"torch.nn.LayerNorm",
"torch.matmul",... | [((1750, 1839), 'torch.nn.Conv2d', 'nn.Conv2d', (['in_planes', 'out_planes'], {'kernel_size': '(3)', 'stride': 'stride', 'padding': '(1)', 'bias': '(False)'}), '(in_planes, out_planes, kernel_size=3, stride=stride, padding=1,\n bias=False)\n', (1759, 1839), True, 'import torch.nn as nn\n'), ((6545, 6631), 'torch.nn.... |
"""
Challenge Exercises for Chapter 1.
"""
import random
import timeit
from algs.table import DataTable, ExerciseNum, caption
from algs.counting import RecordedItem
def partition(A, lo, hi, idx):
"""
Partition using A[idx] as value. Note lo and hi are INCLUSIVE on both
ends and idx must be valid index. C... | [
"random.shuffle",
"algs.table.caption",
"ch01.largest_two.Match.advance",
"algs.counting.RecordedItem.report",
"algs.counting.RecordedItem.clear",
"algs.table.ExerciseNum",
"ch01.largest_two.Match",
"algs.counting.RecordedItem",
"algs.table.DataTable",
"random.randint"
] | [((2712, 2803), 'algs.table.DataTable', 'DataTable', (['[8, 15, 15]', "['N', 'counting_sort', 'counting_sort_improved']"], {'output': 'output'}), "([8, 15, 15], ['N', 'counting_sort', 'counting_sort_improved'],\n output=output)\n", (2721, 2803), False, 'from algs.table import DataTable, ExerciseNum, caption\n'), ((3... |
import torch
import pytest
# NOTE: also registers the KL divergence
from chmp.torch_utils import NormalModule, WeightsHS, fixed
def test_kl_divergence__gamma__log_normal():
p = torch.distributions.LogNormal(torch.zeros(2), torch.ones(2))
q = torch.distributions.Gamma(torch.ones(2), torch.ones(2))
torch.... | [
"pytest.approx",
"torch.mean",
"torch.distributions.kl_divergence",
"chmp.torch_utils.WeightsHS",
"torch.zeros",
"torch.ones"
] | [((314, 353), 'torch.distributions.kl_divergence', 'torch.distributions.kl_divergence', (['p', 'q'], {}), '(p, q)\n', (347, 353), False, 'import torch\n'), ((1303, 1339), 'chmp.torch_utils.WeightsHS', 'WeightsHS', (['[10, 20, 30]'], {'tau_0': '(1e-05)'}), '([10, 20, 30], tau_0=1e-05)\n', (1312, 1339), False, 'from chmp... |
import torch
from torch_geometric.data import Data
from graphnet.components.pool import group_pulses_to_dom, group_pulses_to_pmt, sum_pool_and_distribute
from graphnet.data.constants import FEATURES
from graphnet.models.detector.detector import Detector
class IceCube86(Detector):
"""`Detector` class for IceCube-... | [
"graphnet.components.pool.group_pulses_to_dom",
"torch.stack",
"torch.log10",
"graphnet.components.pool.group_pulses_to_pmt",
"graphnet.components.pool.sum_pool_and_distribute",
"torch.norm"
] | [((3121, 3146), 'graphnet.components.pool.group_pulses_to_dom', 'group_pulses_to_dom', (['data'], {}), '(data)\n', (3140, 3146), False, 'from graphnet.components.pool import group_pulses_to_dom, group_pulses_to_pmt, sum_pool_and_distribute\n'), ((3162, 3187), 'graphnet.components.pool.group_pulses_to_pmt', 'group_pulse... |
import dearpygui.dearpygui as dpg
import datetime as dt
import math
from registry import *
SUN_DATA.update_date()
# FUNCTIONS
def get_semi_circle_points( center, radius, angle_i, angle_f, segments = 360, closed = False ):
points_close = [[ center[0], center[1]-radius ] , center, [ c... | [
"dearpygui.dearpygui.set_axis_limits",
"dearpygui.dearpygui.set_axis_limits_auto",
"math.cos",
"dearpygui.dearpygui.window",
"dearpygui.dearpygui.add_drag_floatx",
"dearpygui.dearpygui.menu_bar",
"dearpygui.dearpygui.hide_item",
"dearpygui.dearpygui.add_drag_float",
"dearpygui.dearpygui.add_drawlist... | [((5563, 5661), 'dearpygui.dearpygui.configure_item', 'dpg.configure_item', (['(id_link + 1)'], {'p1': '[center[0] - r, center[1]]', 'p2': '[center[0] + r, center[1]]'}), '(id_link + 1, p1=[center[0] - r, center[1]], p2=[center[0\n ] + r, center[1]])\n', (5581, 5661), True, 'import dearpygui.dearpygui as dpg\n'), ((... |
import os, time, mimetypes, glob
from django.utils.translation import gettext_lazy as _
from django.urls import reverse
from task.const import *
from task.models import Task, detect_group
from rusel.base.config import Config
from rusel.base.forms import CreateGroupForm
from rusel.context import get_base_context
from ru... | [
"os.path.getsize",
"task.models.detect_group",
"rusel.base.forms.CreateGroupForm",
"django.utils.translation.gettext_lazy",
"task.models.Task.get_role_tasks",
"rusel.base.config.Config",
"rusel.utils.extract_get_params",
"os.scandir",
"django.urls.reverse",
"mimetypes.guess_type",
"os.path.getmt... | [((438, 462), 'rusel.base.config.Config', 'Config', (['config', 'cur_view'], {}), '(config, cur_view)\n', (444, 462), False, 'from rusel.base.config import Config\n'), ((1433, 1450), 'rusel.base.forms.CreateGroupForm', 'CreateGroupForm', ([], {}), '()\n', (1448, 1450), False, 'from rusel.base.forms import CreateGroupFo... |
# -*- coding: utf-8 -*-
# Copyright (c) 2017, Frappe Technologies Pvt. Ltd. and Contributors
# See license.txt
from __future__ import unicode_literals
import frappe
import unittest
class TestStockSettings(unittest.TestCase):
def setUp(self):
frappe.db.set_value("Stock Settings", None, "clean_description_html", 0)
... | [
"frappe.get_single",
"frappe.db.set_value"
] | [((247, 319), 'frappe.db.set_value', 'frappe.db.set_value', (['"""Stock Settings"""', 'None', '"""clean_description_html"""', '(0)'], {}), "('Stock Settings', None, 'clean_description_html', 0)\n", (266, 319), False, 'import frappe\n'), ((837, 872), 'frappe.get_single', 'frappe.get_single', (['"""Stock Settings"""'], {... |
#!/usr/bin/env python
import rospy
from std_msgs.msg import Float64
import random
possibleLayers = [140, 50, 80, 200, 100]
cur_position = 0.0
def position_callback(msg):
global cur_position
cur_position = msg.data
#Build the layers simulation, then publish material strengths. Lasts 100 seconds.
def runLayers... | [
"rospy.Subscriber",
"rospy.is_shutdown",
"rospy.init_node",
"rospy.Rate",
"rospy.Publisher",
"random.randint"
] | [((343, 365), 'random.randint', 'random.randint', (['(10)', '(20)'], {}), '(10, 20)\n', (357, 365), False, 'import random\n'), ((575, 635), 'rospy.Publisher', 'rospy.Publisher', (['"""material_strength"""', 'Float64'], {'queue_size': '(10)'}), "('material_strength', Float64, queue_size=10)\n", (590, 635), False, 'impor... |
import scrapy
import re
from scrapy.linkextractors import LinkExtractor
from scrapy.spiders import CrawlSpider, Rule
from ..items import ImagescraperItem
class ImageCrawlSpiderSpider(CrawlSpider):
name = "image_crawl_spider"
allowed_domains = ["books.toscrape.com"]
def start_requests(self):
url =... | [
"scrapy.Request",
"scrapy.linkextractors.LinkExtractor",
"re.match"
] | [((364, 387), 'scrapy.Request', 'scrapy.Request', ([], {'url': 'url'}), '(url=url)\n', (378, 387), False, 'import scrapy\n'), ((407, 440), 'scrapy.linkextractors.LinkExtractor', 'LinkExtractor', ([], {'allow': '"""catalogue/"""'}), "(allow='catalogue/')\n", (420, 440), False, 'from scrapy.linkextractors import LinkExtr... |
import os
import argparse
import subprocess
import random
import edlib
from typing import List
from collections import Counter
import stanza
class ExtractMetric(object):
"""used for precision recall"""
def __init__(self, nume=0, denom_p=0, denom_r=0, precision=0, recall=0, f1=0):
super(ExtractMetric, ... | [
"edlib.align",
"argparse.ArgumentParser",
"os.path.join",
"collections.Counter",
"stanza.Pipeline"
] | [((6056, 6120), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Evaluate analysis metrics"""'}), "(description='Evaluate analysis metrics')\n", (6079, 6120), False, 'import argparse\n'), ((6576, 6619), 'os.path.join', 'os.path.join', (['args.exp_dir', '"""prototype.txt"""'], {}), "(args.e... |
""" The ARIMA model. """
import torch
import numpy as np
class ARIMA(torch.nn.Module):
"""ARIMA [summary]
"""
def __init__(self,
p: int = 0,
d: int = 0,
q: int = 0) -> None:
"""__init__ General ARIMA model constructor.
Args:
... | [
"numpy.random.normal",
"torch.pow",
"torch.diff",
"torch.no_grad",
"torch.zeros",
"torch.rand"
] | [((789, 802), 'torch.rand', 'torch.rand', (['p'], {}), '(p)\n', (799, 802), False, 'import torch\n'), ((889, 902), 'torch.rand', 'torch.rand', (['q'], {}), '(q)\n', (899, 902), False, 'import torch\n'), ((989, 1002), 'torch.rand', 'torch.rand', (['d'], {}), '(d)\n', (999, 1002), False, 'import torch\n'), ((1067, 1080),... |
#import
import os
#import torch
#import torch.nn as nn
import torch.utils.data as Data
#import torchvision
import matplotlib.pyplot as plt
import h5py
#from torch.autograd import Variable
import numpy as np
import torch
class rawdataDataset(Data.Dataset):
def __init__(self):
super(rawdataDataset, self)... | [
"os.path.join",
"h5py.File"
] | [((796, 833), 'os.path.join', 'os.path.join', (['opt.dataroot', 'opt.phase'], {}), '(opt.dataroot, opt.phase)\n', (808, 833), False, 'import os\n'), ((1025, 1053), 'h5py.File', 'h5py.File', (['self.A_paths', '"""r"""'], {}), "(self.A_paths, 'r')\n", (1034, 1053), False, 'import h5py\n'), ((1076, 1104), 'h5py.File', 'h5... |
"""
Copyright 2012-2019 <NAME>
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
di... | [
"dateutil.tz.tzutc",
"unittest.mock.Mock",
"hqlib.metric_source.JunitTestReport",
"dateutil.tz.tzlocal"
] | [((921, 938), 'hqlib.metric_source.JunitTestReport', 'JunitTestReport', ([], {}), '()\n', (936, 938), False, 'from hqlib.metric_source import JunitTestReport\n'), ((1058, 1271), 'unittest.mock.Mock', 'Mock', ([], {'return_value': '"""<testsuites> <testsuite tests="12" failures="2" errors="0" skipped="1" disabled="0"> ... |
sort_functions = [
builtinsort, # see implementation above
insertion_sort, # see [[Insertion sort]]
insertion_sort_lowb, # ''insertion_sort'', where sequential search is replaced
# by lower_bound() function
qsort, # see [[Quicksort]]
qsortranlc... | [
"sys.setrecursionlimit"
] | [((719, 747), 'sys.setrecursionlimit', 'sys.setrecursionlimit', (['(10000)'], {}), '(10000)\n', (740, 747), False, 'import sys\n')] |
from flaskapp import app, db, mail
from flask import render_template, url_for
from flask import request, flash, redirect
# from flaskapp.model import User
from flaskapp.form import SurveyForm
from flask_mail import Message
@app.route('/', methods = ['POST', 'GET'])
def form():
form = SurveyForm()
if ... | [
"flask.render_template",
"flaskapp.app.route",
"flask.flash",
"flask.url_for",
"flaskapp.form.SurveyForm",
"flask_mail.Message",
"flaskapp.mail.send"
] | [((232, 271), 'flaskapp.app.route', 'app.route', (['"""/"""'], {'methods': "['POST', 'GET']"}), "('/', methods=['POST', 'GET'])\n", (241, 271), False, 'from flaskapp import app, db, mail\n'), ((884, 903), 'flaskapp.app.route', 'app.route', (['"""/thank"""'], {}), "('/thank')\n", (893, 903), False, 'from flaskapp import... |
import unittest
from kameramera import camera
class Camera(unittest.TestCase):
def setUp(self):
self.camera = camera.Camera(camera_id='canon_ae1')
def test_general_manufacturer(self):
self.assertEqual(self.camera.general.manufacturer, 'Canon')
def test_general_name(self):
se... | [
"kameramera.camera.Camera"
] | [((125, 161), 'kameramera.camera.Camera', 'camera.Camera', ([], {'camera_id': '"""canon_ae1"""'}), "(camera_id='canon_ae1')\n", (138, 161), False, 'from kameramera import camera\n')] |
import matplotlib.pyplot as plt
import numpy as np
import math
import cv2
kernel = np.ones((3, 3), np.int8)
# 去除雜訊
def eraseImage (image):
return cv2.erode(image, kernel, iterations = 1)
# 模糊圖片
def blurImage (image):
return cv2.GaussianBlur(image, (5, 5), 0)
# 銳利化圖片
# threshold1,2，較小的值為作為偵測邊界的最小值
def edgedImage... | [
"cv2.rectangle",
"numpy.ones",
"cv2.resize",
"cv2.erode",
"matplotlib.pyplot.plot",
"cv2.boundingRect",
"cv2.imshow",
"cv2.waitKey",
"cv2.destroyAllWindows",
"cv2.findContours",
"cv2.dilate",
"cv2.Canny",
"cv2.imread",
"cv2.GaussianBlur",
"matplotlib.pyplot.show"
] | [((84, 108), 'numpy.ones', 'np.ones', (['(3, 3)', 'np.int8'], {}), '((3, 3), np.int8)\n', (91, 108), True, 'import numpy as np\n'), ((150, 188), 'cv2.erode', 'cv2.erode', (['image', 'kernel'], {'iterations': '(1)'}), '(image, kernel, iterations=1)\n', (159, 188), False, 'import cv2\n'), ((231, 265), 'cv2.GaussianBlur',... |
import pprint
from nn_wtf.parameter_optimizers.neural_network_optimizer import NeuralNetworkOptimizer
__author__ = '<NAME> <<EMAIL>>'
class BruteForceOptimizer(NeuralNetworkOptimizer):
DEFAULT_LAYER_SIZES = (
(32, 48, 64), # (32, 48, 64, 80, 96, 128),
(32, 48, 64, 80, 96, 128),
(None, ... | [
"pprint.pprint",
"nn_wtf.parameter_optimizers.neural_network_optimizer.NeuralNetworkOptimizer.OptimizationParameters"
] | [((1758, 1791), 'pprint.pprint', 'pprint.pprint', (['results'], {'width': '(100)'}), '(results, width=100)\n', (1771, 1791), False, 'import pprint\n'), ((1509, 1584), 'nn_wtf.parameter_optimizers.neural_network_optimizer.NeuralNetworkOptimizer.OptimizationParameters', 'NeuralNetworkOptimizer.OptimizationParameters', ([... |
import numpy as np
import tensorflow as tf
import sys, os
sys.path.extend(['alg/', 'models/'])
from visualisation import plot_images
from encoder_no_shared import encoder, recon
from utils import init_variables, save_params, load_params, load_data
from eval_test_ll import construct_eval_func
dimZ = 50
dimH = 500
n_cha... | [
"eval_test_ll.construct_eval_func",
"generator.construct_gen",
"notmnist.load_notmnist",
"vae_laplace.init_fisher_accum",
"visualisation.plot_images",
"vae_si.update_si_reg",
"tensorflow.placeholder",
"tensorflow.Session",
"utils.load_params",
"os.path.isdir",
"sys.path.extend",
"os.mkdir",
... | [((58, 94), 'sys.path.extend', 'sys.path.extend', (["['alg/', 'models/']"], {}), "(['alg/', 'models/'])\n", (73, 94), False, 'import sys, os\n'), ((580, 608), 'config.config', 'config', (['data_name', 'n_channel'], {}), '(data_name, n_channel)\n', (586, 608), False, 'from config import config\n'), ((1757, 1810), 'tenso... |
import logging
import os
import cltl.combot.infra.config.local as local_config
logger = logging.getLogger(__name__)
K8_CONFIG_DIR = "/cltl_k8_config"
K8_CONFIG = "config/k8.config"
class K8LocalConfigurationContainer(local_config.LocalConfigurationContainer):
@staticmethod
def load_configuration(config_fi... | [
"logging.getLogger",
"os.listdir",
"os.path.join",
"cltl.combot.infra.config.local.LocalConfigurationContainer.load_configuration"
] | [((90, 117), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (107, 117), False, 'import logging\n'), ((773, 858), 'cltl.combot.infra.config.local.LocalConfigurationContainer.load_configuration', 'local_config.LocalConfigurationContainer.load_configuration', (['config_file', 'configs'], {})... |
import json
import apiai
import speech_recognition as sr
def speechRecognition():
recog = sr.Recognizer()
with sr.Microphone() as source:
print("It's your cue")
audio = recog.listen(source)
i = True
while i is True:
try:
text = recog.recognize_google(audio)
... | [
"speech_recognition.Recognizer",
"apiai.ApiAI",
"speech_recognition.Microphone"
] | [((96, 111), 'speech_recognition.Recognizer', 'sr.Recognizer', ([], {}), '()\n', (109, 111), True, 'import speech_recognition as sr\n'), ((650, 682), 'apiai.ApiAI', 'apiai.ApiAI', (['CLIENT_ACCESS_TOKEN'], {}), '(CLIENT_ACCESS_TOKEN)\n', (661, 682), False, 'import apiai\n'), ((121, 136), 'speech_recognition.Microphone'... |
# raise NotImplementedError("Did not check!")
"""MSCOCO Semantic Segmentation pretraining for VOC."""
import os
from tqdm import trange
from PIL import Image, ImageOps, ImageFilter
import numpy as np
import pickle
from gluoncv.data.segbase import SegmentationDataset
class COCOSegmentation(SegmentationDataset):
... | [
"os.path.exists",
"pickle.dump",
"os.path.join",
"pycocotools.coco.COCO",
"pickle.load",
"numpy.sum",
"numpy.zeros",
"os.path.expanduser"
] | [((471, 515), 'os.path.expanduser', 'os.path.expanduser', (['"""~/.mxnet/datasets/coco"""'], {}), "('~/.mxnet/datasets/coco')\n", (489, 515), False, 'import os\n'), ((1266, 1280), 'pycocotools.coco.COCO', 'COCO', (['ann_file'], {}), '(ann_file)\n', (1270, 1280), False, 'from pycocotools.coco import COCO\n'), ((1322, 13... |
# __author__ = 'sree'
import urllib2
from lxml import html
import requests
def get_page_tree(url=None):
page = requests.get(url=url, verify=False)
return html.fromstring(page.text)
def get_title(url=None):
tree = get_page_tree(url=url)
return tree.xpath('//title//text()')[0].strip().split(' -')[0]
d... | [
"lxml.html.fromstring",
"urllib2.quote",
"requests.get"
] | [((117, 152), 'requests.get', 'requests.get', ([], {'url': 'url', 'verify': '(False)'}), '(url=url, verify=False)\n', (129, 152), False, 'import requests\n'), ((164, 190), 'lxml.html.fromstring', 'html.fromstring', (['page.text'], {}), '(page.text)\n', (179, 190), False, 'from lxml import html\n'), ((668, 688), 'urllib... |
# encoding: utf-8
# Copyright 2009-2020 <NAME>.
#
# 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
#
# https://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or a... | [
"os.path.exists",
"xml.dom.minidom.parse",
"sqlite3.connect",
"os.path.join",
"os.path.isfile",
"os.path.dirname",
"xml.dom.minidom.parseString",
"os.path.isdir",
"os.path.basename",
"os.walk"
] | [((1103, 1119), 'os.walk', 'os.walk', (['dirpath'], {}), '(dirpath)\n', (1110, 1119), False, 'import os\n'), ((1515, 1531), 'os.walk', 'os.walk', (['dirpath'], {}), '(dirpath)\n', (1522, 1531), False, 'import os\n'), ((1953, 1969), 'os.walk', 'os.walk', (['dirpath'], {}), '(dirpath)\n', (1960, 1969), False, 'import os\... |
import datetime, hashlib, base64, traceback, os, re
import poshc2.server.database.DB as DB
from poshc2.Colours import Colours
from poshc2.server.Config import ModulesDirectory, DownloadsDirectory, ReportsDirectory
from poshc2.server.Implant import Implant
from poshc2.server.Core import decrypt, encrypt, default_respon... | [
"poshc2.server.Core.process_mimikatz",
"poshc2.server.database.DB.get_implanttype",
"base64.b64encode",
"poshc2.server.database.DB.get_implants_all",
"poshc2.server.database.DB.get_implantbyrandomuri",
"poshc2.server.database.DB.new_task",
"re.search",
"os.listdir",
"poshc2.Utils.randomuri",
"posh... | [((704, 727), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (725, 727), False, 'import datetime, hashlib, base64, traceback, os, re\n'), ((747, 768), 'poshc2.server.database.DB.get_implants_all', 'DB.get_implants_all', ([], {}), '()\n', (766, 768), True, 'import poshc2.server.database.DB as DB\n')... |
from django.urls import path, re_path
from . import views
urlpatterns = [
path('', views.index, name='index'),
path('countdown/', views.countdown, name='countdown'),
#re_path(r'.+', views.redir, name='redir'),
]
| [
"django.urls.path"
] | [((80, 115), 'django.urls.path', 'path', (['""""""', 'views.index'], {'name': '"""index"""'}), "('', views.index, name='index')\n", (84, 115), False, 'from django.urls import path, re_path\n'), ((121, 174), 'django.urls.path', 'path', (['"""countdown/"""', 'views.countdown'], {'name': '"""countdown"""'}), "('countdown/... |
# Copyright (C) 2013 Nippon Telegraph and Telephone Corporation.
#
# 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... | [
"flask.render_template",
"flask.request.host.split"
] | [((819, 842), 'flask.request.host.split', 'request.host.split', (['""":"""'], {}), "(':')\n", (837, 842), False, 'from flask import render_template, request\n'), ((858, 912), 'flask.render_template', 'render_template', (['"""topology.html"""'], {'host': 'host', 'port': 'port'}), "('topology.html', host=host, port=port)... |
import tensorflow as tf
import numpy as np
def clipped_error(x):
# Huber loss
try:
return tf.select(tf.abs(x) < 1.0, 0.5 * tf.square(x), tf.abs(x) - 0.5 )
except:
return tf.where(tf.abs(x) < 1.0, 0.5 * tf.square(x), tf.abs(x) - 0.5 )
def linear(input_, output_size, stddev=0.02, bias_star... | [
"tensorflow.variable_scope",
"tensorflow.random_normal_initializer",
"tensorflow.matmul",
"tensorflow.constant_initializer",
"tensorflow.square",
"tensorflow.abs"
] | [((425, 448), 'tensorflow.variable_scope', 'tf.variable_scope', (['name'], {}), '(name)\n', (442, 448), True, 'import tensorflow as tf\n'), ((553, 596), 'tensorflow.random_normal_initializer', 'tf.random_normal_initializer', ([], {'stddev': 'stddev'}), '(stddev=stddev)\n', (581, 596), True, 'import tensorflow as tf\n')... |
"""Cell parameter random initializations."""
from typing import Any, Dict
import numpy as np
from ..parameters import (
Height,
NewCellBendLowerLower,
NewCellBendLowerUpper,
NewCellBendOverallLower,
NewCellBendOverallUpper,
NewCellBendUpperLower,
NewCellBendUpperUpper,
NewCellLength1Me... | [
"numpy.sin",
"numpy.cos"
] | [((3328, 3341), 'numpy.cos', 'np.cos', (['angle'], {}), '(angle)\n', (3334, 3341), True, 'import numpy as np\n'), ((3397, 3410), 'numpy.sin', 'np.sin', (['angle'], {}), '(angle)\n', (3403, 3410), True, 'import numpy as np\n')] |
import qiskit
import numpy as np
import matplotlib.pyplot as plt
import json
from graph import *
# Random comment
P =1
def makeCircuit(inbits, outbits):
q = qiskit.QuantumRegister(inbits+outbits)
c = qiskit.ClassicalRegister(inbits+outbits)
qc = qiskit.QuantumCircuit(q, c)
q_input = [q[i] for i in ran... | [
"qiskit.ClassicalRegister",
"matplotlib.pyplot.title",
"qiskit.execute",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"json.dump",
"numpy.binary_repr",
"numpy.linspace",
"matplotlib.pyplot.errorbar",
"json.load",
"qiskit.QuantumCircuit",
"qiskit.QuantumRegister",
"matplotlib.pyplo... | [((162, 202), 'qiskit.QuantumRegister', 'qiskit.QuantumRegister', (['(inbits + outbits)'], {}), '(inbits + outbits)\n', (184, 202), False, 'import qiskit\n'), ((209, 251), 'qiskit.ClassicalRegister', 'qiskit.ClassicalRegister', (['(inbits + outbits)'], {}), '(inbits + outbits)\n', (233, 251), False, 'import qiskit\n'),... |
"""Simple code for training an RNN for motion prediction."""
import os
import sys
import time
import numpy as np
import torch
import torch.optim as optim
from torch.autograd import Variable
import mtfixb_model
import mtfixb_model2
import parseopts
def create_model(args, total_num_batches):
"""Create MT model a... | [
"numpy.sqrt",
"torch.from_numpy",
"parseopts.parse_args",
"torch.exp",
"parseopts.initial_arg_transform",
"mtfixb_model2.MTGRU_NoBias",
"mtfixb_model.MTGRU",
"mtfixb_model.DataIterator",
"mtfixb_model.OpenLoopGRU",
"sys.stdout.flush",
"torch.optim.SGD",
"mtfixb_model.DynamicsDict",
"numpy.in... | [((890, 1307), 'mtfixb_model.MTGRU', 'mtfixb_model.MTGRU', (['args.seq_length_out', 'args.decoder_size', 'args.decoder_size2', 'args.batch_size', 'total_num_batches', 'args.k', 'args.size_psi_hidden', 'args.size_psi_lowrank', 'args.bottleneck'], {'output_dim': 'args.human_size', 'input_dim': 'args.input_size', 'dropout... |
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not u... | [
"tvm.relay.nn.conv2d_transpose",
"tvm.relay.transpose",
"tvm.te.compute",
"tvm.te.reduce_axis"
] | [((3445, 3589), 'tvm.te.compute', 'te.compute', (['(out_c, in_c, filter_h, filter_w)', '(lambda o, i, h, w: kernel[i][o][filter_h - 1 - h][filter_w - 1 - w])'], {'name': '"""kernel_transform"""'}), "((out_c, in_c, filter_h, filter_w), lambda o, i, h, w: kernel[i][\n o][filter_h - 1 - h][filter_w - 1 - w], name='kern... |
import argparse
import copy
import torch
from torchvision.datasets import MNIST, CIFAR10
import torchvision.transforms as TF
import torchelie as tch
import torchelie.loss.gan.hinge as gan_loss
from torchelie.recipes.gan import GANRecipe
import torchelie.callbacks as tcb
from torchelie.recipes import Recipe
parser =... | [
"copy.deepcopy",
"argparse.ArgumentParser",
"torchelie.transforms.AdaptPad",
"torchelie.callbacks.Log",
"torchelie.loss.gan.hinge.generated",
"torchvision.transforms.RandomHorizontalFlip",
"torchelie.callbacks.WindowedMetricAvg",
"torchelie.callbacks.Polyak",
"torchvision.datasets.CIFAR10",
"torch... | [((321, 346), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (344, 346), False, 'import argparse\n'), ((607, 671), 'torchvision.datasets.CIFAR10', 'CIFAR10', (['"""~/.cache/torch/cifar10"""'], {'download': '(True)', 'transform': 'tfms'}), "('~/.cache/torch/cifar10', download=True, transform=tfm... |
import xml.sax
import rdflib
from django.db import transaction
from hs_core.serialization import GenericResourceMeta
class RasterResourceMeta(GenericResourceMeta):
"""
Lightweight class for representing metadata of RasterResource instances.
"""
def __init__(self):
super(RasterResourceMeta, s... | [
"rdflib.namespace.Namespace",
"hs_core.serialization.GenericResourceMeta.ResourceMetaException"
] | [((876, 934), 'rdflib.namespace.Namespace', 'rdflib.namespace.Namespace', (['"""http://hydroshare.org/terms/"""'], {}), "('http://hydroshare.org/terms/')\n", (902, 934), False, 'import rdflib\n'), ((1387, 1433), 'hs_core.serialization.GenericResourceMeta.ResourceMetaException', 'GenericResourceMeta.ResourceMetaExceptio... |
import os
import os.path
import sqlite3
import logging
from typing import List
from gumtree_watchdog.types import Listing, Contract, ListingWithChatId
TConn = sqlite3.Connection
DB_PATH = os.environ.get('GUMTREE_DB')
def get_connection() -> TConn:
if not DB_PATH:
raise Exception("Please specify Sqlite3 db... | [
"sqlite3.connect",
"gumtree_watchdog.types.ListingWithChatId",
"logging.warning",
"os.environ.get",
"os.path.isfile",
"gumtree_watchdog.types.Contract",
"logging.info"
] | [((189, 217), 'os.environ.get', 'os.environ.get', (['"""GUMTREE_DB"""'], {}), "('GUMTREE_DB')\n", (203, 217), False, 'import os\n'), ((375, 399), 'sqlite3.connect', 'sqlite3.connect', (['DB_PATH'], {}), '(DB_PATH)\n', (390, 399), False, 'import sqlite3\n'), ((478, 501), 'os.path.isfile', 'os.path.isfile', (['DB_PATH'],... |
#section [initial]
def _parameters_accessors_checks():
from finess.params import Parameter, Accessor, Check, \
CheckGreaterEqual, CheckGreaterThan, \
CheckOneOf, EnumParameterType
parameters = []
checks = []
rhol = Parameter(variable_name = "rhol",
... | [
"finess.params.CheckGreaterThan",
"finess.params.Parameter"
] | [((280, 359), 'finess.params.Parameter', 'Parameter', ([], {'variable_name': '"""rhol"""', 'section': '"""initial"""', 'name': '"""rhol"""', 'type_': '"""double"""'}), "(variable_name='rhol', section='initial', name='rhol', type_='double')\n", (289, 359), False, 'from finess.params import Parameter, Accessor, Check, Ch... |
from setuptools import setup
import os
with open("README.md", "r", encoding="utf-8") as f:
long_description = f.read()
requirements = []
if os.path.isfile("./requirements.txt"):
with open("requirements.txt", "r") as f:
requirements = f.read()
requirements = [x for x in requirements.split("\n") if ... | [
"os.path.isfile",
"setuptools.setup"
] | [((146, 182), 'os.path.isfile', 'os.path.isfile', (['"""./requirements.txt"""'], {}), "('./requirements.txt')\n", (160, 182), False, 'import os\n'), ((330, 1000), 'setuptools.setup', 'setup', ([], {'name': '"""ma5_expert"""', 'version': '"""0.0.1"""', 'description': '"""MadAnalysis 5 interpreter for Expert mode"""', 'l... |
import time
import numpy as np
import vtk
from vtk.util import numpy_support
from svtk.lib.toolbox.integer import minmax
from svtk.lib.toolbox.idarray import IdArray
from svtk.lib.toolbox.numpy_helpers import normalize
import math as m
class VTKAnimationTimerCallback(object):
"""This class is called every few m... | [
"numpy.tile",
"numpy.allclose",
"math.ceil",
"numpy.cross",
"time.clock",
"math.floor",
"svtk.lib.toolbox.idarray.IdArray",
"vtk.util.numpy_support.numpy_to_vtkIdTypeArray",
"svtk.lib.toolbox.integer.minmax",
"numpy.append",
"numpy.array",
"numpy.matmul",
"vtk.util.numpy_support.numpy_to_vtk... | [((1209, 1221), 'time.clock', 'time.clock', ([], {}), '()\n', (1219, 1221), False, 'import time\n'), ((1264, 1276), 'time.clock', 'time.clock', ([], {}), '()\n', (1274, 1276), False, 'import time\n'), ((1322, 1334), 'time.clock', 'time.clock', ([], {}), '()\n', (1332, 1334), False, 'import time\n'), ((1361, 1373), 'tim... |
import time
import numpy as np
from tqdm import tqdm
from utils import RandomCNOT, RandomCNOTs
def SimulatedAnnealing(quantum_count, layer_count, solver, epochs=100, save_path=None, global_best_score=0):
#TODO:
best_score = 0
cnot = RandomCNOTs(quantum_count, layer_count)
sc, model = solver(cnot)
... | [
"utils.RandomCNOTs",
"numpy.random.randint",
"time.time",
"utils.RandomCNOT"
] | [((247, 286), 'utils.RandomCNOTs', 'RandomCNOTs', (['quantum_count', 'layer_count'], {}), '(quantum_count, layer_count)\n', (258, 286), False, 'from utils import RandomCNOT, RandomCNOTs\n'), ((591, 602), 'time.time', 'time.time', ([], {}), '()\n', (600, 602), False, 'import time\n'), ((2114, 2125), 'time.time', 'time.t... |
#!/usr/bin/env python
#
# Copyright 2013 <NAME>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed ... | [
"testtools.ExpectedException",
"os.path.join",
"os.path.dirname",
"os.path.basename",
"jenkins_jobs.config.JJBConfig",
"jenkins_jobs.parser.YamlParser",
"tests.base.get_scenarios"
] | [((1172, 1258), 'tests.base.get_scenarios', 'base.get_scenarios', (['fixtures_path', '"""yaml"""', '"""json"""'], {'filter_func': '_exclude_scenarios'}), "(fixtures_path, 'yaml', 'json', filter_func=\n _exclude_scenarios)\n", (1190, 1258), False, 'from tests import base\n'), ((1879, 1930), 'tests.base.get_scenarios'... |
from bot_interface import *
import math
class SeijiBot(BotBase):
def __init__(self):
self.initialized = False
def initialize(self, gamestate):
gamestate.log("Initializing...")
#Getting UID
self.uid = gamestate.bot.uid
gamestate.log("This ship has uid " + str(self.ui... | [
"math.floor",
"math.sqrt",
"math.cos",
"math.atan2",
"math.sin"
] | [((1088, 1104), 'math.sqrt', 'math.sqrt', (['delta'], {}), '(delta)\n', (1097, 1104), False, 'import math\n'), ((1214, 1284), 'math.sqrt', 'math.sqrt', (['((obj1.posx - obj2.posx) ** 2 + (obj1.posy - obj2.posy) ** 2)'], {}), '((obj1.posx - obj2.posx) ** 2 + (obj1.posy - obj2.posy) ** 2)\n', (1223, 1284), False, 'import... |
from datetime import date, datetime, timedelta
import time
START_DATE = date(2021, 5, 25)
duration = timedelta(days=100)
def countdown():
event_delta = LAST_DAY_OF_SCHOOL - datetime.now()
print()
print("\tTime until school is out for summer 2021:", end="\n\n")
while event_delta.seconds > 0:
h... | [
"datetime.datetime.now",
"datetime.timedelta",
"datetime.date",
"time.sleep"
] | [((73, 90), 'datetime.date', 'date', (['(2021)', '(5)', '(25)'], {}), '(2021, 5, 25)\n', (77, 90), False, 'from datetime import date, datetime, timedelta\n'), ((102, 121), 'datetime.timedelta', 'timedelta', ([], {'days': '(100)'}), '(days=100)\n', (111, 121), False, 'from datetime import date, datetime, timedelta\n'), ... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
__title__ = ''
__author__ = 'HaiFeng'
__mtime__ = '2016/8/16'
"""
import time
from py_at.EnumDefine import *
########################################################################
class OrderItem(object):
"""策略信号"""
#----------------------------------------------... | [
"time.time"
] | [((477, 488), 'time.time', 'time.time', ([], {}), '()\n', (486, 488), False, 'import time\n')] |
from __future__ import print_function, division
import numpy as np
from numpy import identity, dot, zeros, zeros_like
def rf_den_via_rf0(self, rf0, v):
""" Whole matrix of the interacting response via non-interacting response and interaction"""
rf = zeros_like(rf0)
I = identity(rf0.shape[1])
for ir,r in enume... | [
"numpy.identity",
"numpy.dot",
"numpy.zeros_like"
] | [((255, 270), 'numpy.zeros_like', 'zeros_like', (['rf0'], {}), '(rf0)\n', (265, 270), False, 'from numpy import identity, dot, zeros, zeros_like\n'), ((278, 300), 'numpy.identity', 'identity', (['rf0.shape[1]'], {}), '(rf0.shape[1])\n', (286, 300), False, 'from numpy import identity, dot, zeros, zeros_like\n'), ((364, ... |
import os
import logging
import numpy as np
from typing import Optional
import torch
from torch.utils.data import DataLoader
from ..eval import Metric
from .dataset import CHMMBaseDataset
from .dataset import collate_fn as default_collate_fn
logger = logging.getLogger(__name__)
OUT_RECALL = 0.9
OUT_PRECISION = 0.8
... | [
"logging.getLogger",
"torch.load",
"os.path.join",
"os.path.split",
"os.path.isfile",
"numpy.random.dirichlet",
"torch.save",
"torch.utils.data.DataLoader",
"torch.zeros"
] | [((254, 281), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (271, 281), False, 'import logging\n'), ((14610, 14650), 'numpy.random.dirichlet', 'np.random.dirichlet', (['(init_counts + 1e-10)'], {}), '(init_counts + 1e-10)\n', (14629, 14650), True, 'import numpy as np\n'), ((2409, 2454), ... |
from random import Random
from collections_extended import setlist
# The version of seeding to use for random
SEED_VERSION = 2
# Common alphabets to use
ALPHANUM = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
BASE58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
def shuffle(key... | [
"random.Random",
"collections_extended.setlist"
] | [((336, 347), 'random.Random', 'Random', (['key'], {}), '(key)\n', (342, 347), False, 'from random import Random\n'), ((711, 722), 'random.Random', 'Random', (['key'], {}), '(key)\n', (717, 722), False, 'from random import Random\n'), ((6443, 6460), 'collections_extended.setlist', 'setlist', (['alphabet'], {}), '(alpha... |
# -*- coding: utf-8 -*-
"""
pbkdf2 hashing handler module.
"""
import hashlib
import re
import pyrin.configuration.services as config_services
import pyrin.security.utils.services as security_utils_services
from pyrin.security.hashing.decorators import hashing
from pyrin.security.hashing.handlers.base import Hashing... | [
"pyrin.configuration.services.get",
"pyrin.security.hashing.decorators.hashing",
"pyrin.security.utils.services.get_bytes",
"re.compile"
] | [((488, 497), 'pyrin.security.hashing.decorators.hashing', 'hashing', ([], {}), '()\n', (495, 497), False, 'from pyrin.security.hashing.decorators import hashing\n'), ((790, 848), 're.compile', 're.compile', (['"""^\\\\$PBKDF2\\\\$[^$]+\\\\$[\\\\d]+\\\\$[\\\\d]+\\\\$(.+)$"""'], {}), "('^\\\\$PBKDF2\\\\$[^$]+\\\\$[\\\\d... |
# -*- coding: utf-8 -*-
"""
Created on Wed Jun 28 13:03:05 2017
@author: <NAME>
"""
import cntk as C
import _cntk_py
import cntk.layers
import cntk.initializer
import cntk.losses
import cntk.metrics
import cntk.logging
import cntk.io.transforms as xforms
import cntk.io
import cntk.train
import os
import numpy as np
i... | [
"os.path.exists",
"yolo2.Yolo2Metric",
"_cntk_py.set_computation_network_trace_level",
"cntk.Trainer",
"os.path.join",
"cntk.learners.momentum_sgd",
"yolo2.Yolo2Error",
"cntk.io.transforms.color",
"cntk.learners.momentum_schedule",
"cntk.input_variable",
"cntk.io.transforms.scale",
"numpy.arra... | [((469, 501), 'os.path.join', 'os.path.join', (['abs_path', '"""Models"""'], {}), "(abs_path, 'Models')\n", (481, 501), False, 'import os\n'), ((429, 454), 'os.path.abspath', 'os.path.abspath', (['__file__'], {}), '(__file__)\n', (444, 454), False, 'import os\n'), ((2267, 2326), 'cntk.input_variable', 'C.input_variable... |
from django.core.mail import EmailMessage
from django.conf import settings
def send_email(name, date, email):
txt = """
<html>
<body>
<table cellpadding='0' cellspacing='0' width='100%' border='0'>
<tbody>
<tr>
<td style='word-wrap:break-word;font-size:0px;padding:0px;padding-bottom:10px' alig... | [
"django.core.mail.EmailMessage"
] | [((2019, 2071), 'django.core.mail.EmailMessage', 'EmailMessage', (['settings.EMAIL_TITLE', 'txt'], {'to': '(email,)'}), '(settings.EMAIL_TITLE, txt, to=(email,))\n', (2031, 2071), False, 'from django.core.mail import EmailMessage\n')] |
import KNN as K
K.clearScreen()
dataTraining= K.loadData("dataTraining.txt")
X=dataTraining[:,0:3]
initial_centroids=K.listToArray([[3, 3,3],[6, 2,4],[8,5,7]])
idx=K.KMean_Run(X,initial_centroids,5)
K.SaveData(K.concatenateVectors(X,idx))
K.plotKNN2(X,idx)
| [
"KNN.concatenateVectors",
"KNN.plotKNN2",
"KNN.listToArray",
"KNN.loadData",
"KNN.KMean_Run",
"KNN.clearScreen"
] | [((20, 35), 'KNN.clearScreen', 'K.clearScreen', ([], {}), '()\n', (33, 35), True, 'import KNN as K\n'), ((50, 80), 'KNN.loadData', 'K.loadData', (['"""dataTraining.txt"""'], {}), "('dataTraining.txt')\n", (60, 80), True, 'import KNN as K\n'), ((124, 172), 'KNN.listToArray', 'K.listToArray', (['[[3, 3, 3], [6, 2, 4], [8... |
#!/usr/bin/env python
import pyqtgraph as pg
from pyqtgraph import ViewBox
from hummingbird.graphics.plotter_args import PlotBoxArgs
from hummingbird.graphics.state_plot import StatePlot
class StatePlotBox:
def __init__(self, window, args):
""" Create a new plotbox wrapper object
Arguments:
... | [
"hummingbird.graphics.state_plot.StatePlot",
"pyqtgraph.intColor",
"pyqtgraph.mkPen"
] | [((2115, 2149), 'pyqtgraph.mkPen', 'pg.mkPen', ([], {'color': 'color', 'width': 'width'}), '(color=color, width=width)\n', (2123, 2149), True, 'import pyqtgraph as pg\n'), ((2531, 2565), 'hummingbird.graphics.state_plot.StatePlot', 'StatePlot', (['self.plotbox', 'plot_args'], {}), '(self.plotbox, plot_args)\n', (2540, ... |
import json
#start
print('start')
with open('quizoutput.txt') as f:
lines = f.readlines()
print('loaded quiz data')
print('changing to json')
json_output = json.loads(lines[0])
print(json_output)
with open('quizoutput.txt', 'w') as f:
f.write(json_output)
# for item in json_output:
# print(item['ques... | [
"json.loads"
] | [((166, 186), 'json.loads', 'json.loads', (['lines[0]'], {}), '(lines[0])\n', (176, 186), False, 'import json\n')] |
#!/usr/bin/python
import requests
import boto3
import time
import geopy.distance
import xml.etree.ElementTree as ET
import itertools
import sys
import pickle
S3_BUCKET = "panku-gdzie-jestes-latest-storage"
class LatestPositionStorage(object):
def __init__(self, service):
self.objectName = "%s.latest" % service... | [
"boto3.client",
"boto3.session.Session",
"requests.Session",
"pickle.dumps",
"sys.exc_info",
"boto3.resource",
"xml.etree.ElementTree.fromstring",
"time.time"
] | [((373, 393), 'boto3.resource', 'boto3.resource', (['"""s3"""'], {}), "('s3')\n", (387, 393), False, 'import boto3\n'), ((716, 736), 'boto3.resource', 'boto3.resource', (['"""s3"""'], {}), "('s3')\n", (730, 736), False, 'import boto3\n'), ((817, 840), 'pickle.dumps', 'pickle.dumps', (['positions'], {}), '(positions)\n'... |
# -*- coding: utf-8 -*-
# Generated by Django 1.10.1 on 2017-12-08 18:42
from __future__ import unicode_literals
from django.db import migrations, models
import django.db.models.deletion
def update_questionnaires(apps, schema_editor):
"""
Forward migration function to normalize settings into VMSettings and C... | [
"django.db.migrations.RunPython"
] | [((1361, 1404), 'django.db.migrations.RunPython', 'migrations.RunPython', (['update_questionnaires'], {}), '(update_questionnaires)\n', (1381, 1404), False, 'from django.db import migrations, models\n')] |
import os
import unittest
import json
import filecmp
from genofunk.sequence_utils import *
this_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
class TestSequenceUtils(unittest.TestCase):
def test_get_coordinates_from_json_simple_pairs(self):
json_value = {
"start": 30,
... | [
"os.path.abspath"
] | [((136, 161), 'os.path.abspath', 'os.path.abspath', (['__file__'], {}), '(__file__)\n', (151, 161), False, 'import os\n')] |
# -*- coding: utf-8 -*-
"""
Created on Thu Aug 13 09:52:47 2015
@author: wirkert
"""
import unittest
import os
import numpy as np
import msi.msimanipulations as msimani
from msi.io.nrrdreader import NrrdReader
from msi.io.nrrdwriter import NrrdWriter
from msi.test import helpers
class TestNrrdWriter(unittest.TestC... | [
"msi.io.nrrdreader.NrrdReader",
"os.remove",
"os.path.isfile",
"numpy.array",
"msi.msimanipulations.calculate_mean_spectrum",
"msi.test.helpers.getFakeMsi",
"msi.io.nrrdwriter.NrrdWriter"
] | [((430, 450), 'msi.test.helpers.getFakeMsi', 'helpers.getFakeMsi', ([], {}), '()\n', (448, 450), False, 'from msi.test import helpers\n'), ((574, 604), 'os.remove', 'os.remove', (['self.fileUriToWrite'], {}), '(self.fileUriToWrite)\n', (583, 604), False, 'import os\n'), ((666, 686), 'msi.io.nrrdwriter.NrrdWriter', 'Nrr... |
import h2o
from h2o.base import Keyed
from h2o.exceptions import H2OValueError
from h2o.job import H2OJob
from h2o.model import ModelBase
from h2o.utils.typechecks import assert_is_type, is_type
class H2OAutoMLBaseMixin:
def predict(self, test_data):
"""
Predict on a dataset.
:param ... | [
"h2o.get_model",
"h2o.model.ModelBase.download_mojo",
"h2o.utils.typechecks.is_type",
"h2o.download_pojo",
"h2o.utils.typechecks.assert_is_type",
"h2o.H2OFrame",
"h2o.assign",
"h2o.automl.get_leaderboard"
] | [((9792, 9836), 'h2o.utils.typechecks.assert_is_type', 'assert_is_type', (['extensions', 'None', 'str', '[str]'], {}), '(extensions, None, str, [str])\n', (9806, 9836), False, 'from h2o.utils.typechecks import assert_is_type, is_type\n'), ((1841, 1932), 'h2o.download_pojo', 'h2o.download_pojo', (['self.leader', 'path']... |
# coding: utf-8
from pymongo import MongoClient
import conf
class MongoQuery(object):
def __init__(self):
self._conn = MongoClient(conf.mongodb_conn_str)
self._db = self._conn.geokb
def query(self, grounded, limit=15, sort_keys=None):
col = self._db[grounded['from']]
docs = co... | [
"pymongo.MongoClient"
] | [((133, 167), 'pymongo.MongoClient', 'MongoClient', (['conf.mongodb_conn_str'], {}), '(conf.mongodb_conn_str)\n', (144, 167), False, 'from pymongo import MongoClient\n')] |
#
# Copyright (C) 2014 Dell, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in wri... | [
"logging.getLogger",
"os.path.exists",
"dcm.agent.logger.log_to_dcm_console_configuration_management_error",
"dcm.agent.plugins.api.exceptions.AgentPluginParameterBadValueException",
"dcm.agent.logger.log_to_dcm_console_configuration_management_output",
"dcm.agent.plugins.api.base.PluginReply",
"json.du... | [((948, 975), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (965, 975), False, 'import logging\n'), ((3059, 3096), 'os.path.join', 'os.path.join', (['chef_dir', '"""runList.cfg"""'], {}), "(chef_dir, 'runList.cfg')\n", (3071, 3096), False, 'import os\n'), ((4736, 4767), 'configparser.Saf... |
from toolz import get
PLOT_VALIDATORS = [
(
{"line", "scatter", "bar"},
lambda x: ("x" not in x) or ("y" not in x),
"XY plot does not have X and Y.",
),
(
{"histogram"},
lambda x: ("step" in x) and ("bins" in x),
"Histogram cannot have STEP and BINS.",
),... | [
"toolz.get"
] | [((1666, 1683), 'toolz.get', 'get', (['"""step"""', 'x', '(1)'], {}), "('step', x, 1)\n", (1669, 1683), False, 'from toolz import get\n'), ((1787, 1804), 'toolz.get', 'get', (['"""bins"""', 'x', '(1)'], {}), "('bins', x, 1)\n", (1790, 1804), False, 'from toolz import get\n'), ((551, 566), 'toolz.get', 'get', (['"""x"""... |
from hoyolab import main
from os import environ
from os.path import exists
import atoma
def init_environ(d):
environ['HOYOLAB_JSON_PATH'] = '{}/hoyolab.json'.format(d)
environ['HOYOLAB_ATOM_PATH'] = '{}/hoyolab.xml'.format(d)
environ['HOYOLAB_JSON_URL'] = 'hoyolab.json'
environ['HOYOLAB_ATOM_URL'] = '... | [
"os.path.exists",
"atoma.parse_json_feed_file",
"hoyolab.main",
"atoma.parse_atom_file"
] | [((571, 577), 'hoyolab.main', 'main', ([], {}), '()\n', (575, 577), False, 'from hoyolab import main\n'), ((590, 607), 'os.path.exists', 'exists', (['json_path'], {}), '(json_path)\n', (596, 607), False, 'from os.path import exists\n'), ((619, 636), 'os.path.exists', 'exists', (['atom_path'], {}), '(atom_path)\n', (625... |
from django.urls import path
from . import views as sg
urlpatterns = [
path('artist', sg.artist),
path('genre', sg.genre),
path('release', sg.release),
path('track', sg.track),
path('', sg.sausage_grinder_index),
]
| [
"django.urls.path"
] | [((77, 102), 'django.urls.path', 'path', (['"""artist"""', 'sg.artist'], {}), "('artist', sg.artist)\n", (81, 102), False, 'from django.urls import path\n'), ((108, 131), 'django.urls.path', 'path', (['"""genre"""', 'sg.genre'], {}), "('genre', sg.genre)\n", (112, 131), False, 'from django.urls import path\n'), ((137, ... |
from FitnessPlot import FitnessPlot
'''
for n in range(1,6):
plot = FitnessPlot(folder_prefix='data_top{}'.format(n))
plot.plot_all_workers()
plot.plot_workers_as_average()
'''
plot = FitnessPlot(folder_prefix='data_top1', num_workers=16)
worker_dict = plot.create_worker_dict()
#plot.plot_all_workers()
#... | [
"FitnessPlot.FitnessPlot"
] | [((199, 253), 'FitnessPlot.FitnessPlot', 'FitnessPlot', ([], {'folder_prefix': '"""data_top1"""', 'num_workers': '(16)'}), "(folder_prefix='data_top1', num_workers=16)\n", (210, 253), False, 'from FitnessPlot import FitnessPlot\n')] |
import logging
def setup_logger():
formatter = logging.Formatter('%(asctime)s.%(msecs)03d %(levelname)s %(message)s',
'%Y-%m-%d %H:%M:%S')
logging.basicConfig(level=logging.INFO,
format='%(asctime)s.%(msecs)03d %(levelname)-8s %(message)s',
... | [
"logging.basicConfig",
"logging.Formatter",
"logging.getLogger"
] | [((54, 149), 'logging.Formatter', 'logging.Formatter', (['"""%(asctime)s.%(msecs)03d %(levelname)s %(message)s"""', '"""%Y-%m-%d %H:%M:%S"""'], {}), "('%(asctime)s.%(msecs)03d %(levelname)s %(message)s',\n '%Y-%m-%d %H:%M:%S')\n", (71, 149), False, 'import logging\n'), ((184, 324), 'logging.basicConfig', 'logging.ba... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""ThreeScale Proxies Rule interface for APIs."""
from .base import ThreeScale
import logging
import requests
import xmltodict
import json
logger = logging.getLogger(__name__)
class Proxies(ThreeScale):
"""ThreeScale Proxies create, update."""
response = None... | [
"logging.getLogger",
"requests.post",
"xmltodict.parse",
"requests.patch",
"json.dumps",
"requests.get",
"requests.put"
] | [((198, 225), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (215, 225), False, 'import logging\n'), ((2457, 2496), 'requests.patch', 'requests.patch', (['_url'], {'data': 'request_body'}), '(_url, data=request_body)\n', (2471, 2496), False, 'import requests\n'), ((3491, 3524), 'requests.... |
# Created with tutorials:
# https://www.digitalocean.com/community/tutorials/how-to-structure-large-flask-applications
# http://flask.pocoo.org/docs/0.12/tutorial
from flask import Flask, g, render_template
from flask_sqlalchemy import SQLAlchemy
import sqlite3
# Define WSGI application object.
app = Flask(__name__... | [
"flask.render_template",
"flask_sqlalchemy.SQLAlchemy",
"flask.Flask"
] | [((306, 321), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (311, 321), False, 'from flask import Flask, g, render_template\n'), ((451, 466), 'flask_sqlalchemy.SQLAlchemy', 'SQLAlchemy', (['app'], {}), '(app)\n', (461, 466), False, 'from flask_sqlalchemy import SQLAlchemy\n'), ((524, 551), 'flask.render_t... |
# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from . import ... | [
"pulumi.get",
"pulumi.getter",
"pulumi.set",
"pulumi.InvokeOptions",
"pulumi.runtime.invoke"
] | [((1788, 1817), 'pulumi.getter', 'pulumi.getter', ([], {'name': '"""isLocal"""'}), "(name='isLocal')\n", (1801, 1817), False, 'import pulumi\n'), ((1914, 1945), 'pulumi.getter', 'pulumi.getter', ([], {'name': '"""loginName"""'}), "(name='loginName')\n", (1927, 1945), False, 'import pulumi\n'), ((766, 802), 'pulumi.set'... |
import logging
import os
import tensorflow as tf
from punc_recover.models.punc_transformer import PuncTransformer
from punc_recover.tester.base_tester import BaseTester
from utils.text_featurizers import TextFeaturizer
class PuncTester(BaseTester):
""" Trainer for CTC Models """
def __init__(self,
... | [
"utils.text_featurizers.TextFeaturizer",
"os.listdir",
"tensorflow.equal",
"tensorflow.reduce_sum",
"tensorflow.keras.metrics.Mean",
"os.path.join",
"tensorflow.keras.metrics.sparse_categorical_accuracy",
"tensorflow.math.equal",
"tensorflow.reduce_mean",
"punc_recover.models.punc_transformer.Punc... | [((507, 543), 'utils.text_featurizers.TextFeaturizer', 'TextFeaturizer', (["config['punc_vocab']"], {}), "(config['punc_vocab'])\n", (521, 543), False, 'from utils.text_featurizers import TextFeaturizer\n'), ((573, 612), 'utils.text_featurizers.TextFeaturizer', 'TextFeaturizer', (["config['punc_biaodian']"], {}), "(con... |
# encoding: utf-8
import datetime
from south.db import db
from south.v2 import SchemaMigration
from django.db import models
class Migration(SchemaMigration):
def forwards(self, orm):
# Adding field 'ProductVersion.cc_version'
db.add_column('core_productversion', 'cc_version', self.gf('django.db.... | [
"south.db.db.delete_column"
] | [((652, 705), 'south.db.db.delete_column', 'db.delete_column', (['"""core_productversion"""', '"""cc_version"""'], {}), "('core_productversion', 'cc_version')\n", (668, 705), False, 'from south.db import db\n'), ((761, 807), 'south.db.db.delete_column', 'db.delete_column', (['"""core_product"""', '"""cc_version"""'], {... |
import matplotlib.pyplot as pl
import os
import numpy as np
from ticle.data.dataHandler import normalizeData,load_file
from ticle.analysis.analysis import get_phases,normalize_phase
pl.rc('xtick', labelsize='x-small')
pl.rc('ytick', labelsize='x-small')
pl.rc('font', family='serif')
pl.rcParams.update({'font.size': 2... | [
"os.makedirs",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.plot",
"ticle.data.dataHandler.load_file",
"os.getcwd",
"ticle.data.dataHandler.normalizeData",
"matplotlib.pyplot.rcParams.update",
"matplotlib.pyplot.figure",
"ticle.analysis.analysis.get_phases",
"numpy.... | [((184, 219), 'matplotlib.pyplot.rc', 'pl.rc', (['"""xtick"""'], {'labelsize': '"""x-small"""'}), "('xtick', labelsize='x-small')\n", (189, 219), True, 'import matplotlib.pyplot as pl\n'), ((220, 255), 'matplotlib.pyplot.rc', 'pl.rc', (['"""ytick"""'], {'labelsize': '"""x-small"""'}), "('ytick', labelsize='x-small')\n"... |
#!/usr/bin/python
import shlex
import simplejson
from putil.rabbitmq.rabbitmqadmin import Management, make_parser, LISTABLE, DELETABLE
class RabbitManagementUtil(object):
def __init__(self, config, options=None, sysname=None):
"""
Given a config object (system CFG or rabbit mgmt config), extra... | [
"shlex.split",
"putil.rabbitmq.rabbitmqadmin.make_parser",
"simplejson.loads",
"putil.rabbitmq.rabbitmqadmin.Management"
] | [((773, 786), 'putil.rabbitmq.rabbitmqadmin.make_parser', 'make_parser', ([], {}), '()\n', (784, 786), False, 'from putil.rabbitmq.rabbitmqadmin import Management, make_parser, LISTABLE, DELETABLE\n'), ((4489, 4518), 'putil.rabbitmq.rabbitmqadmin.Management', 'Management', (['options', 'args[1:]'], {}), '(options, args... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
ExchangeConnector fixEngine
Copyright (c) 2020 <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 lim... | [
"configparser.SafeConfigParser",
"asyncio.open_connection",
"connectionHandler.FIXConnectionHandler.__init__"
] | [((1479, 1555), 'connectionHandler.FIXConnectionHandler.__init__', 'FIXConnectionHandler.__init__', (['self', 'config', 'reader', 'writer', 'messageListener'], {}), '(self, config, reader, writer, messageListener)\n', (1508, 1555), False, 'from connectionHandler import FIXConnectionHandler, SocketConnectionState\n'), (... |
from jadi import component
from aj.api.http import url, HttpPlugin
from aj.auth import authorize
from aj.api.endpoint import endpoint, EndpointError
import aj
import gevent
@component(HttpPlugin)
class Handler(HttpPlugin):
def __init__(self, context):
self.context = context
@url(r'/api/session_list/l... | [
"gevent.sleep",
"aj.api.http.url",
"jadi.component",
"aj.api.endpoint.endpoint"
] | [((176, 197), 'jadi.component', 'component', (['HttpPlugin'], {}), '(HttpPlugin)\n', (185, 197), False, 'from jadi import component\n'), ((295, 324), 'aj.api.http.url', 'url', (['"""/api/session_list/list"""'], {}), "('/api/session_list/list')\n", (298, 324), False, 'from aj.api.http import url, HttpPlugin\n'), ((331, ... |
import pandas as pd
import os
#opt = itertools.islice(ls, len(ls))
#st = map(lambda x : )
def parsecode(txt):
df = pd.read_csv(os.getcwd() + '\\OMDB.csv')
ls = df['Code'].to_list()
code = []
q = 0
for i in range(len(ls)):
text = txt
if ls[i] in text:
n = text.find(ls[... | [
"pandas.read",
"os.getcwd"
] | [((135, 146), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (144, 146), False, 'import os\n'), ((1379, 1401), 'pandas.read', 'pd.read', (['qry'], {'con': 'conn'}), '(qry, con=conn)\n', (1386, 1401), True, 'import pandas as pd\n')] |
import socket
import unittest
from eats.webdriver import PytractorWebDriver
from eats.tests.common import SimpleWebServerProcess as SimpleServer
def _get_local_ip_addr():
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(("gmail.com",80))
local_ip_addr = s.getsockname()[0]
s.close()
re... | [
"eats.tests.common.SimpleWebServerProcess",
"socket.socket"
] | [((180, 228), 'socket.socket', 'socket.socket', (['socket.AF_INET', 'socket.SOCK_DGRAM'], {}), '(socket.AF_INET, socket.SOCK_DGRAM)\n', (193, 228), False, 'import socket\n'), ((454, 468), 'eats.tests.common.SimpleWebServerProcess', 'SimpleServer', ([], {}), '()\n', (466, 468), True, 'from eats.tests.common import Simpl... |