text stringlengths 213 32.3k |
|---|
import asyncio
from asyncio import TimeoutError as AsyncIOTimeoutError
from aiohttp import ClientError, ClientTimeout
from bond_api import Bond
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import CONF_ACCESS_TOKEN, CONF_HOST
from homeassistant.core import HomeAssistant
from homeassis... |
import logging
import sys
from kalliope.core import FileManager
from kalliope.core.TTS.TTSModule import TTSModule, MissingTTSParameter
logging.basicConfig()
logger = logging.getLogger("kalliope")
# TODO : voicerss lib dependancies are not working as expected in python3
# CF: git : https://github.com/kalliope-projec... |
import asyncio
from collections import deque
from datetime import timedelta
import logging
import aiohttp
import async_timeout
import voluptuous as vol
from homeassistant.components.camera import (
PLATFORM_SCHEMA,
STATE_IDLE,
STATE_RECORDING,
Camera,
)
from homeassistant.components.camera.const impo... |
import numpy as np
import pandas as pd
import xarray as xr
from . import parameterized, randn, requires_dask
nx = 3000
long_nx = 30000000
ny = 2000
nt = 1000
window = 20
randn_xy = randn((nx, ny), frac_nan=0.1)
randn_xt = randn((nx, nt))
randn_t = randn((nt,))
randn_long = randn((long_nx,), frac_nan=0.1)
class R... |
from __future__ import print_function
import pytest
from plumbum import colors
from plumbum.colorlib.styles import ANSIStyle as Style, ColorNotFound
from plumbum.colorlib import htmlcolors
import sys
class TestImportColors:
def testDifferentImports(self):
import plumbum.colors
from plumbum.colors... |
import os.path as op
import numpy as np
from numpy.testing import (assert_array_almost_equal, assert_allclose,
assert_equal)
import pytest
import matplotlib.pyplot as plt
from mne import find_events, Epochs, pick_types
from mne.io import read_raw_fif
from mne.io.array import RawArray
from ... |
from twisted.internet.task import react
from twisted.internet.defer import inlineCallbacks as coroutine
from autobahn.twisted.wamp import Connection
# A single session joins a first realm, leaves and joins another realm
# all over the same, still running transport
@coroutine
def main(transport):
session = Applic... |
import logging
from homeassistant.components.fan import (
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 DOMAIN, SIGNAL_UPDATE_SMARTY
_... |
from kalliope.core.Utils.FileManager import FileManager
from requests.auth import HTTPBasicAuth
from kalliope.core.TTS.TTSModule import TTSModule, MissingTTSParameter
import logging
import requests
logging.basicConfig()
logger = logging.getLogger("kalliope")
API_VERSION = "v1"
TTS_URL = "https://stream.watsonplatfor... |
import logging
from pyqvrpro import Client
from pyqvrpro.client import AuthenticationError, InsufficientPermissionsError
from requests.exceptions import ConnectionError as RequestsConnectionError
import voluptuous as vol
from homeassistant.components.camera import DOMAIN as CAMERA_DOMAIN
from homeassistant.const imp... |
from homeassistant.setup import async_setup_component
from tests.components.light import common
from tests.components.switch import common as switch_common
async def test_default_state(hass):
"""Test light switch default state."""
await async_setup_component(
hass,
"light",
{
... |
from __future__ import print_function
from __future__ import with_statement
import os
import sys
import unittest
import rospkg
from . import pmon
from .baretest import BareTestCase
from .baretest import print_runner_summary
from . core import create_xml_runner
from . core import xml_results_file
from .junitxml impo... |
from kalliope.core.Models.settings.SettingsEntry import SettingsEntry
class Tts(SettingsEntry):
"""
This Class is representing a Text To Speech (TTS) with its name and parameters
.. note:: must be defined in the settings.yml
"""
def __init__(self, name=None, parameters=None):
super(Tts,... |
from typing import Callable
from homeassistant.components.light import SUPPORT_BRIGHTNESS, LightEntity
from homeassistant.config_entries import ConfigEntry
from homeassistant.core import HomeAssistant
from .dynalitebase import DynaliteBase, async_setup_entry_base
async def async_setup_entry(
hass: HomeAssistan... |
import boto3
import os
import subprocess
import sys
import time
from random import shuffle
from src.config import cache_paths, create_cache_directories, NAIP_DATA_DIR, LABELS_DATA_DIR
class NAIPDownloader:
"""Downloads NAIP images from S3, by state/year."""
def __init__(self, number_of_naips, should_randomi... |
from __future__ import absolute_import, unicode_literals
from ._compat import implements_to_string
class TmuxpException(Exception):
"""Base Exception for Tmuxp Errors."""
class ConfigError(TmuxpException):
"""Error parsing tmuxp configuration dict."""
pass
class EmptyConfigException(ConfigError):... |
import asyncio
from datetime import timedelta
import logging
import aiohttp
import async_timeout
import voluptuous as vol
from homeassistant.components.sensor import ENTITY_ID_FORMAT, PLATFORM_SCHEMA
from homeassistant.const import (
ATTR_ATTRIBUTION,
ATTR_ID,
ATTR_LATITUDE,
ATTR_LOCATION,
ATTR_L... |
import contextlib
import os
import random
import string
import tempfile
import pytest
from molecule import config
from molecule import logger
from molecule import util
LOG = logger.get_logger(__name__)
pytest_plugins = ['helpers_namespace']
@pytest.helpers.register
def run_command(cmd, env=os.environ, log=True):... |
from .__about__ import * # noqa: F401,F403 isort: skip
import sys
import traceback
import warnings
import pkg_resources
from pygal import maps
from pygal.config import Config
from pygal.graph.bar import Bar
from pygal.graph.box import Box
from pygal.graph.dot import Dot
from pygal.graph.funnel import Funnel
from p... |
import concurrent
import contextlib
import datetime
import logging
import random
import time
from pathlib import Path
from types import SimpleNamespace
from typing import TYPE_CHECKING, Callable, List, MutableMapping, Optional, Tuple, Union
from redbot.core import Config
from redbot.core.bot import Red
from redbot.c... |
import typing
import pandas as pd
import numpy as np
import matchzoo
def pack(df: pd.DataFrame) -> 'matchzoo.DataPack':
"""
Pack a :class:`DataPack` using `df`.
The `df` must have `text_left` and `text_right` columns. Optionally,
the `df` can have `id_left`, `id_right` to index `text_left` and
... |
from typing import Dict
from homeassistant.components.device_tracker import SOURCE_TYPE_GPS
from homeassistant.components.device_tracker.config_entry import TrackerEntity
from homeassistant.config_entries import ConfigEntry
from homeassistant.core import callback
from homeassistant.helpers.dispatcher import async_dis... |
import unittest
import os
import sys
from kalliope.core.Utils.FileManager import FileManager
class TestFileManager(unittest.TestCase):
"""
Class to test FileManager
"""
def setUp(self):
pass
def create_file_manager(self):
file_manager = FileManager()
self.assertIsInstan... |
import logging
from datetime import datetime
from itertools import islice
from .cursors import mod_cursor
import dateutil.parser as iso_date
logger = logging.getLogger(__name__)
# prevent sqlite3 from throwing too many arguments errors (#145)
def gen_slice(list_, length=100):
it = iter(list_)
while True:
... |
import pytest
from samsungctl.exceptions import AccessDenied, UnhandledResponse
from samsungtvws.exceptions import ConnectionFailure
from websocket import WebSocketProtocolException
from homeassistant.components.samsungtv.const import (
CONF_MANUFACTURER,
CONF_MODEL,
DOMAIN,
)
from homeassistant.component... |
import pytest
from tests.async_mock import patch
@pytest.fixture
def patch_load_json():
"""Prevent load JSON being used."""
with patch("homeassistant.components.ps4.load_json", return_value={}) as mock_load:
yield mock_load
@pytest.fixture
def patch_save_json():
"""Prevent save JSON being used... |
from homeassistant.const import ATTR_ENTITY_ID, ATTR_SERVICE
from homeassistant.core import callback
from .const import ATTR_DISPLAY_NAME, ATTR_VALUE, DOMAIN, EVENT_HOMEKIT_CHANGED
@callback
def async_describe_events(hass, async_describe_event):
"""Describe logbook events."""
@callback
def async_descri... |
from abc import ABCMeta, abstractmethod
from qstrader.signals.buffer import AssetPriceBuffers
class Signal(object):
"""
Abstract class to provide historical price range-based
rolling signals utilising deque-based 'buffers'.
Parameters
----------
start_dt : `pd.Timestamp`
The startin... |
from homeassistant.core import callback
from homeassistant.helpers.storage import Store
from homeassistant.loader import bind_hass
from . import views
from .const import DOMAIN, STEP_CORE_CONFIG, STEP_INTEGRATION, STEP_USER, STEPS
STORAGE_KEY = DOMAIN
STORAGE_VERSION = 3
class OnboadingStorage(Store):
"""Store... |
from __future__ import absolute_import
import contextlib
import sys
import unittest
import warnings
import six
# pylint: disable=invalid-name
if six.PY2:
_subtest_msg_sentinel = object()
class _ShouldStop(Exception):
"""The test should stop."""
class _Outcome(object):
def __init__(self, result=Non... |
import unittest
import numpy as np
import numpy.testing as npt
from pgmpy.utils import optimize, pinverse
from pgmpy.global_vars import device, dtype
try: # pragma: no cover
import torch
except ImportError: # pragma: no cover
torch = None
class TestOptimize(unittest.TestCase):
"""
self = TestOpti... |
from homeassistant.components.alarm_control_panel import (
DOMAIN as ALARM_CONTROL_PANEL_DOMAIN,
)
from homeassistant.components.homematicip_cloud import DOMAIN as HMIPC_DOMAIN
from homeassistant.const import (
STATE_ALARM_ARMED_AWAY,
STATE_ALARM_ARMED_HOME,
STATE_ALARM_DISARMED,
STATE_ALARM_TRIGGE... |
from __future__ import division
import numpy as np
from chainer.backends import cuda
from chainercv.utils.bbox._nms_gpu_post import _nms_gpu_post
if cuda.available:
import cupy as cp
def non_maximum_suppression(bbox, thresh, score=None,
limit=None):
"""Suppress bounding boxes ... |
import unittest
from uiautomator import Selector
class TestSelector(unittest.TestCase):
fields = {
"text": (0x01, None), # MASK_TEXT,
"textContains": (0x02, None), # MASK_TEXTCONTAINS,
"textMatches": (0x04, None), # MASK_TEXTMATCHES,
"textStartsWith": (0x08, None), # MASK_TEX... |
from crispy_forms.helper import FormHelper
from crispy_forms.layout import Div, Field, Layout
from django import forms
from django.core.exceptions import ValidationError
from django.utils.translation import gettext_lazy as _
from django.utils.translation import pgettext_lazy
from weblate.glossary.models import Glossa... |
from collections import Counter
from unittest import TestCase
from scattertext.features.FeatsFromTopicModel import FeatsFromTopicModel
class TestFeatsFromTopicModel(TestCase):
def test_get_doc_get_feats(self):
expected = Counter({'a b': 2, 'c e f': 1, 'b': 1})
actual = FeatsFromTopicModel(
... |
from absl import flags
from perfkitbenchmarker import network
from perfkitbenchmarker import providers
from perfkitbenchmarker import vm_util
from perfkitbenchmarker.providers.cloudstack import util
FLAGS = flags.FLAGS
class CloudStackNetwork(network.BaseNetwork):
"""Object representing a CloudStack Network."""
... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
from compare_gan import datasets
from compare_gan.metrics import eval_task
import matplotlib
matplotlib.use("Agg")
import matplotlib.pyplot as plt # pylint: disable=g-import-not-at-top
import num... |
import logging
from homeassistant.components.switch import SwitchEntity
from . import DOMAIN
from .const import (
KEY_CONSUMER,
KEY_IDENTIFIER,
KEY_MEASUREMENT,
KEY_PARENT_MAC,
KEY_PARENT_NAME,
KEY_UNIT,
PERIPHERAL_STATE_OFF,
PERIPHERAL_STATE_ON,
)
_LOGGER = logging.getLogger(__name_... |
from homeassistant import config_entries, setup
from homeassistant.components.NEW_DOMAIN.config_flow import CannotConnect, InvalidAuth
from homeassistant.components.NEW_DOMAIN.const import DOMAIN
from tests.async_mock import patch
async def test_form(hass):
"""Test we get the form."""
await setup.async_setu... |
from datetime import timedelta
import logging
from ProgettiHWSW.input import Input
import async_timeout
from homeassistant.components.binary_sensor import BinarySensorEntity
from homeassistant.helpers.update_coordinator import (
CoordinatorEntity,
DataUpdateCoordinator,
)
from . import setup_input
from .con... |
import typing
import functools
from .units.unit import Unit
def chain_transform(units: typing.List[Unit]) -> typing.Callable:
"""
Compose unit transformations into a single function.
:param units: List of :class:`matchzoo.StatelessUnit`.
"""
@functools.wraps(chain_transform)
def wrapper(ar... |
from homeassistant.components.binary_sensor import (
DEVICE_CLASS_MOTION,
BinarySensorEntity,
)
from homeassistant.helpers import entity_platform
from .const import DATA_COORDINATOR, DOMAIN
from .entity import RiscoEntity
SERVICE_BYPASS_ZONE = "bypass_zone"
SERVICE_UNBYPASS_ZONE = "unbypass_zone"
async def... |
import os
from mayavi.core.ui.mayavi_scene import MayaviScene
from mayavi.tools.mlab_scene_model import MlabSceneModel
import numpy as np
from pyface.api import confirm, error, FileDialog, OK, YES
from traits.api import (HasTraits, HasPrivateTraits, on_trait_change,
cached_property, DelegatesT... |
from unittest import mock
from vcr import mode
from vcr.stubs import VCRHTTPSConnection
from vcr.cassette import Cassette
class TestVCRConnection:
def test_setting_of_attributes_get_propogated_to_real_connection(self):
vcr_connection = VCRHTTPSConnection("www.examplehost.com")
vcr_connection.ssl... |
from datetime import timedelta
import pytest
from homeassistant.components.cover import (
ATTR_CURRENT_POSITION,
ATTR_CURRENT_TILT_POSITION,
ATTR_POSITION,
ATTR_TILT_POSITION,
DOMAIN,
)
from homeassistant.const import (
ATTR_ENTITY_ID,
ATTR_SUPPORTED_FEATURES,
SERVICE_CLOSE_COVER,
... |
from flexx import flx
class Relay(flx.Component):
""" Global object to relay messages to all participants.
"""
@flx.emitter
def create_message(self, name, message):
return dict(name=name, message=message)
@flx.emitter
def new_name(self):
return {}
# Create global relay
rela... |
import logging
import requests
import voluptuous as vol
from homeassistant.components.device_tracker import (
DOMAIN,
PLATFORM_SCHEMA,
DeviceScanner,
)
from homeassistant.const import CONF_HOST, HTTP_OK
import homeassistant.helpers.config_validation as cv
DEFAULT_TIMEOUT = 10
_LOGGER = logging.getLogge... |
from rest_framework import serializers
from shop.models.product import ProductModel
class ProductSelectSerializer(serializers.ModelSerializer):
"""
A simple serializer to convert the product's name and code used for rendering the
`Select2 Widget`_'s content, while looking up for a certain product.
Th... |
import io
import json
import logging
from zipfile import ZipFile
from babelfish import Language
from guessit import guessit
from requests import Session
from six.moves import urllib
from . import Provider
from ..cache import EPISODE_EXPIRATION_TIME, region
from ..exceptions import ProviderError
from ..matches import... |
from __future__ import print_function
import os
import sys
import argparse
import time
import fnmatch
from functools import partial
class FilePredicate(object):
def __init__(self):
self.funclist = []
def add_filter(self, func):
self.funclist.append(func)
def run(self, paths):
n... |
from homeassistant.components.notify import ATTR_DATA, BaseNotificationService
from . import DOMAIN
async def async_get_service(hass, config, discovery_info=None):
"""Return the notify service."""
client = hass.data[DOMAIN]
return KebaNotificationService(client)
class KebaNotificationService(BaseNoti... |
import logging
from pyaehw4a1.aehw4a1 import AehW4a1
import pyaehw4a1.exceptions
from homeassistant.components.climate import ClimateEntity
from homeassistant.components.climate.const import (
FAN_AUTO,
FAN_HIGH,
FAN_LOW,
FAN_MEDIUM,
HVAC_MODE_COOL,
HVAC_MODE_DRY,
HVAC_MODE_FAN_ONLY,
... |
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_fail_fast_test."""
def testA(self):
sys.stderr.write('\nclass A test A\n')
def te... |
import logging
from homeassistant.components.switch import SwitchEntity
from homeassistant.core import callback
from homeassistant.helpers.dispatcher import async_dispatcher_connect
from . import (
CONF_DEVICE_CODE,
CONF_SWITCHABLE_OUTPUTS,
CONF_ZONE_NAME,
DATA_SATEL,
SIGNAL_OUTPUTS_UPDATED,
)
_... |
import logging
from homeassistant.const import (
ATTR_BATTERY_LEVEL,
DEVICE_CLASS_BATTERY,
DEVICE_CLASS_HUMIDITY,
DEVICE_CLASS_ILLUMINANCE,
DEVICE_CLASS_POWER,
DEVICE_CLASS_PRESSURE,
DEVICE_CLASS_TEMPERATURE,
LIGHT_LUX,
PERCENTAGE,
POWER_WATT,
PRESSURE_HPA,
TEMP_CELSIUS... |
import os
import base64
import numpy as np
import flexx
from flexx.util.icon import Icon
# colors:
# (70, 140, 210) - Python blue
# (240, 80, 80) - a strong red
def create_icon(N=16, COLOR=(240, 80, 80)):
im = np.zeros((N, N), np.bool)
row_index = [0, 1, 1, 1, 1, 0, 2, 2, 2, 2, 0, 3, 3, 3, 3, 0]
co... |
import copy
import pytest
from molecule import config
from molecule import scenario
from molecule import scenarios
@pytest.fixture
def _instance(config_instance):
config_instance_1 = copy.deepcopy(config_instance)
config_instance_2 = copy.deepcopy(config_instance)
config_instance_2.config['scenario'][... |
import errno
import os
import shutil
import socket
import ssl
import subprocess
import sys
import tempfile
import threading
import time
from configparser import RawConfigParser
from urllib import request
from urllib.error import HTTPError, URLError
import pytest
from radicale import config, server
from radicale.test... |
from __future__ import absolute_import
import unittest, gc
from .common_imports import etree, HelperTestCase, _bytes, BytesIO
xml_str = _bytes('''\
<root xmlns="myNS" xmlns:other="otherNS">
<c1 a1="A1" a2="A2" other:a3="A3">
<c2 a1="C2">0</c2>
<c2>1</c2>
<other:c2>2</other:c2>
</c1>
</root>''')
cl... |
from marshmallow import fields
from lemur.common.fields import ArrowDateTime
from lemur.common.schema import LemurInputSchema, LemurOutputSchema
class DnsProvidersNestedOutputSchema(LemurOutputSchema):
__envelope__ = False
id = fields.Integer()
name = fields.String()
provider_type = fields.String()
... |
import os
import pandas as pd
from qstrader.asset.equity import Equity
from qstrader.broker.simulated_broker import SimulatedBroker
from qstrader.broker.fee_model.zero_fee_model import ZeroFeeModel
from qstrader.data.backtest_data_handler import BacktestDataHandler
from qstrader.data.daily_bar_csv import CSVDailyBar... |
from behave import given
from behave import then
from behave import when
from paasta_tools.cli.utils import x_mark
from paasta_tools.utils import _run
@given('a "{service_type}" service')
@given('an "{service_type}" service')
def given_service(context, service_type):
context.service = "fake_%s_service" % servic... |
import os.path as op
import shutil
import os
import datetime as dt
import pytest
from numpy.testing import assert_allclose, assert_array_equal
from mne import pick_types
from mne.datasets.testing import data_path, requires_testing_data
from mne.io import read_raw_nirx
from mne.io.tests.test_raw import _test_raw_read... |
import re
import requests_mock
from homeassistant.components.uk_transport.sensor import (
ATTR_ATCOCODE,
ATTR_CALLING_AT,
ATTR_LOCALITY,
ATTR_NEXT_BUSES,
ATTR_NEXT_TRAINS,
ATTR_STATION_CODE,
ATTR_STOP_NAME,
CONF_API_APP_ID,
CONF_API_APP_KEY,
UkTransportSensor,
)
from homeassis... |
import homeassistant.scripts as scripts
from tests.async_mock import patch
@patch("homeassistant.scripts.get_default_config_dir", return_value="/default")
def test_config_per_platform(mock_def):
"""Test config per platform method."""
assert scripts.get_default_config_dir() == "/default"
assert scripts.e... |
from songpal import SongpalException
from homeassistant.components.songpal.const import CONF_ENDPOINT
from homeassistant.const import CONF_NAME
from tests.async_mock import AsyncMock, MagicMock, patch
FRIENDLY_NAME = "name"
ENTITY_ID = f"media_player.{FRIENDLY_NAME}"
HOST = "0.0.0.0"
ENDPOINT = f"http://{HOST}:1000... |
from django.db import migrations
from weblate.gitexport.models import SUPPORTED_VCS, get_export_url
def set_export_url(apps, schema_editor):
Component = apps.get_model("trans", "Component")
db_alias = schema_editor.connection.alias
matching = (
Component.objects.using(db_alias)
.filter(v... |
import os
import testinfra.utils.ansible_runner
testinfra_hosts = testinfra.utils.ansible_runner.AnsibleRunner(
os.environ['MOLECULE_INVENTORY_FILE']).get_hosts('all')
def test_hostname(host):
assert 'instance' == host.check_output('hostname -s')
def test_etc_molecule_directory(host):
f = host.file('... |
import json
from scattertext.Common import DEFAULT_DIV_ID, DEFAULT_D3_AXIS_VALUE_FORMAT
class InvalidProtocolException(Exception):
pass
class ScatterplotStructure(object):
def __init__(
self,
visualization_data,
width_in_pixels=None,
height_in_pixels=None,
... |
import urllib2
import diamond.collector
try:
import simplejson as json
except ImportError:
import json
class FlumeCollector(diamond.collector.Collector):
# items to collect
_metrics_collect = {
'CHANNEL': [
'ChannelFillPercentage',
'EventPutAttemptCount',
... |
from __future__ import print_function, absolute_import
import re
import os
import sys
import logging
if sys.version_info[0] == 2: # pragma: no cover
from ConfigParser import ConfigParser as _ConfigParser
from StringIO import StringIO
class ConfigParser(_ConfigParser):
def read_string(self, stri... |
from datetime import datetime, timedelta
import logging
from august.activity import ActivityType
from august.lock import LockDoorStatus
from august.util import update_lock_detail_from_activity
from homeassistant.components.binary_sensor import (
DEVICE_CLASS_CONNECTIVITY,
DEVICE_CLASS_DOOR,
DEVICE_CLASS_... |
import logging
from django.core.management.base import BaseCommand as DjangoBaseCommand
class BaseCommand(DjangoBaseCommand):
requires_system_checks = False
def execute(self, *args, **options):
logger = logging.getLogger("weblate")
if not any(handler.get_name() == "console" for handler in l... |
from copy import deepcopy
import pydeconz
import pytest
from homeassistant.components.binary_sensor import DOMAIN as BINARY_SENSOR_DOMAIN
from homeassistant.components.climate import DOMAIN as CLIMATE_DOMAIN
from homeassistant.components.cover import DOMAIN as COVER_DOMAIN
from homeassistant.components.deconz.config... |
import os
import unittest
import responses
import smart_open.http
import smart_open.s3
import smart_open.constants
BYTES = b'i tried so hard and got so far but in the end it doesn\'t even matter'
URL = 'http://localhost'
HTTPS_URL = 'https://localhost'
HEADERS = {
'Content-Length': str(len(BYTES)),
'Accept... |
import os
import os.path
import pytest
import jinja2
from PyQt5.QtCore import QUrl
import qutebrowser
class JSTester:
"""Common subclass providing basic functionality for all JS testers.
Attributes:
tab: The tab object which is used.
qtbot: The QtBot fixture from pytest-qt.
_jinj... |
from unittest.mock import patch
from homeassistant import config_entries, data_entry_flow
from homeassistant.components import sonos
from homeassistant.setup import async_setup_component
from tests.common import mock_coro
async def test_creating_entry_sets_up_media_player(hass):
"""Test setting up Sonos loads ... |
import logging
from homeassistant.const import (
CONF_MONITORED_CONDITIONS,
DEVICE_CLASS_HUMIDITY,
DEVICE_CLASS_TEMPERATURE,
PERCENTAGE,
STATE_OFF,
TEMP_CELSIUS,
TEMP_FAHRENHEIT,
)
from . import CONF_SENSORS, DATA_NEST, DATA_NEST_CONFIG, NestSensorDevice
SENSOR_TYPES = ["humidity", "oper... |
import numpy as np
import unittest
from chainer import testing
from chainercv.experimental.links.model.pspnet import convolution_crop
class TestConvolutionCrop(unittest.TestCase):
def test_convolution_crop(self):
size = (8, 6)
stride = (8, 6)
n_channel = 3
img = np.random.unifor... |
import re
import click
mention_re = re.compile(r'@<(?:(?P<name>\S+?)\s+)?(?P<url>\S+?://.*?)>')
short_mention_re = re.compile(r'@(?P<name>\w+)')
def get_source_by_url(url):
conf = click.get_current_context().obj["conf"]
if url == conf.twturl:
return conf.source
return next((source for source in... |
from pylutron_caseta.smartbridge import Smartbridge
from homeassistant import config_entries, data_entry_flow
from homeassistant.components.lutron_caseta import DOMAIN
import homeassistant.components.lutron_caseta.config_flow as CasetaConfigFlow
from homeassistant.components.lutron_caseta.const import (
CONF_CA_C... |
from homeassistant.components.directv.const import CONF_RECEIVER_ID, DOMAIN
from homeassistant.components.ssdp import ATTR_SSDP_LOCATION
from homeassistant.const import (
CONF_HOST,
CONTENT_TYPE_JSON,
HTTP_FORBIDDEN,
HTTP_INTERNAL_SERVER_ERROR,
)
from homeassistant.helpers.typing import HomeAssistantTy... |
import urwid.curses_display
import urwid.raw_display
import urwid.web_display
import urwid
import sys
if urwid.web_display.is_web_request():
Screen = urwid.web_display.Screen
else:
if len(sys.argv)>1 and sys.argv[1][:1] == "r":
Screen = urwid.raw_display.Screen
else:
Screen = urwid.curses... |
import pytest
from homeassistant.setup import async_setup_component
import homeassistant.util.dt as dt_util
@pytest.fixture
def time_zone():
"""Fixture for time zone."""
return dt_util.get_time_zone("America/New_York")
async def test_time(hass, time_zone):
"""Test the time at a different location."""
... |
import pytest
from django.contrib.auth import get_user_model
from django.contrib.auth.models import AnonymousUser
from django.contrib.sessions.backends.cache import SessionStore
from shop.models.customer import VisitingCustomer
from testshop.models import Customer
@pytest.mark.django_db
def test_visiting_customer(rf... |
import os
import pytest
from molecule import config
from molecule.driver import azure
# NOTE(retr0h): The use of the `patched_config_validate` fixture, disables
# config.Config._validate from executing. Thus preventing odd side-effects
# throughout patched.assert_called unit tests.
@pytest.fixture
def _instance(p... |
from __future__ import unicode_literals
import posixpath
from os import path
from docutils import nodes
from docutils.parsers.rst.directives import flag, images, nonnegative_int
from sphinx.errors import SphinxError
from sphinx.util import ensuredir, logging, relative_uri
try:
from hashlib import sha1 as sha
ex... |
import logging
from kalliope.core import Utils
logging.basicConfig()
logger = logging.getLogger("kalliope")
class PlayerLauncher(object):
def __init__(self):
pass
@staticmethod
def get_player(settings):
"""
Instantiate a Player
:param settings: setting object
:t... |
import logging
from threading import Thread
from kalliope.core import SignalModule
logging.basicConfig()
logger = logging.getLogger("kalliope")
class Geolocation(SignalModule, Thread):
def __init__(self, **kwargs):
super(Geolocation, self).__init__(**kwargs)
Thread.__init__(self, name=Geolocati... |
from redbot.cogs.permissions.permissions import Permissions, GLOBAL
def test_schema_update():
old = {
str(GLOBAL): {
"owner_models": {
"cogs": {
"Admin": {"allow": [78631113035100160], "deny": [96733288462286848]},
"Audio": {"allow": [13... |
import sys
import mne
from mne.utils import _check_option
def run():
"""Run command."""
from mne.commands.utils import get_optparser, _add_verbose_flag
parser = get_optparser(__file__)
parser.add_option('-s', '--subject',
dest='subject',
help='Subject nam... |
import numpy as np
import unittest
import chainer
from chainer import testing
from chainer.testing import attr
from chainercv.links import SSD300
from chainercv.links import SSD512
@testing.parameterize(*testing.product({
'insize': [300, 512],
'n_fg_class': [1, 5, 20],
}))
class TestSSDVGG16(unittest.TestC... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import pytest
import numpy as np
import tensornetwork as tn
from tensornetwork.backends import backend_factory
from tensornetwork.matrixproductstates.base_mps import BaseMPS
import tensorflow as tf
from jax.co... |
revision = "9f79024fe67b"
down_revision = "ee827d1e1974"
from alembic import op
import sqlalchemy as sa
def upgrade():
op.sync_enum_values(
"public",
"log_type",
["create_cert", "key_view", "revoke_cert", "update_cert"],
["create_cert", "delete_cert", "key_view", "revoke_cert", "... |
import logging
import threading
from uuid import UUID
from pygatt import BLEAddressType
from pygatt.backends import Characteristic, GATTToolBackend
from pygatt.exceptions import BLEError, NotConnectedError, NotificationTimeout
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from ... |
from __future__ import unicode_literals
from lib.fun.fun import cool
from lib.fun.decorator import magic
from lib.data.data import pyoptions
def ftp_magic(*args):
"""[keyword1] [keyword2] ..."""
args = list(args[0])
if len(args) == 1:
exit(pyoptions.CRLF + cool.fuchsia("[!] Usage: {} {}".format(... |
from utils import WriterTC
from logilab.common.testlib import TestCase, unittest_main
from logilab.common.ureports.text_writer import TextWriter
class TextWriterTC(TestCase, WriterTC):
def setUp(self):
self.writer = TextWriter()
# Section tests ########################################################... |
import numpy as np
import unittest
import chainer
from chainer.datasets import TupleDataset
from chainer.iterators import SerialIterator
from chainer import testing
from chainercv.extensions import DetectionCOCOEvaluator
from chainercv.utils import generate_random_bbox
from chainercv.utils.testing import attr
from ... |
from rest_framework import renderers
from rest_framework.exceptions import APIException
from shop.models.cart import CartModel
from shop.serializers.cart import CartSerializer
class TemplateContextMixin:
"""
Alternative implementation which does not pollute the template context with
the serialized data ... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.