code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
from django.contrib import admin
from .models import Label, Document, Project
from .models import DocumentAnnotation, SequenceAnnotation, Seq2seqAnnotation
admin.site.register(DocumentAnnotation)
admin.site.register(SequenceAnnotation)
admin.site.register(Seq2seqAnnotation)
admin.site.register(Label)
admin.site.regis... | [
"django.contrib.admin.site.register"
] | [((158, 197), 'django.contrib.admin.site.register', 'admin.site.register', (['DocumentAnnotation'], {}), '(DocumentAnnotation)\n', (177, 197), False, 'from django.contrib import admin\n'), ((198, 237), 'django.contrib.admin.site.register', 'admin.site.register', (['SequenceAnnotation'], {}), '(SequenceAnnotation)\n', (... |
# BUILD THE PROJECT WITH THE CORRECT PYTHON VERSION
# pip install wheel
# python setup.py bdist_wheel
# OR python setup.py sdist bdist_wheel (to include the source)
# for python 3.8
# C:\Users\yoann\AppData\Roaming\Python\Python38\Scripts\twine upload
# --verbose --repository testpypi dist/IndexMapping-1.0.3-... | [
"setuptools.Extension",
"numpy.get_include",
"setuptools.find_packages",
"warnings.filterwarnings"
] | [((1154, 1216), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {'category': 'DeprecationWarning'}), "('ignore', category=DeprecationWarning)\n", (1177, 1216), False, 'import warnings\n'), ((1218, 1275), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""ignore"""'], {'category': 'Futu... |
import datetime
import logging
from sqlalchemy import (
Boolean,
Column,
DateTime,
ForeignKey,
Integer,
MetaData,
Numeric,
String,
Table,
TEXT,
)
# Need our custom types, but don't import anything else from model
from galaxy.model.custom_types import (
JSONType,
Metadat... | [
"sqlalchemy.MetaData",
"galaxy.model.custom_types.TrimmedString",
"sqlalchemy.ForeignKey",
"sqlalchemy.Numeric",
"sqlalchemy.Column",
"sqlalchemy.String",
"logging.getLogger"
] | [((355, 382), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (372, 382), False, 'import logging\n'), ((425, 435), 'sqlalchemy.MetaData', 'MetaData', ([], {}), '()\n', (433, 435), False, 'from sqlalchemy import Boolean, Column, DateTime, ForeignKey, Integer, MetaData, Numeric, String, Tabl... |
"""
Configuration to get the same results every time.
https://keras.io/getting-started/faq/#how-can-i-obtain-reproducible-results-using-keras-during-development
"""
import os
import random as rn
import numpy as np
import tensorflow as tf
from keras import backend as K
# Set up random seed to
# get the same results ... | [
"numpy.random.seed",
"tensorflow.compat.v1.get_default_graph",
"keras.backend.set_session",
"tensorflow.compat.v1.set_random_seed",
"random.seed",
"tensorflow.compat.v1.ConfigProto"
] | [((532, 550), 'numpy.random.seed', 'np.random.seed', (['rs'], {}), '(rs)\n', (546, 550), True, 'import numpy as np\n'), ((551, 562), 'random.seed', 'rn.seed', (['rs'], {}), '(rs)\n', (558, 562), True, 'import random as rn\n'), ((579, 671), 'tensorflow.compat.v1.ConfigProto', 'tf.compat.v1.ConfigProto', ([], {'intra_op_... |
# --------------------------------------------------------------------------------------------
# Copyright (c) Microsoft Corporation. All rights reserved.
# Licensed under the MIT License. See License.txt in the project root for license information.
# --------------------------------------------------------------------... | [
"azure.cli.core.commands.CliCommandType"
] | [((518, 655), 'azure.cli.core.commands.CliCommandType', 'CliCommandType', ([], {'operations_tmpl': '"""azext_dns.dns.operations.zones_operations#ZonesOperations.{}"""', 'client_factory': 'cf_dns_mgmt_zones'}), "(operations_tmpl=\n 'azext_dns.dns.operations.zones_operations#ZonesOperations.{}',\n client_factory=cf... |
from collections import OrderedDict
from kraken.core.maths import Vec3
from kraken.core.maths.xfo import Xfo
from kraken.core.objects.components.base_example_component import BaseExampleComponent
from kraken.core.objects.attributes.attribute_group import AttributeGroup
from kraken.core.objects.attributes.scalar_at... | [
"kraken.core.objects.attributes.integer_attribute.IntegerAttribute",
"kraken.core.objects.ctrlSpace.CtrlSpace",
"kraken.core.objects.joint.Joint",
"kraken.core.objects.operators.kl_operator.KLOperator",
"kraken.core.maths.Vec3",
"kraken.core.objects.attributes.attribute_group.AttributeGroup",
"kraken.co... | [((20111, 20137), 'kraken.core.kraken_system.KrakenSystem.getInstance', 'KrakenSystem.getInstance', ([], {}), '()\n', (20135, 20137), False, 'from kraken.core.kraken_system import KrakenSystem\n'), ((2542, 2586), 'kraken.core.objects.attributes.attribute_group.AttributeGroup', 'AttributeGroup', (['"""GuideSettings"""']... |
from django.shortcuts import render
import mhn_api.stats as mhn_stats
import mhn_api.util as mhn_util
def index(request):
attacks = mhn_stats.get_request('')['data']
top_ips = mhn_util.get_top_5(attacks, 'source_ip')
top_ports = mhn_util.get_top_5(attacks, 'destination_port')
past_24_hours = mhn_stats.... | [
"django.shortcuts.render",
"mhn_api.util.get_top_5",
"mhn_api.stats.get_past_time_attacks",
"mhn_api.stats.get_request"
] | [((185, 225), 'mhn_api.util.get_top_5', 'mhn_util.get_top_5', (['attacks', '"""source_ip"""'], {}), "(attacks, 'source_ip')\n", (203, 225), True, 'import mhn_api.util as mhn_util\n'), ((242, 289), 'mhn_api.util.get_top_5', 'mhn_util.get_top_5', (['attacks', '"""destination_port"""'], {}), "(attacks, 'destination_port')... |
from rest_framework import routers
from accounts.views import UserViewSet
from django.urls import path, include
from rest_framework_jwt.views import refresh_jwt_token, obtain_jwt_token
router = routers.DefaultRouter()
router.register('users', UserViewSet)
urlpatterns = [
path('', include(router.urls)),
#path(... | [
"django.urls.path",
"rest_framework.routers.DefaultRouter",
"django.urls.include"
] | [((195, 218), 'rest_framework.routers.DefaultRouter', 'routers.DefaultRouter', ([], {}), '()\n', (216, 218), False, 'from rest_framework import routers\n'), ((361, 397), 'django.urls.path', 'path', (['"""api/login/"""', 'obtain_jwt_token'], {}), "('api/login/', obtain_jwt_token)\n", (365, 397), False, 'from django.urls... |
from rest_framework import serializers
from .models import User, ApiKey
class UserSerializer(serializers.ModelSerializer):
"""
serializer to handle turning our `User` object into
something that can be JSONified and sent to the client
"""
password = serializers.CharField(write_only=True)
def c... | [
"rest_framework.serializers.CharField"
] | [((271, 309), 'rest_framework.serializers.CharField', 'serializers.CharField', ([], {'write_only': '(True)'}), '(write_only=True)\n', (292, 309), False, 'from rest_framework import serializers\n')] |
from django.http import HttpResponse, Http404
from django.shortcuts import render, redirect
from courses.actions import auth_is_course_admin_view_wrapper
from courses.common_page_data import get_common_page_data
from courses.exams.forms import *
@auth_is_course_admin_view_wrapper
def delete_exam(request):
... | [
"django.shortcuts.redirect"
] | [((612, 650), 'django.shortcuts.redirect', 'redirect', (["request.META['HTTP_REFERER']"], {}), "(request.META['HTTP_REFERER'])\n", (620, 650), False, 'from django.shortcuts import render, redirect\n')] |
# coding=utf-8
"""
This package manages configuration for other packages.
It is intended for my personal use only
"""
from pkg_resources import DistributionNotFound, get_distribution
# noinspection PyProtectedMember
from elib_config._file._exc import (
ConfigFileNotFoundError, EmptyValueError, IncompleteSetupErr... | [
"pkg_resources.get_distribution"
] | [((1675, 1706), 'pkg_resources.get_distribution', 'get_distribution', (['"""elib_config"""'], {}), "('elib_config')\n", (1691, 1706), False, 'from pkg_resources import DistributionNotFound, get_distribution\n')] |
import xml.etree.ElementTree as ET, re
from collections import defaultdict
from typing import Union
class XMLtoDict(object):
def parse(self, xml: str):
return self.__to_dict(ET.fromstring(xml))
def value_from_nest(self, pattern: str, nest: Union[dict, str]):
nest = nest if type(nest) is ... | [
"collections.defaultdict",
"re.search",
"xml.etree.ElementTree.fromstring"
] | [((189, 207), 'xml.etree.ElementTree.fromstring', 'ET.fromstring', (['xml'], {}), '(xml)\n', (202, 207), True, 'import xml.etree.ElementTree as ET, re\n'), ((401, 422), 're.search', 're.search', (['pattern', 'k'], {}), '(pattern, k)\n', (410, 422), False, 'import xml.etree.ElementTree as ET, re\n'), ((703, 720), 'colle... |
import sense2vec
model = sense2vec.load()
freq, wood_glue = model['wood_glue|NOUN']
#freq
#824
freq, super_glue = model['super_glue|NOUN']
#freq
#2303
model.data.similarity(wood_glue, super_glue)
#0.8765814304351807
freq, furniture = model['furniture|NOUN']
#freq
#31845
model.data.similarity(wood_glue, furniture)
#0.52... | [
"sense2vec.load"
] | [((25, 41), 'sense2vec.load', 'sense2vec.load', ([], {}), '()\n', (39, 41), False, 'import sense2vec\n')] |
import comet_ml
import tempfile
import torch
from torch import cuda
from torch.utils import data
import os
import logging
from inspect import signature
from torchexpresso.callbacks.metrics import AverageLossMetric
from torchexpresso.callbacks import CallbackRegistry
from torchexpresso import steps
from torchexpresso... | [
"os.makedirs",
"tempfile.gettempdir",
"torch.nn.CrossEntropyLoss",
"os.path.exists",
"comet_ml.Experiment",
"torch.utils.data.dataloader.DataLoader",
"torchexpresso.steps.TrainingStep",
"inspect.signature",
"torchexpresso.callbacks.metrics.AverageLossMetric",
"comet_ml.OfflineExperiment",
"torch... | [((386, 413), 'logging.getLogger', 'logging.getLogger', (['__file__'], {}), '(__file__)\n', (403, 413), False, 'import logging\n'), ((2841, 2866), 'torch.device', 'torch.device', (['device_name'], {}), '(device_name)\n', (2853, 2866), False, 'import torch\n'), ((2971, 2989), 'torchexpresso.callbacks.CallbackRegistry', ... |
# -*- coding: utf-8 -*-
# Generated by Django 1.9.8 on 2016-09-29 19:29
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('core', '0064_remove_ssh_keys_toggle'),
]
operations = [
migrations.AlterFiel... | [
"django.db.models.CharField",
"django.db.models.TextField"
] | [((430, 478), 'django.db.models.TextField', 'models.TextField', ([], {'default': "b'Description Missing'"}), "(default=b'Description Missing')\n", (446, 478), False, 'from django.db import migrations, models\n'), ((622, 682), 'django.db.models.CharField', 'models.CharField', ([], {'default': '"""No Name Provided"""', '... |
from great_expectations.dataset import DataSet
from functools import wraps
import inspect
from .util import DocInherit, parse_result_format
import sqlalchemy as sa
from sqlalchemy.engine import reflection
from numbers import Number
class MetaSqlAlchemyDataSet(DataSet):
def __init__(self, *args, **kwargs):
... | [
"sqlalchemy.not_",
"great_expectations.dataset.DataSet.expectation",
"sqlalchemy.table",
"sqlalchemy.engine.reflection.Inspector.from_engine",
"inspect.getargspec",
"functools.wraps",
"sqlalchemy.func.count",
"sqlalchemy.create_engine",
"sqlalchemy.column"
] | [((7175, 7205), 'great_expectations.dataset.DataSet.expectation', 'DataSet.expectation', (["['value']"], {}), "(['value'])\n", (7194, 7205), False, 'from great_expectations.dataset import DataSet\n'), ((8006, 8053), 'great_expectations.dataset.DataSet.expectation', 'DataSet.expectation', (["['min_value', 'max_value']"]... |
"""
Contains app creation functionality
"""
from flask import Flask
from flask_cors import CORS
from flask_jwt_extended import JWTManager
from flask.logging import default_handler
from flask_mail import Mail
from flask_migrate import Migrate
from flask_restful import Api
from flask_sqlalchemy import SQLAlchemy
from fl... | [
"flask_jwt_extended.JWTManager",
"flask_restful.Api",
"flask_cors.CORS",
"flask.Flask",
"flask_app.models.RevokedTokenModel.is_jti_blacklisted",
"flask_mail.Mail",
"flask_sqlalchemy.SQLAlchemy",
"flask_migrate.Migrate",
"flask.logging.default_handler.setFormatter"
] | [((387, 399), 'flask_sqlalchemy.SQLAlchemy', 'SQLAlchemy', ([], {}), '()\n', (397, 399), False, 'from flask_sqlalchemy import SQLAlchemy\n'), ((406, 418), 'flask_jwt_extended.JWTManager', 'JWTManager', ([], {}), '()\n', (416, 418), False, 'from flask_jwt_extended import JWTManager\n'), ((426, 432), 'flask_mail.Mail', '... |
import datetime
import pytest
import os
import traceback
import click
from wandb import __version__
from wandb import api as wandb_api
from wandb import cli
from .utils import runner, git_repo
from .api_mocks import *
import netrc
import signal
import time
import six
import time
import whaaaaat
import yaml
import git
i... | [
"imp.reload",
"pytest.mark.teams",
"pytest.mark.updateAvailable",
"os.mkdir",
"os.getpid",
"wandb.board.app.graphql.loader.load",
"traceback.print_tb",
"os.path.realpath",
"yaml.dump",
"os.path.exists",
"time.sleep",
"os.path.isfile",
"wandb.api.Api",
"datetime.timedelta",
"pytest.mark.s... | [((1918, 1977), 'pytest.mark.skip', 'pytest.mark.skip', ([], {'reason': '"""config reworked, fixes coming..."""'}), "(reason='config reworked, fixes coming...')\n", (1934, 1977), False, 'import pytest\n'), ((2331, 2390), 'pytest.mark.skip', 'pytest.mark.skip', ([], {'reason': '"""config reworked, fixes coming..."""'}),... |
import json
from flask import Blueprint, abort, make_response, request
from flaskr.db import get_db
bp = Blueprint("developers", __name__, url_prefix="/developers")
@bp.route("/register", methods=("POST",))
def register():
"""Register a new developer.
"""
if request.method == "POST":
body = jso... | [
"flask.Blueprint",
"flaskr.db.get_db",
"json.loads",
"flask.abort",
"flask.make_response"
] | [((108, 167), 'flask.Blueprint', 'Blueprint', (['"""developers"""', '__name__'], {'url_prefix': '"""/developers"""'}), "('developers', __name__, url_prefix='/developers')\n", (117, 167), False, 'from flask import Blueprint, abort, make_response, request\n'), ((317, 341), 'json.loads', 'json.loads', (['request.data'], {... |
import pytest
from eth.vm import forks as pyevm_forks
from evm_asm import evm_opcodes
@pytest.fixture(scope="session")
def w3():
from web3.auto.infura.mainnet import w3
yield w3
@pytest.fixture(params=[*evm_opcodes.forks()])
def fork_name(request):
yield request.param
@pytest.fixture
def fork_expect... | [
"evm_asm.evm_opcodes.forks",
"pytest.fixture"
] | [((90, 121), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""session"""'}), "(scope='session')\n", (104, 121), False, 'import pytest\n'), ((217, 236), 'evm_asm.evm_opcodes.forks', 'evm_opcodes.forks', ([], {}), '()\n', (234, 236), False, 'from evm_asm import evm_opcodes\n')] |
import sys
sys.path.insert(0, ".")
# from trimesh.exchange.obj import load_obj
import trimesh
import cv2
import numpy as np
from nara.camera import Camera
from nara.vis import Plot
from nara.rasterizing import rasterizing
camera = 10
frame = 250
person = "377"
# extri_fpath = f"data/easymocap/extri_{camera}.yml"
#... | [
"numpy.load",
"trimesh.load",
"nara.vis.Plot",
"sys.path.insert",
"nara.rasterizing.rasterizing",
"cv2.imread",
"cv2.FileStorage",
"numpy.min",
"numpy.max",
"nara.camera.Camera"
] | [((12, 35), 'sys.path.insert', 'sys.path.insert', (['(0)', '"""."""'], {}), "(0, '.')\n", (27, 35), False, 'import sys\n'), ((975, 1012), 'cv2.FileStorage', 'cv2.FileStorage', (['intri_fpath'], {'flags': '(0)'}), '(intri_fpath, flags=0)\n', (990, 1012), False, 'import cv2\n'), ((1027, 1064), 'cv2.FileStorage', 'cv2.Fil... |
from django_sqlalchemy.test import *
from django_sqlalchemy.backend import session
from apps.events.models import Owner, VenueInfo, Event
class TestValues(object):
def setup(self):
session.add_all([
Owner(name='<NAME>', phone='557-895-9687'),
Owner(name='<NAME>'),
Owner... | [
"apps.events.models.VenueInfo.objects.values",
"apps.events.models.VenueInfo.query.filter_by",
"apps.events.models.Event",
"apps.events.models.Owner.query.get",
"apps.events.models.Owner",
"apps.events.models.Owner.objects.values"
] | [((224, 266), 'apps.events.models.Owner', 'Owner', ([], {'name': '"""<NAME>"""', 'phone': '"""557-895-9687"""'}), "(name='<NAME>', phone='557-895-9687')\n", (229, 266), False, 'from apps.events.models import Owner, VenueInfo, Event\n'), ((281, 301), 'apps.events.models.Owner', 'Owner', ([], {'name': '"""<NAME>"""'}), "... |
import unittest
from models import news
Movie = movie.Movie
class NewsTest(unittest.TestCase):
'''
Test Class to test the behaviour of the News class
'''
def setUp(self):
'''
Set up method that will run before every Test
'''
self.new_news = News(1234,'Aljazera News', 'Y... | [
"unittest.main"
] | [((574, 589), 'unittest.main', 'unittest.main', ([], {}), '()\n', (587, 589), False, 'import unittest\n')] |
from collections import namedtuple
from dockerphile.errors import DockerphileError
from dockerphile.structures.add_t import ADD_t
from dockerphile.structures.arg_t import ARG_t
from dockerphile.structures.cmd_t import CMD_t
from dockerphile.structures.copy_t import COPY_t
from dockerphile.structures.entrypoint_t impor... | [
"dockerphile.errors.DockerphileError",
"collections.namedtuple"
] | [((879, 917), 'collections.namedtuple', 'namedtuple', (['"""ONBUILD"""', "['instruction']"], {}), "('ONBUILD', ['instruction'])\n", (889, 917), False, 'from collections import namedtuple\n'), ((2754, 2775), 'dockerphile.errors.DockerphileError', 'DockerphileError', (['msg'], {}), '(msg)\n', (2770, 2775), False, 'from d... |
# Generated by Django 2.2.1 on 2019-05-22 03:41
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('port_monitor', '0001_initial'),
]
operations = [
migrations.AddField(
model_name='monitortarget',
name='order',
... | [
"django.db.models.CharField",
"django.db.models.IntegerField"
] | [((334, 473), 'django.db.models.IntegerField', 'models.IntegerField', ([], {'default': '(-1)', 'help_text': '"""It will be shown in the upper position if the number is higher."""', 'verbose_name': '"""Order"""'}), "(default=-1, help_text=\n 'It will be shown in the upper position if the number is higher.',\n verb... |
#Boa:Frame:frmEmailCentralID
import wx, re
import wx.lib.buttons
from SqliteDatabase import *
import Globals
import Constants
import CommonFunctions
import DBFunctions
import EmailUtilities
import EmailMapWindow
import images
def create(parent):
return frmEmailCentralID(parent)
[wxID_FRMEMAILCE... | [
"wx.Colour",
"wx.Point",
"re.compile",
"Globals.EmailsDict.has_key",
"CommonFunctions.ShowErrorMessage",
"EmailUtilities.LookupEmailID",
"images.getMAKE2Icon",
"EmailMapWindow.WindowHolder",
"wx.BusyInfo",
"wx.MessageDialog",
"wx.FileDialog",
"wx.NewId",
"wx.Yield",
"wx.Size",
"EmailUtil... | [((730, 740), 'wx.NewId', 'wx.NewId', ([], {}), '()\n', (738, 740), False, 'import wx, re\n'), ((5336, 5410), 're.compile', 're.compile', (['"""([\\\\W]*)([A-Z0-9._%-]+@[A-Z0-9._%-]+\\\\.[A-Z]+)([\\\\W]*)"""', 're.I'], {}), "('([\\\\W]*)([A-Z0-9._%-]+@[A-Z0-9._%-]+\\\\.[A-Z]+)([\\\\W]*)', re.I)\n", (5346, 5410), False,... |
"""
This example uses the nRF24L01 as a 'fake' BLE Beacon
.. warning:: ATSAMD21 M0-based boards have memory allocation
error when loading 'fake_ble.mpy'
"""
import time
import board
from digitalio import DigitalInOut
from circuitpython_nrf24l01.fake_ble import (
chunk,
FakeBLE,
UrlServiceData,
... | [
"circuitpython_nrf24l01.fake_ble.TemperatureServiceData",
"spidev.SpiDev",
"time.sleep",
"board.SPI",
"circuitpython_nrf24l01.fake_ble.UrlServiceData",
"digitalio.DigitalInOut",
"time.monotonic",
"circuitpython_nrf24l01.rf24.address_repr",
"circuitpython_nrf24l01.fake_ble.BatteryServiceData",
"cir... | [((1180, 1213), 'circuitpython_nrf24l01.fake_ble.FakeBLE', 'FakeBLE', (['SPI_BUS', 'CSN_PIN', 'CE_PIN'], {}), '(SPI_BUS, CSN_PIN, CE_PIN)\n', (1187, 1213), False, 'from circuitpython_nrf24l01.fake_ble import chunk, FakeBLE, UrlServiceData, BatteryServiceData, TemperatureServiceData\n'), ((2321, 2341), 'circuitpython_nr... |
from typing import Dict, List, Tuple
import networkx as nx
from parchmint.component import Component
from parchmint.connection import Connection
from parchmint.target import Target
from ufssanalyzer.config import get_flowrate, get_inlets_outlets, get_pressure
from ufssanalyzer.electrical.constants import IN
from ufss... | [
"ufssanalyzer.electrical.cPoint.CPoint",
"ufssanalyzer.electrical.cPoint.CPoint.generate_CPoint_name_from_target",
"ufssanalyzer.config.get_inlets_outlets",
"ufssanalyzer.config.get_flowrate",
"ufssanalyzer.electrical.rElement.RElement.generate_relement_from_component",
"networkx.Graph",
"ufssanalyzer.e... | [((1257, 1267), 'networkx.Graph', 'nx.Graph', ([], {}), '()\n', (1265, 1267), True, 'import networkx as nx\n'), ((1888, 1908), 'ufssanalyzer.config.get_inlets_outlets', 'get_inlets_outlets', ([], {}), '()\n', (1906, 1908), False, 'from ufssanalyzer.config import get_flowrate, get_inlets_outlets, get_pressure\n'), ((361... |
from django import forms
from paikkala.models import Zone
class PrintForm(forms.Form):
zones = forms.ModelMultipleChoiceField(queryset=Zone.objects.none(), required=False)
included_numbers = forms.CharField(required=False)
excluded_numbers = forms.CharField(required=False)
exclude_reserved_seats = fo... | [
"django.forms.BooleanField",
"django.forms.CharField",
"paikkala.models.Zone.objects.none"
] | [((202, 233), 'django.forms.CharField', 'forms.CharField', ([], {'required': '(False)'}), '(required=False)\n', (217, 233), False, 'from django import forms\n'), ((257, 288), 'django.forms.CharField', 'forms.CharField', ([], {'required': '(False)'}), '(required=False)\n', (272, 288), False, 'from django import forms\n'... |
#!/usr/bin/env python
# Copyright © 2016 ButenkoMS. All rights reserved. Contacts: <<EMAIL>>
#
# 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.... | [
"help_tools.is_ok",
"help_tools.bytes_to_float",
"help_tools.bytes__to__hex_string",
"help_tools.IsOK_BlockFailed",
"help_tools.bytes_to_int",
"help_tools.is_ok_reader",
"struct.pack",
"help_tools.bytes_to_byte",
"help_tools.short_to_bytes",
"help_tools.IsOK_ContextHolder._block_list_to_str",
"I... | [((44075, 44099), 'copy.copy', 'copy.copy', (['memory_offset'], {}), '(memory_offset)\n', (44084, 44099), False, 'import copy\n'), ((44826, 44847), 'copy.copy', 'copy.copy', (['input_data'], {}), '(input_data)\n', (44835, 44847), False, 'import copy\n'), ((57069, 57090), 'copy.copy', 'copy.copy', (['input_data'], {}), ... |
import re,argparse
import os,json
import time,random
import itertools
def cal_csr(args):
with open(args.tgt_cons,'r') as load_f:
tgt_pt = json.load(load_f)
total_count = 0
copy_count = 0
with open(args.hypo,'r') as fin:
for idx, line in enumerate(fin):
if str(idx) in tgt_pt:... | [
"json.load",
"argparse.ArgumentParser"
] | [((1408, 1433), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (1431, 1433), False, 'import re, argparse\n'), ((151, 168), 'json.load', 'json.load', (['load_f'], {}), '(load_f)\n', (160, 168), False, 'import os, json\n')] |
import scrapy
from twitchtest.items import TwitchtestItem
class twitchtestSpider(scrapy.Spider):
name = "twitchtest_spider"
custom_settings = {
# custom pipeline for each spider for flexibility
'ITEM_PIPELINES': {#'twitchtest.pipelines.ValidateItemPipeline': 100,
'twitchtest.pipelines.WriteItemPipeline':... | [
"twitchtest.items.TwitchtestItem",
"scrapy.Request"
] | [((1693, 1709), 'twitchtest.items.TwitchtestItem', 'TwitchtestItem', ([], {}), '()\n', (1707, 1709), False, 'from twitchtest.items import TwitchtestItem\n'), ((1109, 1159), 'scrapy.Request', 'scrapy.Request', (['url'], {'callback': 'self.parse_each_page'}), '(url, callback=self.parse_each_page)\n', (1123, 1159), False,... |
# -*- coding: utf-8 -*-
"""
Created on Sun Mar 8 18:46:24 2020
@author: hulsed
"""
import sys
sys.path.append('../')
from eps import EPS
import fmdtools.faultsim.propagate as propagate
import fmdtools.resultdisp as rd
mdl= EPS()
rd.graph.show(mdl.bipartite, gtype='bipartite')
endresults,resgraph, mdlhists = propaga... | [
"sys.path.append",
"fmdtools.faultsim.propagate.one_fault",
"fmdtools.resultdisp.process.avgdegtimeheatmap",
"fmdtools.resultdisp.process.hists",
"fmdtools.resultdisp.graph.show",
"eps.EPS",
"fmdtools.resultdisp.tabulate.summary",
"fmdtools.faultsim.propagate.single_faults"
] | [((96, 118), 'sys.path.append', 'sys.path.append', (['"""../"""'], {}), "('../')\n", (111, 118), False, 'import sys\n'), ((226, 231), 'eps.EPS', 'EPS', ([], {}), '()\n', (229, 231), False, 'from eps import EPS\n'), ((232, 279), 'fmdtools.resultdisp.graph.show', 'rd.graph.show', (['mdl.bipartite'], {'gtype': '"""biparti... |
from flask import Blueprint
bp = Blueprint('web', __name__)
from app.web import routes, forms
| [
"flask.Blueprint"
] | [((34, 60), 'flask.Blueprint', 'Blueprint', (['"""web"""', '__name__'], {}), "('web', __name__)\n", (43, 60), False, 'from flask import Blueprint\n')] |
from math import sqrt
"""
Se tienen unos puntos conocidos (Balizas) con posiciones (X,Y) también conocidas,
de repente aparece un punto nuevo (Bracelet) con posición (X,Y) desconocida
y se necesita determinar la posición (X,Y) de ese nuevo punto,
los unicos datos que se otorgan son la dsitancia de este nuevo punto a... | [
"math.sqrt"
] | [((2993, 3010), 'math.sqrt', 'sqrt', (['denominador'], {}), '(denominador)\n', (2997, 3010), False, 'from math import sqrt\n')] |
# -*- coding: utf-8 -*-
"""A collection of tools for analyzing the data from the Gaia satellite.
Code modified from project written by <NAME>
The description below follows the order in which these tools should be used.
get_mean_pm.py:
A small module providing the eponymous routine for computing the mean proper
... | [
"warnings.warn",
"argparse.ArgumentParser"
] | [((6211, 6356), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""get_globular_clusters"""', 'add_help': '(~inheritable)', 'conflict_handler': "('resolve' if ~inheritable else 'error')"}), "(description='get_globular_clusters', add_help=~\n inheritable, conflict_handler='resolve' if ~inh... |
import numpy as np
import cv2
from scipy import io
from scipy import ndimage
import math
import json
if __name__ == "__main__":
seriesNum = '007'
testDate = '0523'
cropNum = 1
constraint_rgb = cv2.imread('./'+ testDate +'/pieces/const' + seriesNum + 'c' + str(cropNum) + '.png')
constraint = cv2.i... | [
"cv2.waitKey",
"cv2.imshow"
] | [((830, 861), 'cv2.imshow', 'cv2.imshow', (['"""c"""', 'constraint_rgb'], {}), "('c', constraint_rgb)\n", (840, 861), False, 'import cv2\n'), ((866, 880), 'cv2.waitKey', 'cv2.waitKey', (['(0)'], {}), '(0)\n', (877, 880), False, 'import cv2\n')] |
import bisect
import sys
import math
from collections import defaultdict, deque
sys.setrecursionlimit(10 ** 6)
stdin = sys.stdin
INF = float('inf')
ni = lambda: int(ns())
na = lambda: list(map(int, stdin.readline().split()))
ns = lambda: stdin.readline().strip()
def prime_factor(x):
res = []
for i in range(... | [
"sys.setrecursionlimit",
"math.sqrt"
] | [((81, 111), 'sys.setrecursionlimit', 'sys.setrecursionlimit', (['(10 ** 6)'], {}), '(10 ** 6)\n', (102, 111), False, 'import sys\n'), ((327, 339), 'math.sqrt', 'math.sqrt', (['x'], {}), '(x)\n', (336, 339), False, 'import math\n')] |
import argparse
import joblib
import os
import numpy as np
import pandas as pd
# sklearn
from sklearn.compose import ColumnTransformer
from sklearn.compose import make_column_selector as selector
from sklearn.pipeline import Pipeline
from sklearn.impute import SimpleImputer
from sklearn.experimental import enable_iter... | [
"sklearn.impute.SimpleImputer",
"sklearn.preprocessing.StandardScaler",
"argparse.ArgumentParser",
"os.makedirs",
"sklearn.compose.make_column_selector",
"sklearn.model_selection.train_test_split",
"azureml.core.run.Run.get_context",
"joblib.dump",
"numpy.float",
"sklearn.preprocessing.OneHotEncod... | [((969, 994), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (992, 994), False, 'import argparse\n'), ((1659, 1676), 'azureml.core.run.Run.get_context', 'Run.get_context', ([], {}), '()\n', (1674, 1676), False, 'from azureml.core.run import Run\n'), ((2232, 2259), 'numpy.array', 'np.array', (["... |
# modu
# Copyright (c) 2006-2010 <NAME>
# http://modu.bubblehouse.org
#
#
# See LICENSE for details
"""
ISite implementors and sample resource classes used in the testing framework.
Since the ISite implementors don't actually use real (or even valid)
hostnames, none of these sites should ever activate in normal use.
... | [
"zope.interface.classProvides",
"zope.interface.implements"
] | [((579, 608), 'zope.interface.implements', 'implements', (['resource.IContent'], {}), '(resource.IContent)\n', (589, 608), False, 'from zope.interface import classProvides, implements\n'), ((1210, 1248), 'zope.interface.implements', 'implements', (['resource.IResourceDelegate'], {}), '(resource.IResourceDelegate)\n', (... |
from random import Random
from Environment import Environnement
import defines
class Agent:
def __init__(self, player_num):
self.player_num = player_num
self.env = Environnement(player_num)
def get_action(self, state):
pass
def do_action(self, action):
pass
def get_state(self):
pass
class Rand... | [
"Environment.Environnement",
"random.Random",
"time.sleep"
] | [((171, 196), 'Environment.Environnement', 'Environnement', (['player_num'], {}), '(player_num)\n', (184, 196), False, 'from Environment import Environnement\n'), ((415, 440), 'Environment.Environnement', 'Environnement', (['player_num'], {}), '(player_num)\n', (428, 440), False, 'from Environment import Environnement\... |
import sys # запуск окна
import os # поиск файла
import MySQLdb # библиотека для работы с MySQL
import igraph # библиотека для работы с графами
# import numpy as np # формирование случайной последовательности (если много систем и нужно каждой задать цвет)
from my_graph import my_indicator, my_graph, syst_ind # фу... | [
"my_graph.syst_ind",
"PyQt5.QtGui.QIcon",
"os.path.abspath",
"MySQLdb.connect",
"PyQt5.QtWidgets.QMainWindow.__init__",
"my_graph.my_graph",
"igraph.Graph",
"PyQt5.QtWidgets.QCheckBox",
"PyQt5.uic.loadUi",
"PyQt5.QtWidgets.QVBoxLayout",
"PyQt5.QtWidgets.QFileDialog.getSaveFileName",
"PyQt5.QtW... | [((31139, 31161), 'PyQt5.QtWidgets.QApplication', 'QApplication', (['sys.argv'], {}), '(sys.argv)\n', (31151, 31161), False, 'from PyQt5.QtWidgets import QMainWindow, QFileDialog, QApplication, QMessageBox, QVBoxLayout\n'), ((809, 835), 'PyQt5.QtWidgets.QMainWindow.__init__', 'QMainWindow.__init__', (['self'], {}), '(s... |
#!/usr/bin/env python
# coding=utf-8
'''
Author:<NAME>
Date:Thu 09 Feb 2017 04:08:17 PM CST
Info:
'''
#!/usr/bin/env python
import roslib
import rospy
import tf
if __name__ == '__main__':
target_x = -0.5
target_y = -5
rospy.init_node('target2worldbr')
br = tf.TransformBroadcaster()
rate = ... | [
"rospy.Time.now",
"tf.TransformBroadcaster",
"rospy.Rate",
"rospy.get_param",
"rospy.is_shutdown",
"rospy.init_node"
] | [((235, 268), 'rospy.init_node', 'rospy.init_node', (['"""target2worldbr"""'], {}), "('target2worldbr')\n", (250, 268), False, 'import rospy\n'), ((283, 308), 'tf.TransformBroadcaster', 'tf.TransformBroadcaster', ([], {}), '()\n', (306, 308), False, 'import tf\n'), ((320, 335), 'rospy.Rate', 'rospy.Rate', (['(100)'], {... |
#!/usr/bin/python3.7
import argparse, json, gc, matplotlib, numpy, os, random, sys
import tensorflow, tensorly, sklearn.linear_model
import tensorflow.keras as keras
tensorflow.config.experimental.set_visible_devices (devices=[], device_type='GPU')
matplotlib.use ('Agg')
import matplotlib.pyplot
import scipy.cluster.h... | [
"numpy.absolute",
"matplotlib.pyplot.yscale",
"os.remove",
"tensorflow.keras.layers.MaxPooling2D",
"argparse.ArgumentParser",
"tensorflow.keras.layers.Reshape",
"tensorflow.keras.layers.Dense",
"numpy.sum",
"tensorly.kruskal_tensor.kruskal_to_tensor",
"random.shuffle",
"numpy.random.random_sampl... | [((167, 253), 'tensorflow.config.experimental.set_visible_devices', 'tensorflow.config.experimental.set_visible_devices', ([], {'devices': '[]', 'device_type': '"""GPU"""'}), "(devices=[], device_type=\n 'GPU')\n", (217, 253), False, 'import tensorflow, tensorly, sklearn.linear_model\n'), ((250, 271), 'matplotlib.us... |
#!/usr/bin/env python3
"""tests for blastomatic.py"""
import csv
import hashlib
import os
import random
import re
import string
from subprocess import getstatusoutput, getoutput
from random import shuffle
prg = './blastomatic.py'
hits1 = 'hits1.tab'
hits2 = 'hits2.tab'
centroids = 'centroids.csv'
# ----------------... | [
"os.remove",
"csv.DictReader",
"random.choices",
"re.match",
"os.path.isfile"
] | [((1361, 1380), 'os.path.isfile', 'os.path.isfile', (['err'], {}), '(err)\n', (1375, 1380), False, 'import os\n'), ((1898, 1922), 'os.path.isfile', 'os.path.isfile', (['out_file'], {}), '(out_file)\n', (1912, 1922), False, 'import os\n'), ((435, 494), 'random.choices', 'random.choices', (['(string.ascii_uppercase + str... |
import json
import random
import string
from os.path import exists
from resources.logger import createLogger
# File where the key-value pairs will be stored for persistence
file_path = "/app/store/KeyValue.json"
# Creating logger
LOGGER = createLogger()
class HelperFunction:
"""
This class contains multiple... | [
"json.dump",
"json.load",
"os.path.exists",
"random.choice",
"resources.logger.createLogger"
] | [((241, 255), 'resources.logger.createLogger', 'createLogger', ([], {}), '()\n', (253, 255), False, 'from resources.logger import createLogger\n'), ((1230, 1247), 'os.path.exists', 'exists', (['file_path'], {}), '(file_path)\n', (1236, 1247), False, 'from os.path import exists\n'), ((2190, 2225), 'random.choice', 'rand... |
"""Voice and Photo simple conversion with bot
"""
import asyncio
import base64
from balebot.filters import *
from balebot.handlers import MessageHandler
from balebot.models.messages import *
from balebot.updater import Updater
# A token you give from BotFather when you create your bot set below
updater = Updater(toke... | [
"asyncio.get_event_loop"
] | [((368, 392), 'asyncio.get_event_loop', 'asyncio.get_event_loop', ([], {}), '()\n', (390, 392), False, 'import asyncio\n')] |
from datetime import datetime
import logging
from typing import Tuple
from unittest.mock import MagicMock, call
from cidc_api.models import (
Users,
DownloadableFiles,
TrialMetadata,
Permissions,
CIDCRole,
)
from cidc_api.config.settings import GOOGLE_DATA_BUCKET
from cidc_api.resources.upload_jobs... | [
"cidc_api.models.DownloadableFiles.find_by_id",
"unittest.mock.MagicMock",
"cidc_api.models.TrialMetadata",
"datetime.datetime.now",
"cidc_api.models.Permissions",
"cidc_api.resources.upload_jobs.log_multiple_errors",
"unittest.mock.call"
] | [((1310, 1373), 'cidc_api.models.TrialMetadata', 'TrialMetadata', ([], {'trial_id': 'trial_id_1', 'metadata_json': 'metadata_json'}), '(trial_id=trial_id_1, metadata_json=metadata_json)\n', (1323, 1373), False, 'from cidc_api.models import Users, DownloadableFiles, TrialMetadata, Permissions, CIDCRole\n'), ((1388, 1451... |
# Copyright (c) 2015-2018 by the parties listed in the AUTHORS
# file. All rights reserved. Use of this source code is governed
# by a BSD-style license that can be found in the LICENSE file.
from toast_planck.reproc_modules.destriping import FancyDestriperPol
from toast.mpi import MPI
from toast.tests.mpi import M... | [
"numpy.random.seed",
"toast_planck.reproc_modules.destriping.FancyDestriperPol",
"numpy.logical_and",
"numpy.sum",
"numpy.random.randn",
"numpy.abs",
"healpy.reorder",
"numpy.logical_not",
"numpy.zeros",
"numpy.ones",
"numpy.hstack",
"numpy.sin",
"numpy.arange",
"numpy.array",
"numpy.cos... | [((615, 802), 'toast_planck.reproc_modules.destriping.FancyDestriperPol', 'FancyDestriperPol', (['self.npix', 'self.nnz', 'MPI.COMM_WORLD'], {'do_offset': '(True)', 'do_gain': '(True)', 'do_pol_eff': '(True)', 'do_pol_angle': '(True)', 'ndegrade': '(4)', 'fsample': '(1.0)', 'lowpassfreq': '(0.1)', 'dir_out': '"""test""... |
# -*- coding: utf-8 -*-
import collections
from functools import partial
from StringIO import StringIO
import json
def mock_get(content):
def _mock_get(*args, **kwargs):
return MockResponse(content)
return _mock_get
class MockResponse(collections.namedtuple('Response', 'content')):
def iter_cont... | [
"StringIO.StringIO",
"collections.namedtuple",
"json.loads"
] | [((255, 300), 'collections.namedtuple', 'collections.namedtuple', (['"""Response"""', '"""content"""'], {}), "('Response', 'content')\n", (277, 300), False, 'import collections\n'), ((490, 514), 'json.loads', 'json.loads', (['self.content'], {}), '(self.content)\n', (500, 514), False, 'import json\n'), ((373, 395), 'St... |
from django.core.management.base import BaseCommand
from twitter_feed.import_tweets import ImportTweets
class Command(BaseCommand):
help = 'Import the tweets'
def handle(self, *args, **options):
importer = ImportTweets()
importer.update_tweets() | [
"twitter_feed.import_tweets.ImportTweets"
] | [((226, 240), 'twitter_feed.import_tweets.ImportTweets', 'ImportTweets', ([], {}), '()\n', (238, 240), False, 'from twitter_feed.import_tweets import ImportTweets\n')] |
from django.db import models
from django.contrib.gis.db.models import PointField
# Create your models here.
class Marker(models.Model):
name = models.CharField(max_length=255)
location = PointField()
| [
"django.db.models.CharField",
"django.contrib.gis.db.models.PointField"
] | [((149, 181), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(255)'}), '(max_length=255)\n', (165, 181), False, 'from django.db import models\n'), ((197, 209), 'django.contrib.gis.db.models.PointField', 'PointField', ([], {}), '()\n', (207, 209), False, 'from django.contrib.gis.db.models import ... |
# Copyright 2016 6WIND S.A.
# 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... | [
"vif_plug_ovs.ovs.OvsPlugin.get_veth_pair_names",
"oslo_log.log.getLogger",
"vif_plug_ovs.ovsdb.ovsdb_lib.BaseOVS",
"vif_plug_ovs.linux_net.delete_bridge",
"oslo_concurrency.processutils.ProcessExecutionError",
"vif_plug_ovs.linux_net.add_bridge_port",
"vif_plug_vhostuser_fp.common.delete_fp_dev",
"vi... | [((971, 998), 'oslo_log.log.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (988, 998), True, 'from oslo_log import log as logging\n'), ((1315, 1345), 'vif_plug_ovs.ovsdb.ovsdb_lib.BaseOVS', 'ovsdb_lib.BaseOVS', (['self.config'], {}), '(self.config)\n', (1332, 1345), False, 'from vif_plug_ovs.ovsdb... |
from rest_framework import serializers
class VehicleSerializer(serializers.Serializer):
class Meta:
swagger_schema_fields = {'example': {'vehicleType': 'truck'}}
vehicle_type = serializers.CharField(max_length=10)
class ItemSerializer(serializers.Serializer):
item_type = serializers.CharField(m... | [
"rest_framework.serializers.CharField"
] | [((196, 232), 'rest_framework.serializers.CharField', 'serializers.CharField', ([], {'max_length': '(10)'}), '(max_length=10)\n', (217, 232), False, 'from rest_framework import serializers\n'), ((297, 333), 'rest_framework.serializers.CharField', 'serializers.CharField', ([], {'max_length': '(10)'}), '(max_length=10)\n... |
# pylint: disable=redefined-outer-name,unused-import
import base64
import jwt
import uuid
import time
import pytest
from gaea.models import Users, Permissions
from gaea.rbmq import RBMQPublisher
from gaea.rbmq.utils.tests import MockRBMQConnectionManager
from cerbes.helpers import generate_jwt
@pytest.mark.paramet... | [
"uuid.uuid4",
"gaea.models.Permissions",
"time.sleep",
"pytest.raises",
"pytest.mark.parametrize",
"jwt.decode"
] | [((301, 1101), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""username, password, email, expected_code, expected_msg"""', "(('Maya', 'ILoveYouHoney1', '<EMAIL>', 200, None), ('coucou', 'coucou',\n 'coucou', 400, 'Invalid email address'), ('coucou', 'coucou',\n 'coucou@cou', 400, 'Invalid email addres... |
from random import choice
aluno01 = str(input('Primeiro aluno: '))
aluno02 = str(input('Segundo aluno: '))
aluno03 = str(input('Terceiro aluno: '))
aluno04 = str(input('Quarto aluno: '))
lista = [aluno01, aluno02, aluno03, aluno04]
print(f'O aluno escolhido foi {choice(lista)}') | [
"random.choice"
] | [((265, 278), 'random.choice', 'choice', (['lista'], {}), '(lista)\n', (271, 278), False, 'from random import choice\n')] |
# -*- coding: utf-8 -*-
# Define here the models for your scraped items
#
# See documentation in:
# https://doc.scrapy.org/en/latest/topics/items.html
from scrapy import Field, Item
class BugItem(Item):
bug_id = Field()
summary = Field()
reporter = Field()
version = Field()
class CommentItem(Item)... | [
"scrapy.Field"
] | [((220, 227), 'scrapy.Field', 'Field', ([], {}), '()\n', (225, 227), False, 'from scrapy import Field, Item\n'), ((242, 249), 'scrapy.Field', 'Field', ([], {}), '()\n', (247, 249), False, 'from scrapy import Field, Item\n'), ((265, 272), 'scrapy.Field', 'Field', ([], {}), '()\n', (270, 272), False, 'from scrapy import ... |
from app import db
from datetime import datetime
class Entry(db.Model):
__tablename__ = 'entries'
id = db.Column(db.Integer, primary_key = True)
humidity = db.Column(db.String(255))
temp = db.Column(db.String(255))
date = db.Column(db.DateTime, nullable=False,
default=datetime.utcnow)
f... | [
"app.db.String",
"app.db.create_all",
"app.db.Column"
] | [((1056, 1071), 'app.db.create_all', 'db.create_all', ([], {}), '()\n', (1069, 1071), False, 'from app import db\n'), ((112, 151), 'app.db.Column', 'db.Column', (['db.Integer'], {'primary_key': '(True)'}), '(db.Integer, primary_key=True)\n', (121, 151), False, 'from app import db\n'), ((243, 306), 'app.db.Column', 'db.... |
import os
from ament_index_python.packages import get_package_share_directory
from launch import LaunchDescription
from launch.actions import DeclareLaunchArgument
from launch.substitutions import LaunchConfiguration
from launch_ros.actions import Node
def generate_launch_description():
urdf = os.path.j... | [
"ament_index_python.packages.get_package_share_directory"
] | [((333, 382), 'ament_index_python.packages.get_package_share_directory', 'get_package_share_directory', (['"""baxter_description"""'], {}), "('baxter_description')\n", (360, 382), False, 'from ament_index_python.packages import get_package_share_directory\n')] |
import hashlib
import io
from funcy import cached_property
from dvc.hash_info import HashInfo
from dvc.istextfile import DEFAULT_CHUNK_SIZE, istextblock
from dvc.utils import dos2unix
class HashedStreamReader(io.IOBase):
PARAM_CHECKSUM = "md5"
def __init__(self, fobj):
self.fobj = fobj
sel... | [
"dvc.utils.dos2unix",
"hashlib.md5",
"dvc.istextfile.istextblock"
] | [((328, 341), 'hashlib.md5', 'hashlib.md5', ([], {}), '()\n', (339, 341), False, 'import hashlib\n'), ((807, 846), 'dvc.istextfile.istextblock', 'istextblock', (['chunk[:DEFAULT_CHUNK_SIZE]'], {}), '(chunk[:DEFAULT_CHUNK_SIZE])\n', (818, 846), False, 'from dvc.istextfile import DEFAULT_CHUNK_SIZE, istextblock\n'), ((89... |
from shutil import copy, rmtree
import os
from pathlib import Path
import sys
def delete_existing_dirs(vehicles, player_dir):
for vehicle in vehicles:
if os.path.exists(Path(player_dir, vehicle)):
rmtree(Path(player_dir, vehicle))
return None
def create_driver_dirs(drivers, player_dir, output_vehicle_dir):
... | [
"pathlib.Path",
"os.path.exists",
"os.makedirs"
] | [((381, 421), 'pathlib.Path', 'Path', (['player_dir', 'driver.car_folder_name'], {}), '(player_dir, driver.car_folder_name)\n', (385, 421), False, 'from pathlib import Path\n'), ((516, 590), 'pathlib.Path', 'Path', (['player_dir', 'driver.car_folder_name', "(driver.first + ' ' + driver.last)"], {}), "(player_dir, drive... |
from fastapi_amis_admin.amis.components import Page, PageSchema
def test_Page():
page = Page(title='标题', body='Hello World!')
page_json = r'{"type":"page","title":"\u6807\u9898","body":"Hello World!"}'
assert page.amis_json() == page_json
assert page.amis_dict() == {'type': 'page', 'title': '标题', 'bod... | [
"fastapi_amis_admin.amis.components.PageSchema",
"fastapi_amis_admin.amis.components.Page"
] | [((94, 131), 'fastapi_amis_admin.amis.components.Page', 'Page', ([], {'title': '"""标题"""', 'body': '"""Hello World!"""'}), "(title='标题', body='Hello World!')\n", (98, 131), False, 'from fastapi_amis_admin.amis.components import Page, PageSchema\n'), ((437, 443), 'fastapi_amis_admin.amis.components.Page', 'Page', ([], {... |
import pygame
import time
WIDTH, HEIGHT = 800, 600
WINDOW = pygame.display.set_mode((WIDTH, HEIGHT))
WINDOW_COLOR = (0, 0, 0)
FPS = 60
def updateWindow(*items):
WINDOW.fill(WINDOW_COLOR)
for item in items:
if item[0] == "rect":
pygame.draw.rect(WINDOW, item[1], item[2])
elif item[0... | [
"pygame.quit",
"pygame.draw.circle",
"pygame.event.get",
"pygame.display.set_mode",
"pygame.draw.rect",
"pygame.display.update",
"pygame.display.set_caption",
"pygame.time.Clock"
] | [((61, 101), 'pygame.display.set_mode', 'pygame.display.set_mode', (['(WIDTH, HEIGHT)'], {}), '((WIDTH, HEIGHT))\n', (84, 101), False, 'import pygame\n'), ((405, 428), 'pygame.display.update', 'pygame.display.update', ([], {}), '()\n', (426, 428), False, 'import pygame\n'), ((486, 505), 'pygame.time.Clock', 'pygame.tim... |
from zdppy_requests import Requests
r = Requests(port=8080, debug=True)
json_data = {
"name": "张大鹏",
"age": 22,
}
r.log.info(r.post("/", json=json_data).json())
r.log.info(r.put("/", json=json_data).json())
| [
"zdppy_requests.Requests"
] | [((41, 72), 'zdppy_requests.Requests', 'Requests', ([], {'port': '(8080)', 'debug': '(True)'}), '(port=8080, debug=True)\n', (49, 72), False, 'from zdppy_requests import Requests\n')] |
#!/usr/bin/env python
"""Unit tests for opscore.utility.html
"""
# Created 28-Jun-2008 by <NAME> (<EMAIL>)
import unittest
from html.parser import HTMLParser
import opscore.utility.html as utilHtml
class HTMLTests(unittest.TestCase):
@staticmethod
def validate(doc):
parser = HTMLParser()
par... | [
"unittest.main",
"html.parser.HTMLParser",
"opscore.utility.html.Span",
"opscore.utility.html.Div",
"opscore.utility.html.Head",
"opscore.utility.html.Body"
] | [((1514, 1529), 'unittest.main', 'unittest.main', ([], {}), '()\n', (1527, 1529), False, 'import unittest\n'), ((296, 308), 'html.parser.HTMLParser', 'HTMLParser', ([], {}), '()\n', (306, 308), False, 'from html.parser import HTMLParser\n'), ((961, 1020), 'opscore.utility.html.Head', 'utilHtml.Head', ([], {'title': '""... |
# You can use disnake or nextcord or something like this.
# (THIS EXAMPLE IS NOT TESTED. IF YOU HAVE ANY PROBLEMS - ASK DEVELOPER PLEASE)
from discord.ext import commands
from boticordpy import BoticordClient
bot = commands.Bot(command_prefix="!")
async def get_stats():
return {"servers": len(bot.guilds), "sha... | [
"boticordpy.BoticordClient",
"discord.ext.commands.Bot"
] | [((218, 250), 'discord.ext.commands.Bot', 'commands.Bot', ([], {'command_prefix': '"""!"""'}), "(command_prefix='!')\n", (230, 250), False, 'from discord.ext import commands\n'), ((447, 479), 'boticordpy.BoticordClient', 'BoticordClient', (['"""your_api_token"""'], {}), "('your_api_token')\n", (461, 479), False, 'from ... |
import cv2 # Import relevant libraries
import numpy as np
from pymouse import PyMouse
if __name__ == '__main__':
# img = cv2.imread('Landscape.jpg', 0) # Read in image
img1 = cv2.imread('LandscapeGrey.jpg',0) # Read in image
img2 = cv2.imread('LandscapeGrey2.jpg',0) # Read in image
dst2 = cv2.resize(i... | [
"cv2.waitKey",
"numpy.ones",
"pymouse.PyMouse",
"cv2.imread",
"cv2.imshow",
"cv2.resize"
] | [((185, 219), 'cv2.imread', 'cv2.imread', (['"""LandscapeGrey.jpg"""', '(0)'], {}), "('LandscapeGrey.jpg', 0)\n", (195, 219), False, 'import cv2\n'), ((246, 281), 'cv2.imread', 'cv2.imread', (['"""LandscapeGrey2.jpg"""', '(0)'], {}), "('LandscapeGrey2.jpg', 0)\n", (256, 281), False, 'import cv2\n'), ((308, 342), 'cv2.r... |
import asyncio
import configparser
import logging
import blink.blinkgenerator
import blinkenio.controller
import common.protocol as protocol
from common.service import AbstractService
from common.coordinatorclient import CoordinatorClient
class Blinkenlights(AbstractService):
def __init__(self, config):
se... | [
"common.protocol.create_message",
"configparser.ConfigParser"
] | [((1401, 1428), 'configparser.ConfigParser', 'configparser.ConfigParser', ([], {}), '()\n', (1426, 1428), False, 'import configparser\n'), ((954, 1030), 'common.protocol.create_message', 'protocol.create_message', (['protocol.MessageType.STATUS_MSG', 'protocol.Status.OK'], {}), '(protocol.MessageType.STATUS_MSG, protoc... |
from flask import Flask, render_template, request
from showmestuff import app
import requests
import time
import json
@app.route("/uptime", methods=["POST"])
def get_uptime():
if request.method == 'POST':
response = {}
urls = json.loads(request.form['urls'])
for url in u... | [
"requests.get",
"showmestuff.app.route",
"json.loads",
"json.dumps"
] | [((122, 160), 'showmestuff.app.route', 'app.route', (['"""/uptime"""'], {'methods': "['POST']"}), "('/uptime', methods=['POST'])\n", (131, 160), False, 'from showmestuff import app\n'), ((258, 290), 'json.loads', 'json.loads', (["request.form['urls']"], {}), "(request.form['urls'])\n", (268, 290), False, 'import json\n... |
import gc
from typing import Tuple
import numpy as np
import torch
def get_embed_dropout(config):
if hasattr(config, 'embd_pdrop'):
return config.embd_pdrop
if hasattr(config, 'embed_dropout'):
return config.embed_dropout
def get_embed_dim(config):
if hasattr(config, "hidden_size"):
... | [
"torch.ones",
"gc.collect",
"numpy.cumsum",
"torch.Tensor",
"torch.arange",
"torch.cuda.empty_cache",
"numpy.argwhere",
"torch.sum",
"torch.nn.Module"
] | [((1545, 1569), 'torch.cuda.empty_cache', 'torch.cuda.empty_cache', ([], {}), '()\n', (1567, 1569), False, 'import torch\n'), ((1578, 1590), 'gc.collect', 'gc.collect', ([], {}), '()\n', (1588, 1590), False, 'import gc\n'), ((1862, 1886), 'torch.cuda.empty_cache', 'torch.cuda.empty_cache', ([], {}), '()\n', (1884, 1886... |
import os
import tempfile
from tests.test_base import TestBase
from capanno_utils.repo_config import config
from capanno_utils.content_maps import make_tools_map, make_script_maps
class TestToolMaps(TestBase):
def test_make_tools_map(self):
make_tools_map(tempfile.NamedTemporaryFile().name)
retur... | [
"tempfile.NamedTemporaryFile"
] | [((271, 300), 'tempfile.NamedTemporaryFile', 'tempfile.NamedTemporaryFile', ([], {}), '()\n', (298, 300), False, 'import tempfile\n'), ((400, 429), 'tempfile.NamedTemporaryFile', 'tempfile.NamedTemporaryFile', ([], {}), '()\n', (427, 429), False, 'import tempfile\n'), ((535, 564), 'tempfile.NamedTemporaryFile', 'tempfi... |
from django.shortcuts import render
from rest_framework import status
from rest_framework.response import Response
from .serializers import(
CreateBlogSerializer,
BlogSerializer,
CreateCommentSerializer,
CommentSerializer,
CreateSubCommentSerializer,
SubCommentSerializer,
ActionBlogSerializ... | [
"rest_framework.response.Response"
] | [((6265, 6313), 'rest_framework.response.Response', 'Response', (['{}'], {'status': 'status.HTTP_400_BAD_REQUEST'}), '({}, status=status.HTTP_400_BAD_REQUEST)\n', (6273, 6313), False, 'from rest_framework.response import Response\n'), ((10481, 10529), 'rest_framework.response.Response', 'Response', (['{}'], {'status': ... |
from os import PathLike
from pathlib import Path
from typing import Dict, Optional, Union
import sass
from sphinx.application import Sphinx
from sphinx.util import logging
logger = logging.getLogger(__name__)
Targets = Dict[PathLike, PathLike]
def configure_path(
conf_dir: str,
src: Optional[Unio... | [
"sphinx.util.logging.getLogger",
"pathlib.Path"
] | [((184, 211), 'sphinx.util.logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (201, 211), False, 'from sphinx.util import logging\n'), ((387, 401), 'pathlib.Path', 'Path', (['conf_dir'], {}), '(conf_dir)\n', (391, 401), False, 'from pathlib import Path\n'), ((450, 459), 'pathlib.Path', 'Path',... |
import re
class ParseCruncherValidation:
re_platform_instance = re.compile(r'User:\s+(.*)\s+\((.*)\)')
re_constant = re.compile(r'Constant:\s+(?:Custom - )?(.*)')
re_algorithm = re.compile(r'Algorithm : "(.*)"')
re_name_short = re.compile(r'NameShort : "(.*)"')
re_name_long = re.compile(r'NameLong... | [
"re.compile"
] | [((70, 111), 're.compile', 're.compile', (['"""User:\\\\s+(.*)\\\\s+\\\\((.*)\\\\)"""'], {}), "('User:\\\\s+(.*)\\\\s+\\\\((.*)\\\\)')\n", (80, 111), False, 'import re\n'), ((127, 172), 're.compile', 're.compile', (['"""Constant:\\\\s+(?:Custom - )?(.*)"""'], {}), "('Constant:\\\\s+(?:Custom - )?(.*)')\n", (137, 172), ... |
"""
Authors: <NAME>, <NAME>
Licensed under the CC BY-NC 4.0 license (https://creativecommons.org/licenses/by-nc/4.0/)
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
import os
import torchvision.models as models
TYPE_CLASSES = {
'chair': {'num_classes': 13, 'num_heads': 1},
'table': {'nu... | [
"torchvision.models.resnet18",
"torch.nn.ReLU",
"os.getcwd",
"torch.load",
"torch.nn.Conv2d",
"os.path.exists",
"torchvision.models.resnet50",
"torch.nn.Linear",
"torch.nn.Identity",
"torch.nn.functional.normalize"
] | [((3575, 3592), 'torchvision.models.resnet18', 'models.resnet18', ([], {}), '()\n', (3590, 3592), True, 'import torchvision.models as models\n'), ((3614, 3678), 'torch.nn.Conv2d', 'nn.Conv2d', (['(1)', '(64)'], {'kernel_size': '(7)', 'stride': '(2)', 'padding': '(3)', 'bias': '(False)'}), '(1, 64, kernel_size=7, stride... |
import random
import numpy as np
from environment import Env
from keras.layers.core import Dense
from keras.optimizers import Adam
from keras.models import Sequential
EPISODES = 1000
class DeepSARSAgent:
def __init__(self):
self.load_model = False
# actions which agent can do
self.action_... | [
"environment.Env",
"numpy.reshape"
] | [((855, 860), 'environment.Env', 'Env', ([], {}), '()\n', (858, 860), False, 'from environment import Env\n'), ((1054, 1080), 'numpy.reshape', 'np.reshape', (['state', '[1, 15]'], {}), '(state, [1, 15])\n', (1064, 1080), True, 'import numpy as np\n'), ((1364, 1395), 'numpy.reshape', 'np.reshape', (['next_state', '[1, 1... |
import sqlite3
import os
def delete_id(id_delete):
with sqlite3.connect("products.sqlite3") as session:
cursor = session.cursor()
cursor.execute(
'''DELETE FROM user
WHERE id=?;''',
(id_delete))
session.commit()
return cursor.fetchone()
def update_tabbl... | [
"os.path.isfile",
"sqlite3.connect"
] | [((62, 97), 'sqlite3.connect', 'sqlite3.connect', (['"""products.sqlite3"""'], {}), "('products.sqlite3')\n", (77, 97), False, 'import sqlite3\n'), ((352, 387), 'sqlite3.connect', 'sqlite3.connect', (['"""products.sqlite3"""'], {}), "('products.sqlite3')\n", (367, 387), False, 'import sqlite3\n'), ((646, 681), 'sqlite3... |
'''
Gauged - https://github.com/chriso/gauged
Copyright 2014 (c) <NAME> <<EMAIL>>
'''
import re
from distutils.core import setup, Extension
cflags = ['-O3', '-std=c99', '-pedantic', '-Wall', '-Wextra', '-pthread']
gauged = Extension('libgauged',
sources=[
'lib/%s.c' % src fo... | [
"distutils.core.Extension",
"distutils.core.setup"
] | [((226, 393), 'distutils.core.Extension', 'Extension', (['"""libgauged"""'], {'sources': "[('lib/%s.c' % src) for src in ('array', 'hash', 'sort', 'map', 'writer')]", 'include_dirs': "['include']", 'extra_compile_args': 'cflags'}), "('libgauged', sources=[('lib/%s.c' % src) for src in ('array',\n 'hash', 'sort', 'ma... |
import json
import logging
import os
from sqlalchemy import create_engine
from botocore.vendored import requests
from models import Session, SlackTeams
logger = logging.getLogger()
logger.setLevel(logging.INFO)
CLIENT_ID = os.getenv('CLIENT_ID')
CLIENT_SECRET = os.getenv('CLIENT_SECRET')
DOMAIN_NAME = os.getenv('DO... | [
"models.Session.configure",
"json.dumps",
"botocore.vendored.requests.post",
"models.SlackTeams",
"models.Session",
"sqlalchemy.create_engine",
"os.getenv",
"logging.getLogger"
] | [((164, 183), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (181, 183), False, 'import logging\n'), ((227, 249), 'os.getenv', 'os.getenv', (['"""CLIENT_ID"""'], {}), "('CLIENT_ID')\n", (236, 249), False, 'import os\n'), ((266, 292), 'os.getenv', 'os.getenv', (['"""CLIENT_SECRET"""'], {}), "('CLIENT_SECRET... |
import tkinter as tk
import GUIConstants
class MainFrame(tk.Frame):
def __init__(self, parent, number):
tk.Frame.__init__(self, parent)
label = tk.Label(self, text="Process Resolver", font=GUIConstants.LARGE_FONT)
self.add_button = tk.Button(self, text="Add Process")
self.del_button... | [
"tkinter.Button",
"tkinter.Label",
"tkinter.Listbox",
"tkinter.Frame.__init__"
] | [((117, 148), 'tkinter.Frame.__init__', 'tk.Frame.__init__', (['self', 'parent'], {}), '(self, parent)\n', (134, 148), True, 'import tkinter as tk\n'), ((165, 234), 'tkinter.Label', 'tk.Label', (['self'], {'text': '"""Process Resolver"""', 'font': 'GUIConstants.LARGE_FONT'}), "(self, text='Process Resolver', font=GUICo... |
# -*- coding: utf-8 -*-
"""
Module to interact with a Delft IVVI DAC module.
Uses the pySerial module to communicate with the device.
Assumes the address is of the form COM<xx> where
<xx> is the relevant port.
We assume that the IVVI rack has 16 DACs.
Script based on: http://qtwork.tudelft.nl/~schouten/ivvi/doc-d5/rs2... | [
"serial.Serial"
] | [((705, 720), 'serial.Serial', 'serial.Serial', ([], {}), '()\n', (718, 720), False, 'import serial\n')] |
import json
import azure.functions as func
def main(req: func.HttpRequest, messageJSON) -> func.HttpResponse:
message = json.loads(messageJSON)
return func.HttpResponse(f"Table row: {messageJSON}")
| [
"azure.functions.HttpResponse",
"json.loads"
] | [((127, 150), 'json.loads', 'json.loads', (['messageJSON'], {}), '(messageJSON)\n', (137, 150), False, 'import json\n'), ((162, 208), 'azure.functions.HttpResponse', 'func.HttpResponse', (['f"""Table row: {messageJSON}"""'], {}), "(f'Table row: {messageJSON}')\n", (179, 208), True, 'import azure.functions as func\n')] |
import falcon_rpc
class Test:
"""``test`` method family """
def ok(self, req):
# /test.ok
req.resp_body = {'foo': 'bar'}
def error(self, req):
# /test.error
# can raise an error at anytime
raise falcon_rpc.RPCError('dummy_error_code')
def fatal(self, req):
... | [
"falcon_rpc.RPCError",
"falcon_rpc.RPC",
"falcon_rpc.RPCRedirect"
] | [((1058, 1074), 'falcon_rpc.RPC', 'falcon_rpc.RPC', ([], {}), '()\n', (1072, 1074), False, 'import falcon_rpc\n'), ((251, 290), 'falcon_rpc.RPCError', 'falcon_rpc.RPCError', (['"""dummy_error_code"""'], {}), "('dummy_error_code')\n", (270, 290), False, 'import falcon_rpc\n'), ((822, 869), 'falcon_rpc.RPCRedirect', 'fal... |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# Copyright (c) 2021 Idiap Research Institute, http://www.idiap.ch/
# Written by <NAME> <<EMAIL>>
#
# System imports.
import arff
import argparse
import glob
import logging
import os
import shutil
import subprocess
import sys
import tempfile
from typing import List, Tu... | [
"os.path.abspath",
"logging.debug",
"argparse.ArgumentParser",
"logging.basicConfig",
"idiaptts.misc.normalisation.MeanStdDevExtractor.MeanStdDevExtractor",
"os.path.basename",
"subprocess.check_output",
"numpy.asarray",
"tempfile.mkdtemp",
"shutil.rmtree",
"os.path.join",
"sys.exit"
] | [((4757, 4796), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO'}), '(level=logging.INFO)\n', (4776, 4796), False, 'import logging\n'), ((4811, 4914), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '__doc__', 'formatter_class': 'argparse.RawDescriptionHelpFormatter... |
import numpy as np
def bit_get(val, idx):
return (val >> idx) & 1
def create_generic_colormap(n):
colormap = np.zeros((n, 3), dtype=int)
ind = np.arange(n, dtype=int)
for shift in reversed(range(8)):
for channel in range(3):
colormap[:, channel] |= bit_get(ind, channel) << shift
... | [
"numpy.zeros",
"numpy.arange"
] | [((117, 144), 'numpy.zeros', 'np.zeros', (['(n, 3)'], {'dtype': 'int'}), '((n, 3), dtype=int)\n', (125, 144), True, 'import numpy as np\n'), ((155, 178), 'numpy.arange', 'np.arange', (['n'], {'dtype': 'int'}), '(n, dtype=int)\n', (164, 178), True, 'import numpy as np\n')] |
import heapq
import time
import uuid
import asyncio
class Timer:
def __init__(self):
self.timerList = list()
self.d = dict()
# ratio:间隔,runSize:次数
def addTimer(self, func, args: list, ratio=1, runSize=-1):
if ratio == 0:
raise
while (uid := uuid.uuid4()) in sel... | [
"uuid.uuid4",
"asyncio.get_event_loop",
"heapq.heappush",
"heapq.heappop",
"time.time"
] | [((361, 372), 'time.time', 'time.time', ([], {}), '()\n', (370, 372), False, 'import time\n'), ((458, 501), 'heapq.heappush', 'heapq.heappush', (['self.timerList', 'self.d[uid]'], {}), '(self.timerList, self.d[uid])\n', (472, 501), False, 'import heapq\n'), ((786, 797), 'time.time', 'time.time', ([], {}), '()\n', (795,... |
import json
from decimal import Decimal
import pytest
from vial.json import NativeJson
class TestNativeJson:
@staticmethod
def test_dumps() -> None:
data = {"hello": "world"}
assert NativeJson.dumps(data) == json.dumps(data)
@staticmethod
def test_loads() -> None:
data = '{"... | [
"vial.json.NativeJson.loads",
"json.loads",
"decimal.Decimal",
"vial.json.NativeJson.dumps",
"json.dumps"
] | [((476, 517), 'vial.json.NativeJson.dumps', 'NativeJson.dumps', (["{'one', 'two', 'three'}"], {}), "({'one', 'two', 'three'})\n", (492, 517), False, 'from vial.json import NativeJson\n'), ((210, 232), 'vial.json.NativeJson.dumps', 'NativeJson.dumps', (['data'], {}), '(data)\n', (226, 232), False, 'from vial.json import... |
# NumCosmo implementation of CLMModeling
import gi
gi.require_version('NumCosmo', '1.0')
gi.require_version('NumCosmoMath', '1.0')
from gi.repository import NumCosmo as Nc
from gi.repository import NumCosmoMath as Ncm
import math
import numpy as np
from .parent_class import CLMMCosmology
__all__ = []
class NumCos... | [
"gi.repository.NumCosmo.Distance.new",
"gi.repository.NumCosmo.HICosmo.new_from_name",
"gi.require_version",
"numpy.vectorize"
] | [((52, 89), 'gi.require_version', 'gi.require_version', (['"""NumCosmo"""', '"""1.0"""'], {}), "('NumCosmo', '1.0')\n", (70, 89), False, 'import gi\n'), ((90, 131), 'gi.require_version', 'gi.require_version', (['"""NumCosmoMath"""', '"""1.0"""'], {}), "('NumCosmoMath', '1.0')\n", (108, 131), False, 'import gi\n'), ((10... |
from adminsortable.fields import SortableForeignKey
from adminsortable.models import SortableMixin
from django.conf import settings
from django.core.validators import MinValueValidator
from django.db import models
from django.db.models import Q
from django.urls import reverse
from django.utils.functional import cached_... | [
"django.db.models.TextField",
"django.db.models.URLField",
"django.db.models.ManyToManyField",
"django.db.models.BigIntegerField",
"django.utils.translation.gettext_lazy",
"django.db.models.CharField",
"django.db.models.ForeignKey",
"django.db.models.PositiveIntegerField",
"django.core.validators.Mi... | [((506, 550), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(50)', 'unique': '(True)'}), '(max_length=50, unique=True)\n', (522, 550), False, 'from django.db import models\n'), ((692, 736), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(50)', 'unique': '(True)'}), '(max... |
from unittest.mock import Mock
import pytest
from pi.types import Service
from pi.utils import SequenceMap
from pi.ui.custom import _required_services
def mk_service(name, requires):
return Service(name=name, image=None, requires=requires)
def test_required_services():
env = Mock(services=SequenceMap([
... | [
"pi.types.Service",
"unittest.mock.Mock",
"pytest.raises",
"pi.utils.SequenceMap",
"pi.ui.custom._required_services"
] | [((198, 247), 'pi.types.Service', 'Service', ([], {'name': 'name', 'image': 'None', 'requires': 'requires'}), '(name=name, image=None, requires=requires)\n', (205, 247), False, 'from pi.types import Service\n'), ((449, 469), 'unittest.mock.Mock', 'Mock', ([], {'requires': "['c']"}), "(requires=['c'])\n", (453, 469), Fa... |
from collections import defaultdict, OrderedDict
from pprint import pformat
from dictdiffer import DictDiffer
from miniworld.model.network.linkqualitymodels import LinkQualityConstants
from miniworld import singletons
from miniworld.Scenario import scenario_config
from miniworld.log import log
from miniworld.manageme... | [
"miniworld.Scenario.scenario_config.is_network_links_auto_ipv4",
"dictdiffer.DictDiffer",
"miniworld.model.network.connections.ConnectionStore.ConnectionStore",
"miniworld.singletons.network_backend.get_network_provisioner",
"networkx.readwrite.json_graph.node_link_data",
"miniworld.Scenario.scenario_conf... | [((958, 1014), 'miniworld.util.PathUtil.get_log_file_path', 'PathUtil.get_log_file_path', (['"""network_check_commands.txt"""'], {}), "('network_check_commands.txt')\n", (984, 1014), False, 'from miniworld.util import PathUtil\n'), ((21509, 21543), 'miniworld.testing.init_testing_environment', 'testing.init_testing_env... |
#!/usr/bin/python3
import datetime
day_values = {'monday': 0,
'tuesday': 1,
'wednesday': 2,
'thursday': 3,
'friday': 4,
'saturday': 5,
'sunday': 6}
DATE_STR_FMT = '%B %d %Y'
def convert_str_to_date(date_str):
"""Converts a strin... | [
"datetime.datetime.strptime",
"datetime.datetime.now",
"datetime.date.today",
"datetime.timedelta"
] | [((1105, 1128), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (1126, 1128), False, 'import datetime\n'), ((1560, 1590), 'datetime.timedelta', 'datetime.timedelta', (['days_ahead'], {}), '(days_ahead)\n', (1578, 1590), False, 'import datetime\n'), ((404, 425), 'datetime.date.today', 'datetime.date.... |
import sys, inspect
from cast.ParserCommon import *
def whoami():
return inspect.stack()[1][3]
def whosdaddy():
return inspect.stack()[2][3]
def parse( iterator, entry ):
p = pp_Parser()
return p.parse(iterator, entry)
class pp_ExpressionParser__expr:
def __init__(self, parent):
self.__dict__.update(local... | [
"inspect.stack"
] | [((75, 90), 'inspect.stack', 'inspect.stack', ([], {}), '()\n', (88, 90), False, 'import sys, inspect\n'), ((123, 138), 'inspect.stack', 'inspect.stack', ([], {}), '()\n', (136, 138), False, 'import sys, inspect\n')] |
from fastapi import APIRouter, Body
from fastapi.encoders import jsonable_encoder
from ..database import (
add_meme,
delete_meme,
retrieve_meme,
retrieve_memes,
update_meme,
)
from ..models.meme import (
MemeSchema,
UpdateMemeModel,
ResponseModel,
ErrorResponseModel,
)
router = A... | [
"fastapi.Body",
"fastapi.encoders.jsonable_encoder",
"fastapi.APIRouter"
] | [((319, 330), 'fastapi.APIRouter', 'APIRouter', ([], {}), '()\n', (328, 330), False, 'from fastapi import APIRouter, Body\n'), ((452, 461), 'fastapi.Body', 'Body', (['...'], {}), '(...)\n', (456, 461), False, 'from fastapi import APIRouter, Body\n'), ((475, 497), 'fastapi.encoders.jsonable_encoder', 'jsonable_encoder',... |
from kivymd.app import MDApp
from kivymd.theming import ThemeManager
from kivy.lang import Builder
class MainApp(MDApp):
def build(self):
self.theme_cls.Theme_style = 'Dark'
self.theme_cls.primary_palette = 'BlueGray'
return Builder.load_file('main.kv')
MainApp().run() | [
"kivy.lang.Builder.load_file"
] | [((254, 282), 'kivy.lang.Builder.load_file', 'Builder.load_file', (['"""main.kv"""'], {}), "('main.kv')\n", (271, 282), False, 'from kivy.lang import Builder\n')] |
# author: <NAME> github.com/pgalatic
#
# Manages GUI for default subreddits and custom subreddits
#
# extra junk to make sure we can import from a parent directory
from os import sys, path
sys.path.append(path.dirname(path.dirname(path.abspath(__file__))))
from reddit import Reddit
from gui.tooltip import Tooltip
imp... | [
"tkinter.StringVar",
"tkinter.Checkbutton",
"os.path.abspath",
"tkinter.Entry",
"reddit.Reddit",
"tkinter.messagebox.showinfo",
"tkinter.Frame",
"tkinter.IntVar",
"tkinter.Label",
"gui.tooltip.Tooltip"
] | [((1095, 1110), 'tkinter.Frame', 'tk.Frame', (['frame'], {}), '(frame)\n', (1103, 1110), True, 'import tkinter as tk\n'), ((1189, 1268), 'tkinter.Label', 'tk.Label', (['subreddits_frame'], {'text': '"""Select which subreddits to pull images from."""'}), "(subreddits_frame, text='Select which subreddits to pull images f... |
from .models import Category, Brand, ProductAttribute, Product
from django.db.models import Min, Max
from .utils import store_open
def get_filters(request):
is_open = store_open()
products = Product.objects.all() # NEW
categories = Category.objects.all()
brands = Brand.objects.all()
min_max_price... | [
"django.db.models.Max",
"django.db.models.Min"
] | [((367, 379), 'django.db.models.Min', 'Min', (['"""price"""'], {}), "('price')\n", (370, 379), False, 'from django.db.models import Min, Max\n'), ((381, 393), 'django.db.models.Max', 'Max', (['"""price"""'], {}), "('price')\n", (384, 393), False, 'from django.db.models import Min, Max\n')] |
"""
README
======
This file contains Python codes.
======
"""
""" Store common attributes of a stock option """
import math
class StockOption(object):
def __init__(self, S0, K, r, T, N, params):
self.S0 = S0
self.K = K
self.r = r
self.T = T
self.N = max(1, N) # Ensure N h... | [
"math.exp"
] | [((953, 988), 'math.exp', 'math.exp', (['(-(r - self.div) * self.dt)'], {}), '(-(r - self.div) * self.dt)\n', (961, 988), False, 'import math\n')] |
import time
import requests
import json
header = {
"Accept": "application/json",
"Content-Type": "application/json",
}
info = {
"url_log": "http://chatbot-backend:5000/session/test",
"url_extract": "http://chatbot-backend:5000/session/test",
"url_request_qr_code": "http://chatbot-backend:5000/sessio... | [
"json.dumps",
"time.sleep"
] | [((625, 638), 'time.sleep', 'time.sleep', (['(1)'], {}), '(1)\n', (635, 638), False, 'import time\n'), ((847, 863), 'json.dumps', 'json.dumps', (['info'], {}), '(info)\n', (857, 863), False, 'import json\n')] |
import numpy as np
import matplotlib.pyplot as plt
from tqdm import tqdm
from time import time
import os
import h5mapper as h5m
# last dim of data
D = 256
class RandnArray(h5m.Array):
def __init__(self, n, **ds_kwargs):
self.n = n
self.__ds_kwargs__.update(ds_kwargs)
def load(self, source)... | [
"os.remove",
"tqdm.tqdm",
"matplotlib.pyplot.show",
"numpy.random.randn",
"matplotlib.pyplot.subplots",
"time.time",
"h5mapper.GetId",
"matplotlib.pyplot.tight_layout"
] | [((1930, 1944), 'matplotlib.pyplot.subplots', 'plt.subplots', ([], {}), '()\n', (1942, 1944), True, 'import matplotlib.pyplot as plt\n'), ((2274, 2292), 'matplotlib.pyplot.tight_layout', 'plt.tight_layout', ([], {}), '()\n', (2290, 2292), True, 'import matplotlib.pyplot as plt\n'), ((2297, 2307), 'matplotlib.pyplot.sho... |