code stringlengths 20 1.04M | apis list | extract_api stringlengths 75 9.94M |
|---|---|---|
import shutil
from os.path import expanduser, exists
from configobj import ConfigObj
def load_config(usr_cfg, def_cfg=None):
cfg = ConfigObj()
cfg.merge(ConfigObj(def_cfg, interpolation=False))
cfg.merge(ConfigObj(expanduser(usr_cfg), interpolation=False))
cfg.filename = expanduser(usr_cfg)
return... | [
"shutil.copyfile",
"os.path.expanduser",
"configobj.ConfigObj",
"os.path.exists"
] | [((136, 147), 'configobj.ConfigObj', 'ConfigObj', ([], {}), '()\n', (145, 147), False, 'from configobj import ConfigObj\n'), ((289, 308), 'os.path.expanduser', 'expanduser', (['usr_cfg'], {}), '(usr_cfg)\n', (299, 308), False, 'from os.path import expanduser, exists\n'), ((408, 431), 'os.path.expanduser', 'expanduser',... |
from malaya_speech.utils.text import (
convert_to_ascii,
collapse_whitespace,
put_spacing_num,
tts_encode,
TextIDS,
)
from malaya_speech.supervised import tts
import numpy as np
import logging
from typing import Callable
logger = logging.getLogger('malaya_speech.tts')
_tacotron2_availability = {
... | [
"malaya_speech.utils.describe_availability",
"malaya_speech.supervised.tts.tacotron_load",
"packaging.version.parse",
"malaya_speech.utils.text.TextIDS",
"malaya.normalize.normalizer",
"malaya_speech.supervised.tts.fastpitch_load",
"malaya_speech.supervised.tts.glowtts_load",
"malaya_speech.supervised... | [((251, 289), 'logging.getLogger', 'logging.getLogger', (['"""malaya_speech.tts"""'], {}), "('malaya_speech.tts')\n", (268, 289), False, 'import logging\n'), ((5723, 5861), 'malaya_speech.utils.describe_availability', 'describe_availability', (['_tacotron2_availability'], {'text': '"""`husein`, `haqkiem` and `female-si... |
import fiona
import os
import time
import argparse
from osgeo import gdal, ogr, osr
import shapefile
from hydroDL.utils import gis
from hydroDL import kPath
import numpy as np
import pandas as pd
"""
test for
1 convert a raster to points
2 project and write a shapefile
using osgeo shits
Failed. Easier way is to expor... | [
"osgeo.ogr.Open",
"osgeo.ogr.GetDriverByName",
"osgeo.osr.CoordinateTransformation",
"os.path.exists",
"numpy.array",
"numpy.arange",
"osgeo.ogr.Geometry",
"osgeo.gdal.Open",
"os.path.join",
"osgeo.osr.SpatialReference",
"osgeo.ogr.Feature"
] | [((358, 423), 'os.path.join', 'os.path.join', (['kPath.dirData', '"""USGS"""', '"""basins"""', '"""basinAll_prj.shp"""'], {}), "(kPath.dirData, 'USGS', 'basins', 'basinAll_prj.shp')\n", (370, 423), False, 'import os\n'), ((461, 517), 'os.path.join', 'os.path.join', (['kPath.dirData', '"""GLiM"""', '"""NA_gageII_1KM.tif... |
"""
This is the Python interface
"""
import logging
from geopy.extra.rate_limiter import RateLimiter
from sqlite_utils import Database
log = logging.getLogger("geocode_sqlite")
GEOMETRY_COLUMN = "geometry"
GEOCODER_COLUMN = "geocoder"
def geocode_table(
db,
table_name,
geocoder,
query_template="{loc... | [
"sqlite_utils.Database",
"logging.getLogger",
"geopy.extra.rate_limiter.RateLimiter"
] | [((142, 177), 'logging.getLogger', 'logging.getLogger', (['"""geocode_sqlite"""'], {}), "('geocode_sqlite')\n", (159, 177), False, 'import logging\n'), ((2255, 2309), 'geopy.extra.rate_limiter.RateLimiter', 'RateLimiter', (['geocoder.geocode'], {'min_delay_seconds': 'delay'}), '(geocoder.geocode, min_delay_seconds=dela... |
import rhinoscriptsyntax as rs
polySrfs = rs.GetObjects('select polysrfs', rs.filter.polysurface, preselect=True)
width = rs.GetReal("width", 0.2)
height = rs.GetReal("height", 3)
# if polySrf:
def wallProfile(polySrf):
if polySrf:
offsets = []
border = rs.DuplicateSurfaceBorder( polySrf )
... | [
"rhinoscriptsyntax.CopyObject",
"rhinoscriptsyntax.SimplifyCurve",
"rhinoscriptsyntax.CreateVector",
"rhinoscriptsyntax.ExplodePolysurfaces",
"rhinoscriptsyntax.GetReal",
"rhinoscriptsyntax.EnableRedraw",
"rhinoscriptsyntax.IsPolysurfaceClosed",
"rhinoscriptsyntax.CurveAreaCentroid",
"rhinoscriptsyn... | [((43, 114), 'rhinoscriptsyntax.GetObjects', 'rs.GetObjects', (['"""select polysrfs"""', 'rs.filter.polysurface'], {'preselect': '(True)'}), "('select polysrfs', rs.filter.polysurface, preselect=True)\n", (56, 114), True, 'import rhinoscriptsyntax as rs\n'), ((123, 147), 'rhinoscriptsyntax.GetReal', 'rs.GetReal', (['""... |
import pytest
from django.db.models.query import QuerySet
from accounts.models import Account
from .models import UserMessage
from .forms import UserMessageForm
@pytest.mark.django_db
def test_main_feed():
out = UserMessage.messages.main_feed()
assert isinstance(out, QuerySet)
assert all(isinstance(m, Us... | [
"accounts.models.Account.accounts.first"
] | [((978, 1002), 'accounts.models.Account.accounts.first', 'Account.accounts.first', ([], {}), '()\n', (1000, 1002), False, 'from accounts.models import Account\n')] |
"""Custom CSV-related functionality."""
import csv
import os
def create_csv():
"""Create new csv to store git-geo result
Delete any existing csv and the create new csv.
Args:
None
Returns:
None
"""
# delete csv if it already exists
filename = "git-geo-results.csv"
i... | [
"os.remove",
"os.path.exists",
"csv.DictWriter"
] | [((322, 346), 'os.path.exists', 'os.path.exists', (['filename'], {}), '(filename)\n', (336, 346), False, 'import os\n'), ((356, 375), 'os.remove', 'os.remove', (['filename'], {}), '(filename)\n', (365, 375), False, 'import os\n'), ((529, 572), 'csv.DictWriter', 'csv.DictWriter', (['file'], {'fieldnames': 'fieldnames'})... |
from CoSpecPy.composites import Composite
from CoSpecPy.download import DownloadHandler
from CoSpecPy.plotting import ComparisonPlot
import pkg_resources
import os
from astropy.io import fits
print("Testing Composite")
test_aria2_download = DownloadHandler("aria2", 5, 10, "test_tmp")
test_aria2_download.clear_up()
ex... | [
"os.path.abspath",
"CoSpecPy.plotting.ComparisonPlot",
"CoSpecPy.composites.Composite",
"CoSpecPy.download.DownloadHandler",
"astropy.io.fits.open"
] | [((242, 285), 'CoSpecPy.download.DownloadHandler', 'DownloadHandler', (['"""aria2"""', '(5)', '(10)', '"""test_tmp"""'], {}), "('aria2', 5, 10, 'test_tmp')\n", (257, 285), False, 'from CoSpecPy.download import DownloadHandler\n'), ((337, 385), 'os.path.abspath', 'os.path.abspath', (['"""test_tmp/example_speclist.txt"""... |
from tensorflow.python.keras import backend as K
from tensorflow.python.keras.models import model_from_yaml
from rdkit.Chem import AllChem
from rdkit.Chem import MACCSkeys
from optparse import OptionParser
import rdkit
import rdkit.Chem as Chem
import torch
import pandas as pd
import numpy as np
import sys
import subpr... | [
"sys.path.append",
"rdkit.Chem.AllChem.GetMorganFingerprintAsBitVect",
"pandas.read_csv",
"numpy.asarray",
"tensorflow.python.keras.models.model_from_yaml",
"rdkit.Chem.SDWriter",
"rdkit.Chem.AllChem.ETKDG",
"rdkit.Chem.RDKFingerprint",
"rdkit.RDLogger.logger",
"numpy.fromstring",
"tensorflow.py... | [((336, 360), 'sys.path.append', 'sys.path.append', (['"""jtnn/"""'], {}), "('jtnn/')\n", (351, 360), False, 'import sys\n'), ((380, 402), 'sys.path.append', 'sys.path.append', (['"""../"""'], {}), "('../')\n", (395, 402), False, 'import sys\n'), ((2420, 2446), 'rdkit.Chem.MolFromSmiles', 'Chem.MolFromSmiles', (['smile... |
import os
import sys
import shutil
try:
os.environ['PLUTO_DIR']
except KeyError:
print('PLUTO_DIR not defined. Setting it to the Current Directory')
pluto_directory = os.getcwd()
pass
else:
pluto_directory = os.environ['PLUTO_DIR']
sys.path.append(pluto_directory + '/Tools/Python/')
import menu
import confi... | [
"sys.path.append",
"configure.check",
"os.getcwd",
"menu.RestoreScreen",
"menu.Browse",
"os.path.exists",
"menu.Prompt",
"make_problem.MakeProblem",
"menu.SetTitle",
"menu.Print",
"shutil.copy",
"menu.CursesIsActive",
"sys.exit"
] | [((244, 295), 'sys.path.append', 'sys.path.append', (["(pluto_directory + '/Tools/Python/')"], {}), "(pluto_directory + '/Tools/Python/')\n", (259, 295), False, 'import sys\n'), ((432, 443), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (441, 443), False, 'import os\n'), ((1678, 1699), 'menu.CursesIsActive', 'menu.Curses... |
"""
Snippet for creating a tamr client object with manual passing of credentials during runtime.
Note: This approach cannot be coupled with fully automated workflows (e.g., crontab jobs)
"""
from getpass import getpass
from tamr_toolbox import utils as tbu
# load configuration variables that do not include AUTH crede... | [
"getpass.getpass",
"tamr_toolbox.utils.client.create",
"tamr_toolbox.utils.config.from_yaml"
] | [((357, 390), 'tamr_toolbox.utils.config.from_yaml', 'tbu.config.from_yaml', (['config_path'], {}), '(config_path)\n', (377, 390), True, 'from tamr_toolbox import utils as tbu\n'), ((558, 585), 'getpass.getpass', 'getpass', (['"""Enter password: """'], {}), "('Enter password: ')\n", (565, 585), False, 'from getpass imp... |
from __future__ import division
from models import *
from utils.utils import *
from utils.datasets import *
from torch.utils.data import DataLoader
from torch.autograd import Variable
from unet import UNet
from LPR_Net import*
import time
import cv2
import argparse
import torch
import csv
parser = argparse.ArgumentPar... | [
"csv.writer",
"argparse.ArgumentParser",
"unet.UNet",
"cv2.cvtColor",
"torch.load",
"time.time",
"cv2.imread",
"torch.cuda.is_available",
"torch.zeros",
"cv2.erode",
"torch.no_grad",
"cv2.resize"
] | [((300, 325), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (323, 325), False, 'import argparse\n'), ((1468, 1502), 'csv.writer', 'csv.writer', (['csvfile'], {'delimiter': '""","""'}), "(csvfile, delimiter=',')\n", (1478, 1502), False, 'import csv\n'), ((1620, 1651), 'unet.UNet', 'UNet', ([], ... |
from __future__ import absolute_import, division, print_function, unicode_literals
from six import python_2_unicode_compatible, string_types
import warnings
from canvasapi.canvas_object import CanvasObject
from canvasapi.grading_standard import GradingStandard
from canvasapi.exceptions import CanvasException, Requir... | [
"canvasapi.content_migration.ContentMigration",
"canvasapi.exceptions.CanvasException",
"canvasapi.exceptions.RequiredFieldMissing",
"canvasapi.external_tool.ExternalTool",
"canvasapi.util.obj_or_id",
"canvasapi.authentication_provider.AuthenticationProvider",
"warnings.warn",
"canvasapi.enrollment_te... | [((1430, 1462), 'canvasapi.util.obj_or_id', 'obj_or_id', (['user', '"""user"""', '(User,)'], {}), "(user, 'user', (User,))\n", (1439, 1462), False, 'from canvasapi.util import combine_kwargs, obj_or_id\n'), ((1482, 1545), 'canvasapi.util.obj_or_id', 'obj_or_id', (['notification', '"""notification"""', '(AccountNotifica... |
import torch
from torch._utils import _flatten_dense_tensors, _unflatten_dense_tensors
import torch.distributed as dist
warn_on_half = True
def broadcast_params(params):
for p in params:
if torch.is_tensor(p):
torch.distributed.broadcast(p, 0)
def reduce_gradients(module):
buckets = {}
for name, param in mod... | [
"torch.cuda.synchronize",
"torch._utils._flatten_dense_tensors",
"torch.distributed.all_reduce",
"torch.distributed.get_world_size",
"torch.distributed.broadcast",
"torch.is_tensor",
"torch._utils._unflatten_dense_tensors"
] | [((195, 213), 'torch.is_tensor', 'torch.is_tensor', (['p'], {}), '(p)\n', (210, 213), False, 'import torch\n'), ((823, 852), 'torch._utils._flatten_dense_tensors', '_flatten_dense_tensors', (['grads'], {}), '(grads)\n', (845, 852), False, 'from torch._utils import _flatten_dense_tensors, _unflatten_dense_tensors\n'), (... |
from django.db import models
from django.db.models import Case
from django.db.models import Value as V
from django.db.models import When
from django.utils import timezone
from graphene_django_jwt.settings import jwt_settings
class RefreshTokenQuerySet(models.QuerySet):
def expired(self):
expires = timezo... | [
"django.utils.timezone.now",
"django.db.models.Value",
"django.db.models.BooleanField"
] | [((314, 328), 'django.utils.timezone.now', 'timezone.now', ([], {}), '()\n', (326, 328), False, 'from django.utils import timezone\n'), ((531, 552), 'django.db.models.BooleanField', 'models.BooleanField', ([], {}), '()\n', (550, 552), False, 'from django.db import models\n'), ((578, 586), 'django.db.models.Value', 'V',... |
# -*- coding: utf-8 -*-
# @Time : 2020/9/14
# @Author : <NAME>
# @Email : <EMAIL>
"""
CFKG
##################################################
Reference:
Qingyao Ai et al. "Learning heterogeneous knowledge base embeddings for explainable recommendation." in MDPI 2018.
"""
import torch
import torch.nn as nn
impo... | [
"torch.norm",
"torch.nn.Embedding",
"torch.cat",
"torch.mul",
"torch.nn.functional.softplus",
"torch.nn.TripletMarginLoss"
] | [((1702, 1749), 'torch.nn.Embedding', 'nn.Embedding', (['self.n_users', 'self.embedding_size'], {}), '(self.n_users, self.embedding_size)\n', (1714, 1749), True, 'import torch.nn as nn\n'), ((1782, 1832), 'torch.nn.Embedding', 'nn.Embedding', (['self.n_entities', 'self.embedding_size'], {}), '(self.n_entities, self.emb... |
import parse
import sys
import asm
if len(sys.argv) != 3:
print("Usage: python main.py <tacPath> <stPath>")
exit(1)
parsed = parse.Parse(sys.argv[1], sys.argv[2])
print(parsed.tt)
print("Tac parsed:")
parsed.print_tac()
print()
print("Type table:")
parsed.print_tt()
print()
print("Symbol table:")
parsed... | [
"asm.gen",
"parse.Parse",
"asm.write_asm",
"asm.ASM"
] | [((135, 172), 'parse.Parse', 'parse.Parse', (['sys.argv[1]', 'sys.argv[2]'], {}), '(sys.argv[1], sys.argv[2])\n', (146, 172), False, 'import parse\n'), ((348, 363), 'asm.ASM', 'asm.ASM', (['parsed'], {}), '(parsed)\n', (355, 363), False, 'import asm\n'), ((364, 373), 'asm.gen', 'asm.gen', ([], {}), '()\n', (371, 373), ... |
import numpy as np
import string as str
import bibtexparser
FILENAME = '_data/ref.bib'
OUTFILE = '_includes/bib.html'
def format_authors(al):
al = np.str(al)
al = al.replace("and",";")
al = al.replace("{","")
al = al.replace("}","")
al = al.replace("~","")
return al
def format_journal(jl):
... | [
"bibtexparser.load",
"numpy.min",
"numpy.max",
"numpy.arange",
"numpy.int",
"numpy.str"
] | [((2281, 2294), 'numpy.min', 'np.min', (['years'], {}), '(years)\n', (2287, 2294), True, 'import numpy as np\n'), ((2306, 2319), 'numpy.max', 'np.max', (['years'], {}), '(years)\n', (2312, 2319), True, 'import numpy as np\n'), ((153, 163), 'numpy.str', 'np.str', (['al'], {}), '(al)\n', (159, 163), True, 'import numpy a... |
import argparse, matplotlib as mpl, matplotlib.pyplot as plt, numpy as np, os, torch
mpl.rcParams["axes.spines.right"] = False
mpl.rcParams["axes.spines.top"] = False
mpl.rc('font', family='serif')
from .bootstrap import bootstrap2d
from flexehr.utils.modelIO import load_metadata, load_model
from utils.helpers import ... | [
"matplotlib.pyplot.xlim",
"matplotlib.rc",
"matplotlib.pyplot.show",
"argparse.ArgumentParser",
"matplotlib.pyplot.ylim",
"matplotlib.pyplot.legend",
"utils.helpers.array",
"numpy.random.randint",
"flexehr.utils.modelIO.load_model",
"torch.cuda.is_available",
"numpy.linspace",
"matplotlib.pypl... | [((167, 197), 'matplotlib.rc', 'mpl.rc', (['"""font"""'], {'family': '"""serif"""'}), "('font', family='serif')\n", (173, 197), True, 'import argparse, matplotlib as mpl, matplotlib.pyplot as plt, numpy as np, os, torch\n'), ((1273, 1288), 'matplotlib.pyplot.xlim', 'plt.xlim', (['(0)', '(48)'], {}), '(0, 48)\n', (1281,... |
import pathlib
import types
from typing import Optional
def get_base_dir(module: Optional[types.ModuleType] = None) -> pathlib.Path:
if module is None:
file = pathlib.Path(__file__).parent
else:
file = module.__file__ # type: ignore
return pathlib.Path(file).parent.relative_to(pathlib.Pa... | [
"pathlib.Path.cwd",
"pathlib.Path"
] | [((310, 328), 'pathlib.Path.cwd', 'pathlib.Path.cwd', ([], {}), '()\n', (326, 328), False, 'import pathlib\n'), ((174, 196), 'pathlib.Path', 'pathlib.Path', (['__file__'], {}), '(__file__)\n', (186, 196), False, 'import pathlib\n'), ((272, 290), 'pathlib.Path', 'pathlib.Path', (['file'], {}), '(file)\n', (284, 290), Fa... |
import logging
from core.api.grpc import client, core_pb2
def log_event(event):
logging.info("event: %s", event)
def main():
core = client.CoreGrpcClient()
with core.context_connect():
# create session
response = core.create_session()
logging.info("created session: %s", respons... | [
"logging.basicConfig",
"core.api.grpc.core_pb2.Node",
"core.api.grpc.core_pb2.Position",
"logging.info",
"core.api.grpc.client.InterfaceHelper",
"core.api.grpc.client.CoreGrpcClient"
] | [((87, 119), 'logging.info', 'logging.info', (['"""event: %s"""', 'event'], {}), "('event: %s', event)\n", (99, 119), False, 'import logging\n'), ((145, 168), 'core.api.grpc.client.CoreGrpcClient', 'client.CoreGrpcClient', ([], {}), '()\n', (166, 168), False, 'from core.api.grpc import client, core_pb2\n'), ((1797, 183... |
import json
from django.test import TestCase
from django.urls import reverse
from src.regions.models import Region
class RegionListViewTestCase(TestCase):
def setUp(self):
self.url = reverse("region-list")
self.region_1 = Region.objects.create(code="DE", name="Germany")
self.region_2 = R... | [
"src.regions.models.Region.objects.create",
"src.regions.models.Region.objects.last",
"json.dumps",
"django.urls.reverse",
"src.regions.models.Region.objects.filter",
"src.regions.models.Region.objects.count"
] | [((199, 221), 'django.urls.reverse', 'reverse', (['"""region-list"""'], {}), "('region-list')\n", (206, 221), False, 'from django.urls import reverse\n'), ((246, 294), 'src.regions.models.Region.objects.create', 'Region.objects.create', ([], {'code': '"""DE"""', 'name': '"""Germany"""'}), "(code='DE', name='Germany')\n... |
from datetime import timedelta
from django.contrib.auth.models import User
from django.test import TestCase
from django.utils import timezone
from votepredictapp.models import Answer, Prediction, Question, Reply, Vote
class ModelsTests(TestCase):
def setUp(self) -> None:
self.start_date = timezone.now()... | [
"django.utils.timezone.now",
"votepredictapp.models.Reply",
"django.contrib.auth.models.User",
"votepredictapp.models.Prediction",
"votepredictapp.models.Vote",
"votepredictapp.models.Answer",
"votepredictapp.models.Question",
"datetime.timedelta"
] | [((306, 320), 'django.utils.timezone.now', 'timezone.now', ([], {}), '()\n', (318, 320), False, 'from django.utils import timezone\n'), ((535, 563), 'django.contrib.auth.models.User', 'User', ([], {'username': '"""sample_user"""'}), "(username='sample_user')\n", (539, 563), False, 'from django.contrib.auth.models impor... |
#libraries for audio input
import keras
from keras.layers import Dense
from keras.layers import Input, Flatten, Dropout, Activation, BatchNormalization
from keras import losses, models
from keras.activations import softmax
from keras.layers import (Convolution2D, BatchNormalization, Flatten, Dropout, MaxPool2D, A... | [
"transformers.models.wav2vec2.modeling_wav2vec2.Wav2Vec2Model",
"keras.layers.MaxPool2D",
"keras.models.Model",
"keras.layers.Input",
"torch.cuda.amp.autocast",
"torch.nn.MSELoss",
"keras.layers.Flatten",
"transformers.is_apex_available",
"torch.softmax",
"apex.amp.scale_loss",
"tensorflow.keras... | [((875, 894), 'transformers.is_apex_available', 'is_apex_available', ([], {}), '()\n', (892, 894), False, 'from transformers import Trainer, is_apex_available\n'), ((928, 960), 'packaging.version.parse', 'version.parse', (['torch.__version__'], {}), '(torch.__version__)\n', (941, 960), False, 'from packaging import ver... |
import pytest
from django.contrib.auth import get_user_model
from django.db.models import Q
from pontoon.base.utils import aware_datetime
from pontoon.test.factories import (
EntityFactory,
TranslationFactory,
UserFactory,
)
@pytest.mark.django_db
def test_mgr_user_without_translations(translation_a, us... | [
"pontoon.test.factories.UserFactory.create_batch",
"pontoon.test.factories.TranslationFactory.create",
"django.db.models.Q",
"django.contrib.auth.get_user_model",
"pontoon.test.factories.EntityFactory.create_batch",
"pontoon.base.utils.aware_datetime"
] | [((809, 841), 'pontoon.test.factories.UserFactory.create_batch', 'UserFactory.create_batch', ([], {'size': '(5)'}), '(size=5)\n', (833, 841), False, 'from pontoon.test.factories import EntityFactory, TranslationFactory, UserFactory\n'), ((857, 913), 'pontoon.test.factories.EntityFactory.create_batch', 'EntityFactory.cr... |
import tempfile
import os
import base64
import bpy
from bpy_extras.image_utils import load_image
def create_image(op, idx):
image = op.gltf['images'][idx]
name = image.get('name', 'image-%d' % idx)
img = None
if 'uri' in image:
uri = image['uri']
is_data_uri = uri[:5] == 'data:'
... | [
"tempfile.TemporaryDirectory",
"os.path.basename",
"bpy_extras.image_utils.load_image",
"base64.b64decode",
"os.path.join"
] | [((751, 782), 'os.path.join', 'os.path.join', (['op.base_path', 'uri'], {}), '(op.base_path, uri)\n', (763, 782), False, 'import os\n'), ((801, 827), 'bpy_extras.image_utils.load_image', 'load_image', (['image_location'], {}), '(image_location)\n', (811, 827), False, 'from bpy_extras.image_utils import load_image\n'), ... |
from pathlib import Path
from alembic import command # type: ignore
from alembic import script
from alembic.config import Config # type: ignore
from alembic.runtime import migration # type: ignore
from sqlalchemy import create_engine, inspect
from sqlalchemy.orm import Session, sessionmaker
from sqlalchemy.pool imp... | [
"sqlalchemy.inspect",
"alembic.runtime.migration.MigrationContext.configure",
"alembic.command.stamp",
"pathlib.Path",
"sqlalchemy.create_engine",
"sqlalchemy.orm.sessionmaker",
"alembic.script.ScriptDirectory.from_config"
] | [((520, 607), 'sqlalchemy.create_engine', 'create_engine', (['database_uri'], {'echo': '(False)', 'connect_args': "{'check_same_thread': False}"}), "(database_uri, echo=False, connect_args={'check_same_thread': \n False})\n", (533, 607), False, 'from sqlalchemy import create_engine, inspect\n'), ((830, 967), 'sqlalc... |
# *****************************************************************************
# Copyright (c) 2019-2020, Intel Corporation All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
# Redistributions o... | [
"numpy.random.seed",
"sdc.tests.test_series.gen_frand_array",
"numpy.ones",
"numpy.arange",
"unittest.main",
"pandas.DataFrame",
"itertools.product",
"numpy.random.shuffle",
"pandas.testing.assert_frame_equal",
"copy.deepcopy",
"pandas.date_range",
"numpy.median",
"pandas.Series",
"platfor... | [((38654, 38716), 'sdc.tests.test_utils.skip_sdc_jit', 'skip_sdc_jit', (['"""DataFrame.rolling.min() unsupported exceptions"""'], {}), "('DataFrame.rolling.min() unsupported exceptions')\n", (38666, 38716), False, 'from sdc.tests.test_utils import count_array_REPs, count_parfor_REPs, skip_numba_jit, skip_sdc_jit, test_... |
from pricestf import get_price
def prctf_err():
print("Something went wrong with module 'pricestf' while loading current prices!")
input("Press any key to quit!")
quit()
try:
key_current = get_price("Mann Co. Supply Crate Key")
earbuds_current = get_price("Earbuds")
if type(key_current) == ty... | [
"pricestf.get_price"
] | [((207, 245), 'pricestf.get_price', 'get_price', (['"""Mann Co. Supply Crate Key"""'], {}), "('Mann Co. Supply Crate Key')\n", (216, 245), False, 'from pricestf import get_price\n'), ((268, 288), 'pricestf.get_price', 'get_price', (['"""Earbuds"""'], {}), "('Earbuds')\n", (277, 288), False, 'from pricestf import get_pr... |
#!/usr/bin/env python
# -*- coding: utf-8 -*-
import vtk
def main():
colors = vtk.vtkNamedColors()
colors.SetColor("BkgColor", [26, 51, 102, 255])
surface = vtk.vtkParametricKuen()
source = vtk.vtkParametricFunctionSource()
renderer = vtk.vtkRenderer()
mapper = vtk.vtkPolyDataMapper()
... | [
"vtk.vtkMath.Pi",
"vtk.vtkRenderer",
"vtk.vtkRenderWindow",
"vtk.vtkNamedColors",
"vtk.vtkProperty",
"vtk.vtkActor",
"vtk.vtkSliderRepresentation2D",
"vtk.vtkParametricKuen",
"vtk.vtkParametricFunctionSource",
"vtk.vtkRenderWindowInteractor",
"vtk.vtkSliderWidget",
"vtk.vtkPolyDataMapper"
] | [((85, 105), 'vtk.vtkNamedColors', 'vtk.vtkNamedColors', ([], {}), '()\n', (103, 105), False, 'import vtk\n'), ((174, 197), 'vtk.vtkParametricKuen', 'vtk.vtkParametricKuen', ([], {}), '()\n', (195, 197), False, 'import vtk\n'), ((211, 244), 'vtk.vtkParametricFunctionSource', 'vtk.vtkParametricFunctionSource', ([], {}),... |
from collections import Counter
from typing import List
from new.data.report import Report
class OneHotExceptionClass:
"""
One-hot features for most popular exception classes
"""
def __init__(self, top_n: int = None):
self.top_n = top_n
self.top_exceptions = None
def fit(self, re... | [
"collections.Counter"
] | [((505, 524), 'collections.Counter', 'Counter', (['exceptions'], {}), '(exceptions)\n', (512, 524), False, 'from collections import Counter\n')] |
#!/usr/bin/env python
# Copyright 2016-2020 Workiva 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 ... | [
"argparse.ArgumentParser",
"future.standard_library.install_aliases",
"aws_lambda_fsm.aws._get_sqs_queue_url",
"builtins.range",
"aws_lambda_fsm.handler.lambda_timer_handler",
"logging.error",
"aws_lambda_fsm.serialization.json_dumps_additional_kwargs",
"random.seed",
"aws_lambda_fsm.aws.get_arn_fro... | [((753, 787), 'future.standard_library.install_aliases', 'standard_library.install_aliases', ([], {}), '()\n', (785, 787), False, 'from future import standard_library\n'), ((1174, 1237), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Mock AWS Lambda service."""'}), "(description='Mock AW... |
import numpy as np
#Input array
X=np.array([[1,0,1,0],[1,0,1,1],[0,1,0,1]])
#Output
y=np.array([[1],[1],[1]])
#Sigmoid Function
def sigmoid (x):
return 1/(1 + np.exp(-x))
#Derivative of Sigmoid Function
def derivatives_sigmoid(x):
return x * (1 - x)
#Variable initialization
epoch=5... | [
"numpy.random.uniform",
"numpy.sum",
"numpy.array",
"numpy.exp",
"numpy.dot"
] | [((38, 90), 'numpy.array', 'np.array', (['[[1, 0, 1, 0], [1, 0, 1, 1], [0, 1, 0, 1]]'], {}), '([[1, 0, 1, 0], [1, 0, 1, 1], [0, 1, 0, 1]])\n', (46, 90), True, 'import numpy as np\n'), ((94, 119), 'numpy.array', 'np.array', (['[[1], [1], [1]]'], {}), '([[1], [1], [1]])\n', (102, 119), True, 'import numpy as np\n'), ((60... |
# -*- coding: utf-8 -*-
#
# Copyright 2015 Ternaris, Munich, Germany
#
# 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, c... | [
"datetime.datetime.utcnow",
"os.path.join"
] | [((4446, 4491), 'os.path.join', 'os.path.join', (['self.fileset.dirpath', 'self.name'], {}), '(self.fileset.dirpath, self.name)\n', (4458, 4491), False, 'import os\n'), ((3018, 3035), 'datetime.datetime.utcnow', 'datetime.utcnow', ([], {}), '()\n', (3033, 3035), False, 'from datetime import datetime\n')] |
from dateutil.parser import parse
from datetime import datetime, time
from functools import reduce
from tzlocal import get_localzone
DEBUG = True
def debug(s):
if DEBUG:
print(s)
class InputError(Exception):
pass
# Dates are stored in the JSON file as timezone-aware datetimes.
# Timezones are conver... | [
"tzlocal.get_localzone",
"dateutil.parser.parse",
"datetime.datetime.now"
] | [((404, 419), 'dateutil.parser.parse', 'parse', (['date_str'], {}), '(date_str)\n', (409, 419), False, 'from dateutil.parser import parse\n'), ((435, 450), 'tzlocal.get_localzone', 'get_localzone', ([], {}), '()\n', (448, 450), False, 'from tzlocal import get_localzone\n'), ((529, 544), 'tzlocal.get_localzone', 'get_lo... |
"""
Copyright 2021 <NAME>
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed... | [
"pandas.read_csv",
"matplotlib.pyplot.style.use",
"os.path.isfile",
"numpy.mean",
"absl.flags.DEFINE_boolean",
"absl.flags.DEFINE_list",
"matplotlib.pyplot.tight_layout",
"matplotlib.pyplot.setp",
"absl.flags.mark_flag_as_required",
"optcache.essentials.IO.dump_yaml",
"numpy.max",
"matplotlib.... | [((707, 795), 'absl.flags.DEFINE_string', 'flags.DEFINE_string', (['"""data_report"""', 'None', '"""The CSV report that provides the results"""'], {}), "('data_report', None,\n 'The CSV report that provides the results')\n", (726, 795), False, 'from absl import app, flags, logging\n'), ((832, 929), 'absl.flags.DEFIN... |
import warnings
from typing import Tuple
import numpy as np
import torch
from torch import matmul
def regularize_matrix(mat, regularization, relative_to_diag_mean=True):
if regularization > 0:
assert len(set(mat.shape[-2:])) == 1, "matrix must be square"
if relative_to_diag_mean:
diag... | [
"torch.ones_like",
"torch.logsumexp",
"torch.finfo",
"torch.isnan",
"numpy.log",
"torch.log",
"torch.cat",
"torch.cholesky",
"torch.exp",
"numpy.finfo",
"numpy.array",
"torch.tril",
"torch.arange",
"torch.zeros",
"warnings.warn",
"torch.inverse",
"torch.matmul",
"torch.tril_indices... | [((3396, 3415), 'torch.inverse', 'torch.inverse', (['Lmat'], {}), '(Lmat)\n', (3409, 3415), False, 'import torch\n'), ((3739, 3785), 'torch.zeros', 'torch.zeros', (['shape'], {'dtype': 'dtype', 'device': 'device'}), '(shape, dtype=dtype, device=device)\n', (3750, 3785), False, 'import torch\n'), ((4726, 4744), 'torch.l... |
import sys
from setuptools import setup
if sys.version_info[0] < 3:
with open("README.md", encoding="utf-8") as f:
long_description = f.read()
else:
with open("README.md", encoding="utf-8") as f:
long_description = f.read()
setup(
name="cron-validator",
packages=["cron_validator"],
... | [
"setuptools.setup"
] | [((251, 829), 'setuptools.setup', 'setup', ([], {'name': '"""cron-validator"""', 'packages': "['cron_validator']", 'version': '"""1.0.4"""', 'license': '"""MIT"""', 'description': '"""Unix cron implementation by Python"""', 'long_description': 'long_description', 'long_description_content_type': '"""text/markdown"""', ... |
# Copyright 2017 The Sonnet 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 applicable l... | [
"tensorflow.python.util.deprecation.deprecated",
"sonnet.python.modules.util.reuse_variables"
] | [((1102, 1273), 'tensorflow.python.util.deprecation.deprecated', 'deprecation.deprecated', (['"""2017-08-01"""', '"""The @snt.experimental.reuse_vars decorator has been moved to @snt.reuse_variables. Please change to use the new location. """'], {}), "('2017-08-01',\n 'The @snt.experimental.reuse_vars decorator has ... |
import logging
import ee
import pytest
import openet.disalexi.tseb as tseb
import openet.disalexi.utils as utils
@pytest.mark.parametrize(
'T_air,T_rad,u,'
'p,z,Rs_1,Rs24,vza,'
'zs,aleafv,aleafn,aleafl,adeadv,adeadn,adeadl,'
'albedo,ndvi,lai,clump,'
'hc,time,t_rise,'
't_end,leaf_width,a_PT_i... | [
"pytest.mark.parametrize",
"openet.disalexi.utils.constant_image_value",
"ee.Image.constant"
] | [((118, 1462), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""T_air,T_rad,u,p,z,Rs_1,Rs24,vza,zs,aleafv,aleafn,aleafl,adeadv,adeadn,adeadl,albedo,ndvi,lai,clump,hc,time,t_rise,t_end,leaf_width,a_PT_in,iterations,expected"""', '[[296.8625996843974, 302.4907495117188, 7.02662301063538, 97.23062487251867,\n ... |
from datetime import datetime
import itertools
import math
import unittest
from future.builtins import range
import pytest
from clkhash import randomnames as rn
__author__ = 'shardy'
class TestRandomNames(unittest.TestCase):
def test_random_date(self):
start = datetime(1980, 1, 1)
end = dateti... | [
"unittest.main",
"clkhash.randomnames.random_date",
"math.floor",
"datetime.datetime",
"future.builtins.range",
"itertools.combinations",
"pytest.raises",
"clkhash.randomnames.NameList"
] | [((2308, 2323), 'unittest.main', 'unittest.main', ([], {}), '()\n', (2321, 2323), False, 'import unittest\n'), ((279, 299), 'datetime.datetime', 'datetime', (['(1980)', '(1)', '(1)'], {}), '(1980, 1, 1)\n', (287, 299), False, 'from datetime import datetime\n'), ((314, 334), 'datetime.datetime', 'datetime', (['(1990)', ... |
##
from flask import Flask
from flask_restful import Api, Resource
from flask_webpack import Webpack
from flask_cors import CORS
from sqlalchemy.sql.sqltypes import TIMESTAMP
import datetime
from Setting.FrontSetting import FrontSetting
from Setting.ApiSetting import ApiSetting
from flask_pymongo import PyMongo
from... | [
"flask_webpack.Webpack",
"flask_restful.Api",
"flask_cors.CORS",
"Setting.ApiSetting.ApiSetting",
"flask.Flask",
"flask_pymongo.PyMongo",
"Setting.FrontSetting.FrontSetting"
] | [((353, 358), 'flask_restful.Api', 'Api', ([], {}), '()\n', (356, 358), False, 'from flask_restful import Api, Resource\n'), ((369, 378), 'flask_webpack.Webpack', 'Webpack', ([], {}), '()\n', (376, 378), False, 'from flask_webpack import Webpack\n'), ((645, 660), 'flask.Flask', 'Flask', (['__name__'], {}), '(__name__)\... |
# Copyright (C) 2016, zordsdavini
#
# 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, distri... | [
"libqtile.extension.dmenu.Dmenu.__init__"
] | [((1682, 1712), 'libqtile.extension.dmenu.Dmenu.__init__', 'Dmenu.__init__', (['self'], {}), '(self, **config)\n', (1696, 1712), False, 'from libqtile.extension.dmenu import Dmenu\n')] |
import json
import pandas as pd
import numpy as np
from tqdm import tqdm
import os
import time
import subprocess
import sys
from typing import List
import pdb #TODO:REMOVE
def install(package):
subprocess.check_call([sys.executable, "-m", "pip", "install", package])
import spacy
# python3 -m spacy download en_co... | [
"pandas.DataFrame",
"os.mkdir",
"tqdm.tqdm",
"copy.deepcopy",
"numpy.random.seed",
"json.loads",
"spacy.tokens.doc.Doc",
"os.path.exists",
"json.dumps",
"time.sleep",
"spacy.load",
"numpy.cumsum",
"numpy.random.randint",
"numpy.where",
"pdb.set_trace",
"numpy.random.rand",
"pandas.co... | [((200, 272), 'subprocess.check_call', 'subprocess.check_call', (["[sys.executable, '-m', 'pip', 'install', package]"], {}), "([sys.executable, '-m', 'pip', 'install', package])\n", (221, 272), False, 'import subprocess\n'), ((402, 416), 'pandas.DataFrame', 'pd.DataFrame', ([], {}), '()\n', (414, 416), True, 'import pa... |
#
# voter DAO: no commit here
#
import config
from model import Voter,Option,VotingUser,Votation
db = config.db
#import option_dao
import user
import votation_dao
from sqlalchemy import desc
# class voter_dto:
# """DTO class for the database table"""
# def __init__(self):
# self.user_id = None
# ... | [
"sqlalchemy.desc",
"model.Voter",
"votation_dao.load_votation_by_id"
] | [((2609, 2654), 'votation_dao.load_votation_by_id', 'votation_dao.load_votation_by_id', (['votation_id'], {}), '(votation_id)\n', (2641, 2654), False, 'import votation_dao\n'), ((1502, 1558), 'model.Voter', 'Voter', ([], {'votation_id': 'votation_id', 'user_id': 'user_id', 'voted': '(1)'}), '(votation_id=votation_id, u... |
# Generated by Django 2.1.1 on 2018-10-12 00:14
from django.db import migrations, models
import django.db.models.deletion
class Migration(migrations.Migration):
initial = True
dependencies = [
]
operations = [
migrations.CreateModel(
name='Car',
fields=[
... | [
"django.db.models.TextField",
"django.db.models.ForeignKey",
"django.db.models.CharField",
"django.db.models.IntegerField",
"django.db.models.DateField"
] | [((6073, 6182), 'django.db.models.ForeignKey', 'models.ForeignKey', ([], {'blank': '(True)', 'null': '(True)', 'on_delete': 'django.db.models.deletion.CASCADE', 'to': '"""CarApp.Store"""'}), "(blank=True, null=True, on_delete=django.db.models.\n deletion.CASCADE, to='CarApp.Store')\n", (6090, 6182), False, 'from dja... |
from rest_framework import viewsets
from production.models import *
from production.serializers import *
from datetime import date, datetime as dt
TODAY = date.today()
class ProductViewSet(viewsets.ModelViewSet):
queryset = Product.objects.all()
serializer_class = ProductSerializer
| [
"datetime.date.today"
] | [((156, 168), 'datetime.date.today', 'date.today', ([], {}), '()\n', (166, 168), False, 'from datetime import date, datetime as dt\n')] |
from collections import namedtuple
PermissionPair = namedtuple('Permission', ['value', 'label'])
NONE = 0x000000000
# Request Information Permissions
CHANGE_PRIVACY_TITLE = 0x000000001
CHANGE_PRIVACY_AGENCY_REQUEST_SUMMARY = 0x000000002
EDIT_TITLE = 0x000000004
EDIT_AGENCY_REQUEST_SUMMARY = 0x000000008
VIEW_REQUEST... | [
"collections.namedtuple"
] | [((53, 97), 'collections.namedtuple', 'namedtuple', (['"""Permission"""', "['value', 'label']"], {}), "('Permission', ['value', 'label'])\n", (63, 97), False, 'from collections import namedtuple\n')] |
#!/usr/bin/python3
# coding=utf-8
# -------------------------------------------------------------------------------
# This file is part of Phobos, a Blender Add-On to edit robot models.
# Copyright (C) 2020 University of Bremen & DFKI GmbH Robotics Innovation Center
#
# You should have received a copy of the 3-Clause ... | [
"phobos.utils.io.getExpSettings",
"phobos.utils.selection.getRoot",
"bpy.props.FloatProperty",
"phobos.io.libraries.unregister",
"phobos.io.libraries.register",
"phobos.utils.io.getSceneTypesForExport",
"bpy.props.PointerProperty",
"bpy.props.IntProperty",
"inspect.getmembers",
"phobos.utils.valid... | [((1323, 1339), 'bpy.props.StringProperty', 'StringProperty', ([], {}), '()\n', (1337, 1339), False, 'from bpy.props import BoolProperty, IntProperty, StringProperty, EnumProperty, PointerProperty, CollectionProperty, FloatProperty\n'), ((1352, 1368), 'bpy.props.StringProperty', 'StringProperty', ([], {}), '()\n', (136... |
# Copyright (c) 2002, <NAME>, http://eikeon.com/
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are
# met:
#
# * Redistributions of source code must retain the above copyright
# notice, this list of con... | [
"rdflib.graph.ConjunctiveGraph",
"rdflib.term.Literal",
"rdflib.graph.Graph",
"rdflib.term.BNode",
"rdflib.namespace.Namespace",
"rdflib.exceptions.ParserError",
"xml.sax.handler.ErrorHandler",
"xml.sax.make_parser"
] | [((1989, 2040), 'rdflib.namespace.Namespace', 'Namespace', (['"""http://www.w3.org/2004/03/trix/trix-1/"""'], {}), "('http://www.w3.org/2004/03/trix/trix-1/')\n", (1998, 2040), False, 'from rdflib.namespace import Namespace\n'), ((2047, 2096), 'rdflib.namespace.Namespace', 'Namespace', (['"""http://www.w3.org/XML/1998/... |
import datetime
class SystemInfo:
@staticmethod
def __init__():
pass
@staticmethod
def get_time():
now = datetime.datetime.now()
answer = f"São {now.hour} horas e {now.minute} minutos."
return answer
| [
"datetime.datetime.now"
] | [((141, 164), 'datetime.datetime.now', 'datetime.datetime.now', ([], {}), '()\n', (162, 164), False, 'import datetime\n')] |
from datetime import datetime
from product import Product
class Slides(Product):
def __init__(self, raw_product):
Product.__init__(self, raw_product)
bib_info = raw_product.get('slides', {})
self._parse_bib_info(bib_info)
def _parse_bib_info(self, bib_info):
self._repository =... | [
"product.Product.__init__"
] | [((128, 163), 'product.Product.__init__', 'Product.__init__', (['self', 'raw_product'], {}), '(self, raw_product)\n', (144, 163), False, 'from product import Product\n')] |
from django.db import models
from db.base_model import BaseModel
from tinymce.models import HTMLField
# Create your models here.
class GoodsType(BaseModel):
name = models.CharField(max_length=20)
logo = models.CharField(max_length=20)
image = models.ImageField(upload_to='type')
def __str__(self):
... | [
"django.db.models.CharField",
"django.db.models.ForeignKey",
"tinymce.models.HTMLField",
"django.db.models.ImageField",
"django.db.models.DecimalField",
"django.db.models.IntegerField",
"django.db.models.SmallIntegerField"
] | [((170, 201), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(20)'}), '(max_length=20)\n', (186, 201), False, 'from django.db import models\n'), ((213, 244), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(20)'}), '(max_length=20)\n', (229, 244), False, 'from django.db im... |
"""
Common tools for system tests
"""
from __future__ import print_function
import os
from ..utils.common import bloom_answer
from ..utils.common import change_directory
from ..utils.common import user
def create_release_repo(upstream_url, upstream_type, upstream_branch='',
rosdistro='groov... | [
"os.getcwd"
] | [((660, 671), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (669, 671), False, 'import os\n')] |
# Copyright 2019-2021 ETH Zurich and the DaCe authors. All rights reserved.
""" Transformation helper API. """
import copy
import itertools
from networkx import MultiDiGraph
from dace.subsets import Range, Subset, union
import dace.subsets as subsets
from typing import Dict, List, Optional, Tuple, Set, Union
from dac... | [
"dace.memlet.Memlet.from_memlet",
"copy.deepcopy",
"dace.sdfg.scope.ScopeSubgraphView",
"dace.symbolic.pystr_to_symbolic",
"networkx.MultiDiGraph",
"dace.subsets.Range.from_indices",
"dace.memlet.Memlet.from_array",
"dace.memlet.Memlet",
"dace.transformation.dataflow.MapCollapse.apply_to",
"dace.t... | [((3084, 3120), 'dace.sdfg.utils.consolidate_edges', 'utils.consolidate_edges', (['sdfg', 'scope'], {}), '(sdfg, scope)\n', (3107, 3120), False, 'from dace.sdfg import nodes, utils\n'), ((4917, 4954), 'dace.sdfg.SDFG', 'SDFG', (["(name or 'nested_' + state.label)"], {}), "(name or 'nested_' + state.label)\n", (4921, 49... |
"""
parse_configs.py
Implements a method for parsing configuration objects from JSON file.
"""
from __future__ import absolute_import, division, print_function
import argparse
import json
from tensorflow.python.ops.gen_math_ops import log1p_eager_fallback
def parse_configs():
"""Parse configs from JSON file."""... | [
"argparse.Namespace",
"json.load",
"argparse.ArgumentParser"
] | [((334, 423), 'argparse.ArgumentParser', 'argparse.ArgumentParser', (['"""L2HMC algorithm applied to a 2D U(1) lattice gauge model."""'], {}), "(\n 'L2HMC algorithm applied to a 2D U(1) lattice gauge model.')\n", (357, 423), False, 'import argparse\n'), ((1572, 1592), 'argparse.Namespace', 'argparse.Namespace', ([],... |
'''
create a bank account class that has two attributes in Python:
• owner
• balance
and two methods:
• deposit
• withdraw
As an added requirement, withdrawals may not exceed the available balance.
Instantiate your class, make several deposits and withdrawals, and test to make sure the account
can't be overdrawn.
'''
... | [
"os.system"
] | [((1021, 1039), 'os.system', 'os.system', (['"""clear"""'], {}), "('clear')\n", (1030, 1039), False, 'import os\n')] |
#!/usr/bin/env python3
import time
from networktables import NetworkTables
import logging
# To see messages from networktables, you must setup logging
logging.basicConfig(level=logging.DEBUG)
def valueChanged(table, key, value, is_new):
print('{}; key: {}; value: {}; is_new: {}'.format(table, key, value, is_new)... | [
"networktables.NetworkTables.getTable",
"time.sleep",
"logging.basicConfig",
"networktables.NetworkTables.initialize"
] | [((153, 193), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.DEBUG'}), '(level=logging.DEBUG)\n', (172, 193), False, 'import logging\n'), ((323, 367), 'networktables.NetworkTables.initialize', 'NetworkTables.initialize', ([], {'server': '"""localhost"""'}), "(server='localhost')\n", (347, 367), F... |
#!/usr/bin/env python
# coding=utf-8
from setuptools import setup, find_packages
CLASSIFIERS = [
'Development Status :: 4 - Beta',
'Intended Audience :: Developers',
'License :: OSI Approved :: BSD License',
'Programming Language :: Python',
'Operating System :: MacOS :: MacOS X',
'Operating ... | [
"setuptools.find_packages"
] | [((1627, 1683), 'setuptools.find_packages', 'find_packages', ([], {'where': '"""src"""', 'include': "['tempo', 'tempo.*']"}), "(where='src', include=['tempo', 'tempo.*'])\n", (1640, 1683), False, 'from setuptools import setup, find_packages\n')] |
# This code is part of Qiskit.
#
# (C) Copyright IBM 2021.
#
# This code is licensed under the Apache License, Version 2.0. You may
# obtain a copy of this license in the LICENSE.txt file in the root directory
# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0.
#
# Any modifications or derivative wo... | [
"os.path.expanduser",
"os.mkdir",
"qiskit_cold_atom.providers.ColdAtomProvider.stored_account",
"uuid.uuid4",
"os.remove",
"os.path.isdir",
"qiskit_cold_atom.providers.ColdAtomProvider.add_url",
"os.path.exists",
"qiskit_cold_atom.providers.ColdAtomProvider.load_account",
"qiskit_cold_atom.provide... | [((987, 1011), 'os.path.isdir', 'os.path.isdir', (['self.path'], {}), '(self.path)\n', (1000, 1011), False, 'import os\n'), ((1255, 1318), 'os.path.join', 'os.path.join', (['self.path', "('cold_atom_provider_test' + self._uuid)"], {}), "(self.path, 'cold_atom_provider_test' + self._uuid)\n", (1267, 1318), False, 'impor... |
# Copyright 2015 Pants project contributors (see CONTRIBUTORS.md).
# Licensed under the Apache License, Version 2.0 (see LICENSE).
from dataclasses import dataclass
from typing import Any, Dict, Iterator, List, Set, Type
from pants.option.global_options import GlobalOptions
from pants.option.parser_hierarchy import e... | [
"pants.option.parser_hierarchy.enclosing_scope",
"dataclasses.dataclass"
] | [((465, 487), 'dataclasses.dataclass', 'dataclass', ([], {'frozen': '(True)'}), '(frozen=True)\n', (474, 487), False, 'from dataclasses import dataclass\n'), ((1898, 1920), 'pants.option.parser_hierarchy.enclosing_scope', 'enclosing_scope', (['scope'], {}), '(scope)\n', (1913, 1920), False, 'from pants.option.parser_hi... |
# Generated by Django 3.2.7 on 2021-09-07 21:15
from django.conf import settings
from django.db import migrations, models
import django.db.models.deletion
import storages.backends.sftpstorage
class Migration(migrations.Migration):
initial = True
dependencies = [
migrations.swappable_dependency(sett... | [
"django.db.migrations.swappable_dependency",
"django.db.models.BigAutoField",
"django.db.models.CharField",
"django.db.models.ForeignKey",
"django.db.models.EmailField",
"django.db.models.DateField"
] | [((284, 341), 'django.db.migrations.swappable_dependency', 'migrations.swappable_dependency', (['settings.AUTH_USER_MODEL'], {}), '(settings.AUTH_USER_MODEL)\n', (315, 341), False, 'from django.db import migrations, models\n'), ((473, 569), 'django.db.models.BigAutoField', 'models.BigAutoField', ([], {'auto_created': '... |
# -*- coding: utf-8 -*-
# Form implementation generated from reading ui file 'Spatial_tab.ui'
#
# Created by: PyQt5 UI code generator 5.6
#
# WARNING! All changes made in this file will be lost!
from PyQt5 import QtCore, QtGui, QtWidgets
class Ui_spatial_tab(object):
def setupUi(self, spatial_tab):
spat... | [
"PyQt5.QtWidgets.QLabel",
"PyQt5.QtWidgets.QSizePolicy",
"PyQt5.QtWidgets.QWidget",
"PyQt5.QtCore.QRect",
"PyQt5.QtWidgets.QHBoxLayout",
"PyQt5.QtWidgets.QPushButton",
"PyQt5.QtCore.QSize",
"PyQt5.QtGui.QFont",
"PyQt5.QtWidgets.QSpacerItem",
"PyQt5.QtWidgets.QScrollArea",
"PyQt5.QtWidgets.QVBoxL... | [((427, 461), 'PyQt5.QtWidgets.QVBoxLayout', 'QtWidgets.QVBoxLayout', (['spatial_tab'], {}), '(spatial_tab)\n', (448, 461), False, 'from PyQt5 import QtCore, QtGui, QtWidgets\n'), ((653, 683), 'PyQt5.QtWidgets.QWidget', 'QtWidgets.QWidget', (['spatial_tab'], {}), '(spatial_tab)\n', (670, 683), False, 'from PyQt5 import... |
import argparse
import json
import os
import re
import time
import openai
from tqdm import tqdm
def parse_good_bad(data):
text = data['text']
if 'bad question:' not in text.lower():
return '', ''
good_question, bad_question = re.split('bad question:', text, flags=re.IGNORECASE)
good_question =... | [
"tqdm.tqdm",
"re.split",
"argparse.ArgumentParser",
"os.path.exists",
"json.dumps",
"time.sleep",
"os.getenv",
"openai.Completion.create"
] | [((248, 300), 're.split', 're.split', (['"""bad question:"""', 'text'], {'flags': 're.IGNORECASE'}), "('bad question:', text, flags=re.IGNORECASE)\n", (256, 300), False, 'import re\n'), ((582, 635), 're.split', 're.split', (['"""good question:"""', 'text'], {'flags': 're.IGNORECASE'}), "('good question:', text, flags=r... |
# -*- coding: utf-8 -*- #
# 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 requir... | [
"googlecloudsdk.command_lib.compute.interconnects.flags.AddRequestedLinkCountForUpdate",
"googlecloudsdk.command_lib.compute.interconnects.flags.AddNocContactEmail",
"googlecloudsdk.calliope.base.ReleaseTracks",
"googlecloudsdk.api_lib.compute.interconnects.client.Interconnect",
"googlecloudsdk.command_lib.... | [((1596, 1636), 'googlecloudsdk.calliope.base.ReleaseTracks', 'base.ReleaseTracks', (['base.ReleaseTrack.GA'], {}), '(base.ReleaseTrack.GA)\n', (1614, 1636), False, 'from googlecloudsdk.calliope import base\n'), ((3162, 3229), 'googlecloudsdk.calliope.base.ReleaseTracks', 'base.ReleaseTracks', (['base.ReleaseTrack.ALPH... |
# Generated by Django 2.0.2 on 2018-08-12 09:55
import datetime
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('main', '0030_auto_20180811_1620'),
]
operations = [
migrations.CreateModel(
name='currentData',
fiel... | [
"django.db.models.FileField",
"django.db.models.CharField",
"django.db.migrations.DeleteModel",
"datetime.datetime",
"django.db.models.AutoField"
] | [((851, 894), 'django.db.migrations.DeleteModel', 'migrations.DeleteModel', ([], {'name': '"""Crop_Seasons"""'}), "(name='Crop_Seasons')\n", (873, 894), False, 'from django.db import migrations, models\n'), ((348, 441), 'django.db.models.AutoField', 'models.AutoField', ([], {'auto_created': '(True)', 'primary_key': '(T... |
import asyncio
from datetime import datetime, timedelta
import discord
from datasources.queries import *
import inspect
import datasources.models as models
import datasources.queries as queries
from mappings import BOT, GUILD, COMMANDS, MUSIC_PREFIX, MUSIC_COMMANDS
from datasources import session, engine
from random i... | [
"colour.Color",
"discord.utils.get",
"discord.Client",
"random.randint",
"asyncio.sleep",
"discord.Embed",
"datasources.session.close",
"discord.Object",
"discord.Game",
"datetime.timedelta",
"inspect.isawaitable",
"discord.PermissionOverwrite",
"datasources.session.commit",
"datetime.date... | [((501, 517), 'discord.Client', 'discord.Client', ([], {}), '()\n', (515, 517), False, 'import discord\n'), ((391, 433), 'datasources.engine.dialect.has_table', 'engine.dialect.has_table', (['engine', '"""member"""'], {}), "(engine, 'member')\n", (415, 433), False, 'from datasources import session, engine\n'), ((11706,... |
from typing import Set, Dict, Any
import random
from . import RandomPolicy
from src.mdp import MarkovDecisionProcedure
class QTablePolicy:
def __init__(self, initial_value_estimate: float = 0.0):
self._q_table: Dict[Any, Dict[Any, float]] = dict()
self.initial_value_estimate: float = initial_val... | [
"random.choice"
] | [((976, 1014), 'random.choice', 'random.choice', (['current_optimal_actions'], {}), '(current_optimal_actions)\n', (989, 1014), False, 'import random\n')] |
"""This modules includes unit tests for helpers."""
from pytest_reportportal.helpers import get_attributes
def test_get__attributes():
"""Test get_attributes functionality."""
expected_out = [{'value': 'Tag'}, {'key': 'Key', 'value': 'Value'}]
out = get_attributes(['Tag', 'Key:Value', ''])
assert exp... | [
"pytest_reportportal.helpers.get_attributes"
] | [((265, 305), 'pytest_reportportal.helpers.get_attributes', 'get_attributes', (["['Tag', 'Key:Value', '']"], {}), "(['Tag', 'Key:Value', ''])\n", (279, 305), False, 'from pytest_reportportal.helpers import get_attributes\n')] |
#!/usr/bin/env python3
import re
from boardfarm.lib.network_testing import tshark_read
def duration_between_packets(
device, capture_file, msg_list, user=None, count=10, **kwargs
):
"""Calculate the time duration between two packets until count
:param device: lan or wan
:type device: object
:par... | [
"re.search",
"boardfarm.lib.network_testing.tshark_read"
] | [((946, 1019), 'boardfarm.lib.network_testing.tshark_read', 'tshark_read', (['device', 'capture_file'], {'filter_str': 'filter_opt', 'rm_file': 'rm_file'}), '(device, capture_file, filter_str=filter_opt, rm_file=rm_file)\n', (957, 1019), False, 'from boardfarm.lib.network_testing import tshark_read\n'), ((2157, 2277), ... |
import os
for file in os.listdir('.'):
if file.endswith('.html'):
with open(file, 'r') as f:
content = f.read()
with open(file, 'w') as f:
for private in ['_images', '_static', '_sources']:
content = content.replace(private, private.replace('_', ''))
... | [
"os.listdir"
] | [((23, 38), 'os.listdir', 'os.listdir', (['"""."""'], {}), "('.')\n", (33, 38), False, 'import os\n')] |
# -*- coding: utf-8 -*-
from src.strategies_execution.executions import print_execution_name
from src.strategies_execution.executions import execute_strategy
from src.strategies_execution.executions import optimize_strategy
from src.strategies.moving_average_rsi.strategy_moving_average_rsi import MovingAverageRsiStrate... | [
"src.strategies_execution.executions.print_execution_name",
"src.strategies_execution.executions.execute_strategy"
] | [((848, 891), 'src.strategies_execution.executions.print_execution_name', 'print_execution_name', (['"""Estrategia: clásica"""'], {}), "('Estrategia: clásica')\n", (868, 891), False, 'from src.strategies_execution.executions import print_execution_name\n'), ((1196, 1252), 'src.strategies_execution.executions.execute_st... |
import os
import RPi.GPIO as GPIO
import time
# from gpio import LED
GPIO.setmode(GPIO.BCM)
GPIO.setwarnings(False)
# led = 21
# GPIO.setup(led, GPIO.OUT)
def sensor():
for i in os.listdir('/sys/bus/w1/devices'):
if i != 'w1_bus_master1':
ds18b20 = i
return ds18b20
def read(ds18b20):
lo... | [
"os.listdir",
"RPi.GPIO.setmode",
"RPi.GPIO.setwarnings"
] | [((69, 91), 'RPi.GPIO.setmode', 'GPIO.setmode', (['GPIO.BCM'], {}), '(GPIO.BCM)\n', (81, 91), True, 'import RPi.GPIO as GPIO\n'), ((92, 115), 'RPi.GPIO.setwarnings', 'GPIO.setwarnings', (['(False)'], {}), '(False)\n', (108, 115), True, 'import RPi.GPIO as GPIO\n'), ((183, 216), 'os.listdir', 'os.listdir', (['"""/sys/bu... |
import pytest, numpy
import tequila as tq
import multiprocessing as mp
from tequila.simulators.simulator_api import simulate
from tequila.optimizers.optimizer_gd import minimize
@pytest.mark.parametrize("simulator", [tq.simulators.simulator_api.pick_backend("random")])
@pytest.mark.parametrize('method', numpy.random.... | [
"tequila.optimizers.optimizer_gd.minimize",
"tequila.paulis.Z",
"tequila.optimizers.optimizer_gd.OptimizerGD.available_methods",
"tequila.gates.Ry",
"tequila.gates.Rz",
"tequila.paulis.X",
"tequila.simulators.simulator_api.pick_backend",
"tequila.gates.CNOT",
"numpy.isclose",
"tequila.gates.X",
... | [((391, 598), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""options"""', "[None, '2-point', {'method': '2-point', 'stepsize': 0.0001}, {'method':\n '2-point-forward', 'stepsize': 0.0001}, {'method': '2-point-backward',\n 'stepsize': 0.0001}]"], {}), "('options', [None, '2-point', {'method': '2-point... |
# -*- coding: utf-8 -*-
"""
Created on Wed Jun 13 17:00:00 2018
@author: giurt
"""
# -*- coding: utf-8 -*-
"""
Created on Thu May 24 14:25:27 2018
@author: giurt
"""
import os
import csv
from PyQt5 import uic, QtCore
from PyQt5 import QtWidgets
from PyQt5.QtCore import QSettings, QTranslator, qVersion, QCoreApplica... | [
"PyQt5.QtWidgets.QMessageBox.about",
"csv.reader",
"os.makedirs",
"csv.writer",
"os.path.dirname",
"os.path.join",
"os.listdir"
] | [((562, 587), 'os.path.dirname', 'os.path.dirname', (['__file__'], {}), '(__file__)\n', (577, 587), False, 'import os\n'), ((2908, 3009), 'os.path.join', 'os.path.join', (['master_mapping_config.CURRENT_MAPPING_DIRECTORY', 'master_mapping_config.INPUT_FOLDER'], {}), '(master_mapping_config.CURRENT_MAPPING_DIRECTORY,\n ... |
import TL.ApplicationLayer as AL
import socket
import time
import os
input_filename = r"CS3543_100MB"
# Creates UDP socket objects.
send_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
receive_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# Defining the desired port to connect to on the server.... | [
"os.path.getsize",
"socket.socket",
"TL.ApplicationLayer.TCPML",
"time.time"
] | [((148, 196), 'socket.socket', 'socket.socket', (['socket.AF_INET', 'socket.SOCK_DGRAM'], {}), '(socket.AF_INET, socket.SOCK_DGRAM)\n', (161, 196), False, 'import socket\n'), ((214, 262), 'socket.socket', 'socket.socket', (['socket.AF_INET', 'socket.SOCK_DGRAM'], {}), '(socket.AF_INET, socket.SOCK_DGRAM)\n', (227, 262)... |
"""
Test file for REQ-REP communication pattern.
"""
import time
from osbrain import run_agent
from osbrain import run_logger
from osbrain.helper import logger_received
from osbrain.helper import sync_agent_logger
from common import nsproxy # noqa: F401
def test_return(nsproxy):
"""
REQ-REP pattern using a... | [
"osbrain.helper.logger_received",
"osbrain.run_agent",
"osbrain.helper.sync_agent_logger",
"time.sleep",
"time.time",
"osbrain.run_logger"
] | [((429, 444), 'osbrain.run_agent', 'run_agent', (['"""a0"""'], {}), "('a0')\n", (438, 444), False, 'from osbrain import run_agent\n'), ((454, 469), 'osbrain.run_agent', 'run_agent', (['"""a1"""'], {}), "('a1')\n", (463, 469), False, 'from osbrain import run_agent\n'), ((743, 758), 'osbrain.run_agent', 'run_agent', (['"... |
# encoding: utf-8
from utils import audio
from hparams import hparams
import numpy as np
from griffin_lim import inv_spectrogram, tf
import os
if __name__ == '__main__':
data_foler = "data"
wavs = [os.path.join(data_foler, file[:-4]) for file in os.listdir(data_foler) if file.endswith(".wav")]
outputs_py =... | [
"utils.audio.load_wav",
"utils.audio.save_wav",
"griffin_lim.tf.Session",
"utils.audio.inv_spectrogram",
"griffin_lim.inv_spectrogram",
"utils.audio.spectrogram",
"os.path.join",
"os.listdir"
] | [((207, 242), 'os.path.join', 'os.path.join', (['data_foler', 'file[:-4]'], {}), '(data_foler, file[:-4])\n', (219, 242), False, 'import os\n'), ((430, 484), 'utils.audio.load_wav', 'audio.load_wav', (["(wav_path + '.wav')", 'hparams.sample_rate'], {}), "(wav_path + '.wav', hparams.sample_rate)\n", (444, 484), False, '... |
import discord # type: ignore
class embedHandler:
''' Create an embed with an uniform format
'''
def __init__(self,elementList,embedType,color):
''' elementList : A list of all the elements that will figure in the embed description
embedType : For now it's useless since there is only on... | [
"discord.Color"
] | [((593, 618), 'discord.Color', 'discord.Color', (['self.color'], {}), '(self.color)\n', (606, 618), False, 'import discord\n')] |
#!/usr/bin/env python
"""
DMLC submission script, MPI version
"""
import argparse
import sys
import os
import subprocess
import tracker
from threading import Thread
parser = argparse.ArgumentParser(description='DMLC script to submit dmlc job using MPI')
parser.add_argument('-n', '--nworker', required=True, type=int,
... | [
"threading.Thread",
"argparse.ArgumentParser",
"os.system",
"tracker.config_logger",
"subprocess.check_call"
] | [((175, 254), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""DMLC script to submit dmlc job using MPI"""'}), "(description='DMLC script to submit dmlc job using MPI')\n", (198, 254), False, 'import argparse\n'), ((2858, 2885), 'tracker.config_logger', 'tracker.config_logger', (['args'], ... |
import numpy as np
import scipy as sp
from sklearn.utils.multiclass import type_of_target
def balanced_accuracy(solution, prediction):
"""balanced accuracy implementation of auto-sklearn"""
y_type = type_of_target(solution)
if y_type not in ["binary", "multiclass", 'multilabel-indicator']:
rais... | [
"numpy.multiply",
"numpy.max",
"sklearn.utils.multiclass.type_of_target",
"numpy.mean",
"numpy.min",
"scipy.maximum"
] | [((211, 235), 'sklearn.utils.multiclass.type_of_target', 'type_of_target', (['solution'], {}), '(solution)\n', (225, 235), False, 'from sklearn.utils.multiclass import type_of_target\n'), ((1812, 1831), 'scipy.maximum', 'sp.maximum', (['eps', 'tp'], {}), '(eps, tp)\n', (1822, 1831), True, 'import scipy as sp\n'), ((184... |
import math
valores_x=[
0.0000,
0.2500,
0.5000,
0.7500,
1.0000,
1.2500,
1.5000,
1.7500,
2.0000,
2.2500,
2.5000,
2.7500,
3.0000,
3.2500,
3.5000,
3.7500,
4.0000,
4.2500,
4.5000,
4.7500,
5.0000]
valores_y=[
0.0718,
0.7662,
0.11... | [
"math.cos",
"math.sin"
] | [((664, 690), 'math.cos', 'math.cos', (['(a * valores_x[i])'], {}), '(a * valores_x[i])\n', (672, 690), False, 'import math\n'), ((689, 715), 'math.sin', 'math.sin', (['(b * valores_x[i])'], {}), '(b * valores_x[i])\n', (697, 715), False, 'import math\n')] |
import pytest
from datetime import datetime
from src.inspetor.model.inspetor_category import InspetorCategory
from src.inspetor.exception.model_exception.inspetor_category_exception import InspetorCategoryException
class TestInspetorCategory:
def get_default_category(self):
category = InspetorCategory()
... | [
"src.inspetor.model.inspetor_category.InspetorCategory"
] | [((301, 319), 'src.inspetor.model.inspetor_category.InspetorCategory', 'InspetorCategory', ([], {}), '()\n', (317, 319), False, 'from src.inspetor.model.inspetor_category import InspetorCategory\n')] |
from setuptools import setup
setup(name="replication_ar2018", version="0.0.1")
| [
"setuptools.setup"
] | [((30, 79), 'setuptools.setup', 'setup', ([], {'name': '"""replication_ar2018"""', 'version': '"""0.0.1"""'}), "(name='replication_ar2018', version='0.0.1')\n", (35, 79), False, 'from setuptools import setup\n')] |
from unittest.mock import Mock
from blitsh.commands.exec import ExecCommand
def test_format_args():
cmd = ExecCommand()
assert cmd.parse_args(':exec', 'ls', '-lah') == {'shell_cmd': 'ls -lah'}
def test_send_payload():
client = Mock()
cmd = ExecCommand()
assert cmd.execute(client, shell_cmd='h... | [
"unittest.mock.Mock",
"blitsh.commands.exec.ExecCommand"
] | [((113, 126), 'blitsh.commands.exec.ExecCommand', 'ExecCommand', ([], {}), '()\n', (124, 126), False, 'from blitsh.commands.exec import ExecCommand\n'), ((245, 251), 'unittest.mock.Mock', 'Mock', ([], {}), '()\n', (249, 251), False, 'from unittest.mock import Mock\n'), ((262, 275), 'blitsh.commands.exec.ExecCommand', '... |
"""
board_util.py
Utility functions for Go board.
"""
import numpy as np
from random import shuffle
"""
Encoding of colors on and off a Go board.
FLODDFILL is used internally for a temporary marker
"""
EMPTY = 0
BLACK = 1
WHITE = 2
BORDER = 3
def is_black_white(color):
return color == BLACK or color == WHITE
"""... | [
"random.shuffle",
"numpy.where",
"numpy.zeros",
"numpy.random.shuffle"
] | [((884, 903), 'numpy.where', 'np.where', (['condition'], {}), '(condition)\n', (892, 903), True, 'import numpy as np\n'), ((2992, 3012), 'random.shuffle', 'shuffle', (['legal_moves'], {}), '(legal_moves)\n', (2999, 3012), False, 'from random import shuffle\n'), ((3295, 3319), 'numpy.random.shuffle', 'np.random.shuffle'... |
import sys
from os.path import abspath, dirname, join
"""
Prepend the parent directory to the python path so that the local copy
of the code is used instead of whatever happens to be in the user's
PYTHONPATH. Hopefully prevents development code from accidentally getting
imported in a production run.
"""
sy... | [
"os.path.abspath"
] | [((359, 376), 'os.path.abspath', 'abspath', (['__file__'], {}), '(__file__)\n', (366, 376), False, 'from os.path import abspath, dirname, join\n')] |
"""
Plotting functionality based on VTK.
"""
# Author: <NAME> <<EMAIL>>
# License: BSD 3 clause
import os
import warnings
from collections import defaultdict
import numpy as np
from numpy.lib.stride_tricks import as_strided
from vtk import vtkCommand
import vtk.qt as vtk_qt
from brainspace import OFF_SCREEN
from ... | [
"numpy.empty",
"numpy.ones",
"collections.defaultdict",
"PyQt5.QtWidgets.QVBoxLayout",
"numpy.arange",
"numpy.tile",
"PyQt5.QtWidgets.QApplication",
"PyQt5.QtWidgets.QApplication.instance",
"numpy.unique",
"IPython.external.qt_for_kernel.QtGui.QApplication.instance",
"IPython.get_ipython",
"nu... | [((967, 986), 'panel.extension', 'pn.extension', (['"""vtk"""'], {}), "('vtk')\n", (979, 986), True, 'import panel as pn\n'), ((4368, 4388), 'numpy.tile', 'np.tile', (['x_min', 'nrow'], {}), '(x_min, nrow)\n', (4375, 4388), True, 'import numpy as np\n'), ((4401, 4421), 'numpy.tile', 'np.tile', (['x_max', 'nrow'], {}), ... |
import random
def moja(x):
a = 0
b = 1
while a < x:
b,a = a + b,b
print(a)
return x
#moja(100)
def moja2():
lista = []
lista.append(1)
lista.append(5)
lista.append(6)
lista.append(1)
print(lista)
print(lista.count(1))
return
#moja2()
ileliczb = int(in... | [
"random.randint"
] | [((445, 474), 'random.randint', 'random.randint', (['(1)', 'maksliczba'], {}), '(1, maksliczba)\n', (459, 474), False, 'import random\n')] |
import numpy
def sort_phonebook():
# 10M / 32 supports 0 - 9999999 (or ph:999-9999)
bv_size = 321500
int_size = 32
bit_vector = numpy.zeros(bv_size, dtype=numpy.uint32)
for idx in xrange(bv_size):
bit_vector[idx] = 0
# reading from file
with open('unsorted_phonebook.txt',... | [
"numpy.uint32",
"numpy.zeros"
] | [((150, 190), 'numpy.zeros', 'numpy.zeros', (['bv_size'], {'dtype': 'numpy.uint32'}), '(bv_size, dtype=numpy.uint32)\n', (161, 190), False, 'import numpy\n'), ((489, 504), 'numpy.uint32', 'numpy.uint32', (['(1)'], {}), '(1)\n', (501, 504), False, 'import numpy\n'), ((695, 710), 'numpy.uint32', 'numpy.uint32', (['(1)'],... |
import os.path as op
import numpy as np
from joblib import Parallel, delayed
import mne
import config as cfg
from library import preprocessing as pp
def _compute_cov(file_raw):
subject = pp.get_subject(file_raw)
raw = mne.io.read_raw_fif(file_raw)
rawc, reject = pp.clean_raw(raw, subject)
events = ... | [
"mne.io.read_raw_fif",
"mne.make_fixed_length_events",
"mne.pick_types",
"library.preprocessing.get_subject",
"library.preprocessing.clean_raw",
"mne.externals.h5io.write_hdf5",
"mne.Epochs",
"mne.compute_covariance",
"numpy.array",
"joblib.Parallel",
"joblib.delayed",
"os.path.join",
"mne.u... | [((1691, 1740), 'os.path.join', 'op.join', (['cfg.derivative_path', '"""covs_allch_oas.h5"""'], {}), "(cfg.derivative_path, 'covs_allch_oas.h5')\n", (1698, 1740), True, 'import os.path as op\n'), ((1741, 1803), 'mne.externals.h5io.write_hdf5', 'mne.externals.h5io.write_hdf5', (['fname_covs', 'out'], {'overwrite': '(Tru... |
import math
import torch
import torch.nn as nn
import torch.nn.functional as F
from ..builder_models import PyTorchBuilderLayer
from ..layer_registry import register_layer
import mrbuilder.utils as mrbu
@register_layer("Conv2d")
class Conv2dBuilderLayer(PyTorchBuilderLayer):
def __init__(self, config=None, connec... | [
"torch.nn.Dropout",
"torch.nn.AdaptiveAvgPool2d",
"torch.flatten",
"torch.nn.ReLU",
"mrbuilder.utils.repeat_if_single",
"math.ceil",
"torch.nn.Conv2d",
"math.floor",
"torch.cat",
"torch.roll",
"torch.nn.functional.pad",
"torch.nn.BatchNorm2d",
"torch.nn.Softmax",
"torch.nn.Linear",
"torc... | [((859, 888), 'mrbuilder.utils.repeat_if_single', 'mrbu.repeat_if_single', (['kernel'], {}), '(kernel)\n', (880, 888), True, 'import mrbuilder.utils as mrbu\n'), ((912, 942), 'mrbuilder.utils.repeat_if_single', 'mrbu.repeat_if_single', (['strides'], {}), '(strides)\n', (933, 942), True, 'import mrbuilder.utils as mrbu\... |
# Generated by Django 2.0.5 on 2018-06-13 20:52
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('dmjb', '0003_job_slug'),
]
operations = [
migrations.AddField(
model_name='job',
name='company_name',
fi... | [
"django.db.models.CharField",
"django.db.models.EmailField"
] | [((324, 368), 'django.db.models.CharField', 'models.CharField', ([], {'default': '""""""', 'max_length': '(128)'}), "(default='', max_length=128)\n", (340, 368), False, 'from django.db import migrations, models\n'), ((492, 537), 'django.db.models.EmailField', 'models.EmailField', ([], {'default': '""""""', 'max_length'... |
import re
module_file = open("chacractl/__init__.py").read()
metadata = dict(re.findall("__([a-z]+)__\s*=\s*'([^']+)'", module_file))
long_description = open('README.rst').read()
from setuptools import setup, find_packages
setup(
name = 'chacractl',
description = 'client tool for a chacra service',
packa... | [
"re.findall",
"setuptools.find_packages"
] | [((78, 135), 're.findall', 're.findall', (['"""__([a-z]+)__\\\\s*=\\\\s*\'([^\']+)\'"""', 'module_file'], {}), '("__([a-z]+)__\\\\s*=\\\\s*\'([^\']+)\'", module_file)\n', (88, 135), False, 'import re\n'), ((326, 341), 'setuptools.find_packages', 'find_packages', ([], {}), '()\n', (339, 341), False, 'from setuptools imp... |
from .eval import Eval
from pyramid import threadlocal
def getSession():
return threadlocal.get_current_request().dbsession | [
"pyramid.threadlocal.get_current_request"
] | [((85, 118), 'pyramid.threadlocal.get_current_request', 'threadlocal.get_current_request', ([], {}), '()\n', (116, 118), False, 'from pyramid import threadlocal\n')] |
import os
import sys
from unittest.mock import MagicMock, patch
from openslides.utils import main
from openslides.utils.test import TestCase
class TestFunctions(TestCase):
@patch("openslides.utils.main.sys")
def test_detect_openslides_type_unix(self, mock_sys):
"""
Tests the return value on a... | [
"openslides.utils.main.get_default_user_data_dir",
"openslides.utils.main.start_browser",
"os.path.abspath",
"unittest.mock.MagicMock",
"openslides.utils.main.get_default_settings_dir",
"openslides.utils.main.detect_openslides_type",
"unittest.mock.patch",
"openslides.utils.main.get_local_settings_dir... | [((180, 214), 'unittest.mock.patch', 'patch', (['"""openslides.utils.main.sys"""'], {}), "('openslides.utils.main.sys')\n", (185, 214), False, 'from unittest.mock import MagicMock, patch\n'), ((463, 510), 'unittest.mock.patch', 'patch', (['"""openslides.utils.main.os.path.basename"""'], {}), "('openslides.utils.main.os... |
import sublime, sublime_plugin
import sys
if sys.version_info >= (3, 0):
from .diffy_lib import diffier
else:
from diffy_lib import diffier
class DiffyCommand(sublime_plugin.TextCommand):
def get_entire_content(self, view):
selection = sublime.Region(0, view.size())
content = view.substr(s... | [
"diffy_lib.diffier.Diffy"
] | [((944, 959), 'diffy_lib.diffier.Diffy', 'diffier.Diffy', ([], {}), '()\n', (957, 959), False, 'from diffy_lib import diffier\n')] |
# -*- coding: utf-8 -*-
# Generated by Django 1.10.1 on 2016-09-06 12:41
from __future__ import unicode_literals
from django.db import migrations, models
import django_prices.models
class Migration(migrations.Migration):
dependencies = [
('order', '0012_auto_20160216_1032'),
]
operations = [
... | [
"django.db.models.CharField"
] | [((434, 680), 'django.db.models.CharField', 'models.CharField', ([], {'choices': "[('new', 'Processing'), ('cancelled', 'Cancelled'), ('shipped', 'Shipped'),\n ('payment-pending', 'Payment pending'), ('fully-paid', 'Fully paid')]", 'default': '"""new"""', 'max_length': '(32)', 'verbose_name': '"""delivery status"""'... |
import copy
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
from matplotlib.colors import ListedColormap, LogNorm
from src.parameters import COLORS, USE_LIKELIHOODS
HUE_ORDER = {
'replay_motion_type': ['Away', 'Neither', 'Towards'],
'replay_type': ['Inbound-Forward... | [
"src.parameters.USE_LIKELIHOODS.keys",
"seaborn.heatmap",
"numpy.argmax",
"matplotlib.pyplot.suptitle",
"numpy.argsort",
"numpy.histogram",
"matplotlib.colors.LogNorm",
"numpy.arange",
"matplotlib.pyplot.gca",
"matplotlib.pyplot.FormatStrFormatter",
"numpy.tril_indices_from",
"numpy.linspace",... | [((2435, 2453), 'matplotlib.pyplot.subplots', 'plt.subplots', (['(1)', '(1)'], {}), '(1, 1)\n', (2447, 2453), True, 'import matplotlib.pyplot as plt\n'), ((3598, 3697), 'seaborn.heatmap', 'sns.heatmap', (['jaccard_similarity'], {'annot': '(True)', 'annot_kws': "{'size': 16}", 'vmin': '(0.0)', 'vmax': '(1.0)', 'ax': 'ax... |
import asyncio
import discord
import os
import sys
from async_timeout import timeout
from database.model import ActiveMembers, MemberSounds
from datetime import datetime
from discord.ext import commands
from pathlib import Path, PurePath
from random import choice
from rapidfuzz import process
from sqlalchemy.dialects.p... | [
"utilities.format.alphanumerical",
"pathlib.Path",
"utilities.member.get_member_by_id",
"discord.ext.commands.command",
"discord.ext.commands.has_any_role",
"async_timeout.timeout",
"datetime.datetime.now",
"asyncio.sleep",
"os.rename",
"database.model.MemberSounds.create",
"database.model.Activ... | [((4786, 4804), 'discord.ext.commands.command', 'commands.command', ([], {}), '()\n', (4802, 4804), False, 'from discord.ext import commands\n'), ((4810, 4867), 'discord.ext.commands.has_any_role', 'commands.has_any_role', (['"""Administrator"""', '"""Moderator"""', '"""OG"""'], {}), "('Administrator', 'Moderator', 'OG... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.