text stringlengths 213 32.3k |
|---|
import logging
class AbstractPlugin(object):
""" Plugin interface
Parent class for all plugins """
SECTION = 'DEFAULT'
@staticmethod
def get_key():
""" Get dictionary key for plugin,
should point to __file__ magic constant """
raise TypeError("Abstract method needs to be... |
try:
import redis
except ImportError:
redis = None
from django.conf import settings
from django.dispatch import Signal
customer_recognized = Signal(providing_args=['customer', 'request'])
if redis and hasattr(settings, 'SESSION_REDIS'):
redis_con = dict((key, settings.SESSION_REDIS[key]) for key in ['ho... |
import asyncio
import http.server
import threading
from typing import List
import mock
from behave import given
from behave import then
from behave import when
from paasta_tools import drain_lib
@given("a fake HTTP server")
def make_fake_http_server(context):
context.fake_http_server = FakeHTTPServer()
con... |
import json
from django.contrib import messages as django_messages
from django.utils.encoding import force_str
def add_message(request, level, message, title=None, delay=None):
if title is None:
title = django_messages.DEFAULT_TAGS[level].capitalize()
extra_tags = {'title': force_str(title), 'delay':... |
import sys
import cherrypy
from cherrypy._cpcompat import ntob
from cherrypy.test import helper
class WSGIGraftTests(helper.CPWebCase):
@staticmethod
def setup_server():
def test_app(environ, start_response):
status = '200 OK'
response_headers = [('Content-type', 'text/plai... |
from homeassistant.components.switch import DOMAIN, SwitchEntity
from homeassistant.util import convert
from . import FIBARO_DEVICES, FibaroDevice
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the Fibaro switches."""
if discovery_info is None:
return
add_entitie... |
from datetime import timedelta
from django.db.models import Q, Sum
from django.utils import timezone
from django.utils.translation import gettext_lazy as _
from weblate.addons.base import BaseAddon
from weblate.addons.events import EVENT_DAILY
from weblate.addons.forms import RemoveForm, RemoveSuggestionForm
from we... |
import logging
from kalliope.core.Cortex import Cortex
from kalliope.core.NeuronLauncher import NeuronLauncher
from kalliope.core.Models.APIResponse import APIResponse
logging.basicConfig()
logger = logging.getLogger("kalliope")
class Serialize(Exception):
"""
When raised, the LIFO class return the current... |
import logging
import voluptuous as vol
import voluptuous_serialize
from homeassistant import data_entry_flow
from homeassistant.components import websocket_api
from homeassistant.core import HomeAssistant, callback
WS_TYPE_SETUP_MFA = "auth/setup_mfa"
SCHEMA_WS_SETUP_MFA = websocket_api.BASE_COMMAND_MESSAGE_SCHEMA... |
import contextlib
import datetime
import functools
import glob
import os
import os.path
import random
import re
import shlex
import sys
import types
import pytest
from unittest_mixins import (
EnvironmentAwareMixin, StdStreamCapturingMixin, TempDirMixin,
DelayedAssertionMixin,
)
import coverage
from coverage... |
import unittest
import time
from common import gpu_test
class TestJAX(unittest.TestCase):
def tanh(self, x):
import jax.numpy as np
y = np.exp(-2.0 * x)
return (1.0 - y) / (1.0 + y)
@gpu_test
def test_JAX(self):
# importing inside the gpu-only test because these package... |
from datetime import timedelta
import logging
from netdata import Netdata
from netdata.exceptions import NetdataError
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import (
CONF_HOST,
CONF_ICON,
CONF_NAME,
CONF_PORT,
CONF_RESOURCES,
... |
from test import CollectorTestCase
from test import get_collector_config
from test import unittest
from celerymon import CelerymonCollector
###############################################################################
class TestCelerymonCollector(CollectorTestCase):
def setUp(self):
config = get_col... |
from django.db import transaction
class atomic_if_using_transaction:
"""Context manager wraps `atomic` if `using_transactions`.
Replaces code::
if using_transactions:
with transaction.atomic():
return something()
return something()
"""
def __init__(self, ... |
import diamond.collector
import os
import subprocess
from diamond.collector import str_to_bool
class UPSCollector(diamond.collector.Collector):
def get_default_config_help(self):
config_help = super(UPSCollector, self).get_default_config_help()
config_help.update({
'ups_name': 'Th... |
import logging
import threading
from pushbullet import InvalidKeyError, Listener, PushBullet
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import CONF_API_KEY, CONF_MONITORED_CONDITIONS
import homeassistant.helpers.config_validation as cv
from homeassis... |
import diamond.collector
import os
import re
import subprocess
from diamond.collector import str_to_bool
class PassengerCollector(diamond.collector.Collector):
"""
Collect Memory and CPU Utilization for Passenger
"""
def get_default_config_help(self):
"""
Return help text
"""... |
from datetime import timedelta
import logging
import pyiss
import requests
import voluptuous as vol
from homeassistant.components.binary_sensor import PLATFORM_SCHEMA, BinarySensorEntity
from homeassistant.const import (
ATTR_LATITUDE,
ATTR_LONGITUDE,
CONF_NAME,
CONF_SHOW_ON_MAP,
)
import homeassista... |
import logging
from absl import flags
from perfkitbenchmarker import configs
from perfkitbenchmarker import regex_util
from perfkitbenchmarker import sample
from perfkitbenchmarker.linux_benchmarks import mnist_benchmark
FLAGS = flags.FLAGS
BENCHMARK_NAME = 'tensor2tensor'
BENCHMARK_CONFIG = """
tensor2tensor:
des... |
from homeassistant.components import mysensors
from homeassistant.components.binary_sensor import (
DEVICE_CLASS_MOISTURE,
DEVICE_CLASS_MOTION,
DEVICE_CLASS_SAFETY,
DEVICE_CLASS_SOUND,
DEVICE_CLASS_VIBRATION,
DEVICE_CLASSES,
DOMAIN,
BinarySensorEntity,
)
from homeassistant.const import ... |
import pytest
from qutebrowser.utils import usertypes
@pytest.fixture
def question():
return usertypes.Question()
def test_attributes(question):
"""Test setting attributes."""
question.default = True
question.text = "foo"
def test_mode(question):
"""Test setting mode to valid members."""
... |
import os
from perfkitbenchmarker import object_storage_service
AZURE_CREDENTIAL_DIRECTORY = os.path.join('~', '.azure')
AZURE_CREDENTIAL_TOKENS_FILE = os.path.join(AZURE_CREDENTIAL_DIRECTORY,
'accessTokens.json')
AZURE_CREDENTIAL_PROFILE_FILE = os.path.join(AZURE_CREDENTI... |
import asyncio
import logging
from typing import Any, Awaitable, Dict, List, Optional
from homeassistant.core import CALLBACK_TYPE, Event, callback
from homeassistant.helpers import entity
from homeassistant.helpers.device_registry import CONNECTION_ZIGBEE
from homeassistant.helpers.dispatcher import (
async_disp... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import getopt
import os
import re
import sys
import types
import warnings
from absl.flags import _argument_parser
from absl.flags import _defines
from absl.flags import _exceptions
from absl.flags import _fla... |
import json
import os.path
import requests
import socket
import sys
from base64 import b64decode
from bs4 import BeautifulSoup as bs
from httpobs.conf import (SCANNER_ALLOW_LOCALHOST,
SCANNER_PINNED_DOMAINS)
from requests.structures import CaseInsensitiveDict
HSTS_URL = ('https://chromium.... |
import numpy as np
from tensornetwork.block_sparse.charge import BaseCharge, fuse_charges
import copy
from typing import List, Union
class Index:
"""
An index class to store indices of a symmetric tensor.
"""
def __init__(self, charges: Union[List[BaseCharge], BaseCharge],
flow: Union[List[bo... |
from homeassistant.components.binary_sensor import DEVICE_CLASSES, BinarySensorEntity
from tests.common import MockEntity
ENTITIES = {}
def init(empty=False):
"""Initialize the platform with entities."""
global ENTITIES
ENTITIES = (
{}
if empty
else {
device_class: ... |
import re
from typing import List, Optional
from xbox.webapi.api.client import XboxLiveClient
from xbox.webapi.api.provider.catalog.models import Image
from xbox.webapi.api.provider.smartglass.models import (
PlaybackState,
PowerState,
SmartglassConsole,
SmartglassConsoleList,
VolumeDirection,
)
... |
from datetime import datetime, timezone
import humanize
from dateutil.tz import tzlocal
class Tweet:
"""A :class:`Tweet` represents a single tweet.
:param str text: text of the tweet in raw format
:param ~datetime.datetime created_at: (optional) when the tweet was created, defaults to :meth:`~datetime.... |
import logging
import gammu # pylint: disable=import-error, no-member
import voluptuous as vol
from homeassistant import config_entries, core, exceptions
from homeassistant.const import CONF_DEVICE
from .const import DOMAIN # pylint:disable=unused-import
from .gateway import create_sms_gateway
_LOGGER = logging.... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from absl import logging
from compare_gan.architectures import arch_ops
import gin
import numpy as np
import tensorflow as tf
class ArchOpsTpuTest(tf.test.TestCase):
def setUp(self):
# Construct input... |
from pygal.graph.graph import Graph
from pygal.util import alter, cached_property, decorate
class Line(Graph):
"""Line graph class"""
def __init__(self, *args, **kwargs):
"""Set _self_close as False, it's True for Radar like Line"""
self._self_close = False
super(Line, self).__init__... |
from test import CollectorTestCase
from test import get_collector_config
from test import unittest
from mock import Mock
from mock import patch
from diamond.collector import Collector
from monit import MonitCollector
##########################################################################
class TestMonitCollect... |
import inspect
from django.db import models
from django.utils.encoding import force_text
from django.utils.html import strip_tags
def skip_model_member(app, what, name, obj, skip, options):
# These fields always fails !
if name in ('tags', 'image'):
return True
return skip
def process_model_do... |
import numpy as np
import pandas as pd
from pdpbox import pdp
import unittest
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
class TestPdpbox(unittest.TestCase):
def test_simple_pdp(self):
# set up data
data = pd.read_csv("/input/tests/data/fif... |
import numpy as np
from scipy import linalg
from .. import EvokedArray, Evoked
from ..cov import Covariance, _regularized_covariance
from ..decoding import TransformerMixin, BaseEstimator
from ..epochs import BaseEpochs
from ..io import BaseRaw
from ..io.pick import _pick_data_channels, pick_info
from ..utils import ... |
from unittest import TestCase
from scattertext.Formatter import large_int_format
class TestLarge_int_format(TestCase):
def test_large_int_format(self):
self.assertEqual(large_int_format(1), '1')
self.assertEqual(large_int_format(6), '6')
self.assertEqual(large_int_format(10), '10')
self.assertEqual(large_i... |
from paasta_tools.autoscaling import load_boost
from paasta_tools.cli.utils import execute_paasta_cluster_boost_on_remote_master
from paasta_tools.cli.utils import lazy_choices_completer
from paasta_tools.utils import DEFAULT_SOA_DIR
from paasta_tools.utils import list_clusters
from paasta_tools.utils import load_syst... |
import logging
import pytest
import voluptuous as vol
from homeassistant.helpers import collection, entity, entity_component, storage
from tests.common import flush_store
_LOGGER = logging.getLogger(__name__)
def track_changes(coll: collection.ObservableCollection):
"""Create helper to track changes in a col... |
import socket
from contextlib import contextmanager
from functools import partial
from itertools import count
from time import sleep
from .common import ignore_errors
from .messaging import Consumer, Producer
from .log import get_logger
from .utils.compat import nested
from .utils.encoding import safe_repr
from .uti... |
from homeassistant.components.ring import DOMAIN
from homeassistant.setup import async_setup_component
from tests.async_mock import patch
from tests.common import MockConfigEntry
async def setup_platform(hass, platform):
"""Set up the ring platform and prerequisites."""
MockConfigEntry(domain=DOMAIN, data={... |
from datetime import datetime as dt
import tzlocal
from mock import patch
from pytest import raises
from arctic.date import mktz, TimezoneError
DEFAULT_TIME_ZONE_NAME = tzlocal.get_localzone().zone # 'Europe/London'
def test_mktz():
tz = mktz("Europe/London")
d = dt(2012, 2, 2, tzinfo=tz)
assert d.tz... |
from weblate.trans.models import ContributorAgreement
from weblate.trans.tests.test_views import FixtureTestCase
class AgreementTest(FixtureTestCase):
def test_basic(self):
self.assertFalse(
ContributorAgreement.objects.has_agreed(self.user, self.component)
)
ContributorAgreem... |
from os import path
from homeassistant import config as hass_config
import homeassistant.components.notify as notify
from homeassistant.components.telegram import DOMAIN
from homeassistant.const import SERVICE_RELOAD
from homeassistant.setup import async_setup_component
from tests.async_mock import patch
async def... |
import logging
import numpy as np
import numpy.ma as ma
import pandas as pd
from bson import Binary, SON
from .._compression import compress, decompress, compress_array
from ._serializer import Serializer
try:
from pandas.api.types import infer_dtype
except ImportError:
from pandas.lib import infer_dtype
t... |
import asyncio
from datetime import timedelta
import logging
from typing import Any, Dict
from wled import WLED, Device as WLEDDevice, WLEDConnectionError, WLEDError
from homeassistant.components.light import DOMAIN as LIGHT_DOMAIN
from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
from homeassistan... |
from homeassistant import config_entries, setup
from homeassistant.components.ozw.config_flow import TITLE
from homeassistant.components.ozw.const import DOMAIN
from tests.async_mock import patch
from tests.common import MockConfigEntry
async def test_user_create_entry(hass):
"""Test the user step creates an en... |
import functools
import io
import os
from distutils.version import LooseVersion
import numpy as np
from ..core import indexing
from ..core.utils import FrozenDict, is_remote_uri, read_magic_number
from ..core.variable import Variable
from .common import BackendEntrypoint, WritableCFDataStore, find_root_and_group
fro... |
from datetime import datetime, timedelta
import logging
from typing import Callable, Dict, Optional, Union
import herepy
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import (
ATTR_ATTRIBUTION,
ATTR_LATITUDE,
ATTR_LONGITUDE,
ATTR_MODE,
... |
from datetime import datetime as dt
from mock import create_autospec
from pandas.util.testing import assert_frame_equal
from arctic.store.bitemporal_store import BitemporalStore
from tests.util import read_str_as_pandas
ts1 = read_str_as_pandas(""" sample_dt | near
2012-09-08 17:0... |
from homeassistant.components.cover import (
ATTR_POSITION,
ATTR_TILT_POSITION,
DEVICE_CLASS_GARAGE,
CoverEntity,
)
from .const import ATTR_DEVICE_TYPE, ATTR_DISCOVER_DEVICES
from .entity import HMDevice
HM_GARAGE = ("IPGarage",)
def setup_platform(hass, config, add_entities, discovery_info=None):
... |
import mock
from kubernetes.client import V1DeleteOptions
from pysensu_yelp import Status
from paasta_tools.kubernetes.bin.kubernetes_remove_evicted_pods import (
evicted_pods_per_service,
)
from paasta_tools.kubernetes.bin.kubernetes_remove_evicted_pods import EvictedPod
from paasta_tools.kubernetes.bin.kubernet... |
import asyncio
from unittest.mock import Mock
import pytest
from homeassistant.setup import async_setup_component
from tests.common import mock_coro
@pytest.fixture
def mock_system_info(hass):
"""Mock system info."""
hass.helpers.system_info.async_get_system_info = Mock(
return_value=mock_coro({"h... |
from sense_hat import SenseHat
import voluptuous as vol
from homeassistant.components.light import (
ATTR_BRIGHTNESS,
ATTR_HS_COLOR,
PLATFORM_SCHEMA,
SUPPORT_BRIGHTNESS,
SUPPORT_COLOR,
LightEntity,
)
from homeassistant.const import CONF_NAME
import homeassistant.helpers.config_validation as cv... |
import diamond.collector
import subprocess
import os
from diamond.collector import str_to_bool
class EximCollector(diamond.collector.Collector):
def get_default_config_help(self):
config_help = super(EximCollector, self).get_default_config_help()
config_help.update({
'bin': '... |
from typing import Dict, Tuple
import cairo
from gi.repository import Gdk, GdkPixbuf, GObject, Gtk
class EmblemCellRenderer(Gtk.CellRenderer):
__gtype_name__ = "EmblemCellRenderer"
icon_cache: Dict[Tuple[str, int], GdkPixbuf.Pixbuf] = {}
icon_name = GObject.Property(
type=str,
nick='N... |
import errno
from contextlib import contextmanager
from queue import Empty
from time import sleep
from types import GeneratorType as generator # noqa
from kombu.log import get_logger
from kombu.utils.compat import fileno
from kombu.utils.eventio import ERR, READ, WRITE, poll
from kombu.utils.objects import cached_pr... |
import copy
from functools import wraps
import logging
import time
from bluepy.btle import ( # pylint: disable=import-error, no-member, no-name-in-module
BTLEException,
)
import decora # pylint: disable=import-error, no-member
import voluptuous as vol
from homeassistant.components.light import (
ATTR_BRIGH... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import random
import subprocess
from absl import flags
from absl.testing import _bazelize_command
from absl.testing import absltest
from absl.testing import parameterized
FLAGS = flags.FLAGS
clas... |
try:
import ast
from _markerlib.markers import default_environment, compile, interpret
except ImportError:
if 'ast' in globals():
raise
def default_environment():
return {}
def compile(marker):
def marker_fn(environment=None, override=None):
# 'empty markers are ... |
from math import log, pi, sqrt
def erfinv(x, a=.147):
"""Approximation of the inverse error function
https://en.wikipedia.org/wiki/Error_function
#Approximation_with_elementary_functions
"""
lnx = log(1 - x * x)
part1 = (2 / (a * pi) + lnx / 2)
part2 = lnx / a
sgn = 1 if x > 0 else -1... |
from datetime import timedelta
import logging
from typing import Dict
from pycfdns import CloudflareUpdater
from pycfdns.exceptions import (
CloudflareAuthenticationException,
CloudflareConnectionException,
CloudflareException,
)
import voluptuous as vol
from homeassistant.components import persistent_no... |
import tensornetwork as tn
import pytest
import numpy as np
def assert_nodes_eq(a, b):
assert type(a) == type(b) #pylint: disable=unidiomatic-typecheck
assert getattr(a, 'name', None) == getattr(b, 'name', None)
assert getattr(a, 'axis_names', None) == getattr(b, 'axis_names', None)
assert getattr(a, 'backe... |
import logging
import unittest
import os
import numpy
from gensim.models.wrappers import wordrank
from gensim.test.utils import datapath, get_tmpfile
class TestWordrank(unittest.TestCase):
def setUp(self):
wr_home = os.environ.get('WR_HOME', None)
self.wr_path = wr_home if wr_home else None
... |
import urwid
class CursorPudding(urwid.Widget):
_sizing = frozenset(['flow'])
_selectable = True
def __init__(self):
self.cursor_col = 0
def rows(self, size, focus=False):
return 1
def render(self, size, focus=False):
(maxcol,) = size
num_pudding = maxcol / len("... |
import warnings
from django.test import TestCase
from zinnia.spam_checker import get_spam_checker
from zinnia.spam_checker.backends.all_is_spam import backend
class SpamCheckerTestCase(TestCase):
"""Test cases for zinnia.spam_checker"""
def test_get_spam_checker(self):
with warnings.catch_warnings... |
import sys
from re import compile as re
from ._compat import StringIO
from .environment import env
encoding = re(r'#.*coding[:=]\s*([-\w.]+)')
def run_code():
""" Run python code in current buffer.
:returns: None
"""
errors, err = [], ''
line1, line2 = env.var('a:line1'), env.var('a:line2')
... |
import unittest, sys
from .common_imports import (
etree, html, BytesIO, _bytes, _str,
HelperTestCase, make_doctest, skipIf,
fileInTestDir, fileUrlInTestDir
)
class ETreeDtdTestCase(HelperTestCase):
def test_dtd(self):
pass
def test_dtd_file(self):
parse = etree.parse
tr... |
import json
import logging
import string
import threading
from perfkitbenchmarker import disk
from perfkitbenchmarker import vm_util
from perfkitbenchmarker.configs import option_decoders
from perfkitbenchmarker.providers import aws
from perfkitbenchmarker.providers.aws import util
VOLUME_EXISTS_STATUSES = frozenset... |
from __future__ import division
import numpy as np
import unittest
import chainer
from chainer import testing
from chainer.testing import attr
from chainercv.links.model.fpn import mask_head_loss_post
from chainercv.links.model.fpn import mask_head_loss_pre
from chainercv.links.model.fpn import MaskHead
from chain... |
import os
from pylatex.utils import fix_filename
def test_no_dots():
fname = "aaa"
assert fix_filename(fname) == fname
def test_one_dot():
fname = "aa.a"
assert fix_filename(fname) == fname
def test_two_dots():
fname = "aa.a.a"
original_os_name = os.name
try:
os.name = 'posix'... |
from unittest import mock
import pytest
from meld.meldbuffer import BufferLines, MeldBuffer
text = ("""0
1
2
3
4
5
6
7
8
9
10
""")
@pytest.mark.parametrize("line_start, line_end, expected_text", [
(0, 1, ["0"],),
(0, 2, ["0", "1"],),
# zero-sized slice
(9, 9, [],),
(9, 10, ["9"],),
(9, 11,... |
from homeassistant.components.broadlink.const import DOMAIN, SENSOR_DOMAIN
from homeassistant.helpers.entity_registry import async_entries_for_device
from . import get_device
from tests.common import mock_device_registry, mock_registry
async def test_a1_sensor_setup(hass):
"""Test a successful e-Sensor setup."... |
import keras
import tensorflow as tf
from matchzoo.engine import hyper_spaces
from matchzoo.engine.base_model import BaseModel
from matchzoo.engine.param import Param
from matchzoo.engine.param_table import ParamTable
class MVLSTM(BaseModel):
"""
MVLSTM Model.
Examples:
>>> model = MVLSTM()
... |
from homeassistant import data_entry_flow
from homeassistant.components.poolsense.const import DOMAIN
from homeassistant.config_entries import SOURCE_USER
from homeassistant.const import CONF_EMAIL, CONF_PASSWORD
from tests.async_mock import patch
async def test_show_form(hass):
"""Test that the form is served ... |
from __future__ import absolute_import
from __future__ import unicode_literals
import datetime
import dateutil.relativedelta
def date_from_isoformat(isoformat_date):
"""Convert an ISO-8601 date into a `datetime.date` object.
Argument:
isoformat_date (str): a date in ISO-8601 format (YYYY-MM-DD)
... |
import pytest
from homeassistant.components.pvpc_hourly_pricing import ATTR_TARIFF, DOMAIN
from homeassistant.const import (
ATTR_UNIT_OF_MEASUREMENT,
CURRENCY_EURO,
ENERGY_KILO_WATT_HOUR,
)
from tests.common import load_fixture
from tests.test_util.aiohttp import AiohttpClientMocker
FIXTURE_JSON_DATA_2... |
import pytest
from yandextank.common.interfaces import TankInfo
class TestStatus(object):
@pytest.mark.parametrize('updates, result', [
([(['plugin', 'key1'], 'foo'), (['plugin', 'key2'], 42)], {'plugin': {'key1': 'foo', 'key2': 42}}),
([(['plugin1', 'key1'], 'foo'),
(['plugin1', 'key... |
from homeassistant.components.coronavirus.const import DOMAIN, OPTION_WORLDWIDE
from homeassistant.helpers import entity_registry
from homeassistant.setup import async_setup_component
from tests.common import MockConfigEntry, mock_registry
async def test_migration(hass):
"""Test that we can migrate coronavirus ... |
import glob
import os.path as op
import numpy as np
import pytest
from mne import what, create_info
from mne.datasets import testing
from mne.io import RawArray
from mne.preprocessing import ICA
from mne.utils import run_tests_if_main, requires_sklearn
data_path = testing.data_path(download=False)
@pytest.mark.sl... |
from homeassistant.components.binary_sensor import BinarySensorEntity
from homeassistant.const import CONF_TYPE
from . import IHC_CONTROLLER, IHC_INFO
from .const import CONF_INVERTING
from .ihcdevice import IHCDevice
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the IHC binary ... |
import pytest
from tests.async_mock import patch
@pytest.fixture()
def mock_get_stations():
"""Mock aioeafm.get_stations."""
with patch("homeassistant.components.eafm.config_flow.get_stations") as patched:
yield patched
@pytest.fixture()
def mock_get_station():
"""Mock aioeafm.get_station."""
... |
from django.utils.functional import cached_property
from django.utils.translation import gettext_lazy as _
from translate.storage.resx import RESXFile
from weblate.addons.cleanup import BaseCleanupAddon
class ResxUpdateAddon(BaseCleanupAddon):
name = "weblate.resx.update"
verbose = _("Update RESX files")
... |
from homeassistant.components import switch, tellduslive
from homeassistant.helpers.dispatcher import async_dispatcher_connect
from homeassistant.helpers.entity import ToggleEntity
from .entry import TelldusLiveEntity
async def async_setup_entry(hass, config_entry, async_add_entities):
"""Set up tellduslive sen... |
import asyncio
from datetime import timedelta
import logging
import aiohttp
from pyjuicenet import Api, TokenError
import voluptuous as vol
from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
from homeassistant.const import CONF_ACCESS_TOKEN
from homeassistant.core import HomeAssistant
from homeassis... |
import asyncio
from functools import partial
from homeassistant.components.light import (
ATTR_BRIGHTNESS,
ATTR_HS_COLOR,
ATTR_WHITE_VALUE,
DOMAIN,
SUPPORT_BRIGHTNESS,
SUPPORT_COLOR,
SUPPORT_WHITE_VALUE,
LightEntity,
)
from homeassistant.const import CONF_WHITE_VALUE
import homeassista... |
import logging
from typing import List, Optional
from connect_box import ConnectBox
from connect_box.exceptions import ConnectBoxError, ConnectBoxLoginError
import voluptuous as vol
from homeassistant.components.device_tracker import (
DOMAIN,
PLATFORM_SCHEMA,
DeviceScanner,
)
from homeassistant.const im... |
from homeassistant.config_entries import ENTRY_STATE_LOADED
from tests.components.plugwise.common import async_init_integration
async def test_adam_climate_switch_entities(hass, mock_smile_adam):
"""Test creation of climate related switch entities."""
entry = await async_init_integration(hass, mock_smile_ad... |
from diamond.collector import Collector
import diamond.convertor
import os
class MemoryLxcCollector(Collector):
def get_default_config_help(self):
"""
Return help text for collector configuration.
"""
config_help = super(MemoryLxcCollector, self).get_default_config_help()
... |
import diamond.collector
import os
class EntropyStatCollector(diamond.collector.Collector):
PROC = '/proc/sys/kernel/random/entropy_avail'
def get_default_config(self):
"""
Returns the default collector settings
"""
config = super(EntropyStatCollector, self).get_default_conf... |
import os
import shutil
from pylatex import Document
def test():
doc = Document('jobname_test', data=['Jobname test'])
doc.generate_pdf()
assert os.path.isfile('jobname_test.pdf')
os.remove('jobname_test.pdf')
folder = 'tmp_jobname'
os.makedirs(folder)
path = os.path.join(folder, 'job... |
import asyncio
from datetime import timedelta
import logging
import pymyq
from pymyq.errors import InvalidCredentialsError, MyQError
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from homeassistant.core import HomeAssistant
from homeassistant.except... |
import pytest
from rumps.utils import ListDict
class TestListDict(object):
def test_clear(self):
ld = ListDict()
ld[1] = 11
ld['b'] = 22
ld[object()] = 33
assert len(ld) == 3
ld.clear()
assert len(ld) == 0
assert ld.items() == []
|
import errno
import pytest
from homeassistant import config_entries, data_entry_flow
from homeassistant.components.wiffi.const import DOMAIN
from homeassistant.const import CONF_PORT, CONF_TIMEOUT
from homeassistant.data_entry_flow import (
RESULT_TYPE_ABORT,
RESULT_TYPE_CREATE_ENTRY,
RESULT_TYPE_FORM,
)... |
import scipy
import numpy as np
from sklearn.metrics.pairwise import cosine_similarity
from scattertext.Scalers import stretch_0_to_1
from scattertext.categoryprojector.CategoryProjection import CategoryProjection, CategoryProjectionBase
class CategoryProjectionEvaluator(object):
def evaluate(self, category_pr... |
import logging
from hangups.auth import GoogleAuthError
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.components.conversation.util import create_matcher
from homeassistant.const import EVENT_HOMEASSISTANT_STOP
from homeassistant.helpers import dispatcher, intent
import homeassi... |
import os
import testinfra.utils.ansible_runner
testinfra_hosts = testinfra.utils.ansible_runner.AnsibleRunner(
os.environ['MOLECULE_INVENTORY_FILE']).get_hosts('bar')
def test_hostname(host):
assert 'instance-1' == host.check_output('hostname -s')
def test_etc_molecule_directory(host):
f = host.file... |
from stash.tests.stashtest import StashTestCase
class AliasTests(StashTestCase):
"""Tests for the 'alias' command."""
def test_help(self):
"""test 'alias --help'"""
output = self.run_command("alias --help", exitcode=0)
self.assertIn("alias", output)
self.assertIn("-h", output... |
import asynctest
import mock
import pytest
from paasta_tools.monitoring.check_mesos_duplicate_frameworks import (
check_mesos_no_duplicate_frameworks,
)
def test_check_mesos_no_duplicate_frameworks_ok(capfd):
with mock.patch(
"paasta_tools.monitoring.check_mesos_duplicate_frameworks.parse_args",
... |
from abc import ABC
from dataclasses import dataclass
from typing import List, Optional, Tuple
from homeassistant.components.media_player import BrowseMedia
from homeassistant.components.media_player.const import (
MEDIA_CLASS_CHANNEL,
MEDIA_CLASS_DIRECTORY,
MEDIA_TYPE_CHANNEL,
MEDIA_TYPE_CHANNELS,
)
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.