code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
C APDCAM10G Firmware test
reated on Mon Jul 2 15:46:13 2018
@author: apdcam
"""
def firmware_test(card=8) :
import APDCAM10G_control
c = APDCAM10G_control.APDCAM10G_regCom()
ret = c.startReceiveAnswer()
if ret != "" :
print("Could... | [
"APDCAM10G_control.APDCAM10G_regCom",
"APDCAM10G_control.APDCAM10G_data"
] | [((205, 241), 'APDCAM10G_control.APDCAM10G_regCom', 'APDCAM10G_control.APDCAM10G_regCom', ([], {}), '()\n', (239, 241), False, 'import APDCAM10G_control\n'), ((828, 862), 'APDCAM10G_control.APDCAM10G_data', 'APDCAM10G_control.APDCAM10G_data', ([], {}), '()\n', (860, 862), False, 'import APDCAM10G_control\n')] |
import numpy as np
from scipy.stats import norm
def make_grid(xx, yy):
"""
Returns two n-by-n matrices. The first one contains all the x values
and the second all the y values of a cartesian product between `xx` and `yy`.
"""
n = len(xx)
xx, yy = np.meshgrid(xx, yy)
grid = np.array([xx.r... | [
"numpy.meshgrid",
"numpy.log",
"scipy.stats.norm.pdf",
"numpy.sum"
] | [((275, 294), 'numpy.meshgrid', 'np.meshgrid', (['xx', 'yy'], {}), '(xx, yy)\n', (286, 294), True, 'import numpy as np\n'), ((673, 747), 'scipy.stats.norm.pdf', 'norm.pdf', (['yy[:, None, None]'], {'loc': 'mus[None, :, :]', 'scale': 'sigmas[None, :, :]'}), '(yy[:, None, None], loc=mus[None, :, :], scale=sigmas[None, :,... |
# -*- coding: utf-8 -*-
import importlib
from django.db.models.signals import post_save, post_delete
from jsonmirror.conf import BACKEND
if BACKEND == "rethinkdb":
from jsonmirror.backends.rethinkdb.signals import model_save, model_delete
def register_model(model):
post_save.connect(model_save, sende... | [
"django.db.models.signals.post_save.connect",
"importlib.import_module",
"django.db.models.signals.post_delete.connect"
] | [((285, 328), 'django.db.models.signals.post_save.connect', 'post_save.connect', (['model_save'], {'sender': 'model'}), '(model_save, sender=model)\n', (302, 328), False, 'from django.db.models.signals import post_save, post_delete\n'), ((333, 380), 'django.db.models.signals.post_delete.connect', 'post_delete.connect',... |
import sys
import os
import random
import socket
import string
import time
def connect( ip, port ):
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
s.connect( (ip, port) )
except:
print('Failed to connect to %s:%d' %(ip, port))
sys.exit(1)
return s
def readuntil( s... | [
"random.choice",
"socket.socket",
"time.sleep",
"random.seed",
"sys.exit",
"socket.gethostname",
"random.randint"
] | [((109, 158), 'socket.socket', 'socket.socket', (['socket.AF_INET', 'socket.SOCK_STREAM'], {}), '(socket.AF_INET, socket.SOCK_STREAM)\n', (122, 158), False, 'import socket\n'), ((28262, 28277), 'time.sleep', 'time.sleep', (['(0.3)'], {}), '(0.3)\n', (28272, 28277), False, 'import time\n'), ((30493, 30503), 'sys.exit', ... |
import torch
from torch import nn
from torch.autograd import Variable
class CovaMLoss(nn.Module):
def __init__(self):
super(CovaMLoss, self).__init__()
# self.ranking_loss = nn.MarginRankingLoss(margin=margin)
# calculate the similarity
def cal_similarity(self, input, CovaMatrix_list):
... | [
"torch.norm",
"torch.cuda.is_available",
"torch.cat",
"torch.transpose"
] | [((990, 1012), 'torch.cat', 'torch.cat', (['Cova_Sim', '(0)'], {}), '(Cova_Sim, 0)\n', (999, 1012), False, 'import torch\n'), ((513, 546), 'torch.norm', 'torch.norm', (['query_sam', '(2)', '(1)', '(True)'], {}), '(query_sam, 2, 1, True)\n', (523, 546), False, 'import torch\n'), ((616, 641), 'torch.cuda.is_available', '... |
from logging import getLogger
from calendar import monthrange
from collections import OrderedDict
from datetime import date
from datetime import datetime
from dateutil.parser import parse
import ckan.plugins as p
import ckan.logic as logic
from ckan.logic.action.create import user_create as ckan_user_create
import cka... | [
"logging.getLogger",
"ckanext.scheming.helpers.scheming_field_choices",
"ckan.lib.helpers.redirect_to",
"ckan.common._",
"ckanext.scheming.helpers.scheming_get_dataset_schema",
"calendar.monthrange",
"ckan.plugins.toolkit.add_template_directory",
"datetime.datetime",
"ckan.plugins.toolkit.get_action... | [((790, 809), 'logging.getLogger', 'getLogger', (['__name__'], {}), '(__name__)\n', (799, 809), False, 'from logging import getLogger\n'), ((915, 943), 'ckan.plugins.implements', 'p.implements', (['p.ITranslation'], {}), '(p.ITranslation)\n', (927, 943), True, 'import ckan.plugins as p\n'), ((1095, 1123), 'ckan.plugins... |
# standard library imports
import os
# local application imports
from atoms import Atom
from exceptions import XYZfileDidNotExist
from exceptions import XYZfileWrongFormat
def xyz_file_to_atoms(filename):
"""
From an .xyz file get a list of atoms
Arguments:
filename (str): .xyz fil... | [
"atoms.Atom",
"os.path.exists"
] | [((425, 449), 'os.path.exists', 'os.path.exists', (['filename'], {}), '(filename)\n', (439, 449), False, 'import os\n'), ((1144, 1189), 'atoms.Atom', 'Atom', ([], {'atomic_symbol': 'atom_label', 'x': 'x', 'y': 'y', 'z': 'z'}), '(atomic_symbol=atom_label, x=x, y=y, z=z)\n', (1148, 1189), False, 'from atoms import Atom\n... |
#import torch.nn as nn
import torch
from torch.nn import functional as F
#from PIL import Image
import numpy as np
import pandas as pd
#import os
import os.path as osp
import shutil
#import math
def save_checkpoint(state,best_pred, epoch,is_best,checkpoint_path,filename='./checkpoint/checkpoint.pth.tar'):
torch.sa... | [
"numpy.histogram",
"torch.max",
"numpy.asarray",
"torch.sigmoid",
"numpy.equal",
"numpy.stack",
"numpy.sum",
"numpy.array",
"torch.save",
"numpy.all",
"torch.argmax"
] | [((312, 339), 'torch.save', 'torch.save', (['state', 'filename'], {}), '(state, filename)\n', (322, 339), False, 'import torch\n'), ((1371, 1402), 'numpy.stack', 'np.stack', (['semantic_map'], {'axis': '(-1)'}), '(semantic_map, axis=-1)\n', (1379, 1402), True, 'import numpy as np\n'), ((4205, 4223), 'numpy.sum', 'np.su... |
# -*- coding: utf-8 -*-
# Copyright 2020 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or... | [
"proto.RepeatedField",
"proto.Field",
"proto.module",
"proto.MapField"
] | [((941, 1280), 'proto.module', 'proto.module', ([], {'package': '"""google.cloud.datalabeling.v1beta1"""', 'manifest': "{'DataType', 'Dataset', 'InputConfig', 'TextMetadata',\n 'ClassificationMetadata', 'GcsSource', 'BigQuerySource', 'OutputConfig',\n 'GcsDestination', 'GcsFolderDestination', 'DataItem',\n 'An... |
import json
import math
import multiprocessing
import os
import tempfile
from pathlib import Path
import gym
import numpy as np
import pandas as pd
from ray import tune
from ray.rllib.models import ModelCatalog
from ray.rllib.utils import try_import_tf
from examples.rllib_agent import TrainingModel
from smarts.core.a... | [
"tempfile.TemporaryDirectory",
"smarts.core.agent_interface.AgentInterface.from_type",
"json.loads",
"smarts.env.custom_observations.lane_ttc_observation_adapter.transform",
"pathlib.Path",
"ray.rllib.models.ModelCatalog.get_preprocessor_for_space",
"os.path.join",
"math.sqrt",
"pandas.DataFrame.fro... | [((562, 577), 'ray.rllib.utils.try_import_tf', 'try_import_tf', ([], {}), '()\n', (575, 577), False, 'from ray.rllib.utils import try_import_tf\n'), ((1718, 1773), 'smarts.env.custom_observations.lane_ttc_observation_adapter.transform', 'lane_ttc_observation_adapter.transform', (['env_observation'], {}), '(env_observat... |
"""
MIT License
Copyright (c) 2017 s0hvaperuna
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, d... | [
"logging.getLogger",
"utils.utilities.get_image",
"bot.bot.command",
"PIL.Image.new",
"bot.bot.bot_has_permissions",
"io.BytesIO",
"sys.exc_info",
"utils.imagetools.create_shadow",
"numpy.sin",
"utils.imagetools.get_color",
"collections.OrderedDict.fromkeys",
"utils.utilities.get_picture_from_... | [((2206, 2235), 'logging.getLogger', 'logging.getLogger', (['"""terminal"""'], {}), "('terminal')\n", (2223, 2235), False, 'import logging\n'), ((8207, 8233), 'bot.bot.command', 'command', ([], {'aliases': "['stand']"}), "(aliases=['stand'])\n", (8214, 8233), False, 'from bot.bot import command, cooldown, bot_has_permi... |
from django.contrib import admin
from enrollment.enrollment.models import (
StudentEnrollment,
CourseGroup,
Schedule,
)
@admin.register(CourseGroup)
class CourseGroupAdmin(admin.ModelAdmin):
list_display = ['course', 'name', 'teacher', 'year', 'semester']
search_fields = ['course', 'name', 'teach... | [
"django.contrib.admin.register"
] | [((136, 163), 'django.contrib.admin.register', 'admin.register', (['CourseGroup'], {}), '(CourseGroup)\n', (150, 163), False, 'from django.contrib import admin\n'), ((328, 361), 'django.contrib.admin.register', 'admin.register', (['StudentEnrollment'], {}), '(StudentEnrollment)\n', (342, 361), False, 'from django.contr... |
from distutils.core import setup
setup(name = "DWL5500XY",
version = "0",
description = "Python module to use the Digipass DWL5500XY",
author = "<NAME>",
author_email = "<EMAIL>",
url = "https://github.com/Stormholt/DWL5500XY-Python",
packages = ['DWL5500XY'],
scripts = ["test.py"],
... | [
"distutils.core.setup"
] | [((36, 331), 'distutils.core.setup', 'setup', ([], {'name': '"""DWL5500XY"""', 'version': '"""0"""', 'description': '"""Python module to use the Digipass DWL5500XY"""', 'author': '"""<NAME>"""', 'author_email': '"""<EMAIL>"""', 'url': '"""https://github.com/Stormholt/DWL5500XY-Python"""', 'packages': "['DWL5500XY']", '... |
#
# test_siteconfig.py
#
# Tests for site config generation (siteconfig.py).
#
# Copyright (C) 2018-2021 by
# <NAME>.
#
# This file is part of the FreeType project, and may only be used,
# modified, and distributed under the terms of the FreeType project
# license, LICENSE.TXT. By continuing to use, modify, o... | [
"yaml.safe_load",
"docwriter.siteconfig.SiteConfig"
] | [((650, 673), 'docwriter.siteconfig.SiteConfig', 'siteconfig.SiteConfig', ([], {}), '()\n', (671, 673), False, 'from docwriter import siteconfig\n'), ((1749, 1771), 'yaml.safe_load', 'yaml.safe_load', (['result'], {}), '(result)\n', (1763, 1771), False, 'import yaml\n')] |
import unittest
from pywavez.zwave import Message, inboundMessageFromBytes
from pywavez.zwave.Constants import LibraryType
class TestGetVersion(unittest.TestCase):
def test_GetVersionResponse(self):
data = bytes.fromhex("01155a2d5761766520342e30350001")
obj = inboundMessageFromBytes(data)
... | [
"unittest.main",
"pywavez.zwave.inboundMessageFromBytes"
] | [((2482, 2497), 'unittest.main', 'unittest.main', ([], {}), '()\n', (2495, 2497), False, 'import unittest\n'), ((283, 312), 'pywavez.zwave.inboundMessageFromBytes', 'inboundMessageFromBytes', (['data'], {}), '(data)\n', (306, 312), False, 'from pywavez.zwave import Message, inboundMessageFromBytes\n'), ((793, 822), 'py... |
# Generated by Django 3.2.9 on 2021-12-04 16:44
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('pokemon', '0008_auto_20211204_1644'),
('trainers', '0002_teams'),
]
operations = [
migrations.Creat... | [
"django.db.models.CharField",
"django.db.models.BigAutoField",
"django.db.models.ForeignKey"
] | [((400, 496), 'django.db.models.BigAutoField', 'models.BigAutoField', ([], {'auto_created': '(True)', 'primary_key': '(True)', 'serialize': '(False)', 'verbose_name': '"""ID"""'}), "(auto_created=True, primary_key=True, serialize=False,\n verbose_name='ID')\n", (419, 496), False, 'from django.db import migrations, m... |
from Distributions import NormalDistribution
class Guest:
cur_id = 0
work_time_distribution = NormalDistribution(10, 1)
def __init__(self, guest_type):
self.id = Guest.cur_id
self.type = guest_type
self.eating = False
self.finished = False
self.time_to_finish = 0
... | [
"Distributions.NormalDistribution"
] | [((104, 129), 'Distributions.NormalDistribution', 'NormalDistribution', (['(10)', '(1)'], {}), '(10, 1)\n', (122, 129), False, 'from Distributions import NormalDistribution\n')] |
#!/usr/bin/python
import sys
import os
import ctypes
import threading
import socket
import time
from PySide2.QtCore import *
from PySide2.QtGui import *
from PySide2.QtWidgets import QWidget, QTextEdit, QTabWidget, QFormLayout
class UpdateSig(QObject):
sig = Signal(float)
class LoggerWidget(QWidget):
def __... | [
"PySide2.QtWidgets.QFormLayout",
"PySide2.QtWidgets.QTabWidget",
"PySide2.QtWidgets.QTextEdit"
] | [((423, 434), 'PySide2.QtWidgets.QTextEdit', 'QTextEdit', ([], {}), '()\n', (432, 434), False, 'from PySide2.QtWidgets import QWidget, QTextEdit, QTabWidget, QFormLayout\n'), ((903, 919), 'PySide2.QtWidgets.QTabWidget', 'QTabWidget', (['self'], {}), '(self)\n', (913, 919), False, 'from PySide2.QtWidgets import QWidget,... |
import torch
import torch.nn as nn
import torch.nn.functional as F
class BaseCNNModel(nn.Module):
def __init__(self, num_classes):
super(BaseCNNModel, self).__init__()
self.conv1 = nn.Conv2d(3, 32, 5, 2)
self.conv2 = nn.Conv2d(32, 32, 5, 1)
self.conv3 = nn.Conv2d(32, 64, 5, 1)
... | [
"torch.nn.BatchNorm2d",
"torch.nn.Dropout",
"torch.nn.Conv2d",
"torch.nn.MaxPool2d",
"torch.nn.Linear",
"torch.rand"
] | [((1732, 1760), 'torch.rand', 'torch.rand', (['(1, 3, 256, 256)'], {}), '((1, 3, 256, 256))\n', (1742, 1760), False, 'import torch\n'), ((205, 227), 'torch.nn.Conv2d', 'nn.Conv2d', (['(3)', '(32)', '(5)', '(2)'], {}), '(3, 32, 5, 2)\n', (214, 227), True, 'import torch.nn as nn\n'), ((249, 272), 'torch.nn.Conv2d', 'nn.C... |
"""
Support for Chuang Mi IR Remote Controller.
Thank rytilahti for his great work
"""
import logging
from datetime import timedelta
import asyncio
from random import randint
import voluptuous as vol
from socket import timeout
import homeassistant.loader as loader
from homeassistant.components.switch import (SwitchDe... | [
"logging.getLogger",
"homeassistant.util.dt.utcnow",
"voluptuous.Required",
"voluptuous.Schema",
"homeassistant.loader.get_component",
"datetime.timedelta",
"voluptuous.Length",
"miio.ChuangmiIr",
"asyncio.sleep",
"voluptuous.Optional",
"random.randint"
] | [((784, 811), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (801, 811), False, 'import logging\n'), ((2343, 2390), 'homeassistant.loader.get_component', 'loader.get_component', (['"""persistent_notification"""'], {}), "('persistent_notification')\n", (2363, 2390), True, 'import homeassis... |
# Copyright (C) 2018 Google Inc.
# Licensed under http://www.apache.org/licenses/LICENSE-2.0 <see LICENSE file>
"""This module contains common utils for integration functionality."""
import sqlalchemy as sa
from ggrc import db
from ggrc import settings
from ggrc.models import exceptions
from ggrc.models import all_m... | [
"ggrc.models.all_models.Person.email.in_",
"ggrc.integrations.synchronization_jobs.assessment_sync_job.ASSESSMENT_STATUSES_MAPPING.get",
"ggrc.models.exceptions.ValidationError",
"ggrc.db.session.query",
"sqlalchemy.and_"
] | [((3457, 3502), 'ggrc.integrations.synchronization_jobs.assessment_sync_job.ASSESSMENT_STATUSES_MAPPING.get', 'ASSESSMENT_STATUSES_MAPPING.get', (['assmt.status'], {}), '(assmt.status)\n', (3488, 3502), False, 'from ggrc.integrations.synchronization_jobs.assessment_sync_job import ASSESSMENT_STATUSES_MAPPING\n'), ((131... |
# vim: set ts=4 sw=4 expandtab:
from puremvc.patterns.command import SimpleCommand
from model.TimeProxy import TimeProxy
from view.DialogMediator import DialogMediator
from view.MenuMediator import MenuMediator
from view.DatePickerMediator import DatePickerMediator
from view.TimeGridMediator import TimeGridMediator... | [
"view.SummaryMediator.SummaryMediator",
"model.TimeProxy.TimeProxy",
"view.DialogMediator.DialogMediator",
"view.DatePickerMediator.DatePickerMediator",
"view.MenuMediator.MenuMediator",
"view.TimeGridMediator.TimeGridMediator"
] | [((470, 481), 'model.TimeProxy.TimeProxy', 'TimeProxy', ([], {}), '()\n', (479, 481), False, 'from model.TimeProxy import TimeProxy\n'), ((556, 581), 'view.DialogMediator.DialogMediator', 'DialogMediator', (['mainPanel'], {}), '(mainPanel)\n', (570, 581), False, 'from view.DialogMediator import DialogMediator\n'), ((62... |
# -*- coding: utf-8 -*-
from __future__ import absolute_import, division, print_function
try:
input = raw_input
except NameError:
pass
import re
def promptYesOrNo(message):
while True:
m = re.match(r'(y|yes)|(n|no)', input(message + " "), re.IGNORECASE)
if m is None:
print(... | [
"re.compile"
] | [((568, 614), 're.compile', 're.compile', (['"""(?P<num>\\\\d+)\\\\s*(?P<unit>\\\\w+)*"""'], {}), "('(?P<num>\\\\d+)\\\\s*(?P<unit>\\\\w+)*')\n", (578, 614), False, 'import re\n')] |
from __future__ import division
from __future__ import print_function
from __future__ import absolute_import
from builtins import zip
from builtins import range
from builtins import object
from past.utils import old_div
from nose.tools import (assert_equal, assert_not_equal, assert_almost_equal,
... | [
"logging.getLogger",
"openpathsampling.IdentityPathMover",
"openpathsampling.MSOuterTISInterface.from_lambdas",
"past.utils.old_div",
"openpathsampling.high_level.move_strategy.OrganizeByMoveGroupStrategy",
"nose.tools.assert_equal",
"copy.copy",
"openpathsampling.high_level.move_strategy.OneWayShooti... | [((2423, 2496), 'openpathsampling.RandomChoiceMoveChange', 'paths.RandomChoiceMoveChange', ([], {'subchange': 'group_mover_change', 'mover': 'chooser'}), '(subchange=group_mover_change, mover=chooser)\n', (2451, 2496), True, 'import openpathsampling as paths\n'), ((2543, 2615), 'openpathsampling.RandomChoiceMoveChange'... |
from onegov.core.utils import Bunch
from onegov.core.elements import Link, Confirm, Intercooler
def test_link(render_element):
# text is translated
result = render_element(Link(text="Settings", url='/settings'))
assert result.pyquery('a').text() == "Settings"
assert result.pyquery('a').attr('href') ==... | [
"onegov.core.elements.Intercooler",
"onegov.core.elements.Confirm",
"onegov.core.elements.Link",
"onegov.core.utils.Bunch"
] | [((182, 220), 'onegov.core.elements.Link', 'Link', ([], {'text': '"""Settings"""', 'url': '"""/settings"""'}), "(text='Settings', url='/settings')\n", (186, 220), False, 'from onegov.core.elements import Link, Confirm, Intercooler\n'), ((398, 450), 'onegov.core.elements.Link', 'Link', ([], {'text': '"""foo"""', 'url': ... |
import multiprocessing
num_cores = multiprocessing.cpu_count()
INPUT = './data/scratch/scripts.txt'
BLOCK_LANG = 'data/scratch/tokens.pickle.lang'
RESULTS_DIR = './results'
FIGURES_DIR = './figures'
START_SYMBOL = 'START'
END_SYMBOL = 'END'
WORD2VEC_SIZE = 8
WORD2VEC_MODEL = './results/wv-{}.model'.format(WORD2VEC_SIZ... | [
"multiprocessing.cpu_count"
] | [((36, 63), 'multiprocessing.cpu_count', 'multiprocessing.cpu_count', ([], {}), '()\n', (61, 63), False, 'import multiprocessing\n')] |
import contextlib
import contextvars
import logging
import os
import sys
from typing import Iterator
_logging_prefix: contextvars.ContextVar[str] = contextvars.ContextVar(
"logging_prefix",
default="",
)
@contextlib.contextmanager
def logging_prefix(prefix: str) -> Iterator[str]:
token = _logging_prefix.... | [
"logging.basicConfig",
"logging.StreamHandler",
"os.getenv",
"contextvars.ContextVar",
"logging.root.removeHandler"
] | [((149, 201), 'contextvars.ContextVar', 'contextvars.ContextVar', (['"""logging_prefix"""'], {'default': '""""""'}), "('logging_prefix', default='')\n", (171, 201), False, 'import contextvars\n'), ((644, 672), 'os.getenv', 'os.getenv', (['"""HOSTNAME"""', '"""dev"""'], {}), "('HOSTNAME', 'dev')\n", (653, 672), False, '... |
import json
from web3 import Web3, HTTPProvider
from web3.gas_strategies.rpc import rpc_gas_price_strategy
class ContractInterface(object):
def __init__(self, config):
"""
sets up w3 and the contract
"""
self.config = config
self.provider = HTTPProvider(self.config.PROVIDE... | [
"json.load",
"web3.HTTPProvider",
"web3.Web3.toChecksumAddress",
"web3.Web3"
] | [((288, 326), 'web3.HTTPProvider', 'HTTPProvider', (['self.config.PROVIDER_URI'], {}), '(self.config.PROVIDER_URI)\n', (300, 326), False, 'from web3 import Web3, HTTPProvider\n'), ((345, 364), 'web3.Web3', 'Web3', (['self.provider'], {}), '(self.provider)\n', (349, 364), False, 'from web3 import Web3, HTTPProvider\n'),... |
"""This module handles all operations involving the user's settings."""
import json
from os import path
from PyQt5.QtWidgets import QWidget
from PyQt5.QtCore import QObject, pyqtSignal
from ui import SettingsTab
import ManageDB
from Constants import *
import GeneralUtils
from GeneralUtils import JsonModel
class Sett... | [
"PyQt5.QtCore.pyqtSignal",
"json.loads",
"GeneralUtils.show_message",
"ManageDB.get_all_report_files",
"json.dumps",
"GeneralUtils.save_json_file",
"GeneralUtils.read_json_file",
"ManageDB.get_all_cost_files",
"os.path.abspath",
"GeneralUtils.choose_directory",
"ManageDB.UpdateDatabaseProgressDi... | [((3654, 3679), 'PyQt5.QtCore.pyqtSignal', 'pyqtSignal', (['SettingsModel'], {}), '(SettingsModel)\n', (3664, 3679), False, 'from PyQt5.QtCore import QObject, pyqtSignal\n'), ((3895, 3962), 'GeneralUtils.read_json_file', 'GeneralUtils.read_json_file', (['(SETTINGS_FILE_DIR + SETTINGS_FILE_NAME)'], {}), '(SETTINGS_FILE_... |
"""Entries Table Seeder.
You can run this seeder in order to generate journal entries.
- Each time it is ran it will generate 5 random entries.
- You can run the seeder by running: craft seed:run.
"""
from orator.seeds import Seeder
from app.Entry import Entry
from config.factories import factory
class En... | [
"config.factories.factory"
] | [((444, 462), 'config.factories.factory', 'factory', (['Entry', '(25)'], {}), '(Entry, 25)\n', (451, 462), False, 'from config.factories import factory\n')] |
# Train.py
import numpy as np
import pandas as pandas
from Data import Data
from BuildModel import BuildModel
import copy
import sys
from keras.callbacks import EarlyStopping
class Train():
@staticmethod
def train():
# adam = optimizers.Adam(lr=0.001, beta_1=0.9, beta_2=0.999, epsilon=No... | [
"BuildModel.BuildModel.cnn_base_model",
"keras.callbacks.EarlyStopping"
] | [((367, 394), 'BuildModel.BuildModel.cnn_base_model', 'BuildModel.cnn_base_model', ([], {}), '()\n', (392, 394), False, 'from BuildModel import BuildModel\n'), ((508, 595), 'keras.callbacks.EarlyStopping', 'EarlyStopping', ([], {'monitor': '"""val_loss"""', 'min_delta': '(0)', 'patience': '(2)', 'verbose': '(0)', 'mode... |
def run():
import requests, json
api = 'http://ip-api.com/json/'
ip = input("\n[?] Enter IP or Domain To Lookup: ")
print("[!] Sending Request... [!]")
request = requests.get(api + ip).text
response = json.loads(request)
status = response['status']
if status == "success":
... | [
"json.loads",
"requests.get"
] | [((233, 252), 'json.loads', 'json.loads', (['request'], {}), '(request)\n', (243, 252), False, 'import requests, json\n'), ((189, 211), 'requests.get', 'requests.get', (['(api + ip)'], {}), '(api + ip)\n', (201, 211), False, 'import requests, json\n')] |
import os
import subprocess
from datetime import date
from mne import __version__ as release_version
# NOTE: ../codemeta.json and ../citation.cff should not be continuously
# updated. Run this script only at release time.
package_name = 'MNE-Python'
hard_dependencies = ('numpy', 'scipy')
release_date = str(dat... | [
"datetime.date.today",
"subprocess.run",
"os.path.join",
"mne.__version__.split"
] | [((2326, 2378), 'subprocess.run', 'subprocess.run', (['args'], {'capture_output': '(True)', 'text': '(True)'}), '(args, capture_output=True, text=True)\n', (2340, 2378), False, 'import subprocess\n'), ((317, 329), 'datetime.date.today', 'date.today', ([], {}), '()\n', (327, 329), False, 'from datetime import date\n'), ... |
#!/usr/bin/env python
import rospy
from flexbe_core import EventState, Logger
from rospy.exceptions import ROSInterruptException
'''
Created on 11.06.2013
@author: <NAME>
'''
class MyDecisionState(EventState):
'''
Evaluates a condition function in order to return one of the specified outcomes.
This state can be ... | [
"rospy.sleep",
"rospy.logwarn"
] | [((1396, 1412), 'rospy.sleep', 'rospy.sleep', (['(0.2)'], {}), '(0.2)\n', (1407, 1412), False, 'import rospy\n'), ((1486, 1517), 'rospy.logwarn', 'rospy.logwarn', (['"""Skipped sleep."""'], {}), "('Skipped sleep.')\n", (1499, 1517), False, 'import rospy\n')] |
import glob
import os
import re
all_files = glob.glob("*pdf")
for file in all_files:
if "label" in file:
new_file = re.sub("label", "delivery", file)
os.system(f'mv {file} {new_file}')
if "Ausfahrliste.pdf" in file:
new_file = re.sub("Ausfahrliste.pdf", "ausfahrliste_delivery_file.pdf",... | [
"re.sub",
"os.system",
"glob.glob"
] | [((44, 61), 'glob.glob', 'glob.glob', (['"""*pdf"""'], {}), "('*pdf')\n", (53, 61), False, 'import glob\n'), ((128, 161), 're.sub', 're.sub', (['"""label"""', '"""delivery"""', 'file'], {}), "('label', 'delivery', file)\n", (134, 161), False, 'import re\n'), ((170, 204), 'os.system', 'os.system', (['f"""mv {file} {new_... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
"""
Created on Sun Jun 25 10:44:24 2017
@author: wroscoe
"""
import time
from threading import Thread
import socket
from donkeycar.parts.controller import JoystickController, PS3JoystickController, PS3Joystick
class Vehicle():
def __init__(self, mem=None):
... | [
"socket.socket",
"time.sleep",
"donkeycar.parts.controller.PS3Joystick",
"threading.Thread",
"time.time"
] | [((7750, 7784), 'threading.Thread', 'Thread', ([], {'target': 'ctr.update', 'args': '()'}), '(target=ctr.update, args=())\n', (7756, 7784), False, 'from threading import Thread\n'), ((4757, 4806), 'socket.socket', 'socket.socket', (['socket.AF_INET', 'socket.SOCK_STREAM'], {}), '(socket.AF_INET, socket.SOCK_STREAM)\n',... |
# _________________________________________________________________________
#
# PyUtilib: A Python utility library.
# Copyright (c) 2008 Sandia Corporation.
# This software is distributed under the BSD License.
# Under the terms of Contract DE-AC04-94AL85000 with Sandia Corporation,
# the U.S. Government retains ... | [
"pyutilib.pyro.util.set_maxconnections",
"socket.gethostname",
"Pyro.nsc.main",
"Pyro.naming.main"
] | [((641, 708), 'pyutilib.pyro.util.set_maxconnections', 'set_maxconnections', ([], {'max_allowed_connections': 'max_allowed_connections'}), '(max_allowed_connections=max_allowed_connections)\n', (659, 708), False, 'from pyutilib.pyro.util import set_maxconnections, Pyro, using_pyro4\n'), ((1061, 1083), 'Pyro.naming.main... |
# -*- coding:utf-8 -*-
"""
桌面截图
"""
from PIL import Image
import win32gui, win32ui, win32con, win32api
class CaptureDesktop(object):
""" 桌面截图 """
SM_XVIRTUALSCREEN = 76
SM_YVIRTUALSCREEN = 77
SM_CXVIRTUALSCREEN = 78
SM_CYVIRTUALSCREEN = 79
def __init__(self):
super(CaptureDesktop,... | [
"win32gui.GetWindowDC",
"win32gui.GetDesktopWindow",
"win32api.GetSystemMetrics",
"win32ui.CreateDCFromHandle",
"win32ui.CreateBitmap"
] | [((517, 544), 'win32gui.GetDesktopWindow', 'win32gui.GetDesktopWindow', ([], {}), '()\n', (542, 544), False, 'import win32gui, win32ui, win32con, win32api\n'), ((568, 600), 'win32gui.GetWindowDC', 'win32gui.GetWindowDC', (['self.mHwnd'], {}), '(self.mHwnd)\n', (588, 600), False, 'import win32gui, win32ui, win32con, win... |
# -*- coding: utf-8 -*-
"""
Created on Sun Jul 30 09:08:26 2017
@author: hp
"""
'''
SeriousDlqin2yrsY/N超过90天或更糟的逾期拖欠
RevolvingUtilizationOfUnsecuredLines
无担保放款的循环利用：除了不动产和像车贷那样除以信用额度总和的无分期付款债务的信用卡和个人信用额度总额
NumberOfTime30-59DaysPastDueNotWorse35-59天逾期但不糟糕次数
DebtRatio负债比率
NumberOfOpenCreditLinesAndLoans
开放式信贷和贷款数量，开放式贷款... | [
"pandas.read_csv",
"matplotlib.pyplot.ylabel",
"sklearn.metrics.auc",
"numpy.log",
"sklearn.metrics.roc_auc_score",
"sklearn.metrics.roc_curve",
"numpy.arange",
"numpy.mean",
"scipy.interp",
"pandas.qcut",
"sklearn.cross_validation.cross_val_score",
"matplotlib.pyplot.xlabel",
"matplotlib.py... | [((1955, 1988), 'pandas.read_csv', 'pd.read_csv', (['"""...cs-training.csv"""'], {}), "('...cs-training.csv')\n", (1966, 1988), True, 'import pandas as pd\n'), ((1999, 2028), 'pandas.read_csv', 'pd.read_csv', (['"""...cs-test.csv"""'], {}), "('...cs-test.csv')\n", (2010, 2028), True, 'import pandas as pd\n'), ((2094, 2... |
from argparse import ArgumentParser
import dmsbatch
from dmsbatch import __version__
from dmsbatch import commands
def config_generate_cmd(args):
if not args.file:
print('Specify config file!')
return
print('Generating blank config: ', args.file)
commands.generate_blank_config(args.file)
... | [
"dmsbatch.commands.generate_blank_config",
"argparse.ArgumentParser"
] | [((277, 318), 'dmsbatch.commands.generate_blank_config', 'commands.generate_blank_config', (['args.file'], {}), '(args.file)\n', (307, 318), False, 'from dmsbatch import commands\n'), ((348, 449), 'argparse.ArgumentParser', 'ArgumentParser', ([], {'description': '"""Azure Batch for Delta Modeling Section """', 'conflic... |
# Copyright Contributors to the Pyro project.
# SPDX-License-Identifier: Apache-2.0
from contextlib import ExitStack
import pyro.distributions as dist
from pyro import poutine
from pyro.infer.autoguide.guides import AutoStructured
from pyro.poutine.plate_messenger import block_plate
from .reparam import Reparam
cl... | [
"pyro.poutine.reparam",
"pyro.poutine.get_mask",
"pyro.poutine.condition",
"pyro.poutine.mask",
"pyro.poutine.plate_messenger.block_plate",
"contextlib.ExitStack",
"pyro.distributions.Delta"
] | [((2200, 2248), 'pyro.poutine.reparam', 'poutine.reparam', (['fn'], {'config': 'self._reparam_config'}), '(fn, config=self._reparam_config)\n', (2215, 2248), False, 'from pyro import poutine\n'), ((3100, 3118), 'pyro.poutine.get_mask', 'poutine.get_mask', ([], {}), '()\n', (3116, 3118), False, 'from pyro import poutine... |
import cdd
import numpy as np
class Cone_on_Plane(object):
"""Attributes:
Quadratic_Form (list of lists, 2x2 matrix): The quadratic form of the cone.
Linear_Form (list, 2x1 vector): The linear form of the matrix.
"""
def __init__(self, a, b, plane_flag):
self.Quadratic_Form = [[-2*n... | [
"numpy.cos",
"numpy.sin",
"numpy.shape",
"cdd.Polyhedron",
"cdd.Matrix"
] | [((1886, 1931), 'cdd.Matrix', 'cdd.Matrix', (['cdd_vertices'], {'number_type': '"""float"""'}), "(cdd_vertices, number_type='float')\n", (1896, 1931), False, 'import cdd\n'), ((1983, 2002), 'cdd.Polyhedron', 'cdd.Polyhedron', (['mat'], {}), '(mat)\n', (1997, 2002), False, 'import cdd\n'), ((2791, 2836), 'cdd.Matrix', '... |
"""
create_model_input.py
Create Model input objects for use in tests.
"""
import os
import seekr2.modules.common_base as base
import seekr2.modules.common_prepare as common_prepare
import seekr2.modules.common_cv as common_cv
import seekr2.modules.filetree as filetree
import seekr2.modules.check as check
# Don't r... | [
"seekr2.prepare.prepare",
"seekr2.modules.common_base.Amber_params",
"seekr2.modules.common_cv.Spherical_cv_input",
"os.path.exists",
"seekr2.modules.common_cv.RMSD_cv_input",
"seekr2.modules.common_prepare.Model_input",
"seekr2.modules.common_prepare.MMVT_input_settings",
"seekr2.modules.common_prepa... | [((433, 458), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (448, 458), False, 'import os\n'), ((477, 510), 'os.path.dirname', 'os.path.dirname', (['prepare.__file__'], {}), '(prepare.__file__)\n', (492, 510), False, 'import os\n'), ((623, 642), 'seekr2.modules.common_base.Amber_params', 'ba... |
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import torch
from fairseq import utils
from fairseq.data import LanguagePairDataset, TransformEosLangPairDataset
from . import register_task
... | [
"logging.getLogger",
"fairseq.utils.split_paths",
"fairseq.data.LanguagePairDataset",
"torch.no_grad",
"fairseq_cli.generate.get_symbols_to_strip_from_output",
"sacrebleu.corpus_bleu"
] | [((633, 660), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (650, 660), False, 'import logging\n'), ((2816, 2849), 'fairseq.utils.split_paths', 'utils.split_paths', (['self.args.data'], {}), '(self.args.data)\n', (2833, 2849), False, 'from fairseq import utils\n'), ((6135, 6268), 'fairse... |
## This script will grab population and language data from Census Bureau ACS API and output to Geodatabase of user's choice. Designed as a ArcGIS script tool.
## Developed by <NAME> for Wisconsin Emergency Management Sept 2017
#import modules
try:
import sys, urllib2, json, string, csv, arcpy, os, socket
... | [
"string.join",
"arcpy.GetSystemEnvironment",
"arcpy.AddField_management",
"arcpy.da.SearchCursor",
"arcpy.CopyRows_management",
"arcpy.ListFields",
"sys.exit",
"arcpy.Delete_management",
"socket.setdefaulttimeout",
"arcpy.da.UpdateCursor",
"arcpy.CopyFeatures_management",
"urllib2.urlopen",
... | [((6115, 6148), 'socket.setdefaulttimeout', 'socket.setdefaulttimeout', (['timeout'], {}), '(timeout)\n', (6139, 6148), False, 'import sys, urllib2, json, string, csv, arcpy, os, socket\n'), ((6221, 6248), 'arcpy.GetParameterAsText', 'arcpy.GetParameterAsText', (['(0)'], {}), '(0)\n', (6245, 6248), False, 'import sys, ... |
import gitlab
import gitlab.v4.objects as glo
import zenodo_gitlab.const as const
import typing as ty
import zenodo_gitlab.base as base
class ZenodoGitLab:
"""
Main class to handle the interactions between GitLab repositories and Zenodo.
"""
def __init__(self, *, gitlab_instance: gitlab.Gitlab, zenod... | [
"zenodo_gitlab.base.new_deposit",
"zenodo_gitlab.base.get_deposition_data",
"zenodo_gitlab.base.get_depositions",
"zenodo_gitlab.base.publish_deposition",
"zenodo_gitlab.base.extract_archive_name_from_url",
"zenodo_gitlab.base.get_archive_url",
"zenodo_gitlab.base.upload_archive",
"zenodo_gitlab.base.... | [((1774, 1881), 'zenodo_gitlab.base.new_deposit', 'base.new_deposit', ([], {'zen_token': 'self.zenodo_token', 'zen_base_url': 'self.base_url', 'deposition_metadata': 'metadata'}), '(zen_token=self.zenodo_token, zen_base_url=self.base_url,\n deposition_metadata=metadata)\n', (1790, 1881), True, 'import zenodo_gitlab.... |
"""Test for version file syntax."""
import re
from transpose_dict.__version__ import __version__
def test_version():
pattern = re.compile(r"\d+\.\d+\.\d+")
assert pattern.match(__version__) | [
"re.compile"
] | [((134, 166), 're.compile', 're.compile', (['"""\\\\d+\\\\.\\\\d+\\\\.\\\\d+"""'], {}), "('\\\\d+\\\\.\\\\d+\\\\.\\\\d+')\n", (144, 166), False, 'import re\n')] |
# coding: utf-8
# import sys,os,os.path
# os.environ['CUDA_VISIBLE_DEVICES']=''
import json
import os
import sys
from collections import Counter
import tqdm
import numpy as np
import tensorflow as tf
from tensorflow.contrib import layers
from tensorflow.python.ops import array_ops
import random
import pickle
import ed... | [
"tensorflow.local_variables_initializer",
"tensorflow.shape",
"numpy.argsort",
"numpy.array",
"tensorflow.contrib.layers.bias_add",
"tensorflow.reduce_mean",
"tensorflow.nn.embedding_lookup",
"tensorflow.slice",
"tensorflow.placeholder",
"tensorflow.concat",
"tensorflow.nn.pool",
"tensorflow.C... | [((3406, 3450), 'tensorflow.placeholder', 'tf.placeholder', (['tf.int32'], {'shape': '[None, None]'}), '(tf.int32, shape=[None, None])\n', (3420, 3450), True, 'import tensorflow as tf\n'), ((3464, 3508), 'tensorflow.placeholder', 'tf.placeholder', (['tf.int32'], {'shape': '[None, None]'}), '(tf.int32, shape=[None, None... |
from django.conf.urls import url
from .views import index , detail
urlpatterns = [
url(r'^$', view=index),
#/bookr/22/
url(r'^(?P<book_id>[0-9]+)/$',view = detail)
]
| [
"django.conf.urls.url"
] | [((91, 112), 'django.conf.urls.url', 'url', (['"""^$"""'], {'view': 'index'}), "('^$', view=index)\n", (94, 112), False, 'from django.conf.urls import url\n'), ((135, 177), 'django.conf.urls.url', 'url', (['"""^(?P<book_id>[0-9]+)/$"""'], {'view': 'detail'}), "('^(?P<book_id>[0-9]+)/$', view=detail)\n", (138, 177), Fal... |
from setuptools import setup, find_packages
setup(
name="configtune",
version="0.0.8",
description="A package to tune parameters with config files: designed with machine learning hyperparameter tuning in mind.",
long_description=None,
url= "https://github.com/orionw/configtune",
author="<NAME> and <NAME>",
auth... | [
"setuptools.find_packages"
] | [((589, 604), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (602, 604), False, 'from setuptools import setup, find_packages\n')] |
# The MIT License (MIT)
# Copyright © 2021 <NAME>
# Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
# documentation files (the “Software”), to deal in the Software without restriction, including without limitation
# the rights to use, copy, modify, merge, ... | [
"substrateinterface.utils.ss58.ss58_encode",
"bittensor.Keypair.create_from_seed",
"os.path.exists",
"json.dumps",
"bittensor.Keypair",
"getpass.getpass",
"os.chmod",
"ansible_vault.Vault",
"os.path.expanduser",
"json.loads",
"os.access",
"os.path.isfile",
"os.path.dirname",
"cryptography.... | [((4706, 4771), 'password_strength.PasswordPolicy.from_names', 'PasswordPolicy.from_names', ([], {'strength': '(0.2)', 'entropybits': '(10)', 'length': '(6)'}), '(strength=0.2, entropybits=10, length=6)\n', (4731, 4771), False, 'from password_strength import PasswordPolicy\n'), ((5118, 5159), 'getpass.getpass', 'getpas... |
from setuptools import setup, find_packages
def scm_version():
def local_scheme(version):
if version.tag and not version.distance:
return version.format_with("")
else:
return version.format_choice("+{node}", "+{node}.dirty")
return {
"relative_to": __file__,
... | [
"setuptools.find_packages",
"setuptools_scm.git.parse"
] | [((545, 559), 'setuptools_scm.git.parse', 'parse_git', (['"""."""'], {}), "('.')\n", (554, 559), True, 'from setuptools_scm.git import parse as parse_git\n'), ((1555, 1598), 'setuptools.find_packages', 'find_packages', ([], {'exclude': "('tests', 'tests.*')"}), "(exclude=('tests', 'tests.*'))\n", (1568, 1598), False, '... |
import os
import re
FILE_BEGIN = 0
FILE_END = 1
LINE = 2
LABEL = 3
CODE = 4
COMMENT = 5
PREPROC = 6
SECTION = 7
GLOBAL = 8
FINISH = 9
# Yield tuples as files in a project are scanned:
# (FILE_BEGIN, full_path)
# (FILE_END, full_path)
# (LINE, line_num, line)
# (LABEL, label)
# (CODE, code)
# (COM... | [
"re.findall",
"os.path.join",
"os.walk"
] | [((509, 526), 'os.walk', 'os.walk', (['rootpath'], {}), '(rootpath)\n', (516, 526), False, 'import os\n'), ((571, 602), 'os.path.join', 'os.path.join', (['dirname', 'filename'], {}), '(dirname, filename)\n', (583, 602), False, 'import os\n'), ((1696, 1723), 're.findall', 're.findall', (['"""[\\\\w\']+"""', 'code'], {})... |
import sys
import os
own_dir = os.path.abspath(os.path.dirname(__name__))
repo_root = os.path.abspath(os.path.join(own_dir, os.path.pardir))
sys.path.insert(1, repo_root)
| [
"os.path.dirname",
"sys.path.insert",
"os.path.join"
] | [((143, 172), 'sys.path.insert', 'sys.path.insert', (['(1)', 'repo_root'], {}), '(1, repo_root)\n', (158, 172), False, 'import sys\n'), ((48, 73), 'os.path.dirname', 'os.path.dirname', (['__name__'], {}), '(__name__)\n', (63, 73), False, 'import os\n'), ((103, 140), 'os.path.join', 'os.path.join', (['own_dir', 'os.path... |
import math
from ..lib import Image
def histogram_entropy(im):
"""
Calculate the entropy of an images' histogram. Used for "smart cropping" in easy-thumbnails;
see: https://raw.github.com/SmileyChris/easy-thumbnails/master/easy_thumbnails/utils.py
"""
if not isinstance(im, Image.Image):
r... | [
"math.log"
] | [((521, 535), 'math.log', 'math.log', (['p', '(2)'], {}), '(p, 2)\n', (529, 535), False, 'import math\n')] |
from time import time
def cache(function):
memo = {}
time_to_cache = 60
def wrapper(*args):
if args in memo and time() < memo[args]['time'] + time_to_cache:
return memo[args]['record']
else:
rv = function(*args)
memo[args] = {
'record': r... | [
"time.time"
] | [((134, 140), 'time.time', 'time', ([], {}), '()\n', (138, 140), False, 'from time import time\n'), ((347, 353), 'time.time', 'time', ([], {}), '()\n', (351, 353), False, 'from time import time\n')] |
import numpy as np
import pytest
from docarray import DocumentArray, Document
from docarray.array.qdrant import DocumentArrayQdrant
from docarray.array.sqlite import DocumentArraySqlite
from docarray.array.annlite import DocumentArrayAnnlite, AnnliteConfig
from docarray.array.storage.qdrant import QdrantConfig
from do... | [
"docarray.array.annlite.AnnliteConfig",
"docarray.array.storage.qdrant.QdrantConfig",
"pytest.mark.parametrize",
"docarray.Document",
"pytest.fixture",
"docarray.array.storage.weaviate.WeaviateConfig",
"numpy.testing.assert_array_equal"
] | [((433, 465), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""function"""'}), "(scope='function')\n", (447, 465), False, 'import pytest\n'), ((611, 657), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""min_freq"""', '[1, 2, 3]'], {}), "('min_freq', [1, 2, 3])\n", (634, 657), False, 'import pytest\n')... |
from __future__ import division
from __future__ import absolute_import
from __future__ import print_function
import numpy as np
import os
class Memory(object):
"""
An implementation of the replay memory. This is essential when dealing with DRL algorithms that are not
multi-threaded as in A3C.
"""
... | [
"os.path.exists",
"os.makedirs",
"os.path.join",
"numpy.random.randint",
"numpy.empty"
] | [((721, 763), 'numpy.empty', 'np.empty', ([], {'shape': '((memory_size,) + state_dim)'}), '(shape=(memory_size,) + state_dim)\n', (729, 763), True, 'import numpy as np\n'), ((812, 854), 'numpy.empty', 'np.empty', ([], {'shape': '((memory_size,) + state_dim)'}), '(shape=(memory_size,) + state_dim)\n', (820, 854), True, ... |
from catalyst import utils
from catalyst.data.cv import BlurMixin, FlareMixin, RotateMixin
jpg_rgb_uri = (
"https://raw.githubusercontent.com/catalyst-team/catalyst-pics/master"
"/test_images/catalyst_icon.jpg"
)
image = utils.imread(jpg_rgb_uri)
def test_blur_mixin():
"""@TODO: Docs. Contribution is we... | [
"catalyst.utils.imread",
"catalyst.data.cv.FlareMixin",
"catalyst.data.cv.RotateMixin",
"catalyst.data.cv.BlurMixin"
] | [((231, 256), 'catalyst.utils.imread', 'utils.imread', (['jpg_rgb_uri'], {}), '(jpg_rgb_uri)\n', (243, 256), False, 'from catalyst import utils\n'), ((390, 401), 'catalyst.data.cv.BlurMixin', 'BlurMixin', ([], {}), '()\n', (399, 401), False, 'from catalyst.data.cv import BlurMixin, FlareMixin, RotateMixin\n'), ((808, 8... |
import numpy as np
from proteus import Domain, Context, Comm
from proteus.mprans import SpatialTools as st
import proteus.TwoPhaseFlow.TwoPhaseFlowProblem as TpFlow
from proteus import WaveTools as wt
from proteus.Profiling import logEvent
from proteus.mbd import CouplingFSI as fsi
import os
import pychrono
rho_0 = 99... | [
"proteus.TwoPhaseFlow.TwoPhaseFlowProblem.OutputStepping",
"proteus.mbd.CouplingFSI.ProtChSystem",
"proteus.ctransportCoefficients.smoothedHeaviside_integral",
"proteus.TwoPhaseFlow.TwoPhaseFlowProblem.TwoPhaseFlowProblem",
"proteus.ctransportCoefficients.smoothedHeaviside",
"proteus.mprans.SpatialTools.T... | [((728, 765), 'proteus.Domain.PiecewiseLinearComplexDomain', 'Domain.PiecewiseLinearComplexDomain', ([], {}), '()\n', (763, 765), False, 'from proteus import Domain, Context, Comm\n'), ((805, 832), 'proteus.mprans.SpatialTools.Tank3D', 'st.Tank3D', (['domain', 'tank_dim'], {}), '(domain, tank_dim)\n', (814, 832), True,... |
import smtplib
from email import encoders
from email.mime.text import MIMEText
from email.mime.base import MIMEBase
from email.mime.multipart import MIMEMultipart
sender_email=input("enter sender email")
reciver_emil=input("add reciver email")
server=smtplib.SMTP_SSL('smtp.gmail.com',465)
# server.connect("smtp.gmail.... | [
"email.mime.base.MIMEBase",
"smtplib.SMTP_SSL",
"email.encoders.encode_base64",
"email.mime.multipart.MIMEMultipart",
"email.mime.text.MIMEText"
] | [((252, 291), 'smtplib.SMTP_SSL', 'smtplib.SMTP_SSL', (['"""smtp.gmail.com"""', '(465)'], {}), "('smtp.gmail.com', 465)\n", (268, 291), False, 'import smtplib\n'), ((460, 475), 'email.mime.multipart.MIMEMultipart', 'MIMEMultipart', ([], {}), '()\n', (473, 475), False, 'from email.mime.multipart import MIMEMultipart\n')... |
import json
import os
import sys
from unittest import mock
import gemmi
from relion.cryolo_relion_it import mask_soft_edge_external_job
@mock.patch("relion.cryolo_relion_it.mask_soft_edge_external_job.subprocess")
def test_mask_soft_edge_main(mock_subprocess, tmpdir):
# Prepare things
os.chdir(tmpdir)
c... | [
"unittest.mock.call",
"gemmi.cif.Document",
"relion.cryolo_relion_it.mask_soft_edge_external_job.main",
"os.chdir",
"os.path.isfile",
"unittest.mock.patch",
"json.dump"
] | [((141, 217), 'unittest.mock.patch', 'mock.patch', (['"""relion.cryolo_relion_it.mask_soft_edge_external_job.subprocess"""'], {}), "('relion.cryolo_relion_it.mask_soft_edge_external_job.subprocess')\n", (151, 217), False, 'from unittest import mock\n'), ((298, 314), 'os.chdir', 'os.chdir', (['tmpdir'], {}), '(tmpdir)\n... |
#!/usr/bin/env python3
import os
import sys
import argparse
import subprocess
bash_output = lambda *s: subprocess.check_output(s, stderr=subprocess.STDOUT).decode()
USE_ENV_BASH="""#!/bin/bash
export VENV_RUNNING=1
alias pip=venv_pip_recording
unvenv () {
unset VENV_RUNNING
unset -f unvenv
unalias pip
... | [
"subprocess.check_output",
"os.path.exists",
"os.listdir",
"argparse.ArgumentParser",
"os.rmdir",
"os.path.dirname",
"collections.defaultdict",
"os.system",
"os.remove"
] | [((3467, 3574), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': 'description', 'formatter_class': 'argparse.RawDescriptionHelpFormatter'}), '(description=description, formatter_class=argparse.\n RawDescriptionHelpFormatter)\n', (3490, 3574), False, 'import argparse\n'), ((1665, 1690), 'os.... |
import struct
import datetime
from simpledbf import Dbf5
class Dbf6(Dbf5):
def _get_recs(self, chunk=None):
'''Generator that returns individual records.
Parameters
----------
chunk : int, optional
Number of records to return as a single chunk. Default 'None',
... | [
"datetime.date"
] | [((3271, 3293), 'datetime.date', 'datetime.date', (['y', 'm', 'd'], {}), '(y, m, d)\n', (3284, 3293), False, 'import datetime\n')] |
from playwright.sync_api import sync_playwright
def crawler(username, password):
with sync_playwright() as playwright:
browser = playwright.chromium.launch()
page = browser.new_page()
page.goto("http://nginx")
page.type('input[name="username"]', username)
page.type('input[n... | [
"playwright.sync_api.sync_playwright"
] | [((92, 109), 'playwright.sync_api.sync_playwright', 'sync_playwright', ([], {}), '()\n', (107, 109), False, 'from playwright.sync_api import sync_playwright\n')] |
# -*- coding: utf-8 -*-
#
# Copyright 2017 Gehirn 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... | [
"hmac.new",
"hmac.compare_digest"
] | [((1690, 1725), 'hmac.compare_digest', 'hmac.compare_digest', (['signature', "b''"], {}), "(signature, b'')\n", (1709, 1725), False, 'import hmac\n'), ((2190, 2227), 'hmac.new', 'hmac.new', (['key', 'message', 'self.hash_fun'], {}), '(key, message, self.hash_fun)\n', (2198, 2227), False, 'import hmac\n')] |
import kivy
import pyodbc as pyodbc
from kivy.app import App
from kivy.uix.label import Label
from kivy.uix.gridlayout import GridLayout
from kivy.uix.textinput import TextInput
from kivy.uix.button import Button
from kivy.uix.widget import Widget
from kivy.properties import StringProperty
from kivy.properties import O... | [
"pyodbc.connect",
"kivy.uix.label.Label",
"kivy.uix.button.Button",
"kivy.uix.textinput.TextInput"
] | [((687, 800), 'pyodbc.connect', 'pyodbc.connect', (['"""Trusted_Connection=yes"""'], {'driver': '"""{SQL Server}"""', 'server': '"""Server name"""', 'database': '"""FlowerShop"""'}), "('Trusted_Connection=yes', driver='{SQL Server}', server=\n 'Server name', database='FlowerShop')\n", (701, 800), True, 'import pyodb... |
import matplotlib
matplotlib.use('agg')
import matplotlib.pyplot as plt
import abc,os,pickle,sys
import scipy.stats
import numpy as np
from datetime import datetime
import tensorflow as tf
from BatchIterator import PaddedDataIterator
from generation import *
from Plotter import get_intensity,get_integral,get_integral_... | [
"Utils.file2sequence",
"tensorflow.shape",
"matplotlib.pyplot.grid",
"matplotlib.pyplot.ylabel",
"numpy.linalg.norm",
"tensorflow.reduce_mean",
"tensorflow.set_random_seed",
"tensorflow.GPUOptions",
"tensorflow.log",
"BatchIterator.PaddedDataIterator",
"os.path.exists",
"Utils.sequence2file",
... | [((19, 40), 'matplotlib.use', 'matplotlib.use', (['"""agg"""'], {}), "('agg')\n", (33, 40), False, 'import matplotlib\n'), ((1230, 1254), 'tensorflow.set_random_seed', 'tf.set_random_seed', (['SEED'], {}), '(SEED)\n', (1248, 1254), True, 'import tensorflow as tf\n'), ((1255, 1275), 'numpy.random.seed', 'np.random.seed'... |
# Copyright (c) 2015, Frappe Technologies Pvt. Ltd. and Contributors
# License: GNU General Public License v3. See license.txt
from __future__ import unicode_literals
import frappe
from frappe.utils import cint, fmt_money, flt, nowdate, getdate
no_cache = 1
no_sitemap = 1
def get_context(context):
home... | [
"frappe.get_doc"
] | [((327, 374), 'frappe.get_doc', 'frappe.get_doc', (['"""Capital Care Website Settings"""'], {}), "('Capital Care Website Settings')\n", (341, 374), False, 'import frappe\n'), ((582, 628), 'frappe.get_doc', 'frappe.get_doc', (['"""Website Slideshow"""', 'slideshow'], {}), "('Website Slideshow', slideshow)\n", (596, 628)... |
__author__ = "<NAME> <<EMAIL>>"
import re
from time import sleep
from unicon.bases.routers.services import BaseService
from unicon.plugins.generic.service_statements import reload_statement_list
from unicon.plugins.generic.service_implementation import ReloadResult
from unicon.eal.dialogs import Dialog
from unicon.c... | [
"unicon.utils.AttributeDict",
"unicon.eal.dialogs.Dialog",
"unicon.core.errors.SubCommandFailure",
"time.sleep"
] | [((1519, 1574), 'unicon.eal.dialogs.Dialog', 'Dialog', (['(reload_statement_list + [boot_from_rommon_stmt])'], {}), '(reload_statement_list + [boot_from_rommon_stmt])\n', (1525, 1574), False, 'from unicon.eal.dialogs import Dialog\n'), ((1677, 1687), 'unicon.eal.dialogs.Dialog', 'Dialog', (['[]'], {}), '([])\n', (1683,... |
from django.apps import AppConfig
from django.utils.translation import gettext_lazy as _
class ViscometersConfig(AppConfig):
name = 'scieio.viscometers'
verbose_name = _("Viscometers and Rheometers")
| [
"django.utils.translation.gettext_lazy"
] | [((178, 209), 'django.utils.translation.gettext_lazy', '_', (['"""Viscometers and Rheometers"""'], {}), "('Viscometers and Rheometers')\n", (179, 209), True, 'from django.utils.translation import gettext_lazy as _\n')] |
import math
import cv2
import numpy as np
import tensorflow as tf
from scipy import ndimage
import os
from MNIST_data import input_data
class Recognizer:
def __init__(self):
pass
@staticmethod
def shift(img, sx, sy):
rows, cols = img.shape
M = np.float32([[1, 0, sx], [0, 1, sy]])... | [
"math.floor",
"numpy.lib.pad",
"scipy.ndimage.measurements.center_of_mass",
"tensorflow.cast",
"tensorflow.log",
"os.remove",
"MNIST_data.input_data.read_data_sets",
"cv2.threshold",
"numpy.delete",
"tensorflow.placeholder",
"tensorflow.Session",
"tensorflow.matmul",
"numpy.round",
"tensor... | [((284, 320), 'numpy.float32', 'np.float32', (['[[1, 0, sx], [0, 1, sy]]'], {}), '([[1, 0, sx], [0, 1, sy]])\n', (294, 320), True, 'import numpy as np\n'), ((339, 375), 'cv2.warpAffine', 'cv2.warpAffine', (['img', 'M', '(cols, rows)'], {}), '(img, M, (cols, rows))\n', (353, 375), False, 'import cv2\n'), ((462, 502), 's... |
import matplotlib.pyplot as plt
from ._compat import *
class GridCurves(object):
def __init__(self, curves):
self._curves = curves
@property
def curves(self):
return self._curves
def __str__(self):
fh = StringIO()
fh.write('gridcurves objects:\n\n')
fh.write(... | [
"matplotlib.pyplot.plot"
] | [((531, 576), 'matplotlib.pyplot.plot', 'plt.plot', (['curve.real', 'curve.imag'], {'color': '"""0.6"""'}), "(curve.real, curve.imag, color='0.6')\n", (539, 576), True, 'import matplotlib.pyplot as plt\n')] |
#!/usr/bin/env python3
from __future__ import annotations
import unittest
import warnings
import torch
from linear_operator.test.base_test_case import BaseTestCase
from linear_operator.utils.cholesky import psd_safe_cholesky
from linear_operator.utils.errors import NanError
from linear_operator.utils.warnings impor... | [
"linear_operator.utils.cholesky.psd_safe_cholesky",
"torch.eye",
"torch.cholesky",
"warnings.catch_warnings",
"torch.empty_like",
"torch.tensor",
"warnings.simplefilter",
"unittest.main",
"torch.allclose",
"torch.arange",
"torch.device"
] | [((4350, 4365), 'unittest.main', 'unittest.main', ([], {}), '()\n', (4363, 4365), False, 'import unittest\n'), ((459, 531), 'torch.tensor', 'torch.tensor', (['[[[0.25, -0.75], [-0.75, 2.25]], [[1.0, 1.0], [1.0, 1.0]]]'], {}), '([[[0.25, -0.75], [-0.75, 2.25]], [[1.0, 1.0], [1.0, 1.0]]])\n', (471, 531), False, 'import t... |
from pathlib import Path
from beet import BlockTag, DataPack, Function, FunctionTag, JsonFile, Structure
def test_equality():
assert DataPack() == DataPack()
assert DataPack("hello") == DataPack("hello")
assert DataPack("hello") != DataPack("world")
p1 = DataPack("foo", mcmeta=JsonFile({"pack": {"de... | [
"beet.Function",
"beet.FunctionTag",
"beet.BlockTag",
"beet.JsonFile",
"beet.DataPack"
] | [((709, 719), 'beet.DataPack', 'DataPack', ([], {}), '()\n', (717, 719), False, 'from beet import BlockTag, DataPack, Function, FunctionTag, JsonFile, Structure\n'), ((729, 739), 'beet.DataPack', 'DataPack', ([], {}), '()\n', (737, 739), False, 'from beet import BlockTag, DataPack, Function, FunctionTag, JsonFile, Stru... |
# -*- coding: utf-8 -*-
# Copyright 2017 <NAME>
# Copyright 2018 <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
#
# Un... | [
"ccpi.viewer.CILViewer2D.ViewerEventManager",
"vtk.vtkDecimatePro",
"vtk.vtkImageMapToWindowLevelColors",
"vtk.vtkTextMapper",
"vtk.vtkTextProperty",
"vtk.vtkPNGWriter",
"ccpi.viewer.utils.colormaps.CILColorMaps.get_color_transfer_function",
"vtk.vtkImageActor",
"vtk.vtkInteractorStyleTrackballCamer... | [((1180, 1232), 'vtk.vtkInteractorStyleTrackballCamera.__init__', 'vtk.vtkInteractorStyleTrackballCamera.__init__', (['self'], {}), '(self)\n', (1226, 1232), False, 'import vtk\n'), ((9408, 9429), 'vtk.vtkTextProperty', 'vtk.vtkTextProperty', ([], {}), '()\n', (9427, 9429), False, 'import vtk\n'), ((9809, 9828), 'vtk.v... |
import os, json
from django.core.exceptions import ImproperlyConfigured
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
ROOT_DIR = os.path.dirname(BASE_DIR)
INTERNAL_IPS = ['127.0.0.1',]
ROOT_URLCONF = 'djangotube.urls'
TEMPLATES = [
{
'BACKEND': 'django.template.backends.django... | [
"os.path.abspath",
"os.path.dirname"
] | [((156, 181), 'os.path.dirname', 'os.path.dirname', (['BASE_DIR'], {}), '(BASE_DIR)\n', (171, 181), False, 'import os, json\n'), ((117, 142), 'os.path.abspath', 'os.path.abspath', (['__file__'], {}), '(__file__)\n', (132, 142), False, 'import os, json\n')] |
from random import randint
import config
class wall:
"""
Stores the state data for a wall on the map
"""
def __init__(self):
"""
Randomly generates a wall using the bounding values in config.py
"""
# Set lengths for the long and short sides of the wall
longSide ... | [
"random.randint"
] | [((322, 401), 'random.randint', 'randint', (['config.game.wall.longSideBounds[0]', 'config.game.wall.longSideBounds[1]'], {}), '(config.game.wall.longSideBounds[0], config.game.wall.longSideBounds[1])\n', (329, 401), False, 'from random import randint\n'), ((422, 508), 'random.randint', 'randint', (['config.game.wall.s... |
import json
import os
import time
import urllib.parse
import urllib.request
import pandas as pd
import pathlib
#ルートディレクトリの設定(dataディレクトリ )
root_dir = pathlib.Path(__file__).parent.parent
#都道府県一覧の取得
c = os.path.join(root_dir, 'codes/preflist.json')
with open(c) as j:
prefList = json.load(j)
#市区町村一覧の取得
c = os.path.... | [
"os.getenv",
"pathlib.Path",
"os.path.join",
"dotenv.load_dotenv",
"json.load",
"json.dump"
] | [((203, 248), 'os.path.join', 'os.path.join', (['root_dir', '"""codes/preflist.json"""'], {}), "(root_dir, 'codes/preflist.json')\n", (215, 248), False, 'import os\n'), ((312, 357), 'os.path.join', 'os.path.join', (['root_dir', '"""codes/citylist.json"""'], {}), "(root_dir, 'codes/citylist.json')\n", (324, 357), False,... |
from django.urls import path
from .views import *
from .reportes import reporte_compras
urlpatterns = [
path('proveedores/', ProveedorView.as_view(), name="proveedor_list"),
path('proveedores/new', ProveedorNew.as_view(), name="proveedor_new"),
path('proveedores/edit/<int:pk>',
ProveedorEdit.as_vi... | [
"django.urls.path"
] | [((354, 432), 'django.urls.path', 'path', (['"""proveedor/inactivar/<int:id>"""', 'proveedorInactivar'], {'name': '"""proveedor_ina"""'}), "('proveedor/inactivar/<int:id>', proveedorInactivar, name='proveedor_ina')\n", (358, 432), False, 'from django.urls import path\n'), ((521, 570), 'django.urls.path', 'path', (['"""... |
from functools import reduce
import urwid
from ui_interface import UIInterface
from feed import Feed
from episode import Episode
from urwid_widgets import(
SelectionList,
PackableLineBox,
EditDialogue,
InformationDialogue,
)
from player import Player
class UI(UIInterface):
palette = (
('... | [
"urwid.Columns",
"urwid_widgets.PackableLineBox",
"feed.Feed.add",
"player.Player",
"urwid_widgets.SelectionList",
"urwid.LineBox",
"urwid.SolidFill",
"urwid.AsyncioEventLoop",
"feed.Feed.getall",
"urwid_widgets.InformationDialogue",
"urwid.connect_signal",
"urwid.signals.emit_signal",
"feed... | [((1030, 1090), 'urwid.Columns', 'urwid.Columns', (["(('pack', self.feeds_box), self.episodes_box)"], {}), "((('pack', self.feeds_box), self.episodes_box))\n", (1043, 1090), False, 'import urwid\n'), ((1375, 1440), 'urwid.signals.emit_signal', 'urwid.signals.emit_signal', (['self.feeds_list.listwalker', '"""modified"""... |
from starter_two_three_tree import TwoThreeTree, Node
import unittest
class NodeTest(unittest.TestCase):
def test_init(self):
data = 1
node = Node(data)
assert node.data[0] == data
assert len(node.data) == 1
assert len(node.children) == 0
assert node.parent is None... | [
"unittest.main",
"starter_two_three_tree.TwoThreeTree",
"starter_two_three_tree.Node"
] | [((9497, 9512), 'unittest.main', 'unittest.main', ([], {}), '()\n', (9510, 9512), False, 'import unittest\n'), ((165, 175), 'starter_two_three_tree.Node', 'Node', (['data'], {}), '(data)\n', (169, 175), False, 'from starter_two_three_tree import TwoThreeTree, Node\n'), ((400, 411), 'starter_two_three_tree.Node', 'Node'... |
#
from sqlite3 import connect
from numpy import array
import re
from metfrag2 import fragmenter_rank
def main():
con = connect('replicate_data_assigned_MS2.db')
cur = con.cursor()
pat = re.compile(r'_met[0-9]+')
cmpds, ranks = [], []
qry = """SELECT cmpd, well, spectrum, adduct, monoiso, formula... | [
"metfrag2.fragmenter_rank",
"sqlite3.connect",
"re.compile"
] | [((127, 168), 'sqlite3.connect', 'connect', (['"""replicate_data_assigned_MS2.db"""'], {}), "('replicate_data_assigned_MS2.db')\n", (134, 168), False, 'from sqlite3 import connect\n'), ((202, 226), 're.compile', 're.compile', (['"""_met[0-9]+"""'], {}), "('_met[0-9]+')\n", (212, 226), False, 'import re\n'), ((1189, 122... |
from flask import Blueprint,request,jsonify
import requests
import json
url = 'https://flow-api.fluctuo.com/v1?access_token=eFwW53d4EiCdlmbrs8muiM5gSvOrhPwh'
vehicles_info_bp = Blueprint('vehicles_info',__name__)
@vehicles_info_bp.route('/vehicles_info', methods=['post'])
def vehicles_info():
try:
... | [
"json.dumps",
"flask.request.get_json",
"flask.Blueprint",
"flask.jsonify"
] | [((185, 221), 'flask.Blueprint', 'Blueprint', (['"""vehicles_info"""', '__name__'], {}), "('vehicles_info', __name__)\n", (194, 221), False, 'from flask import Blueprint, request, jsonify\n'), ((334, 352), 'flask.request.get_json', 'request.get_json', ([], {}), '()\n', (350, 352), False, 'from flask import Blueprint, r... |
#!/usr/bin/env python3
import re
import fire
import requests
import logging as logger
CONFIG = {
'SERVER_ADDRESS': 'http://localhost',
'SERVER_PORT': 5050
}
def interact():
"""
Interactively call the model's server
"""
address = f"{CONFIG['SERVER_ADDRESS']}:{CONFIG['SERVER_PORT']}"
wh... | [
"fire.Fire",
"requests.get",
"requests.head",
"re.findall",
"logging.info",
"logging.error"
] | [((1697, 1716), 'fire.Fire', 'fire.Fire', (['interact'], {}), '(interact)\n', (1706, 1716), False, 'import fire\n'), ((712, 733), 'logging.info', 'logger.info', (['raw_text'], {}), '(raw_text)\n', (723, 733), True, 'import logging as logger\n'), ((750, 791), 're.findall', 're.findall', (['"""\\\\<\\\\|(.+?)\\\\|\\\\>""... |
from __future__ import (absolute_import, division, print_function)
__metaclass__ = type
DOCUMENTATION = '''
name: apt_keys
author: Manala (@manala)
short_description: returns a curated keys list
description:
- Takes a keys list and returns it curated.
'''
from ansible.plugins.lookup import Looku... | [
"ansible.errors.AnsibleError"
] | [((1380, 1412), 'ansible.errors.AnsibleError', 'AnsibleError', (['"""Missing "id" key"""'], {}), '(\'Missing "id" key\')\n', (1392, 1412), False, 'from ansible.errors import AnsibleError\n')] |
from setuptools import setup, Extension
import numpy as np
from Cython.Build import cythonize
from Cython.Distutils import build_ext
from torch.utils.cpp_extension import BuildExtension, CUDAExtension
# Obtain the numpy include directory. This logic works across numpy versions.
try:
numpy_include = np.get_includ... | [
"setuptools.Extension",
"Cython.Build.cythonize",
"numpy.get_numpy_include",
"numpy.get_include"
] | [((307, 323), 'numpy.get_include', 'np.get_include', ([], {}), '()\n', (321, 323), True, 'import numpy as np\n'), ((498, 559), 'setuptools.Extension', 'Extension', (['"""nms_cpu"""'], {'sources': "['src/nms_cpu.cpp']"}), "('nms_cpu', sources=['src/nms_cpu.cpp'], **ext_args)\n", (507, 559), False, 'from setuptools impor... |
from expertise.create_dataset import OpenReviewExpertise
from unittest.mock import patch, MagicMock
from collections import defaultdict
import openreview
import json
import random
from pathlib import Path
import sys
import pytest
import os
import time
import numpy as np
import shutil
import expertise.service
from exper... | [
"json.dumps",
"time.sleep",
"shutil.rmtree",
"os.path.isfile",
"os.path.isdir",
"time.time",
"pytest.fixture",
"expertise.create_dataset.OpenReviewExpertise",
"expertise.service.utils.mock_client",
"os.remove"
] | [((509, 540), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""session"""'}), "(scope='session')\n", (523, 540), False, 'import pytest\n'), ((965, 996), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""session"""'}), "(scope='session')\n", (979, 996), False, 'import pytest\n'), ((1084, 1115), 'pytest.fixtur... |
import numpy as np
def rotX(theta):
return np.array([[1, 0, 0]
, [0, np.cos(theta), -np.sin(theta)]
, [0, np.sin(theta), np.cos(theta)]])
def rotY(theta):
return np.array([[np.cos(theta), 0, np.sin(theta)]
, [0, 1, 0]
, [-np.sin(theta... | [
"numpy.cross",
"numpy.diag",
"numpy.array",
"numpy.dot",
"numpy.outer",
"numpy.cos",
"numpy.linalg.norm",
"numpy.sin"
] | [((630, 646), 'numpy.cross', 'np.cross', (['v1', 'v2'], {}), '(v1, v2)\n', (638, 646), True, 'import numpy as np\n'), ((928, 941), 'numpy.sin', 'np.sin', (['angle'], {}), '(angle)\n', (934, 941), True, 'import numpy as np\n'), ((953, 966), 'numpy.cos', 'np.cos', (['angle'], {}), '(angle)\n', (959, 966), True, 'import n... |
# coding=utf-8
# Copyright 2019 The Google Research Authors.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicab... | [
"absl.app.UsageError",
"tensorflow.compat.v2.io.gfile.makedirs",
"uq_benchmark_2019.experiment_utils.record_config",
"absl.flags.DEFINE_integer",
"absl.logging.info",
"uq_benchmark_2019.cifar.models_lib.build_and_train",
"uq_benchmark_2019.cifar.data_lib.build_dataset",
"absl.app.run",
"uq_benchmark... | [((1251, 1336), 'absl.flags.DEFINE_enum', 'flags.DEFINE_enum', (['"""method"""', 'None', 'models_lib.METHODS', '"""Name of modeling method."""'], {}), "('method', None, models_lib.METHODS,\n 'Name of modeling method.')\n", (1268, 1336), False, 'from absl import flags\n'), ((1355, 1415), 'absl.flags.DEFINE_string', '... |
from django.contrib.auth.models import User
from django.db import models
from django.template.defaultfilters import slugify
class Category(models.Model):
name=models.CharField(max_length=128,unique=type)
views=models.IntegerField(default=0)
likes=models.IntegerField(default=0)
slug=models.SlugField()
... | [
"django.db.models.OneToOneField",
"django.db.models.ForeignKey",
"django.db.models.IntegerField",
"django.db.models.ImageField",
"django.template.defaultfilters.slugify",
"django.db.models.SlugField",
"django.db.models.URLField",
"django.db.models.CharField"
] | [((163, 208), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(128)', 'unique': 'type'}), '(max_length=128, unique=type)\n', (179, 208), False, 'from django.db import models\n'), ((218, 248), 'django.db.models.IntegerField', 'models.IntegerField', ([], {'default': '(0)'}), '(default=0)\n', (237, ... |
# Resource object code (Python 3)
# Created by: object code
# Created by: The Resource Compiler for Qt version 5.15.2
# WARNING! All changes made in this file will be lost!
from PySide2 import QtCore
qt_resource_data = b"\
\x00\x00\x0f\xb6\
\x89\
PNG\x0d\x0a\x1a\x0a\x00\x00\x00\x0dIHDR\x00\
\x00\x00@\x00\x00\x00@\x08... | [
"PySide2.QtCore.qUnregisterResourceData",
"PySide2.QtCore.qRegisterResourceData"
] | [((146918, 147009), 'PySide2.QtCore.qRegisterResourceData', 'QtCore.qRegisterResourceData', (['(3)', 'qt_resource_struct', 'qt_resource_name', 'qt_resource_data'], {}), '(3, qt_resource_struct, qt_resource_name,\n qt_resource_data)\n', (146946, 147009), False, 'from PySide2 import QtCore\n'), ((147039, 147132), 'PyS... |
# -*- coding: utf-8 -*-
# !/usr/bin/env python
# Author: Mocobk
# Data: 2019/03/18
# License: MIT
# Modified by <NAME>
# <EMAIL>
# Modified At: 2020/11/15
import unittest
import os
from BeautifulReport import BeautifulReport
report_dir = os.path.expanduser("~/")
if __name__ == '__main__':
test_suite = unittest.de... | [
"BeautifulReport.BeautifulReport",
"os.path.expanduser",
"unittest.defaultTestLoader.discover"
] | [((239, 263), 'os.path.expanduser', 'os.path.expanduser', (['"""~/"""'], {}), "('~/')\n", (257, 263), False, 'import os\n'), ((309, 380), 'unittest.defaultTestLoader.discover', 'unittest.defaultTestLoader.discover', (['"""./tests"""'], {'pattern': '"""test_demo*.py"""'}), "('./tests', pattern='test_demo*.py')\n", (344,... |
import torch
from torch import nn
def conv_bn(in_c, out_c, kernel_size, stride=1, padding=0, groups=1):
return nn.Sequential(
nn.Conv2d(in_c, out_c, kernel_size, stride, padding, groups=groups),
nn.BatchNorm2d(out_c)
)
# Used to upscale the image (height and width) after global average pooling
def scale_dim(... | [
"torch.nn.BatchNorm2d",
"torch.nn.Sigmoid",
"torch.nn.Dropout",
"torch.randperm",
"torch.nn.Sequential",
"torch.nn.Flatten",
"torch.nn.Conv2d",
"torch.nn.SiLU",
"torch.matmul",
"torch.nn.AdaptiveAvgPool2d",
"torch.nn.Linear",
"torch.nn.AvgPool2d",
"torch.nn.LogSoftmax",
"torch.cat"
] | [((131, 198), 'torch.nn.Conv2d', 'nn.Conv2d', (['in_c', 'out_c', 'kernel_size', 'stride', 'padding'], {'groups': 'groups'}), '(in_c, out_c, kernel_size, stride, padding, groups=groups)\n', (140, 198), False, 'from torch import nn\n'), ((202, 223), 'torch.nn.BatchNorm2d', 'nn.BatchNorm2d', (['out_c'], {}), '(out_c)\n', ... |
import matplotlib.pyplot as plt
radix_len = [120, 110, 100, 90, 80, 70, 60, 50, 40, 30, 20]
radix_time = [82.941, 71.651, 60.559, 47.864, 37.66, 29.485, 21.827, 14.785, 9.637, 5.537, 2.694]
suffix_len = [19, 24, 37, 52, 66, 81, 90, 120]
suffix_time = [0.241, 0.242, 0.244, 0.245, 0.246, 0.248, 0.250, 0.251]
fig, ax =... | [
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.subplots",
"matplotlib.pyplot.show",
"matplotlib.pyplot.ylabel"
] | [((321, 335), 'matplotlib.pyplot.subplots', 'plt.subplots', ([], {}), '()\n', (333, 335), True, 'import matplotlib.pyplot as plt\n'), ((383, 431), 'matplotlib.pyplot.xlabel', 'plt.xlabel', (['"""Document size, Kbytes"""'], {'fontsize': '(12)'}), "('Document size, Kbytes', fontsize=12)\n", (393, 431), True, 'import matp... |
#<NAME>
from sklearn import preprocessing
import matplotlib.pyplot as plt
import numpy as np
from sklearn.cluster import KMeans
# Data set
# Datos de 13/02/2020 a 10/11/2020
# De acuerdo con: https://tablerocovid.mspas.gob.gt/
# Regiones de acuerdo con: https://aprende.guatemala.com/historia/geografia/regiones-de-gua... | [
"sklearn.cluster.KMeans",
"sklearn.preprocessing.LabelEncoder",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"numpy.array",
"matplotlib.pyplot.scatter",
"matplotlib.pyplot.title",
"matplotlib.pyplot.show"
] | [((1468, 1496), 'sklearn.preprocessing.LabelEncoder', 'preprocessing.LabelEncoder', ([], {}), '()\n', (1494, 1496), False, 'from sklearn import preprocessing\n'), ((1591, 2612), 'numpy.array', 'np.array', (['[[region_guatemala2[0], no_fallecidos[0]], [region_guatemala2[1],\n no_fallecidos[1]], [region_guatemala2[2],... |
from textwrap import dedent
import attack_flow.graphviz
def test_convert_attack_flow_to_dot():
flow = {
"actions": [
{
"id": "action1",
"name": "action-one",
},
{
"id": "action2",
"name": "action-two",
... | [
"textwrap.dedent"
] | [((853, 1187), 'textwrap.dedent', 'dedent', (['""" digraph {\n node [shape=box,style="rounded,filled,fixedsize=true,width=2,height=1"]\n\n "action1" [fillcolor=pink,label="action-one"]\n "action2" [fillcolor=pink,label="action-two"]\n\n "asset1" [fillcolor=lightblue1]\n ... |
from imutils import contours
from collections import deque
import numpy as np
import argparse
import imutils
import cv2
from Tkinter import Frame, Tk, BOTH, Text, Menu, END
import tkFileDialog
import os.path
import os
import sys
from time import gmtime, strftime
def PT(F):
Time = strftime("%Y-%... | [
"os.listdir",
"collections.deque",
"cv2.countNonZero",
"argparse.ArgumentParser",
"cv2.inRange",
"Tkinter.Tk",
"cv2.destroyWindow",
"cv2.bitwise_and",
"os.path.split",
"os.path.isfile",
"numpy.array",
"cv2.waitKey",
"cv2.destroyAllWindows",
"cv2.VideoCapture",
"cv2.cvtColor",
"time.gmt... | [((9238, 9253), 'os.listdir', 'os.listdir', (['"""."""'], {}), "('.')\n", (9248, 9253), False, 'import os\n'), ((9371, 9394), 'cv2.destroyAllWindows', 'cv2.destroyAllWindows', ([], {}), '()\n', (9392, 9394), False, 'import cv2\n'), ((420, 445), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (44... |
"""LVM based backup workflows and MixIn classes."""
import copy
import os
import gflags
import rdiff_backup_wrapper
FLAGS = gflags.FLAGS
gflags.DEFINE_string(
'snapshot_mount_root', '/tmp',
'root path for creating temporary directories for mounting LVM snapshots')
gflags.DEFINE_string('snapshot_suffix', '-a... | [
"copy.copy",
"gflags.DEFINE_string",
"os.path.join",
"os.path.ismount"
] | [((141, 271), 'gflags.DEFINE_string', 'gflags.DEFINE_string', (['"""snapshot_mount_root"""', '"""/tmp"""', '"""root path for creating temporary directories for mounting LVM snapshots"""'], {}), "('snapshot_mount_root', '/tmp',\n 'root path for creating temporary directories for mounting LVM snapshots')\n", (161, 271... |
from pandas import DataFrame as df
from pandas.io.parsers import read_csv
import os
import numpy as np
import re
from extras import toint
def check_dir(dirpath):
if not os.path.isdir(dirpath):
raise "Directory : %s is missing"
def check_file(fpath):
if not os.path.isfile(fpath):
r... | [
"os.path.join",
"os.path.isfile",
"os.path.isdir",
"pandas.DataFrame",
"re.findall",
"pandas.io.parsers.read_csv"
] | [((459, 519), 're.findall', 're.findall', (['"""\\\\[Result "(.+)"\\\\]"""', 'everything', 're.IGNORECASE'], {}), '(\'\\\\[Result "(.+)"\\\\]\', everything, re.IGNORECASE)\n', (469, 519), False, 'import re\n'), ((539, 603), 're.findall', 're.findall', (['"""\\\\[WhiteElo "(\\\\d+)"\\\\]"""', 'everything', 're.IGNORECAS... |