code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
from django.contrib import admin
from django.urls import path
from django.urls import path, include
from .views import CommentView, comment_vote
app_name = "home"
urlpatterns = [
path("", CommentView.as_view(), name="comment"),
path("<int:comment_id>/vote", comment_vote, name="comment-vote"),
]
| [
"django.urls.path"
] | [((237, 301), 'django.urls.path', 'path', (['"""<int:comment_id>/vote"""', 'comment_vote'], {'name': '"""comment-vote"""'}), "('<int:comment_id>/vote', comment_vote, name='comment-vote')\n", (241, 301), False, 'from django.urls import path, include\n')] |
"""
Parsing text file into Experiment instance using strictyaml
(github.com/crdoconnor/strictyaml/)
The aim here is to make config:
* possible to use even for non-programmers
* hard to misuse
* easy debuggable
Hence, the process of parsing config is a bit more complicated than
it could be, but it produces more useful... | [
"strictyaml.Any",
"strictyaml.Bool",
"strictyaml.Int",
"strictyaml.dirty_load",
"strictyaml.Str",
"strictyaml.Seq",
"strictyaml.Optional",
"strictyaml.EmptyDict",
"strictyaml.EmptyNone",
"inspect.signature",
"strictyaml.Float",
"docstring_parser.parse",
"strictyaml.Map",
"strictyaml.EmptyL... | [((4369, 4374), 'strictyaml.Any', 'Any', ([], {}), '()\n', (4372, 4374), False, 'from strictyaml import Any, Optional, EmptyDict, EmptyNone, EmptyList\n'), ((2500, 2505), 'strictyaml.Int', 'Int', ([], {}), '()\n', (2503, 2505), False, 'from strictyaml import Map, Str, Int, Seq, Float, Bool\n'), ((2515, 2521), 'strictya... |
# -*- coding: utf-8 -*-
import json
from urllib import parse
import scrapy
from locations.items import GeojsonPointItem
class VueCinemasSpider(scrapy.Spider):
name = "vue_cinemas"
start_urls = ("https://www.myvue.com/data/locations/",)
def parse(self, response):
data = json.loads(response.body_as... | [
"urllib.parse.parse_qs",
"urllib.parse.urlparse",
"locations.items.GeojsonPointItem"
] | [((1381, 1409), 'urllib.parse.parse_qs', 'parse.parse_qs', (['query_string'], {}), '(query_string)\n', (1395, 1409), False, 'from urllib import parse\n'), ((1328, 1353), 'urllib.parse.urlparse', 'parse.urlparse', (['maps_link'], {}), '(maps_link)\n', (1342, 1353), False, 'from urllib import parse\n'), ((1819, 1849), 'l... |
from sklearn.decomposition import NMF, LatentDirichletAllocation
import numpy as np
import os
def write_lines(string, saveFile):
open("%s" %saveFile, "a").write(string+"\n")
###
def save_topics(model, feature_names, saveFile, topic_nums, top_words_nums):
# saveFile= "%s/LDA_TopWords_Topic%s.txt" %(saveFileDi... | [
"os.path.exists",
"numpy.argmax",
"numpy.savetxt",
"sklearn.decomposition.LatentDirichletAllocation",
"os.remove"
] | [((1269, 1293), 'os.path.exists', 'os.path.exists', (['saveFile'], {}), '(saveFile)\n', (1283, 1293), False, 'import os\n'), ((1474, 1563), 'numpy.savetxt', 'np.savetxt', (["('%s_Topic_Words_matrix.txt' % saveFileHeader)", 'lda.components_'], {'fmt': '"""%.6f"""'}), "('%s_Topic_Words_matrix.txt' % saveFileHeader, lda.c... |
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import migrations
def add_91_room_functional_names(apps, schema_editor):
map = {
'Hibiscus': 'Breakout 3',
'South Pacific 2': 'Meeting Room #6',
'South Pacific 1': 'Terminal Room',
... | [
"django.db.migrations.RunPython"
] | [((1732, 1782), 'django.db.migrations.RunPython', 'migrations.RunPython', (['add_91_room_functional_names'], {}), '(add_91_room_functional_names)\n', (1752, 1782), False, 'from django.db import migrations\n')] |
# -*- coding: utf-8 -*-
# HINT:image
import chainer
import chainer.functions as F
import chainer.links as L
"""
GoogLeNet:
Going Deeper with Convolutions
http://www.cs.unc.edu/~wliu/papers/GoogLeNet.pdf
##############################
## DO NOT CHANGE CLASS NAME ##
##############################
"""
class Network(cha... | [
"chainer.functions.softmax_cross_entropy",
"chainer.Variable",
"chainer.functions.softmax",
"chainer.functions.average_pooling_2d",
"chainer.links.Linear",
"chainer.links.Convolution2D",
"chainer.links.BatchNormalization",
"chainer.links.InceptionBN",
"chainer.functions.accuracy"
] | [((2870, 2906), 'chainer.functions.average_pooling_2d', 'F.average_pooling_2d', (['h', '(5)'], {'stride': '(3)'}), '(h, 5, stride=3)\n', (2890, 2906), True, 'import chainer.functions as F\n'), ((3067, 3096), 'chainer.functions.softmax_cross_entropy', 'F.softmax_cross_entropy', (['a', 't'], {}), '(a, t)\n', (3090, 3096)... |
# hardware imports
import gc
import board
from board import DISPLAY as display
import displayio
import adafruit_touchscreen
# TG-Gui setup imports
from tg_gui_core import *
from tg_gui_std import *
from tg_gui_std.event_loops import SinglePointEventLoop
from tg_gui_std.root_wrapper import DisplayioRootWrapper, Displa... | [
"board.DISPLAY.refresh",
"board.DISPLAY.show",
"displayio.Group",
"adafruit_touchscreen.Touchscreen",
"tg_gui_std.root_wrapper.DisplayioRootWrapper",
"gc.collect",
"tg_gui_std.event_loops.SinglePointEventLoop"
] | [((358, 375), 'displayio.Group', 'displayio.Group', ([], {}), '()\n', (373, 375), False, 'import displayio\n'), ((376, 396), 'board.DISPLAY.show', 'display.show', (['splash'], {}), '(splash)\n', (388, 396), True, 'from board import DISPLAY as display\n'), ((412, 578), 'adafruit_touchscreen.Touchscreen', 'adafruit_touch... |
# coding=utf-8
import requests
from lxml import etree
import json
import re
from urllib.parse import unquote
import time
import os
class TiebaSpider:
def __init__(self, tiebaName):
self.tiebaName = tiebaName
self.host = "http://tieba.baidu.com/mo/q---,sz@320_240-1-3"
self.startUrl = self.h... | [
"os.path.exists",
"json.dumps",
"requests.get",
"lxml.etree.HTML",
"os.mkdir",
"re.sub",
"urllib.parse.unquote",
"re.search"
] | [((644, 683), 'requests.get', 'requests.get', (['url'], {'headers': 'self.headers'}), '(url, headers=self.headers)\n', (656, 683), False, 'import requests\n'), ((1209, 1228), 'lxml.etree.HTML', 'etree.HTML', (['htmlStr'], {}), '(htmlStr)\n', (1219, 1228), False, 'from lxml import etree\n'), ((2122, 2146), 'lxml.etree.H... |
from linode_api4.errors import UnexpectedResponseError
from linode_api4.objects import Base, Property
class AuthorizedApp(Base):
api_endpoint = "/profile/apps/{id}"
properties = {
"id": Property(identifier=True),
"scopes": Property(),
"label": Property(),
"created": Property(i... | [
"linode_api4.objects.account.UserGrants",
"linode_api4.objects.Property",
"linode_api4.errors.UnexpectedResponseError"
] | [((205, 230), 'linode_api4.objects.Property', 'Property', ([], {'identifier': '(True)'}), '(identifier=True)\n', (213, 230), False, 'from linode_api4.objects import Base, Property\n'), ((250, 260), 'linode_api4.objects.Property', 'Property', ([], {}), '()\n', (258, 260), False, 'from linode_api4.objects import Base, Pr... |
from __future__ import annotations
import io
import os
import subprocess
import textwrap
import unittest
from typing import Sequence
from unittest import mock
from dconf_manager import HierarchicalSet
from dconf_manager import main
EXPECTED_OUTPUT = """\
\033[32m> add/AddedKey=1
\033[31m< clear/foo/bar/blah=50
\033[... | [
"textwrap.dedent",
"dconf_manager.main",
"unittest.mock.call",
"os.path.dirname",
"io.StringIO",
"unittest.mock.patch"
] | [((2245, 2283), 'unittest.mock.patch', 'mock.patch', (['"""dconf_manager.dconf_dump"""'], {}), "('dconf_manager.dconf_dump')\n", (2255, 2283), False, 'from unittest import mock\n'), ((2289, 2328), 'unittest.mock.patch', 'mock.patch', (['"""dconf_manager.dconf_write"""'], {}), "('dconf_manager.dconf_write')\n", (2299, 2... |
import asyncio
from decimal import Decimal
from typing import Any, Dict, Optional, Tuple
from hummingbot.connector.exchange.bitmart import bitmart_utils
from hummingbot.connector.in_flight_order_base import InFlightOrderBase
from hummingbot.core.event.events import OrderType, TradeType
class BitmartInFlightOrder(InF... | [
"decimal.Decimal",
"hummingbot.connector.exchange.bitmart.bitmart_utils.get_ms_timestamp",
"asyncio.Event"
] | [((1058, 1073), 'asyncio.Event', 'asyncio.Event', ([], {}), '()\n', (1071, 1073), False, 'import asyncio\n'), ((1951, 1987), 'decimal.Decimal', 'Decimal', (["trade_update['filled_size']"], {}), "(trade_update['filled_size'])\n", (1958, 1987), False, 'from decimal import Decimal\n'), ((2020, 2060), 'decimal.Decimal', 'D... |
from tensorflow.keras import Input, Dense, Flatten, LSTM
from keras.models import Model, Sequential
import pandas as pd
input_size = 9
df = pd.read_csv("adjusted.csv")
data_input = Input(shape=(input_size,))
hidden = Dense(20, activation="softplus")(data_input)
hidden = Dense(10, activation="softplus")(hidden)
hid... | [
"keras.models.Model",
"tensorflow.keras.Input",
"pandas.read_csv",
"tensorflow.keras.Dense"
] | [((143, 170), 'pandas.read_csv', 'pd.read_csv', (['"""adjusted.csv"""'], {}), "('adjusted.csv')\n", (154, 170), True, 'import pandas as pd\n'), ((185, 211), 'tensorflow.keras.Input', 'Input', ([], {'shape': '(input_size,)'}), '(shape=(input_size,))\n', (190, 211), False, 'from tensorflow.keras import Input, Dense, Flat... |
# -*- coding:utf-8 -*-
import unittest
import mock
from django.core.urlresolvers import reverse
from django import forms
from libs import constants as lib_constants
from ..views import BusinessFormView
class BusinessFormViewTestCase(unittest.TestCase):
def test_get_should_call_render_to_response_with_business_f... | [
"mock.Mock",
"django.core.urlresolvers.reverse"
] | [((415, 426), 'mock.Mock', 'mock.Mock', ([], {}), '()\n', (424, 426), False, 'import mock\n'), ((1163, 1174), 'mock.Mock', 'mock.Mock', ([], {}), '()\n', (1172, 1174), False, 'import mock\n'), ((1989, 2000), 'mock.Mock', 'mock.Mock', ([], {}), '()\n', (1998, 2000), False, 'import mock\n'), ((2024, 2052), 'django.core.u... |
# Copyright 2021 Alibaba Group Holding Limited. All Rights Reserved.
#
# 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 ... | [
"unittest.main",
"os.urandom",
"xfl.data.psi.ecc_signer.EccSigner"
] | [((1969, 1995), 'unittest.main', 'unittest.main', ([], {'verbosity': '(1)'}), '(verbosity=1)\n', (1982, 1995), False, 'import unittest\n'), ((989, 1003), 'os.urandom', 'os.urandom', (['(32)'], {}), '(32)\n', (999, 1003), False, 'import os\n'), ((1059, 1070), 'xfl.data.psi.ecc_signer.EccSigner', 'EccSigner', ([], {}), '... |
# coding: utf-8
#
# Copyright 2021 The Oppia Authors. All Rights Reserved.
#
# 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 requi... | [
"mypy_imports.translation_models.MachineTranslationModel.get_deletion_policy",
"mypy_imports.translation_models.MachineTranslationModel.get_model_association_to_user",
"mypy_imports.translation_models.EntityTranslationsModel.get_deletion_policy",
"mypy_imports.translation_models.MachineTranslationModel.create... | [((962, 1049), 'core.platform.models.Registry.import_models', 'models.Registry.import_models', (['[models.NAMES.base_model, models.NAMES.translation]'], {}), '([models.NAMES.base_model, models.NAMES.\n translation])\n', (991, 1049), False, 'from core.platform import models\n'), ((1267, 1459), 'mypy_imports.translati... |
from .analysis import Gini, LorenzPlot
from nakamoto.coefficient import SectorNakamoto
import uuid
import numpy as np
class Sector(object):
def __init__(self, currency, **kwargs):
self.uuid = uuid.uuid4()
self.data = None
self.type = None
self.plot_notebook = kwargs.get('plot_note... | [
"nakamoto.coefficient.SectorNakamoto",
"uuid.uuid4"
] | [((206, 218), 'uuid.uuid4', 'uuid.uuid4', ([], {}), '()\n', (216, 218), False, 'import uuid\n'), ((995, 1027), 'nakamoto.coefficient.SectorNakamoto', 'SectorNakamoto', (['self.lorenz_data'], {}), '(self.lorenz_data)\n', (1009, 1027), False, 'from nakamoto.coefficient import SectorNakamoto\n'), ((2479, 2491), 'uuid.uuid... |
"""Useful hooks for debugging."""
from __future__ import annotations
import logging
from typing import TYPE_CHECKING
import msgpack
from wingline import hasher
from wingline.types import PayloadIterator
logger = logging.getLogger(__name__)
if TYPE_CHECKING:
from wingline import plumbing
from wingline.plumbi... | [
"logging.getLogger",
"msgpack.packb",
"wingline.plumbing.input_queue.qsize"
] | [((216, 243), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (233, 243), False, 'import logging\n'), ((699, 727), 'wingline.plumbing.input_queue.qsize', 'plumbing.input_queue.qsize', ([], {}), '()\n', (725, 727), False, 'from wingline import plumbing\n'), ((622, 644), 'msgpack.packb', 'ms... |
from argparse import ArgumentParser
from pathlib import Path
import torch
import torch.nn.functional as F
from torch import nn
from torch.optim import SGD
from torch.optim.lr_scheduler import StepLR
from torch.utils.data import DataLoader
from torchvision.datasets import MNIST
from torchvision.transforms import Compos... | [
"ignite.metrics.Loss",
"ignite.metrics.Accuracy",
"ignite.handlers.Checkpoint.load_objects",
"torch.cuda.is_available",
"ignite.engine.create_supervised_trainer",
"torch.utils.tensorboard.SummaryWriter",
"argparse.ArgumentParser",
"tqdm.tqdm.write",
"pathlib.Path",
"ignite.handlers.DiskSaver",
"... | [((4565, 4580), 'ignite.utils.manual_seed', 'manual_seed', (['(75)'], {}), '(75)\n', (4576, 4580), False, 'from ignite.utils import manual_seed\n'), ((4695, 4725), 'torch.utils.tensorboard.SummaryWriter', 'SummaryWriter', ([], {'log_dir': 'log_dir'}), '(log_dir=log_dir)\n', (4708, 4725), False, 'from torch.utils.tensor... |
import jax.numpy as jnp
from ivy.functional.backends.jax import JaxArray
from typing import Optional
def argmax(
x: JaxArray,
axis: Optional[int] = None,
out: Optional[JaxArray] = None,
keepdims: bool = False
) -> JaxArray:
return jnp.argmax(x, axis=axis, out=out, keepdims=keepdims)
def argm... | [
"jax.numpy.argmax",
"jax.numpy.nonzero",
"jax.numpy.where",
"jax.numpy.argmin"
] | [((257, 309), 'jax.numpy.argmax', 'jnp.argmax', (['x'], {'axis': 'axis', 'out': 'out', 'keepdims': 'keepdims'}), '(x, axis=axis, out=out, keepdims=keepdims)\n', (267, 309), True, 'import jax.numpy as jnp\n'), ((486, 538), 'jax.numpy.argmin', 'jnp.argmin', (['x'], {'axis': 'axis', 'out': 'out', 'keepdims': 'keepdims'}),... |
import gaphas
import pytest
from gaphor.core.modeling import Diagram, Presentation, StyleSheet
class Example(gaphas.Element, Presentation):
def __init__(self, diagram, id):
super().__init__(connections=diagram.connections, diagram=diagram, id=id)
def unlink(self):
self.test_unlinked = True
... | [
"pytest.raises",
"gaphor.core.modeling.Diagram"
] | [((749, 768), 'gaphor.core.modeling.Diagram', 'Diagram', (['"""id"""', 'None'], {}), "('id', None)\n", (756, 768), False, 'from gaphor.core.modeling import Diagram, Presentation, StyleSheet\n'), ((870, 889), 'gaphor.core.modeling.Diagram', 'Diagram', (['"""id"""', 'None'], {}), "('id', None)\n", (877, 889), False, 'fro... |
from rvce_web_results import app,db
from flask import render_template, flash, redirect,session
from rvce_web_results.forms import *
from rvce_web_results.models import *
from fuzzywuzzy import fuzz
from fuzzywuzzy import process
import operator
#download data into shelf file using rvresult.py,(status, sd) = scrape_s... | [
"flask.render_template",
"operator.itemgetter",
"flask.redirect",
"rvce_web_results.app.route",
"rvce_web_results.db.session.query",
"fuzzywuzzy.fuzz.WRatio",
"rvce_web_results.app.run"
] | [((2763, 2802), 'rvce_web_results.app.route', 'app.route', (['"""/"""'], {'methods': "['GET', 'POST']"}), "('/', methods=['GET', 'POST'])\n", (2772, 2802), False, 'from rvce_web_results import app, db\n'), ((2863, 2914), 'rvce_web_results.app.route', 'app.route', (['"""/name_results"""'], {'methods': "['GET', 'POST']"}... |
# Code to instruct the computer to generate dice roll values and display output to the screen.
# Input: number, an integer variable
# Output: a vertical list of randomly generated integers in the range specified.
# The above text is commentary. The actual program starts below:
import random # provides this prog... | [
"random.randint"
] | [((876, 897), 'random.randint', 'random.randint', (['(1)', '(12)'], {}), '(1, 12)\n', (890, 897), False, 'import random\n')] |
#!/usr/bin/env python3
from itertools import *
from pprint import pprint
import sys
def lowercase_words(fp):
for line in fp.readlines():
yield line.rstrip('\n').lower()
def words_from_file(filename):
with open(filename) as fp:
return list(lowercase_words(fp))
def good_words():
def only_a... | [
"sys.stderr.write",
"sys.exit"
] | [((913, 1005), 'sys.stderr.write', 'sys.stderr.write', (["('Not enough words! After filtering we ' + 'only have %d\\n' % num_words)"], {}), "('Not enough words! After filtering we ' + 'only have %d\\n' %\n num_words)\n", (929, 1005), False, 'import sys\n'), ((1018, 1095), 'sys.stderr.write', 'sys.stderr.write', (['"... |
import re
from .basis import BrawlType
from .enums import URLS
class BrawlClub(BrawlType):
'''
A Handler for Brawl Stars Club
call coroutine update to update the cached attributes
BrawlClub.updated: False if coroutine update was never called
BrawlClub.request: shorthand for BrawlClub.client.reques... | [
"re.sub"
] | [((956, 999), 're.sub', 're.sub', (['"""(.)([A-Z][a-z]+)"""', '"""\\\\1_\\\\2"""', 'name'], {}), "('(.)([A-Z][a-z]+)', '\\\\1_\\\\2', name)\n", (962, 999), False, 'import re\n'), ((1018, 1062), 're.sub', 're.sub', (['"""([a-z0-9])([A-Z])"""', '"""\\\\1_\\\\2"""', 'name'], {}), "('([a-z0-9])([A-Z])', '\\\\1_\\\\2', name... |
import sys
import numpy
from PyQt5.QtWidgets import QApplication, QMessageBox, QSizePolicy
from orangewidget import gui
from orangewidget.settings import Setting
from oasys.widgets import gui as oasysgui, congruence
from oasys.widgets.exchange import DataExchangeObject
from orangecontrib.xoppy.util.xoppy_xraylib_util ... | [
"oasys.widgets.gui.widgetBox",
"oasys.widgets.congruence.checkStrictlyPositiveNumber",
"numpy.array",
"PyQt5.QtWidgets.QApplication",
"PyQt5.QtWidgets.QSizePolicy",
"orangewidget.settings.Setting",
"oasys.widgets.congruence.checkFile",
"oasys.widgets.congruence.checkPositiveNumber",
"orangecontrib.x... | [((881, 891), 'orangewidget.settings.Setting', 'Setting', (['(2)'], {}), '(2)\n', (888, 891), False, 'from orangewidget.settings import Setting\n'), ((915, 930), 'orangewidget.settings.Setting', 'Setting', (['(0.0001)'], {}), '(0.0001)\n', (922, 930), False, 'from orangewidget.settings import Setting\n'), ((947, 958), ... |
'''
Test Vid4 (SR) and REDS4 (SR-clean, SR-blur, deblur-clean, deblur-compression) datasets
'''
import os
import os.path as osp
import glob
import logging
import numpy as np
import cv2
import torch
import utils.util as util
import data.util as data_util
import models.archs.EDVR_arch as EDVR_arch
def main():
###... | [
"logging.getLogger",
"utils.util.setup_logger",
"numpy.copy",
"models.archs.EDVR_arch.EDVR",
"data.util.read_img",
"torch.LongTensor",
"torch.load",
"os.path.join",
"utils.util.single_forward",
"data.util.read_img_seq",
"data.util.index_generation",
"utils.util.calculate_psnr",
"os.path.base... | [((391, 411), 'torch.device', 'torch.device', (['"""cuda"""'], {}), "('cuda')\n", (403, 411), False, 'import torch\n'), ((2495, 2570), 'models.archs.EDVR_arch.EDVR', 'EDVR_arch.EDVR', (['(128)', 'N_in', '(8)', '(5)', 'back_RBs'], {'predeblur': 'predeblur', 'HR_in': 'HR_in'}), '(128, N_in, 8, 5, back_RBs, predeblur=pred... |
# Copyright (c) Jupyter Development Team.
# Distributed under the terms of the Modified BSD License.
import logging
import signal
import queue
import time
import sys
from traitlets.config import catch_config_error
from traitlets import (
Instance, Dict, Unicode, Bool, List, CUnicode, Any, Float
)
from jupyter_co... | [
"signal.signal",
"traitlets.Dict",
"traitlets.Float",
"sys.stdin.read",
"time.time",
"traitlets.Any"
] | [((1243, 1254), 'traitlets.Dict', 'Dict', (['flags'], {}), '(flags)\n', (1247, 1254), False, 'from traitlets import Instance, Dict, Unicode, Bool, List, CUnicode, Any, Float\n'), ((1269, 1282), 'traitlets.Dict', 'Dict', (['aliases'], {}), '(aliases)\n', (1273, 1282), False, 'from traitlets import Instance, Dict, Unicod... |
from django.urls import path, include
from rest_framework import routers
from . import views
router = routers.DefaultRouter()
router.register('courses', views.CourseViewSet)
app_name = 'courses'
urlpatterns = [
path('subjects/', views.SubjectListView.as_view(), name='subject_list'),
path('subjects/<pk>/', ... | [
"rest_framework.routers.DefaultRouter",
"django.urls.include"
] | [((105, 128), 'rest_framework.routers.DefaultRouter', 'routers.DefaultRouter', ([], {}), '()\n', (126, 128), False, 'from rest_framework import routers\n'), ((392, 412), 'django.urls.include', 'include', (['router.urls'], {}), '(router.urls)\n', (399, 412), False, 'from django.urls import path, include\n')] |
"""Utilities to validate Galaxy xml tool wrappers.
"""
from typing import List, Optional
from lxml import etree
from galaxy.util import xml_macros
from pygls.workspace import Document
from pygls.types import (
Diagnostic,
Position,
Range,
)
MACROS_TAG = "<macros>"
class GalaxyToolValidationService:
... | [
"galaxy.util.xml_macros.load_with_references",
"pygls.types.Position",
"pygls.types.Diagnostic",
"lxml.etree.fromstring"
] | [((1133, 1166), 'lxml.etree.fromstring', 'etree.fromstring', (['document.source'], {}), '(document.source)\n', (1149, 1166), False, 'from lxml import etree\n'), ((3174, 3207), 'lxml.etree.fromstring', 'etree.fromstring', (['document.source'], {}), '(document.source)\n', (3190, 3207), False, 'from lxml import etree\n'),... |
#
#
#
from __future__ import absolute_import, division, print_function, \
unicode_literals
from collections import defaultdict
from os import makedirs
from os.path import isdir, join
import logging
from ..record import Record
from ..yaml import safe_load, safe_dump
from .base import BaseProvider
class YamlProv... | [
"os.path.isdir",
"collections.defaultdict",
"os.makedirs"
] | [((3138, 3155), 'collections.defaultdict', 'defaultdict', (['list'], {}), '(list)\n', (3149, 3155), False, 'from collections import defaultdict\n'), ((3668, 3689), 'os.path.isdir', 'isdir', (['self.directory'], {}), '(self.directory)\n', (3673, 3689), False, 'from os.path import isdir, join\n'), ((3703, 3727), 'os.make... |
# Copyright 2014 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, s... | [
"os.getenv",
"google.cloud.exceptions.from_http_response",
"urllib.parse.urlencode",
"json.dumps",
"collections.defaultdict",
"warnings.warn",
"google.api_core.client_info.ClientInfo",
"platform.python_version"
] | [((1174, 1199), 'platform.python_version', 'platform.python_version', ([], {}), '()\n', (1197, 1199), False, 'import platform\n'), ((2321, 2406), 'warnings.warn', 'warnings.warn', (['_USER_AGENT_ALL_CAPS_DEPRECATED', 'DeprecationWarning'], {'stacklevel': '(2)'}), '(_USER_AGENT_ALL_CAPS_DEPRECATED, DeprecationWarning, s... |
#!/usr/bin/env python3
# Copyright 2021 Google Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or... | [
"logging.getLogger",
"aiy.leds.Leds.rgb_off",
"aiy.leds.Color.blend",
"aiy.leds.Leds",
"aiy.toneplayer.TonePlayer"
] | [((853, 880), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (870, 880), False, 'import logging\n'), ((1022, 1043), 'aiy.toneplayer.TonePlayer', 'TonePlayer', (['gpio', 'bpm'], {}), '(gpio, bpm)\n', (1032, 1043), False, 'from aiy.toneplayer import TonePlayer\n'), ((1717, 1731), 'aiy.leds.... |
"""
Broad strokes, end-to-end testing because something is better than nothing,
which is what we have right now.
"""
from hydra import initialize, initialize_config_module, initialize_config_dir, compose
from omegaconf import OmegaConf
CONFIG_BASE_PATH = "config"
CONFIG_DEFAULTS = "default.yaml"
def test_import():
... | [
"pytti.workhorse._main",
"hydra.initialize",
"hydra.compose"
] | [((501, 541), 'hydra.initialize', 'initialize', ([], {'config_path': 'CONFIG_BASE_PATH'}), '(config_path=CONFIG_BASE_PATH)\n', (511, 541), False, 'from hydra import initialize, initialize_config_module, initialize_config_dir, compose\n'), ((557, 620), 'hydra.compose', 'compose', ([], {'config_name': 'CONFIG_DEFAULTS', ... |
"""
qgs tensor module
=================
This module computes and holds the tensor representing the tendencies of the model's equations.
Notes
-----
These are computed using the analytical expressions from:
* <NAME>., <NAME>. and <NAME>.: *The Modular Arbitrary-Order Ocean-Atmosphere Mode... | [
"params.params.QgParams",
"sparse.zeros",
"numpy.array",
"numpy.zeros",
"inner_products.analytic.OceanicInnerProducts",
"inner_products.analytic.AtmosphericInnerProducts",
"numpy.tril",
"numpy.triu"
] | [((14107, 14117), 'params.params.QgParams', 'QgParams', ([], {}), '()\n', (14115, 14117), False, 'from params.params import QgParams\n'), ((14202, 14234), 'inner_products.analytic.AtmosphericInnerProducts', 'AtmosphericInnerProducts', (['params'], {}), '(params)\n', (14226, 14234), False, 'from inner_products.analytic ... |
from typing import Optional
from ariadne import ObjectType
from context import LND
import rpc_pb2 as ln
CHANNEL_PAYLOAD = ObjectType('ChannelPayload')
@CHANNEL_PAYLOAD.field('openChannels')
async def open_channels(
self,
*_,
active: bool = False,
inactive: bool = False,
public: bool = False,
p... | [
"context.LND.stub.PendingChannels",
"rpc_pb2.ListChannelsRequest",
"rpc_pb2.PendingChannelsRequest",
"ariadne.ObjectType",
"context.LND.stub.ListChannels"
] | [((123, 151), 'ariadne.ObjectType', 'ObjectType', (['"""ChannelPayload"""'], {}), "('ChannelPayload')\n", (133, 151), False, 'from ariadne import ObjectType\n'), ((388, 500), 'rpc_pb2.ListChannelsRequest', 'ln.ListChannelsRequest', ([], {'active_only': 'active', 'inactive_only': 'inactive', 'public_only': 'public', 'pr... |
# -*- coding: utf-8 -*-
"""
eve.flaskapp
~~~~~~~~~~~~
This module implements the central WSGI application object as a Flask
subclass.
:copyright: (c) 2013 by <NAME>.
:license: BSD, see LICENSE for more details.
"""
import eve
import sys
import os
from flask import Flask
from werkzeug.routing... | [
"os.path.isabs",
"eve.utils.extract_key_values",
"os.environ.get",
"os.path.join",
"os.path.dirname",
"eve.exceptions.SchemaException",
"eve.exceptions.ConfigException",
"eve.utils.api_prefix"
] | [((7954, 7976), 'os.environ.get', 'os.environ.get', (['envvar'], {}), '(envvar)\n', (7968, 7976), False, 'import os\n'), ((21549, 21614), 'eve.utils.api_prefix', 'api_prefix', (["self.config['URL_PREFIX']", "self.config['API_VERSION']"], {}), "(self.config['URL_PREFIX'], self.config['API_VERSION'])\n", (21559, 21614), ... |
import argparse
import os
from sliding_window.window_plot import WindowPlot
from sliding_window.sliding_window import SlidingWindow
def main():
# parse command line arguments
parser = argparse.ArgumentParser()
parser.add_argument(
"path_to_data",
type=str,
help="The path to the di... | [
"os.path.exists",
"os.makedirs",
"argparse.ArgumentParser",
"sliding_window.window_plot.WindowPlot",
"sliding_window.sliding_window.SlidingWindow"
] | [((195, 220), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (218, 220), False, 'import argparse\n'), ((2018, 2039), 'sliding_window.sliding_window.SlidingWindow', 'SlidingWindow', ([], {}), '(**args)\n', (2031, 2039), False, 'from sliding_window.sliding_window import SlidingWindow\n'), ((2482,... |
import unittest
from kyu6.autocorrect import autocorrect
class TestAutocorrect(unittest.TestCase):
def test_u(self):
self.assertEquals('your sister', autocorrect('u'))
def test_you(self):
self.assertEquals('your sister', autocorrect('you'))
def test_You(self):
self.assertEquals... | [
"kyu6.autocorrect.autocorrect"
] | [((166, 182), 'kyu6.autocorrect.autocorrect', 'autocorrect', (['"""u"""'], {}), "('u')\n", (177, 182), False, 'from kyu6.autocorrect import autocorrect\n'), ((250, 268), 'kyu6.autocorrect.autocorrect', 'autocorrect', (['"""you"""'], {}), "('you')\n", (261, 268), False, 'from kyu6.autocorrect import autocorrect\n'), ((3... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# =============================================================================
## @file
# Module with some simple but useful utilities for
# - timing
# - memory
# - profiling
# - ...
# @author <NAME> <EMAIL>
# @date 2013-02-10
#
# =========================... | [
"ostap.utils.docme.docme",
"random.setstate",
"fcntl.fcntl",
"time.sleep",
"ROOT.ROOT.EnableImplicitMT",
"builtins.range",
"copy.deepcopy",
"math.log10",
"ROOT.ROOT.GetROOT",
"ROOT.TCanvas",
"itertools.repeat",
"os.path.exists",
"ROOT.SetOwnership",
"os.readlink",
"random.getstate",
"R... | [((4979, 5009), 'ostap.logger.logger.getLogger', 'getLogger', (['"""ostap.utils.utils"""'], {}), "('ostap.utils.utils')\n", (4988, 5009), False, 'from ostap.logger.logger import getLogger\n'), ((5050, 5069), 'ostap.logger.logger.getLogger', 'getLogger', (['__name__'], {}), '(__name__)\n', (5059, 5069), False, 'from ost... |
import logging
import re
import sys
from anime_downloader.sites.anime import Anime, AnimeEpisode, SearchResult
from anime_downloader.sites import helpers
logger = logging.getLogger(__name__)
class WatchMovie(Anime, sitename='watchmovie'):
"""
Nice things
Siteconfig
----------
s... | [
"logging.getLogger",
"anime_downloader.sites.helpers.get"
] | [((164, 191), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (181, 191), False, 'import logging\n'), ((1644, 1665), 'anime_downloader.sites.helpers.get', 'helpers.get', (['self.url'], {}), '(self.url)\n', (1655, 1665), False, 'from anime_downloader.sites import helpers\n'), ((534, 598), '... |
import logging
import numpy as np
from ctapipe.calib.camera import CameraCalibrator
from ctapipe.io import (
EventSource,
read_table,
)
from numba import njit
from scipy.interpolate import interp1d
from traitlets.config import Config
from lstchain.io import standard_config
from lstchain.io.config import read... | [
"logging.getLogger",
"numpy.random.default_rng",
"scipy.interpolate.interp1d",
"numpy.array",
"numpy.arange",
"numpy.mean",
"numpy.histogram",
"numpy.random.poisson",
"numpy.where",
"numpy.random.multinomial",
"numpy.linspace",
"numpy.random.seed",
"numpy.concatenate",
"lstchain.io.config.... | [((540, 567), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (557, 567), False, 'import logging\n'), ((690, 739), 'numpy.full', 'np.full', (['N_PIXEL_NEIGHBORS', '(1 / N_PIXEL_NEIGHBORS)'], {}), '(N_PIXEL_NEIGHBORS, 1 / N_PIXEL_NEIGHBORS)\n', (697, 739), True, 'import numpy as np\n'), ((2... |
#!/usr/bin/python
# @lint-avoid-python-3-compatibility-imports
#
# killsnoop Trace signals issued by the kill() syscall.
# For Linux, uses BCC, eBPF. Embedded C.
#
# USAGE: killsnoop [-h] [-x] [-p PID]
#
# Copyright (c) 2015 <NAME>.
# Licensed under the Apache License, Version 2.0 (the "License")
#
# 20-Sep-2... | [
"bcc.BPF",
"time.strftime",
"argparse.ArgumentParser"
] | [((790, 952), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Trace signals issued by the kill() syscall"""', 'formatter_class': 'argparse.RawDescriptionHelpFormatter', 'epilog': 'examples'}), "(description=\n 'Trace signals issued by the kill() syscall', formatter_class=argparse.\n ... |
from lxml import html
from typing import Dict
import re
from .http import dispatch
def make_zipfile_form(page: bytes) -> Dict[str, str]:
tree = html.fromstring(page)
filelist_xpath = '//form[@method="POST"]/input[@name="FileList"]'
subdirectory_xpath = '//form[@method="POST"]/input[@name="Subdirectory"]... | [
"lxml.html.fromstring",
"re.search"
] | [((151, 172), 'lxml.html.fromstring', 'html.fromstring', (['page'], {}), '(page)\n', (166, 172), False, 'from lxml import html\n'), ((857, 881), 're.search', 're.search', (['pattern', 'path'], {}), '(pattern, path)\n', (866, 881), False, 'import re\n'), ((961, 982), 'lxml.html.fromstring', 'html.fromstring', (['page'],... |
from django.contrib import admin
from .models import *
import nested_admin
com_info = ('Personal information', {'fields': ['profile', 'first_name', 'middle_name','last_name', \
'gender', 'dob','blood_type', 'email', ]})
'''
- Clinic -
'''
class CBranchAssistantDoctorInline(nested_admin.NestedTabularInli... | [
"django.contrib.admin.site.register"
] | [((3825, 3853), 'django.contrib.admin.site.register', 'admin.site.register', (['Address'], {}), '(Address)\n', (3844, 3853), False, 'from django.contrib import admin\n'), ((3854, 3880), 'django.contrib.admin.site.register', 'admin.site.register', (['Phone'], {}), '(Phone)\n', (3873, 3880), False, 'from django.contrib i... |
import os
import sys
import pandas as pd
path = os.path.dirname(os.path.abspath(__file__))
from ..constant import CM_NAME
from ..helper import generate_output_file_tif, create_zip_shapefiles, generate_output_file_shp, generate_output_file_csv
""" Entry point of the calculation module function"""
if path not in sys.pa... | [
"os.path.abspath",
"sys.path.append",
"my_calculation_module_directory.run_cm.main",
"pandas.read_csv"
] | [((65, 90), 'os.path.abspath', 'os.path.abspath', (['__file__'], {}), '(__file__)\n', (80, 90), False, 'import os\n'), ((328, 349), 'sys.path.append', 'sys.path.append', (['path'], {}), '(path)\n', (343, 349), False, 'import sys\n'), ((1038, 1101), 'pandas.read_csv', 'pd.read_csv', (['industrial_database_excess_heat'],... |
import FWCore.ParameterSet.Config as cms
hltEle5WP70EcalIsoL1SeededFilter = cms.EDFilter("HLTEgammaGenericQuadraticEtaFilter",
absEtaLowEdges = cms.vdouble(0.0, 1.0, 1.479, 2.1),
candTag = cms.InputTag("hltEle5WP70HEL1SeededFilter"),
doRhoCorrection = cms.bool(False),
effectiveAreas = cms.vdouble(0.2, ... | [
"FWCore.ParameterSet.Config.double",
"FWCore.ParameterSet.Config.InputTag",
"FWCore.ParameterSet.Config.vdouble",
"FWCore.ParameterSet.Config.int32",
"FWCore.ParameterSet.Config.bool"
] | [((149, 182), 'FWCore.ParameterSet.Config.vdouble', 'cms.vdouble', (['(0.0)', '(1.0)', '(1.479)', '(2.1)'], {}), '(0.0, 1.0, 1.479, 2.1)\n', (160, 182), True, 'import FWCore.ParameterSet.Config as cms\n'), ((198, 241), 'FWCore.ParameterSet.Config.InputTag', 'cms.InputTag', (['"""hltEle5WP70HEL1SeededFilter"""'], {}), "... |
# coding:utf8
import unittest
from unittest import mock
import easyquotation
class TestTimeklineQuotation(unittest.TestCase):
MOCK_RESPONSE_DATA = [
(
"000001",
'min_data="\\n\\\ndate:180413\\n\\\n0930 11.64 29727\\n\\\n0931 11.65 52410\\n\\\n";',
)
]
def setUp(se... | [
"unittest.main",
"easyquotation.use",
"unittest.mock.patch"
] | [((382, 470), 'unittest.mock.patch', 'mock.patch', (['"""easyquotation.timekline.basequotation.BaseQuotation._fetch_stock_data"""'], {}), "(\n 'easyquotation.timekline.basequotation.BaseQuotation._fetch_stock_data')\n", (392, 470), False, 'from unittest import mock\n'), ((1475, 1490), 'unittest.main', 'unittest.main... |
"""
https://leetcode.com/problems/word-ladder/
Given two words (beginWord and endWord), and a dictionary's word list, find the length of shortest transformation sequence from beginWord to endWord, such that:
Only one letter can be changed at a time.
Each transformed word must exist in the word list.
Note:
Return 0 if... | [
"collections.deque",
"collections.defaultdict"
] | [((3075, 3104), 'collections.defaultdict', 'collections.defaultdict', (['list'], {}), '(list)\n', (3098, 3104), False, 'import collections\n'), ((3868, 3903), 'collections.deque', 'collections.deque', (['[(beginWord, 1)]'], {}), '([(beginWord, 1)])\n', (3885, 3903), False, 'import collections\n'), ((3924, 3957), 'colle... |
import base64
import datetime
import io
import os
import matplotlib as mpl
import matplotlib.pyplot as plt
import numpy as np
from xlrd.xldate import xldate_as_datetime
from yattag import Doc
plt.rcParams.update({"figure.autolayout": True})
import matplotlib.gridspec as gridspec
import pandas as pd
import scipy.stats... | [
"logging.getLogger",
"matplotlib.pyplot.hist",
"pandas.read_csv",
"matplotlib.pyplot.ylabel",
"numpy.less_equal",
"matplotlib.colorbar.ColorbarBase",
"io.BytesIO",
"numpy.equal",
"tensorflow.keras.callbacks.EarlyStopping",
"numpy.array",
"matplotlib.colors.BoundaryNorm",
"tensorflow.keras.laye... | [((194, 242), 'matplotlib.pyplot.rcParams.update', 'plt.rcParams.update', (["{'figure.autolayout': True}"], {}), "({'figure.autolayout': True})\n", (213, 242), True, 'import matplotlib.pyplot as plt\n'), ((1164, 1199), 'sklearn.preprocessing.MinMaxScaler', 'MinMaxScaler', ([], {'feature_range': '(-1, 1)'}), '(feature_r... |
import os
import shutil
import sys
from setuptools import setup, find_packages
def read(fname):
return open(os.path.join(os.path.dirname(__file__), fname)).read()
dst = 'debian/openstackx/var/lib/nova/'
os.system('rm -rf %s' % dst)
shutil.copytree('extensions', '%s/extensions' % dst)
requirements = ['httplib2']
... | [
"shutil.copytree",
"os.system",
"setuptools.find_packages",
"os.path.dirname"
] | [((209, 237), 'os.system', 'os.system', (["('rm -rf %s' % dst)"], {}), "('rm -rf %s' % dst)\n", (218, 237), False, 'import os\n'), ((238, 290), 'shutil.copytree', 'shutil.copytree', (['"""extensions"""', "('%s/extensions' % dst)"], {}), "('extensions', '%s/extensions' % dst)\n", (253, 290), False, 'import shutil\n'), (... |
import pylab
import numpy
class GeneralRandom:
"""This class enables us to generate random numbers with an arbitrary
distribution."""
def __init__(self, x = pylab.arange(-1.0, 1.0, .01), p = None, Nrl = 1000):
"""Initialize the lookup table (with default values if necessary)
Inputs:
x = random nu... | [
"pylab.zeros",
"pylab.subplot",
"pylab.arange",
"pylab.plot",
"pylab.array",
"pylab.figure",
"pylab.diff",
"numpy.random.uniform",
"pylab.exp"
] | [((168, 197), 'pylab.arange', 'pylab.arange', (['(-1.0)', '(1.0)', '(0.01)'], {}), '(-1.0, 1.0, 0.01)\n', (180, 197), False, 'import pylab\n'), ((987, 1003), 'pylab.zeros', 'pylab.zeros', (['Nrl'], {}), '(Nrl)\n', (998, 1003), False, 'import pylab\n'), ((1585, 1632), 'numpy.random.uniform', 'numpy.random.uniform', ([],... |
from django.urls import reverse
from django.http import HttpResponse, HttpResponseRedirect
from django.contrib.auth import login, logout, authenticate
from django.contrib.auth.forms import UserCreationForm
from django.contrib.auth.decorators import login_required
from django.shortcuts import render, redirect, get_obj... | [
"board.models.Figure.objects.create",
"django.shortcuts.get_object_or_404",
"django.contrib.auth.decorators.login_required",
"django.urls.reverse",
"board.analyzer.Frequency.Frequency"
] | [((470, 512), 'django.contrib.auth.decorators.login_required', 'login_required', ([], {'login_url': '"""/board/signin/"""'}), "(login_url='/board/signin/')\n", (484, 512), False, 'from django.contrib.auth.decorators import login_required\n'), ((815, 860), 'django.shortcuts.get_object_or_404', 'get_object_or_404', (['Da... |
import itertools
from typing import List
def checksum(spreadsheet: List[List[int]]) -> int:
return sum(map(lambda row: max(row) - min(row), spreadsheet))
def checksum2(spreadsheet: List[List[int]]) -> int:
def process_row(row: List[int]) -> int:
for x, y in itertools.combinations(row, 2):
... | [
"itertools.combinations"
] | [((276, 306), 'itertools.combinations', 'itertools.combinations', (['row', '(2)'], {}), '(row, 2)\n', (298, 306), False, 'import itertools\n')] |
from bs4 import BeautifulSoup
import config
import requests
import time
import json
import re
class BilibiliInfo:
'''获取视频和音频相关信息类'''
def __init__(self, url):
# 视频页地址
self.url = url
def get_video_page(self):
response = requests.get(
url=self.url,
headers={
... | [
"bs4.BeautifulSoup",
"json.loads",
"requests.get",
"re.compile"
] | [((258, 477), 'requests.get', 'requests.get', ([], {'url': 'self.url', 'headers': "{'User-Agent':\n 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/88.0.4324.150 Safari/537.36 Edg/88.0.705.68'\n , 'cookie': config.COOKIE}"}), "(url=self.url, headers={'User-Agent':\n 'Mo... |
import matplotlib.pyplot as plt
import numpy as np
while True:
try:
print('-'*111) # for decoration purpose
x = input('<< TO CONTINUE PRESS "ENTER" OR TO KILL THE APPLICATION PRESS "0" >> ')
if x == '':
print()
print('<< THIS APPLICATION CALCULATES ROOTS FOR A GIV... | [
"numpy.linspace",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.figure",
"matplotlib.pyplot.show"
] | [((1838, 1877), 'numpy.linspace', 'np.linspace', (['(-10 ** 2)', '(10 ** 2)', '(10 ** 2)'], {}), '(-10 ** 2, 10 ** 2, 10 ** 2)\n', (1849, 1877), True, 'import numpy as np\n'), ((1894, 1933), 'numpy.linspace', 'np.linspace', (['(-10 ** 2)', '(10 ** 2)', '(10 ** 2)'], {}), '(-10 ** 2, 10 ** 2, 10 ** 2)\n', (1905, 1933), ... |
"""
this is a program use Class to handle two Fractions plus, minus, mutiply, divide and
check-out if they equals to each other
upgraded with unittest module to build a test suite
Written by <NAME>
"""
import unittest as ut
class TestFraction(ut.TestCase):
""" Test class of fraction which includes testing '+-*/... | [
"unittest.main"
] | [((7550, 7582), 'unittest.main', 'ut.main', ([], {'exit': '(False)', 'verbosity': '(2)'}), '(exit=False, verbosity=2)\n', (7557, 7582), True, 'import unittest as ut\n')] |
from PyQt5 import QtWidgets
class ResultsModel(QtWidgets.QWidget):
def __init__(self, parent):
super().__init__(parent)
self.init()
def init(self):
self.layout = QtWidgets.QGridLayout()
self.setObjectName("modelResult")
self.refreshButton = self.createRefreshButton()... | [
"GBSUserInterface.PlotResult.PlotResult",
"PyQt5.QtWidgets.QGridLayout",
"PyQt5.QtWidgets.QPushButton",
"PyQt5.QtWidgets.QComboBox"
] | [((198, 221), 'PyQt5.QtWidgets.QGridLayout', 'QtWidgets.QGridLayout', ([], {}), '()\n', (219, 221), False, 'from PyQt5 import QtWidgets\n'), ((1206, 1228), 'GBSUserInterface.PlotResult.PlotResult', 'PlotResult', (['self', 'data'], {}), '(self, data)\n', (1216, 1228), False, 'from GBSUserInterface.PlotResult import Plot... |
# Lint as: python3
# Copyright 2020 The TensorFlow Authors. All Rights Reserved.
#
# 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 ... | [
"tensorflow.train.Checkpoint",
"official.nlp.tasks.question_answering.ModelConfig",
"official.nlp.tasks.masked_lm.MaskedLMTask",
"official.nlp.tasks.question_answering.QuestionAnsweringTask",
"tensorflow.io.gfile.GFile",
"official.nlp.bert.configs.BertConfig",
"itertools.product",
"json.dumps",
"ten... | [((6321, 6388), 'absl.testing.parameterized.named_parameters', 'parameterized.named_parameters', (["('squad1', False)", "('squad2', True)"], {}), "(('squad1', False), ('squad2', True))\n", (6351, 6388), False, 'from absl.testing import parameterized\n'), ((7194, 7208), 'tensorflow.test.main', 'tf.test.main', ([], {}), ... |
import fisher
import numpy as np
def print_2x2_table(table, row_labels, col_labels, fmt="%d"):
"""
Prints a table used for Fisher's exact test. Adds row, column, and grand
totals.
:param table: The four cells of a 2x2 table: [r1c1, r1c2, r2c1, r2c2]
:param row_labels: A length-2 list of row names
... | [
"fisher.pvalue",
"textwrap.dedent"
] | [((4031, 4052), 'fisher.pvalue', 'fisher.pvalue', (['*table'], {}), '(*table)\n', (4044, 4052), False, 'import fisher\n'), ((4956, 4973), 'textwrap.dedent', 'dedent', (['str_table'], {}), '(str_table)\n', (4962, 4973), False, 'from textwrap import dedent\n')] |
from typing import List, Optional
import base58
from common.serializers.serialization import proof_nodes_serializer, \
state_roots_serializer
from plenum.common.txn_util import get_type, get_payload_data, get_seq_no, reqToTxn
from sovtoken.messages.validation import static_req_validation
from plenum.server.ledge... | [
"sovtoken.types.Output",
"sovtoken.util.validate_multi_sig_txn",
"plenum.common.txn_util.get_seq_no",
"plenum.common.txn_util.get_payload_data",
"common.serializers.serialization.proof_nodes_serializer.serialize",
"plenum.common.exceptions.OperationError",
"state.trie.pruning_trie.rlp_decode",
"sovtok... | [((5341, 5371), 'sovtoken.messages.validation.static_req_validation', 'static_req_validation', (['request'], {}), '(request)\n', (5362, 5371), False, 'from sovtoken.messages.validation import static_req_validation\n'), ((6524, 6537), 'plenum.common.txn_util.reqToTxn', 'reqToTxn', (['req'], {}), '(req)\n', (6532, 6537),... |
#!/usr/bin/env python3
from tkinter import *
import tkinter.messagebox as messagebox
from support.logging import log
import edp_modules.edp_controller as edp_controller
root = Tk(className="EDPath")
systemList = StringVar()
startSystem = StringVar()
endSystem = StringVar()
startSystemCheckState = IntVar()
endSystem... | [
"edp_modules.edp_controller.compute_route"
] | [((1124, 1211), 'edp_modules.edp_controller.compute_route', 'edp_controller.compute_route', (['system_names_list', 'start_system_name', 'end_system_name'], {}), '(system_names_list, start_system_name,\n end_system_name)\n', (1152, 1211), True, 'import edp_modules.edp_controller as edp_controller\n')] |
#!/usr/bin/env python3
# -*- coding: utf-8 -*-
from apscheduler.schedulers.background import BackgroundScheduler
from apscheduler.schedulers import SchedulerNotRunningError
from aliyunsdkcore.client import AcsClient
from urllib.request import urlopen
import colorlog
import logging
import json
import time
impo... | [
"logging.getLogger",
"aliyunsdkalidns.request.v20150109.UpdateDomainRecordRequest.UpdateDomainRecordRequest",
"json.loads",
"logging.StreamHandler",
"aliyunsdkcore.client.AcsClient",
"logging.Formatter",
"aliyunsdkalidns.request.v20150109.DescribeSubDomainRecordsRequest.DescribeSubDomainRecordsRequest",... | [((612, 644), 'logging.getLogger', 'logging.getLogger', (['"""logger_name"""'], {}), "('logger_name')\n", (629, 644), False, 'import logging\n'), ((670, 693), 'logging.StreamHandler', 'logging.StreamHandler', ([], {}), '()\n', (691, 693), False, 'import logging\n'), ((714, 771), 'logging.FileHandler', 'logging.FileHand... |
import pandas as pd
import geopandas
coral = 'D:/TAMU Work/TAMU 2022 SPRING/OCEN 460/depthtempsal_short2.csv'
second_param = 'D:/TAMU Work/TAMU 2022 SPRING/OCEN 460/woa18_all_O00mn01.csv'
raw_coral = pd.read_csv(coral)
raw_coral = geopandas.GeoDataFrame(raw_coral, geometry=geopandas.points_from_xy(raw_coral.longitude... | [
"pandas.read_csv",
"geopandas.points_from_xy"
] | [((202, 220), 'pandas.read_csv', 'pd.read_csv', (['coral'], {}), '(coral)\n', (213, 220), True, 'import pandas as pd\n'), ((514, 539), 'pandas.read_csv', 'pd.read_csv', (['second_param'], {}), '(second_param)\n', (525, 539), True, 'import pandas as pd\n'), ((276, 341), 'geopandas.points_from_xy', 'geopandas.points_from... |
from typing import List
import numpy as np
class BenchmarkResult:
def __init__(self, loop_names: List[str], n_repeats: int, metric_names: List[str]):
"""
:param loop_names: List of loop names
:param n_repeats: Number of random restarts in benchmarking
:param metric_names: List of... | [
"numpy.array"
] | [((1664, 1711), 'numpy.array', 'np.array', (['self._results[loop_name][metric_name]'], {}), '(self._results[loop_name][metric_name])\n', (1672, 1711), True, 'import numpy as np\n')] |
import matplotlib.pyplot as plt
import numpy as np
strategies = np.array([
[
#gamma = 0.5
[-9.563336572173805, -8.193748914742143, -10.270220524396596, -3.0000000000000004, -7.553846153846153, -7.904142011834319, -3.0, -3.0, -3.0, -3.0],
[-7.378487640724603, -3.3197512739857147, -7.49614268... | [
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.xlabel",
"numpy.asarray",
"numpy.array",
"matplotlib.pyplot.title",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.show"
] | [((65, 6140), 'numpy.array', 'np.array', (['[[[-9.563336572173805, -8.193748914742143, -10.270220524396596, -\n 3.0000000000000004, -7.553846153846153, -7.904142011834319, -3.0, -3.0,\n -3.0, -3.0], [-7.378487640724603, -3.3197512739857147, -\n 7.496142688168831, -3.0000000000000004, -3.0, -3.0, -3.0, -3.0, -3... |
# Lint as: python2, python3
# Copyright 2018 The TensorFlow Authors All Rights Reserved.
#
# 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-... | [
"six.moves.range",
"tensorflow.variable_scope",
"tensorflow.contrib.layers.l2_regularizer",
"tensorflow.nn.relu",
"tensorflow.contrib.layers.variance_scaling_initializer",
"tensorflow.logging.info",
"deeplab.core.utils.get_batch_norm_fn",
"tensorflow.contrib.training.HParams",
"tensorflow.contrib.sl... | [((2068, 2245), 'tensorflow.contrib.training.HParams', 'contrib_training.HParams', ([], {'filter_scaling_rate': '(2.0)', 'num_conv_filters': 'num_conv_filters', 'drop_path_keep_prob': 'drop_path_keep_prob', 'total_training_steps': 'total_training_steps'}), '(filter_scaling_rate=2.0, num_conv_filters=\n num_conv_filt... |
#!/usr/bin/env python
# coding: utf-8
# In[2]:
get_ipython().system('pip install dask')
from dask import dataframe
import pandas as pd
import yfinance as yf
import os
import logging
import numpy as np
from scipy.cluster.hierarchy import dendrogram, linkage, leaves_list
import seaborn as sns
import matplotlib.pypl... | [
"scipy.cluster.hierarchy.leaves_list",
"os.listdir",
"numpy.ones",
"numpy.asarray",
"os.path.join",
"numpy.sum",
"matplotlib.pyplot.figure",
"numpy.linalg.inv",
"numpy.array",
"scipy.cluster.hierarchy.linkage",
"pandas.DataFrame",
"matplotlib.pyplot.show"
] | [((1396, 1414), 'numpy.linalg.inv', 'np.linalg.inv', (['cov'], {}), '(cov)\n', (1409, 1414), True, 'import numpy as np\n'), ((4661, 4712), 'pandas.DataFrame', 'pd.DataFrame', ([], {'index': 'stocks_universe', 'columns': "['mu']"}), "(index=stocks_universe, columns=['mu'])\n", (4673, 4712), True, 'import pandas as pd\n'... |
import os
from azure.storage.blob import ContainerClient
def get_files(dir):
""" Function to list all files in a directory as a "objects". """
with os.scandir(dir) as entries:
for entry in entries:
if entry.is_file() and not entry.name.startswith('.'):
yield entry
... | [
"os.scandir",
"azure.storage.blob.ContainerClient.from_connection_string",
"os.remove"
] | [((687, 765), 'azure.storage.blob.ContainerClient.from_connection_string', 'ContainerClient.from_connection_string', (['azure_strg_connecstr', 'pic_contain_name'], {}), '(azure_strg_connecstr, pic_contain_name)\n', (725, 765), False, 'from azure.storage.blob import ContainerClient\n'), ((164, 179), 'os.scandir', 'os.sc... |
#!/bin/env python
import csv, os, re, sys
import index_congress_scores
columns_115 = [
"running_in_2018"
]
columns_116 = [
"running_for_president"
]
if len(sys.argv) < 2:
sys.exit('Usage: %s [congress session]' % sys.argv[0])
session = int(sys.argv[1])
script = os.path.realpath(sys.argv[0])
scripts_dir = os.pat... | [
"csv.writer",
"os.path.realpath",
"os.path.dirname",
"sys.exit",
"index_congress_scores.get_sen_id",
"re.sub",
"index_congress_scores.get_rep_id",
"csv.reader"
] | [((270, 299), 'os.path.realpath', 'os.path.realpath', (['sys.argv[0]'], {}), '(sys.argv[0])\n', (286, 299), False, 'import csv, os, re, sys\n'), ((314, 337), 'os.path.dirname', 'os.path.dirname', (['script'], {}), '(script)\n', (329, 337), False, 'import csv, os, re, sys\n'), ((349, 377), 'os.path.dirname', 'os.path.di... |
"""
The idea of late parallelization is that we don't have to
slice our tensor network in the beginning of the contraction.
"""
import psutil
import numpy as np
from functools import partial
from loguru import logger as log
import qtree
import qtensor as qtn
from qtensor.optimisation import Optimizer, RGreedyOptimize... | [
"qtensor.toolbox.get_ordering_algo",
"qtree.graph_model.get_equivalent_peo",
"loguru.logger.info",
"loguru.logger.debug",
"qtree.graph_model.make_clique_on",
"qtree.graph_model.get_treewidth_from_peo",
"qtensor.utils.n_neighbors",
"loguru.logger.warning",
"psutil.virtual_memory",
"functools.partia... | [((479, 523), 'qtensor.toolbox.get_ordering_algo', 'qtn.toolbox.get_ordering_algo', (['ordering_algo'], {}), '(ordering_algo)\n', (508, 523), True, 'import qtensor as qtn\n'), ((539, 559), 'qtensor.optimisation.GreedyParvars', 'GreedyParvars', (['graph'], {}), '(graph)\n', (552, 559), False, 'from qtensor.optimisation ... |
'''
Created on 31 Oct 2014
@author: <NAME> (<EMAIL>)
@copyright: (c) 2014 <NAME>
@license: MIT
'''
# standard library
import unittest
# external libraries
import numpy as np
import nose
# local libraries
from zignal import Audio
class Test_single_channel(unittest.TestCase):
def setUp(self):
self.y = np... | [
"zignal.Audio",
"numpy.zeros",
"nose.run"
] | [((2514, 2537), 'nose.run', 'nose.run', ([], {'argv': 'noseargs'}), '(argv=noseargs)\n', (2522, 2537), False, 'import nose\n'), ((318, 329), 'numpy.zeros', 'np.zeros', (['(4)'], {}), '(4)\n', (326, 329), True, 'import numpy as np\n'), ((399, 431), 'zignal.Audio', 'Audio', ([], {'fs': '(10)', 'initialdata': 'values'}), ... |
# -*- coding: utf-8 -*-
from __future__ import absolute_import, print_function, unicode_literals
from datetime import datetime
from inspect import getmodulename
import logging
import os
import re
import socket
import ssl
from urllib.error import HTTPError, URLError
from urllib.request import urlopen, Request
from ..co... | [
"inspect.getmodulename",
"pytz.timezone",
"os.path.getsize",
"urllib.request.Request",
"datetime.datetime.now",
"re.sub",
"urllib.request.urlopen"
] | [((649, 672), 'inspect.getmodulename', 'getmodulename', (['__file__'], {}), '(__file__)\n', (662, 672), False, 'from inspect import getmodulename\n'), ((1521, 1567), 'pytz.timezone', 'pytz.timezone', (["settings['SOURCES'][name]['tz']"], {}), "(settings['SOURCES'][name]['tz'])\n", (1534, 1567), False, 'import pytz\n'),... |
from typing import Dict # isort:skip
import argparse
from argparse import ArgumentParser
from pathlib import Path
import safitty
import torch
from catalyst import utils
from catalyst.dl.core import Experiment
from catalyst.dl.utils.scripts import import_experiment_and_runner
from catalyst.dl.utils.trace import trac... | [
"catalyst.utils.unpack_checkpoint",
"catalyst.utils.load_checkpoint",
"argparse.ArgumentParser",
"pathlib.Path",
"safitty.get",
"catalyst.dl.utils.scripts.import_experiment_and_runner",
"safitty.load",
"catalyst.dl.utils.trace.trace_model",
"torch.jit.save"
] | [((670, 695), 'safitty.load', 'safitty.load', (['config_path'], {}), '(config_path)\n', (682, 695), False, 'import safitty\n'), ((739, 788), 'safitty.get', 'safitty.get', (['config', '"""args"""', '"""expdir"""'], {'apply': 'Path'}), "(config, 'args', 'expdir', apply=Path)\n", (750, 788), False, 'import safitty\n'), ((... |
"""
Задача 5. Картирование ридов на референс при помощи полиномиальных хешей.
Картирование коротких прочтений
(англ. Short-Read Sequence Alignment, Short-Read Sequence Mapping) —
биоинформатический метод анализа результатов секвенирования нового поколения,
состоящий в определении позиций в референсном геноме или тра... | [
"Bio.SeqIO.FastaIO.SimpleFastaParser",
"argparse.ArgumentParser"
] | [((3266, 3404), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Finding all occurrences of reeds from .fasta file in reference sequence (protein or dna)."""'}), "(description=\n 'Finding all occurrences of reeds from .fasta file in reference sequence (protein or dna).'\n )\n", (3289... |
import pytest
from firebase_admin import messaging
from backend.common.consts.fcm.platform_priority import PlatformPriority
from backend.common.models.fcm.platform_config import PlatformConfig
from backend.common.models.notifications.notification import Notification
from backend.common.models.notifications.tests.mocks... | [
"backend.common.models.notifications.tests.mocks.notifications.mock_notification.MockNotification",
"backend.common.models.notifications.notification.Notification._type",
"backend.common.models.fcm.platform_config.PlatformConfig",
"pytest.raises",
"firebase_admin.messaging.Notification",
"firebase_admin.m... | [((427, 487), 'firebase_admin.messaging.Notification', 'messaging.Notification', ([], {'title': '"""Title Here"""', 'body': '"""Body here"""'}), "(title='Title Here', body='Body here')\n", (449, 487), False, 'from firebase_admin import messaging\n'), ((549, 637), 'backend.common.models.fcm.platform_config.PlatformConfi... |
import numpy as np
from scipy.spatial.distance import pdist, squareform
from itertools import permutations
import matplotlib.pyplot as plt
def generate_points(num = 7):
return np.random.rand(num, 2) #technically this is [0,1) rather than (0,1)
def calculate_distance_matrix(point_array):
return squareform(#Not str... | [
"numpy.random.rand",
"scipy.spatial.distance.pdist",
"matplotlib.pyplot.plot",
"matplotlib.pyplot.scatter",
"matplotlib.pyplot.show"
] | [((179, 201), 'numpy.random.rand', 'np.random.rand', (['num', '(2)'], {}), '(num, 2)\n', (193, 201), True, 'import numpy as np\n'), ((1037, 1096), 'matplotlib.pyplot.plot', 'plt.plot', (['ordered_points[:, 0]', 'ordered_points[:, 1]'], {'c': '"""r"""'}), "(ordered_points[:, 0], ordered_points[:, 1], c='r')\n", (1045, 1... |
import discord
from redbot.core import Config, commands, checks
from typing import Optional, Literal
import datetime
import re
IMAGE_LINKS = re.compile(r"(http[s]?:\/\/[^\"\']*\.(?:png|jpg|jpeg|gif|png))")
class Away(commands.Cog):
"""Le away cog"""
default_global_settings = {"ign_servers": []}
default_... | [
"redbot.core.Config.get_conf",
"re.compile",
"datetime.datetime.utcnow",
"redbot.core.commands.Cog.listener",
"redbot.core.commands.guild_only",
"redbot.core.commands.command",
"re.sub",
"discord.Embed",
"re.search"
] | [((142, 211), 're.compile', 're.compile', (['"""(http[s]?:\\\\/\\\\/[^\\\\"\\\\\']*\\\\.(?:png|jpg|jpeg|gif|png))"""'], {}), '(\'(http[s]?:\\\\/\\\\/[^\\\\"\\\\\\\']*\\\\.(?:png|jpg|jpeg|gif|png))\')\n', (152, 211), False, 'import re\n'), ((3163, 3186), 'redbot.core.commands.Cog.listener', 'commands.Cog.listener', ([],... |
import functools
import io
from typing import AbstractSet, Dict, List, Optional, Tuple, TypeVar, Union, overload
from immutables import Map
from .ast import TYPE_ORDER_MAP, Order, OrderCondition, Variable
from .typing import Term, Triple
T = TypeVar("T")
@functools.total_ordering
class Key:
__slots__ = ["obj",... | [
"immutables.Map",
"typing.TypeVar"
] | [((245, 257), 'typing.TypeVar', 'TypeVar', (['"""T"""'], {}), "('T')\n", (252, 257), False, 'from typing import AbstractSet, Dict, List, Optional, Tuple, TypeVar, Union, overload\n'), ((1767, 1773), 'immutables.Map', 'Map', (['d'], {}), '(d)\n', (1770, 1773), False, 'from immutables import Map\n')] |
"""
Process an input dataset into a format suitable for machine learning.
"""
from __future__ import print_function
from __future__ import division
from __future__ import unicode_literals
import os
import gzip
import pandas as pd
import numpy as np
import csv
import numbers
import tempfile
from rdkit.Chem import rdmolf... | [
"os.dup2",
"numpy.ones",
"rdkit.Chem.rdmolops.RenumberAtoms",
"rdkit.Chem.MolFromSmiles",
"numpy.zeros_like",
"rdkit.Chem.rdmolfiles.CanonicalRankAtoms",
"os.dup",
"numpy.squeeze",
"numpy.array",
"numpy.concatenate",
"dcCustom.feat.Protein",
"deepchem.utils.save.log",
"sys.stderr.fileno",
... | [((908, 919), 'time.time', 'time.time', ([], {}), '()\n', (917, 919), False, 'import time\n'), ((1028, 1039), 'time.time', 'time.time', ([], {}), '()\n', (1037, 1039), False, 'import time\n'), ((1047, 1076), 'numpy.ones', 'np.ones', (['(n_samples, n_tasks)'], {}), '((n_samples, n_tasks))\n', (1054, 1076), True, 'import... |
import json
import pprint
import PySide2
from PySide2.QtCore import *
from PySide2.QtGui import *
from PySide2.QtWidgets import *
from CustomTipWidget_Ui import Ui_TipWidget
class CustomComboBox(QWidget, Ui_TipWidget):
Autocomplete_Signal = Signal(dict)
def __init__(self, p):
super(CustomComboBox, ... | [
"json.load"
] | [((4830, 4842), 'json.load', 'json.load', (['f'], {}), '(f)\n', (4839, 4842), False, 'import json\n')] |
# -*- coding: utf-8 -*-
import sys
import os.path
import setuptools
root_dir = os.path.abspath(os.path.dirname(__file__))
readme_file = os.path.join(root_dir, 'README.md')
with open(readme_file) as f:
long_description = f.read()
version_module = os.path.join(root_dir, 'raspi_io', 'version.py')
with open(version_... | [
"setuptools.setup"
] | [((495, 990), 'setuptools.setup', 'setuptools.setup', ([], {'name': '"""raspi_io"""', 'version': 'version', 'description': '"""Using socket.io control your raspberry pi"""', 'long_description': 'long_description', 'url': '"""https://github.com/amaork/raspi-io"""', 'author': '"""Amaork"""', 'author_email': '"""<EMAIL>""... |
# coding: utf-8
# This file is a part of VK4XMPP transport
# © simpleApps, 2014 — 2015.
from __main__ import *
from __main__ import _
VCARD_SEMAPHORE = threading.Semaphore()
DESCRIPTION = "VK4XMPP Transport\n© simpleApps, 2013 — 2015."
GITHUB_URL = "https://github.com/mrDoctorWho/vk4xmpp"
if AdditionalAbout:
DESCR... | [
"__main__._"
] | [((2199, 2242), '__main__._', '_', (['"""You\'re not registered for this action."""'], {}), '("You\'re not registered for this action.")\n', (2200, 2242), False, 'from __main__ import _\n'), ((2091, 2122), '__main__._', '_', (['"""Your friend-list is empty."""'], {}), "('Your friend-list is empty.')\n", (2092, 2122), F... |
# -*- coding: utf-8 -*-
# https://github.com/Hnfull/Intensio-Obfuscator
#---------------------------------------------------------- [Lib] -----------------------------------------------------------#
import shutil
import os
import glob
import re
import colorama
from core.utils.intensio_utils import Utils
from core.... | [
"os.path.exists",
"os.path.getsize",
"re.match",
"shutil.copytree",
"os.path.isdir",
"core.utils.intensio_utils.Utils",
"shutil.rmtree"
] | [((1028, 1035), 'core.utils.intensio_utils.Utils', 'Utils', ([], {}), '()\n', (1033, 1035), False, 'from core.utils.intensio_utils import Utils\n'), ((1240, 1264), 'os.path.exists', 'os.path.exists', (['inputArg'], {}), '(inputArg)\n', (1254, 1264), False, 'import os\n'), ((3931, 3956), 'os.path.exists', 'os.path.exist... |
"""Columbia Uncompressed Image Splicing Detection Evaluation Dataset
- https://www.ee.columbia.edu/ln/dvmm/downloads/authsplcuncmp/
- Detecting Image Splicing Using Geometry Invariants And Camera Characteristics Consistency, <NAME>, <NAME>
"""
import tarfile
from pathlib import Path
from typing import Any, Dict
impor... | [
"tarfile.open",
"pathlib.Path",
"torch.from_numpy",
"numpy.array",
"numpy.zeros",
"toml.load",
"src.datasets.utils.download_raw_dataset"
] | [((480, 519), 'pathlib.Path', 'Path', (['"""data/raw/columbia/metadata.toml"""'], {}), "('data/raw/columbia/metadata.toml')\n", (484, 519), False, 'from pathlib import Path\n'), ((538, 570), 'pathlib.Path', 'Path', (['"""data/downloaded/columbia"""'], {}), "('data/downloaded/columbia')\n", (542, 570), False, 'from path... |
# Licensed to the Apache Software Foundation (ASF) under one
# or more contributor license agreements. See the NOTICE file
# distributed with this work for additional information
# regarding copyright ownership. The ASF licenses this file
# to you under the Apache License, Version 2.0 (the
# "License"); you may not u... | [
"mxnet.nd.random.uniform",
"common.with_seed",
"mxnet.nd.contrib.multi_adamw_update",
"mxnet.nd.zeros",
"mxnet.nd.square",
"mxnet.nd.clip",
"itertools.product",
"mxnet.nd.sqrt",
"mxnet.nd.contrib.mp_adamw_update",
"nose.runmodule",
"mxnet.nd.contrib.adamw_update",
"mxnet.nd.contrib.multi_mp_ad... | [((3318, 3329), 'common.with_seed', 'with_seed', ([], {}), '()\n', (3327, 3329), False, 'from common import with_seed\n'), ((2170, 2187), 'mxnet.random.seed', 'mx.random.seed', (['(0)'], {}), '(0)\n', (2184, 2187), True, 'import mxnet as mx\n'), ((9810, 9826), 'nose.runmodule', 'nose.runmodule', ([], {}), '()\n', (9824... |
import os
import sys
import math
import fire
import json
from tqdm import tqdm
from math import floor, log2
from random import random
from shutil import rmtree
from functools import partial
import multiprocessing
from contextlib import contextmanager, ExitStack
import numpy as np
import torch
from torch import nn, e... | [
"apex.amp.scale_loss",
"torchvision.transforms.ToPILImage",
"kornia.filters.filter2D",
"math.log2",
"torch.cuda.is_available",
"torch.flip",
"numpy.arange",
"torch.nn.ModuleList",
"torch.linspace",
"torchvision.transforms.Resize",
"torch.index_select",
"torch.optim.Adam",
"contrastive_learne... | [((1029, 1054), 'torch.cuda.is_available', 'torch.cuda.is_available', ([], {}), '()\n', (1052, 1054), False, 'import torch\n'), ((1137, 1164), 'multiprocessing.cpu_count', 'multiprocessing.cpu_count', ([], {}), '()\n', (1162, 1164), False, 'import multiprocessing\n'), ((5726, 5740), 'torch.isnan', 'torch.isnan', (['t']... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
# standard modules
import math
import re
# third party modules
import luigi
import unicodecsv as csv
# local modules
from alleletraj import utils
from alleletraj.const import OUTGROUP_POP
from alleletraj.db.load import CreateDatabase
from alleletraj.sra import entrez_dir... | [
"luigi.run",
"luigi.BoolParameter",
"unicodecsv.DictReader",
"alleletraj.db.load.CreateDatabase",
"re.sub",
"luigi.Parameter",
"alleletraj.sra.entrez_direct_esearch"
] | [((639, 656), 'luigi.Parameter', 'luigi.Parameter', ([], {}), '()\n', (654, 656), False, 'import luigi\n'), ((671, 692), 'luigi.BoolParameter', 'luigi.BoolParameter', ([], {}), '()\n', (690, 692), False, 'import luigi\n'), ((1021, 1038), 'luigi.Parameter', 'luigi.Parameter', ([], {}), '()\n', (1036, 1038), False, 'impo... |
# Copyright 2017 The TensorFlow Authors. All Rights Reserved.
#
# 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 applica... | [
"tensorflow.python.ops.array_ops.placeholder",
"tensorflow.python.data.ops.dataset_ops.Dataset.from_tensors",
"math.ceil",
"tensorflow.python.ops.string_ops.as_string",
"tensorflow.python.framework.constant_op.constant",
"numpy.max",
"numpy.array",
"numpy.random.randint",
"tensorflow.python.framewor... | [((10147, 10158), 'tensorflow.python.platform.test.main', 'test.main', ([], {}), '()\n', (10156, 10158), False, 'from tensorflow.python.platform import test\n'), ((1791, 1836), 'tensorflow.python.ops.array_ops.placeholder', 'array_ops.placeholder', (['dtypes.int64'], {'shape': '[]'}), '(dtypes.int64, shape=[])\n', (181... |
# -*- coding: utf-8 -*-
import os
import argparse
import inspect
import sys
from ..interfaces.base import Interface, InputMultiPath, traits
from ..interfaces.base.support import get_trait_desc
from .misc import str2bool
def listClasses(module=None):
if module:
__import__(module)
pkg = sys.modules... | [
"inspect.isclass",
"sys.exit",
"argparse.ArgumentParser",
"os.path.split"
] | [((2150, 2226), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Nipype interface runner"""', 'prog': 'argv[0]'}), "(description='Nipype interface runner', prog=argv[0])\n", (2173, 2226), False, 'import argparse\n'), ((2437, 2459), 'os.path.split', 'os.path.split', (['argv[0]'], {}), '(arg... |
import telebot
from telebot import types
from loguru import logger
import settings
from Bot.UserManager import UserManager, User
@logger.catch
def Bot(bot : telebot.TeleBot):
UM = UserManager()
@bot.message_handler(commands = ['start'])
@UM.Wraps
@logger.catch
def start_func(message : types.Message, user ... | [
"Bot.UserManager.UserManager",
"loguru.logger.opt",
"loguru.logger.info"
] | [((185, 198), 'Bot.UserManager.UserManager', 'UserManager', ([], {}), '()\n', (196, 198), False, 'from Bot.UserManager import UserManager, User\n'), ((333, 373), 'loguru.logger.info', 'logger.info', (['f"""{user} : started the bot"""'], {}), "(f'{user} : started the bot')\n", (344, 373), False, 'from loguru import logg... |
#!/usr/bin/env python
from setuptools import find_packages, setup
from l5kit import __version__
setup(
name="l5kit",
version=__version__,
description="Lyft Autonomous Vehicle Research library",
author="<NAME>",
author_email="<EMAIL>",
url="https://github.com/lyft/l5kit",
license="apache2",... | [
"setuptools.find_packages"
] | [((1008, 1075), 'setuptools.find_packages', 'find_packages', ([], {'exclude': "['*.tests', '*.tests.*', 'tests.*', 'tests']"}), "(exclude=['*.tests', '*.tests.*', 'tests.*', 'tests'])\n", (1021, 1075), False, 'from setuptools import find_packages, setup\n')] |
import theano.tensor as T
import numpy as np
from ..utils.utils_functions import ITLFunctions
__all__ = [
'dummy_score',
'get_accuracy',
'score_accuracy',
'score_ensemble_ambiguity',
'score_rms',
'score_silverman',
'mutual_information_cs',
'mutual_information_ed',
'mutual_informatio... | [
"numpy.sum",
"theano.tensor.mean",
"theano.tensor.zeros",
"theano.tensor.power"
] | [((869, 891), 'theano.tensor.zeros', 'T.zeros', (['_target.shape'], {}), '(_target.shape)\n', (876, 891), True, 'import theano.tensor as T\n'), ((1575, 1600), 'theano.tensor.mean', 'T.mean', (['(_target * _output)'], {}), '(_target * _output)\n', (1581, 1600), True, 'import theano.tensor as T\n'), ((3240, 3271), 'thean... |
# ===============================================================================
# Copyright 2012 <NAME>
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LI... | [
"traitsui.extras.checkbox_column.CheckboxColumn",
"traits.api.Property",
"traitsui.table_column.ObjectColumn",
"traitsui.api.TableEditor",
"pychron.spectrometer.get_spectrometer_config_path",
"random.random",
"six.moves.configparser.ConfigParser",
"traits.api.Bool",
"pychron.spectrometer.jobs.peak_c... | [((1712, 1742), 'traits.api.Property', 'Property', ([], {'depends_on': '"""results"""'}), "(depends_on='results')\n", (1720, 1742), False, 'from traits.api import List, HasTraits, Str, Bool, Float, Property\n'), ((2351, 2361), 'traits.api.Bool', 'Bool', (['(True)'], {}), '(True)\n', (2355, 2361), False, 'from traits.ap... |
import unittest
from google.protobuf import json_format
import rastervision as rv
from rastervision.protos.backend_pb2 import BackendConfig as BackendConfigMsg
from tests import data_file_path
@unittest.skipIf(not rv.backend.tf_available, 'TF is not available')
class TestTFObjectDetectionConfig(unittest.TestCase):
... | [
"tests.data_file_path",
"rastervision.ExperimentConfig.builder",
"rastervision.protos.backend_pb2.BackendConfig",
"unittest.skipIf",
"rastervision.TaskConfig.builder",
"rastervision.DatasetConfig.builder",
"unittest.main",
"rastervision.BackendConfig.from_proto",
"rastervision.BackendConfig.builder"... | [((198, 265), 'unittest.skipIf', 'unittest.skipIf', (['(not rv.backend.tf_available)', '"""TF is not available"""'], {}), "(not rv.backend.tf_available, 'TF is not available')\n", (213, 265), False, 'import unittest\n'), ((339, 414), 'tests.data_file_path', 'data_file_path', (['"""tf_object_detection/embedded_ssd_mobil... |
import random
from item import Item
from creatures import Miner
from enchantments import SleepSpell, Frozen, Firestarter
class BookOfSpells(Item):
def __init__(self, x, y):
Item.__init__(self, x, y)
self.char = 'B'
self.color = 948
self.type = 'Book of Spells'
spells = [Sl... | [
"item.Item.__init__",
"random.randint",
"item.Item.add_to_mine"
] | [((188, 213), 'item.Item.__init__', 'Item.__init__', (['self', 'x', 'y'], {}), '(self, x, y)\n', (201, 213), False, 'from item import Item\n'), ((459, 487), 'item.Item.add_to_mine', 'Item.add_to_mine', (['self', 'mine'], {}), '(self, mine)\n', (475, 487), False, 'from item import Item\n'), ((558, 578), 'random.randint'... |
import asyncio
import json
import logging
import websockets
class WSServer:
HOST = '0.0.0.0'
MOVE_DELAY = 100
def __init__(self, server, port, loop=None):
self._server = server
self._storage = server.storage
self._port = port
self._loop = loop or asyncio.get_event_loop()
... | [
"json.loads",
"logging.debug",
"json.dumps",
"asyncio.wait",
"logging.exception",
"websockets.serve",
"asyncio.get_event_loop",
"logging.info"
] | [((406, 480), 'logging.info', 'logging.info', (['"""Starting WebSockets server on %s:%d"""', 'self.HOST', 'self._port'], {}), "('Starting WebSockets server on %s:%d', self.HOST, self._port)\n", (418, 480), False, 'import logging\n'), ((497, 568), 'websockets.serve', 'websockets.serve', (['self._handler', 'self.HOST', '... |
from disco.core import result_iterator
from disco.error import DataError
from disco.test import TestCase, TestJob, FailedReply
class RedundantJob(TestJob):
@staticmethod
def map(e, params):
yield int(e), ''
@staticmethod
def reduce(iter, params):
yield sum(k for k, v in iter), ''
clas... | [
"disco.core.result_iterator",
"disco.error.DataError",
"disco.test.FailedReply"
] | [((423, 436), 'disco.test.FailedReply', 'FailedReply', ([], {}), '()\n', (434, 436), False, 'from disco.test import TestCase, TestJob, FailedReply\n'), ((1544, 1631), 'disco.core.result_iterator', 'result_iterator', (["[['raw://corrupt'] * 9 + ['raw://decent']]"], {'reader': 'corrupt_reader'}), "([['raw://corrupt'] * 9... |
#!/usr/bin/env python
# wujian@2018
"""
Do WPE Dereverbration Algorithm
"""
import argparse
from distutils.util import strtobool
import numpy as np
from libs.data_handler import SpectrogramReader, WaveWriter
from libs.opts import StftParser
from libs.utils import get_logger, inverse_stft
from libs.wpe import wpe
lo... | [
"libs.utils.inverse_stft",
"argparse.ArgumentParser",
"libs.wpe.wpe",
"libs.utils.get_logger",
"libs.data_handler.SpectrogramReader",
"nara_wpe.wpe.wpe_v8",
"numpy.transpose",
"libs.data_handler.WaveWriter"
] | [((327, 347), 'libs.utils.get_logger', 'get_logger', (['__name__'], {}), '(__name__)\n', (337, 347), False, 'from libs.utils import get_logger, inverse_stft\n'), ((621, 715), 'libs.data_handler.SpectrogramReader', 'SpectrogramReader', (['args.wav_scp'], {'round_power_of_two': 'args.round_power_of_two'}), '(args.wav_scp... |
import pandas as pd
import os
def load(file_name):
file_path = os.path.join('../../data/external/',file_name)
data = pd.read_csv(file_path, index_col=0)
return data | [
"os.path.join",
"pandas.read_csv"
] | [((68, 115), 'os.path.join', 'os.path.join', (['"""../../data/external/"""', 'file_name'], {}), "('../../data/external/', file_name)\n", (80, 115), False, 'import os\n'), ((126, 161), 'pandas.read_csv', 'pd.read_csv', (['file_path'], {'index_col': '(0)'}), '(file_path, index_col=0)\n', (137, 161), True, 'import pandas ... |
# Copyright 2017 Google Inc. All Rights Reserved.
#
# 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... | [
"os.environ.get",
"argparse.ArgumentParser"
] | [((834, 859), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (857, 859), False, 'import argparse\n'), ((3957, 3990), 'os.environ.get', 'os.environ.get', (['"""TF_CONFIG"""', '"""{}"""'], {}), "('TF_CONFIG', '{}')\n", (3971, 3990), False, 'import os\n')] |