code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
import urlparse
import httplib
def solveRedirect(url, depth=0):
"""
Facebook API provides a URL for acquiring profile pictures.
That URL contains a person's username, which is not wanted.
However, the URL redirects to an encrypted link, which can then be used.
This function gets the encrypted addr... | [
"httplib.HTTPConnection",
"urlparse.urlparse"
] | [((495, 539), 'urlparse.urlparse', 'urlparse.urlparse', (['url'], {'allow_fragments': '(True)'}), '(url, allow_fragments=True)\n', (512, 539), False, 'import urlparse\n'), ((551, 583), 'httplib.HTTPConnection', 'httplib.HTTPConnection', (['o.netloc'], {}), '(o.netloc)\n', (573, 583), False, 'import httplib\n')] |
# -*- coding: utf-8 -*-
"""Database module, including the SQLAlchemy database object and DB-related utilities."""
from sqlalchemy import Column, ForeignKey, Integer
from fm_database.base import get_base, get_session
Base = get_base(with_query=True)
class CRUDMixin:
"""Mixin that adds convenience methods for CRU... | [
"fm_database.base.get_session",
"sqlalchemy.ForeignKey",
"sqlalchemy.Column",
"fm_database.base.get_base"
] | [((225, 250), 'fm_database.base.get_base', 'get_base', ([], {'with_query': '(True)'}), '(with_query=True)\n', (233, 250), False, 'from fm_database.base import get_base, get_session\n'), ((1925, 1958), 'sqlalchemy.Column', 'Column', (['Integer'], {'primary_key': '(True)'}), '(Integer, primary_key=True)\n', (1931, 1958),... |
#! /usr/bin/env python3
from __future__ import annotations
from __future__ import absolute_import
from typing import Generator
from urllib.parse import parse_qs, urlencode
from base64 import b64decode, b64encode
from essentials import *
data = [
{
"tag": "html",
"attributes": [
("lang"... | [
"urllib.parse.parse_qs"
] | [((3070, 3090), 'urllib.parse.parse_qs', 'parse_qs', (['attributes'], {}), '(attributes)\n', (3078, 3090), False, 'from urllib.parse import parse_qs, urlencode\n')] |
# XXX - execute until line number/cursor
# XXX - more memory printing
# XXX - need a way to disable the architecture modes, maybe be on context
# destruction
from talon import Context, Module, actions, app
mod = Module()
mod.tag("debugger", desc="Tag for enabling generic debugger commands")
# this list is updated by ... | [
"talon.Module",
"talon.app.notify",
"talon.Context"
] | [((214, 222), 'talon.Module', 'Module', ([], {}), '()\n', (220, 222), False, 'from talon import Context, Module, actions, app\n'), ((425, 434), 'talon.Context', 'Context', ([], {}), '()\n', (432, 434), False, 'from talon import Context, Module, actions, app\n'), ((1642, 1705), 'talon.app.notify', 'app.notify', ([], {'s... |
from pylint_complexity import MethodCountChecker, MethodLengthChecker
def register(linter):
linter.register_checker(MethodLengthChecker(linter))
linter.register_checker(MethodCountChecker(linter))
| [
"pylint_complexity.MethodLengthChecker",
"pylint_complexity.MethodCountChecker"
] | [((122, 149), 'pylint_complexity.MethodLengthChecker', 'MethodLengthChecker', (['linter'], {}), '(linter)\n', (141, 149), False, 'from pylint_complexity import MethodCountChecker, MethodLengthChecker\n'), ((179, 205), 'pylint_complexity.MethodCountChecker', 'MethodCountChecker', (['linter'], {}), '(linter)\n', (197, 20... |
import time
import grovepi
from grovepi import *
import datetime;
import urllib.request, urllib.parse
import simplejson as json
import requests
from grove_rgb_lcd import *
# Connect the Grove Light Sensor to analog port A0
# SIG,NC,VCC,GND
light_sensor = 0
sound_sensor = 1
header_content = {'Content-type': 'applicatio... | [
"requests.post",
"grovepi.analogRead",
"time.sleep",
"datetime.datetime.now",
"grovepi.pinMode"
] | [((540, 578), 'grovepi.pinMode', 'grovepi.pinMode', (['light_sensor', '"""INPUT"""'], {}), "(light_sensor, 'INPUT')\n", (555, 578), False, 'import grovepi\n'), ((578, 608), 'grovepi.pinMode', 'grovepi.pinMode', (['led', '"""OUTPUT"""'], {}), "(led, 'OUTPUT')\n", (593, 608), False, 'import grovepi\n'), ((745, 777), 'gro... |
import json
import logging
import time
from typing import Dict
from socutils.exceptions import KafkaSettingsError, KafkaProducerError
logger = logging.getLogger(__name__)
class Message:
def __init__(self):
self.value = None
self.topic = None
self.partition = None
self.offset = No... | [
"logging.getLogger",
"json.loads",
"json.dumps",
"time.sleep",
"confluent_kafka.Producer",
"socutils.exceptions.KafkaProducerError",
"confluent_kafka.Consumer",
"socutils.exceptions.KafkaSettingsError"
] | [((145, 172), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (162, 172), False, 'import logging\n'), ((2525, 2566), 'confluent_kafka.Consumer', 'ConfluentConsumer', (['self.consumer_settings'], {}), '(self.consumer_settings)\n', (2542, 2566), True, 'from confluent_kafka import Consumer as... |
"""create_data.py
Script to take the orignal BioText protein-protein interactons data and create
data resources.
This project has been shelved for now, see the README.md file at the top-level
of this repository for reasons.
Usage:
$ python3 create_data.py
This creates the needed data in ../resources/data.
Thi... | [
"os.path.exists",
"os.makedirs",
"os.path.join",
"io.StringIO",
"codecs.open"
] | [((1706, 1745), 'os.path.join', 'os.path.join', (['""".."""', '"""resources"""', '"""data"""'], {}), "('..', 'resources', 'data')\n", (1718, 1745), False, 'import os\n'), ((1764, 1804), 'os.path.join', 'os.path.join', (['DATA_DIR', '"""pubmed_ids.txt"""'], {}), "(DATA_DIR, 'pubmed_ids.txt')\n", (1776, 1804), False, 'im... |
# Copyright 2020 DeepMind Technologies Limited.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or ag... | [
"numpy.dtype",
"dm_robotics.moma.sensors.robot_tcp_sensor.RobotTCPSensor",
"dm_robotics.moma.models.end_effectors.robot_hands.robotiq_2f85.Robotiq2F85",
"dm_robotics.moma.effectors.arm_effector.ArmEffector",
"dm_robotics.moma.scene_initializer.CompositeSceneInitializer",
"dm_robotics.moma.sensors.robot_ar... | [((6122, 6137), 'absl.testing.absltest.main', 'absltest.main', ([], {}), '()\n', (6135, 6137), False, 'from absl.testing import absltest\n'), ((1497, 1522), 'dm_robotics.moma.models.arenas.empty.Arena', 'empty.Arena', (['"""test_arena"""'], {}), "('test_arena')\n", (1508, 1522), False, 'from dm_robotics.moma.models.are... |
# -*- coding: utf-8 -*-
import re
import os
from django.conf import settings
from django.shortcuts import redirect
from django.db.models import Q
from datetime import datetime, timedelta
from djobberbase.conf import settings as djobberbase_settings
def normalize_query(query_string,
findterms=re.co... | [
"re.compile",
"datetime.datetime.now",
"django.db.models.Q",
"datetime.timedelta",
"os.remove"
] | [((2127, 2142), 'os.remove', 'os.remove', (['name'], {}), '(name)\n', (2136, 2142), False, 'import os\n'), ((2296, 2310), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (2308, 2310), False, 'from datetime import datetime, timedelta\n'), ((2415, 2429), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n... |
"""
Contains utility functions to populate database with a default
learning objects.
"""
import glob
import gettext
from manager.insert_one import insert_one
def create_default_learning_objects(db):
"""Populate database with default learning objects."""
# TODO: fix category
list_files_path = glob.glob("se... | [
"gettext.translation",
"manager.insert_one.insert_one",
"glob.glob"
] | [((307, 360), 'glob.glob', 'glob.glob', (['"""setup/default_learning_objects_xml/*.xml"""'], {}), "('setup/default_learning_objects_xml/*.xml')\n", (316, 360), False, 'import glob\n'), ((381, 451), 'gettext.translation', 'gettext.translation', (['"""collection"""', '"""/code/locale"""'], {'languages': "['en_US']"}), "(... |
from .core import KeyStore, KeyStoreError, PinError
from platform import CriticalErrorWipeImmediately
import platform
from rng import get_random_bytes
import hashlib
import hmac
from bitcoin import ec, bip39, bip32
from bitcoin.transaction import SIGHASH
from helpers import aead_encrypt, aead_decrypt, tagged_hash
impor... | [
"hmac.new",
"platform.maybe_mkdir",
"gui.screens.MnemonicScreen",
"bitcoin.bip39.mnemonic_is_valid",
"gui.screens.PinScreen",
"bitcoin.ec.Signature",
"gui.screens.Prompt",
"platform.sync",
"secp256k1.ecdsa_sign_recoverable",
"gui.screens.Alert",
"bitcoin.bip39.mnemonic_to_seed",
"helpers.aead_... | [((2189, 2236), 'bitcoin.bip39.mnemonic_to_seed', 'bip39.mnemonic_to_seed', (['self.mnemonic', 'password'], {}), '(self.mnemonic, password)\n', (2211, 2236), False, 'from bitcoin import ec, bip39, bip32\n'), ((2257, 2284), 'bitcoin.bip32.HDKey.from_seed', 'bip32.HDKey.from_seed', (['seed'], {}), '(seed)\n', (2278, 2284... |
import torch
import torch.nn as nn
F = nn.functional
from mmcv.cnn import ConvModule
from mmcv.runner import BaseModule, auto_fp16
from mmdet.models.backbones.resnet import Bottleneck
from mmdet.models.builder import HEADS
#from .bbox_head import BBoxHead
from .convfc_bbox_head import Shared2FCBBoxHead
@HEADS.regist... | [
"torch.nn.ReLU",
"torch.linalg.vector_norm",
"torch.topk",
"torch.empty_like",
"mmdet.models.builder.HEADS.register_module",
"torch.einsum",
"torch.nn.Linear",
"torch.cat",
"mmcv.runner.auto_fp16"
] | [((308, 331), 'mmdet.models.builder.HEADS.register_module', 'HEADS.register_module', ([], {}), '()\n', (329, 331), False, 'from mmdet.models.builder import HEADS\n'), ((1012, 1023), 'mmcv.runner.auto_fp16', 'auto_fp16', ([], {}), '()\n', (1021, 1023), False, 'from mmcv.runner import BaseModule, auto_fp16\n'), ((741, 78... |
import cv2
import itertools, os, time
import numpy as np
from Model import get_Model
from parameter import letters
import argparse
from keras import backend as K
K.set_learning_phase(0)
def decode_label(out):
# out : (1, 32, 42)
out_best = list(np.argmax(out[0, 2:], axis=1)) # get max index -> len = 32
... | [
"os.listdir",
"itertools.groupby",
"argparse.ArgumentParser",
"Model.get_Model",
"numpy.argmax",
"numpy.expand_dims",
"time.time",
"cv2.resize",
"keras.backend.set_learning_phase",
"cv2.imread"
] | [((162, 185), 'keras.backend.set_learning_phase', 'K.set_learning_phase', (['(0)'], {}), '(0)\n', (182, 185), True, 'from keras import backend as K\n'), ((531, 556), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (554, 556), False, 'import argparse\n'), ((864, 889), 'Model.get_Model', 'get_Mode... |
from django.conf import settings
from django.conf.urls import include, url
from django.contrib import admin
from django.contrib.sitemaps.views import sitemap
from django.views.static import serve
from blog.sitemaps import BlogSitemap
from blog.views import ArticleListView
sitemaps = {
'blog': BlogSitemap
}
# i18... | [
"django.conf.urls.include",
"django.conf.urls.url",
"blog.views.ArticleListView.as_view"
] | [((1068, 1191), 'django.conf.urls.url', 'url', ([], {'regex': '"""^sitemap\\\\.xml$"""', 'view': 'sitemap', 'kwargs': "{'sitemaps': sitemaps}", 'name': '"""django.contrib.sitemaps.views.sitemap"""'}), "(regex='^sitemap\\\\.xml$', view=sitemap, kwargs={'sitemaps': sitemaps},\n name='django.contrib.sitemaps.views.site... |
import tensorflow as tf
class VGG(tf.keras.layers.Layer):
def __init__(self, use_bn=False):
super(VGG, self).__init__()
self.conv1 = VGG._make_conv_block(64, 3, 1, "same", use_bn)
self.conv2 = VGG._make_conv_block(64, 3, 1, "same", use_bn)
self.pool1 = tf.keras.layers.MaxPool2D(poo... | [
"tensorflow.keras.layers.Conv2D",
"tensorflow.nn.relu",
"tensorflow.keras.layers.ReLU",
"tensorflow.keras.layers.BatchNormalization",
"tensorflow.keras.layers.MaxPool2D"
] | [((291, 356), 'tensorflow.keras.layers.MaxPool2D', 'tf.keras.layers.MaxPool2D', ([], {'pool_size': '(2)', 'strides': '(2)', 'padding': '"""same"""'}), "(pool_size=2, strides=2, padding='same')\n", (316, 356), True, 'import tensorflow as tf\n'), ((517, 582), 'tensorflow.keras.layers.MaxPool2D', 'tf.keras.layers.MaxPool2... |
"""
Contain builder for raid creation
"""
from datetime import datetime
from typing import Optional
from discord.ext.commands import Context
from core.command_gates.raid_gate import RaidGate
from core.commands.common import command_logging
from core.database.manager import DatabaseManager
from core.guild_managers.man... | [
"core.raid.raid_member.RaidMemberFactory.produce_by_discord_user",
"core.database.manager.DatabaseManager",
"core.guild_managers.managers_controller.ManagersController.create_raid",
"core.users_interactor.senders.ChannelsSender.send_captain_created_raid",
"core.command_gates.raid_gate.RaidGate.can_user_crea... | [((710, 727), 'core.database.manager.DatabaseManager', 'DatabaseManager', ([], {}), '()\n', (725, 727), False, 'from core.database.manager import DatabaseManager\n'), ((1101, 1154), 'core.raid.raid_member.RaidMemberFactory.produce_by_discord_user', 'RaidMemberFactory.produce_by_discord_user', (['ctx.author'], {}), '(ct... |
import json
from decouple import config
import requests
import datetime
import os
class Updater():
def __init__(self):
self.savefilepath = './data/habits.json'
self.NOTION_URL = "https://api.notion.com/v1/databases/"
self.integration_token = config("INTEGRATION_TOKEN")
self.DATABAS... | [
"os.path.exists",
"requests.post",
"os.makedirs",
"decouple.config",
"datetime.datetime.now",
"json.load",
"datetime.timedelta",
"json.dump"
] | [((272, 299), 'decouple.config', 'config', (['"""INTEGRATION_TOKEN"""'], {}), "('INTEGRATION_TOKEN')\n", (278, 299), False, 'from decouple import config\n'), ((327, 348), 'decouple.config', 'config', (['"""DATABASE_ID"""'], {}), "('DATABASE_ID')\n", (333, 348), False, 'from decouple import config\n'), ((1473, 1618), 'r... |
#- Import packages
import names
import random
'''
@module: Travel Dataset Generator
@authors: <NAME> <leomaurodesenv>
@link: https://github.com/Argo-Solutions/travel-dataset-generator GitHub
@license: Creative Commons BY License
@copyright: 2019 Argo Solutions
@access: public
'''
#- Functions
def funcUserGenerator(g... | [
"random.randint",
"names.get_full_name"
] | [((759, 793), 'names.get_full_name', 'names.get_full_name', ([], {'gender': 'gender'}), '(gender=gender)\n', (778, 793), False, 'import names\n'), ((812, 868), 'random.randint', 'random.randint', (["agesInterval['min']", "agesInterval['max']"], {}), "(agesInterval['min'], agesInterval['max'])\n", (826, 868), False, 'im... |
from django.core.context_processors import request
from blog.models import Category
def menu(request):
return {"category_menu": Category.objects.all(), }
| [
"blog.models.Category.objects.all"
] | [((134, 156), 'blog.models.Category.objects.all', 'Category.objects.all', ([], {}), '()\n', (154, 156), False, 'from blog.models import Category\n')] |
from decimal import Decimal
from gtin import GTIN
from gtin.gcp import GCP_PREFIXES
def test_check_digit():
assert GTIN(raw=890123456789).check_digit == '0'
assert GTIN(raw=10101).check_digit == '1'
assert GTIN(raw=567898901234).check_digit == '2'
assert GTIN(raw=82957399425).check_digit == '3'
a... | [
"gtin.gcp.GCP_PREFIXES.refresh",
"gtin.GTIN"
] | [((2296, 2318), 'gtin.gcp.GCP_PREFIXES.refresh', 'GCP_PREFIXES.refresh', ([], {}), '()\n', (2316, 2318), False, 'from gtin.gcp import GCP_PREFIXES\n'), ((122, 144), 'gtin.GTIN', 'GTIN', ([], {'raw': '(890123456789)'}), '(raw=890123456789)\n', (126, 144), False, 'from gtin import GTIN\n'), ((175, 190), 'gtin.GTIN', 'GTI... |
from __future__ import annotations # noqa: F401
import re
import warnings
import numpy as np
import pandas as pd
import xarray as xr
from .config import config
from .grid import _wrf_grid_from_dataset
def _decode_times(ds: xr.Dataset) -> xr.Dataset:
"""
Decode the time variable to datetime64.
"""
... | [
"warnings.warn",
"numpy.issubdtype",
"pandas.to_datetime"
] | [((800, 844), 'numpy.issubdtype', 'np.issubdtype', (['ds.XTIME.dtype', 'np.datetime64'], {}), '(ds.XTIME.dtype, np.datetime64)\n', (813, 844), True, 'import numpy as np\n'), ((4319, 4443), 'warnings.warn', 'warnings.warn', (['"""Unable to create coordinate values and CRS due to insufficient dimensions or projection met... |
import unittest
import cellpylib as cpl
import numpy as np
import os
THIS_DIR = os.path.dirname(os.path.abspath(__file__))
class TestHopfieldNet(unittest.TestCase):
def test_hopfield_net(self):
np.random.seed(0)
# patterns for training
zero = [
0, 1, 1, 1, 0,
1, ... | [
"numpy.testing.assert_equal",
"cellpylib.HopfieldNet",
"cellpylib.evolve",
"os.path.join",
"numpy.array",
"numpy.random.seed",
"os.path.abspath"
] | [((97, 122), 'os.path.abspath', 'os.path.abspath', (['__file__'], {}), '(__file__)\n', (112, 122), False, 'import os\n'), ((210, 227), 'numpy.random.seed', 'np.random.seed', (['(0)'], {}), '(0)\n', (224, 227), True, 'import numpy as np\n'), ((1164, 1193), 'cellpylib.HopfieldNet', 'cpl.HopfieldNet', ([], {'num_cells': '... |
# To run the job:
# pyats run job features_example_job.py
# Description: This example shows an overview of the different features/flows
# that pyATS supports like skipping testcases, looping, variants,
# in addition to basic usage (passing/failing/etc)
import os
from pyats.easypy import run
f... | [
"os.path.abspath",
"pyats.datastructures.logic.Not",
"os.path.join"
] | [((517, 570), 'os.path.join', 'os.path.join', (['test_path', '"""features_example_script.py"""'], {}), "(test_path, 'features_example_script.py')\n", (529, 570), False, 'import os\n'), ((473, 498), 'os.path.abspath', 'os.path.abspath', (['__file__'], {}), '(__file__)\n', (488, 498), False, 'import os\n'), ((618, 669), ... |
from djangae.test import TestCase
import mock
from core.tests.factories import VideoCommentFactory, VideoFactory
from videos.models import VideoComment
from videos.tasks import (
cloudnlp_analyze_comment,
cloudnlp_analyze_transcript,
youtube_import_comments,
youtube_import_transcript
)
class Youtube... | [
"core.tests.factories.VideoFactory",
"videos.models.VideoComment.objects.all",
"videos.tasks.cloudnlp_analyze_comment",
"mock.patch",
"mock.Mock",
"videos.tasks.youtube_import_transcript",
"videos.tasks.cloudnlp_analyze_transcript",
"videos.tasks.youtube_import_comments",
"core.tests.factories.Video... | [((410, 439), 'videos.tasks.youtube_import_comments', 'youtube_import_comments', (['(9999)'], {}), '(9999)\n', (433, 439), False, 'from videos.tasks import cloudnlp_analyze_comment, cloudnlp_analyze_transcript, youtube_import_comments, youtube_import_transcript\n'), ((600, 614), 'core.tests.factories.VideoFactory', 'Vi... |
# Copyright (c) 2018 Graphcore Ltd. All rights reserved.
#This test is not live until T7159 has been resolved
import sys
import os
import c10driver
import popart
import cmdline
from popart.torch import torchwriter
import torch
args = cmdline.parse()
nInChans = 3
nOutChans = 8
batchSize = 2
batchesPerStep = 4
anchors ... | [
"cmdline.parse",
"torch.manual_seed",
"torch.nn.BatchNorm2d",
"popart.AnchorReturnType",
"popart.DataFlow",
"popart.InputShapeInfo",
"popart.torch.torchwriter.conv3x3",
"c10driver.run",
"popart.TensorInfo",
"popart.ConstSGD",
"popart.L1Loss",
"torch.nn.Module.__init__"
] | [((235, 250), 'cmdline.parse', 'cmdline.parse', ([], {}), '()\n', (248, 250), False, 'import cmdline\n'), ((479, 519), 'popart.DataFlow', 'popart.DataFlow', (['batchesPerStep', 'anchors'], {}), '(batchesPerStep, anchors)\n', (494, 519), False, 'import popart\n'), ((537, 560), 'popart.InputShapeInfo', 'popart.InputShape... |
import uvicorn
from fastapi import FastAPI
from starlette import status
from starlette.middleware.cors import CORSMiddleware
from starlette.responses import Response
from fimed import __version__
from fimed.config import settings
from fimed.logger import logger
from fimed.routes.authentication import router as auth_ro... | [
"starlette.responses.Response",
"fimed.logger.logger.info",
"fastapi.FastAPI",
"uvicorn.run"
] | [((502, 672), 'fastapi.FastAPI', 'FastAPI', ([], {'title': '"""FIMED"""', 'docs_url': '"""/api/docs"""', 'openapi_prefix': 'settings.ROOT_PATH', 'description': '"""https://github.com/dandobjim/FIMED2.0-BACKEND"""', 'version': '__version__'}), "(title='FIMED', docs_url='/api/docs', openapi_prefix=settings.\n ROOT_PAT... |
from django.contrib import admin
from jsonschema import ValidationError
from shop.models import (Image, Like, Product, Video,
Wishlist)
import random
from shop.utils import create_product_slug
@admin.register(Product)
class ProductAdmin(admin.ModelAdmin):
list_display = ['name', 'color',... | [
"shop.models.Product.objects.bulk_create",
"random.randrange",
"shop.models.Product",
"shop.utils.create_product_slug",
"django.contrib.admin.register"
] | [((222, 245), 'django.contrib.admin.register', 'admin.register', (['Product'], {}), '(Product)\n', (236, 245), False, 'from django.contrib import admin\n'), ((2302, 2323), 'django.contrib.admin.register', 'admin.register', (['Image'], {}), '(Image)\n', (2316, 2323), False, 'from django.contrib import admin\n'), ((2548,... |
#!/bin/env python
from prompt_toolkit import prompt
from prompt_toolkit.history import FileHistory
from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
from prompt_toolkit.completion import WordCompleter
from prompt_toolkit.shortcuts import PromptSession
from prompt_toolkit.patch_stdout import patch_stdout
f... | [
"logging.exception",
"logging.info",
"prompt_toolkit.patch_stdout.patch_stdout",
"re.split",
"os.path.exists",
"click.secho",
"json.dumps",
"qcg.pilotjob.utils.auxdir.find_single_aux_dir",
"asyncio.sleep",
"zmq.asyncio.Context.instance",
"prompt_toolkit.auto_suggest.AutoSuggestFromHistory",
"a... | [((670, 806), 'prompt_toolkit.completion.WordCompleter', 'WordCompleter', (["['jobs', 'status', 'jinfo', 'load', 'edit', 'jcancel', 'jdel', 'connect',\n 'exit', 'finish', 'help']"], {'ignore_case': '(True)'}), "(['jobs', 'status', 'jinfo', 'load', 'edit', 'jcancel', 'jdel',\n 'connect', 'exit', 'finish', 'help'],... |
import pytest
from stock_indicators import indicators
class TestHMA:
def test_standard(self, quotes):
results = indicators.get_hma(quotes, 20)
assert 502 == len(results)
assert 480 == len(list(filter(lambda x: x.hma is not None, results)))
r = results[149]
... | [
"stock_indicators.indicators.get_hma",
"pytest.raises"
] | [((125, 155), 'stock_indicators.indicators.get_hma', 'indicators.get_hma', (['quotes', '(20)'], {}), '(quotes, 20)\n', (143, 155), False, 'from stock_indicators import indicators\n'), ((508, 542), 'stock_indicators.indicators.get_hma', 'indicators.get_hma', (['bad_quotes', '(15)'], {}), '(bad_quotes, 15)\n', (526, 542)... |
# !/usr/bin/env python
# coding=utf-8
"""
Make a graph for lecture 2, hippo digestion
"""
from __future__ import print_function
import sys
import numpy as np
from scipy import interpolate
from common import make_fig, GOOD_RET
__author__ = 'hbmayes'
def graph_alg_eq():
"""
Given a simple algebraic equation, ... | [
"common.make_fig",
"scipy.interpolate.interp1d",
"numpy.array",
"numpy.linspace",
"scipy.interpolate.splrep",
"scipy.interpolate.splev",
"sys.exit",
"numpy.divide"
] | [((578, 616), 'numpy.linspace', 'np.linspace', (['x_start', 'x_end', 'num_steps'], {}), '(x_start, x_end, num_steps)\n', (589, 616), True, 'import numpy as np\n'), ((647, 726), 'numpy.divide', 'np.divide', (['(1.0 + 16.5 * (1.0 - conversion_scale))', '(1.75 * (1 - conversion_scale))'], {}), '(1.0 + 16.5 * (1.0 - conver... |
import numpy as np
from astropy.io import fits
def stitch_all_images(all_hdus,date):
stitched_hdu_dict = {}
hdu_opamp_dict = {}
for (camera, filenum, imtype, opamp),hdu in all_hdus.items():
if (camera, filenum, imtype) not in hdu_opamp_dict.keys():
hdu_opamp_dict[(camera, filenum, imty... | [
"astropy.io.fits.PrimaryHDU",
"numpy.flipud",
"numpy.fliplr",
"numpy.ndarray",
"numpy.sign"
] | [((1388, 1408), 'numpy.fliplr', 'np.fliplr', (["img['br']"], {}), "(img['br'])\n", (1397, 1408), True, 'import numpy as np\n'), ((1427, 1447), 'numpy.flipud', 'np.flipud', (["img['ul']"], {}), "(img['ul'])\n", (1436, 1447), True, 'import numpy as np\n'), ((1882, 1926), 'numpy.ndarray', 'np.ndarray', ([], {'shape': '(y_... |
# pylint: disable=no-self-use,line-too-long
from __future__ import absolute_import
from __future__ import print_function
from allennlp.common.testing import AllenNlpTestCase
from allennlp.models.archival import load_archive
from allennlp.predictors import Predictor
def demo_model(archive_file , predictor_name ... | [
"allennlp.predictors.Predictor.from_archive",
"allennlp.models.archival.load_archive"
] | [((352, 378), 'allennlp.models.archival.load_archive', 'load_archive', (['archive_file'], {}), '(archive_file)\n', (364, 378), False, 'from allennlp.models.archival import load_archive\n'), ((390, 437), 'allennlp.predictors.Predictor.from_archive', 'Predictor.from_archive', (['archive', 'predictor_name'], {}), '(archiv... |
import logging
class Logger():
def __init__(self, name, items):
self.logger = logging.getLogger(name)
self.name = name
self.items = items
def format(self, FORMAT):
if self.logger.handlers:
return
handler = logging.StreamHandler()
formatter = logging.... | [
"logging.getLogger",
"logging.Formatter",
"logging.StreamHandler"
] | [((91, 114), 'logging.getLogger', 'logging.getLogger', (['name'], {}), '(name)\n', (108, 114), False, 'import logging\n'), ((268, 291), 'logging.StreamHandler', 'logging.StreamHandler', ([], {}), '()\n', (289, 291), False, 'import logging\n'), ((312, 337), 'logging.Formatter', 'logging.Formatter', (['FORMAT'], {}), '(F... |
from typing import Optional, Dict
import aiohttp
from pydantic import BaseModel, HttpUrl, validator
from pydantic.fields import Field
from fastapi import Response, Query, security
from fastapi.exceptions import HTTPException
from fastapi.params import Depends
from aiocogdumper.errors import TIFFError
from aiocogdumper... | [
"fastapi.Response",
"fastapi.exceptions.HTTPException",
"pydantic.validator",
"cache.AsyncLRU",
"fastapi.params.Depends",
"aiocogdumper.cog_tiles.COGTiff",
"aiocogdumper.httpdumper.Reader",
"aiohttp.ClientTimeout",
"fastapi.security.api_key.APIKeyHeader",
"fastapi.Query",
"fastapi.security.api_k... | [((1078, 1094), 'pydantic.validator', 'validator', (['"""url"""'], {}), "('url')\n", (1087, 1094), False, 'from pydantic import BaseModel, HttpUrl, validator\n'), ((2638, 2660), 'cache.AsyncLRU', 'AsyncLRU', ([], {'maxsize': '(1024)'}), '(maxsize=1024)\n', (2646, 2660), False, 'from cache import AsyncLRU\n'), ((730, 79... |
# pylint: disable=invalid-name, arguments-differ, missing-docstring, line-too-long, no-member, redefined-builtin, abstract-method
from functools import partial
from typing import List, Tuple
import math
import torch
from e3nn import o3, rs
from e3nn.linear_mod import KernelLinear
from e3nn.util.eval_code import eval_c... | [
"e3nn.rs.dim",
"e3nn.util.eval_code.eval_code",
"e3nn.util.sparse.get_sparse_buffer",
"e3nn.util.sparse.register_sparse_buffer",
"e3nn.rs.tensor_square",
"e3nn.o3.wigner_3j",
"e3nn.rs.format_Rs",
"torch.randn",
"functools.partial",
"torch.einsum",
"e3nn.rs.convention",
"e3nn.rs.simplify",
"e... | [((4158, 4177), 'e3nn.rs.simplify', 'rs.simplify', (['Rs_in1'], {}), '(Rs_in1)\n', (4169, 4177), False, 'from e3nn import o3, rs\n'), ((4191, 4210), 'e3nn.rs.simplify', 'rs.simplify', (['Rs_in2'], {}), '(Rs_in2)\n', (4202, 4210), False, 'from e3nn import o3, rs\n'), ((4224, 4243), 'e3nn.rs.simplify', 'rs.simplify', (['... |
#__BEGIN_LICENSE__
# Copyright (c) 2017, United States Government, as represented by the
# Administrator of the National Aeronautics and Space Administration.
# All rights reserved.
#
# The GeoRef platform is licensed under the Apache License, Version 2.0
# (the "License"); you may not use this file except in complianc... | [
"unittest.main",
"geomath.transformEnuToLonLatAlt"
] | [((1328, 1343), 'unittest.main', 'unittest.main', ([], {}), '()\n', (1341, 1343), False, 'import unittest\n'), ((1106, 1159), 'geomath.transformEnuToLonLatAlt', 'geomath.transformEnuToLonLatAlt', (['originLonLatAlt', 'enu'], {}), '(originLonLatAlt, enu)\n', (1137, 1159), False, 'import geomath\n')] |
import unittest
import numpy as np
from ssvm.utils import item_2_idc
class Test_item_2_idc(unittest.TestCase):
def test_correctness(self):
l_Y = [[], ["A", "B", "C"], ["A"], ["D", "E"], ["D"], [], ["A", "X", "Z", "Y"], []]
X = np.array([2, 2, 2, 3, 4, 4, 5, 7, 7, 7, 7])
out = item_2_idc(... | [
"unittest.main",
"numpy.array",
"numpy.all",
"ssvm.utils.item_2_idc"
] | [((506, 521), 'unittest.main', 'unittest.main', ([], {}), '()\n', (519, 521), False, 'import unittest\n'), ((250, 293), 'numpy.array', 'np.array', (['[2, 2, 2, 3, 4, 4, 5, 7, 7, 7, 7]'], {}), '([2, 2, 2, 3, 4, 4, 5, 7, 7, 7, 7])\n', (258, 293), True, 'import numpy as np\n'), ((309, 324), 'ssvm.utils.item_2_idc', 'item_... |
"""
DeepLabCut Toolbox
https://github.com/AlexEMG/DeepLabCut
<NAME>, <EMAIL>
<NAME>, <EMAIL>
This script analyzes videos based on a trained network (as specified in myconfig_analysis.py)
You need tensorflow for evaluation. Run by:
CUDA_VISIBLE_DEVICES=0 python3 AnalyzeVideos.py
"""
###############################... | [
"dlct.load_configuration_file",
"pandas.MultiIndex.from_product",
"os.path.exists",
"numpy.ceil",
"dlct.file_name_without_extension_from_path",
"nnet.predict.setup_pose_prediction",
"nnet.predict.extract_cnn_output",
"os.path.join",
"dlct.replace_extension",
"os.path.split",
"os.path.dirname",
... | [((493, 518), 'os.path.abspath', 'os.path.abspath', (['__file__'], {}), '(__file__)\n', (508, 518), False, 'import os\n'), ((547, 583), 'os.path.dirname', 'os.path.dirname', (['path_to_this_script'], {}), '(path_to_this_script)\n', (562, 583), False, 'import os\n'), ((602, 648), 'os.path.join', 'os.path.join', (['path_... |
from lml.registry import PluginInfoChain
__test_plugins__ = PluginInfoChain(__name__).add_a_plugin("test_io2", "reader")
| [
"lml.registry.PluginInfoChain"
] | [((61, 86), 'lml.registry.PluginInfoChain', 'PluginInfoChain', (['__name__'], {}), '(__name__)\n', (76, 86), False, 'from lml.registry import PluginInfoChain\n')] |
from sgmllib import SGMLParser
import htmlentitydefs
class BaseHTMLProcessor(SGMLParser):
def reset(self):
self.pieces = []
SGMLParser.reset(self)
def unknown_starttag(self, tag, attrs):
"""
attrs is a list of (attr, value) tuples
e.g. for <pre class="screen">, tag="pr... | [
"sgmllib.SGMLParser.reset"
] | [((146, 168), 'sgmllib.SGMLParser.reset', 'SGMLParser.reset', (['self'], {}), '(self)\n', (162, 168), False, 'from sgmllib import SGMLParser\n')] |
from datetime import datetime, timezone
from . import _except_return_none
@_except_return_none
def get_timestamp():
return datetime.now().replace(
tzinfo=timezone.utc,
).replace(
microsecond=0,
).isoformat().replace('+', 'Z')
| [
"datetime.datetime.now"
] | [((129, 143), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (141, 143), False, 'from datetime import datetime, timezone\n')] |
from random import randint
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
import time
import urllib
navegador = webdriver.Chrome('chromedriver.exe')
navegador.get('https://web.whatsapp.com/')
while len(navegador.find_elements_by_id('side')) < 1:
time.sleep(1)
#Login feito no whats... | [
"selenium.webdriver.Chrome",
"urllib.parse.quote",
"random.randint",
"time.sleep"
] | [((145, 181), 'selenium.webdriver.Chrome', 'webdriver.Chrome', (['"""chromedriver.exe"""'], {}), "('chromedriver.exe')\n", (161, 181), False, 'from selenium import webdriver\n'), ((284, 297), 'time.sleep', 'time.sleep', (['(1)'], {}), '(1)\n', (294, 297), False, 'import time\n'), ((588, 602), 'random.randint', 'randint... |
'''Autogenerated by xml_generate script, do not edit!'''
from OpenGL import platform as _p, arrays
# Code generation uses this
from OpenGL.raw.GL import _types as _cs
# End users want this...
from OpenGL.raw.GL._types import *
from OpenGL.raw.GL import _errors
from OpenGL.constant import Constant as _C
import... | [
"OpenGL.platform.types",
"OpenGL.constant.Constant",
"OpenGL.platform.createFunction"
] | [((540, 588), 'OpenGL.constant.Constant', '_C', (['"""GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV"""', '(35080)'], {}), "('GL_MAX_PROGRAM_ATTRIB_COMPONENTS_NV', 35080)\n", (542, 588), True, 'from OpenGL.constant import Constant as _C\n'), ((624, 670), 'OpenGL.constant.Constant', '_C', (['"""GL_MAX_PROGRAM_GENERIC_ATTRIBS_NV"""... |
# Copyright © 2019 Province of British Columbia
#
# 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 agr... | [
"tracker.services.MessageProcessingService.find_message_by_message_id",
"tracker.services.MessageProcessingService.create_message",
"entity_emailer.email_processors.filing_notification.FILING_TYPE_CONVERTER.keys",
"tracker.services.MessageProcessingService.find_message_by_source_and_message_id",
"tracker.se... | [((7726, 7953), 'tracker.services.MessageProcessingService.create_message', 'MessageProcessingService.create_message', ([], {'message_id': 'message_id', 'source': 'source', 'identifier': 'identifier', 'message_type': 'message_type', 'status': 'new_status', 'message_json': 'message_json', 'last_error': 'error_details', ... |
"""URL configuration for the Scheduler API."""
from django.urls import path
from rest_framework import routers
from . import views
app_name = "api"
router = routers.DefaultRouter()
router.register(r"exchanges", views.ExchangeViewSet)
router.register(r"exchange_statuses", views.ExchangeStatusViewSet)
router.register(r... | [
"rest_framework.routers.DefaultRouter"
] | [((158, 181), 'rest_framework.routers.DefaultRouter', 'routers.DefaultRouter', ([], {}), '()\n', (179, 181), False, 'from rest_framework import routers\n')] |
#!/usr/bin/env python
# -*- coding: UTF-8 -*-
import cherrypy
from pydrop.config import config
from pydrop.app import app, register_blueprints
def run_server():
register_blueprints()
if config.env == "production":
cherrypi_server()
else:
flask_server()
def flask_server()... | [
"pydrop.app.register_blueprints",
"cherrypy.engine.block",
"cherrypy.engine.stop",
"pydrop.app.app.run",
"pydrop.config.config.get",
"cherrypy.config.update",
"cherrypy.tree.graft",
"cherrypy.engine.start"
] | [((177, 198), 'pydrop.app.register_blueprints', 'register_blueprints', ([], {}), '()\n', (196, 198), False, 'from pydrop.app import app, register_blueprints\n'), ((327, 382), 'pydrop.app.app.run', 'app.run', ([], {'host': 'config.host', 'port': 'config.port', 'debug': '(True)'}), '(host=config.host, port=config.port, d... |
import asyncio
import os
import secrets
import typing
import fastapi
import httpx
from aioredis import client
from fastapi import responses
from starlette import background, requests, status
from app import utils
from app.api import dependencies
from app.models.domain import video
from app.resources import details
fr... | [
"app.services.youtube.search_video_plus",
"secrets.token_hex",
"app.services.youtube.search_video_list",
"app.resources.details.AudibleYtContent",
"fastapi.HTTPException",
"app.services.youtube.download_video_plus",
"fastapi.responses.FileResponse",
"app.utils.validate_duration",
"fastapi.responses.... | [((383, 444), 'typing.TypeVar', 'typing.TypeVar', (['"""_T"""', 'list[dict[str, typing.Any]]', 'list[None]'], {}), "('_T', list[dict[str, typing.Any]], list[None])\n", (397, 444), False, 'import typing\n'), ((455, 474), 'fastapi.APIRouter', 'fastapi.APIRouter', ([], {}), '()\n', (472, 474), False, 'import fastapi\n'), ... |
#!/usr/bin/python3
#%%
from cassandra.cluster import Cluster
from cassandra import query
cluster = Cluster(['localhost'], port=9042)
session = cluster.connect()
session.set_keyspace('cnn')
#Create smaller table to match with Postgress data
q = "CREATE TABLE IF NOT EXISTS wb_texts"
q = q + """
(date date,
author text,... | [
"cassandra.cluster.Cluster"
] | [((100, 133), 'cassandra.cluster.Cluster', 'Cluster', (["['localhost']"], {'port': '(9042)'}), "(['localhost'], port=9042)\n", (107, 133), False, 'from cassandra.cluster import Cluster\n')] |
from django.urls import path
from django_gramm.views import (
auth_views, post_views, user_views
)
from django.views.generic import TemplateView
from allauth.socialaccount.views import SignupView as SignUpOauth
app_name = 'django_gramm'
urlpatterns = [
path('', post_views.Index.as_view(), name='index'),
... | [
"django_gramm.views.post_views.Index.as_view",
"django.views.generic.TemplateView.as_view",
"django_gramm.views.user_views.UserProfile.as_view",
"django_gramm.views.auth_views.UserPasswordResetDone.as_view",
"django_gramm.views.auth_views.UserRegistration.as_view",
"django_gramm.views.post_views.ShowUserD... | [((863, 930), 'django.urls.path', 'path', (['"""users/search/"""', 'user_views.search_users'], {'name': '"""search_users"""'}), "('users/search/', user_views.search_users, name='search_users')\n", (867, 930), False, 'from django.urls import path\n'), ((275, 301), 'django_gramm.views.post_views.Index.as_view', 'post_vie... |
#!/usr/bin/env python3
"""Move the robot on the trajectory of a previously recorded log file."""
import argparse
import pandas
import robot_fingers
def main():
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument(
"robot_type",
choices=robot_fingers.Robot.get_supported_r... | [
"robot_fingers.Robot.create_by_name",
"robot_fingers.Robot.get_supported_robots",
"argparse.ArgumentParser",
"pandas.read_csv"
] | [((177, 221), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '__doc__'}), '(description=__doc__)\n', (200, 221), False, 'import argparse\n'), ((592, 677), 'pandas.read_csv', 'pandas.read_csv', (['args.logfile'], {'delim_whitespace': '(True)', 'header': '(0)', 'low_memory': '(False)'}), '(arg... |
import pytest
import os
from npt import download
from npt import log
log.setLevel('DEBUG')
_data = {
'success': {
'url': 'https://upload.wikimedia.org/wikipedia/commons/thumb/9/97/The_Earth_seen_from_Apollo_17.jpg/256px-The_Earth_seen_from_Apollo_17.jpg',
'name': '256px-The_Earth_seen_from_Apollo... | [
"npt.download.file",
"os.path.exists",
"os.path.join",
"npt.log.setLevel",
"npt.download.files",
"os.path.isfile",
"os.path.dirname",
"os.path.isdir",
"tempfile.mkdtemp",
"shutil.rmtree",
"os.remove"
] | [((71, 92), 'npt.log.setLevel', 'log.setLevel', (['"""DEBUG"""'], {}), "('DEBUG')\n", (83, 92), False, 'from npt import log\n'), ((546, 555), 'tempfile.mkdtemp', 'mkdtemp', ([], {}), '()\n', (553, 555), False, 'from tempfile import mkdtemp\n'), ((613, 625), 'shutil.rmtree', 'rmtree', (['_dir'], {}), '(_dir)\n', (619, 6... |
#!/usr/bin/python
# make code as python 3 compatible as possible
from __future__ import (absolute_import, division, print_function,
unicode_literals)
import argparse
import ast
import json
import logging
import sys
from io import BytesIO
import numpy
LOGGER = logging.getLogger()
def get_nam... | [
"logging.getLogger",
"logging.basicConfig",
"pandas.io.json.read_json",
"argparse.ArgumentParser",
"pandas.DataFrame.from_csv",
"io.BytesIO",
"json.dumps",
"ast.Module",
"numpy.array",
"autopep8.fix_code",
"numpy.savetxt",
"ast.parse",
"sys.stdout.flush",
"numpy.genfromtxt",
"ast.Express... | [((288, 307), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (305, 307), False, 'import logging\n'), ((341, 356), 'ast.parse', 'ast.parse', (['expr'], {}), '(expr)\n', (350, 356), False, 'import ast\n'), ((2857, 2956), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'prog': '"""npcli"""', 'desc... |
import discord
from discord.ext import commands, tasks
class StatusCycler(commands.Cog):
def __init__(self, bot):
self.bot = bot
self.status_dict = {
# ActivityType values; playing = 0, streaming = 1, listening = 2, watching = 3
"status": [
{"name": "with my... | [
"discord.ext.tasks.loop",
"discord.Activity"
] | [((627, 651), 'discord.ext.tasks.loop', 'tasks.loop', ([], {'minutes': '(10.0)'}), '(minutes=10.0)\n', (637, 651), False, 'from discord.ext import commands, tasks\n'), ((813, 871), 'discord.Activity', 'discord.Activity', ([], {'name': "status['name']", 'type': "status['type']"}), "(name=status['name'], type=status['typ... |
import PySimpleGUI as sg
sg.theme('SandyBeach')
layout = [
[sg.Text('Please enter your Username and the Seed provided by the Host')],
[sg.Text('Username', size =(15, 1)), sg.InputText()],
[sg.Text('Server Seed', size =(15, 1)), sg.InputText()],
[sg.Submit(), sg.Cancel()]
]
window = s... | [
"PySimpleGUI.Submit",
"PySimpleGUI.Cancel",
"PySimpleGUI.Text",
"PySimpleGUI.theme",
"PySimpleGUI.InputText",
"PySimpleGUI.Window"
] | [((28, 50), 'PySimpleGUI.theme', 'sg.theme', (['"""SandyBeach"""'], {}), "('SandyBeach')\n", (36, 50), True, 'import PySimpleGUI as sg\n'), ((319, 352), 'PySimpleGUI.Window', 'sg.Window', (['"""Shoeshine.tv"""', 'layout'], {}), "('Shoeshine.tv', layout)\n", (328, 352), True, 'import PySimpleGUI as sg\n'), ((75, 146), '... |
import numpy as np
import matplotlib.pyplot as plt
from scipy.stats import multivariate_normal
uniform_var = np.random.uniform(-5,5,100)
target_val = 0.1 * (uniform_var**3) + 3
noise = np.random.normal(size=100)
noisy_obs = target_val + noise
# plotting
fig_noisy_data = plt.figure()
plot = fig_noisy_data.add_subplot... | [
"numpy.random.normal",
"matplotlib.pyplot.figure",
"numpy.random.uniform"
] | [((112, 141), 'numpy.random.uniform', 'np.random.uniform', (['(-5)', '(5)', '(100)'], {}), '(-5, 5, 100)\n', (129, 141), True, 'import numpy as np\n'), ((188, 214), 'numpy.random.normal', 'np.random.normal', ([], {'size': '(100)'}), '(size=100)\n', (204, 214), True, 'import numpy as np\n'), ((274, 286), 'matplotlib.pyp... |
"""
Functionality to perform inference. Acts as runner between image queue and
GPU cluster containing trained models.
inference_runner.py
"""
import os
import os.path as op
import time
import base64
import json
import tempfile
from io import BytesIO
from functools import partial
import logging
import requests
import ... | [
"requests.post",
"rasterio.Affine.identity",
"io.BytesIO",
"absl.logging.info",
"time.sleep",
"numpy.array",
"os.remove",
"os.path.exists",
"sqlalchemy.orm.sessionmaker",
"google.oauth2.service_account.Credentials.from_service_account_file",
"osgeo.gdal.Warp",
"divdet.inference.utils_inference... | [((990, 1058), 'absl.flags.DEFINE_string', 'flags.DEFINE_string', (['"""gcp_project"""', 'None', '"""Google cloud project ID."""'], {}), "('gcp_project', None, 'Google cloud project ID.')\n", (1009, 1058), False, 'from absl import app, logging, flags\n'), ((1059, 1168), 'absl.flags.DEFINE_string', 'flags.DEFINE_string'... |
# Generated by Django 2.2.2 on 2019-07-11 01:19
from django.db import migrations, models
import django.db.models.deletion
import django.utils.timezone
class Migration(migrations.Migration):
dependencies = [
('webapp', '0026_studentinfo_course_hours'),
]
operations = [
migrations.AddFiel... | [
"django.db.models.DateField",
"django.db.models.TextField",
"django.db.models.ForeignKey",
"django.db.models.AutoField",
"django.db.models.DateTimeField",
"django.db.models.CharField"
] | [((421, 610), 'django.db.models.CharField', 'models.CharField', ([], {'choices': "[('1', '申请撤销成功'), ('2', '申请撤销失败')]", 'default': '(2)', 'help_text': '"""1 申请撤销成功 2 申请撤销失败,一旦管理员同意注销,将无法编辑修改,信息的操作权限将转移到对应的负责人手中"""', 'max_length': '(50)', 'verbose_name': '"""负责人申请注销状态"""'}), "(choices=[('1', '申请撤销成功'), ('2', '申请撤销失败')], ... |
import numpy as np
import pandas as pd
import seaborn as sns
import pandas_profiling as pdp
import matplotlib.pyplot as plt
def load_and_process(csv):
# Method Chain 1 (load data, rename columns, round values to 2 d.p. and sort 'Charges' descending)
df1 = (
pd.read_csv('Medical_Cost.csv')
.rena... | [
"pandas.read_csv"
] | [((275, 306), 'pandas.read_csv', 'pd.read_csv', (['"""Medical_Cost.csv"""'], {}), "('Medical_Cost.csv')\n", (286, 306), True, 'import pandas as pd\n')] |
import unittest
from aoc.d11.main import _calculate_value, largest_grid_value_coords, largest_grid_value_coords_of_3x3
class TestCase(unittest.TestCase):
def test_cell_value(self):
self.assertEqual(4, _calculate_value(8, (3, 5)))
self.assertEqual(-5, _calculate_value(57, (122, 79)))
self.... | [
"unittest.main",
"aoc.d11.main.largest_grid_value_coords_of_3x3",
"aoc.d11.main._calculate_value",
"aoc.d11.main.largest_grid_value_coords"
] | [((898, 913), 'unittest.main', 'unittest.main', ([], {}), '()\n', (911, 913), False, 'import unittest\n'), ((216, 243), 'aoc.d11.main._calculate_value', '_calculate_value', (['(8)', '(3, 5)'], {}), '(8, (3, 5))\n', (232, 243), False, 'from aoc.d11.main import _calculate_value, largest_grid_value_coords, largest_grid_va... |
from django.core.exceptions import ValidationError
from django.core.validators import MinLengthValidator, MinValueValidator
from django.db import models
from django.utils.deconstruct import deconstructible
from expenses_tracker.web.vaidators import validate_only_letters, ImageMaxSizeInMbValidator
class Profile(model... | [
"django.db.models.FloatField",
"django.db.models.TextField",
"expenses_tracker.web.vaidators.ImageMaxSizeInMbValidator",
"django.core.validators.MinLengthValidator",
"django.db.models.URLField",
"django.core.validators.MinValueValidator",
"django.db.models.CharField"
] | [((1562, 1607), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': 'TITLE_MAX_LENGTH'}), '(max_length=TITLE_MAX_LENGTH)\n', (1578, 1607), False, 'from django.db import models\n'), ((1644, 1690), 'django.db.models.URLField', 'models.URLField', ([], {'verbose_name': '"""Link to Image:"""'}), "(verbose_... |
#!/usr/bin/env python
import os, io, random
import string
import numpy as np
from Bio.Seq import Seq
from Bio.Align import MultipleSeqAlignment
from Bio import AlignIO, SeqIO
from io import StringIO
import panel as pn
import panel.widgets as pnw
import pandas as pd
pn.extension()
from bokeh.plotting import figure
... | [
"Bio.pairwise2.align.globalms",
"Bio.AlignIO.read",
"bokeh.plotting.figure",
"pandas.read_csv",
"random.shuffle",
"tqdm.tqdm",
"bokeh.models.Range1d",
"random.seed",
"panel.extension",
"bokeh.layouts.gridplot",
"Bio.Align.Applications.MuscleCommandline",
"bokeh.io.export_svgs",
"bokeh.models... | [((270, 284), 'panel.extension', 'pn.extension', ([], {}), '()\n', (282, 284), True, 'import panel as pn\n'), ((4193, 4229), 'pandas.read_csv', 'pd.read_csv', (['"""sp_top_100_scores.csv"""'], {}), "('sp_top_100_scores.csv')\n", (4204, 4229), True, 'import pandas as pd\n'), ((4241, 4267), 'pandas.read_csv', 'pd.read_cs... |
__author__ = "<NAME>"
from pickle import dumps, loads
from expyriment import io, misc
from .. import __version__ as forceDAQVersion
from .._lib.misc import SensorHistory
from .._lib.types import ForceData, Thresholds, GUIRemoteControlCommands as RcCmd
from ..force.sensor_process import SensorProcess
from . import s... | [
"pickle.dumps",
"expyriment.misc.Clock"
] | [((2770, 2782), 'expyriment.misc.Clock', 'misc.Clock', ([], {}), '()\n', (2780, 2782), False, 'from expyriment import io, misc\n'), ((9224, 9234), 'pickle.dumps', 'dumps', (['tmp'], {}), '(tmp)\n', (9229, 9234), False, 'from pickle import dumps, loads\n'), ((9325, 9336), 'pickle.dumps', 'dumps', (['None'], {}), '(None)... |
# check basic functionality of the timer class
import pyb
from pyb import Timer
tim = Timer(4)
tim = Timer(4, prescaler=100, period=200)
print(tim.prescaler())
print(tim.period())
tim.prescaler(300)
print(tim.prescaler())
tim.period(400)
print(tim.period())
| [
"pyb.Timer"
] | [((88, 96), 'pyb.Timer', 'Timer', (['(4)'], {}), '(4)\n', (93, 96), False, 'from pyb import Timer\n'), ((103, 138), 'pyb.Timer', 'Timer', (['(4)'], {'prescaler': '(100)', 'period': '(200)'}), '(4, prescaler=100, period=200)\n', (108, 138), False, 'from pyb import Timer\n')] |
import os
import warnings
from typing import TYPE_CHECKING, Optional, Union
from .model import OME
try:
from qtpy.QtCore import QMimeData, Qt
from qtpy.QtWidgets import QTreeWidget, QTreeWidgetItem
except ImportError:
raise ImportError(
"qtpy and a Qt backend (pyside or pyqt) is required to use th... | [
"warnings.warn",
"qtpy.QtWidgets.QTreeWidgetItem",
"qtpy.QtWidgets.QApplication",
"os.path.basename"
] | [((4829, 4845), 'qtpy.QtWidgets.QApplication', 'QApplication', (['[]'], {}), '([])\n', (4841, 4845), False, 'from qtpy.QtWidgets import QApplication\n'), ((3753, 3775), 'qtpy.QtWidgets.QTreeWidgetItem', 'QTreeWidgetItem', (['[key]'], {}), '([key])\n', (3768, 3775), False, 'from qtpy.QtWidgets import QTreeWidget, QTreeW... |
import sys
import getopt
import json
def print_help():
print("""== ue4tojson ==
Utility script for converting between Unreal Engine and JSON files, should PO files be unsupported.
This script can work two ways:
1. It can convert UE4 .manifest files (generated by text gather operation) into a JSON file while ... | [
"json.load",
"getopt.getopt",
"json.dump",
"sys.exit"
] | [((915, 939), 'json.load', 'json.load', (['manifest_file'], {}), '(manifest_file)\n', (924, 939), False, 'import json\n'), ((1652, 1714), 'json.dump', 'json.dump', (['output_json', 'jsonfile'], {'ensure_ascii': '(False)', 'indent': '(4)'}), '(output_json, jsonfile, ensure_ascii=False, indent=4)\n', (1661, 1714), False,... |
import astropy.units as u
from astropy.coordinates import SkyCoord
def angular_distance(ra1, dec1, ra2, dec2, unit='degree'):
"""
Compute angular distance between pairs of coordinates
:param ra1:
:param dec1:
:param ra2:
:param dec2:
:param unit: the unit of the output (default: degree)
... | [
"astropy.coordinates.SkyCoord"
] | [((371, 433), 'astropy.coordinates.SkyCoord', 'SkyCoord', ([], {'ra': '(ra1 * u.degree)', 'dec': '(dec1 * u.degree)', 'frame': '"""icrs"""'}), "(ra=ra1 * u.degree, dec=dec1 * u.degree, frame='icrs')\n", (379, 433), False, 'from astropy.coordinates import SkyCoord\n'), ((449, 511), 'astropy.coordinates.SkyCoord', 'SkyCo... |
from scrapy.selector import Selector
import requests
import pickle
import argparse
def _parse_args():
parser = argparse.ArgumentParser()
parser.add_argument('url', help="pass in URL of hotel to scrape")
args = parser.parse_args()
return args
def start_scraper(url):
return collect_reviews(url)
de... | [
"pickle.dump",
"requests.get",
"scrapy.selector.Selector",
"argparse.ArgumentParser"
] | [((116, 141), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (139, 141), False, 'import argparse\n'), ((1642, 1659), 'requests.get', 'requests.get', (['url'], {}), '(url)\n', (1654, 1659), False, 'import requests\n'), ((1688, 1706), 'scrapy.selector.Selector', 'Selector', (['response'], {}), '(... |
import requests, re, json, logging
from datetime import datetime
logger = logging.getLogger(__name__)
request_validation_re = re.compile(r'<input name="__RequestVerificationToken" type="hidden" value="([^"]*)" />')
class Ecowater:
def __init__(self, username, password, serialnumber):
try:
... | [
"logging.getLogger",
"json.loads",
"requests.Session",
"re.compile",
"datetime.datetime.strptime",
"logging.error",
"re.search"
] | [((78, 105), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (95, 105), False, 'import requests, re, json, logging\n'), ((131, 228), 're.compile', 're.compile', (['"""<input name="__RequestVerificationToken" type="hidden" value="([^"]*)" />"""'], {}), '(\n \'<input name="__RequestVerifi... |
# Copyright (c) 2013-2015 Centre for Advanced Internet Architectures,
# Swinburne University of Technology. All rights reserved.
#
# Author: <NAME> (<EMAIL>)
# <NAME> (<EMAIL>)
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following condit... | [
"os.path.isdir",
"os.makedirs"
] | [((1950, 1967), 'os.makedirs', 'os.makedirs', (['path'], {}), '(path)\n', (1961, 1967), False, 'import os\n'), ((2050, 2069), 'os.path.isdir', 'os.path.isdir', (['path'], {}), '(path)\n', (2063, 2069), False, 'import os\n')] |
from datetime import datetime, timedelta
from typing import Callable
from unittest.mock import MagicMock, patch
import pandas as pd
import pytest
from _pytest.monkeypatch import MonkeyPatch
from pybaseball import cache
@pytest.fixture(name="mock_data_1")
def _mock_data_1() -> pd.DataFrame:
return pd.DataFrame([1... | [
"pybaseball.cache.df_cache",
"pandas.DataFrame",
"unittest.mock.MagicMock",
"pybaseball.cache.cache.df_cache",
"pybaseball.cache.purge",
"pybaseball.cache.enable",
"pybaseball.cache.disable",
"unittest.mock.patch.object",
"pytest.fixture",
"pandas.testing.assert_frame_equal",
"pybaseball.cache.f... | [((223, 257), 'pytest.fixture', 'pytest.fixture', ([], {'name': '"""mock_data_1"""'}), "(name='mock_data_1')\n", (237, 257), False, 'import pytest\n'), ((344, 382), 'pytest.fixture', 'pytest.fixture', ([], {'name': '"""empty_load_mock"""'}), "(name='empty_load_mock')\n", (358, 382), False, 'import pytest\n'), ((581, 61... |
import firebase_admin
from fireo.models import Model
from fireo import fields, connection
from fireo.fields import errors
from firebase_admin import firestore as _firestore
from firebase_admin import credentials
from google.cloud import firestore
from settings import FIREBASE_OPTIONS, DEV, FIREBASE_SERVICE_ACCOUNT
if... | [
"firebase_admin.initialize_app",
"fireo.fields.TextField",
"fireo.fields.IDField",
"fireo.fields.errors.FieldValidationFailed",
"fireo.connection",
"firebase_admin.firestore.client",
"firebase_admin.credentials.Certificate",
"fireo.fields.DateTime"
] | [((556, 575), 'firebase_admin.firestore.client', '_firestore.client', ([], {}), '()\n', (573, 575), True, 'from firebase_admin import firestore as _firestore\n'), ((341, 390), 'firebase_admin.credentials.Certificate', 'credentials.Certificate', (['FIREBASE_SERVICE_ACCOUNT'], {}), '(FIREBASE_SERVICE_ACCOUNT)\n', (364, 3... |
import chess
import board
def is_back_rank_mate(fen, move):
"""
According to Wikipedia:
> In chess, a back-rank checkmate (also known as the corridor mate) is a checkmate delivered by a rook or queen
> along a back rank (that is, the row on which the pieces [not pawns] stand at the start of the game)... | [
"board.AugBoard",
"chess.square_rank"
] | [((552, 571), 'board.AugBoard', 'board.AugBoard', (['fen'], {}), '(fen)\n', (566, 571), False, 'import board\n'), ((1218, 1243), 'chess.square_rank', 'chess.square_rank', (['square'], {}), '(square)\n', (1235, 1243), False, 'import chess\n'), ((745, 774), 'chess.square_rank', 'chess.square_rank', (['their_king'], {}), ... |
import torch
from torch import nn
import torch.nn.functional as F
# torch.Size([1, 18, 104, 104])
# torch.Size([1, 36, 52, 52])
# torch.Size([1, 72, 26, 26])
# torch.Size([1, 144, 13, 13])
class ConcatHead(nn.Module):
'''
把 backbone 的多尺度输出合在一起
'''
def __init__(self, args):
super().__init__()
... | [
"torch.nn.Sigmoid",
"torch.nn.ReLU",
"torch.nn.Conv2d",
"torch.nn.functional.interpolate",
"torch.cat"
] | [((561, 592), 'torch.cat', 'torch.cat', (['upsample_list'], {'dim': '(1)'}), '(upsample_list, dim=1)\n', (570, 592), False, 'import torch\n'), ((795, 828), 'torch.cat', 'torch.cat', (['downsample_list'], {'dim': '(1)'}), '(downsample_list, dim=1)\n', (804, 828), False, 'import torch\n'), ((1245, 1276), 'torch.cat', 'to... |
# Copyright 2020 Huawei Technologies Co., Ltd
#
# 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 a... | [
"mindspore.ops.op_info_register.op_info_register",
"te.tik.Dprofile",
"mindspore.ops.op_info_register.TBERegOp",
"topi.cce.util.get_product_version"
] | [((1470, 1503), 'mindspore.ops.op_info_register.op_info_register', 'op_info_register', (['dsd_matmul_info'], {}), '(dsd_matmul_info)\n', (1486, 1503), False, 'from mindspore.ops.op_info_register import DataType, TBERegOp, op_info_register\n'), ((1763, 1789), 'topi.cce.util.get_product_version', 'util.get_product_versio... |
import numpy as np
from rlscore.learner import LeaveOneOutRLS
from rlscore.measure import sqerror
from housing_data import load_housing
def train_rls():
#Selects both the gamma parameter for Gaussian kernel, and regparam with loocv
X_train, Y_train, X_test, Y_test = load_housing()
regparams = [2.**i for ... | [
"rlscore.measure.sqerror",
"housing_data.load_housing",
"rlscore.learner.LeaveOneOutRLS",
"numpy.min"
] | [((278, 292), 'housing_data.load_housing', 'load_housing', ([], {}), '()\n', (290, 292), False, 'from housing_data import load_housing\n'), ((566, 661), 'rlscore.learner.LeaveOneOutRLS', 'LeaveOneOutRLS', (['X_train', 'Y_train'], {'kernel': '"""GaussianKernel"""', 'gamma': 'gamma', 'regparams': 'regparams'}), "(X_train... |
import json # For saving and loading games
import re # Ensure that moves only use alphanumeric characters
import bisect # Lets us insert into a sorted list
class Game(object):
def __init__(self):
self.moves = []
self.beats = {} # Antisymmetric square matrix with elements in {-1, 0, 1}
def getM... | [
"json.load",
"bisect.insort",
"re.match",
"json.dump"
] | [((811, 842), 'bisect.insort', 'bisect.insort', (['self.moves', 'move'], {}), '(self.moves, move)\n', (824, 842), False, 'import bisect\n'), ((684, 716), 're.match', 're.match', (['"""^[a-zA-z0-9]+$"""', 'move'], {}), "('^[a-zA-z0-9]+$', move)\n", (692, 716), False, 'import re\n'), ((3094, 3117), 'json.dump', 'json.dum... |
# Generated by Django 2.2.13 on 2020-10-09 17:57
import django.db.models.deletion
import django.utils.timezone
import model_utils.fields
from django.db import migrations, models
import waldur_core.core.fields
import waldur_core.core.models
import waldur_core.core.shims
import waldur_core.core.validators
import waldur... | [
"django.db.models.AutoField",
"django.db.models.CharField",
"django.db.models.ForeignKey"
] | [((679, 772), 'django.db.models.AutoField', 'models.AutoField', ([], {'auto_created': '(True)', 'primary_key': '(True)', 'serialize': '(False)', 'verbose_name': '"""ID"""'}), "(auto_created=True, primary_key=True, serialize=False,\n verbose_name='ID')\n", (695, 772), False, 'from django.db import migrations, models\... |
"""
Train the regressor and plot the results
"""
import os
import numpy as np
from matplotlib import pyplot as plt
from sklearn.preprocessing import StandardScaler
from linear_model import LinearRegressionGD
def train_reg(df):
X = df[['RM']].values
y = df['MEDV'].values
sc_x = StandardScaler()
sc_y = StandardScale... | [
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.gcf",
"linear_model.LinearRegressionGD",
"matplotlib.pyplot.xlabel",
"os.getcwd",
"sklearn.preprocessing.StandardScaler",
"os.mkdir",
"matplotlib.pyplot.scatter"
] | [((282, 298), 'sklearn.preprocessing.StandardScaler', 'StandardScaler', ([], {}), '()\n', (296, 298), False, 'from sklearn.preprocessing import StandardScaler\n'), ((307, 323), 'sklearn.preprocessing.StandardScaler', 'StandardScaler', ([], {}), '()\n', (321, 323), False, 'from sklearn.preprocessing import StandardScale... |
from dash import html, dcc
APP_CONSTANTS = {
"graph_color" : '#23359d'
}
def Header(app):
return html.Div([get_header(app), html.Br([]), get_menu()])
def get_header(app):
header = html.Div(
[
html.Div(
[
html.A(
[
... | [
"dash.html.Td",
"dash.html.Tr",
"dash.dcc.Link",
"dash.html.Br",
"dash.html.H5"
] | [((135, 146), 'dash.html.Br', 'html.Br', (['[]'], {}), '([])\n', (142, 146), False, 'from dash import html, dcc\n'), ((1461, 1522), 'dash.dcc.Link', 'dcc.Link', (['"""Overview"""'], {'href': '"""/overview"""', 'className': '"""tab first"""'}), "('Overview', href='/overview', className='tab first')\n", (1469, 1522), Fal... |
import os
from waterbutler.core import metadata
class S3CompatMetadata(metadata.BaseMetadata):
@property
def provider(self):
return self.raw['provider']
@property
def name(self):
return os.path.split(self.path)[1]
@staticmethod
def convert_prefix(provider, raw, key):
... | [
"os.path.split"
] | [((223, 247), 'os.path.split', 'os.path.split', (['self.path'], {}), '(self.path)\n', (236, 247), False, 'import os\n')] |
import re,subprocess
gitcommand = 'git log origin..master --format="- %s"'
news = subprocess.check_output(gitcommand, shell=True).decode('utf-8')
if len(news)<2:
print("Nothing new.")
exit()
f = open("CHANGELOG.txt", "rb")
changelog = f.read()
f.close()
ver = re.match("(\d+)\.(\d+)\.(\d+)\.(\d+)", changelog.dec... | [
"subprocess.check_output"
] | [((84, 131), 'subprocess.check_output', 'subprocess.check_output', (['gitcommand'], {'shell': '(True)'}), '(gitcommand, shell=True)\n', (107, 131), False, 'import re, subprocess\n')] |
# coding=utf-8
from selenium import webdriver
import time
from selenium.webdriver.common.by import By
from selenium.webdriver.common.keys import Keys
from selenium.webdriver.support import expected_conditions as EC
class Login():
def __init__(self):
self.driver = webdriver.Chrome()
self.driver.get... | [
"selenium.webdriver.Chrome"
] | [((278, 296), 'selenium.webdriver.Chrome', 'webdriver.Chrome', ([], {}), '()\n', (294, 296), False, 'from selenium import webdriver\n')] |
# Generated by Django 2.2.5 on 2019-09-24 09:16
import django.db.models.deletion
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('mysign_app', '0001_initial'),
]
operations = [
migrations.AddField(
model_name='user',
... | [
"django.db.models.ForeignKey",
"django.db.models.BooleanField"
] | [((359, 393), 'django.db.models.BooleanField', 'models.BooleanField', ([], {'default': '(False)'}), '(default=False)\n', (378, 393), False, 'from django.db import migrations, models\n'), ((556, 671), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'blank': '(True)', 'null': '(True)', 'on_delete': 'django.db.m... |
"""
Gaussian Transformation with Scikit-learn
- Scikit-learn has recently released transformers to do Gaussian mappings as they call the variable transformations.
The PowerTransformer allows to do Box-Cox and Yeo-Johnson transformation.
With the FunctionTransformer, we can specify any function we... | [
"pandas.read_csv",
"numpy.where",
"sklearn.preprocessing.PowerTransformer",
"matplotlib.pyplot.figure",
"pandas.DataFrame",
"sklearn.preprocessing.FunctionTransformer",
"scipy.stats.probplot",
"matplotlib.pyplot.subplot",
"matplotlib.pyplot.show"
] | [((1400, 1476), 'pandas.read_csv', 'pd.read_csv', (['"""dataset/house-prices-advanced-regression-techniques/train.csv"""'], {}), "('dataset/house-prices-advanced-regression-techniques/train.csv')\n", (1411, 1476), True, 'import pandas as pd\n'), ((3426, 3436), 'matplotlib.pyplot.show', 'plt.show', ([], {}), '()\n', (34... |
import datetime
import os
from functools import lru_cache
import json
import cherrypy
import tinydb
ROOTDIR = os.path.dirname(os.path.abspath(__file__))
class RequestStorage:
def __init__(self):
if "HOGGER_PERSIST" in os.environ:
self.storage = tinydb.TinyDB("hogger.json")
else:
... | [
"cherrypy.tools.json_out",
"cherrypy.tree.mount",
"tinydb.TinyDB",
"cherrypy.request.params.items",
"cherrypy.engine.block",
"os.environ.get",
"cherrypy.config.update",
"os.path.join",
"json.load",
"datetime.datetime.now",
"cherrypy.engine.start",
"os.path.abspath",
"functools.lru_cache",
... | [((127, 152), 'os.path.abspath', 'os.path.abspath', (['__file__'], {}), '(__file__)\n', (142, 152), False, 'import os\n'), ((742, 767), 'cherrypy.tools.json_out', 'cherrypy.tools.json_out', ([], {}), '()\n', (765, 767), False, 'import cherrypy\n'), ((1577, 1597), 'functools.lru_cache', 'lru_cache', ([], {'maxsize': '(2... |
# MIT Licensed. Copyright (c) 2017
import sqlite3
from sqlalchemy import create_engine
from sqlalchemy.ext.automap import automap_base
# Setup our connection to the database
engine = create_engine('sqlite+pysqlite:///license_database.sqlite3', module=sqlite3)
Base = automap_base()
Base.prepare(engine, reflect=True) | [
"sqlalchemy.ext.automap.automap_base",
"sqlalchemy.create_engine"
] | [((184, 260), 'sqlalchemy.create_engine', 'create_engine', (['"""sqlite+pysqlite:///license_database.sqlite3"""'], {'module': 'sqlite3'}), "('sqlite+pysqlite:///license_database.sqlite3', module=sqlite3)\n", (197, 260), False, 'from sqlalchemy import create_engine\n'), ((268, 282), 'sqlalchemy.ext.automap.automap_base'... |
from django.db import models
from django.db.models.deletion import CASCADE
from foods.models import Foods
from phasesDay.models import PhasesDay
from users.models import User
class Favourites(models.Model):
name = models.CharField(max_length=255, blank=False, null=False)
description = models.TextField(blank=... | [
"django.db.models.TextField",
"django.db.models.ForeignKey",
"django.db.models.ManyToManyField",
"django.db.models.DateTimeField",
"django.db.models.CharField"
] | [((221, 278), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(255)', 'blank': '(False)', 'null': '(False)'}), '(max_length=255, blank=False, null=False)\n', (237, 278), False, 'from django.db import models\n'), ((297, 336), 'django.db.models.TextField', 'models.TextField', ([], {'blank': '(True)... |
#!/usr/bin/env python
import rospy
from net_box_hardware_helper import NetBoxRosWrapper
if __name__== "__main__":
rospy.init_node("force_torque_sensor")
sensor=NetBoxRosWrapper()
rospy.spin() | [
"rospy.init_node",
"net_box_hardware_helper.NetBoxRosWrapper",
"rospy.spin"
] | [((119, 157), 'rospy.init_node', 'rospy.init_node', (['"""force_torque_sensor"""'], {}), "('force_torque_sensor')\n", (134, 157), False, 'import rospy\n'), ((169, 187), 'net_box_hardware_helper.NetBoxRosWrapper', 'NetBoxRosWrapper', ([], {}), '()\n', (185, 187), False, 'from net_box_hardware_helper import NetBoxRosWrap... |
# Generated by Django 4.0 on 2021-12-24 10:35
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('product', '0003_remove_product_category'),
]
operations = [
migrations.AddField(
model_name='prod... | [
"django.db.models.ForeignKey"
] | [((373, 473), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'default': '(6)', 'on_delete': 'django.db.models.deletion.CASCADE', 'to': '"""product.category"""'}), "(default=6, on_delete=django.db.models.deletion.CASCADE,\n to='product.category')\n", (390, 473), False, 'from django.db import migrations, mo... |
import unittest
from MyStringBuilder import MyStringBuilder
class MyStringBuilderTests(unittest.TestCase):
def test_when_append_one_time_then_ToString_returns_the_text(self):
sut = MyStringBuilder()
sut.Append("Initial sentence..")
self.assertEqual("Initial sentence..", sut.ToString())
... | [
"unittest.main",
"MyStringBuilder.MyStringBuilder"
] | [((634, 649), 'unittest.main', 'unittest.main', ([], {}), '()\n', (647, 649), False, 'import unittest\n'), ((195, 212), 'MyStringBuilder.MyStringBuilder', 'MyStringBuilder', ([], {}), '()\n', (210, 212), False, 'from MyStringBuilder import MyStringBuilder\n'), ((405, 422), 'MyStringBuilder.MyStringBuilder', 'MyStringBu... |
"""Test each form directly for expected validation behavior."""
from django.contrib.auth.models import User
from django.test import TestCase, Client
from issues.forms import (
UserForm,
UserGroupForm,
ManagePasswordForm,
ProjectForm,
ProjectIssueForm,
IssueForm,
CommentForm,
ReplyForm
... | [
"issues.forms.UserGroupForm",
"issues.models.Project.objects.get",
"issues.forms.ProjectForm",
"issues.forms.ProjectIssueForm",
"issues.forms.ReplyForm",
"issues.forms.UserForm",
"issues.forms.IssueForm",
"django.contrib.auth.models.User.objects.get",
"issues.forms.CommentForm",
"issues.forms.Mana... | [((524, 642), 'issues.forms.UserForm', 'UserForm', ([], {'data': "{'first_name': 'John', 'last_name': 'Doe', 'username': 'jd', 'email':\n '<EMAIL>', 'select_group': 3}"}), "(data={'first_name': 'John', 'last_name': 'Doe', 'username': 'jd',\n 'email': '<EMAIL>', 'select_group': 3})\n", (532, 642), False, 'from iss... |
# -*- coding: utf-8 -*-
# Generated by Django 1.11.28 on 2021-03-16 13:27
from __future__ import unicode_literals
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('osme', '0001_initial'),
]
operations = [
migrations.RemoveField(
... | [
"django.db.migrations.RemoveField",
"django.db.models.CharField"
] | [((287, 351), 'django.db.migrations.RemoveField', 'migrations.RemoveField', ([], {'model_name': '"""region"""', 'name': '"""query_string"""'}), "(model_name='region', name='query_string')\n", (309, 351), False, 'from django.db import migrations, models\n'), ((495, 581), 'django.db.models.CharField', 'models.CharField',... |
import tkstyle
from cyberpunk_theme import constant
def get_style(font_family=constant.FONT_FAMILY,
font_size=constant.FONT_SIZE):
style = tkstyle.LabelFrame()
style.font = (font_family, font_size, "normal")
style.background = constant.BACKGROUND_COLOR
style.foreground = "#B0B0B0"
st... | [
"tkstyle.LabelFrame"
] | [((159, 179), 'tkstyle.LabelFrame', 'tkstyle.LabelFrame', ([], {}), '()\n', (177, 179), False, 'import tkstyle\n')] |
from django.db import models
from django import forms
import re
class UserManager(models.Manager):
def register_validator(self, post_data):
errors = {}
EMAIL_REGEX = re.compile(r'^[a-zA-Z0-9.+_-]+@[a-zA-Z0-9._-]+\.[a-zA-Z]+$')
if len(post_data['first_name']) < 1:
errors['first_n... | [
"django.db.models.EmailField",
"django.db.models.IntegerField",
"django.db.models.ForeignKey",
"re.compile",
"django.db.models.BooleanField",
"django.db.models.DateTimeField",
"django.db.models.CharField"
] | [((915, 946), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(20)'}), '(max_length=20)\n', (931, 946), False, 'from django.db import models\n'), ((963, 994), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(20)'}), '(max_length=20)\n', (979, 994), False, 'from django.db im... |
# Copyright (c) 2011-2020 <NAME>
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distrib... | [
"ba.WeakCall",
"ba.internal.get_store_item_display_size",
"_ba.get_price",
"ba.containerwidget",
"ba.getsound",
"_ba.purchase",
"ba.Lstr",
"bastd.ui.store.item.instantiate_store_item_display",
"ba.textwidget",
"bastd.ui.getcurrency.show_get_tickets_prompt",
"_ba.in_game_purchase",
"_ba.get_pur... | [((2548, 2787), 'ba.textwidget', 'ba.textwidget', ([], {'parent': 'self._root_widget', 'position': '(self._width * 0.5, self._height - 30)', 'size': '(0, 0)', 'text': 'header_text', 'h_align': '"""center"""', 'v_align': '"""center"""', 'maxwidth': '(self._width * 0.9 - 120)', 'scale': '(1.2)', 'color': '(1, 0.8, 0.3, 1... |
"""SQLAlchemy Metadata and Session object"""
from sqlalchemy import MetaData
from sqlalchemy.orm import scoped_session, sessionmaker
import pylons
__all__ = ['Session', 'metadata']
# SQLAlchemy database engine. Updated by model.init_model().
engine = None
# SQLAlchemy session manager. Updated by model.init_model(... | [
"sqlalchemy.MetaData"
] | [((475, 485), 'sqlalchemy.MetaData', 'MetaData', ([], {}), '()\n', (483, 485), False, 'from sqlalchemy import MetaData\n')] |
"""
.. versionadded:: 0.4
This function generates Uniform white noise series. This function uses
`numpy.random.uniform`.
Function Documentation
======================================
"""
import numpy as np
def uniform_white_noise(n, minimum=-1, maximum=1):
"""
Random values with uniform distribution.
**... | [
"numpy.random.uniform"
] | [((632, 684), 'numpy.random.uniform', 'np.random.uniform', ([], {'low': 'minimum', 'high': 'maximum', 'size': 'n'}), '(low=minimum, high=maximum, size=n)\n', (649, 684), True, 'import numpy as np\n')] |
from typing import Type, final
from aioddd import Command, CommandHandler
from pydantic import BaseModel, Field
from project.libs.user.application.password_changer_service import (
UserPasswordChangerService,
)
from project.libs.user.domain.properties import UserId, UserPassword
@final
class ChangeUserPasswordC... | [
"pydantic.Field",
"project.libs.user.domain.properties.UserPassword",
"project.libs.user.domain.properties.UserId"
] | [((367, 384), 'pydantic.Field', 'Field', ([], {'alias': '"""id"""'}), "(alias='id')\n", (372, 384), False, 'from pydantic import BaseModel, Field\n'), ((812, 835), 'project.libs.user.domain.properties.UserId', 'UserId', (['command.user_id'], {}), '(command.user_id)\n', (818, 835), False, 'from project.libs.user.domain.... |
import logging
import time
import json
import requests
class MattermostAPI:
def __init__(self, url, team, token=""):
self.url = url
self.token = token
self.team = team
self.team_id = ""
def get(self, request):
"""
Used to make get calls to mattermost api
... | [
"json.loads",
"json.dumps",
"requests.get"
] | [((440, 489), 'requests.get', 'requests.get', (['(self.url + request)'], {'headers': 'headers'}), '(self.url + request, headers=headers)\n', (452, 489), False, 'import requests\n'), ((505, 523), 'json.loads', 'json.loads', (['g.text'], {}), '(g.text)\n', (515, 523), False, 'import json\n'), ((913, 931), 'json.loads', '... |