text stringlengths 213 32.3k |
|---|
from homeassistant.components.powerwall.const import DOMAIN
from homeassistant.const import STATE_ON
from homeassistant.setup import async_setup_component
from .mocks import _mock_get_config, _mock_powerwall_with_fixtures
from tests.async_mock import patch
async def test_sensors(hass):
"""Test creation of the ... |
import re
from itertools import chain, groupby
from builtins import range
from . import info
from .util import parse_duration, solve_quadratic, proper_round
class Const(object):
'''
Load plan with constant load
'''
def __init__(self, rps, duration):
self.rps = float(rps)
self.duratio... |
from os.path import exists
from os.path import sys
from setuptools import setup, find_packages
def parse_version(fpath):
"""
Statically parse the version number from a python file
"""
import ast
if not exists(fpath):
raise ValueError("fpath={!r} does not exist".format(fpath))
with op... |
import logging
from homeassistant.const import CONF_DEVICE, EVENT_HOMEASSISTANT_STOP
from .const import DOMAIN as AXIS_DOMAIN
from .device import AxisNetworkDevice
_LOGGER = logging.getLogger(__name__)
async def async_setup(hass, config):
"""Old way to set up Axis devices."""
return True
async def async... |
import numpy as np
from scattertext.CSRMatrixTools import CSRMatrixFactory
from scattertext.indexstore import IndexStore
from scattertext.termranking import AbsoluteFrequencyRanker
class CompactTerms(object):
def __init__(self,
term_ranker=AbsoluteFrequencyRanker,
minimum_term_count=0,
... |
from datetime import timedelta
from typing import Dict
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import (
CONF_DISKS,
DATA_MEGABYTES,
DATA_RATE_KILOBYTES_PER_SECOND,
DATA_TERABYTES,
PRECISION_TENTHS,
TEMP_CELSIUS,
)
from homeassistant.helpers.temperature imp... |
import numbers
import numpy as np
import six
import chainer
def _is_iterable(x):
if isinstance(x, str):
return False
return hasattr(x, '__iter__')
def _as_tuple(t):
if _is_iterable(t):
return tuple(t)
else:
return t,
def _bool_to_indices(indices, len_):
true_indices =... |
from __future__ import print_function
import numpy
import os
import time
from PIL import Image
from src.training_data import load_training_tiles, way_bitmap_for_naip
from src.single_layer_network import list_findings
def render_errors(raster_data_paths, model, training_info, render_results):
"""Render JPEGs show... |
from homeassistant import config_entries, setup
from homeassistant.components.avri.const import DOMAIN
from tests.async_mock import patch
async def test_form(hass):
"""Test we get the form."""
await setup.async_setup_component(hass, "avri", {})
result = await hass.config_entries.flow.async_init(
... |
from homeassistant.components.lock import SUPPORT_OPEN, LockEntity
from homeassistant.const import STATE_LOCKED, STATE_UNLOCKED
async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
"""Set up the Demo lock platform."""
async_add_entities(
[
DemoLock("Front... |
import functools
import numpy as np
from . import utils
# Use as a sentinel value to indicate a dtype appropriate NA value.
NA = utils.ReprObject("<NA>")
@functools.total_ordering
class AlwaysGreaterThan:
def __gt__(self, other):
return True
def __eq__(self, other):
return isinstance(othe... |
import logging
from homeassistant.const import CONF_DEVICE, CONF_NAME, STATE_UNKNOWN
from homeassistant.helpers.entity import Entity
DOMAIN = "kira"
_LOGGER = logging.getLogger(__name__)
ICON = "mdi:remote"
CONF_SENSOR = "sensor"
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up... |
import arrow
import requests
import xmltodict
from cryptography import x509
from flask import current_app
from lemur.common.utils import get_psuedo_random_string
from lemur.extensions import metrics, sentry
from lemur.plugins import lemur_verisign as verisign
from lemur.plugins.bases import IssuerPlugin, SourcePlugin... |
import logging
import unittest
from gensim.corpora import mmcorpus, Dictionary
from gensim.models import hdpmodel
from gensim.test import basetmtests
from gensim.test.utils import datapath, common_texts
import numpy as np
dictionary = Dictionary(common_texts)
corpus = [dictionary.doc2bow(text) for text in common_te... |
from __future__ import print_function
import json
import re
import sys
def main():
if len(sys.argv) != 4:
print('usage: %s samples_file.json metric_name data_label' % sys.argv[0])
sys.exit(1)
with open(sys.argv[1]) as samples_file:
for line in samples_file:
sample = json.loads(line)
if sa... |
revision = "5e680529b666"
down_revision = "131ec6accff5"
from alembic import op
import sqlalchemy as sa
def upgrade():
op.add_column("endpoints", sa.Column("sensitive", sa.Boolean(), nullable=True))
op.add_column("endpoints", sa.Column("source_id", sa.Integer(), nullable=True))
op.create_foreign_key(Non... |
import unittest
import subprocess
import time
from gensim.models import LdaModel
from gensim.test.utils import datapath, common_dictionary
from gensim.corpora import MmCorpus
from gensim.models.callbacks import CoherenceMetric
try:
from visdom import Visdom
VISDOM_INSTALLED = True
except ImportError:
VIS... |
import argparse
import logging
import os
import sys
import manhole
import requests_cache
import service_configuration_lib
import yaml
from pyramid.config import Configurator
from wsgicors import CORS
import paasta_tools.api
from paasta_tools import kubernetes_tools
from paasta_tools import marathon_tools
from paasta... |
import random
from flexx import flx
COLORS = ('#eee', '#999', '#555', '#111',
'#f00', '#0f0', '#00f', '#ff0', '#f0f', '#0ff',
'#a44', '#4a4', '#44a', '#aa4', '#afa', '#4aa',
)
class Relay(flx.Component):
""" Global object to relay paint events to all participants.
"""
@flx... |
from django.contrib.auth.decorators import login_required
from django.core.exceptions import PermissionDenied
from django.http import Http404, HttpResponse, HttpResponseBadRequest, JsonResponse
from django.shortcuts import get_object_or_404, render
from django.utils.translation import gettext as _
from django.views.de... |
import importlib.util
import os
import shutil
import sys
import textwrap
import traceback
import doit.cmd_base
from collections import defaultdict
from blinker import signal
from doit.cmd_auto import Auto as DoitAuto
from doit.cmd_base import TaskLoader, _wrap
from doit.cmd_clean import Clean as DoitClean
from doit.c... |
import hangups
def get_conv_name(conv, truncate=False, show_unread=False):
"""Return a readable name for a conversation.
If the conversation has a custom name, use the custom name. Otherwise, for
one-to-one conversations, the name is the full name of the other user. For
group conversations, the name... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
__author__ = 'p3rf@google.com'
import json
import logging
import time
from absl import app
from absl import flags
import script_driver
import tpc_profile_details
flags.DEFINE_string('profile', None, 'Profile... |
import asyncio
from collections import OrderedDict
import logging
import async_timeout
from songpal import (
ConnectChange,
ContentChange,
Device,
PowerChange,
SongpalException,
VolumeChange,
)
import voluptuous as vol
from homeassistant.components.media_player import MediaPlayerEntity
from h... |
from flexx import event
class Person(event.Component):
first_name = event.StringProp('Jane', settable=True)
last_name = event.StringProp('Doe', settable=True)
class Greeter(event.Component):
message = event.StringProp('', settable=True)
@event.reaction
def show_message(self):
print('... |
from unittest import TestCase
import numpy as np
import pandas as pd
from scattertext import LogOddsRatioInformativeDirichletPrior
from scattertext.PriorFactory import PriorFactory
from scattertext.test.test_semioticSquare import get_test_corpus
class TestPriorFactory(TestCase):
def test_all_categories(self):
c... |
import functools
from hangups import get_auth
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.const import CONF_EMAIL, CONF_PASSWORD
from homeassistant.core import callback
from .const import (
CONF_2FA,
CONF_AUTH_CODE,
CONF_REFRESH_TOKEN,
DOMAIN as HANGOUTS_DOMA... |
import argparse # noqa
import logging
import os
import redis
from docker_registry.lib import layers
from docker_registry.lib import rlock
from docker_registry.lib import rqueue
import docker_registry.storage as storage
store = storage.load()
redis_default_host = os.environ.get(
'DOCKER_REDIS_1_PORT_6379_TCP_... |
import math
from homeassistant.components.fan import (
DOMAIN,
SPEED_HIGH,
SPEED_LOW,
SPEED_MEDIUM,
SPEED_OFF,
SUPPORT_SET_SPEED,
FanEntity,
)
from homeassistant.core import callback
from homeassistant.helpers.dispatcher import async_dispatcher_connect
from . import ZWaveDeviceEntity
SPE... |
from typing import Optional, Sequence
from pysmartthings import Attribute, Capability
from homeassistant.components.cover import (
ATTR_POSITION,
DEVICE_CLASS_DOOR,
DEVICE_CLASS_GARAGE,
DEVICE_CLASS_SHADE,
DOMAIN as COVER_DOMAIN,
STATE_CLOSED,
STATE_CLOSING,
STATE_OPEN,
STATE_OPEN... |
import pytest
from plumbum.colorlib.styles import ANSIStyle, Color, AttributeNotFound, ColorNotFound
from plumbum.colorlib.names import color_html, FindNearest
# Just check to see if this file is importable
from plumbum.cli.image import Image
class TestNearestColor:
def test_exact(self):
assert FindNeare... |
import json
import logging
import voluptuous as vol
from homeassistant.components import mqtt
from homeassistant.components.light import (
ATTR_BRIGHTNESS,
ATTR_COLOR_TEMP,
ATTR_EFFECT,
ATTR_FLASH,
ATTR_HS_COLOR,
ATTR_TRANSITION,
ATTR_WHITE_VALUE,
FLASH_LONG,
FLASH_SHORT,
SUPP... |
import pytest
from homeassistant import config_entries, data_entry_flow, setup
from homeassistant.components.spider.const import DOMAIN
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from tests.async_mock import Mock, patch
from tests.common import MockConfigEntry
USERNAME = "spider-username"
PASSWORD... |
import pytest
from PyQt5.QtCore import QUrl, QIODevice
from PyQt5.QtNetwork import QNetworkRequest, QNetworkReply
from qutebrowser.browser.webkit.network import networkreply
@pytest.fixture
def req():
return QNetworkRequest(QUrl('http://www.qutebrowser.org/'))
class TestFixedDataNetworkReply:
def test_a... |
from pathlib import Path
from homeassistant.components.camera import SUPPORT_ON_OFF, Camera
async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
"""Set up the Demo camera platform."""
async_add_entities([DemoCamera("Demo camera")])
async def async_setup_entry(hass, config... |
import asyncio
import time
import random
from collections import Counter
import discord
from redbot.core import bank, errors
from redbot.core.i18n import Translator
from redbot.core.utils.chat_formatting import box, bold, humanize_list, humanize_number
from redbot.core.utils.common_filters import normalize_smartquotes... |
import logging
import anthemav
import voluptuous as vol
from homeassistant.components.media_player import PLATFORM_SCHEMA, MediaPlayerEntity
from homeassistant.components.media_player.const import (
SUPPORT_SELECT_SOURCE,
SUPPORT_TURN_OFF,
SUPPORT_TURN_ON,
SUPPORT_VOLUME_MUTE,
SUPPORT_VOLUME_SET,... |
from homeassistant.core import State
from tests.common import async_mock_service
async def test_reproducing_states(hass, caplog):
"""Test reproducing Automation states."""
hass.states.async_set("automation.entity_off", "off", {})
hass.states.async_set("automation.entity_on", "on", {})
turn_on_calls... |
import filecmp
import json
import shutil
import yaml
import vcr.migration
# Use the libYAML versions if possible
try:
from yaml import CLoader as Loader
except ImportError:
from yaml import Loader
def test_try_migrate_with_json(tmpdir):
cassette = tmpdir.join("cassette.json").strpath
shutil.copy("t... |
import os
from . import exceptions
from paasta_tools.async_utils import async_ttl_cache
class File:
chunk_size = 1024
def __init__(self, host, task=None, path=None):
self.host = host
self.task = task
self.path = path
if self.task is None:
self._host_path = self... |
import arrow
from sqlalchemy import or_, cast, Integer
from lemur import database
from lemur.authorities.models import Authority
from lemur.authorities import service as authorities_service
from lemur.certificates import service as certificate_service
from lemur.certificates.schemas import CertificateUploadInputSchem... |
from homeassistant.components.vacuum import (
ATTR_CLEANED_AREA,
STATE_CLEANING,
STATE_DOCKED,
STATE_IDLE,
STATE_PAUSED,
STATE_RETURNING,
SUPPORT_BATTERY,
SUPPORT_CLEAN_SPOT,
SUPPORT_FAN_SPEED,
SUPPORT_LOCATE,
SUPPORT_PAUSE,
SUPPORT_RETURN_HOME,
SUPPORT_SEND_COMMAND,... |
from __future__ import absolute_import
import unittest
from lark import Lark
from lark.lexer import Token
from lark.tree import Tree
from lark.visitors import Visitor, Transformer, Discard
from lark.parsers.earley_forest import TreeForestTransformer, handles_ambiguity
class TestTreeForestTransformer(unittest.TestCa... |
from homeassistant.components.binary_sensor import (
DEVICE_CLASS_PROBLEM,
BinarySensorEntity,
)
from homeassistant.const import CONF_EMAIL
from . import PoolSenseEntity
from .const import DOMAIN
BINARY_SENSORS = {
"pH Status": {
"unit": None,
"icon": None,
"name": "pH Status",
... |
import logging
from asterisk_mbox import Client as asteriskClient
from asterisk_mbox.commands import (
CMD_MESSAGE_CDR,
CMD_MESSAGE_CDR_AVAILABLE,
CMD_MESSAGE_LIST,
)
import voluptuous as vol
from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_PORT
from homeassistant.core import callback
from ... |
import datetime
import json
import logging
import os
from typing import Any, Dict
from google.cloud import pubsub_v1
import voluptuous as vol
from homeassistant.const import EVENT_STATE_CHANGED, STATE_UNAVAILABLE, STATE_UNKNOWN
from homeassistant.core import Event, HomeAssistant
import homeassistant.helpers.config_v... |
import pytest
from vcr.persisters.filesystem import FilesystemPersister
from vcr.serializers import jsonserializer, yamlserializer
@pytest.mark.parametrize(
"cassette_path, serializer",
[
("tests/fixtures/migration/old_cassette.json", jsonserializer),
("tests/fixtures/migration/old_cassette.... |
from homeassistant.components.binary_sensor import BinarySensorEntity
from homeassistant.helpers.typing import ConfigType, HomeAssistantType
from . import DOMAIN, GeniusDevice
GH_STATE_ATTR = "outputOnOff"
async def async_setup_platform(
hass: HomeAssistantType, config: ConfigType, async_add_entities, discover... |
import copy
import numpy as np
from chainer import reporter
import chainer.training.extensions
from chainercv.evaluations import eval_instance_segmentation_voc
from chainercv.utils import apply_to_iterator
class InstanceSegmentationVOCEvaluator(chainer.training.extensions.Evaluator):
"""An evaluation extensio... |
from homeassistant.components.climate import _LOGGER
from homeassistant.components.climate.const import (
ATTR_AUX_HEAT,
ATTR_FAN_MODE,
ATTR_HUMIDITY,
ATTR_HVAC_MODE,
ATTR_PRESET_MODE,
ATTR_SWING_MODE,
ATTR_TARGET_TEMP_HIGH,
ATTR_TARGET_TEMP_LOW,
DOMAIN,
SERVICE_SET_AUX_HEAT,
... |
import logging
from aiohttp import web
import voluptuous as vol
from homeassistant.components.sensor import DOMAIN as SENSOR
from homeassistant.const import (
CONF_WEBHOOK_ID,
HTTP_OK,
TEMP_CELSIUS,
TEMP_FAHRENHEIT,
VOLUME_GALLONS,
VOLUME_LITERS,
)
import homeassistant.helpers.config_validati... |
import re
import sys
import requests
def to_int(value):
value = ''.join((x for x in value if x.isdigit()))
try:
return int(value)
except Exception:
return 0
def to_tuple(version):
return tuple(to_int(x) for x in version.split('.'))
def main():
project = sys.argv[1]
json = ... |
import asyncio
import logging
import math
from typing import Any, Callable, Dict, List, Optional
from aioesphomeapi import (
APIClient,
APIConnectionError,
DeviceInfo,
EntityInfo,
EntityState,
HomeassistantServiceCall,
UserService,
UserServiceArgType,
)
import voluptuous as vol
from h... |
from withings_api.common import NotifyAppli
from homeassistant.components.withings.common import (
WITHINGS_MEASUREMENTS_MAP,
async_get_entity_id,
)
from homeassistant.components.withings.const import Measurement
from homeassistant.const import STATE_OFF, STATE_ON, STATE_UNAVAILABLE
from homeassistant.core im... |
from __future__ import division
import numpy as np
import chainer
import chainer.functions as F
import chainer.links as L
from chainercv.functions import ps_roi_max_align_2d
from chainercv.links.connection.conv_2d_bn_activ import Conv2DBNActiv
from chainercv.links.model.faster_rcnn.region_proposal_network import \
... |
from django.views.debug import SafeExceptionReporterFilter
from weblate.utils.requirements import get_versions_list
class WeblateExceptionReporterFilter(SafeExceptionReporterFilter):
def get_post_parameters(self, request):
if hasattr(request, "META"):
meta = request.META
if hasat... |
from django.conf import settings
from django.core.exceptions import ValidationError
from django.core.files.storage import FileSystemStorage
from django.db import models
from django.urls import reverse
from django.utils.translation import gettext_lazy as _
from weblate.fonts.utils import get_font_name
from weblate.fon... |
import os
from nikola.plugin_categories import Task
from nikola import utils
class Redirect(Task):
"""Generate redirections."""
name = "redirect"
def gen_tasks(self):
"""Generate redirections tasks."""
kw = {
'redirections': self.site.config['REDIRECTIONS'],
'ou... |
from __future__ import print_function
try:
import asyncio
except ImportError:
import trollius as asyncio
from datetime import datetime
import sys
import weakref
import urwid
from urwid.raw_display import Screen
from urwid.display_common import BaseScreen
import logging
logging.basicConfig()
loop = asyncio... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import unittest
from absl import flags
import mock
from perfkitbenchmarker import errors
from perfkitbenchmarker import os_types
from perfkitbenchmarker import providers
from perfkitbenchmarker impo... |
import numpy as np
import xarray as xr
from . import requires_dask
class Unstacking:
def setup(self):
data = np.random.RandomState(0).randn(1, 1000, 500)
self.ds = xr.DataArray(data).stack(flat_dim=["dim_1", "dim_2"])
def time_unstack_fast(self):
self.ds.unstack("flat_dim")
de... |
from pylutron import OccupancyGroup
from homeassistant.components.binary_sensor import (
DEVICE_CLASS_OCCUPANCY,
BinarySensorEntity,
)
from . import LUTRON_CONTROLLER, LUTRON_DEVICES, LutronDevice
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the Lutron occupancy sensor... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from absl import flags
from perfkitbenchmarker import configs
from perfkitbenchmarker import vm_util
from perfkitbenchmarker.windows_packages import nuttcp
from six.moves import range
FLAGS = flags.FLAGS
BEN... |
import asyncio
import json
from homeassistant import config_entries, setup
from homeassistant.components.hunterdouglas_powerview.const import DOMAIN
from tests.async_mock import AsyncMock, MagicMock, patch
from tests.common import MockConfigEntry, load_fixture
def _get_mock_powerview_userdata(userdata=None, get_re... |
import enum
import attr
from PyQt5.QtCore import (pyqtSignal, pyqtSlot, # type: ignore[attr-defined]
pyqtProperty, Qt, QSize, QTimer)
from PyQt5.QtWidgets import QWidget, QHBoxLayout, QStackedLayout, QSizePolicy
from qutebrowser.browser import browsertab
from qutebrowser.config import confi... |
import asyncio
import contextlib
import functools
from typing import Iterable, List, Union
import discord
from .. import commands
from .predicates import ReactionPredicate
_ReactableEmoji = Union[str, discord.Emoji]
async def menu(
ctx: commands.Context,
pages: Union[List[str], List[discord.Embed]],
co... |
import unittest
import mock
from perfkitbenchmarker import vm_util
from perfkitbenchmarker.providers.digitalocean import util
class TestDoctlAndParse(unittest.TestCase):
def testCommandSucceeds(self):
with mock.patch(vm_util.__name__ + '.IssueCommand',
return_value=('{"a": 1, "b": 2}', '',... |
from datetime import timedelta
import logging
from raincloudy.core import RainCloudy
from requests.exceptions import ConnectTimeout, HTTPError
import voluptuous as vol
from homeassistant.const import (
ATTR_ATTRIBUTION,
CONF_PASSWORD,
CONF_SCAN_INTERVAL,
CONF_USERNAME,
PERCENTAGE,
TIME_DAYS,
... |
import os
import re
import sys
import time
import unittest
from spinners.spinners import Spinners
from halo import HaloNotebook
from halo._utils import get_terminal_columns, is_supported
from tests._utils import decode_utf_8_text, encode_utf_8_text, find_colors, strip_ansi
from termcolor import COLORS
if sys.versi... |
import unittest
import mock
from perfkitbenchmarker import errors
from perfkitbenchmarker.linux_packages import intel_repo
from tests import pkb_common_test_case
class IntelRepoTestCase(pkb_common_test_case.PkbCommonTestCase):
def testAptPrepare(self) -> None:
vm = mock.Mock()
intel_repo.AptPrepare(vm)
... |
import mock
from paasta_tools import deployment_utils
from paasta_tools.utils import DeploymentsJsonV2
@mock.patch("paasta_tools.deployment_utils.load_v2_deployments_json", autospec=True)
def test_get_currently_deployed_sha(mock_load_v2_deployments_json,):
mock_load_v2_deployments_json.return_value = Deployment... |
import argparse
import chainer
from chainer import iterators
import chainermn
from chainercv.utils import apply_to_iterator
from chainercv.utils import ProgressHook
from eval_detection import models
from eval_detection import setup
def main():
parser = argparse.ArgumentParser()
parser.add_argument('--dat... |
import os.path as op
import numpy as np
from numpy.testing import assert_array_almost_equal
import pytest
from mne.io import read_raw_fif
from mne.event import read_events
from mne.epochs import Epochs
from mne.preprocessing.stim import fix_stim_artifact
data_path = op.join(op.dirname(__file__), '..', '..', 'io', '... |
from django.template.loader import render_to_string
from django.urls import reverse
from django.utils.translation import gettext_lazy as _
from weblate.addons.models import ADDONS, Addon
from weblate.trans.models import Change
from weblate.utils.docs import get_doc_url
GUIDELINES = []
def register(cls):
GUIDEL... |
import io
import os
import pytest
from nikola import __main__
from .helper import cd, patch_config
from .test_demo_build import prepare_demo_site
from .test_empty_build import ( # NOQA
test_archive_exists,
test_avoid_double_slash_in_rss,
test_check_files,
test_check_links,
)
def test_index_in_sit... |
import os
import os.path
import sys
from coverage.misc import CoverageException, isolate_module
from coverage.plugin import CoveragePlugin, FileTracer, FileReporter
os = isolate_module(os)
class Plugins(object):
"""The currently loaded collection of coverage.py plugins."""
def __init__(self):
self... |
import logging
import pysmarthab
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.const import CONF_EMAIL, CONF_PASSWORD
# pylint: disable=unused-import
from . import DOMAIN
_LOGGER = logging.getLogger(__name__)
class SmartHabConfigFlow(config_entries.ConfigFlow, domain=DOMAIN... |
from os import mkdir, path
CHUNK_SIZE = 4096 * 10
diff_definition = {
'a': {
'a.txt': lambda: b'',
'c': {
'c.txt': lambda: b''
},
'd': {
'd.txt': lambda: (b'd' * CHUNK_SIZE) + b'd'
},
'e': {
'f': {},
'g': {
... |
from __future__ import print_function
import os
import urwid
from urwid.raw_display import Screen
from zope.interface import Interface, Attribute, implements
from twisted.application.service import Application
from twisted.application.internet import TCPServer
from twisted.cred.portal import Portal
from twisted.con... |
from homeassistant.core import callback
from homeassistant.helpers.event import async_track_time_interval
class AugustSubscriberMixin:
"""Base implementation for a subscriber."""
def __init__(self, hass, update_interval):
"""Initialize an subscriber."""
super().__init__()
self._hass ... |
import os
import datetime
import pytest
from cryptography import x509
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import hashes
from flask import current_app
from flask_principal import identity_changed, Identity
from sqlalchemy.sql import text
from lemur import creat... |
import jsonschema
from jsonschema import ValidationError
from werkzeug.exceptions import abort
from flask import Flask
try:
from http import HTTPStatus
except ImportError:
import httplib as HTTPStatus
try:
import simplejson as json
except ImportError:
import json
from flask import jsonify
from flask im... |
from datetime import timedelta
from homeassistant.const import POWER_WATT, TIME_HOURS, TIME_MINUTES, TIME_SECONDS
from homeassistant.setup import async_setup_component
import homeassistant.util.dt as dt_util
from tests.async_mock import patch
async def test_state(hass):
"""Test derivative sensor state."""
... |
import logging
from homeassistant.components.switch import DOMAIN, SwitchEntity
from . import DOMAIN as CASETA_DOMAIN, LutronCasetaDevice
_LOGGER = logging.getLogger(__name__)
async def async_setup_entry(hass, config_entry, async_add_entities):
"""Set up the Lutron Caseta switch platform.
Adds switches f... |
import voluptuous as vol
from homeassistant.components.switch import (
ENTITY_ID_FORMAT,
PLATFORM_SCHEMA,
SwitchEntity,
)
from homeassistant.const import (
ATTR_ENTITY_ID,
ATTR_FRIENDLY_NAME,
CONF_ENTITY_PICTURE_TEMPLATE,
CONF_ICON_TEMPLATE,
CONF_SWITCHES,
CONF_UNIQUE_ID,
CONF_... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import subprocess
from absl import logging
from absl.testing import _bazelize_command
from absl.testing import absltest
class TestFailFastTest(absltest.TestCase):
"""Integration tests: Runs a te... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import functools
import itertools
import re
import types
import unittest
from absl._collections_abc import abc
from absl.testing import absltest
import six
try:
from absl.testing import _parameterized_asyn... |
from homeassistant.components.switch import SwitchEntity
from .const import ATTR_DISCOVER_DEVICES
from .entity import HMDevice
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the HomeMatic switch platform."""
if discovery_info is None:
return
devices = []
for ... |
from datetime import timedelta
import logging
from typing import Tuple
import pyeverlights
import voluptuous as vol
from homeassistant.components.light import (
ATTR_BRIGHTNESS,
ATTR_EFFECT,
ATTR_HS_COLOR,
PLATFORM_SCHEMA,
SUPPORT_BRIGHTNESS,
SUPPORT_COLOR,
SUPPORT_EFFECT,
LightEntity... |
import pytest
import numpy as np
import tensorflow as tf
import jax
import torch
from tensornetwork.backends import backend_factory
#pylint: disable=line-too-long
from tensornetwork.matrixproductstates.mpo import FiniteMPO, BaseMPO, InfiniteMPO
@pytest.fixture(
name="backend_dtype_values",
params=[('numpy', ... |
import pytest
from homeassistant import auth, data_entry_flow
from homeassistant.auth import auth_store
from homeassistant.auth.providers import legacy_api_password
@pytest.fixture
def store(hass):
"""Mock store."""
return auth_store.AuthStore(hass)
@pytest.fixture
def provider(hass, store):
"""Mock p... |
import time
import arctic.serialization.numpy_records as anr
from tests.unit.serialization.serialization_test_data import _mixed_test_data as input_test_data
df_serializer = anr.DataFrameSerializer()
def _bench(rounds, input_df, fast):
fast = bool(fast)
anr.set_fast_check_df_serializable(fast)
start = ... |
import os
import pytest
import requests
from vcr import VCR
from subliminal.video import Episode, Movie
from subliminal.refiners.omdb import OMDBClient, refine
APIKEY = '00000000'
vcr = VCR(path_transformer=lambda path: path + '.yaml',
record_mode=os.environ.get('VCR_RECORD_MODE', 'once'),
cas... |
import re
from absl import flags
from perfkitbenchmarker import data
from perfkitbenchmarker import linux_packages
from perfkitbenchmarker import regex_util
flags.DEFINE_integer(
'netperf_histogram_buckets', 100,
'The number of buckets per bucket array in a netperf histogram. Netperf '
'keeps one array f... |
import logging
from aiohttp import ClientResponseError
from pysmartthings import APIResponseError, AppOAuth, SmartThings
from pysmartthings.installedapp import format_install_url
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.const import (
CONF_ACCESS_TOKEN,
CONF_CLIENT... |
import os
import unittest
from perfkitbenchmarker import test_util
from perfkitbenchmarker.linux_packages import blazemark
class BlazemarkTestCase(unittest.TestCase, test_util.SamplesTestMixin):
maxDiff = None
def setUp(self):
self.data_dir = os.path.join(os.path.dirname(__file__), '..', 'data')
def te... |
import jwt
import base64
import requests
from flask import Blueprint, current_app
from flask_restful import reqparse, Resource, Api
from flask_principal import Identity, identity_changed
from lemur.constants import SUCCESS_METRIC_STATUS, FAILURE_METRIC_STATUS
from lemur.extensions import metrics
from lemur.common.u... |
import inspect
import logging
import threading
import unittest
from perfkitbenchmarker import log_util
from perfkitbenchmarker import vm_util
from tests import pkb_common_test_case
class LogUtilTestCase(pkb_common_test_case.PkbCommonTestCase):
"""Tests exercising the utilities in log_util."""
def testThreadLog... |
from unittest.mock import patch
import pytest
from homeassistant.core import HomeAssistant
from .common import ComponentFactory
from tests.test_util.aiohttp import AiohttpClientMocker
@pytest.fixture()
def component_factory(
hass: HomeAssistant, aiohttp_client, aioclient_mock: AiohttpClientMocker
):
"""R... |
import logging
from threading import Thread
import requests
GA_TRACKING_ID = "UA-124800612-1"
logging.basicConfig()
logger = logging.getLogger("kalliope")
logger.setLevel(logging.DEBUG)
class GoogleTracking(Thread):
"""
send hit to Google Analytics
allow to anonymously evaluate the global usage of Kal... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.