text stringlengths 213 32.3k |
|---|
from django.urls import reverse
from weblate.trans.models.component import Component
from weblate.trans.tests.test_views import ViewTestCase
class LockTest(ViewTestCase):
def setUp(self):
super().setUp()
# Need extra power
self.user.is_superuser = True
self.user.save()
def ... |
import sys
import mne
def run():
"""Run command."""
import matplotlib.pyplot as plt
from mne.commands.utils import get_optparser, _add_verbose_flag
from mne.viz import _RAW_CLIP_DEF
parser = get_optparser(__file__, usage='usage: %prog raw [options]')
parser.add_option("--raw", dest="raw_in"... |
from mock import MagicMock
from mock import patch
from paasta_tools.cli.cmds.itest import paasta_itest
@patch("paasta_tools.cli.cmds.itest.validate_service_name", autospec=True)
@patch("paasta_tools.cli.cmds.itest._run", autospec=True)
@patch("paasta_tools.cli.cmds.itest._log", autospec=True)
@patch("paasta_tools.c... |
import datetime
import json
import sys
from coverage import __version__
from coverage.report import get_analysis_to_report
from coverage.results import Numbers
class JsonReporter(object):
"""A reporter for writing JSON coverage results."""
def __init__(self, coverage):
self.coverage = coverage
... |
from test import CollectorTestCase
from test import get_collector_config
from mock import patch, Mock
from diamond.collector import Collector
from kafka_consumer_lag import KafkaConsumerLagCollector
##########################################################################
class TestKafkaConsumerLagCollector(Colle... |
import copy
import time
from absl import flags
from perfkitbenchmarker import configs
from perfkitbenchmarker import regex_util
from perfkitbenchmarker import sample
from perfkitbenchmarker.linux_packages import cloud_tpu_models
from perfkitbenchmarker.linux_packages import nvidia_driver
from perfkitbenchmarker.linux_... |
import random
import pandas as pd
from arctic import Arctic
def gen_dataframe_random(cols, rows):
c = {}
for col in range(cols):
c[str(col)] = [round(random.uniform(-10000.0, 10000.0), 1) for r in range(rows)]
index = [range(rows)]
return pd.DataFrame(data=c, index=index)
def gen_series_... |
import pytest
from qutebrowser.utils import usertypes
from qutebrowser.misc import objects
from qutebrowser.misc.keyhintwidget import KeyHintView
def expected_text(*args):
"""Helper to format text we expect the KeyHintView to generate.
Args:
args: One tuple for each row in the expected output.
... |
from appconf import AppConf
from django.db import models
from django.db.models import Q
from django.db.models.signals import post_save
from django.dispatch import receiver
from django.urls import reverse
from django.utils.functional import cached_property
from weblate.addons.events import (
EVENT_CHOICES,
EVE... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import abc
import functools
import logging
import os
import posixpath
import threading
import time
import uuid
from absl import flags
from perfkitbenchmarker import errors
from perfkitbenchmarker import events... |
import os
import re
import sys
from collections import namedtuple # noqa
__version__ = '5.0.2'
__author__ = 'Ask Solem'
__contact__ = 'auvipy@gmail.com, ask@celeryproject.org'
__homepage__ = 'https://kombu.readthedocs.io'
__docformat__ = 'restructuredtext en'
# -eof meta-
version_info_t = namedtuple('version_info_... |
from __future__ import unicode_literals
import unittest
import codecs
import os,sys,inspect
currentdir = os.path.dirname(os.path.abspath(inspect.getfile(inspect.currentframe())))
parentdir = os.path.dirname(currentdir)
sys.path.insert(0,parentdir)
from learn_bpe import learn_bpe
from apply_bpe import BPE
class Tes... |
from typing import List, Optional
import voluptuous as vol
from homeassistant.components.device_automation import toggle_entity
from homeassistant.const import (
ATTR_ENTITY_ID,
ATTR_SUPPORTED_FEATURES,
CONF_DEVICE_ID,
CONF_DOMAIN,
CONF_ENTITY_ID,
CONF_TYPE,
)
from homeassistant.core import C... |
import numpy as np
import unittest
from chainer import testing
from chainercv.transforms import crop_bbox
class TestCropBbox(unittest.TestCase):
def setUp(self):
self.bbox = np.array((
(0, 0, 3, 4),
(0, 0, 5, 6),
(0, 5, 3, 6),
(1, 2, 3, 4),
(... |
import unittest
import numpy as np
from pgmpy.models import ClusterGraph
from pgmpy.tests import help_functions as hf
from pgmpy.factors.discrete import DiscreteFactor
class TestClusterGraphCreation(unittest.TestCase):
def setUp(self):
self.graph = ClusterGraph()
def test_add_single_node(self):
... |
import os, sys
nest = 0
def trace(frame, event, arg):
global nest
if nest is None:
# This can happen when Python is shutting down.
return None
print("%s%s %s %d @%d" % (
" " * nest,
event,
os.path.basename(frame.f_code.co_filename),
frame.f_lineno,
... |
import unittest
from trashcli.empty import EmptyCmd
from unit_tests.myStringIO import StringIO
import os
from .files import make_file, require_empty_dir, make_dirs, set_sticky_bit
from .files import make_empty_file
from mock import MagicMock
from trashcli.fs import FileSystemReader
from trashcli.fs import FileRemove... |
from dataclasses import dataclass, field
from .const import DOMAIN
from .device import BroadlinkDevice
@dataclass
class BroadlinkData:
"""Class for sharing data within the Broadlink integration."""
devices: dict = field(default_factory=dict)
platforms: dict = field(default_factory=dict)
async def asy... |
import numpy as np
from scipy.special import ndtr
from scattertext.Scalers import scale_neg_1_to_1_with_zero_mean_abs_max
from scattertext.termranking import AbsoluteFrequencyRanker
from scattertext.termsignificance.TermSignificance import TermSignificance
def z_to_p_val(z_scores):
# return norm.sf(-z_scores) - 0.... |
import numpy as np
import tensorflow as tf
from keras import layers, backend as K
from keras.losses import Loss
from keras.utils import losses_utils
class RankCrossEntropyLoss(Loss):
"""
Rank cross entropy loss.
Examples:
>>> from keras import backend as K
>>> softmax = lambda x: np.exp(... |
import unittest
import tensorflow as tf
import tensorflow_addons as tfa
class TestTensorflowAddons(unittest.TestCase):
def test_tfa_image(self):
img_raw = tf.io.read_file('/input/tests/data/dot.png')
img = tf.io.decode_image(img_raw)
img = tf.image.convert_image_dtype(img, tf.float32)
... |
import functools
import hmac
from passlib.hash import apr_md5_crypt
from radicale import auth
class Auth(auth.BaseAuth):
def __init__(self, configuration):
super().__init__(configuration)
self._filename = configuration.get("auth", "htpasswd_filename")
self._encoding = self.configuration... |
import genuiclasses
import genexamples
import gencommonast
def init():
print('GENERATING DOCS ...')
print(' Generating docs for UI classes.')
genuiclasses.main()
print(' Generating examples.')
genexamples.main()
def clean(app, *args):
genuiclasses.clean()
genexamples.clean()
de... |
import json
import logging
import os
import re
from typing import List, Optional
from absl import flags
from perfkitbenchmarker import configs
from perfkitbenchmarker import data
from perfkitbenchmarker import dpb_service
from perfkitbenchmarker import errors
from perfkitbenchmarker import sample
from perfkitbenchmar... |
import os
import stat as _stat
from six import text_type
from six.moves import builtins
from mlpatches import base
from stashutils.mount_ctrl import get_manager
from stashutils.fsi.errors import IsFile, OperationFailure
# store default functions
_org_listdir = os.listdir
_org_open = builtins.open
_org_chdir = os.... |
import errno
import collections
import logging
import os.path
import subprocess
import time
from ...common.interfaces import AbstractPlugin, GeneratorPlugin, AggregateResultListener, AbstractInfoWidget, \
StatsReader
from ...common.util import FileScanner
from ..Console import Plugin as ConsolePlugin
from ..Phant... |
from __future__ import (absolute_import, division, print_function,
unicode_literals)
import numpy as np
from numpy import dot
from filterpy.common import pretty_str
class FadingMemoryFilter(object):
""" Creates a fading memory filter of order 0, 1, or 2.
The KalmanFilter class also ... |
from threading import Event
import os
import pandas as pd
from yandextank.common.util import get_test_path
from yandextank.common.util import FileMultiReader
from yandextank.plugins.Phantom.reader import PhantomReader, PhantomStatsReader, string_to_df_microsec
from functools import reduce
class TestPhantomReader(ob... |
import logging
import queue
import json
from ..Telegraf.decoder import decoder
logger = logging.getLogger(__name__)
class MonitoringReader(object):
def __init__(self, source):
self.buffer = []
self.source = source
self.finished = False
self.prev_check = None
def __iter__(se... |
import os
import sys
def newexit():
os._exit(1)
def setup():
# We want to monkey patch sys.exit so that we can get some
# information about where exit is being called.
newexit._old = sys.exit
sys.exit = newexit
def teardown():
try:
sys.exit = sys.exit._old
except AttributeErro... |
import gc
import weakref
import asyncio
from pscript import this_is_js
from flexx import app, event
from flexx.util.testing import run_tests_if_main, raises, skip
from flexx.app.live_tester import run_live, roundtrip, launch
from flexx.event import loop
def setup_module():
app.manager._clear_old_pending_sess... |
import logging
from homeassistant.components.binary_sensor import BinarySensorEntity
from homeassistant.config_entries import ConfigEntry
from homeassistant.helpers.typing import HomeAssistantType
from .const import (
CONF_RELAY_ADDR,
CONF_RELAY_CHAN,
CONF_ZONE_LOOP,
CONF_ZONE_NAME,
CONF_ZONE_NUM... |
revision = '434c29e40511'
down_revision = '8323a5ea723a'
from alembic import op
import sqlalchemy as sa
def upgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.add_column('certificates', sa.Column('key_type', sa.String(length=128), nullable=True))
# ### end Alembic commands ###
... |
import typing
import pandas as pd
import collections.abc
from matchzoo.engine.param import Param
from matchzoo.engine import hyper_spaces
class ParamTable(object):
"""
Parameter table class.
Example:
>>> params = ParamTable()
>>> params.add(Param('ham', 'Parma Ham'))
>>> params... |
import pytest
import voluptuous as vol
from homeassistant.auth.permissions.entities import (
ENTITY_POLICY_SCHEMA,
compile_entities,
)
from homeassistant.auth.permissions.models import PermissionLookup
from homeassistant.helpers.device_registry import DeviceEntry
from homeassistant.helpers.entity_registry imp... |
import os
import time
import unittest
import mock
from kalliope.core.NeuronModule import NeuronModule, MissingParameterException, InvalidParameterException
from kalliope.neurons.script.script import Script
class TestScript(unittest.TestCase):
def setUp(self):
self.path = "path"
self.random = "r... |
from absl import flags
from perfkitbenchmarker import configs
from perfkitbenchmarker import vm_util
from perfkitbenchmarker.linux_packages import redis_enterprise
FLAGS = flags.FLAGS
BENCHMARK_NAME = 'redis_enterprise'
REDIS_PORT = 12006
REDIS_UI_PORT = 8443
BENCHMARK_CONFIG = """
redis_enterprise:
description:... |
import inspect
import os
import pkg_resources
import sys
__version__ = pkg_resources.get_distribution('chainercv').version
on_rtd = os.environ.get('READTHEDOCS', None) == 'True'
rtd_version = os.environ.get('READTHEDOCS_VERSION')
if rtd_version == 'latest':
tag = 'master'
else:
tag = 'v{}'.format(__version... |
import logging
import telnetlib
import voluptuous as vol
from homeassistant.components.media_player import PLATFORM_SCHEMA, MediaPlayerEntity
from homeassistant.components.media_player.const import (
SUPPORT_NEXT_TRACK,
SUPPORT_PAUSE,
SUPPORT_PLAY,
SUPPORT_PREVIOUS_TRACK,
SUPPORT_SELECT_SOURCE,
... |
from typing import List
from aiohomekit.model.characteristics import CharacteristicsTypes
from aiohomekit.model.characteristics.const import InputEventValues
from aiohomekit.model.services import ServicesTypes
from aiohomekit.utils import clamp_enum_to_char
import voluptuous as vol
from homeassistant.components.auto... |
from abc import abstractmethod
import logging
from homeassistant.components.binary_sensor import (
DEVICE_CLASS_CONNECTIVITY,
DEVICE_CLASS_MOISTURE,
BinarySensorEntity,
)
from homeassistant.core import callback
from homeassistant.helpers.dispatcher import async_dispatcher_connect
from .const import (
... |
from django.urls import reverse
from weblate.trans.tests.test_views import ViewTestCase
class GitNoChangeProjectTest(ViewTestCase):
"""Testing of git manipulations with no change in repo."""
TEST_TYPE = "project"
def setUp(self):
super().setUp()
# We need extra privileges for overwriti... |
from trashcli.put import TrashPutCmd
import os
from os.path import exists as file_exists
from datetime import datetime
from .files import make_empty_file, require_empty_dir
from .files import make_sticky_dir
from trashcli.fstab import FakeFstab
from trashcli.fs import remove_file
from trashcli.put import parent_path... |
from homeassistant.components.sensor import DOMAIN
from homeassistant.exceptions import PlatformNotReady
from . import CONF_MONITORED_CONDITIONS, DATA_KEY, LTEEntity
from .sensor_types import SENSOR_SMS, SENSOR_SMS_TOTAL, SENSOR_UNITS, SENSOR_USAGE
async def async_setup_platform(hass, config, async_add_entities, di... |
from subliminal.matches import guess_matches
def test_guess_matches_movie(movies):
video = movies['man_of_steel']
guess = {'title': video.title.upper(), 'year': video.year, 'release_group': video.release_group.upper(),
'screen_size': video.resolution, 'source': video.source, 'video_codec': video... |
import heapq
import sys
from collections import namedtuple
from datetime import datetime
from functools import total_ordering
from weakref import proxy as weakrefproxy
from time import monotonic
from vine.utils import wraps
from kombu.log import get_logger
from time import time as _time
try:
from pytz import u... |
from __future__ import absolute_import
import logging
import time
from absl import flags
import boto
import gcs_oauth2_boto_plugin # noqa
# This is the path that we SCP object_storage_interface to.
from providers import object_storage_interface
FLAGS = flags.FLAGS
class GcsServiceBoto(object_storage_interface.Ob... |
import logging
import time
from scrapy.dupefilters import BaseDupeFilter
from scrapy.utils.request import request_fingerprint
from . import defaults
from .connection import get_redis_from_settings
logger = logging.getLogger(__name__)
# TODO: Rename class to RedisDupeFilter.
class RFPDupeFilter(BaseDupeFilter):
... |
import logging
from pprint import pformat
from homeassistant.components.supla import (
DOMAIN,
SUPLA_COORDINATORS,
SUPLA_SERVERS,
SuplaChannel,
)
from homeassistant.components.switch import SwitchEntity
_LOGGER = logging.getLogger(__name__)
async def async_setup_platform(hass, config, async_add_ent... |
import unittest
from hyperopt import fmin, tpe, hp
class TestHyperopt(unittest.TestCase):
def test_find_min(self):
best = fmin(
fn=lambda x: x ** 2,
space=hp.uniform('x', -10, 10),
algo=tpe.suggest,
max_evals=1,
)
self.assertIn('x', best)
|
from copy import deepcopy
from io import StringIO
import os.path as op
from datetime import datetime, timezone
import numpy as np
from numpy.testing import assert_array_equal, assert_allclose
import pytest
from scipy import sparse
from mne import read_evokeds, read_cov, pick_types
from mne.io.pick import _picks_by_t... |
import unittest
import numpy as np
from chainer import testing
from chainercv.transforms import flip_bbox
from chainercv.utils.testing.generate_random_bbox import generate_random_bbox
class TestFlipBbox(unittest.TestCase):
def test_flip_bbox(self):
size = (32, 24)
bbox = generate_random_bbox(1... |
from datetime import timedelta
import logging
import nikohomecontrol
import voluptuous as vol
# Import the device class from the component that you want to support
from homeassistant.components.light import ATTR_BRIGHTNESS, PLATFORM_SCHEMA, LightEntity
from homeassistant.const import CONF_HOST
from homeassistant.exc... |
from __future__ import absolute_import
import datetime
import json
import logging
import os.path
import sys
from subprocess import check_output
from setuptools import Command
from setuptools import setup, find_packages
from setuptools.command.develop import develop
from setuptools.command.install import install
from... |
from aiohttp import web
from homeassistant.components.cloud import utils
def test_serialize_text():
"""Test serializing a text response."""
response = web.Response(status=201, text="Hello")
assert utils.aiohttp_serialize_response(response) == {
"status": 201,
"body": "Hello",
"he... |
import logging
import unittest
import numpy as np
from gensim.test.utils import datapath
from gensim.models.keyedvectors import KeyedVectors
class TestDataType(unittest.TestCase):
def load_model(self, datatype):
path = datapath('high_precision.kv.txt')
kv = KeyedVectors.load_word2vec_format(pat... |
import logging
import requests
import voluptuous as vol
from homeassistant.components.device_tracker import (
DOMAIN,
PLATFORM_SCHEMA,
DeviceScanner,
)
from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME, HTTP_OK
import homeassistant.helpers.config_validation as cv
_LOGGER = logging.... |
from datetime import timedelta
from homeassistant.components.bluetooth_le_tracker import device_tracker
from homeassistant.components.device_tracker.const import (
CONF_SCAN_INTERVAL,
CONF_TRACK_NEW,
DOMAIN,
)
from homeassistant.const import CONF_PLATFORM
from homeassistant.setup import async_setup_compon... |
from datetime import timedelta
from homeassistant import data_entry_flow
from homeassistant.components.geonetnz_volcano import config_flow
from homeassistant.const import (
CONF_LATITUDE,
CONF_LONGITUDE,
CONF_RADIUS,
CONF_SCAN_INTERVAL,
CONF_UNIT_SYSTEM,
)
from tests.async_mock import patch
asy... |
import os
import unittest
import memcached_slab
fixtures = os.path.join(os.path.dirname(__file__), 'fixtures', 'stats')
with open(fixtures, 'rb') as f:
RAW_SLAB_STATS = f.read()
class MemcachedSlabCollectorTestCase(unittest.TestCase):
def test_dict_to_paths(self):
dict_ = {
'foo': {
... |
from axis.event_stream import CLASS_LIGHT
from homeassistant.components.light import (
ATTR_BRIGHTNESS,
SUPPORT_BRIGHTNESS,
LightEntity,
)
from homeassistant.core import callback
from homeassistant.helpers.dispatcher import async_dispatcher_connect
from .axis_base import AxisEventBase
from .const import ... |
from __future__ import print_function
import random
import string
from datetime import datetime as dt
import pytest
import six
import arctic._compression as c
try:
from lz4.block import compress as lz4_compress, decompress as lz4_decompress
lz4_compressHC = lambda _str: lz4_compress(_str, mode='high_compre... |
import asyncio
import logging
from types import MappingProxyType
from typing import Any, Callable, Dict, List, Optional, Union
import voluptuous as vol
from homeassistant.const import CONF_PLATFORM
from homeassistant.core import CALLBACK_TYPE, callback
from homeassistant.helpers.typing import ConfigType, HomeAssista... |
from homeassistant.components.light import (
ATTR_BRIGHTNESS,
ATTR_COLOR_TEMP,
ATTR_HS_COLOR,
SUPPORT_BRIGHTNESS,
SUPPORT_COLOR,
SUPPORT_COLOR_TEMP,
LightEntity,
)
import homeassistant.util.color as color_util
from . import DATA_HIVE, DOMAIN, HiveEntity, refresh_system
def setup_platform... |
import contextlib
import functools
from datetime import datetime, timedelta
from itertools import chain, zip_longest
from typing import Hashable
import numpy as np
import pandas as pd
from pandas.errors import OutOfBoundsDatetime
from .duck_array_ops import array_equiv
from .options import OPTIONS
from .pycompat imp... |
from pylatex import Document, LongTabu, HFill
from pylatex.utils import bold
def genenerate_longtabu():
geometry_options = {
"landscape": True,
"margin": "0.5in",
"headheight": "20pt",
"headsep": "10pt",
"includeheadfoot": True
}
doc = Document(page_numbers=True, g... |
import mock
from docker_registry.lib import checksums
from tests.base import TestCase
class TestShaMethods(TestCase):
def test_sha256_file(self):
self.assertEqual(
checksums.sha256_file(None, None),
'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855')
self... |
import re
from pyparsing import Optional, QuotedString, Regex, ZeroOrMore
def single_value_flag(func):
def parse_values(val):
if not val:
raise ValueError("Missing required parameter")
if len(val) > 1:
raise ValueError("Too many parameters")
return func(val[0])
... |
import logging
from typing import List, Optional
import voluptuous as vol
from homeassistant.components.climate import ClimateEntity
from homeassistant.components.climate.const import (
CURRENT_HVAC_HEAT,
CURRENT_HVAC_IDLE,
DEFAULT_MIN_TEMP,
HVAC_MODE_AUTO,
HVAC_MODE_HEAT,
HVAC_MODE_OFF,
... |
import sys
from paasta_tools.cli.utils import lazy_choices_completer
from paasta_tools.cli.utils import list_deploy_groups
from paasta_tools.cli.utils import PaastaColors
from paasta_tools.cli.utils import validate_service_name
from paasta_tools.deployment_utils import load_v2_deployments_json
from paasta_tools.utils... |
from unittest import TestCase
from scattertext.characteristic.DenseRankCharacteristicness import DenseRankCharacteristicness
from scattertext.test.test_TermDocMat import get_hamlet_term_doc_matrix
class TestDenseRankCharacteristicness(TestCase):
def test_get_scores(self):
c = get_hamlet_term_doc_matrix()
zero_... |
import pytest
@pytest.mark.parametrize("patterns,filename,expected_match", [
([r'*.csv'], 'foo.csv', True),
([r'*.cvs'], 'foo.csv', False),
([r'*.csv *.xml'], 'foo.csv', True),
([r'*.csv *.xml'], 'foo.xml', True),
([r'*.csv', r'*.xml'], 'foo.csv', True),
([r'*.csv', r'*.xml'], 'foo.xml', True... |
import argparse
import matplotlib.pyplot as plt
import chainer
from chainercv.datasets import ade20k_semantic_segmentation_label_colors
from chainercv.datasets import ade20k_semantic_segmentation_label_names
from chainercv.datasets import cityscapes_semantic_segmentation_label_colors
from chainercv.datasets import ... |
from __future__ import unicode_literals
from rules.BaseTrick import wordshaper
def SingleRule(cname, ename, sname, birth, usedpwd, phone, uphone, hphone, email, postcode, nickname, idcard, jobnum,
otherdate, usedchar):
for _ in wordshaper(cname, ename, sname, usedpwd, email, nickname, usedchar):
... |
import argparse
import json
from pathlib import Path
import re
from shutil import rmtree
import sys
from . import download, upload
from .const import INTEGRATIONS_DIR
from .util import get_base_arg_parser
def valid_integration(integration):
"""Test if it's a valid integration."""
if not (INTEGRATIONS_DIR / ... |
import aiopulse
import pytest
from homeassistant import data_entry_flow
from homeassistant.components.acmeda.const import DOMAIN
from homeassistant.config_entries import SOURCE_USER
from homeassistant.const import CONF_HOST
from tests.async_mock import patch
from tests.common import MockConfigEntry
DUMMY_HOST1 = "1... |
from .base import Variable
import itertools
class InteractionType(Variable):
type = "Interaction"
def __init__(self, definition):
self.interactions = definition["interaction variables"]
self.name = "(Interaction: %s)" % str(self.interactions)
self.interaction_fields = self.interact... |
from ...utils import verbose
from ..utils import (_data_path, _data_path_doc,
_get_version, _version_doc)
@verbose
def data_path(path=None, force_update=False, update_path=False,
download=True, verbose=None): # noqa: D103
return _data_path(path=path, force_update=force_update,... |
from homeassistant.components.binary_sensor import BinarySensorEntity
from . import VelbusEntity
from .const import DOMAIN
async def async_setup_entry(hass, entry, async_add_entities):
"""Set up Velbus binary sensor based on config_entry."""
cntrl = hass.data[DOMAIN][entry.entry_id]["cntrl"]
modules_dat... |
from homeassistant.components.cloud.const import DISPATCHER_REMOTE_UPDATE
from homeassistant.setup import async_setup_component
from tests.async_mock import Mock, patch
async def test_remote_connection_sensor(hass):
"""Test the remote connection sensor."""
assert await async_setup_component(hass, "cloud", {... |
from homeassistant.components.awair.const import (
API_CO2,
API_HUMID,
API_LUX,
API_PM10,
API_PM25,
API_SCORE,
API_SPL_A,
API_TEMP,
API_VOC,
ATTR_UNIQUE_ID,
DOMAIN,
SENSOR_TYPES,
)
from homeassistant.const import (
ATTR_ICON,
ATTR_UNIT_OF_MEASUREMENT,
CONCENT... |
from Handler import Handler
import logging
try:
from riemann_client.transport import TCPTransport, UDPTransport
from riemann_client.client import Client
riemann_client = True
except ImportError:
riemann_client = None
class RiemannHandler(Handler):
def __init__(self, config=None):
# Init... |
import mock
import pytest
from addict import Dict
from paasta_tools import utils
from paasta_tools.frameworks import adhoc_scheduler
from paasta_tools.frameworks import native_scheduler
from paasta_tools.frameworks.native_service_config import NativeServiceConfig
from paasta_tools.frameworks.native_service_config imp... |
from plumbum import cli
class Main3Validator(cli.Application):
def main(self, myint:int, myint2:int, *mylist:int):
print(myint, myint2, mylist)
class TestProg3:
def test_prog(self, capsys):
_, rc = Main3Validator.run(["prog", "1", "2", '3', '4', '5'], exit = False)
assert rc == 0
... |
import os.path
import pytest
pytest.importorskip('PyQt5.QtWebEngineWidgets')
from qutebrowser.browser.webengine import webenginedownloads
@pytest.mark.parametrize('path, expected', [
(os.path.join('subfolder', 'foo'), 'foo'),
('foo(1)', 'foo'),
('foo (1)', 'foo'),
('foo - 1970-01-01T00:00:00.000Z'... |
from __future__ import print_function
__docformat__ = "restructuredtext en"
# modified copy of some functions from test/regrtest.py from PyXml
# disable camel case warning
# pylint: disable=C0103
from contextlib import contextmanager
import sys
import os, os.path as osp
import re
import difflib
import tempfile
impor... |
import abc
import logging
import uuid
from threading import RLock, Event
from concurrent.futures import ThreadPoolExecutor, wait, ALL_COMPLETED, FIRST_EXCEPTION
from six import iteritems, itervalues
from arctic._config import ARCTIC_ASYNC_NWORKERS
from arctic.exceptions import AsyncArcticException
ABC = abc.ABCMeta... |
import numpy as np
from numpy.testing import assert_allclose
import pytest
from mne._ola import _COLA, _Interp2, _Storer
def test_interp_2pt():
"""Test our two-point interpolator."""
n_pts = 200
assert n_pts % 50 == 0
feeds = [ # test a bunch of feeds to make sure they don't break things
[n... |
import datetime as dt
import logging
import re
from typing import Optional, Tuple
from homeassistant.components.media_player.const import (
MEDIA_CLASS_DIRECTORY,
MEDIA_CLASS_VIDEO,
MEDIA_TYPE_VIDEO,
)
from homeassistant.components.media_player.errors import BrowseError
from homeassistant.components.media... |
from datetime import timedelta
import logging
import defusedxml.ElementTree as ET
import voluptuous as vol
from homeassistant.const import CONF_DOMAIN, CONF_HOST, CONF_PASSWORD
from homeassistant.helpers.aiohttp_client import async_get_clientsession
import homeassistant.helpers.config_validation as cv
from homeassis... |
import os
from tempfile import NamedTemporaryFile
import pytest
from PIL import Image, ImageDraw
from nikola.plugins.task import scale_images
# These tests don't require valid profiles. They need only to verify
# that profile data is/isn't saved with images.
# It would be nice to use PIL.ImageCms to create valid pr... |
from datetime import timedelta
import logging
import async_timeout
from pyipma.api import IPMA_API
from pyipma.location import Location
import voluptuous as vol
from homeassistant.components.weather import (
ATTR_FORECAST_CONDITION,
ATTR_FORECAST_PRECIPITATION_PROBABILITY,
ATTR_FORECAST_TEMP,
ATTR_FO... |
import os
import unittest
import mock
from perfkitbenchmarker import test_util
from perfkitbenchmarker.linux_benchmarks import mnist_benchmark
from perfkitbenchmarker.linux_benchmarks import resnet_benchmark
from perfkitbenchmarker.sample import Sample
class ResNetBenchmarkTestCase(unittest.TestCase, test_util.Samp... |
from django.urls import reverse
from weblate.trans.models import Comment
from weblate.trans.tests.test_views import FixtureTestCase
class CommentViewTest(FixtureTestCase):
def setUp(self):
super().setUp()
self.translation = self.component.translation_set.get(language_code="cs")
def test_add... |
import logging
import unittest
import numpy as np
from gensim.corpora.dictionary import Dictionary
from gensim.topic_coherence import indirect_confirmation_measure
from gensim.topic_coherence import text_analysis
class TestIndirectConfirmation(unittest.TestCase):
def setUp(self):
# Set up toy example f... |
import asyncio
from datetime import timedelta
import logging
from canary.api import Api
from requests import ConnectTimeout, HTTPError
import voluptuous as vol
from homeassistant.components.camera.const import DOMAIN as CAMERA_DOMAIN
from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
from homeassist... |
import argparse
import matplotlib.pyplot as plt
import chainer
from chainercv.datasets import voc_bbox_label_names
from chainercv.links import SSD300
from chainercv.links import SSD512
from chainercv import utils
from chainercv.visualizations import vis_bbox
def main():
parser = argparse.ArgumentParser()
p... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import tensorflow as tf
from nets import nets_factory
slim = tf.contrib.slim
class NetworksTest(tf.test.TestCase):
def testGetNetworkFn(self):
batch_size = 5
num_classes = 1000
for net in ne... |
from homeassistant.components.fan import (
ATTR_DIRECTION,
ATTR_OSCILLATING,
ATTR_SPEED,
DOMAIN,
SERVICE_OSCILLATE,
SERVICE_SET_DIRECTION,
SERVICE_SET_SPEED,
)
from homeassistant.const import (
ATTR_ENTITY_ID,
ENTITY_MATCH_ALL,
SERVICE_TURN_OFF,
SERVICE_TURN_ON,
)
async de... |
import os
from contextlib import contextmanager
from yapsy.PluginManager import PluginManager
import nikola.utils
import nikola.shortcodes
from nikola.plugin_categories import (
Command,
Task,
LateTask,
TemplateSystem,
PageCompiler,
TaskMultiplier,
CompilerExtension,
MarkdownExtension... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.