text stringlengths 213 32.3k |
|---|
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import sys
from absl.testing import absltest
class ClassA(absltest.TestCase):
"""Helper test case A for absltest_filtering_test."""
def testA(self):
sys.stderr.write('\nclass A test A\n')
def te... |
revision = "1ae8e3104db8"
down_revision = "a02a678ddc25"
from alembic import op
def upgrade():
op.sync_enum_values(
"public", "log_type", ["key_view"], ["create_cert", "key_view", "update_cert"]
)
def downgrade():
op.sync_enum_values(
"public", "log_type", ["create_cert", "key_view", "... |
from __future__ import absolute_import, division, print_function
class Infinity(object):
def __repr__(self):
return "Infinity"
def __hash__(self):
return hash(repr(self))
def __lt__(self, other):
return False
def __le__(self, other):
return False
def __eq__(se... |
from lark import Lark
from lark.parsers.earley_forest import ForestVisitor, TreeForestTransformer
class TokenPrioritizer(ForestVisitor):
def visit_symbol_node_in(self, node):
# visit the entire forest by returning node.children
return node.children
def visit_packed_node_in(self, node):
... |
import cherrypy
from cherrypy.test import helper
from cherrypy._json import json
json_out = cherrypy.config(**{'tools.json_out.on': True})
json_in = cherrypy.config(**{'tools.json_in.on': True})
class JsonTest(helper.CPWebCase):
@staticmethod
def setup_server():
class Root(object):
@c... |
from __future__ import print_function
import os
import sys
import argparse
_stash = globals()['_stash']
def construct_indices_from_list_spec(list_spec):
# Note unlike python, cut's indices start from 1
indices = []
for fld in list_spec.split(','):
if '-' in fld:
sidx, eidx = fld.spli... |
from homeassistant.components.binary_sensor import (
DEVICE_CLASS_COLD,
DOMAIN,
BinarySensorEntity,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.helpers.typing import HomeAssistantType
from . import AqualinkEntity
from .const import DOMAIN as AQUALINK_DOMAIN
PARALLEL_UPDATES ... |
import os.path
import coverage
from tests.coveragetest import CoverageTest
from tests.helpers import CheckUniqueFilenames
class CollectorTest(CoverageTest):
"""Test specific aspects of the collection process."""
def test_should_trace_cache(self):
# The tracers should only invoke should_trace once ... |
import string
import itertools
import textwrap
import pytest
from PyQt5.QtGui import QKeySequence
from qutebrowser.keyinput import basekeyparser
from qutebrowser.keyinput import keyutils
from unit.keyinput import test_keyutils
@pytest.mark.parametrize('entered, configured, match_type',
te... |
import logging
from openzwavemqtt.const import ATTR_CODE_SLOT
from openzwavemqtt.exceptions import BaseOZWError
from openzwavemqtt.util.lock import clear_usercode, set_usercode
import voluptuous as vol
from homeassistant.components.lock import DOMAIN as LOCK_DOMAIN, LockEntity
from homeassistant.core import callback... |
from homeassistant.components.roku.const import DOMAIN
from homeassistant.config_entries import (
ENTRY_STATE_LOADED,
ENTRY_STATE_NOT_LOADED,
ENTRY_STATE_SETUP_RETRY,
)
from homeassistant.helpers.typing import HomeAssistantType
from tests.async_mock import patch
from tests.components.roku import setup_int... |
import numpy as np
import time
import numbers
from ..parallel import parallel_func
from ..fixes import BaseEstimator, is_classifier, _get_check_scoring
from ..utils import logger, warn, fill_doc
class LinearModel(BaseEstimator):
"""Compute and store patterns from linear models.
The linear model coefficients... |
from homeassistant import config_entries
from homeassistant.components.volumio.config_flow import CannotConnectError
from homeassistant.components.volumio.const import DOMAIN
from tests.async_mock import patch
from tests.common import MockConfigEntry
TEST_SYSTEM_INFO = {"id": "1111-1111-1111-1111", "name": "TestVolu... |
from pyramid.response import Response
from pyramid.view import view_config
from paasta_tools.api import settings
from paasta_tools.api.views.exception import ApiFailure
from paasta_tools.cli.utils import get_instance_config
from paasta_tools.kubernetes_tools import KubernetesDeploymentConfig
from paasta_tools.maratho... |
from __future__ import division
from collections import defaultdict
from datetime import timedelta
import glob
import json
import logging
import os
import re
from appdirs import AppDirs
from babelfish import Error as BabelfishError, Language
import click
from dogpile.cache.backends.file import AbstractFileLock
from d... |
import unittest
import numpy as np
import pandas as pd
from pgmpy.models.BayesianModel import BayesianModel
from pgmpy.inference.CausalInference import CausalInference
class TestCausalGraphMethods(unittest.TestCase):
def setUp(self):
self.game = BayesianModel(
[("A", "X"), ("A", "B"), ("C",... |
import logging
import pytest
from homeassistant.components.input_boolean import CONF_INITIAL, DOMAIN, is_on
from homeassistant.const import (
ATTR_EDITABLE,
ATTR_ENTITY_ID,
ATTR_FRIENDLY_NAME,
ATTR_ICON,
ATTR_NAME,
SERVICE_RELOAD,
SERVICE_TOGGLE,
SERVICE_TURN_OFF,
SERVICE_TURN_ON,... |
import chainer
import numpy as np
import PIL
try:
import cv2
_cv2_available = True
except ImportError:
_cv2_available = False
def _resize_cv2(img, size, interpolation):
img = img.transpose((1, 2, 0))
if interpolation == PIL.Image.NEAREST:
cv_interpolation = cv2.INTER_NEAREST
elif in... |
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 http import HttpCollector
##########################################################################
class TestHttpCollector(... |
import json
from homeassistant.components.airly.const import DOMAIN
from tests.async_mock import patch
from tests.common import MockConfigEntry, load_fixture
async def init_integration(hass, forecast=False) -> MockConfigEntry:
"""Set up the Airly integration in Home Assistant."""
entry = MockConfigEntry(
... |
import json
import uuid
from absl import flags
from perfkitbenchmarker import placement_group
from perfkitbenchmarker import vm_util
from perfkitbenchmarker.configs import option_decoders
from perfkitbenchmarker.providers import aws
from perfkitbenchmarker.providers.aws import util
FLAGS = flags.FLAGS
class AwsPl... |
from test import unittest
from test import run_only
from mock import patch
import configobj
from diamond.handler.stats_d import StatsdHandler
from diamond.metric import Metric
def run_only_if_statsd_is_available(func):
try:
import statsd
except ImportError:
statsd = None
pred = lambda: ... |
import os
from os import path as op
import shutil
import glob
import numpy as np
import pytest
from numpy.testing import assert_equal, assert_allclose
from mne import (concatenate_raws, read_bem_surfaces, read_surface,
read_source_spaces, read_bem_solution)
from mne.bem import ConductorModel
from mn... |
import re
import sys
import json
import os.path
import socket
from http import HTTPStatus
import attr
import pytest
from PyQt5.QtCore import pyqtSignal, QUrl
from end2end.fixtures import testprocess
class Request(testprocess.Line):
"""A parsed line from the flask log output.
Attributes:
verb/path... |
from pydexcom import AccountError, SessionError
from homeassistant.components.dexcom.const import DOMAIN
from homeassistant.config_entries import ENTRY_STATE_LOADED, ENTRY_STATE_NOT_LOADED
from tests.async_mock import patch
from tests.common import MockConfigEntry
from tests.components.dexcom import CONFIG, init_int... |
from datetime import timedelta
import pytest
from homeassistant.components.homekit.accessories import (
HomeAccessory,
HomeBridge,
HomeDriver,
debounce,
)
from homeassistant.components.homekit.const import (
ATTR_DISPLAY_NAME,
ATTR_INTERGRATION,
ATTR_MANUFACTURER,
ATTR_MODEL,
ATTR... |
import logging
from aiohttp import web
import voluptuous as vol
from homeassistant import util
from homeassistant.const import EVENT_HOMEASSISTANT_START, EVENT_HOMEASSISTANT_STOP
from homeassistant.exceptions import HomeAssistantError
import homeassistant.helpers.config_validation as cv
from homeassistant.util.json ... |
import logging
from meteofrance.client import MeteoFranceClient
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import SOURCE_IMPORT
from homeassistant.const import CONF_LATITUDE, CONF_LONGITUDE, CONF_MODE
from homeassistant.core import callback
from .const import... |
from unittest.mock import MagicMock
import pytest
from homeassistant import config_entries
from homeassistant.bootstrap import async_setup_component
from homeassistant.components import discovery
from homeassistant.const import EVENT_HOMEASSISTANT_STARTED
from homeassistant.util.dt import utcnow
from tests.async_mo... |
import itertools
import re
import warnings
import numpy as np
import pandas as pd
import scipy
from sklearn.metrics.pairwise import cosine_similarity
from scattertext import ParsedCorpus
from scattertext.representations.Word2VecFromParsedCorpus import Word2VecDefault
class CategoryEmbeddingsResolver:
def __init... |
import asyncio
import pytest
from homeassistant.util.async_ import run_callback_threadsafe
from homeassistant.util.thread import ThreadWithException
async def test_thread_with_exception_invalid(hass):
"""Test throwing an invalid thread exception."""
finish_event = asyncio.Event()
def _do_nothing(*_):... |
import mock
from paasta_tools.cli.cmds import metastatus
from paasta_tools.utils import SystemPaastaConfig
@mock.patch("paasta_tools.cli.cmds.metastatus.load_system_paasta_config", autospec=True)
def test_report_cluster_status(mock_load_system_paasta_config, capfd):
cluster = "fake_cluster"
fake_system_paa... |
import os
import re
import sys
# When perfkitbenchmarker is run with multiple processes, the output
# from each thread is interleaved in the output. This program takes
# a log file with interleaved messages, and separates them back into their
# own file.
class LogDeInterlace(object):
def __init__(self, root_fil... |
import os
import unittest
import mock
from perfkitbenchmarker import test_util
from perfkitbenchmarker.linux_benchmarks import t2t_benchmark
from perfkitbenchmarker.sample import Sample
class Tensor2TensorBenchmarkTestCase(unittest.TestCase,
test_util.SamplesTestMixin):
@mock.... |
import math
import sys
import textwrap
import requests
import qutebrowser.config.websettings
def version(ua):
"""Comparable version of a user agent."""
return tuple(int(v) for v in ua.upstream_browser_version.split('.')[:2])
def wrap(ini, sub, string):
return textwrap.wrap(string, width=80, initial_in... |
import pytest
import numpy as np
from elephas.utils import functional_utils
pytest.mark.usefixtures("spark_context")
def test_add_params():
p1 = [np.ones((5, 5)) for _ in range(10)]
p2 = [np.ones((5, 5)) for _ in range(10)]
res = functional_utils.add_params(p1, p2)
assert len(res) == 10
for i i... |
import configparser
import logging
import os
logger = logging.getLogger(__name__)
def get_conf(path, filename, default_conf: configparser.ConfigParser) \
-> configparser.ConfigParser:
conf = configparser.ConfigParser()
conf.read_dict(default_conf)
conffn = os.path.join(path, filename)
try:
... |
import unittest
import numpy as np
import tensorflow as tf
from common import gpu_test
class TestTensorflow(unittest.TestCase):
def test_addition(self):
result = tf.add(2, 3)
self.assertEqual(5, result.numpy())
def test_conv2d(self):
input = tf.random.normal([1,2,2,1])
... |
from .util import async_init_integration
async def test_automation_scenes(hass):
"""Test creation automation scenes."""
await async_init_integration(hass)
state = hass.states.get("scene.away_short")
expected_attributes = {
"attribution": "Data provided by mynexia.com",
"description"... |
class HashedSeq(list):
"""Hashed Sequence.
Type used for hash() to make sure the hash is not generated
multiple times.
"""
__slots__ = 'hashvalue'
def __init__(self, *seq):
self[:] = seq
self.hashvalue = hash(seq)
def __hash__(self):
return self.hashvalue
def e... |
from unittest import mock
import pytest
from vcr.request import Request
from vcr.serialize import deserialize, serialize
from vcr.serializers import yamlserializer, jsonserializer, compat
def test_deserialize_old_yaml_cassette():
with open("tests/fixtures/migration/old_cassette.yaml", "r") as f:
with p... |
from homeassistant.components.group import GroupIntegrationRegistry
from homeassistant.const import STATE_OFF, STATE_ON
from homeassistant.core import callback
from homeassistant.helpers.typing import HomeAssistantType
from . import STATE_CLEANING, STATE_ERROR, STATE_RETURNING
@callback
def async_describe_on_off_st... |
from datetime import timedelta
import logging
from aiohttp import ClientConnectorError
import async_timeout
from pygti.exceptions import InvalidAuth
from homeassistant.components.binary_sensor import (
DEVICE_CLASS_PROBLEM,
BinarySensorEntity,
)
from homeassistant.const import ATTR_ATTRIBUTION
from homeassis... |
from unittest import mock
import pytest
import voluptuous as vol
import homeassistant.components.statsd as statsd
from homeassistant.const import EVENT_STATE_CHANGED, STATE_OFF, STATE_ON
import homeassistant.core as ha
from homeassistant.setup import async_setup_component
from tests.async_mock import MagicMock, pat... |
from homeassistant.components.water_heater import (
SUPPORT_AWAY_MODE,
SUPPORT_OPERATION_MODE,
SUPPORT_TARGET_TEMPERATURE,
WaterHeaterEntity,
)
from homeassistant.const import ATTR_TEMPERATURE, TEMP_CELSIUS, TEMP_FAHRENHEIT
SUPPORT_FLAGS_HEATER = (
SUPPORT_TARGET_TEMPERATURE | SUPPORT_OPERATION_MO... |
from datetime import timedelta
import logging
from travispy import TravisPy
from travispy.errors import TravisError
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import (
ATTR_ATTRIBUTION,
CONF_API_KEY,
CONF_MONITORED_CONDITIONS,
CONF_SC... |
from homeassistant.components import binary_sensor
from homeassistant.components.binary_sensor import BinarySensorEntity
from homeassistant.core import callback
from homeassistant.helpers.dispatcher import async_dispatcher_connect
import homeassistant.helpers.event as evt
from .const import DATA_REMOVE_DISCOVER_COMPO... |
import sys
import threading
from .shcommon import _SYS_STDIN, _SYS_STDOUT, _SYS_STDERR
from .shthreads import ShBaseThread
class ShStdinWrapper(object):
def __getattribute__(self, item):
thread = threading.currentThread()
if isinstance(thread, ShBaseThread):
return getattr(thread.st... |
import re
from absl import flags
from perfkitbenchmarker import configs
from perfkitbenchmarker import sample
from perfkitbenchmarker.linux_packages import docker
flags.DEFINE_string('cloudsuite_data_caching_memcached_flags',
'-t 1 -m 2048 -n 550',
'Flags to be given to memcach... |
import copy
import logging
import multiprocessing
import string
from pkg_resources import resource_string
from yandextank.common.util import AddressWizard
from ...stepper import StepperWrapper
from ...stepper.util import parse_duration
logger = logging.getLogger(__name__)
class PhantomConfig:
""" config file ... |
import keras
from matchzoo.contrib.layers import MatchingTensorLayer
from matchzoo.contrib.layers import SpatialGRU
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 MatchSRNN(Bas... |
from ... import event
from .._widget import Widget, create_element
class ProgressBar(Widget):
""" A widget to show progress.
The ``node`` of this widget is a
`<div> <https://developer.mozilla.org/docs/Web/HTML/Element/div>`_
containing a few HTML elements for rendering.
"""
DEFAULT_MIN_... |
import json
import unittest
import pytest
import requests_mock
import voluptuous as vol
from homeassistant.components import vultr as base_vultr
from homeassistant.components.vultr import (
ATTR_ALLOWED_BANDWIDTH,
ATTR_AUTO_BACKUPS,
ATTR_COST_PER_MONTH,
ATTR_CREATED_AT,
ATTR_IPV4_ADDRESS,
ATT... |
from datetime import timedelta
from django.conf import settings
from django.contrib.auth.decorators import login_required
from django.core.exceptions import PermissionDenied
from django.http import Http404, HttpResponse
from django.shortcuts import get_object_or_404, redirect, render
from django.utils import timezone... |
from __future__ import print_function
import sys
try:
from cStringIO import StringIO
except ImportError:
from io import StringIO
import rospkg
import rosunit.junitxml as junitxml
def create_summary(result, packages):
buff = StringIO()
buff.write('-' * 80 + '\n')
buff.write('\033[1m[AGGREGATED... |
from collections import Counter
from scattertext.emojis.EmojiExtractor import extract_emoji
from scattertext.features.FeatsFromSpacyDoc import FeatsFromSpacyDoc
class FeatsFromSpacyDocOnlyEmoji(FeatsFromSpacyDoc):
'''
Strips away everything but emoji tokens from spaCy
'''
def get_feats(self, doc):
'''
Para... |
import pytest
from homeassistant.components.light import Profiles
from tests.async_mock import AsyncMock, patch
@pytest.fixture(autouse=True)
def mock_light_profiles():
"""Mock loading of profiles."""
data = {}
def mock_profiles_class(hass):
profiles = Profiles(hass)
profiles.data = da... |
from collections import OrderedDict
import logging
from typing import Any, Dict, Optional
from urllib.parse import urlparse
from huawei_lte_api.AuthorizedConnection import AuthorizedConnection
from huawei_lte_api.Client import Client
from huawei_lte_api.Connection import Connection
from huawei_lte_api.exceptions impo... |
from datetime import timedelta
import logging
from typing import List
import boto3
import requests
import voluptuous as vol
from homeassistant.const import CONF_DOMAIN, CONF_TTL, CONF_ZONE, HTTP_OK
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.event import track_time_interval
_LOGG... |
from roomba import Roomba
import voluptuous as vol
from homeassistant import config_entries, core
from homeassistant.const import CONF_HOST, CONF_PASSWORD
from homeassistant.core import callback
from . import CannotConnect, async_connect_or_timeout, async_disconnect_or_timeout
from .const import (
CONF_BLID,
... |
import gettext
from io import StringIO
from itertools import chain
from unittest import SkipTest
from django.conf import settings
from django.core.management import call_command
from django.test import TestCase
from django.urls import reverse
from django.utils.translation import activate
from weblate_language_data.la... |
import tempfile
import unittest
import mock
from kalliope.core.Models import Singleton
from kalliope.core.Models.settings.Player import Player
from kalliope.core.Models.settings.Stt import Stt
from kalliope.core.Models.settings.Trigger import Trigger
from kalliope.core.Models.settings.Tts import Tts
from kalliope.neu... |
import asyncio
import voluptuous as vol
from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
from homeassistant.const import CONF_DEVICE
from homeassistant.core import HomeAssistant
from homeassistant.helpers import config_validation as cv
from .const import DOMAIN, SMS_GATEWAY
from .gateway import c... |
from pytest import fixture
from . import MOCK_HISTORY, MOCK_STATUS, MOCK_VERSION
from tests.async_mock import MagicMock, patch
@fixture
def nzbget_api(hass):
"""Mock NZBGetApi for easier testing."""
with patch("homeassistant.components.nzbget.coordinator.NZBGetAPI") as mock_api:
instance = mock_api... |
from unittest.mock import Mock
import numpy as np
import pandas as pd
import pytest
import pytz
from qstrader.signals.sma import SMASignal
@pytest.mark.parametrize(
'start_dt,lookbacks,prices,expected',
[
(
pd.Timestamp('2019-01-01 14:30:00', tz=pytz.utc),
[6, 12],
... |
import string
from .unit import Unit
class PuncRemoval(Unit):
"""Process unit for remove punctuations."""
def transform(self, input_: list) -> list:
"""
Remove punctuations from list of tokens.
:param input_: list of toekns.
:return rv: tokens without punctuation.
... |
import logging
import re
import telnetlib
import voluptuous as vol
from homeassistant.components.device_tracker import (
DOMAIN,
PLATFORM_SCHEMA,
DeviceScanner,
)
from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
import homeassistant.helpers.config_validation as cv
_LOGGER = loggin... |
from typing import Any
from homeassistant.components import litejet
from homeassistant.components.scene import Scene
ATTR_NUMBER = "number"
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up scenes for the LiteJet platform."""
litejet_ = hass.data["litejet_system"]
devices ... |
from __future__ import print_function
import argparse
import logging
import pymongo
from .utils import do_db_auth, setup_logging
from ..arctic import Arctic, VERSION_STORE, LIBRARY_TYPES, \
ArcticLibraryBinding
from ..hooks import get_mongodb_uri
logger = logging.getLogger(__name__)
def main():
usage = "... |
from datetime import timedelta
import logging
from typing import Optional
from homeassistant.const import ATTR_LATITUDE, ATTR_LONGITUDE
from homeassistant.helpers.config_validation import ( # noqa: F401
PLATFORM_SCHEMA,
PLATFORM_SCHEMA_BASE,
)
from homeassistant.helpers.entity import Entity
from homeassistan... |
import traceback
class SchedulerBase:
"""Base class with common functionality for schedulers
Derived classes must implement get_current_task.
"""
def __init__(self):
self.tasks = []
self.callbacks = []
def __repr__(self):
return "%s" % self.tasks
def connect(self, ... |
import datetime
import logging
import os
import posixpath
import subprocess
import tarfile
from perfkitbenchmarker.providers.aws.util import AWS_PATH
def ArchiveRun(run_temp_directory, target_bucket,
prefix='',
gsutil_path='gsutil',
aws_path=AWS_PATH):
"""Archive a run... |
from datetime import timedelta
from greeclimate.device import HorizontalSwing, VerticalSwing
from greeclimate.exceptions import DeviceNotBoundError, DeviceTimeoutError
import pytest
from homeassistant.components.climate.const import (
ATTR_FAN_MODE,
ATTR_HVAC_MODE,
ATTR_PRESET_MODE,
ATTR_SWING_MODE,
... |
from typing import Any
from homeassistant.components.scene import Scene
from . import DOMAIN as TAHOMA_DOMAIN
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the Tahoma scenes."""
if discovery_info is None:
return
controller = hass.data[TAHOMA_DOMAIN]["controller"... |
from datetime import timedelta
import logging
import os
import greenwavereality as greenwave
import voluptuous as vol
from homeassistant.components.light import (
ATTR_BRIGHTNESS,
PLATFORM_SCHEMA,
SUPPORT_BRIGHTNESS,
LightEntity,
)
from homeassistant.const import CONF_HOST
import homeassistant.helper... |
from django.test import SimpleTestCase
from django.utils.translation import override
from weblate.utils.render import render_template
class RenderTest(SimpleTestCase):
def test_float(self):
self.assertEqual(render_template("{{ number }}", number=1.1), "1.1")
def test_float_cs(self):
with ov... |
import hangups.user
import hangups.hangouts_pb2
USER_ID = hangups.user.UserID(1, 1)
def test_default_type_detection_empty_0():
# missing names
user = hangups.user.User(
USER_ID,
full_name='',
first_name='',
photo_url='',
emails=[],
is_self=False,
)
a... |
import argparse
from binascii import a2b_hex, b2a_hex
from autobahn import xbr
from twisted.internet.task import react
from twisted.internet.defer import inlineCallbacks
@inlineCallbacks
def main(reactor, gateway, adr):
sbc = xbr.SimpleBlockchain(gateway)
yield sbc.start()
print('status for address 0x{}... |
import logging
from homeassistant.helpers.entity import ToggleEntity
from . import DATA_CLIMATE, DATA_LEAF, LeafEntity
_LOGGER = logging.getLogger(__name__)
def setup_platform(hass, config, add_devices, discovery_info=None):
"""Nissan Leaf switch platform setup."""
if discovery_info is None:
retur... |
import random
import re
import string
import pem
import base64
import sqlalchemy
from cryptography import x509
from cryptography.exceptions import InvalidSignature, UnsupportedAlgorithm
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.... |
from unittest import mock
import pytest
import homeassistant.components.zha.core.registries as registries
MANUFACTURER = "mock manufacturer"
MODEL = "mock model"
@pytest.fixture
def zha_device():
"""Return a mock of ZHA device."""
dev = mock.MagicMock()
dev.manufacturer = MANUFACTURER
dev.model = ... |
from homeassistant.components.switch import DEVICE_CLASS_OUTLET, SwitchEntity
from homeassistant.helpers.typing import ConfigType, HomeAssistantType
from . import DOMAIN, GeniusZone
ATTR_DURATION = "duration"
GH_ON_OFF_ZONE = "on / off"
async def async_setup_platform(
hass: HomeAssistantType, config: ConfigTy... |
from django.test import SimpleTestCase
from weblate.checks.tests.test_checks import MockUnit
from weblate.checks.utils import highlight_string
class HightlightTestCase(SimpleTestCase):
def test_simple(self):
self.assertEqual(
highlight_string(
"simple {format} string", MockUn... |
from functools import partial
import logging
from pyflume import FlumeAuth, FlumeDeviceList
from requests.exceptions import RequestException
import voluptuous as vol
from homeassistant import config_entries, core, exceptions
from homeassistant.const import (
CONF_CLIENT_ID,
CONF_CLIENT_SECRET,
CONF_PASSW... |
import logging
import os
from threading import Thread
from kalliope import Utils
from kalliope.trigger.snowboy import snowboydecoder
from cffi import FFI as _FFI
class SnowboyModelNotFound(Exception):
pass
class MissingParameterException(Exception):
pass
logging.basicConfig()
logger = logging.getLogger("... |
from __future__ import print_function
try:
enumerate = enumerate
except NameError:
def enumerate(iterable):
"""emulates the python2.3 enumerate() function"""
i = 0
for val in iterable:
yield i, val
i += 1
def toto(value):
for k, v in value:
print(v... |
from io import open
import subprocess
from flask import current_app
from lemur.utils import mktempfile, mktemppath
from lemur.plugins.bases import ExportPlugin
from lemur.plugins import lemur_csr as csr
def run_process(command):
"""
Runs a given command with pOpen and wraps some
error handling around i... |
from datetime import timedelta
import pytest
from homeassistant import data_entry_flow
from homeassistant.components.gdacs import CONF_CATEGORIES, DOMAIN
from homeassistant.const import (
CONF_LATITUDE,
CONF_LONGITUDE,
CONF_RADIUS,
CONF_SCAN_INTERVAL,
)
from tests.async_mock import patch
@pytest.f... |
from asyncio import Queue
from datetime import datetime
from typing import Any, Generator, Optional
from pytest import fixture
from .consts import (
DUMMY_AUTO_OFF_SET,
DUMMY_DEVICE_ID,
DUMMY_DEVICE_NAME,
DUMMY_DEVICE_STATE,
DUMMY_ELECTRIC_CURRENT,
DUMMY_IP_ADDRESS,
DUMMY_MAC_ADDRESS,
... |
def AptInstall(vm):
"""Installs the nvidia-docker package on the VM."""
vm.Install('docker')
vm.RemoteCommand('curl -s -L https://nvidia.github.io/nvidia-docker/gpgkey '
'| sudo apt-key add -')
vm.RemoteCommand('curl -s -L https://nvidia.github.io/nvidia-docker/'
'$(. /etc... |
def apply_application_controller_patch(zha_gateway):
"""Apply patches to ZHA objects."""
# Patch handle_message until zigpy can provide an event here
def handle_message(sender, profile, cluster, src_ep, dst_ep, message):
"""Handle message from a device."""
if (
sender.ieee in zh... |
import asyncio
from datetime import timedelta
import logging
from requests import HTTPError
import voluptuous as vol
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import CONF_CLIENT_ID, CONF_CLIENT_SECRET
from homeassistant.core import HomeAssistant
from homeassistant.helpers import c... |
from collections import Counter
import logging
from typing import Callable, List, Tuple
from homeassistant import const as ha_const
from homeassistant.core import callback
from homeassistant.helpers.dispatcher import (
async_dispatcher_connect,
async_dispatcher_send,
)
from homeassistant.helpers.entity_regist... |
from box.box import Box
class ConfigBox(Box):
"""
Modified box object to add object transforms.
Allows for build in transforms like:
cns = ConfigBox(my_bool='yes', my_int='5', my_list='5,4,3,3,2')
cns.bool('my_bool') # True
cns.int('my_int') # 5
cns.list('my_list', mod=lambda x: int(x)... |
__docformat__ = "restructuredtext en"
import sys
from stat import S_IWRITE
import codecs
from six import string_types
BULLET = '*'
SUBBULLET = '-'
INDENT = ' ' * 4
class NoEntry(Exception):
"""raised when we are unable to find an entry"""
class EntryNotFound(Exception):
"""raised when we are unable to f... |
from datetime import timedelta
import logging
import requests
import voluptuous as vol
from homeassistant.components.camera import PLATFORM_SCHEMA, Camera
from homeassistant.const import CONF_MONITORED_CONDITIONS
import homeassistant.helpers.config_validation as cv
from . import DOMAIN as SKYBELL_DOMAIN, SkybellDev... |
import numpy as np
from matchzoo.engine.base_metric import BaseMetric, sort_and_couple
from .discounted_cumulative_gain import DiscountedCumulativeGain
class NormalizedDiscountedCumulativeGain(BaseMetric):
"""Normalized discounted cumulative gain metric."""
ALIAS = ['normalized_discounted_cumulative_gain',... |
import numpy as np
def crop_bbox(
bbox, y_slice=None, x_slice=None,
allow_outside_center=True, return_param=False):
"""Translate bounding boxes to fit within the cropped area of an image.
This method is mainly used together with image cropping.
This method translates the coordinates of b... |
from django.http import HttpRequest
from django.test import TestCase
from django.test.utils import modify_settings, override_settings
from django.urls import reverse
from weblate.accounts.tests.test_registration import REGISTRATION_DATA
from weblate.trans.tests.test_views import RegistrationTestMixin
from weblate.tra... |
import asyncio
import logging
from homematicip.aio.auth import AsyncAuth
from homematicip.aio.home import AsyncHome
from homematicip.base.base_connection import HmipConnectionError
from homematicip.base.enums import EventType
from homeassistant.config_entries import ConfigEntry
from homeassistant.core import callbac... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.