code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
import re
import os
import argparse
from pprint import pprint
from configuration.config import PACKAGE_PATH
from normalize_license_text.normalize_class import NormalizeText
from compare_normalized_files import CompareNormalizedFiles
from normalize_template_text import NormalizeTemplate
from generate_differences.diffe... | [
"os.path.exists",
"argparse.ArgumentParser",
"compare_normalized_files.CompareNormalizedFiles",
"normalize_template_text.NormalizeTemplate",
"normalize_license_text.normalize_class.NormalizeText",
"generate_differences.differences.Generate_Differences",
"pprint.pprint"
] | [((1119, 1188), 'normalize_template_text.NormalizeTemplate', 'NormalizeTemplate', (['normalized_text_string', 'normalized_template_string'], {}), '(normalized_text_string, normalized_template_string)\n', (1136, 1188), False, 'from normalize_template_text import NormalizeTemplate\n'), ((1330, 1390), 'compare_normalized_... |
from PIL import Image, ImageOps
import os
from compact import get_rms
def compare_img ( source, target ):
rms = get_rms( source.convert('RGB'), target.convert('RGB') )
return rms < 100
def compare_with_mask( source, target ):
cut_with_mask( source.alpha, target )
return compare_img( source, target )
def cut_... | [
"PIL.ImageOps.invert"
] | [((444, 465), 'PIL.ImageOps.invert', 'ImageOps.invert', (['mask'], {}), '(mask)\n', (459, 465), False, 'from PIL import Image, ImageOps\n')] |
import streamlit as st
# import spacy
import en_core_web_sm
from textblob import TextBlob
from gensim.summarization import summarize
# tokenizer and lemmatizer
def text_analyzer(my_text):
# https://spacy.io/usage/models#models-download
# nlp = spacy.load("en_core_web_sm")
nlp = en_core_web_sm.load() # fo... | [
"streamlit.checkbox",
"textblob.TextBlob",
"en_core_web_sm.load",
"streamlit.button",
"streamlit.json",
"streamlit.success",
"streamlit.text_area",
"streamlit.subheader",
"streamlit.sidebar.selectbox",
"gensim.summarization.summarize"
] | [((293, 314), 'en_core_web_sm.load', 'en_core_web_sm.load', ([], {}), '()\n', (312, 314), False, 'import en_core_web_sm\n'), ((560, 581), 'en_core_web_sm.load', 'en_core_web_sm.load', ([], {}), '()\n', (579, 581), False, 'import en_core_web_sm\n'), ((759, 812), 'streamlit.subheader', 'st.subheader', (['"""Natural Langu... |
"""The Base module of the `cpp_linter` package. This holds the objects shared by
multiple modules."""
import io
import os
import logging
FOUND_RICH_LIB = False
try:
from rich.logging import RichHandler
FOUND_RICH_LIB = True
logging.basicConfig(
format="%(name)s: %(message)s",
handlers=[Ri... | [
"logging.getLogger",
"logging.basicConfig",
"os.getenv",
"io.open",
"rich.logging.RichHandler"
] | [((466, 497), 'logging.getLogger', 'logging.getLogger', (['"""CPP Linter"""'], {}), "('CPP Linter')\n", (483, 497), False, 'import logging\n'), ((605, 632), 'os.getenv', 'os.getenv', (['"""GITHUB_SHA"""', '""""""'], {}), "('GITHUB_SHA', '')\n", (614, 632), False, 'import os\n'), ((674, 703), 'os.getenv', 'os.getenv', (... |
# Pubchem has a fabulously complicated API, it breaks my brain, and it seems to be quite inflexible.
# Hence the need for this, this serves the purpose of scraping information from a JS based pubchem site
# (thus the need for a web driver), and retriving specific information about it. E.g. Taste.
import asyncio
impor... | [
"asyncio.get_event_loop",
"arsenic.get_session",
"arsenic.browsers.Chrome",
"arsenic.services.Chromedriver"
] | [((427, 450), 'arsenic.services.Chromedriver', 'services.Chromedriver', ([], {}), '()\n', (448, 450), False, 'from arsenic import get_session, keys, browsers, services\n'), ((465, 537), 'arsenic.browsers.Chrome', 'browsers.Chrome', ([], {'chromeOptions': "{'args': ['--headless', '--disable-gpu']}"}), "(chromeOptions={'... |
#!/usr/local/bin/python3
"""
Script to generate a fixture of a chain with N complex links.
Usage: python generate_complex_chainmail_fixture.py N
"""
import json
import pathlib
import numpy
import shapely.geometry
import shapely.ops
from fixture_utils import *
def generate_link_polygons() -> list:
"""Generate ... | [
"numpy.radians",
"numpy.array",
"numpy.full",
"pathlib.Path"
] | [((2548, 2568), 'numpy.radians', 'numpy.radians', (['angle'], {}), '(angle)\n', (2561, 2568), False, 'import numpy\n'), ((1023, 1072), 'numpy.array', 'numpy.array', (['[width / 2, height - half_thickness]'], {}), '([width / 2, height - half_thickness])\n', (1034, 1072), False, 'import numpy\n'), ((1199, 1232), 'numpy.a... |
import json
import os
from utility.preprocess import sentencesBertTokenize, sentencesOktTokenize, pickOnlyNouns, pickOnlyAdjsVerb
from kobert.utils import get_tokenizer
from kobert.pytorch_kobert import get_pytorch_kobert_model
from konlpy.tag import Okt
from utility import constant
import gluonnlp as nlp
from tqdm imp... | [
"utility.preprocess.pickOnlyAdjsVerb",
"gluonnlp.data.BERTSPTokenizer",
"utility.preprocess.sentencesOktTokenize",
"tqdm.tqdm",
"utility.preprocess.sentencesBertTokenize",
"utility.preprocess.pickOnlyNouns",
"kobert.pytorch_kobert.get_pytorch_kobert_model",
"os.path.dirname",
"utility.constant.WEBSI... | [((367, 372), 'konlpy.tag.Okt', 'Okt', ([], {}), '()\n', (370, 372), False, 'from konlpy.tag import Okt\n'), ((396, 422), 'kobert.pytorch_kobert.get_pytorch_kobert_model', 'get_pytorch_kobert_model', ([], {}), '()\n', (420, 422), False, 'from kobert.pytorch_kobert import get_pytorch_kobert_model\n'), ((439, 454), 'kobe... |
"""
Unittests!
"""
from decimal import Decimal
from django.test import TestCase
from core import db
from core import models
class DBTestCase(TestCase):
fixtures = ['testing/base.json']
def test_get_balance(self):
balance = db.get_balance(7, 10, 3)
self.assertEqual(balance.value, 62)
self.assertEqual(
s... | [
"core.models.Currency",
"core.db.get_pending_trans_for_user",
"core.db.get_balance",
"core.db.get_recent_trans_for_user",
"decimal.Decimal",
"core.models.User.objects.get"
] | [((233, 257), 'core.db.get_balance', 'db.get_balance', (['(7)', '(10)', '(3)'], {}), '(7, 10, 3)\n', (247, 257), False, 'from core import db\n'), ((435, 464), 'core.models.User.objects.get', 'models.User.objects.get', ([], {'id': '(3)'}), '(id=3)\n', (458, 464), False, 'from core import models\n'), ((666, 695), 'core.m... |
import os
import abc
import sys
import time
import datetime
import logging
import shutil
import oommfc as oc
import subprocess as sp
import ubermagutil as uu
import micromagneticmodel as mm
log = logging.getLogger(__name__)
_cached_oommf_runner = None
class OOMMFRunner(metaclass=abc.ABCMeta):
"""Abstract class f... | [
"logging.getLogger",
"micromagneticmodel.examples.macrospin",
"shutil.which",
"os.environ.get",
"subprocess.run",
"os.path.join",
"os.getcwd",
"os.path.isfile",
"datetime.datetime.now",
"oommfc.TimeDriver",
"os.path.dirname",
"oommfc.delete",
"time.time"
] | [((197, 224), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (214, 224), False, 'import logging\n'), ((9044, 9072), 'os.environ.get', 'os.environ.get', (['envvar', 'None'], {}), '(envvar, None)\n', (9058, 9072), False, 'import os\n'), ((10376, 10399), 'shutil.which', 'shutil.which', (['oo... |
import torch
import torch.nn as nn
import torch.nn.functional as F
from layers import GraphConvolution
from ...modules.prediction.classification.link_prediction.ConcatFeedForwardNNLayer import (
ConcatFeedForwardNNLayer,
)
from ...modules.prediction.classification.link_prediction.ElementSumLayer import ElementSum... | [
"torch.randn_like",
"torch.exp",
"torch.nn.functional.dropout",
"layers.GraphConvolution"
] | [((635, 701), 'layers.GraphConvolution', 'GraphConvolution', (['input_feat_dim', 'hidden_dim1', 'dropout'], {'act': 'F.relu'}), '(input_feat_dim, hidden_dim1, dropout, act=F.relu)\n', (651, 701), False, 'from layers import GraphConvolution\n'), ((721, 789), 'layers.GraphConvolution', 'GraphConvolution', (['hidden_dim1'... |
# EVALUATING TRAINED DEEP LEARNING MODEL
# In[ ]:
history.history.keys()
# In[ ]:
plt.plot(history.history['accuracy'])
plt.plot(history.history['loss'])
plt.title('Model Loss and Accuracy Progress During Training')
plt.xlabel('Epoch')
plt.ylabel('Training Accuracy and Loss')
plt.legend(['Train... | [
"sklearn.metrics.accuracy_score"
] | [((1845, 1881), 'sklearn.metrics.accuracy_score', 'accuracy_score', (['original', 'prediction'], {}), '(original, prediction)\n', (1859, 1881), False, 'from sklearn.metrics import confusion_matrix, classification_report, accuracy_score\n')] |
#
# Copyright (c) 2015-2019 <NAME> <tflorac AT ulthar.net>
# All Rights Reserved.
#
# This software is subject to the provisions of the Zope Public License,
# Version 2.1 (ZPL). A copy of the ZPL should accompany this distribution.
# THIS SOFTWARE IS PROVIDED "AS IS" AND ANY AND ALL EXPRESS OR IMPLIED
# WARRANTIES ARE... | [
"zope.interface.implementer"
] | [((1513, 1549), 'zope.interface.implementer', 'implementer', (['IBeforeObjectIndexEvent'], {}), '(IBeforeObjectIndexEvent)\n', (1524, 1549), False, 'from zope.interface import Interface, implementer\n')] |
""" Count Occurrences: """
from index_of_last_occurrence import last_occur
from index_of_first_occurrence import first_occur
""" Solution: """
def count_occur(arr, num) -> int:
low_index = first_occur(arr, num)
if low_index == -1:
return 0
high_index = last_occur(arr, num)
return (high_index -... | [
"index_of_first_occurrence.first_occur",
"index_of_last_occurrence.last_occur"
] | [((195, 216), 'index_of_first_occurrence.first_occur', 'first_occur', (['arr', 'num'], {}), '(arr, num)\n', (206, 216), False, 'from index_of_first_occurrence import first_occur\n'), ((275, 295), 'index_of_last_occurrence.last_occur', 'last_occur', (['arr', 'num'], {}), '(arr, num)\n', (285, 295), False, 'from index_of... |
import collections
import pandas as pd
from sklearn.base import TransformerMixin
class OneHotEncoder(TransformerMixin):
"""Encode categorical columns into one-hot/multi-hot codes."""
def __init__(self, topk=10):
self._dummy_dict = {}
self._dummy_columns = None
self.topk = topk
d... | [
"pandas.DataFrame",
"pandas.DataFrame.from_records",
"pandas.value_counts",
"pandas.get_dummies"
] | [((349, 364), 'pandas.DataFrame', 'pd.DataFrame', (['X'], {}), '(X)\n', (361, 364), True, 'import pandas as pd\n'), ((1724, 1739), 'pandas.DataFrame', 'pd.DataFrame', (['X'], {}), '(X)\n', (1736, 1739), True, 'import pandas as pd\n'), ((2456, 2478), 'pandas.get_dummies', 'pd.get_dummies', (['values'], {}), '(values)\n'... |
import data_classes
import os
from tools import *
import help_parser
def read_data(args):
def default_optimize_values():
return {args.v_name_default: data_classes.Value(args.v_name_default)}
to_optimize_values = {}
if args.people_and_things_file is not None:
# "classic", simple ... | [
"data_classes.Thing",
"data_classes.Person",
"data_classes.Value",
"os.path.isfile",
"help_parser.is_default"
] | [((169, 208), 'data_classes.Value', 'data_classes.Value', (['args.v_name_default'], {}), '(args.v_name_default)\n', (187, 208), False, 'import data_classes\n'), ((2960, 2990), 'os.path.isfile', 'os.path.isfile', (['args.yaml_file'], {}), '(args.yaml_file)\n', (2974, 2990), False, 'import os\n'), ((471, 498), 'os.path.i... |
# -*- coding: utf-8 -*-
import random
from kivy.properties import ListProperty
from answer_widgets import AnswerButton, BoxButtonsAnswerWidget
from description_widgets import TextDescriptionWidget
from task_widgets.task_base.base import BaseTask
from task_widgets.task_base.mixins import StartImmediatelyMixin
from uti... | [
"utils.import_kv",
"random.shuffle",
"kivy.properties.ListProperty"
] | [((341, 360), 'utils.import_kv', 'import_kv', (['__file__'], {}), '(__file__)\n', (350, 360), False, 'from utils import import_kv\n'), ((884, 900), 'kivy.properties.ListProperty', 'ListProperty', (['[]'], {}), '([])\n', (896, 900), False, 'from kivy.properties import ListProperty\n'), ((2166, 2190), 'random.shuffle', '... |
from selenium import webdriver
from selenium.webdriver.common.keys import Keys
import time
PROMISED_DOWN = 100
PROMISED_UP = 6
CHROME_DRIVER_PATH = "/Users/user/Development/chromedriver"
TWITTER_EMAIL = "<EMAIL>"
TWITTER_PASSWORD = "password"
class InternetSpeedTwitterBot:
def __init__(self):
self.drive... | [
"selenium.webdriver.Chrome",
"time.sleep"
] | [((324, 376), 'selenium.webdriver.Chrome', 'webdriver.Chrome', ([], {'executable_path': 'CHROME_DRIVER_PATH'}), '(executable_path=CHROME_DRIVER_PATH)\n', (340, 376), False, 'from selenium import webdriver\n'), ((529, 542), 'time.sleep', 'time.sleep', (['(3)'], {}), '(3)\n', (539, 542), False, 'import time\n'), ((658, 6... |
from mopidy.core import PlaybackState
from mopidy.models import Track
from tests import unittest
from tests.frontends.mpd import protocol
PAUSED = PlaybackState.PAUSED
PLAYING = PlaybackState.PLAYING
STOPPED = PlaybackState.STOPPED
class PlaybackOptionsHandlerTest(protocol.BaseTestCase):
def test_consume_off(s... | [
"mopidy.models.Track"
] | [((13795, 13823), 'mopidy.models.Track', 'Track', ([], {'uri': '"""2"""', 'length': '(40000)'}), "(uri='2', length=40000)\n", (13800, 13823), False, 'from mopidy.models import Track\n'), ((14692, 14720), 'mopidy.models.Track', 'Track', ([], {'uri': '"""2"""', 'length': '(40000)'}), "(uri='2', length=40000)\n", (14697, ... |
from django.apps import apps
from django.test import TestCase
from misago.conf import migrationutils
from misago.conf.models import SettingsGroup
from misago.core import threadstore
class DBConfMigrationUtilsTests(TestCase):
def setUp(self):
self.test_group = {
'key': 'test_group',
... | [
"misago.conf.models.SettingsGroup.objects.count",
"misago.conf.migrationutils.migrate_settings_group",
"misago.core.threadstore.clear",
"misago.conf.migrationutils.get_custom_settings_values",
"django.apps.apps.get_model"
] | [((1058, 1118), 'misago.conf.migrationutils.migrate_settings_group', 'migrationutils.migrate_settings_group', (['apps', 'self.test_group'], {}), '(apps, self.test_group)\n', (1095, 1118), False, 'from misago.conf import migrationutils\n'), ((1147, 1176), 'misago.conf.models.SettingsGroup.objects.count', 'SettingsGroup.... |
import os
from flask import Flask, render_template
from flask_login import current_user
from flask_principal import identity_loaded, UserNeed, RoleNeed
from flask_uploads import configure_uploads
from flask_wtf.csrf import CSRFError
from approval_system.blueprints.auth import auth
from approval_system.blueprints.coll... | [
"flask.render_template",
"flask_principal.RoleNeed",
"os.getenv",
"approval_system.extensions.login_manager.init_app",
"approval_system.extensions.db.init_app",
"flask.Flask",
"approval_system.extensions.moment.init_app",
"approval_system.extensions.principals.init_app",
"flask_principal.identity_lo... | [((792, 816), 'flask.Flask', 'Flask', (['"""approval_system"""'], {}), "('approval_system')\n", (797, 816), False, 'from flask import Flask, render_template\n'), ((1035, 1058), 'approval_system.extensions.bootstrap.init_app', 'bootstrap.init_app', (['app'], {}), '(app)\n', (1053, 1058), False, 'from approval_system.ext... |
"""Playback tests for visual inspection of output
"""
from urllib.request import urlretrieve
import tempfile
from vidstab import VidStab, layer_overlay
import matplotlib.pyplot as plt
# download videos for testing
tmp_dir = tempfile.TemporaryDirectory()
# remote_ostrich_vid = 'https://s3.amazonaws.com/python-vidstab/... | [
"tempfile.TemporaryDirectory",
"vidstab.VidStab",
"matplotlib.pyplot.show",
"urllib.request.urlretrieve"
] | [((225, 254), 'tempfile.TemporaryDirectory', 'tempfile.TemporaryDirectory', ([], {}), '()\n', (252, 254), False, 'import tempfile\n'), ((619, 673), 'urllib.request.urlretrieve', 'urlretrieve', (['remote_skateline_vid', 'local_skateline_vid'], {}), '(remote_skateline_vid, local_skateline_vid)\n', (630, 673), False, 'fro... |
from django.urls import path
from . import views
urlpatterns = [
path('', views.Index, name='index'),
path('news/<int:news_id>', views.FullNews, name='full_news'),
path('news/<int:news_id>/edit', views.EditPost, name='edit_news'),
path('news/<int:news_id>/delete', views.DeletePost, name='delete_news')... | [
"django.urls.path"
] | [((71, 106), 'django.urls.path', 'path', (['""""""', 'views.Index'], {'name': '"""index"""'}), "('', views.Index, name='index')\n", (75, 106), False, 'from django.urls import path\n'), ((112, 172), 'django.urls.path', 'path', (['"""news/<int:news_id>"""', 'views.FullNews'], {'name': '"""full_news"""'}), "('news/<int:ne... |
#!/usr/bin/env python3
#
# ===============LICENSE_START=======================================================
# Acumos
# ===================================================================================
# Copyright (C) 2018 AT&T Intellectual Property. All rights reserved.
# ==========================================... | [
"unittest.mock.patch"
] | [((2305, 2343), 'unittest.mock.patch', 'patch', (['"""flask_mongoengine.MongoEngine"""'], {}), "('flask_mongoengine.MongoEngine')\n", (2310, 2343), False, 'from unittest.mock import patch\n'), ((2358, 2458), 'unittest.mock.patch', 'patch', (['"""predictormanagerservice.database.models.PredictorDocument"""'], {'new': 'M... |
#!/usr/bin/python
from model.user import UserDAO
from util.github import GitHub, GitHubAuthenticator
from bottle import redirect, request, response, route, run
from pymongo import MongoClient
import json
@route('/login')
def login():
url = "https://github.com/login/oauth/authorize?client_id=%s" % CONFIG['github_cl... | [
"model.user.UserDAO",
"bottle.route",
"json.load",
"pymongo.MongoClient",
"bottle.response.set_cookie",
"bottle.run",
"bottle.redirect",
"util.github.GitHub",
"util.github.GitHubAuthenticator"
] | [((208, 223), 'bottle.route', 'route', (['"""/login"""'], {}), "('/login')\n", (213, 223), False, 'from bottle import redirect, request, response, route, run\n'), ((349, 373), 'bottle.route', 'route', (['"""/login/callback"""'], {}), "('/login/callback')\n", (354, 373), False, 'from bottle import redirect, request, res... |
"""
Authors: <NAME>, <NAME>
Unit tests for the gbdxtools.Ordering class
"""
from gbdxtools import Interface
from gbdxtools.ordering import Ordering
from auth_mock import get_mock_gbdx_session
import vcr
import unittest
from mock import Mock, patch
"""
How to use the mock_gbdx_session and vcr to create unit tests:
1.... | [
"auth_mock.get_mock_gbdx_session",
"mock.patch",
"gbdxtools.Interface",
"vcr.use_cassette",
"gbdxtools.ordering.Ordering"
] | [((1286, 1393), 'vcr.use_cassette', 'vcr.use_cassette', (['"""tests/unit/cassettes/test_order_single_catid.yaml"""'], {'filter_headers': "['authorization']"}), "('tests/unit/cassettes/test_order_single_catid.yaml',\n filter_headers=['authorization'])\n", (1302, 1393), False, 'import vcr\n'), ((1608, 1715), 'vcr.use_... |
# Monocyte - Monocyte - Search and Destroy unwanted AWS Resources relentlessly.
# Copyright 2015 Immobilien Scout GmbH
#
# 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... | [
"logging.getLogger",
"boto3.client",
"warnings.filterwarnings"
] | [((2033, 2065), 'warnings.filterwarnings', 'warnings.filterwarnings', (['"""error"""'], {}), "('error')\n", (2056, 2065), False, 'import warnings\n'), ((2392, 2419), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (2409, 2419), False, 'import logging\n'), ((2817, 2836), 'boto3.client', 'bo... |
from Geometry.MTDGeometryBuilder.mtdParameters_cfi import mtdParameters
from Configuration.ProcessModifiers.dd4hep_cff import dd4hep
dd4hep.toModify(mtdParameters, fromDD4hep = True)
| [
"Configuration.ProcessModifiers.dd4hep_cff.dd4hep.toModify"
] | [((135, 182), 'Configuration.ProcessModifiers.dd4hep_cff.dd4hep.toModify', 'dd4hep.toModify', (['mtdParameters'], {'fromDD4hep': '(True)'}), '(mtdParameters, fromDD4hep=True)\n', (150, 182), False, 'from Configuration.ProcessModifiers.dd4hep_cff import dd4hep\n')] |
import torch
import networkx as nx
import numpy as np
import pickle as pkl
import scipy.sparse as sp
def Graph_load_batch(
min_num_nodes=20,
max_num_nodes=1000,
name="ENZYMES",
node_attributes=True,
graph_labels=True,
):
"""
load many graphs, e.g. enzymes
load ENZYMES and PROTEIN and DD... | [
"numpy.asmatrix",
"networkx.bfs_successors",
"numpy.arange",
"networkx.grid_2d_graph",
"networkx.from_dict_of_lists",
"numpy.sort",
"numpy.ix_",
"networkx.karate_club_graph",
"numpy.random.permutation",
"networkx.ladder_graph",
"numpy.amin",
"networkx.adjacency_matrix",
"numpy.nonzero",
"n... | [((424, 434), 'networkx.Graph', 'nx.Graph', ([], {}), '()\n', (432, 434), True, 'import networkx as nx\n'), ((3325, 3350), 'numpy.sort', 'np.sort', (['test_idx_reorder'], {}), '(test_idx_reorder)\n', (3332, 3350), True, 'import numpy as np\n'), ((3906, 3934), 'networkx.from_dict_of_lists', 'nx.from_dict_of_lists', (['g... |
# 020 - O mesmo professor do desafio anterior quer sortear a ordem de apresentação de trabalhos dos alunos. Faça um programa que leia
#o nome dos quatro alunos e mostre a ordem sorteada:
import random
from random import shuffle
lista = []
for c in range(1,5):
nome = str(input(f'Digite o nome do aluno {c}: '))
lis... | [
"random.shuffle"
] | [((350, 371), 'random.shuffle', 'random.shuffle', (['lista'], {}), '(lista)\n', (364, 371), False, 'import random\n')] |
# -*- coding: utf-8 -*-
"""
pip_services_runtime.services.DummyRestService
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
Dummy REST service implementation
:copyright: Digital Living Software Corp. 2015-2016, see AUTHORS for more details.
:license: MIT, see LICENSE for more details.
"""
f... | [
"pip_services_runtime.errors.UnsupportedError",
"pip_services_runtime.config.ComponentDescriptor"
] | [((581, 658), 'pip_services_runtime.config.ComponentDescriptor', 'ComponentDescriptor', (['Category.Services', '"""pip-services-dummies"""', '"""rest"""', '"""1.0"""'], {}), "(Category.Services, 'pip-services-dummies', 'rest', '1.0')\n", (600, 658), False, 'from pip_services_runtime.config import ComponentDescriptor\n'... |
# Generated by Django 2.2.1 on 2019-05-16 20:05
from django.db import migrations
class Migration(migrations.Migration):
dependencies = [
('IoT_DataMgmt', '0069_auto_20190514_1740'),
]
operations = [
migrations.AlterModelOptions(
name='equipmentfacility',
options=... | [
"django.db.migrations.AlterModelOptions"
] | [((232, 370), 'django.db.migrations.AlterModelOptions', 'migrations.AlterModelOptions', ([], {'name': '"""equipmentfacility"""', 'options': "{'ordering': ('name',), 'verbose_name_plural': 'equipment_facilities'}"}), "(name='equipmentfacility', options={'ordering':\n ('name',), 'verbose_name_plural': 'equipment_facil... |
from django.test import TestCase
from django.core.urlresolvers import reverse
from django.core.exceptions import ValidationError
from urlshortener_project.users.models import User
from ..models import ShortenedLink
class ShortenerModelsTestCase(TestCase):
def setUp(self):
self.user = User.objects.create_u... | [
"urlshortener_project.users.models.User.objects.create_user",
"django.core.urlresolvers.reverse"
] | [((299, 390), 'urlshortener_project.users.models.User.objects.create_user', 'User.objects.create_user', ([], {'username': '"""temporary"""', 'email': '"""<EMAIL>"""', 'password': '"""<PASSWORD>"""'}), "(username='temporary', email='<EMAIL>', password=\n '<PASSWORD>')\n", (323, 390), False, 'from urlshortener_project... |
import time
from codetiming import Timer
import signal
import asyncio
from mps060602 import MPS060602, MPS060602Para, ADChannelMode, PGAAmpRate
def close_card(card):
card.suspend()
card.close()
def new_card():
para = MPS060602Para(
ADChannel=ADChannelMode.in1,
ADSampleRate=1000,
... | [
"mps060602.MPS060602Para",
"asyncio.gather",
"codetiming.Timer",
"time.sleep",
"asyncio.sleep",
"asyncio.get_event_loop",
"mps060602.MPS060602"
] | [((233, 326), 'mps060602.MPS060602Para', 'MPS060602Para', ([], {'ADChannel': 'ADChannelMode.in1', 'ADSampleRate': '(1000)', 'Gain': 'PGAAmpRate.range_10V'}), '(ADChannel=ADChannelMode.in1, ADSampleRate=1000, Gain=\n PGAAmpRate.range_10V)\n', (246, 326), False, 'from mps060602 import MPS060602, MPS060602Para, ADChann... |
import re
# raw:
print(r"I am \r\a\w!")
print("I am \r\a\w!")
# match, search, findall, sub:
pattern = r"spam"
print(re.match(pattern, "spamegg"))
print(re.match(pattern, "eggspam"))
print(re.search(pattern, "eggspamspam"))
print(re.search(pattern, "eggsp"))
print(re.findall(pattern, "eggspamsausagespam"))
matchsr... | [
"re.sub",
"re.findall",
"re.match",
"re.search"
] | [((325, 358), 're.search', 're.search', (['pattern', '"""eggspamspam"""'], {}), "(pattern, 'eggspamspam')\n", (334, 358), False, 'import re\n'), ((530, 557), 're.sub', 're.sub', (['pattern', '"""Amy"""', 'str'], {}), "(pattern, 'Amy', str)\n", (536, 557), False, 'import re\n'), ((1257, 1282), 're.match', 're.match', ([... |
from data.database import Manifest, ManifestLegacyImage, Image
def get_legacy_image_for_manifest(manifest_id):
""" Returns the legacy image associated with the given manifest, if any, or None if none. """
try:
query = (ManifestLegacyImage
.select(ManifestLegacyImage, Image)
.join(Imag... | [
"data.database.ManifestLegacyImage.select"
] | [((228, 282), 'data.database.ManifestLegacyImage.select', 'ManifestLegacyImage.select', (['ManifestLegacyImage', 'Image'], {}), '(ManifestLegacyImage, Image)\n', (254, 282), False, 'from data.database import Manifest, ManifestLegacyImage, Image\n'), ((639, 696), 'data.database.ManifestLegacyImage.select', 'ManifestLega... |
# -*- coding: utf-8 -*-
import hashlib
import logging
import os
import warnings
from collections.abc import MutableMapping
from pathlib import Path
from typing import Callable, Dict, List, Optional, Union
import imageio
import numpy as np
from matplotlib import cm, colors, patches
from matplotlib import pyplot as plt
... | [
"logging.getLogger",
"eyepy.core.config.SEG_MAPPING.values",
"numpy.sqrt",
"pathlib.Path.home",
"scipy.io.loadmat",
"eyepy.core.drusen.DefaultDrusenFinder",
"numpy.array",
"numpy.moveaxis",
"hashlib.sha1",
"numpy.save",
"numpy.less",
"numpy.greater",
"pathlib.Path",
"numpy.stack",
"numpy... | [((581, 608), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (598, 608), False, 'import logging\n'), ((4282, 4296), 'numpy.isnan', 'np.isnan', (['data'], {}), '(data)\n', (4290, 4296), True, 'import numpy as np\n'), ((4502, 4515), 'numpy.copy', 'np.copy', (['data'], {}), '(data)\n', (4509... |
# Generated by Django 3.2.4 on 2021-09-11 12:21
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
dependencies = [
('contribuyente', '0001_initial'),
]
operations = [
migrations.CreateModel(
name='Notificaciones'... | [
"django.db.models.TextField",
"django.db.models.ForeignKey",
"django.db.models.BigAutoField",
"django.db.models.URLField",
"django.db.models.CharField"
] | [((366, 462), 'django.db.models.BigAutoField', 'models.BigAutoField', ([], {'auto_created': '(True)', 'primary_key': '(True)', 'serialize': '(False)', 'verbose_name': '"""ID"""'}), "(auto_created=True, primary_key=True, serialize=False,\n verbose_name='ID')\n", (385, 462), False, 'from django.db import migrations, m... |
import argparse
import sys
from typing import Sequence
from google.protobuf.field_mask_pb2 import FieldMask
from exabel_data_sdk import ExabelClient
from exabel_data_sdk.client.api.data_classes.entity_type import EntityType
from exabel_data_sdk.scripts.base_script import BaseScript
class UpdateEntityType(BaseScript... | [
"google.protobuf.field_mask_pb2.FieldMask",
"exabel_data_sdk.client.api.data_classes.entity_type.EntityType"
] | [((1921, 2136), 'exabel_data_sdk.client.api.data_classes.entity_type.EntityType', 'EntityType', ([], {'name': 'args.name', 'display_name': "(args.display_name if args.display_name is not None else '')", 'description': "(args.description if args.description is not None else '')", 'is_associative': 'args.is_associative'}... |
from setuptools import setup, find_packages
import datetime
import os
YEAR = datetime.date.today().year
__author__ = "<NAME>"
__version__ = "0.3.16"
__license__ = "MIT"
__copyright__ = u'%s, <NAME>' % YEAR
# Add Travis build id if not deploying a release (tag)
if os.environ.get("TRAVIS", "") == "true":
build_id... | [
"datetime.date.today",
"setuptools.find_packages",
"os.environ.get"
] | [((78, 99), 'datetime.date.today', 'datetime.date.today', ([], {}), '()\n', (97, 99), False, 'import datetime\n'), ((268, 296), 'os.environ.get', 'os.environ.get', (['"""TRAVIS"""', '""""""'], {}), "('TRAVIS', '')\n", (282, 296), False, 'import os\n'), ((367, 399), 'os.environ.get', 'os.environ.get', (['"""TRAVIS_TAG""... |
import math
def nthPentagon(n):
return n * (3*n -1) // 2
def isPentagon(x):
n = ( 1 + int( math.sqrt(1+24*x) ) ) // 6
return nthPentagon(n) == x
N, K = input().split(" ")
N = int(N)
K = int(K)
currN = K
currNK = 1
while currN < N:
currN += 1
Pn = nthPentagon(currN)
currNK =... | [
"math.sqrt"
] | [((107, 128), 'math.sqrt', 'math.sqrt', (['(1 + 24 * x)'], {}), '(1 + 24 * x)\n', (116, 128), False, 'import math\n')] |
#!/usr/bin/env python3
#############################################################################
### CMap Clue API client.
### CMap is the project; Clue is the platform.
### https://clue.io/api
### https://clue.io/connectopedia/query_api_tutorial
### https://clue.io/connectopedia/perturbagen_types_and_controls
### ... | [
"logging.basicConfig",
"argparse.ArgumentParser"
] | [((1358, 1447), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""CLUE.IO REST API client utility"""', 'epilog': 'epilog'}), "(description='CLUE.IO REST API client utility',\n epilog=epilog)\n", (1381, 1447), False, 'import sys, os, re, argparse, json, logging\n'), ((2786, 2904), 'loggin... |
from django.db.models.signals import pre_save
from django.dispatch import receiver
from api.podcasts.models import Podcast
@receiver(pre_save, sender=Podcast)
def on_pre_save(instance: Podcast, **kwargs):
instance.name = instance.fetch_details().title
| [
"django.dispatch.receiver"
] | [((126, 160), 'django.dispatch.receiver', 'receiver', (['pre_save'], {'sender': 'Podcast'}), '(pre_save, sender=Podcast)\n', (134, 160), False, 'from django.dispatch import receiver\n')] |
import numpy as np
import pytest
from doddle.words import Dictionary, Word, WordSeries, load_dictionary
class TestWords:
def test_word_compares_correctly(self) -> None:
# Arrange
word1 = Word("SNAKE")
word2 = Word("SHARK")
word3 = Word("snake")
word4 = Word(word1)
... | [
"doddle.words.load_dictionary",
"doddle.words.Dictionary",
"doddle.words.WordSeries",
"numpy.array",
"doddle.words.Word",
"pytest.raises",
"numpy.all",
"numpy.arange"
] | [((210, 223), 'doddle.words.Word', 'Word', (['"""SNAKE"""'], {}), "('SNAKE')\n", (214, 223), False, 'from doddle.words import Dictionary, Word, WordSeries, load_dictionary\n'), ((240, 253), 'doddle.words.Word', 'Word', (['"""SHARK"""'], {}), "('SHARK')\n", (244, 253), False, 'from doddle.words import Dictionary, Word, ... |
import os
from configparser import ConfigParser
from enum import Enum
NAME = 'gitflow'
AUTHOR = '<EMAIL>'
with open(os.path.abspath(os.path.join(os.path.dirname(__file__), 'config.ini')), 'r') as __config_file:
__config = ConfigParser()
__config.read_file(f=__config_file)
VERSION = __config.get(section=__... | [
"os.path.dirname",
"configparser.ConfigParser"
] | [((228, 242), 'configparser.ConfigParser', 'ConfigParser', ([], {}), '()\n', (240, 242), False, 'from configparser import ConfigParser\n'), ((147, 172), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (162, 172), False, 'import os\n')] |
import copy
import unittest
import os
import shutil
from matador.config import load_custom_settings, set_settings
from matador.config.config import DEFAULT_SETTINGS
DUMMY_SETTINGS = {
"mongo": {"host": "blah", "port": 666},
"plotting": {"style": "matador"},
"this_is_a_test": {True: "it is"},
"run3": {
... | [
"matador.config.set_settings",
"copy.deepcopy",
"matador.config.load_custom_settings",
"matador.config.SETTINGS.reset",
"os.path.expanduser"
] | [((644, 660), 'matador.config.SETTINGS.reset', 'SETTINGS.reset', ([], {}), '()\n', (658, 660), False, 'from matador.config import SETTINGS\n'), ((736, 752), 'matador.config.SETTINGS.reset', 'SETTINGS.reset', ([], {}), '()\n', (750, 752), False, 'from matador.config import SETTINGS\n'), ((852, 947), 'matador.config.load... |
import json
from tracker.api.services.auth import (
generate_auth_token, generate_password_hash
)
from tracker.db.schema import users_table, blacklist_tokens_table
from tests.services import generate_user_data
async def test_logout_mutation(migrated_db_connection, client):
app = client.server.app
user =... | [
"tests.services.generate_user_data",
"tracker.db.schema.blacklist_tokens_table.select",
"json.dumps",
"tracker.api.services.auth.generate_auth_token",
"tracker.api.services.auth.generate_password_hash",
"tracker.db.schema.users_table.insert"
] | [((321, 341), 'tests.services.generate_user_data', 'generate_user_data', ([], {}), '()\n', (339, 341), False, 'from tests.services import generate_user_data\n'), ((401, 437), 'tracker.api.services.auth.generate_password_hash', 'generate_password_hash', (['raw_password'], {}), '(raw_password)\n', (423, 437), False, 'fro... |
#
# Copyright (c) 2021 the Hugging Face team.
#
# 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 agree... | [
"app.models.experiment.ExperimentInDB",
"fastapi.HTTPException"
] | [((3805, 3833), 'app.models.experiment.ExperimentInDB', 'ExperimentInDB', ([], {}), '(**experiment)\n', (3819, 3833), False, 'from app.models.experiment import ExperimentCreate, ExperimentInDB, ExperimentUpdate\n'), ((4258, 4286), 'app.models.experiment.ExperimentInDB', 'ExperimentInDB', ([], {}), '(**experiment)\n', (... |
import numpy as np
from ..optics import OpticalElement, Wavefront
class MonochromaticPropagator(OpticalElement):
def __init__(self, wavelength):
self.wavelength = wavelength
def make_propagator(monochromatic_propagator):
class Propagator(OpticalElement):
def __init__(self, *args, **kwargs):
self.wavelengths ... | [
"numpy.abs",
"numpy.array"
] | [((662, 701), 'numpy.abs', 'np.abs', (['(wavelength - wavelength_closest)'], {}), '(wavelength - wavelength_closest)\n', (668, 701), True, 'import numpy as np\n'), ((564, 590), 'numpy.array', 'np.array', (['self.wavelengths'], {}), '(self.wavelengths)\n', (572, 590), True, 'import numpy as np\n')] |
import os
from .base import *
ALLOWED_HOSTS = ['jumpgate.caltech.edu']
DATABASES = {
'default': {
'ENGINE': 'django.db.backends.sqlite3',
'NAME': os.path.join(PROJECT_ROOT, 'fctracker.db'),
}
}
| [
"os.path.join"
] | [((168, 210), 'os.path.join', 'os.path.join', (['PROJECT_ROOT', '"""fctracker.db"""'], {}), "(PROJECT_ROOT, 'fctracker.db')\n", (180, 210), False, 'import os\n')] |
# Copyright 2021 <NAME>
# All rights reserved.
import numpy
import pyaudio
from snyth import Settings
from snyth.debug.samples import get_voice_samples
def play_voice_sync(audio, voice, realtime=True, seconds=1):
frames_per_buffer = Settings.instance().sample_rate//voice.frame_rate
stream = audio.open(rate=S... | [
"numpy.array",
"snyth.Settings.instance",
"numpy.concatenate"
] | [((963, 999), 'numpy.array', 'numpy.array', (['[]'], {'dtype': 'numpy.float32'}), '([], dtype=numpy.float32)\n', (974, 999), False, 'import numpy\n'), ((240, 259), 'snyth.Settings.instance', 'Settings.instance', ([], {}), '()\n', (257, 259), False, 'from snyth import Settings\n'), ((1526, 1572), 'numpy.concatenate', 'n... |
# Author : <NAME>
# Date : 5/31/19
# License: MIT
# Purpose:
#
# Notes :
#
# Questions:
#
# References :
#
import sys
import re
import datetime
import random
import copy
import operator
import numpy
from classes import GTF_ENTRY
from classes import FASTQ_READ
from classes import CHROMOSOME
from classes import GENE... | [
"operator.attrgetter",
"re.split",
"classes.GENE",
"classes.TRANSCRIPT",
"error.exit_with_error",
"numpy.random.normal",
"classes.reverse_complement",
"classes.INSERT",
"classes.FASTQ_READ",
"classes.EXON",
"datetime.datetime.now",
"copy.deepcopy",
"classes.GTF_ENTRY",
"classes.CHROMOSOME"... | [((1370, 1393), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (1391, 1393), False, 'import datetime\n'), ((2029, 2052), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (2050, 2052), False, 'import datetime\n'), ((2666, 2689), 'datetime.datetime.now', 'datetime.datetime.now', ([... |
from regexp_sar import RegexpSar
# Command to be evaluated
command = "(1 + 1 ) ^ (4 - (2 - 1))"
class StateSar:
def __init__(self, init_state):
super().__init__()
self._sar = RegexpSar()
self._state = init_state
self._all_states = set()
def add_regexp(self, state, regexp, ... | [
"regexp_sar.RegexpSar"
] | [((201, 212), 'regexp_sar.RegexpSar', 'RegexpSar', ([], {}), '()\n', (210, 212), False, 'from regexp_sar import RegexpSar\n')] |
# coding=utf-8
# 导入自己的函数包d2lzh_pytorch，注意要先将目标包的父路径添加到系统路径中
from torch import nn
import torch
import sys
sys.path.append(r".")
from d2lzh_pytorch import layers
"""
这一节介绍了神经网络的二维卷积
"""
# 在layers中写好测试用的卷积层函数，然后下面是效果
X = torch.tensor([
[0, 1, 2],
[3, 4, 5],
[6, 7, 8]
])
K = torch.tensor([
[0, 1],
[... | [
"torch.tensor",
"sys.path.append",
"torch.randn",
"d2lzh_pytorch.layers.corr2d",
"torch.ones"
] | [((106, 126), 'sys.path.append', 'sys.path.append', (['"""."""'], {}), "('.')\n", (121, 126), False, 'import sys\n'), ((222, 269), 'torch.tensor', 'torch.tensor', (['[[0, 1, 2], [3, 4, 5], [6, 7, 8]]'], {}), '([[0, 1, 2], [3, 4, 5], [6, 7, 8]])\n', (234, 269), False, 'import torch\n'), ((288, 318), 'torch.tensor', 'tor... |
"""
Randomly sample a fraction of a fastq file and just create one file
Note that if -p is 100 you will randomize the order of sequences in the file
"""
import os
import sys
import argparse
from random import sample
from roblib import stream_fastq, message
__author__ = '<NAME>'
__copyright__ = 'Copyright 2020, <NAME... | [
"roblib.stream_fastq",
"random.sample",
"argparse.ArgumentParser",
"roblib.message"
] | [((457, 531), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Randomly sample a single fastq file"""'}), "(description='Randomly sample a single fastq file')\n", (480, 531), False, 'import argparse\n'), ((1136, 1156), 'roblib.stream_fastq', 'stream_fastq', (['args.f'], {}), '(args.f)\n', ... |
from backend.downloader import Downloader #downloads files behind urls
from backend.zipfilehandler import ZipFileHandler #encapsulates a downloaded .zip file
from backend.plugininfo import Plugininfo #encapsulates a .plugininfo file
from backend.localfilehandler... | [
"backend.downloader.Downloader",
"backend.plugininfo.Plugininfo",
"backend.confighandler.ConfigHandler",
"os.path.abspath",
"backend.plugininfocollection.PlugininfoCollection",
"backend.zipfilehandler.ZipFileHandler",
"backend.localfilehandler.LocalFileHandler"
] | [((1674, 1686), 'backend.downloader.Downloader', 'Downloader', ([], {}), '()\n', (1684, 1686), False, 'from backend.downloader import Downloader\n'), ((1889, 1923), 'backend.confighandler.ConfigHandler', 'ConfigHandler', (['self.configFileName'], {}), '(self.configFileName)\n', (1902, 1923), False, 'from backend.config... |
import mailbox
import io
import time
from gevent.lock import Semaphore
from collections import defaultdict
from ..handleMail import store_message, object_to_message
locks = defaultdict(Semaphore)
class BCDBMailbox(mailbox.Mailbox):
def __init__(self, models, obj, create=False):
self._models = models
... | [
"time.time",
"collections.defaultdict",
"io.BytesIO",
"mailbox.NoSuchMailboxError"
] | [((174, 196), 'collections.defaultdict', 'defaultdict', (['Semaphore'], {}), '(Semaphore)\n', (185, 196), False, 'from collections import defaultdict\n'), ((1192, 1204), 'io.BytesIO', 'io.BytesIO', ([], {}), '()\n', (1202, 1204), False, 'import io\n'), ((4739, 4771), 'mailbox.NoSuchMailboxError', 'mailbox.NoSuchMailbox... |
from __future__ import absolute_import, unicode_literals
import logging
import requests
from celery import shared_task
from django.conf import settings
from django.core.cache import caches
from stats import views as stats_views
logger = logging.getLogger(__name__)
warm_views = [
stats_views.CompanyTypeCountVi... | [
"logging.getLogger",
"requests.get"
] | [((241, 268), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (258, 268), False, 'import logging\n'), ((1024, 1147), 'requests.get', 'requests.get', (['f"""{settings.BACKEND_SITE_URL}{endpoint}"""'], {'headers': "{'Authorization': f'Service {settings.SERVICE_TOKEN}'}"}), "(f'{settings.BACK... |
from collections import deque
import carla
# Import Planner from Carla codebase
from agents.navigation.global_route_planner import GlobalRoutePlanner
from agents.navigation.global_route_planner_dao import GlobalRoutePlannerDAO
from erdos.utils import setup_logging
import pylot.utils
class HDMap(object):
def __... | [
"agents.navigation.global_route_planner_dao.GlobalRoutePlannerDAO",
"erdos.utils.setup_logging",
"carla.Location"
] | [((643, 681), 'erdos.utils.setup_logging', 'setup_logging', (['"""hd_map"""', 'log_file_name'], {}), "('hd_map', log_file_name)\n", (656, 681), False, 'from erdos.utils import setup_logging\n'), ((479, 516), 'agents.navigation.global_route_planner_dao.GlobalRoutePlannerDAO', 'GlobalRoutePlannerDAO', (['self._map', '(1.... |
"""Baseado no livro Python Fluente, <NAME>."""
from abc import ABC, abstractmethod
from collections import namedtuple
Customer = namedtuple('Customer', 'name fidelity')
a = namedtuple('int', 'name')
class LineItem:
def __init__(self, product, quantity, price):
self.__product = product
self.__quan... | [
"collections.namedtuple"
] | [((130, 169), 'collections.namedtuple', 'namedtuple', (['"""Customer"""', '"""name fidelity"""'], {}), "('Customer', 'name fidelity')\n", (140, 169), False, 'from collections import namedtuple\n'), ((174, 199), 'collections.namedtuple', 'namedtuple', (['"""int"""', '"""name"""'], {}), "('int', 'name')\n", (184, 199), F... |
"""
Copyright (c) 2021 <NAME>.
Permission is hereby granted, free of charge, to any person obtaining
a copy of this software and associated documentation files (the
"Software"), to deal in the Software without restriction, including
without limitation the rights to use, copy, modify, merge, publish,
distribute, sublic... | [
"french_toast.alert.FrenchToastAlerter",
"os.environ.get"
] | [((853, 873), 'french_toast.alert.FrenchToastAlerter', 'FrenchToastAlerter', ([], {}), '()\n', (871, 873), False, 'from french_toast.alert import FrenchToastAlerter\n'), ((947, 972), 'os.environ.get', 'environ.get', (['"""PORT"""', '(5000)'], {}), "('PORT', 5000)\n", (958, 972), False, 'from os import environ\n')] |
import json
import logging
import urllib.request
from itertools import islice
from urllib.error import HTTPError
from client.baseclient import BaseClient
class Transmission(BaseClient):
def __init__(self, host, port, username, password, passkey):
manager = urllib.request.HTTPPasswordMgrWithPriorAuth()
... | [
"itertools.islice",
"logging.debug",
"json.dumps",
"logging.info",
"client.baseclient.BaseClient._get_new_credential"
] | [((2568, 2613), 'logging.info', 'logging.info', (['"""共计替换 %d 个种子的密钥"""', 'total_replace'], {}), "('共计替换 %d 个种子的密钥', total_replace)\n", (2580, 2613), False, 'import logging\n'), ((853, 949), 'logging.info', 'logging.info', (['"""连接到： Transmission %s，RPC版本：%d"""', "settings['version']", "settings['rpc-version']"], {}), ... |
"""
Node for Panda3d that renders a floor.
@author <NAME>
"""
from os import path
from pathlib import Path
from panda3d.core import GeomVertexFormat, Geom, GeomVertexData, GeomVertexWriter, GeomTriangles, GeomNode, \
TextureAttrib, RenderState, SamplerState
from direct.showbase.Loader import Loader
class FloorNo... | [
"panda3d.core.GeomVertexWriter",
"panda3d.core.Geom",
"panda3d.core.TextureAttrib.make",
"panda3d.core.GeomTriangles",
"panda3d.core.GeomVertexFormat.get_v3t2",
"panda3d.core.GeomNode.__init__",
"os.path.realpath",
"panda3d.core.RenderState.make",
"direct.showbase.Loader.Loader"
] | [((788, 821), 'panda3d.core.GeomVertexWriter', 'GeomVertexWriter', (['vdata', '"""vertex"""'], {}), "(vdata, 'vertex')\n", (804, 821), False, 'from panda3d.core import GeomVertexFormat, Geom, GeomVertexData, GeomVertexWriter, GeomTriangles, GeomNode, TextureAttrib, RenderState, SamplerState\n'), ((841, 876), 'panda3d.c... |
from collections import namedtuple
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import ray
import stats
Configuration = namedtuple('Configuration', ['banditCount'])
Observation = namedtuple('Observation', ['step', 'reward', 'agentIndex', 'lastActions'])
def smoke_test(agent):
config =... | [
"stats.get_los",
"stats.print_inline_stats",
"collections.namedtuple",
"numpy.random.rand",
"ray.get",
"stats.get_wins",
"stats.get_mean_and_ci",
"numpy.sum",
"numpy.zeros",
"pandas.DataFrame",
"numpy.full",
"matplotlib.pyplot.subplots",
"numpy.arange",
"matplotlib.pyplot.show"
] | [((149, 193), 'collections.namedtuple', 'namedtuple', (['"""Configuration"""', "['banditCount']"], {}), "('Configuration', ['banditCount'])\n", (159, 193), False, 'from collections import namedtuple\n'), ((208, 282), 'collections.namedtuple', 'namedtuple', (['"""Observation"""', "['step', 'reward', 'agentIndex', 'lastA... |
"""
Tests the LIME wrapper.
"""
# Author: <NAME> <<EMAIL>>
# <NAME> <<EMAIL>>
# License: new BSD
import pytest
try:
import lime
except ImportError: # pragma: no cover
pytest.skip(
'Skipping lime wrapper tests -- lime missing.',
allow_module_level=True)
else:
del lime
import impor... | [
"fatf.transparency.lime.Lime",
"fatf.utils.testing.transparency.InvalidModel",
"numpy.ones",
"fatf.utils.testing.imports.module_import_tester",
"fatf.utils.models.KNN",
"pytest.warns",
"numpy.array",
"pytest.raises",
"importlib.reload",
"fatf.utils.testing.transparency.NonProbabilisticModel",
"p... | [((1083, 1111), 'numpy.array', 'np.array', (['[0, 1, 0.08, 0.54]'], {}), '([0, 1, 0.08, 0.54])\n', (1091, 1111), True, 'import numpy as np\n'), ((1233, 1242), 'fatf.utils.models.KNN', 'fum.KNN', ([], {}), '()\n', (1240, 1242), True, 'import fatf.utils.models as fum\n'), ((2933, 2972), 'fatf.utils.testing.transparency.N... |
import os
import sys
from datetime import datetime, timedelta
import numpy as np
quick_hist = False
quick_bar = True
#quick_bar = False
def d4_computation_time_nparray( top='' ):
dirs = [ f.name for f in os.scandir( top ) ] #if f.is_file() ]
path_l = []
ftimes = []
ctimes = []
# Prepare file p... | [
"numpy.mean",
"numpy.copy",
"numpy.sqrt",
"matplotlib.pyplot.savefig",
"matplotlib.pyplot.clf",
"os.scandir",
"numpy.argmax",
"os.path.join",
"matplotlib.pyplot.close",
"numpy.array",
"numpy.zeros",
"numpy.nanmean",
"numpy.isnan",
"os.path.isfile",
"matplotlib.pyplot.subplots",
"numpy.... | [((11344, 11360), 'numpy.array', 'np.array', (['ctimes'], {}), '(ctimes)\n', (11352, 11360), True, 'import numpy as np\n'), ((1623, 1640), 'numpy.array', 'np.array', (['scale_l'], {}), '(scale_l)\n', (1631, 1640), True, 'import numpy as np\n'), ((2255, 2278), 'numpy.zeros', 'np.zeros', (['scale_l.shape'], {}), '(scale_... |
#! usr/bin/python3.6
"""
Module initially auto generated using V5Automation files from CATIA V5 R28 on 2020-07-06 14:02:20.222384
.. warning::
The notes denoted "CAA V5 Visual Basic Help" are to be used as reference only.
They are there as a guide as to how the visual basic / catscript function... | [
"pycatia.navigator_interfaces.group.Group",
"pycatia.navigator_interfaces.marker_3Ds.Marker3Ds",
"pycatia.navigator_interfaces.annotated_views.AnnotatedViews"
] | [((2446, 2489), 'pycatia.navigator_interfaces.annotated_views.AnnotatedViews', 'AnnotatedViews', (['self.section.AnnotatedViews'], {}), '(self.section.AnnotatedViews)\n', (2460, 2489), False, 'from pycatia.navigator_interfaces.annotated_views import AnnotatedViews\n'), ((6416, 6441), 'pycatia.navigator_interfaces.group... |
# -*- coding: utf-8 -*-
import codecs as cs
import nltk
import numpy as np
from utils import sample_token4,LoadGoldEntity
from keras.utils import np_utils
import pickle
SPARSE = 'Sparse_word'
PADDING= 'padding'
E1_B = 'entity1begin'
E1_E = 'entity1end'
E2_B = 'entity2begin'
E2_E = 'entity2end'
#一些用到的字典
small = {'a','... | [
"utils.sample_token4",
"nltk.tokenize.word_tokenize",
"numpy.array",
"numpy.zeros",
"utils.LoadGoldEntity",
"codecs.open"
] | [((2962, 2990), 'codecs.open', 'cs.open', (['abdir', '"""r"""', '"""utf-8"""'], {}), "(abdir, 'r', 'utf-8')\n", (2969, 2990), True, 'import codecs as cs\n'), ((3139, 3166), 'codecs.open', 'cs.open', (['edir', '"""r"""', '"""utf-8"""'], {}), "(edir, 'r', 'utf-8')\n", (3146, 3166), True, 'import codecs as cs\n'), ((3752,... |
import torch
def steps(end: float, steps=None, dtype=None, device=None) -> torch.Tensor:
"""Create a one-dimensional tensor of size `steps` whose values are evenly spaced
zero to `end`, exclusive of zero. That is, the value are:
`steps(end, steps) = torch.linspace(0, end, steps + 1)[1:]`
Args:
... | [
"torch.linspace"
] | [((560, 623), 'torch.linspace', 'torch.linspace', (['(0.0)', 'end', '(steps + 1)'], {'dtype': 'dtype', 'device': 'device'}), '(0.0, end, steps + 1, dtype=dtype, device=device)\n', (574, 623), False, 'import torch\n')] |
# date: 2019.04.18
# Bartlomiej 'furas' Burek
#
# https://stackoverflow.com/questions/16467479/normalizing-unicode
#
#
import os
import zipfile
import unicodedata
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('filename', help='zip file with MAC OS X names')
args = parser.parse_args()
def co... | [
"unicodedata.normalize",
"zipfile.ZipFile",
"argparse.ArgumentParser",
"os.makedirs"
] | [((191, 216), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (214, 216), False, 'import argparse\n'), ((392, 426), 'unicodedata.normalize', 'unicodedata.normalize', (['"""NFC"""', 'name'], {}), "('NFC', name)\n", (413, 426), False, 'import unicodedata\n'), ((470, 500), 'zipfile.ZipFile', 'zipfi... |
import numpy as np
import cv2
import glob
import matplotlib.pyplot as plt
import pickle
from pipeline import pipeline
from tracker import LineTracker
# ## Apply a perspective transform to rectify binary image to create a "birds-eye view"
def warper(img, src, dst):
# Compute and apply perpective transform
img_... | [
"cv2.getPerspectiveTransform",
"numpy.absolute",
"cv2.putText",
"cv2.addWeighted",
"cv2.warpPerspective",
"numpy.array",
"pipeline.pipeline"
] | [((364, 401), 'cv2.getPerspectiveTransform', 'cv2.getPerspectiveTransform', (['src', 'dst'], {}), '(src, dst)\n', (391, 401), False, 'import cv2\n'), ((415, 477), 'cv2.warpPerspective', 'cv2.warpPerspective', (['img', 'M', 'img_size'], {'flags': 'cv2.INTER_NEAREST'}), '(img, M, img_size, flags=cv2.INTER_NEAREST)\n', (4... |
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
class PPO():
def __init__(self, actor_critic, args):
self.actor_critic = actor_critic
self.args = args
self.optimizer = optim.Adam(
actor_critic.parameters(), lr=self.args.lr, eps=s... | [
"torch.max",
"torch.clamp",
"torch.exp",
"torch.min"
] | [((1566, 1622), 'torch.exp', 'torch.exp', (['(action_log_probs - old_action_log_probs_batch)'], {}), '(action_log_probs - old_action_log_probs_batch)\n', (1575, 1622), False, 'import torch\n'), ((1722, 1796), 'torch.clamp', 'torch.clamp', (['ratio', '(1.0 - self.args.clip_param)', '(1.0 + self.args.clip_param)'], {}), ... |
from pylatex import Command, UnsafeCommand, NoEscape
def add_heading(doc, cv_data):
doc.preamble.append(UnsafeCommand("newcommand", "\\cvHeading", options=1, extra_arguments=NoEscape(r"{}".format("""
{\\hspace{-\\marginparsep minus \\marginparwidth}
\\begin{minipage}[t]{\\textwidth + \\marginparwid... | [
"pylatex.Command"
] | [((565, 613), 'pylatex.Command', 'Command', (['"""cvHeading"""', "cv_data['contact']['name']"], {}), "('cvHeading', cv_data['contact']['name'])\n", (572, 613), False, 'from pylatex import Command, UnsafeCommand, NoEscape\n'), ((630, 656), 'pylatex.Command', 'Command', (['"""vspace"""', '"""0.2cm"""'], {}), "('vspace', ... |
from __future__ import print_function
import os
import json
import time
import re
import logging
from kutils.json_min_db import JsonMinConnexion
from wunderous.config import WEEK_OFFSET, DAY, WEEK, MONTHES, CSV_HEADER, config
from wunderous.drive import get_sheet_values, get_sheet_metadata, get_sheet_value, update_she... | [
"logging.getLogger",
"wunderous.utils.output_list",
"wunderous.utils.rewire_to_epoch",
"wunderous.git.get_git_dates",
"os.path.exists",
"wunderous.drive.get_sheet_values",
"wunderous.utils.save_csv",
"wunderous.utils.iso8601date_to_epoch",
"wunderous.utils.weeksheet_to_epoch",
"wunderous.utils.epo... | [((641, 668), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (658, 668), False, 'import logging\n'), ((892, 918), 'os.path.exists', 'os.path.exists', (['sheet_data'], {}), '(sheet_data)\n', (906, 918), False, 'import os\n'), ((7651, 7662), 'time.time', 'time.time', ([], {}), '()\n', (7660... |
# Copyright 2017 reinforce.io. 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... | [
"tensorflow.shape",
"tensorflow.train.SingularMonitoredSession",
"tensorforce.util.shape",
"tensorflow.train.Scaffold",
"tensorflow.control_dependencies",
"tensorforce.core.optimizers.GlobalOptimizer",
"copy.deepcopy",
"tensorflow.reduce_mean",
"tensorflow.scan",
"tensorflow.variables_initializer"... | [((22742, 23075), 'tensorflow.train.Saver', 'tf.train.Saver', ([], {'var_list': 'global_variables', 'reshape': '(False)', 'sharded': '(False)', 'max_to_keep': '(5)', 'keep_checkpoint_every_n_hours': '(10000.0)', 'name': 'None', 'restore_sequentially': '(False)', 'saver_def': 'None', 'builder': 'None', 'defer_build': '(... |
from skimage import io,data,color
import matplotlib.pyplot as plt
import os
cwd=os.getcwd()
data_dir2=cwd+'/split/'
file_list2=os.listdir(data_dir2)
file_list2.sort(key=lambda x:int(x[:-4]))
num=1
for file in file_list2:
img=io.imread(data_dir2+file)
img_gray=color.rgb2gray(img)
rows,cols=img_gray.shape
... | [
"skimage.io.imread",
"os.listdir",
"skimage.color.rgb2gray",
"os.getcwd"
] | [((81, 92), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (90, 92), False, 'import os\n'), ((129, 150), 'os.listdir', 'os.listdir', (['data_dir2'], {}), '(data_dir2)\n', (139, 150), False, 'import os\n'), ((231, 258), 'skimage.io.imread', 'io.imread', (['(data_dir2 + file)'], {}), '(data_dir2 + file)\n', (240, 258), Fals... |
# -*- coding:utf-8 -*-
from urllib import request
from urllib.parse import urljoin, urlencode
class Search:
def __init__(self):
self.word = ""
def execute(self, word):
with open("/Users/noriakioshita/.config/googleCustomSearch/.customsearchApikey.dat", "r", encoding="utf-8") as f:
... | [
"urllib.parse.urlencode",
"urllib.request.urlopen"
] | [((747, 764), 'urllib.parse.urlencode', 'urlencode', (['params'], {}), '(params)\n', (756, 764), False, 'from urllib.parse import urljoin, urlencode\n'), ((778, 798), 'urllib.request.urlopen', 'request.urlopen', (['url'], {}), '(url)\n', (793, 798), False, 'from urllib import request\n')] |
from django.test import SimpleTestCase
from medilov.forms import NameForm
class TestForms(SimpleTestCase):
def test_name_form_validation_with_valid_data(self):
form = NameForm(data={
"form_name": "Tim",
"form_email": "<EMAIL>",
"form_phone": "9999999999",
... | [
"medilov.forms.NameForm"
] | [((186, 424), 'medilov.forms.NameForm', 'NameForm', ([], {'data': "{'form_name': 'Tim', 'form_email': '<EMAIL>', 'form_phone': '9999999999',\n 'datepicker_start': '03/06/2020', 'datepicker_end': '03/08/2020',\n 'form_service': 'wedding photography', 'form_orderdescription': 'test'}"}), "(data={'form_name': 'Tim',... |
#!/usr/bin/env python3
import os
import unicodedata
import copy
from collections import OrderedDict
dbg = False
# labelQ = r" → q w e r t y u i o p [ ] "
label1 = r" § 1 2 3 4 5 6 7 8 9 0 - = ← "
labelQ = r" q w e r t y u i o p [ ] "
labelA = r" a s d f g h j k l ; ' \ "
labelZ = r" ` z x c v b n m , . /... | [
"collections.OrderedDict",
"os.path.join",
"os.path.dirname",
"copy.deepcopy",
"os.path.abspath"
] | [((593, 606), 'collections.OrderedDict', 'OrderedDict', ([], {}), '()\n', (604, 606), False, 'from collections import OrderedDict\n'), ((1311, 1336), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (1326, 1336), False, 'import os\n'), ((1353, 1386), 'os.path.join', 'os.path.join', (['scriptPat... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
"""
Main class
Created by: <NAME>
License: MIT (see LICENSE for details)
"""
import os, sys, logging
log = logging.getLogger()
from bs4 import BeautifulSoup
import patterns, scorers, cleaners
class Strainer:
def __init__(self, prettify = False, add_score = False, ... | [
"logging.getLogger",
"cleaners.demote_divs",
"scorers.text_blocks",
"scorers.highest",
"cleaners.remove_whitespace",
"scorers.extend",
"bs4.BeautifulSoup",
"scorers.sanitize",
"cleaners.remove_unlikely"
] | [((156, 175), 'logging.getLogger', 'logging.getLogger', ([], {}), '()\n', (173, 175), False, 'import os, sys, logging\n'), ((1122, 1148), 'cleaners.demote_divs', 'cleaners.demote_divs', (['soup'], {}), '(soup)\n', (1142, 1148), False, 'import patterns, scorers, cleaners\n'), ((1174, 1221), 'scorers.text_blocks', 'score... |
import os
import argparse
import numpy as np
import tokenization
from run_classifier import ColaProcessor, SstProcessor, MrpcProcessor, QqpProcessor, QnliProcessor, MnliProcessor, RteProcessor, SnliProcessor, WnliProcessor
from run_classifier import file_based_convert_examples_to_features
def grade(basepath):
task... | [
"numpy.array",
"argparse.ArgumentParser"
] | [((1767, 1778), 'numpy.array', 'np.array', (['y'], {}), '(y)\n', (1775, 1778), True, 'import numpy as np\n'), ((1791, 1806), 'numpy.array', 'np.array', (['y_hat'], {}), '(y_hat)\n', (1799, 1806), True, 'import numpy as np\n'), ((1861, 1886), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (1884,... |
import numpy as np
from denoising.utils import *
# from denoising.bm3d import BM3D
# from denoising.non_local_means import NLM
# from denoising.bilateral_filter import bilateral_filter
# from denoising.wavelet import wavelet_soft_thresholding, \
# wavelet_hard_thresholding
# from denoising.wiener import wiener_fil... | [
"numpy.array"
] | [((1231, 1256), 'numpy.array', 'np.array', (['filtered_images'], {}), '(filtered_images)\n', (1239, 1256), True, 'import numpy as np\n')] |
#!/usr/bin/python2.5
# Copyright (C) 2007 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 la... | [
"StringIO.StringIO",
"re.search",
"feedvalidator.RunValidationOutputToFile",
"transitfeed.other_problem",
"transitfeed.ProblemReporter",
"datetime.timedelta",
"transitfeed.Schedule",
"re.findall",
"unittest.main",
"datetime.date.today",
"feedvalidator.CalendarSummary",
"feedvalidator.LimitPerT... | [((20433, 20448), 'unittest.main', 'unittest.main', ([], {}), '()\n', (20446, 20448), False, 'import unittest\n'), ((10579, 10600), 'datetime.date.today', 'datetime.date.today', ([], {}), '()\n', (10598, 10600), False, 'import datetime\n'), ((10733, 10755), 'transitfeed.Schedule', 'transitfeed.Schedule', ([], {}), '()\... |
import logging
import sys
log = logging.getLogger(__name__)
log.setLevel(logging.DEBUG)
handler = logging.StreamHandler(sys.stdout)
handler.setFormatter(logging.Formatter("%(asctime)s [%(levelname)s] %(message)s"))
handler.setLevel(logging.DEBUG)
log.addHandler(handler)
| [
"logging.getLogger",
"logging.Formatter",
"logging.StreamHandler"
] | [((33, 60), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (50, 60), False, 'import logging\n'), ((100, 133), 'logging.StreamHandler', 'logging.StreamHandler', (['sys.stdout'], {}), '(sys.stdout)\n', (121, 133), False, 'import logging\n'), ((155, 215), 'logging.Formatter', 'logging.Format... |
# -*- coding: utf-8 -*-
# pylint: disable=locally-disabled, multiple-statements
# pylint: disable=fixme, line-too-long, invalid-name
# pylint: disable=W0703
""" Trivial Musical """
__author__ = 'EA1HET, EA1GIY'
__date__ = '12/09/2020'
from fastapi import FastAPI
import uvicorn
title = 'Trivial Musical'
description... | [
"fastapi.FastAPI",
"uvicorn.run"
] | [((394, 488), 'fastapi.FastAPI', 'FastAPI', ([], {'title': 'title', 'description': 'description', 'version': 'version', 'root_path': '""""""', 'redoc_url': '""""""'}), "(title=title, description=description, version=version, root_path='',\n redoc_url='')\n", (401, 488), False, 'from fastapi import FastAPI\n'), ((928... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import unittest
from pcompile import ureg
import os
import json
import simplejson
from pcompile.harness import Environment
from pcompile.solution import Solution
class TestContext(object):
'''
Initialize an app run environment from a typical config specifying a
... | [
"pcompile.solution.Solution",
"json.dumps",
"os.path.join",
"pcompile.harness.Environment",
"unittest.main",
"os.system",
"os.path.expanduser"
] | [((11686, 11701), 'unittest.main', 'unittest.main', ([], {}), '()\n', (11699, 11701), False, 'import unittest\n'), ((469, 511), 'os.path.join', 'os.path.join', (['testdir', '"""proto_config.json"""'], {}), "(testdir, 'proto_config.json')\n", (481, 511), False, 'import os\n'), ((555, 587), 'os.system', 'os.system', (["(... |
from skimage import data, filters
from skimage.color import rgb2gray
from matplotlib import pyplot as plt
from skimage.transform import rescale, resize, downscale_local_mean
from skimage.filters import threshold_otsu, try_all_threshold, threshold_multiotsu
import numpy as np
from skimage.filters.thresholding import _cr... | [
"skimage.filters.try_all_threshold",
"numpy.ptp",
"skimage.filters.threshold_otsu",
"skimage.data.camera",
"skimage.transform.downscale_local_mean",
"numpy.max",
"skimage.data.cat",
"numpy.min",
"numpy.argmin",
"skimage.filters.thresholding._cross_entropy",
"skimage.transform.rescale",
"skimag... | [((367, 377), 'skimage.data.cat', 'data.cat', ([], {}), '()\n', (375, 377), False, 'from skimage import data, filters\n'), ((386, 406), 'skimage.filters.sobel', 'filters.sobel', (['image'], {}), '(image)\n', (399, 406), False, 'from skimage import data, filters\n'), ((420, 454), 'matplotlib.pyplot.subplots', 'plt.subpl... |
#!/usr/bin/env python3
import os
from pathlib import Path
from app import process_playlist, model
from model import STORAGE_FOLDER, load_json
DB_FOLDER = "db"
PLAYLIST_DIR = Path(STORAGE_FOLDER) / DB_FOLDER / "playlist"
print("Loading indexes...", end="", flush=True)
model.load()
print("OK")
model.reset()
for file... | [
"model.load_json",
"os.listdir",
"app.process_playlist",
"pathlib.Path",
"app.model.load",
"app.model.save",
"app.model.reset"
] | [((273, 285), 'app.model.load', 'model.load', ([], {}), '()\n', (283, 285), False, 'from app import process_playlist, model\n'), ((298, 311), 'app.model.reset', 'model.reset', ([], {}), '()\n', (309, 311), False, 'from app import process_playlist, model\n'), ((328, 352), 'os.listdir', 'os.listdir', (['PLAYLIST_DIR'], {... |
'''
Different functions used to estimate the value of states.
These estimates are used as targets for training the value network.
'''
from enum import Enum
import torch
from models.models import bottle
from torch.nn.functional import mse_loss
__all__ = ['one_step_td', 'DreamerValueTarget', 'ValueTarget', 'get_target... | [
"torch.ones_like",
"torch.stack"
] | [((2429, 2449), 'torch.stack', 'torch.stack', (['outputs'], {}), '(outputs)\n', (2440, 2449), False, 'import torch\n'), ((2976, 3000), 'torch.ones_like', 'torch.ones_like', (['rewards'], {}), '(rewards)\n', (2991, 3000), False, 'import torch\n'), ((2046, 2069), 'torch.ones_like', 'torch.ones_like', (['reward'], {}), '(... |
import os
import shutil
from aidapy.hist import total_systematic_histogram
from aidapy.hist import hist2array
#from .style_mpl import atlas_mpl_style
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.patches as patches
from matplotlib.ticker import AutoMinorLocator, MultipleLocator
import matplotl... | [
"os.path.exists",
"matplotlib.patches.Rectangle",
"numpy.sqrt",
"os.makedirs",
"matplotlib.font_manager.FontProperties",
"aidapy.hist.total_systematic_histogram",
"numpy.delete",
"numpy.ediff1d",
"numpy.max",
"numpy.array",
"matplotlib.pyplot.figure",
"matplotlib.gridspec.GridSpec",
"numpy.m... | [((560, 576), 'matplotlib.font_manager.FontProperties', 'FontProperties', ([], {}), '()\n', (574, 576), False, 'from matplotlib.font_manager import FontProperties\n'), ((835, 862), 'matplotlib.pyplot.figure', 'plt.figure', ([], {'figsize': 'figsize'}), '(figsize=figsize)\n', (845, 862), True, 'import matplotlib.pyplot ... |
# pylint: skip-file
# Generated by Django 2.2.16 on 2021-01-15 19:57
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('passive_data_kit', '0091_auto_20200918_1819'),
]
operations = [
migrations.CreateModel(
name='PermissionsSu... | [
"django.db.models.AutoField"
] | [((372, 465), '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", (388, 465), False, 'from django.db import migrations, models\... |
from setuptools import setup
setup(
name='mtrack',
version='0.1',
description='ILP based tracking of microtubules in em image stacks',
url='https://github.com/nilsec/mtrack',
author='<NAME>',
author_email='<EMAIL>',
license='MIT',
packages=[
'mtrack',
'mtrack.graphs',
... | [
"setuptools.setup"
] | [((30, 447), 'setuptools.setup', 'setup', ([], {'name': '"""mtrack"""', 'version': '"""0.1"""', 'description': '"""ILP based tracking of microtubules in em image stacks"""', 'url': '"""https://github.com/nilsec/mtrack"""', 'author': '"""<NAME>"""', 'author_email': '"""<EMAIL>"""', 'license': '"""MIT"""', 'packages': "[... |
import warnings
from itertools import chain
from joblib import Parallel, delayed
from .ops import BaseOp, BaseInput, BaseOutput
class Pipeline:
"""Base class for image processing pipelines.
A pipeline can be created by subclassing, instantiating the required
data loaders and operations from `ops` in th... | [
"joblib.Parallel",
"itertools.chain.from_iterable",
"warnings.warn",
"joblib.delayed"
] | [((1373, 1409), 'itertools.chain.from_iterable', 'chain.from_iterable', (['all_subject_ids'], {}), '(all_subject_ids)\n', (1392, 1409), False, 'from itertools import chain\n'), ((4142, 4187), 'joblib.Parallel', 'Parallel', ([], {'n_jobs': 'self.n_jobs', 'verbose': 'verbose'}), '(n_jobs=self.n_jobs, verbose=verbose)\n',... |
"""
types.phonenumber
~~~~~~~~~~~~~~~~~
schematics united states phone number type
"""
import phonenumbers as pn
from phonenumbers.phonenumberutil import NumberParseException
from schematics.exceptions import ConversionError
from schematics.types import BaseType
class Type(BaseType):
""" U.S. phone... | [
"phonenumbers.is_valid_number",
"schematics.exceptions.ConversionError",
"phonenumbers.is_possible_number",
"phonenumbers.format_number",
"phonenumbers.parse"
] | [((1425, 1475), 'phonenumbers.format_number', 'pn.format_number', (['phone', 'pn.PhoneNumberFormat.E164'], {}), '(phone, pn.PhoneNumberFormat.E164)\n', (1441, 1475), True, 'import phonenumbers as pn\n'), ((1499, 1553), 'phonenumbers.format_number', 'pn.format_number', (['phone', 'pn.PhoneNumberFormat.NATIONAL'], {}), '... |
#NORMALIZE FWI VALUES IN INITIAL CSV
import csv
import datetime
import numpy as np
import os
from netCDF4 import Dataset
import pandas
#INITIALIZE REGULAR LISTS
fsize = []
dc = []
dmc = []
ffmc = []
isi = []
bui = []
fwi = []
#INITIALIZE NORMALIZED LISTS
fsizenorm = []
dcnorm = []
dmcnorm = []
ff... | [
"pandas.DataFrame",
"csv.reader"
] | [((2016, 2111), 'pandas.DataFrame', 'pandas.DataFrame', (['raw_data'], {'columns': "['FIRE_SIZE', 'DC', 'DMC', 'FFMC', 'ISI', 'BUI', 'FWI']"}), "(raw_data, columns=['FIRE_SIZE', 'DC', 'DMC', 'FFMC', 'ISI',\n 'BUI', 'FWI'])\n", (2032, 2111), False, 'import pandas\n'), ((459, 479), 'csv.reader', 'csv.reader', (['csvin... |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'ui/qt/main.ui'
#
# Created: Thu Jan 15 22:44:27 2015
# by: PyQt4 UI code generator 4.11.3
#
# WARNING! All changes made in this file will be lost!
from PyQt4 import QtCore, QtGui
try:
_fromUtf8 = QtCore.QString.fromUtf8
except Att... | [
"PyQt4.QtCore.QSize",
"PyQt4.QtGui.QFormLayout",
"PyQt4.QtGui.QSizePolicy",
"PyQt4.QtCore.QMetaObject.connectSlotsByName",
"PyQt4.QtGui.QLabel",
"PyQt4.QtGui.QPushButton",
"PyQt4.QtGui.QComboBox",
"PyQt4.QtGui.QVBoxLayout",
"PyQt4.QtGui.QLineEdit",
"PyQt4.QtGui.QFrame",
"PyQt4.QtGui.QApplication... | [((485, 549), 'PyQt4.QtGui.QApplication.translate', 'QtGui.QApplication.translate', (['context', 'text', 'disambig', '_encoding'], {}), '(context, text, disambig, _encoding)\n', (513, 549), False, 'from PyQt4 import QtCore, QtGui\n'), ((837, 910), 'PyQt4.QtGui.QSizePolicy', 'QtGui.QSizePolicy', (['QtGui.QSizePolicy.Min... |
#
# facebook messanger application
# ref : <EMAIL>
# https://python-scripts.com/gif-messenger-bot-with-flask
#
#!pip install Flask requests
# The Flask app runs a local server("127.0.01:5000"by default),
# but we can't set this as a WebHook (event handler) for the bot messenger
# as it is not connected to the network... | [
"flask.request.args.get",
"requests.post",
"flask.Flask",
"json.dumps",
"requests.get",
"flask.request.get_json"
] | [((503, 518), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\n', (508, 518), False, 'from flask import Flask, request\n'), ((1085, 1103), 'flask.request.get_json', 'request.get_json', ([], {}), '()\n', (1101, 1103), False, 'from flask import Flask, request\n'), ((1513, 1583), 'requests.get', 'requests.get', ([... |
import torch.nn as nn
import torch
import math
class NoSkipBertSelfOutput(nn.Module):
def __init__(self, config):
super().__init__()
self.dense = nn.Linear(config.hidden_size, config.hidden_size)
self.LayerNorm = nn.LayerNorm(config.hidden_size, eps=config.layer_norm_eps)
self.drop... | [
"torch.nn.Dropout",
"torch.nn.Softmax",
"transformers.models.distilbert.modeling_distilbert.FFN",
"torch.nn.LayerNorm",
"math.sqrt",
"transformers.models.t5.modeling_t5.T5Attention",
"transformers.models.distilbert.modeling_distilbert.MultiHeadSelfAttention",
"torch.matmul",
"torch.einsum",
"torch... | [((168, 217), 'torch.nn.Linear', 'nn.Linear', (['config.hidden_size', 'config.hidden_size'], {}), '(config.hidden_size, config.hidden_size)\n', (177, 217), True, 'import torch.nn as nn\n'), ((243, 302), 'torch.nn.LayerNorm', 'nn.LayerNorm', (['config.hidden_size'], {'eps': 'config.layer_norm_eps'}), '(config.hidden_siz... |
#!/usr/bin/env python
from setuptools import setup
setup(
name='PyGoodReads',
version='0.0.1',
description='A wrapper of the GoodReads API in Python.',
author='<NAME>',
author_email='<EMAIL>',
packages=['goodreads'],
package_dir={'goodreads': 'goodreads'},
install_requires=[
'r... | [
"setuptools.setup"
] | [((53, 347), 'setuptools.setup', 'setup', ([], {'name': '"""PyGoodReads"""', 'version': '"""0.0.1"""', 'description': '"""A wrapper of the GoodReads API in Python."""', 'author': '"""<NAME>"""', 'author_email': '"""<EMAIL>"""', 'packages': "['goodreads']", 'package_dir': "{'goodreads': 'goodreads'}", 'install_requires'... |
import asyncio
from zeroservices.backend.mongodb import MongoDBCollection
from . import _BaseCollectionTestCase
from ..utils import TestCase, _create_test_resource_service, _async_test
try:
from unittest.mock import Mock
except ImportError:
from mock import Mock
class MongoDBCollectionTestCase(_BaseCollect... | [
"asyncio.set_event_loop",
"asyncio.new_event_loop",
"zeroservices.backend.mongodb.MongoDBCollection"
] | [((473, 530), 'zeroservices.backend.mongodb.MongoDBCollection', 'MongoDBCollection', (['self.resource_name', 'self.database_name'], {}), '(self.resource_name, self.database_name)\n', (490, 530), False, 'from zeroservices.backend.mongodb import MongoDBCollection\n'), ((863, 891), 'asyncio.set_event_loop', 'asyncio.set_e... |
#
# inventory/suppliers/api/views.py
#
"""
Supplier Views.
"""
__docformat__ = "restructuredtext en"
import logging
from decimal import Decimal
from rest_framework.generics import (
ListCreateAPIView, RetrieveUpdateDestroyAPIView)
from rest_framework.exceptions import PermissionDenied, NotAuthenticated
from rest_... | [
"logging.getLogger",
"inventory.suppliers.models.Supplier.objects.all",
"inventory.common.api.parsers.parser_factory",
"rest_condition.And",
"inventory.common.api.renderers.renderer_factory",
"decimal.Decimal"
] | [((1073, 1113), 'logging.getLogger', 'logging.getLogger', (['"""api.suppliers.views"""'], {}), "('api.suppliers.views')\n", (1090, 1113), False, 'import logging\n'), ((1871, 1893), 'inventory.suppliers.models.Supplier.objects.all', 'Supplier.objects.all', ([], {}), '()\n', (1891, 1893), False, 'from inventory.suppliers... |