code stringlengths 22 1.05M | apis listlengths 1 3.31k | extract_api stringlengths 75 3.25M |
|---|---|---|
# -*- coding: utf-8 -*-
"""
LemonSoap - headers scent.
Deals with column headers.
"""
import pandas as pd
import inflection
import re
import logging
from ..lemon_bar import LemonBar
from .scent_template import ScentTemplate
class ColumnsScent(ScentTemplate):
"""
Manages headers issue identification and fixi... | [
"re.sub",
"inflection.underscore"
] | [((2078, 2106), 'inflection.underscore', 'inflection.underscore', (['fixed'], {}), '(fixed)\n', (2099, 2106), False, 'import inflection\n'), ((2123, 2148), 're.sub', 're.sub', (['"""\\\\W+"""', '""""""', 'fixed'], {}), "('\\\\W+', '', fixed)\n", (2129, 2148), False, 'import re\n')] |
# Generated by Django 3.2.3 on 2021-10-19 18:54
from django.conf import settings
from django.db import migrations, models
class Migration(migrations.Migration):
dependencies = [
('user', '0001_initial'),
]
operations = [
migrations.AddField(
model_name='userprofile',
... | [
"django.db.models.ManyToManyField"
] | [((361, 463), 'django.db.models.ManyToManyField', 'models.ManyToManyField', ([], {'related_name': '"""_user_userprofile_relations_+"""', 'to': 'settings.AUTH_USER_MODEL'}), "(related_name='_user_userprofile_relations_+', to=\n settings.AUTH_USER_MODEL)\n", (383, 463), False, 'from django.db import migrations, models... |
#python -m marbles test_semantic_columns.py
import unittest
from marbles.mixins import mixins
import pandas as pd
import requests
from pyspark.sql import SparkSession
import psycopg2 as pg
import pandas as pd
import marbles
from pyspark.sql.types import StructType, StructField, StringType
import psycopg2 as pg
#from s... | [
"psycopg2.connect",
"pandas.read_sql_query",
"pyspark.sql.functions.col",
"pyspark.sql.SparkSession.builder.config",
"pyspark.sql.types.StringType"
] | [((5059, 5083), 'psycopg2.connect', 'pg.connect', (['config_psyco'], {}), '(config_psyco)\n', (5069, 5083), True, 'import psycopg2 as pg\n'), ((5094, 5164), 'pandas.read_sql_query', 'pd.read_sql_query', (['"""select * from clean.rita limit 1;"""'], {'con': 'connection'}), "('select * from clean.rita limit 1;', con=conn... |
import math
class polygon:
def __init__(self, arr):
self.original_arr = arr
self.size = len(self.original_arr)
self.__set_min_max_by_original__()
self.__refactor_original_seq__()
self.sorted_arr.append(self.sorted_arr[0])
self.size += 1
def __set_min_max_by_ori... | [
"math.ceil",
"math.sqrt"
] | [((4603, 4734), 'math.sqrt', 'math.sqrt', (['((self.sorted_arr[i][0] - self.sorted_arr[i + 1][0]) ** 2 + (self.\n sorted_arr[i][1] - self.sorted_arr[i + 1][1]) ** 2)'], {}), '((self.sorted_arr[i][0] - self.sorted_arr[i + 1][0]) ** 2 + (self.\n sorted_arr[i][1] - self.sorted_arr[i + 1][1]) ** 2)\n', (4612, 4734), ... |
# coding: utf-8
# In[20]:
import numpy as np
import pydensecrf.densecrf as dcrf
import os
import cv2
import random
from tqdm import tqdm
# In[21]:
from skimage.color import gray2rgb
from skimage.color import rgb2gray
import matplotlib.pyplot as plt
from sklearn.metrics import f1_score, accuracy_score
from pyden... | [
"numpy.ascontiguousarray",
"numpy.array",
"pydensecrf.utils.unary_from_softmax",
"matplotlib.pyplot.imshow",
"pydensecrf.densecrf.DenseCRF2D",
"os.path.exists",
"os.listdir",
"numpy.mean",
"matplotlib.pyplot.close",
"numpy.exp",
"os.mkdir",
"matplotlib.pyplot.axis",
"numpy.maximum",
"numpy... | [((1290, 1309), 'numpy.zeros', 'np.zeros', (['(h, w, 2)'], {}), '((h, w, 2))\n', (1298, 1309), True, 'import numpy as np\n'), ((2223, 2239), 'numpy.zeros', 'np.zeros', (['(h, w)'], {}), '((h, w))\n', (2231, 2239), True, 'import numpy as np\n'), ((2253, 2272), 'numpy.zeros', 'np.zeros', (['(h, w, 2)'], {}), '((h, w, 2))... |
import random
from django.core.management.base import BaseCommand
from django.contrib.admin.utils import flatten
from django_seed import Seed
from lists import models as list_models
from users import models as user_models
from rooms import models as room_models
NAME = "lists"
class Command(BaseCommand):
help =... | [
"users.models.User.objects.all",
"rooms.models.Room.objects.all",
"lists.models.List.objects.create",
"random.randint"
] | [((409, 439), 'users.models.User.objects.all', 'user_models.User.objects.all', ([], {}), '()\n', (437, 439), True, 'from users import models as user_models\n'), ((456, 486), 'rooms.models.Room.objects.all', 'room_models.Room.objects.all', ([], {}), '()\n', (484, 486), True, 'from rooms import models as room_models\n'),... |
# -*- coding: utf-8 -*-
from __future__ import unicode_literals
from django.db import models, migrations
class Migration(migrations.Migration):
dependencies = [
('classroom', '0002_assignment_description'),
]
operations = [
migrations.AddField(
model_name='assignment',
... | [
"django.db.models.DateTimeField",
"django.db.models.BooleanField"
] | [((369, 448), 'django.db.models.DateTimeField', 'models.DateTimeField', ([], {'null': '(True)', 'verbose_name': '"""Fecha de evaluación"""', 'blank': '(True)'}), "(null=True, verbose_name='Fecha de evaluación', blank=True)\n", (389, 448), False, 'from django.db import models, migrations\n'), ((616, 768), 'django.db.mod... |
import numpy as np
import matplotlib.pyplot as plt
import os
from pyburst.grids import grid_analyser, grid_strings, grid_tools
# resolution tests
y_factors = {'dt': 3600,
'fluence': 1e39,
'peak': 1e38,
}
y_labels = {'dt': '$\Delta t$',
'rate': 'Burst rate',
... | [
"matplotlib.pyplot.savefig",
"pyburst.grids.grid_tools.enumerate_params",
"numpy.where",
"os.path.join",
"matplotlib.pyplot.close",
"pyburst.grids.grid_strings.plots_path",
"matplotlib.pyplot.tight_layout",
"pyburst.grids.grid_analyser.Kgrid",
"numpy.full",
"matplotlib.pyplot.subplots",
"matplot... | [((1303, 1345), 'pyburst.grids.grid_tools.enumerate_params', 'grid_tools.enumerate_params', (['unique_subset'], {}), '(unique_subset)\n', (1330, 1345), False, 'from pyburst.grids import grid_analyser, grid_strings, grid_tools\n'), ((2387, 2436), 'matplotlib.pyplot.subplots', 'plt.subplots', (['n', '(2)'], {'sharex': '(... |
# Copyright (c) 2020-present, Assistive Robotics Lab
# All rights reserved.
#
# This source code is licensed under the license found in the
# LICENSE file in the root directory of this source tree.
#
from transformers.training_utils import fit
from transformers.transformers import (
InferenceTransformerEncoder,
... | [
"torch.manual_seed",
"torch.optim.lr_scheduler.MultiStepLR",
"argparse.ArgumentParser",
"common.logging.logger.info",
"torch.nn.L1Loss",
"torch.cuda.device_count",
"transformers.training_utils.fit",
"torch.nn.DataParallel",
"torch.cuda.is_available",
"common.losses.QuatDistance",
"numpy.random.s... | [((541, 562), 'torch.manual_seed', 'torch.manual_seed', (['(42)'], {}), '(42)\n', (558, 562), False, 'import torch\n'), ((563, 581), 'numpy.random.seed', 'np.random.seed', (['(42)'], {}), '(42)\n', (577, 581), True, 'import numpy as np\n'), ((833, 858), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '(... |
from typing import Tuple
import torch
import torch.nn as nn
from pyro.distributions.util import broadcast_shape
from pyro_util.modules.weight_scaling import GammaReLU, WSLinear
T = torch.Tensor
def make_ws_fc(*dims: int) -> nn.Module:
"""Helper function for creating a fully connected neural network.
This v... | [
"torch.nn.ReLU",
"pyro_util.modules.weight_scaling.WSLinear",
"torch.nn.Sequential",
"torch.nn.BatchNorm1d",
"pyro_util.modules.weight_scaling.GammaReLU",
"pyro.distributions.util.broadcast_shape",
"torch.nn.Linear"
] | [((704, 726), 'torch.nn.Sequential', 'nn.Sequential', (['*layers'], {}), '(*layers)\n', (717, 726), True, 'import torch.nn as nn\n'), ((1263, 1285), 'torch.nn.Sequential', 'nn.Sequential', (['*layers'], {}), '(*layers)\n', (1276, 1285), True, 'import torch.nn as nn\n'), ((527, 553), 'pyro_util.modules.weight_scaling.WS... |
#!/usr/bin/env python
'''
catalog_harvesting/util.py
General utilities for the project
'''
import random
def unique_id():
'''
Return a random 17-character string that works well for mongo IDs
'''
charmap = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789"
return ''.join([random.cho... | [
"random.choice"
] | [((310, 332), 'random.choice', 'random.choice', (['charmap'], {}), '(charmap)\n', (323, 332), False, 'import random\n')] |
from WeatherScreens.RingScreen import RingScreen
from WeatherScreens.QuadrantScreen import QuadrantScreen
from WeatherScreens.ImageScreen import ImageScreen
from WeatherScreens.ScreenBase import ScreenBase
from datetime import datetime, timedelta
from suntime import Sun, SunTimeException
from dateutil import tz
import ... | [
"WeatherScreens.ScreenBase.ScreenBase",
"argparse.ArgumentParser",
"datetime.datetime.strptime",
"pyowm.OWM",
"WeatherScreens.ImageScreen.ImageScreen",
"datetime.datetime.now",
"WeatherScreens.QuadrantScreen.QuadrantScreen",
"datetime.timedelta",
"WeatherScreens.RingScreen.RingScreen"
] | [((385, 448), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""WeatherFrame CLI Utility"""'}), "(description='WeatherFrame CLI Utility')\n", (408, 448), False, 'import argparse\n'), ((9014, 9028), 'datetime.datetime.now', 'datetime.now', ([], {}), '()\n', (9026, 9028), False, 'from datetim... |
from django.conf.urls import url, include
from django.conf import settings
from . import views
# Wire up our API using automatic URL routing.
# Additionally, we include login URLs for the browsable API.
urlpatterns = [
url(r'manage/', views.index),
]
| [
"django.conf.urls.url"
] | [((222, 249), 'django.conf.urls.url', 'url', (['"""manage/"""', 'views.index'], {}), "('manage/', views.index)\n", (225, 249), False, 'from django.conf.urls import url, include\n')] |
# This code is generated automatically by ClointFusion BOT Builder Tool.
import ClointFusion as cf
import time
cf.window_show_desktop()
cf.mouse_click(int(cf.pg.size()[0]/2),int(cf.pg.size()[1]/2))
try:
cf.mouse_click(*cf.mouse_search_snip_return_coordinates_x_y(r'C:\Users\mrmay\AppData\Local\Temp\cf_log_5fa2... | [
"ClointFusion.key_write_enter",
"ClointFusion.window_show_desktop",
"ClointFusion.key_press",
"time.sleep",
"ClointFusion.mouse_search_snip_return_coordinates_x_y",
"ClointFusion.pg.size",
"ClointFusion.mouse_click"
] | [((114, 138), 'ClointFusion.window_show_desktop', 'cf.window_show_desktop', ([], {}), '()\n', (136, 138), True, 'import ClointFusion as cf\n'), ((530, 543), 'time.sleep', 'time.sleep', (['(2)'], {}), '(2)\n', (540, 543), False, 'import time\n'), ((869, 882), 'time.sleep', 'time.sleep', (['(0)'], {}), '(0)\n', (879, 882... |
#!/usr/bin/env nemesis
"""
This script creates a spatial database for the initial stress and state
variables for a Maxwell plane strain material.
"""
sim = "gravity_vardensity"
materials = ["crust","mantle"]
import numpy
import h5py
from spatialdata.spatialdb.SimpleIOAscii import SimpleIOAscii
from spatialdata.geoco... | [
"spatialdata.spatialdb.SimpleIOAscii.SimpleIOAscii",
"h5py.File",
"numpy.array",
"numpy.zeros",
"spatialdata.geocoords.CSCart.CSCart"
] | [((351, 359), 'spatialdata.geocoords.CSCart.CSCart', 'CSCart', ([], {}), '()\n', (357, 359), False, 'from spatialdata.geocoords.CSCart import CSCart\n'), ((659, 903), 'numpy.array', 'numpy.array', (['[[0.62200847, 0.16666667, 0.0446582, 0.16666667], [0.16666667, 0.62200847, \n 0.16666667, 0.0446582], [0.16666667, 0.... |
import datetime
import typing
from . import enums, tools
class CatalogueAPIWrapper:
"""Methods for listing objects"""
def __init__(
self, username: str, password: str, language: enums.Language = enums.Language.GERMAN
):
"""Create a new Wrapper containing functions for listing different o... | [
"datetime.date.today",
"datetime.timedelta"
] | [((15395, 15416), 'datetime.date.today', 'datetime.date.today', ([], {}), '()\n', (15414, 15416), False, 'import datetime\n'), ((15419, 15446), 'datetime.timedelta', 'datetime.timedelta', ([], {'days': '(-7)'}), '(days=-7)\n', (15437, 15446), False, 'import datetime\n'), ((17879, 17900), 'datetime.date.today', 'datetim... |
# coding: utf-8
"""加密算法：公钥(私钥)加密，私钥解密"""
from Crypto.PublicKey import RSA
from Crypto import Random
DATA = 'Hello, word!'
PRIVATE_KEY_PEM = """-----<KEY>"""
PUBLIC_KEY_PEM = """-----<KEY>"""
def _encrypt_by_public():
random_func = Random.new().read
public_key = RSA.importKey(PUBLIC_KEY_PEM)
encrypted =... | [
"Crypto.Random.new",
"Crypto.PublicKey.RSA.importKey"
] | [((275, 304), 'Crypto.PublicKey.RSA.importKey', 'RSA.importKey', (['PUBLIC_KEY_PEM'], {}), '(PUBLIC_KEY_PEM)\n', (288, 304), False, 'from Crypto.PublicKey import RSA\n'), ((463, 493), 'Crypto.PublicKey.RSA.importKey', 'RSA.importKey', (['PRIVATE_KEY_PEM'], {}), '(PRIVATE_KEY_PEM)\n', (476, 493), False, 'from Crypto.Pub... |
from django.contrib.auth import get_user_model
from rest_framework import mixins
from rest_framework.viewsets import GenericViewSet
from users.serializers import UserSerializer
class UserViewSet(mixins.RetrieveModelMixin, mixins.ListModelMixin, GenericViewSet):
queryset = get_user_model().objects.all()
seria... | [
"django.contrib.auth.get_user_model"
] | [((280, 296), 'django.contrib.auth.get_user_model', 'get_user_model', ([], {}), '()\n', (294, 296), False, 'from django.contrib.auth import get_user_model\n')] |
import numpy
import chainer
from chainer.backends import cuda
from chainer.functions.activation import sigmoid
from chainer.functions.activation import tanh
from chainer.functions.array import concat
from chainer.functions.math import linear_interpolate
from chainer import link
from chainer.links.connection import lin... | [
"chainer.functions.array.concat.concat",
"chainer.Variable",
"chainer.links.connection.linear.Linear",
"chainer.get_device",
"chainer.functions.math.linear_interpolate.linear_interpolate",
"chainer.get_dtype"
] | [((773, 823), 'chainer.functions.math.linear_interpolate.linear_interpolate', 'linear_interpolate.linear_interpolate', (['f', 'h_bar', 'h'], {}), '(f, h_bar, h)\n', (810, 823), False, 'from chainer.functions.math import linear_interpolate\n'), ((1305, 1331), 'chainer.get_device', 'chainer.get_device', (['device'], {}),... |
from django.contrib.auth import get_user_model
from django.urls import reverse
from django.test import TestCase
from rest_framework import status
from rest_framework.test import APIClient
from core.models import Member, Band
from rockband.serializers import MemberSerializer
MEMBERS_URL = reverse('rockband:member-l... | [
"django.contrib.auth.get_user_model",
"django.urls.reverse",
"core.models.Member.objects.all",
"rest_framework.test.APIClient",
"core.models.Member.objects.filter",
"core.models.Band.objects.create",
"core.models.Member.objects.create",
"rockband.serializers.MemberSerializer"
] | [((294, 325), 'django.urls.reverse', 'reverse', (['"""rockband:member-list"""'], {}), "('rockband:member-list')\n", (301, 325), False, 'from django.urls import reverse\n'), ((475, 486), 'rest_framework.test.APIClient', 'APIClient', ([], {}), '()\n', (484, 486), False, 'from rest_framework.test import APIClient\n'), ((8... |
from slave.playground.bots import BotInformation
from slave.lib.bots import BotBasic, BotV2
config = {
'host': 'chat.freenode.net',
'port': 6667,
'channel': "#slavebotpool666",
'boss_name': 'boss666',
'bot_prefix': "SLAVEBOT"
}
BotInformation.read_config_from_dict(config)
BotInformation.use_other... | [
"slave.playground.bots.BotInformation.start",
"slave.playground.bots.BotInformation.read_config_from_dict",
"slave.playground.bots.BotInformation.use_other_bot_commands"
] | [((249, 293), 'slave.playground.bots.BotInformation.read_config_from_dict', 'BotInformation.read_config_from_dict', (['config'], {}), '(config)\n', (285, 293), False, 'from slave.playground.bots import BotInformation\n'), ((296, 340), 'slave.playground.bots.BotInformation.use_other_bot_commands', 'BotInformation.use_ot... |
##############################################################################
# Copyright (c) 2017 <NAME> <<EMAIL>>, Red Hat
#
# All rights reserved. This program and the accompanying materials
# are made available under the terms of the Apache License, Version 2.0
# which accompanies this distribution, and is availab... | [
"hashlib.sha256",
"argparse.ArgumentParser",
"os.path.join",
"binaryornot.check.is_binary",
"os.walk"
] | [((670, 686), 'hashlib.sha256', 'hashlib.sha256', ([], {}), '()\n', (684, 686), False, 'import hashlib\n'), ((696, 721), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {}), '()\n', (719, 721), False, 'import argparse\n'), ((960, 981), 'os.walk', 'os.walk', (['args.project'], {}), '(args.project)\n', (967, 9... |
import inspect
from collections import namedtuple
import numpy as np
from sklearn.ensemble import GradientBoostingRegressor
from sklearn.model_selection import train_test_split
from sklearn.exceptions import NotFittedError
from uq360.algorithms.posthocuq import PostHocUQ
class MetamodelRegression(PostHocUQ):
"""... | [
"numpy.abs",
"collections.namedtuple",
"numpy.hstack",
"sklearn.model_selection.train_test_split",
"numpy.asarray",
"numpy.expand_dims",
"inspect.isclass",
"sklearn.ensemble.GradientBoostingRegressor"
] | [((6132, 6145), 'numpy.asarray', 'np.asarray', (['X'], {}), '(X)\n', (6142, 6145), True, 'import numpy as np\n'), ((6158, 6171), 'numpy.asarray', 'np.asarray', (['y'], {}), '(y)\n', (6168, 6171), True, 'import numpy as np\n'), ((7884, 7916), 'numpy.hstack', 'np.hstack', (['[X, y_hat_meta_prime]'], {}), '([X, y_hat_meta... |
import logging
import subprocess
from threading import Thread
from ulauncher.api.client.Extension import Extension
from ulauncher.api.shared.event import KeywordQueryEvent, ItemEnterEvent, \
PreferencesEvent, PreferencesUpdateEvent
from ulauncher.api.shared.action.ExtensionCustomAction import \
ExtensionCustomA... | [
"logging.getLogger",
"ulauncher.api.shared.item.ExtensionResultItem.ExtensionResultItem",
"dendron.query_listener.KeywordQueryEventListener",
"subprocess.run",
"ulauncher.api.shared.action.RenderResultListAction.RenderResultListAction",
"ulauncher.api.shared.action.ExtensionCustomAction.ExtensionCustomAct... | [((713, 740), 'logging.getLogger', 'logging.getLogger', (['__name__'], {}), '(__name__)\n', (730, 740), False, 'import logging\n'), ((1323, 1361), 'threading.Thread', 'Thread', ([], {'target': 'self.dendron.load_notes'}), '(target=self.dendron.load_notes)\n', (1329, 1361), False, 'from threading import Thread\n'), ((23... |
# pylint: disable=redefined-outer-name
# pylint: disable=too-many-lines
import itertools
import pytest
from buzzard.test.tools import assert_tiles_eq
from buzzard.test import make_tile_set
ANY = 42
PARAMS1 = {
'extend',
'overlap',
'exclude',
'exception',
'shrink',
}
PARAMS2 = {'br', 'tr', 'tl',... | [
"itertools.product",
"pytest.mark.parametrize",
"pytest.raises",
"pytest.fixture",
"buzzard.test.tools.assert_tiles_eq",
"buzzard.test.make_tile_set.make_tile_set"
] | [((1320, 1350), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""module"""'}), "(scope='module')\n", (1334, 1350), False, 'import pytest\n'), ((2402, 2432), 'pytest.fixture', 'pytest.fixture', ([], {'params': 'PARAMS2'}), '(params=PARAMS2)\n', (2416, 2432), False, 'import pytest\n'), ((2497, 2527), 'pytest.fixtur... |
import unittest
from collections import defaultdict
import numpy as np
import pandas as pd
from ife.io.io import ImageReader
class TestMomentFeatures(unittest.TestCase):
def test_moment_output_type(self) -> None:
features = ImageReader.read_from_single_file("ife/data/small_rgb.jpg")
moment = fe... | [
"ife.io.io.ImageReader.read_from_single_file",
"numpy.zeros"
] | [((240, 299), 'ife.io.io.ImageReader.read_from_single_file', 'ImageReader.read_from_single_file', (['"""ife/data/small_rgb.jpg"""'], {}), "('ife/data/small_rgb.jpg')\n", (273, 299), False, 'from ife.io.io import ImageReader\n'), ((945, 1004), 'ife.io.io.ImageReader.read_from_single_file', 'ImageReader.read_from_single_... |
import numpy as np
from math import pi
import torch
from pykeops.torch import LazyTensor
from plyfile import PlyData, PlyElement
from helper import *
import torch.nn as nn
import torch.nn.functional as F
# from matplotlib import pyplot as plt
from pykeops.torch.cluster import grid_cluster, cluster_ranges_centroids, fr... | [
"torch.nn.ReLU",
"numpy.sqrt",
"torch.max",
"math.sqrt",
"torch.sum",
"torch.nn.GroupNorm",
"pyvtk.PointData",
"pyvtk.VtkData",
"pyvtk.CellData",
"torch.zeros_like",
"torch.nn.init.uniform_",
"pykeops.torch.LazyTensor",
"torch.randn",
"torch.ones_like",
"torch.nn.LeakyReLU",
"torch.Ten... | [((2722, 2736), 'pyvtk.VtkData', 'VtkData', (['*data'], {}), '(*data)\n', (2729, 2736), False, 'from pyvtk import PolyData, PointData, CellData, Scalars, Vectors, VtkData, PointData\n'), ((5780, 5805), 'pykeops.torch.LazyTensor', 'LazyTensor', (['x[:, None, :]'], {}), '(x[:, None, :])\n', (5790, 5805), False, 'from pyk... |
from random import randint, seed
import numpy as np
from os import path, mkdir
from maze_utils import generate_grid
seed_number = 69
training_folder = "training"
testing_folder = "testing"
tot_elem_training = 100 # numero di matrici da generare
tot_elem_testing = 20 # numero di matrici da generare
max_w = 10 ... | [
"os.path.exists",
"maze_utils.generate_grid",
"random.seed",
"os.mkdir",
"numpy.random.seed",
"numpy.savetxt",
"random.randint"
] | [((707, 734), 'numpy.random.seed', 'np.random.seed', (['seed_number'], {}), '(seed_number)\n', (721, 734), True, 'import numpy as np\n'), ((739, 756), 'random.seed', 'seed', (['seed_number'], {}), '(seed_number)\n', (743, 756), False, 'from random import randint, seed\n'), ((1101, 1128), 'os.path.exists', 'path.exists'... |
"""create tables
Revision ID: 6fb351569d30
Revises: 4<PASSWORD>1ff38b
Create Date: 2019-05-06 21:59:43.998735
"""
from alembic import op
import sqlalchemy as sa
# revision identifiers, used by Alembic.
revision = '<KEY>'
down_revision = '4<PASSWORD>'
branch_labels = None
depends_on = None
def upgrade():
# ###... | [
"sqlalchemy.ForeignKeyConstraint",
"sqlalchemy.DateTime",
"alembic.op.drop_table",
"sqlalchemy.Boolean",
"sqlalchemy.PrimaryKeyConstraint",
"sqlalchemy.Date",
"sqlalchemy.Integer",
"sqlalchemy.Numeric",
"sqlalchemy.String",
"sqlalchemy.Enum"
] | [((13130, 13179), 'alembic.op.drop_table', 'op.drop_table', (['"""transaction_check"""'], {'schema': '"""glod"""'}), "('transaction_check', schema='glod')\n", (13143, 13179), False, 'from alembic import op\n'), ((13184, 13227), 'alembic.op.drop_table', 'op.drop_table', (['"""transaction"""'], {'schema': '"""glod"""'}),... |
"""Hparams"""
import argparse as ap
import tensorflow as tf
from pathlib import Path
HOME = str(Path.home())
HPARAM_CHOICES= {
"model": ["cpdb", "copy", "bdrnn", "cpdb2", "cpdb2_prot"],
"optimizer": ["adam", "sgd", "adadelta"],
"unit_type": ["lstm", "lstmblock", "nlstm", "gru"],
"train... | [
"pathlib.Path.home",
"tensorflow.contrib.training.HParams",
"argparse.ArgumentParser"
] | [((97, 108), 'pathlib.Path.home', 'Path.home', ([], {}), '()\n', (106, 108), False, 'from pathlib import Path\n'), ((1415, 1513), 'argparse.ArgumentParser', 'ap.ArgumentParser', ([], {'description': '"""Hyperparameters"""', 'add_help': '(False)', 'argument_default': 'ap.SUPPRESS'}), "(description='Hyperparameters', add... |
from kivy.lang import Builder
from kivy.metrics import dp
from kivy import properties as p
from kivy.animation import Animation
from kivymd.app import MDApp as App
from kivymd.uix.screen import MDScreen
class HomeMainScreen(MDScreen):
bg_pos = p.NumericProperty(0)
def toggle_bg_pos(self):
bg_pos... | [
"kivy.animation.Animation",
"kivy.metrics.dp",
"kivy.properties.NumericProperty"
] | [((251, 271), 'kivy.properties.NumericProperty', 'p.NumericProperty', (['(0)'], {}), '(0)\n', (268, 271), True, 'from kivy import properties as p\n'), ((349, 368), 'kivy.metrics.dp', 'dp', (['(self.height / 2)'], {}), '(self.height / 2)\n', (351, 368), False, 'from kivy.metrics import dp\n'), ((375, 399), 'kivy.animati... |
# def draw_nx(g, labels=None):
# import matplotlib.pyplot as plt
# if labels is not None:
# g = nx.relabel_nodes(g, labels)
# pos = nx.kamada_kawai_layout(g)
# nx.draw(g, pos, with_labels=True)
# plt.show()
#
# def draw_nx_attributes_as_labels(g, attribute):
# # import pylab
# impo... | [
"torch.tensor",
"networkx.draw",
"torch_geometric.data.Data",
"torch_geometric.utils.convert.to_networkx"
] | [((2444, 2504), 'torch.tensor', 'torch.tensor', (['[[0, 1, 1, 2], [1, 0, 2, 1]]'], {'dtype': 'torch.long'}), '([[0, 1, 1, 2], [1, 0, 2, 1]], dtype=torch.long)\n', (2456, 2504), False, 'import torch\n'), ((2589, 2625), 'torch.tensor', 'torch.tensor', (['[[0.0], [-1.0], [1.0]]'], {}), '([[0.0], [-1.0], [1.0]])\n', (2601,... |
# Copyright 2016 Open Source Robotics Foundation, Inc.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law... | [
"rclpy.ok",
"ros_mstar.srv.MStarSrv.Request",
"rclpy.spin_once",
"rclpy.init",
"rclpy.shutdown"
] | [((1467, 1488), 'rclpy.init', 'rclpy.init', ([], {'args': 'args'}), '(args=args)\n', (1477, 1488), False, 'import rclpy\n'), ((1914, 1924), 'rclpy.ok', 'rclpy.ok', ([], {}), '()\n', (1922, 1924), False, 'import rclpy\n'), ((2546, 2562), 'rclpy.shutdown', 'rclpy.shutdown', ([], {}), '()\n', (2560, 2562), False, 'import ... |
import atexit
import contextlib
import time
from typing import Any, List, Type
from unittest import mock
import pytest
import region_profiler.global_instance
import region_profiler.profiler
from region_profiler import RegionProfiler, func
from region_profiler import install as install_profiler
from region_profiler imp... | [
"region_profiler.reporters.SilentReporter",
"unittest.mock.Mock",
"region_profiler.install",
"region_profiler.func",
"time.sleep",
"pytest.mark.parametrize",
"region_profiler.region",
"region_profiler.iter_proxy"
] | [((1040, 1091), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""multiple_runs"""', '[0, 1, 2]'], {}), "('multiple_runs', [0, 1, 2])\n", (1063, 1091), False, 'import pytest\n'), ((1589, 1635), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""use_cython"""', '[False]'], {}), "('use_cython', [False]... |
#!/usr/bin/env python
import datetime
import logging
import time
from threading import Thread
import requests
from requests.auth import HTTPBasicAuth
import settings
def update_notiwire(data=None, relative_url=''):
URL = settings.API_URL + settings.NAME + '/'
if not data:
data = {}
data['api_key... | [
"logging.basicConfig",
"requests.post",
"requests.auth.HTTPBasicAuth",
"time.sleep",
"requests.get",
"datetime.datetime.now",
"time.time",
"threading.Thread",
"logging.info",
"logging.error"
] | [((463, 507), 'requests.post', 'requests.post', (['(URL + relative_url)'], {'data': 'data'}), '(URL + relative_url, data=data)\n', (476, 507), False, 'import requests\n'), ((4057, 4127), 'logging.basicConfig', 'logging.basicConfig', ([], {'format': '"""%(asctime)s %(message)s"""', 'level': 'log_level'}), "(format='%(as... |
from django.conf import settings
from django.conf.urls import url
from django.conf.urls.static import static
from . import views
urlpatterns=[
url('^$',views.index,name = 'index'),
url(r'^profile/(\d+)',views.profile,name = "profile"),
url(r'^create/post',views.new_post, name = "new-post"),
url(r'^foll... | [
"django.conf.urls.static.static",
"django.conf.urls.url"
] | [((148, 184), 'django.conf.urls.url', 'url', (['"""^$"""', 'views.index'], {'name': '"""index"""'}), "('^$', views.index, name='index')\n", (151, 184), False, 'from django.conf.urls import url\n'), ((190, 243), 'django.conf.urls.url', 'url', (['"""^profile/(\\\\d+)"""', 'views.profile'], {'name': '"""profile"""'}), "('... |
from unittest.mock import MagicMock
from unittest.mock import patch
import aiofiles
from aiofiles import threadpool
async def test_unit_get_current_version_both_files_dont_exist(mock_hub, hub, tmp_path):
"""
SCENARIO #1
- override_version_file DOES NOT EXIST
- main_version_file DOES NOT EXIST
"""... | [
"aiofiles.threadpool.wrap.register",
"unittest.mock.MagicMock",
"aiofiles.threadpool.AsyncBufferedIOBase",
"unittest.mock.patch"
] | [((622, 663), 'unittest.mock.patch', 'patch', (['"""os.getcwd"""'], {'return_value': 'tmp_path'}), "('os.getcwd', return_value=tmp_path)\n", (627, 663), False, 'from unittest.mock import patch\n'), ((1657, 1698), 'unittest.mock.patch', 'patch', (['"""os.getcwd"""'], {'return_value': 'tmp_path'}), "('os.getcwd', return_... |
import setuptools
setuptools.setup(
name="fakeokpy",
version='0.1',
url="https://github.com/yuvipanda/fakeokpy",
author="<NAME>",
author_email="<EMAIL>",
license="BSD-3-Clause",
packages=setuptools.find_packages(),
)
| [
"setuptools.find_packages"
] | [((216, 242), 'setuptools.find_packages', 'setuptools.find_packages', ([], {}), '()\n', (240, 242), False, 'import setuptools\n')] |
# coding: utf-8
# $ \newcommand{\cat}[2][\phantom{i}]{\ket{C^{#2}_{#1\alpha}}} $
# $ \newcommand{\ket}[1]{|#1\rangle} $
# $ \newcommand{\bra}[1]{\langle#1|} $
# $ \newcommand{\braket}[2]{\langle#1|#2\rangle} $
# $\newcommand{\au}{\hat{a}^\dagger}$
# $\newcommand{\ad}{\hat{a}}$
# $\newcommand{\bu}{\hat{b}^\dagger}$
# ... | [
"numpy.sqrt"
] | [((2879, 2890), 'numpy.sqrt', 'sqrt', (['(Δ * χ)'], {}), '(Δ * χ)\n', (2883, 2890), False, 'from numpy import sqrt\n')] |
def coding_problem_41(flights_db, starting_airport):
"""
Given an unordered list of flights taken by someone, each represented as (origin, destination) pairs, and a
starting airport, compute the person's itinerary. If no such itinerary exists, return null. If there are multiple
possible itineraries, ret... | [
"doctest.testmod"
] | [((935, 964), 'doctest.testmod', 'doctest.testmod', ([], {'verbose': '(True)'}), '(verbose=True)\n', (950, 964), False, 'import doctest\n')] |
import itertools
import pytest
from iterators.invalid_iter import InvalidIter
def _grouper_to_keys(grouper):
return [g[0] for g in grouper]
def _grouper_to_groups(grouper):
return [list(g[1]) for g in grouper]
@pytest.mark.parametrize("keyfunc, data, expected_keys", [
(lambda x: x, [], []),
(lambd... | [
"pytest.mark.parametrize",
"iterators.invalid_iter.InvalidIter",
"pytest.raises",
"itertools.groupby"
] | [((225, 504), 'pytest.mark.parametrize', 'pytest.mark.parametrize', (['"""keyfunc, data, expected_keys"""', "[(lambda x: x, [], []), (lambda x: x, [1, 2, 3], [1, 2, 3]), (lambda x: x,\n [1, 2, 2, 2, 3, 3], [1, 2, 3]), (lambda x: x, '', []), (lambda x: x,\n 'ABC', ['A', 'B', 'C']), (lambda x: x, 'ABBBCC', ['A', 'B... |
import serialio
class Serial(object):
def __init__(self, port, baudrate, timeout):
self.port = port
self.baudrate = baudrate
self.timeout = timeout
self._openPort()
def _openPort(self):
self.hComm = serialio.Serial(self.port, self.baudrate) # Opening the port
def read(self):
data = seria... | [
"serialio.read",
"serialio.Serial"
] | [((223, 264), 'serialio.Serial', 'serialio.Serial', (['self.port', 'self.baudrate'], {}), '(self.port, self.baudrate)\n', (238, 264), False, 'import serialio\n'), ((315, 340), 'serialio.read', 'serialio.read', (['self.hComm'], {}), '(self.hComm)\n', (328, 340), False, 'import serialio\n')] |
import numpy as np
class NumpyDynamic:
def __init__(self, dtype, array_size=(100,)):
self.data = np.zeros(array_size, dtype)
self.array_size = list(array_size)
self.size = 0
def add(self, x):
if self.size == self.array_size[0]:
self.array_size[0] *= 2
... | [
"numpy.zeros"
] | [((112, 139), 'numpy.zeros', 'np.zeros', (['array_size', 'dtype'], {}), '(array_size, dtype)\n', (120, 139), True, 'import numpy as np\n'), ((330, 372), 'numpy.zeros', 'np.zeros', (['self.array_size', 'self.data.dtype'], {}), '(self.array_size, self.data.dtype)\n', (338, 372), True, 'import numpy as np\n')] |
from rest_framework import serializers
from api.models import RouteModel
class RouteDistanceSerializer(serializers.ModelSerializer):
km = serializers.FloatField(source='distance', read_only=True)
class Meta:
model = RouteModel
fields = ('route_id', 'km')
| [
"rest_framework.serializers.FloatField"
] | [((144, 201), 'rest_framework.serializers.FloatField', 'serializers.FloatField', ([], {'source': '"""distance"""', 'read_only': '(True)'}), "(source='distance', read_only=True)\n", (166, 201), False, 'from rest_framework import serializers\n')] |
import numpy as np
from abc import ABCMeta, abstractmethod
class Node(object):
"""Represents state in MCTS search tree.
Args:
state (object): The environment state corresponding to this node in the search tree.
Note:
Node object is immutable. Node is left without exit edges (empty dict)... | [
"numpy.sqrt"
] | [((2113, 2134), 'numpy.sqrt', 'np.sqrt', (['state_visits'], {}), '(state_visits)\n', (2120, 2134), True, 'import numpy as np\n')] |
import os
import random
from sklearn.metrics import mean_squared_error as mse
from core.composer.chain import Chain
from core.composer.composer import ComposerRequirements, DummyChainTypeEnum, DummyComposer
from core.models.data import OutputData
from core.models.model import *
from core.repository.dataset_t... | [
"core.composer.composer.DummyComposer",
"core.repository.model_types_repository.ModelTypesRepository",
"core.utils.project_root",
"matplotlib.pyplot.plot",
"random.seed",
"sklearn.metrics.mean_squared_error",
"core.repository.model_types_repository.ModelMetaInfoTemplate",
"core.composer.composer.Compo... | [((694, 708), 'random.seed', 'random.seed', (['(1)'], {}), '(1)\n', (705, 708), False, 'import random\n'), ((2380, 2402), 'core.repository.model_types_repository.ModelTypesRepository', 'ModelTypesRepository', ([], {}), '()\n', (2400, 2402), False, 'from core.repository.model_types_repository import ModelMetaInfoTemplat... |
import os
import re
import shutil
def svnLockFiles(files):
fileStr = ' '.join(files)
print('Locking files: ', fileStr)
os.system('svn lock ' + fileStr)
def svnUnlockFiles(files):
fileStr = ' '.join(files)
print('Unlocking files: ', fileStr)
os.system('svn unlock ' + fileStr)
... | [
"os.system",
"shutil.move"
] | [((143, 175), 'os.system', 'os.system', (["('svn lock ' + fileStr)"], {}), "('svn lock ' + fileStr)\n", (152, 175), False, 'import os\n'), ((283, 317), 'os.system', 'os.system', (["('svn unlock ' + fileStr)"], {}), "('svn unlock ' + fileStr)\n", (292, 317), False, 'import os\n'), ((1009, 1039), 'shutil.move', 'shutil.m... |
import numpy as np
import time
import pytest
import jax.numpy as jnp
import jax.config as config
import torch
import tensorflow as tf
from tensornetwork.linalg import linalg
from tensornetwork import backends
from tensornetwork.backends.numpy import numpy_backend
from tensornetwork.backends.jax import jax_backend
#pyli... | [
"jax.config.update",
"tensornetwork.linalg.linalg.zeros",
"tensornetwork.linalg.linalg.randn",
"numpy.testing.assert_allclose",
"tensornetwork.backends.backend_factory.get_backend",
"tensornetwork.linalg.linalg.eye",
"numpy.random.seed",
"tensornetwork.linalg.linalg.ones",
"time.time",
"tensornetw... | [((342, 379), 'jax.config.update', 'config.update', (['"""jax_enable_x64"""', '(True)'], {}), "('jax_enable_x64', True)\n", (355, 379), True, 'import jax.config as config\n'), ((1806, 1851), 'tensornetwork.backends.backend_factory.get_backend', 'backends.backend_factory.get_backend', (['backend'], {}), '(backend)\n', (... |
"""main.py file representingcomparison statistics for Pyrunc module"""
# Python module(s)
from timeit import timeit
# Project module(s)
from Pyrunc import Pyrunc
def main():
"""Main Method"""
pr_c = Pyrunc()
# --------------------------------------------------------------------------------
# ----... | [
"timeit.timeit",
"Pyrunc.Pyrunc"
] | [((214, 222), 'Pyrunc.Pyrunc', 'Pyrunc', ([], {}), '()\n', (220, 222), False, 'from Pyrunc import Pyrunc\n'), ((2360, 2414), 'timeit.timeit', 'timeit', ([], {'stmt': '"""csummer(30)"""', 'setup': 'c_setup', 'number': '(1000)'}), "(stmt='csummer(30)', setup=c_setup, number=1000)\n", (2366, 2414), False, 'from timeit imp... |
from django.urls import reverse_lazy, reverse
from django.views.generic import TemplateView
from exporter.applications.services import post_applications, post_open_general_licences_applications
from exporter.apply_for_a_licence.forms.open_general_licences import (
open_general_licence_forms,
open_general_licen... | [
"exporter.apply_for_a_licence.forms.open_general_licences.open_general_licence_forms",
"exporter.apply_for_a_licence.forms.triage_questions.transhipment_questions",
"exporter.apply_for_a_licence.forms.triage_questions.MOD_questions",
"exporter.apply_for_a_licence.forms.triage_questions.trade_control_licence_q... | [((1008, 1026), 'exporter.apply_for_a_licence.forms.triage_questions.opening_question', 'opening_question', ([], {}), '()\n', (1024, 1026), False, 'from exporter.apply_for_a_licence.forms.triage_questions import opening_question, export_licence_questions, MOD_questions, transhipment_questions, trade_control_licence_que... |
#!/usr/bin/env python3
import numpy as np
import pandas as pd
import librosa
import os
import sys
import time
from datetime import datetime
from pathlib import Path
from src.python.audio_transforms import *
from src.python.model_predict import *
from src.python.graphics import plot_graph
# Hardcoding a few variable... | [
"pathlib.Path",
"src.python.graphics.plot_graph",
"numpy.array",
"datetime.datetime.now",
"librosa.effects.trim",
"librosa.load"
] | [((1090, 1129), 'pathlib.Path', 'Path', (['DIR_ROOT', '"""demo_files"""', '"""results"""'], {}), "(DIR_ROOT, 'demo_files', 'results')\n", (1094, 1129), False, 'from pathlib import Path\n'), ((3100, 3117), 'numpy.array', 'np.array', (['results'], {}), '(results)\n', (3108, 3117), True, 'import numpy as np\n'), ((481, 48... |
import socket
import struct
import json
import time
import os
import platform
from optparse import OptionParser
import sys
import xml.etree.ElementTree as ET
import config
from device_config import BASE_CONST
MCAST_GRP = '192.168.3.11'
MCAST_PORT = 8427
DEFAULT_DCID_XML = '/Applications/Shure Update Utility.app/C... | [
"xml.etree.ElementTree.parse",
"socket.socket",
"device_config.BASE_CONST.items",
"optparse.OptionParser",
"os.path.isfile",
"platform.system",
"config.app_dir",
"socket.inet_aton",
"sys.exit",
"json.load",
"time.time",
"json.dump"
] | [((535, 603), 'socket.socket', 'socket.socket', (['socket.AF_INET', 'socket.SOCK_DGRAM', 'socket.IPPROTO_UDP'], {}), '(socket.AF_INET, socket.SOCK_DGRAM, socket.IPPROTO_UDP)\n', (548, 603), False, 'import socket\n'), ((1916, 1934), 'device_config.BASE_CONST.items', 'BASE_CONST.items', ([], {}), '()\n', (1932, 1934), Fa... |
import fastai
from neptune.new.integrations.fastai import NeptuneCallback
from fastai.vision.all import *
import neptune.new as neptune
run = neptune.init(
project="common/fastai-integration", api_token="<PASSWORD>", tags="basic"
)
path = untar_data(URLs.MNIST_TINY)
dls = ImageDataLoaders.from_csv(path)
# Log al... | [
"neptune.new.integrations.fastai.NeptuneCallback",
"neptune.new.init"
] | [((143, 234), 'neptune.new.init', 'neptune.init', ([], {'project': '"""common/fastai-integration"""', 'api_token': '"""<PASSWORD>"""', 'tags': '"""basic"""'}), "(project='common/fastai-integration', api_token='<PASSWORD>',\n tags='basic')\n", (155, 234), True, 'import neptune.new as neptune\n'), ((393, 446), 'neptun... |
import unittest
import numpy as np
from xcube.webapi.controllers.time_series import get_time_series_info, get_time_series_for_point, \
get_time_series_for_geometry, get_time_series_for_geometry_collection
from ..helpers import new_test_service_context
class TimeSeriesControllerTest(unittest.TestCase):
def ... | [
"xcube.webapi.controllers.time_series.get_time_series_for_point",
"xcube.webapi.controllers.time_series.get_time_series_info",
"numpy.datetime64"
] | [((441, 514), 'xcube.webapi.controllers.time_series.get_time_series_for_point', 'get_time_series_for_point', (['ctx', '"""demo"""', '"""conc_tsm"""'], {'lon': '(-150.0)', 'lat': '(-30.0)'}), "(ctx, 'demo', 'conc_tsm', lon=-150.0, lat=-30.0)\n", (466, 514), False, 'from xcube.webapi.controllers.time_series import get_ti... |
from math import sqrt
from math import atan2
from math import asin
beta = 0.1
sampleFreq = 10.0
#Fastest implementation in python for invsqrt
def invsqrt(number):
return number ** -0.5
def update_IMU( gx, gy, gz, ax, ay, az, q0, q1, q2, q3):
gx = gx * 0.0174533
gy = gy * 0.0174533
gz = gz * 0.017453... | [
"math.asin",
"math.sqrt",
"math.atan2"
] | [((6068, 6117), 'math.atan2', 'atan2', (['(q0 * q1 + q2 * q3)', '(0.5 - q1 * q1 - q2 * q2)'], {}), '(q0 * q1 + q2 * q3, 0.5 - q1 * q1 - q2 * q2)\n', (6073, 6117), False, 'from math import atan2\n'), ((6120, 6152), 'math.asin', 'asin', (['(-2.0 * (q1 * q3 - q0 * q2))'], {}), '(-2.0 * (q1 * q3 - q0 * q2))\n', (6124, 6152... |
import setuptools
if __name__ == '__main__':
setuptools.setup(
name='Name',
version='0.1',
# this automatically detects the packages in the specified
# (or current directory if no directory is given).
packages=setuptools.find_packages(exclude=['tests', 'docs']),
# ... | [
"setuptools.find_packages"
] | [((256, 307), 'setuptools.find_packages', 'setuptools.find_packages', ([], {'exclude': "['tests', 'docs']"}), "(exclude=['tests', 'docs'])\n", (280, 307), False, 'import setuptools\n')] |
"""
# Interaction Tracker
# @license http://www.apache.org/licenses/LICENSE-2.0
# Author @ <NAME>, Zaki
"""
from analytics.models import (Log, ActionLog)
from rest_framework import serializers
class LogSerializer(serializers.ModelSerializer):
class Meta:
model = Log
fields = ('app','appuser',... | [
"analytics.models.ActionLog.objects.create",
"rest_framework.serializers.HiddenField",
"analytics.models.Log.objects.create"
] | [((658, 700), 'rest_framework.serializers.HiddenField', 'serializers.HiddenField', ([], {'default': '"""Request"""'}), "(default='Request')\n", (681, 700), False, 'from rest_framework import serializers\n'), ((891, 933), 'analytics.models.ActionLog.objects.create', 'ActionLog.objects.create', ([], {}), '(**validated_da... |
"""
Description:
Requirements: pySerial, wxPython Phoenix
glossary and of other descriptions:
DMM - digital multimeter
PSU - power supply
SBC - single board computer
INS - general instrument commands
GEN - general sequence instructions
"""
import json
import logging
import serial
import serialfunctions as sf
imp... | [
"wx.Button",
"wx.BoxSizer",
"time.sleep",
"wx.StaticBoxSizer",
"wx.StaticText",
"wx.TextCtrl",
"serial.Serial",
"wx.Panel.__init__"
] | [((624, 655), 'wx.Panel.__init__', 'wx.Panel.__init__', (['self', 'parent'], {}), '(self, parent)\n', (641, 655), False, 'import wx\n'), ((932, 956), 'wx.BoxSizer', 'wx.BoxSizer', (['wx.VERTICAL'], {}), '(wx.VERTICAL)\n', (943, 956), False, 'import wx\n'), ((983, 1009), 'wx.BoxSizer', 'wx.BoxSizer', (['wx.HORIZONTAL'],... |
# -*- coding: utf-8 -*-
"""\
Coroutine utilities
-------------------
Some code snippets inspired by http://www.dabeaz.com/coroutines/
"""
import re
import functools
def coroutine(func):
"""Prime a coroutine for send commands.
Args:
func (coroutine): A function that takes values via yield
Retur... | [
"functools.wraps",
"re.compile"
] | [((381, 402), 'functools.wraps', 'functools.wraps', (['func'], {}), '(func)\n', (396, 402), False, 'import functools\n'), ((1371, 1403), 're.compile', 're.compile', (['pattern'], {'flags': 'flags'}), '(pattern, flags=flags)\n', (1381, 1403), False, 'import re\n')] |
from sqlalchemy import Boolean, Column, ForeignKey, Integer, String, DateTime
from sqlalchemy.orm import relationship
import datetime
from database import Base
class Org(Base):
__tablename__ = "orgs"
id = Column(Integer, primary_key=True, index=True)
name = Column(String, unique=True, index=True)
cr... | [
"sqlalchemy.orm.relationship",
"sqlalchemy.ForeignKey",
"sqlalchemy.Column"
] | [((217, 262), 'sqlalchemy.Column', 'Column', (['Integer'], {'primary_key': '(True)', 'index': '(True)'}), '(Integer, primary_key=True, index=True)\n', (223, 262), False, 'from sqlalchemy import Boolean, Column, ForeignKey, Integer, String, DateTime\n'), ((274, 313), 'sqlalchemy.Column', 'Column', (['String'], {'unique'... |
#!/usr/bin/python3
import sys
import time
import array
import numpy as np
import pandas as pd
import statistics
import matplotlib.pyplot as plt
import seaborn as sns
# sns.set_theme(style="darkgrid")
x_b = [1, 10, 100, 1000, 10000, 100000, 1000000]
cyc_pi2 = [8379072, 8379072, 3675200, 372864, 37312, 3728, 368]
cyc... | [
"matplotlib.pyplot.grid",
"matplotlib.pyplot.ylabel",
"matplotlib.pyplot.gca",
"matplotlib.pyplot.xlabel",
"matplotlib.pyplot.bar",
"matplotlib.pyplot.title",
"matplotlib.pyplot.yscale",
"matplotlib.pyplot.legend",
"matplotlib.pyplot.show"
] | [((1063, 1072), 'matplotlib.pyplot.gca', 'plt.gca', ([], {}), '()\n', (1070, 1072), True, 'import matplotlib.pyplot as plt\n'), ((1200, 1252), 'matplotlib.pyplot.bar', 'plt.bar', (['r1', 'cyc_lap'], {'width': 'barWidth', 'label': '"""Laptop"""'}), "(r1, cyc_lap, width=barWidth, label='Laptop')\n", (1207, 1252), True, '... |
from flask_bcrypt import Bcrypt
from flask_caching import Cache
from flask_debugtoolbar import DebugToolbarExtension
from flask_login import LoginManager
from flask_migrate import Migrate
from flask_sqlalchemy import SQLAlchemy
import logging
bcrypt = Bcrypt()
login_manager = LoginManager()
db = SQLAlchemy()
migrate =... | [
"logging.getLogger",
"flask_login.LoginManager",
"flask_debugtoolbar.DebugToolbarExtension",
"flask_bcrypt.Bcrypt",
"flask_caching.Cache",
"flask_migrate.Migrate",
"flask_sqlalchemy.SQLAlchemy"
] | [((253, 261), 'flask_bcrypt.Bcrypt', 'Bcrypt', ([], {}), '()\n', (259, 261), False, 'from flask_bcrypt import Bcrypt\n'), ((278, 292), 'flask_login.LoginManager', 'LoginManager', ([], {}), '()\n', (290, 292), False, 'from flask_login import LoginManager\n'), ((298, 310), 'flask_sqlalchemy.SQLAlchemy', 'SQLAlchemy', ([]... |
import time
def f():
[
# Must be split over multiple lines to see the error.
# https://github.com/benfred/py-spy/pull/208
time.sleep(1)
for _ in range(1000)
]
f()
| [
"time.sleep"
] | [((152, 165), 'time.sleep', 'time.sleep', (['(1)'], {}), '(1)\n', (162, 165), False, 'import time\n')] |
# -*- coding: utf-8 -*-
"""
Microsoft-Windows-UAC-FileVirtualization
GUID : c02afc2b-e24e-4449-ad76-bcc2c2575ead
"""
from construct import Int8sl, Int8ul, Int16ul, Int16sl, Int32sl, Int32ul, Int64sl, Int64ul, Bytes, Double, Float32l, Struct
from etl.utils import WString, CString, SystemTime, Guid
from etl.dtyp import S... | [
"construct.Bytes",
"construct.Struct",
"etl.parsers.etw.core.guid"
] | [((537, 562), 'construct.Struct', 'Struct', (["('Error' / Int32ul)"], {}), "('Error' / Int32ul)\n", (543, 562), False, 'from construct import Int8sl, Int8ul, Int16ul, Int16sl, Int32sl, Int32ul, Int64sl, Int64ul, Bytes, Double, Float32l, Struct\n'), ((739, 764), 'construct.Struct', 'Struct', (["('Error' / Int32ul)"], {}... |
"""
Processing data in win32 format.
"""
import glob
import logging
import math
import os
import subprocess
import tempfile
from fnmatch import fnmatch
from multiprocessing import Pool, cpu_count
from subprocess import DEVNULL, PIPE, Popen
# Setup the logger
FORMAT = "[%(asctime)s] %(levelname)s: %(message)s"
logging.... | [
"logging.basicConfig",
"os.path.exists",
"logging.getLogger",
"os.makedirs",
"math.pow",
"subprocess.Popen",
"os.rename",
"os.path.join",
"math.sqrt",
"multiprocessing.cpu_count",
"os.path.dirname",
"subprocess.call",
"tempfile.NamedTemporaryFile",
"glob.glob"
] | [((312, 400), 'logging.basicConfig', 'logging.basicConfig', ([], {'level': 'logging.INFO', 'format': 'FORMAT', 'datefmt': '"""%Y-%m-%d %H:%M:%S"""'}), "(level=logging.INFO, format=FORMAT, datefmt=\n '%Y-%m-%d %H:%M:%S')\n", (331, 400), False, 'import logging\n'), ((405, 432), 'logging.getLogger', 'logging.getLogger'... |
import asyncio
import aiopg
dsn = 'dbname=aiopg user=aiopg password=<PASSWORD> host=127.0.0.1'
@asyncio.coroutine
def test_select():
pool = yield from aiopg.create_pool(dsn)
with (yield from pool.cursor()) as cur:
yield from cur.execute("SELECT 1")
ret = yield from cur.fetchone()
asse... | [
"asyncio.get_event_loop",
"aiopg.create_pool"
] | [((366, 390), 'asyncio.get_event_loop', 'asyncio.get_event_loop', ([], {}), '()\n', (388, 390), False, 'import asyncio\n'), ((158, 180), 'aiopg.create_pool', 'aiopg.create_pool', (['dsn'], {}), '(dsn)\n', (175, 180), False, 'import aiopg\n')] |
from collections import defaultdict
import io
import hashlib
from datetime import date, datetime
from pyexcel_xls import get_data as xls_get
import pandas
import magic
from contextlib import closing
import csv
from django.db import connection
from io import StringIO
import uuid
from psycopg2.errors import UniqueViolati... | [
"care.facility.api.serializers.patient_external_test.PatientExternalTestSerializer",
"care.facility.models.PatientExternalTest.CSV_MAKE_PRETTY.copy",
"pandas.read_csv",
"rest_framework.exceptions.ValidationError",
"rest_framework.decorators.action",
"pyexcel_xls.get_data",
"core.fernet.FernetEncryption"... | [((1570, 1587), 'collections.defaultdict', 'defaultdict', (['list'], {}), '(list)\n', (1581, 1587), False, 'from collections import defaultdict\n'), ((1609, 1654), 'care.facility.models.PatientExternalTest.HEADER_CSV_MAPPING.keys', 'PatientExternalTest.HEADER_CSV_MAPPING.keys', ([], {}), '()\n', (1652, 1654), False, 'f... |
"""Converts synonyms into SMILES for the data from Gerber's paper."""
# data/hsd11b1_validation/get_smiles_cactus.py
from io import BytesIO
import pandas as pd
import pycurl
def getsmiles_cactus(name):
"""Converts synonyms into SMILES strings.
A function to use the public cactus (National Institutes of Canc... | [
"pycurl.Curl",
"io.BytesIO",
"pandas.read_csv"
] | [((615, 624), 'io.BytesIO', 'BytesIO', ([], {}), '()\n', (622, 624), False, 'from io import BytesIO\n'), ((633, 646), 'pycurl.Curl', 'pycurl.Curl', ([], {}), '()\n', (644, 646), False, 'import pycurl\n'), ((934, 961), 'pandas.read_csv', 'pd.read_csv', (['data'], {'sep': '"""\t"""'}), "(data, sep='\\t')\n", (945, 961), ... |
#! /usr/bin/env python3
# -*- coding: utf-8 -*-
# File : eval-referential.py
# Author : <NAME>, <NAME>
# Email : <EMAIL>, <EMAIL>
# Date : 30.07.2019
# Last Modified Date: 16.10.2019
# Last Modified By : Chi Han, Jiayuan Mao
#
# This file is part of the VCML codebase
# ... | [
"jacinle.io.load_json",
"IPython.core.ultratb.FormattedTB",
"jacinle.utils.meter.GroupMeters",
"jacinle.random.randint",
"jacinle.cli.argument.JacArgumentParser",
"jacinle.random.choice_list",
"jacinle.io.load",
"numpy.fmin",
"jacinle.utils.tqdm.tqdm_gofor"
] | [((890, 960), 'IPython.core.ultratb.FormattedTB', 'ultratb.FormattedTB', ([], {'mode': '"""Plain"""', 'color_scheme': '"""Linux"""', 'call_pdb': '(True)'}), "(mode='Plain', color_scheme='Linux', call_pdb=True)\n", (909, 960), False, 'from IPython.core import ultratb\n'), ((976, 995), 'jacinle.cli.argument.JacArgumentPa... |
import pytest
@pytest.fixture(scope="module")
def client(looper, txnPoolNodeSet, client1, client1Connected):
return client1Connected
| [
"pytest.fixture"
] | [((17, 47), 'pytest.fixture', 'pytest.fixture', ([], {'scope': '"""module"""'}), "(scope='module')\n", (31, 47), False, 'import pytest\n')] |
#!/usr/bin/env python
#
# Copyright (c) 2018 10X Genomics, Inc. All rights reserved.
#
# Utils for feature-barcoding technology
import numpy as np
import os
import json
import tenkit.safe_json as tk_safe_json
def check_if_none_or_empty(matrix):
if matrix is None or matrix.get_shape()[0] == 0 or matrix.get_shape(... | [
"os.path.isfile",
"tenkit.safe_json.json_sanitize"
] | [((1193, 1214), 'os.path.isfile', 'os.path.isfile', (['fpath'], {}), '(fpath)\n', (1207, 1214), False, 'import os\n'), ((494, 532), 'tenkit.safe_json.json_sanitize', 'tk_safe_json.json_sanitize', (['input_dict'], {}), '(input_dict)\n', (520, 532), True, 'import tenkit.safe_json as tk_safe_json\n')] |
import json
import rimu
from rimu import options
def unexpectedError(_, message):
raise Exception(f'unexpected callback: {message}')
def test_render():
assert rimu.render('Hello World!') == '<p>Hello World!</p>'
def test_jsonTests():
with open('./tests/rimu-tests.json') as f:
data = json.load... | [
"json.load",
"rimu.render",
"rimu.RenderOptions"
] | [((172, 199), 'rimu.render', 'rimu.render', (['"""Hello World!"""'], {}), "('Hello World!')\n", (183, 199), False, 'import rimu\n'), ((311, 323), 'json.load', 'json.load', (['f'], {}), '(f)\n', (320, 323), False, 'import json\n'), ((599, 619), 'rimu.RenderOptions', 'rimu.RenderOptions', ([], {}), '()\n', (617, 619), Fa... |
# -*- coding: utf-8 -*-
"""
app_test.py
Tests the tkit.App class.
Author: <NAME>; Oct 2017
License: MIT
"""
import tkit
if __name__ == "__main__":
# Create app
test_app = tkit.App("Test App", 250, 100)
# Create and customize menubar
menubar = tkit.Menubar()
menubar.add_menu("File")
#test_men... | [
"tkit.Popup",
"tkit.Menubar",
"tkit.BrowseFile",
"tkit.App"
] | [((183, 213), 'tkit.App', 'tkit.App', (['"""Test App"""', '(250)', '(100)'], {}), "('Test App', 250, 100)\n", (191, 213), False, 'import tkit\n'), ((263, 277), 'tkit.Menubar', 'tkit.Menubar', ([], {}), '()\n', (275, 277), False, 'import tkit\n'), ((652, 669), 'tkit.BrowseFile', 'tkit.BrowseFile', ([], {}), '()\n', (667... |
""" Database models
"""
from typing import Tuple
import attr
import sqlalchemy as sa
from .settings import DATCORE_STR, SIMCORE_S3_ID, SIMCORE_S3_STR
#FIXME: W0611:Unused UUID imported from sqlalchemy.dialects.postgresql
#from sqlalchemy.dialects.postgresql import UUID
#FIXME: R0902: Too many instance attributes (... | [
"sqlalchemy.MetaData",
"attr.s",
"sqlalchemy.Column"
] | [((392, 405), 'sqlalchemy.MetaData', 'sa.MetaData', ([], {}), '()\n', (403, 405), True, 'import sqlalchemy as sa\n'), ((2050, 2075), 'attr.s', 'attr.s', ([], {'auto_attribs': '(True)'}), '(auto_attribs=True)\n', (2056, 2075), False, 'import attr\n'), ((487, 538), 'sqlalchemy.Column', 'sa.Column', (['"""file_uuid"""', '... |
import pandas as pd
from sklearn.pipeline import Pipeline
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.metrics import confusion_matrix, roc_auc_score
from category_encoders import MEstimateEncoder
import numpy as np
from collections import defaultdict
import os
from sklearn.metrics import roc_au... | [
"numpy.log",
"sklearn.metrics.roc_auc_score",
"numpy.arange",
"numpy.histogram",
"numpy.max",
"numpy.empty",
"numpy.min",
"pandas.DataFrame",
"sklearn.metrics.confusion_matrix",
"numpy.abs",
"sklearn.model_selection.train_test_split",
"sklearn.pipeline.Pipeline",
"sklearn.ensemble.GradientBo... | [((492, 539), 'sklearn.pipeline.Pipeline', 'Pipeline', (["[('encoder', enc), ('model', modelo)]"], {}), "([('encoder', enc), ('model', modelo)])\n", (500, 539), False, 'from sklearn.pipeline import Pipeline\n'), ((2336, 2365), 'sklearn.metrics.confusion_matrix', 'confusion_matrix', (['preds', 'true'], {}), '(preds, tru... |
# Solution of;
# Project Euler Problem 527: Randomized Binary Search
# https://projecteuler.net/problem=527
#
# A secret integer t is selected at random within the range 1 ≤ t ≤ n. The
# goal is to guess the value of t by making repeated guesses, via integer g.
# After a guess is made, there are three possible outco... | [
"timed.caller"
] | [((1894, 1928), 'timed.caller', 'timed.caller', (['dummy', 'n', 'i', 'prob_id'], {}), '(dummy, n, i, prob_id)\n', (1906, 1928), False, 'import timed\n')] |
import asyncio
from aiohttp import web
from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
from multiprocessing import Queue, Process
import os
from time import sleep
async def handle(request):
index = open("index.html", 'rb')
content = index.read()
return web.Response(body=content, co... | [
"aiohttp.web.run_app",
"concurrent.futures.ThreadPoolExecutor",
"multiprocessing.Process",
"aiohttp.web.Response",
"aiohttp.web.Application",
"asyncio.wait",
"time.sleep",
"asyncio.Condition",
"os.getpid",
"multiprocessing.Queue",
"asyncio.get_event_loop",
"aiohttp.web.WebSocketResponse"
] | [((353, 372), 'asyncio.Condition', 'asyncio.Condition', ([], {}), '()\n', (370, 372), False, 'import asyncio\n'), ((2132, 2156), 'asyncio.get_event_loop', 'asyncio.get_event_loop', ([], {}), '()\n', (2154, 2156), False, 'import asyncio\n'), ((2168, 2201), 'concurrent.futures.ThreadPoolExecutor', 'ThreadPoolExecutor', (... |
import pytest
from fixtures import world
from wecs.core import UID
from wecs.core import NoSuchUID
from wecs.core import Component
@Component()
class Reference:
uid: UID
def test_user_defined_names(world):
entity = world.create_entity(name="foo")
assert entity._uid.name == "foo"
def test_automatic_n... | [
"wecs.core.Component",
"fixtures.world.create_entity",
"fixtures.world.flush_component_updates",
"wecs.core.UID",
"pytest.raises"
] | [((136, 147), 'wecs.core.Component', 'Component', ([], {}), '()\n', (145, 147), False, 'from wecs.core import Component\n'), ((229, 260), 'fixtures.world.create_entity', 'world.create_entity', ([], {'name': '"""foo"""'}), "(name='foo')\n", (248, 260), False, 'from fixtures import world\n'), ((346, 367), 'fixtures.world... |
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
from webdriver_manager.chrome import ChromeDriverManager
from pages.home_page import HomePage
from pages.profile_page import ProfilePage
from pages.login_page import LoginPage
from pages.registration_page import RegistrationPage
from p... | [
"selenium.webdriver.chrome.options.Options",
"pages.profile_page.ProfilePage",
"pages.home_page.HomePage",
"pages.login_page.LoginPage",
"pages.navigation_bar.NavigationBar",
"pages.article_page.ArticlePage",
"pages.new_article_page.NewArticlePage",
"webdriver_manager.chrome.ChromeDriverManager"
] | [((498, 507), 'selenium.webdriver.chrome.options.Options', 'Options', ([], {}), '()\n', (505, 507), False, 'from selenium.webdriver.chrome.options import Options\n'), ((908, 937), 'pages.home_page.HomePage', 'HomePage', ([], {'driver': 'self.browser'}), '(driver=self.browser)\n', (916, 937), False, 'from pages.home_pag... |
import numpy as np
import numpy.linalg as LA
from .solve_R1 import problem_R1, Classo_R1, pathlasso_R1
from .solve_R2 import problem_R2, Classo_R2, pathlasso_R2
from .solve_R3 import problem_R3, Classo_R3, pathlasso_R3
from .solve_R4 import problem_R4, Classo_R4, pathlasso_R4
from .path_alg import solve_path, pathalgo... | [
"numpy.vdot",
"numpy.array",
"numpy.linspace",
"numpy.mean"
] | [((9722, 9762), 'numpy.array', 'np.array', (['[(beta / ww) for beta in BETA]'], {}), '([(beta / ww) for beta in BETA])\n', (9730, 9762), True, 'import numpy as np\n'), ((9864, 9878), 'numpy.array', 'np.array', (['BETA'], {}), '(BETA)\n', (9872, 9878), True, 'import numpy as np\n'), ((5733, 5757), 'numpy.linspace', 'np.... |
from tensorpy import image_base
classifications = image_base.classify_folder_images('./images')
print("*** Displaying Image Classification Results as a list: ***")
for classification in classifications:
print(classification)
| [
"tensorpy.image_base.classify_folder_images"
] | [((51, 96), 'tensorpy.image_base.classify_folder_images', 'image_base.classify_folder_images', (['"""./images"""'], {}), "('./images')\n", (84, 96), False, 'from tensorpy import image_base\n')] |
import argparse
import torch
from torch.utils.data import DataLoader
import sys, os
sys.path.insert(0, os.path.join(
os.path.dirname(os.path.realpath(__file__)), "../../"))
from deep_audio_features.dataloading.dataloading import FeatureExtractorDataset
from deep_audio_features.models.cnn import load_cnn
from deep_a... | [
"deep_audio_features.models.cnn.load_cnn",
"deep_audio_features.utils.model_editing.drop_layers",
"argparse.ArgumentParser",
"deep_audio_features.dataloading.dataloading.FeatureExtractorDataset",
"deep_audio_features.lib.training.test",
"os.path.realpath",
"numpy.array",
"torch.cuda.is_available",
"... | [((1363, 1382), 'deep_audio_features.models.cnn.load_cnn', 'load_cnn', (['modelpath'], {}), '(modelpath)\n', (1371, 1382), False, 'from deep_audio_features.models.cnn import load_cnn\n'), ((1621, 1655), 'deep_audio_features.utils.model_editing.drop_layers', 'drop_layers', (['model', 'layers_dropped'], {}), '(model, lay... |
import re
import traceback
from textwrap import dedent
def camel_to_snake(value):
s1 = re.sub('(.)([A-Z][a-z]+)', r'\1_\2', value)
return re.sub('([a-z0-9])([A-Z])', r'\1_\2', s1).lower()
def snake_to_camel(value):
camel = ''
words = value.split('_')
for w in words:
camel += w.title()
... | [
"re.sub",
"re.escape",
"traceback.extract_stack"
] | [((93, 137), 're.sub', 're.sub', (['"""(.)([A-Z][a-z]+)"""', '"""\\\\1_\\\\2"""', 'value'], {}), "('(.)([A-Z][a-z]+)', '\\\\1_\\\\2', value)\n", (99, 137), False, 'import re\n'), ((973, 995), 're.escape', 're.escape', (['replacement'], {}), '(replacement)\n', (982, 995), False, 'import re\n'), ((148, 190), 're.sub', 'r... |
import sys
import os
import random
klasorAdi = os.path.dirname(sys.argv[0])
dosyaIsmi = klasorAdi + "/test.txt"
soruSayisi = 40
ogrenciSayisi = 60
d = {}
dogruSayisi = {}
yalisSayisi = {}
bosSayisi = {}
puan = {}
def sinavHazirla():
for j in range(1, soruSayisi + 1):
r1 = random.randint(1, 5)
d[0, j] = chr(... | [
"os.path.isfile",
"os.path.dirname",
"random.randint"
] | [((47, 75), 'os.path.dirname', 'os.path.dirname', (['sys.argv[0]'], {}), '(sys.argv[0])\n', (62, 75), False, 'import os\n'), ((281, 301), 'random.randint', 'random.randint', (['(1)', '(5)'], {}), '(1, 5)\n', (295, 301), False, 'import random\n'), ((2184, 2209), 'os.path.isfile', 'os.path.isfile', (['dosyaIsmi'], {}), '... |
from twisted.plugin import IPlugin
from heufybot.moduleinterface import IBotModule
from heufybot.modules.commandinterface import BotCommand
from heufybot.utils.timeutils import now, timestamp
from zope.interface import implements
from datetime import datetime
class TimeCommand(BotCommand):
implements(IPlugin, IBo... | [
"heufybot.utils.timeutils.now",
"zope.interface.implements"
] | [((297, 328), 'zope.interface.implements', 'implements', (['IPlugin', 'IBotModule'], {}), '(IPlugin, IBotModule)\n', (307, 328), False, 'from zope.interface import implements\n'), ((4317, 4322), 'heufybot.utils.timeutils.now', 'now', ([], {}), '()\n', (4320, 4322), False, 'from heufybot.utils.timeutils import now, time... |
import pandas as pd
import click
import collections
def kmer_suffix(kmer):
return kmer[1:]
def kmer_prefix(kmer):
return kmer[:-1]
def chunks(l, n):
"""Yield successive n-sized chunks from l."""
for i in range(0, len(l), n):
yield l[i:i + n]
def build_graph(kmers):
graph = collection... | [
"click.option",
"click.command",
"collections.defaultdict",
"pandas.read_csv"
] | [((1789, 1804), 'click.command', 'click.command', ([], {}), '()\n', (1802, 1804), False, 'import click\n'), ((1806, 1868), 'click.option', 'click.option', (['"""--fin"""'], {'type': 'str', 'default': '"""problem11_input.tsv"""'}), "('--fin', type=str, default='problem11_input.tsv')\n", (1818, 1868), False, 'import clic... |
#!/usr/bin/env python3
import sys
import re
import time
import datetime
import os
for module in sorted(sys.modules):
print("%-20s : %s" % (module, sys.modules[module]))
print('USER : ', os.environ['USER'])
print('PWD : ', os.environ['PWD'])
print('PYTHONPATH: ', os.environ.get('PYTHONPATH'))
print(sy... | [
"os.environ.get"
] | [((281, 309), 'os.environ.get', 'os.environ.get', (['"""PYTHONPATH"""'], {}), "('PYTHONPATH')\n", (295, 309), False, 'import os\n')] |
# SPDX-FileCopyrightText: 2020 <NAME> <<EMAIL>>
#
# SPDX-License-Identifier: Apache-2.0
from unittest import mock
import pytest
from codeprep.bpepkg.bpe_config import BpeConfig, BpeParam, BpeConfigNotSupported
from codeprep.pipeline.bpelearner import run
@mock.patch('codeprep.pipeline.bpelearner.Dataset', autospec... | [
"codeprep.pipeline.bpelearner.run",
"codeprep.bpepkg.bpe_config.BpeConfig",
"unittest.mock.patch",
"pytest.raises"
] | [((261, 326), 'unittest.mock.patch', 'mock.patch', (['"""codeprep.pipeline.bpelearner.Dataset"""'], {'autospec': '(True)'}), "('codeprep.pipeline.bpelearner.Dataset', autospec=True)\n", (271, 326), False, 'from unittest import mock\n'), ((621, 686), 'unittest.mock.patch', 'mock.patch', (['"""codeprep.pipeline.bpelearne... |
#!/usr/bin/env python3
import torrent_parser as tp
import asyncio
import contextlib
import pathlib
import argparse
import pprint
import hashlib
import concurrent.futures
import os.path
import logging
import tqdm
class TorrentChecker(object):
def __init__(self, datadir=pathlib.Path('.'), data_file_globs=["**"],
... | [
"logging.getLogger",
"asyncio.CancelledError",
"torrent_parser.parse_torrent_file",
"argparse.ArgumentParser",
"pathlib.Path",
"pathlib.PurePath",
"hashlib.sha1"
] | [((5286, 5351), 'argparse.ArgumentParser', 'argparse.ArgumentParser', ([], {'description': '"""Verify downloaded torrents"""'}), "(description='Verify downloaded torrents')\n", (5309, 5351), False, 'import argparse\n'), ((272, 289), 'pathlib.Path', 'pathlib.Path', (['"""."""'], {}), "('.')\n", (284, 289), False, 'impor... |
import os
_rootdir = os.getcwd()
def find_rootdir(filenames = ('__main__.py', 'main.ipynb')):
path = os.getcwd()
while os.path.isdir(path):
ls = os.listdir(path)
if any([f in ls for f in filenames]):
return os.path.abspath(path)
else:
path += '/..'
# nothi... | [
"os.path.abspath",
"os.listdir",
"os.path.isdir",
"os.getcwd"
] | [((22, 33), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (31, 33), False, 'import os\n'), ((107, 118), 'os.getcwd', 'os.getcwd', ([], {}), '()\n', (116, 118), False, 'import os\n'), ((130, 149), 'os.path.isdir', 'os.path.isdir', (['path'], {}), '(path)\n', (143, 149), False, 'import os\n'), ((371, 382), 'os.getcwd', 'os... |
import math
import random
import numpy as np
# 先生成一个随机的信源
def random_sources():
random_sources = random.randint(0, 16)
print('这个随机数是', random_sources)
return hanming(random_sources)
# return bin(int(random_sources)... | [
"random.randint"
] | [((191, 212), 'random.randint', 'random.randint', (['(0)', '(16)'], {}), '(0, 16)\n', (205, 212), False, 'import random\n')] |
from django.db import models
from users.models import User
class Assignment(models.Model):
title = models.CharField(max_length=50)
teacher = models.ForeignKey(User, on_delete=models.CASCADE)
def __str__(self):
return self.title
class GradedAssignment(models.Model):
student = models.ForeignK... | [
"django.db.models.FloatField",
"django.db.models.ForeignKey",
"django.db.models.ManyToManyField",
"django.db.models.SmallIntegerField",
"django.db.models.CharField"
] | [((105, 136), 'django.db.models.CharField', 'models.CharField', ([], {'max_length': '(50)'}), '(max_length=50)\n', (121, 136), False, 'from django.db import models\n'), ((151, 200), 'django.db.models.ForeignKey', 'models.ForeignKey', (['User'], {'on_delete': 'models.CASCADE'}), '(User, on_delete=models.CASCADE)\n', (16... |
from fastapi import FastAPI
from . import api
app = FastAPI(debug=True)
app.include_router(api.router) | [
"fastapi.FastAPI"
] | [((55, 74), 'fastapi.FastAPI', 'FastAPI', ([], {'debug': '(True)'}), '(debug=True)\n', (62, 74), False, 'from fastapi import FastAPI\n')] |
#!/usr/bin/env python
"""
Perform compressed sensing analysis on a dax file using the
homotopy approach. Return the results in hres image format and
as a list of object locations.
Hazen 09/12
"""
import numpy
import storm_analysis.sa_library.datareader as datareader
import storm_analysis.sa_library.parameters as par... | [
"storm_analysis.sa_library.parameters.ParametersL1H",
"storm_analysis.sa_library.datareader.inferReader",
"argparse.ArgumentParser",
"storm_analysis.L1H.setup_A_matrix.loadAMatrix",
"storm_analysis.sa_library.writeinsight3.I3Writer"
] | [((660, 694), 'storm_analysis.sa_library.datareader.inferReader', 'datareader.inferReader', (['movie_name'], {}), '(movie_name)\n', (682, 694), True, 'import storm_analysis.sa_library.datareader as datareader\n'), ((823, 855), 'storm_analysis.sa_library.writeinsight3.I3Writer', 'writeinsight3.I3Writer', (['bin_name'], ... |
"""
Methods for handling DB creation and CRUD operations in Sqlite3.
"""
# Standard library imports
import logging
import sqlite3
# Local application imports
from ism.exceptions.exceptions import UnrecognisedParameterisationCharacter
from ism.interfaces.dao_interface import DAOInterface
class Sqlite3DAO(DAOInterfac... | [
"logging.getLogger",
"logging.error",
"sqlite3.connect",
"ism.exceptions.exceptions.UnrecognisedParameterisationCharacter"
] | [((617, 664), 'logging.getLogger', 'logging.getLogger', (['"""ism.sqlite3_dao.Sqlite3DAO"""'], {}), "('ism.sqlite3_dao.Sqlite3DAO')\n", (634, 664), False, 'import logging\n'), ((2365, 2394), 'sqlite3.connect', 'sqlite3.connect', (['self.db_path'], {}), '(self.db_path)\n', (2380, 2394), False, 'import sqlite3\n'), ((152... |
# Author: btjanaka (<NAME>)
# Problem: (UVa) 247
import sys
from collections import defaultdict
def kosaraju(g, g_rev):
order = []
visited = set()
def visit(u):
visited.add(u)
for v in g[u]:
if v not in visited:
visit(v)
order.append(u)
for u in g... | [
"collections.defaultdict"
] | [((865, 881), 'collections.defaultdict', 'defaultdict', (['set'], {}), '(set)\n', (876, 881), False, 'from collections import defaultdict\n'), ((883, 899), 'collections.defaultdict', 'defaultdict', (['set'], {}), '(set)\n', (894, 899), False, 'from collections import defaultdict\n')] |
import pyautogui
import time
time.sleep(3)
print(pyautogui.position()) | [
"pyautogui.position",
"time.sleep"
] | [((30, 43), 'time.sleep', 'time.sleep', (['(3)'], {}), '(3)\n', (40, 43), False, 'import time\n'), ((50, 70), 'pyautogui.position', 'pyautogui.position', ([], {}), '()\n', (68, 70), False, 'import pyautogui\n')] |
from jmap.account.imap.imap_utf7 import imap_utf7_decode, imap_utf7_encode
KNOWN_SPECIALS = set('\\HasChildren \\HasNoChildren \\NoSelect \\NoInferiors \\UnMarked \\Subscribed'.lower().split())
# special use or name magic
ROLE_MAP = {
'inbox': 'inbox',
'drafts': 'drafts',
'draft': 'drafts',
'draft messages':... | [
"jmap.account.imap.imap_utf7.imap_utf7_encode"
] | [((2719, 2749), 'jmap.account.imap.imap_utf7.imap_utf7_encode', 'imap_utf7_encode', (["self['name']"], {}), "(self['name'])\n", (2735, 2749), False, 'from jmap.account.imap.imap_utf7 import imap_utf7_decode, imap_utf7_encode\n')] |
from pyieee1905.ieee1905_tlv import IEEE1905_TLV
from scapy.packet import Packet, bind_layers
from scapy.fields import BitField, XByteField, XShortField, XShortEnumField
from scapy.layers.l2 import Ether
IEEE1905_MCAST = "01:80:c2:00:00:13"
ieee1905_msg_type = {
0x0000:"TOPOLOGY_DISCOVERY_MESSAGE",
0x0001:... | [
"scapy.packet.bind_layers",
"scapy.fields.BitField",
"scapy.fields.XShortField",
"scapy.fields.XByteField",
"scapy.fields.XShortEnumField"
] | [((2890, 2937), 'scapy.packet.bind_layers', 'bind_layers', (['Ether', 'MultiAP_Message'], {'type': '(35130)'}), '(Ether, MultiAP_Message, type=35130)\n', (2901, 2937), False, 'from scapy.packet import Packet, bind_layers\n'), ((2939, 2981), 'scapy.packet.bind_layers', 'bind_layers', (['MultiAP_Message', 'IEEE1905_TLV']... |
"""
Command line management utilities for ITEEBot. This module's command line
interface will act as the bot's entry point when installed.
"""
import click
from . import configurator as conf
from . import database as db
from .bot import ITEEBot
@click.group()
def cli():
pass
@click.command("init-config")
@click.a... | [
"click.group",
"click.option",
"click.command",
"click.Path"
] | [((247, 260), 'click.group', 'click.group', ([], {}), '()\n', (258, 260), False, 'import click\n'), ((283, 311), 'click.command', 'click.command', (['"""init-config"""'], {}), "('init-config')\n", (296, 311), False, 'import click\n'), ((770, 794), 'click.command', 'click.command', (['"""init-db"""'], {}), "('init-db')\... |