text stringlengths 213 32.3k |
|---|
import avea # pylint: disable=import-error
from homeassistant.components.light import (
ATTR_BRIGHTNESS,
ATTR_HS_COLOR,
SUPPORT_BRIGHTNESS,
SUPPORT_COLOR,
LightEntity,
)
from homeassistant.exceptions import PlatformNotReady
import homeassistant.util.color as color_util
SUPPORT_AVEA = SUPPORT_BRI... |
import asyncio
import logging
from bravia_tv.braviarc import NoIPControl
import voluptuous as vol
from homeassistant.components.media_player import (
DEVICE_CLASS_TV,
PLATFORM_SCHEMA,
MediaPlayerEntity,
)
from homeassistant.components.media_player.const import (
SUPPORT_NEXT_TRACK,
SUPPORT_PAUSE,... |
import itertools
import warnings
from collections import Counter
from scattertext.ParsedCorpus import ParsedCorpus
class FeatsFromGensim(object):
def __init__(self, phrases, gram_size):
'''
Parameters
----------
phrases : list[gensim.models.Phrases]
gram_size : int, maximum number of words per phrase
k... |
from weblate.machinery.base import MachineTranslation
class DummyTranslation(MachineTranslation):
"""Dummy machine translation for testing purposes."""
name = "Dummy"
def download_languages(self):
"""Dummy translation supports just Czech language."""
return ("en", "cs")
def downloa... |
import functools
import itertools
import warnings
import numpy as np
from ..core.formatting import format_item
from .utils import (
_infer_xy_labels,
_process_cmap_cbar_kwargs,
import_matplotlib_pyplot,
label_from_attrs,
)
# Overrides axes.labelsize, xtick.major.size, ytick.major.size
# from mpl.rcP... |
from pathlib import Path
from typing import Final
from redbot.core.i18n import Translator
_ = Translator("Audio", Path(__file__))
class Equalizer:
def __init__(self):
self.band_count: Final[int] = 15
self.bands = [0.0 for _loop_counter in range(self.band_count)]
def set_gain(self, band: in... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import pytest
import numpy as np
import time
from tensornetwork.backends import backend_factory
from tensornetwork.matrixproductstates.finite_mps import FiniteMPS
from tensornetwork.ncon_interface import ncon
... |
from datetime import datetime
from typing import cast
import discord
from redbot.core import commands, i18n, checks
from redbot.core.utils.common_filters import (
filter_invites,
filter_various_mentions,
escape_spoilers_and_mass_mentions,
)
from redbot.core.utils.mod import get_audit_reason
from .abc impo... |
from scrapy import signals
from scrapy.exceptions import DontCloseSpider
from scrapy.spiders import Spider, CrawlSpider
from collections import Iterable
from . import connection, defaults
from .utils import bytes_to_str
class RedisMixin(object):
"""Mixin class to implement reading urls from a redis queue."""
... |
import os
import unittest
class RoslibManifestlibTest(unittest.TestCase):
def test_ManifestException(self):
from roslib.manifestlib import ManifestException
self.assert_(isinstance(ManifestException(), Exception))
def test_Platform(self):
from roslib.manifestlib import Platform
... |
from homeassistant.core import Config, HomeAssistant
from .config_flow import IpmaFlowHandler # noqa: F401
from .const import DOMAIN # noqa: F401
DEFAULT_NAME = "ipma"
async def async_setup(hass: HomeAssistant, config: Config) -> bool:
"""Set up configured IPMA."""
return True
async def async_setup_ent... |
from datetime import timedelta
import logging
from aiohttp import ClientConnectorError
from pygti.exceptions import InvalidAuth
from pytz import timezone
from homeassistant.const import ATTR_ATTRIBUTION, ATTR_ID, DEVICE_CLASS_TIMESTAMP
from homeassistant.helpers import aiohttp_client
from homeassistant.helpers.entit... |
from homeassistant.components.emulated_hue import Config
from tests.async_mock import MagicMock, Mock, patch
def test_config_google_home_entity_id_to_number():
"""Test config adheres to the type."""
mock_hass = Mock()
mock_hass.config.path = MagicMock("path", return_value="test_path")
conf = Config(... |
import os.path as op
import numpy as np
from numpy.testing import (assert_array_almost_equal, assert_array_equal,
assert_equal, assert_allclose)
import pytest
from scipy import linalg
import scipy.io
import mne
from mne import pick_types, Epochs, find_events, read_events
from mne.datasets.... |
import re
from datetime import date
from hashlib import md5
from urllib.parse import urlencode
from django.conf import settings
from django.contrib.auth import get_user_model
from django.contrib.contenttypes.models import ContentType
from django.db.models import Count
from django.db.models import Q
from django.templa... |
import unittest2
import socket
from psdash.net import NetIOCounters
class TestNet(unittest2.TestCase):
def setUp(self):
self.io_counter = NetIOCounters()
def test_first_time_return(self):
self.assertEqual(self.io_counter.get(), None)
def test_one_update_gives_defaulted_rates(self):
... |
import datetime
import os
DATETIME_FORMAT = '{:%m_%d_%Y_%H_%M_}'
DATETIME_TITLE_FORMAT = '{: %m %d %Y %H %M}'
CHART_TITLE_PREFIX = 'Sysbench TPS'
X_LABEL = 'Thread Count'
Y_LABEL = 'TPS'
# This variable controls the verticle lines inside the chart.
# 0 means no vertical lines.
Y_TICS = '100'
DEFAULT_ITERATIONS =... |
import asyncio
from collections import OrderedDict
import logging
from satel_integra.satel_integra import AlarmState
import homeassistant.components.alarm_control_panel as alarm
from homeassistant.components.alarm_control_panel.const import (
SUPPORT_ALARM_ARM_AWAY,
SUPPORT_ALARM_ARM_HOME,
)
from homeassista... |
from collections import OrderedDict
from datetime import timedelta
import logging
import pytest
import voluptuous as vol
from homeassistant.const import ENTITY_MATCH_ALL, ENTITY_MATCH_NONE
import homeassistant.core as ha
from homeassistant.exceptions import PlatformNotReady
from homeassistant.helpers import discover... |
import os
import arrow
from jinja2 import Environment, FileSystemLoader, select_autoescape
from lemur.plugins.utils import get_plugin_option
loader = FileSystemLoader(searchpath=os.path.dirname(os.path.realpath(__file__)))
env = Environment(
loader=loader, # nosec: potentially dangerous types esc.
autoescap... |
import requests_mock
from homeassistant.components.starline import config_flow
TEST_APP_ID = "666"
TEST_APP_SECRET = "appsecret"
TEST_APP_CODE = "appcode"
TEST_APP_TOKEN = "apptoken"
TEST_APP_SLNET = "slnettoken"
TEST_APP_SLID = "slidtoken"
TEST_APP_UID = "123"
TEST_APP_USERNAME = "sluser"
TEST_APP_PASSWORD = "slpas... |
from datetime import timedelta
import logging
from homeassistant.components.light import (
ATTR_BRIGHTNESS,
ATTR_TRANSITION,
DOMAIN,
SUPPORT_BRIGHTNESS,
SUPPORT_TRANSITION,
LightEntity,
)
from . import DOMAIN as CASETA_DOMAIN, LutronCasetaDevice
_LOGGER = logging.getLogger(__name__)
def to... |
import os
import platform
import threading
import time
from http.client import HTTPConnection
from distutils.spawn import find_executable
import pytest
from path import Path
from more_itertools import consume
import portend
import cherrypy
from cherrypy._cpcompat import HTTPSConnection
from cherrypy.lib import sessi... |
import logging
import voluptuous as vol
from homeassistant.components.switch import (
ENTITY_ID_FORMAT,
PLATFORM_SCHEMA,
SwitchEntity,
)
from homeassistant.const import (
CONF_COMMAND_OFF,
CONF_COMMAND_ON,
CONF_COMMAND_STATE,
CONF_FRIENDLY_NAME,
CONF_SWITCHES,
CONF_VALUE_TEMPLATE,... |
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 ntp import NtpCollector
##########################################################################
class TestNtpCollector(Col... |
import yaml
def test_trivia_lists():
from redbot.cogs.trivia import get_core_lists
list_names = get_core_lists()
assert list_names
problem_lists = []
for l in list_names:
with l.open(encoding="utf-8") as f:
try:
dict_ = yaml.safe_load(f)
except yam... |
from collections import OrderedDict, defaultdict
import json
from typing import Dict
from .model import Config, Integration
BASE = """
\"\"\"Automatically generated by hassfest.
To update, run python3 -m script.hassfest
\"\"\"
# fmt: off
SSDP = {}
""".strip()
def sort_dict(value):
"""Sort a dictionary."""
... |
import logging
import re
import voluptuous as vol
from homeassistant.components import mqtt
import homeassistant.components.alarm_control_panel as alarm
from homeassistant.components.alarm_control_panel.const import (
SUPPORT_ALARM_ARM_AWAY,
SUPPORT_ALARM_ARM_CUSTOM_BYPASS,
SUPPORT_ALARM_ARM_HOME,
SU... |
import re
import requests_mock
from homeassistant.components.sigfox.sensor import (
API_URL,
CONF_API_LOGIN,
CONF_API_PASSWORD,
)
from homeassistant.setup import async_setup_component
TEST_API_LOGIN = "foo"
TEST_API_PASSWORD = "ebcd1234"
VALID_CONFIG = {
"sensor": {
"platform": "sigfox",
... |
import tensorflow as tf
from scipy.misc import imread, imresize
import numpy as np
# Quantize
use_quantized_graph = True
# Read image
img = imread("/home/zehao/Desktop/dog.png")
img = imresize(img, (224, 224, 3))
img = img.astype(np.float32)
img = np.expand_dims(img, 0)
# Preprocess
img = img / 255.
img = img - 0.5... |
from datetime import timedelta
import logging
from typing import Optional
import voluptuous as vol
from homeassistant.components import mqtt, sensor
from homeassistant.components.sensor import DEVICE_CLASSES_SCHEMA
from homeassistant.const import (
CONF_DEVICE,
CONF_DEVICE_CLASS,
CONF_FORCE_UPDATE,
C... |
from typing import Tuple
from PIL import ImageDraw
def draw_box(
draw: ImageDraw,
box: Tuple[float, float, float, float],
img_width: int,
img_height: int,
text: str = "",
color: Tuple[int, int, int] = (255, 255, 0),
) -> None:
"""
Draw a bounding box on and image.
The bounding b... |
import os.path as op
import pytest as pytest
import numpy as np
from numpy.testing import assert_allclose
from mne.datasets.testing import data_path
from mne.io import read_raw_nirx, BaseRaw
from mne.preprocessing.nirs import optical_density
from mne.utils import _validate_type
from mne.datasets import testing
fnam... |
import io
import os
import lxml
import pytest
from nikola import __main__
from .helper import append_config, 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,
)
def test_relativ... |
import numpy as np
import unittest
from chainercv.utils import assert_is_image
from chainercv.utils import testing
@testing.parameterize(
{
'img': np.random.randint(0, 256, size=(3, 48, 64)),
'color': True, 'check_range': True, 'valid': True},
{
'img': np.random.randint(0, 256, size=... |
from collections import OrderedDict
from copy import deepcopy
import logging
import json
import numpy as np
from .check import _check_pandas_installed, _check_preload, _validate_type
from ._logging import warn, verbose
from .numerics import object_size, object_hash
logger = logging.getLogger('mne') # one selectio... |
import numpy as np
from ... import pick_types
from ...io import BaseRaw
from ...utils import _validate_type
from ...io.pick import _picks_to_idx
def temporal_derivative_distribution_repair(raw):
"""Apply temporal derivative distribution repair to data.
Applies temporal derivative distribution repair (TDDR)... |
from django.conf import settings
from django.template.loader import select_template
from django.urls import NoReverseMatch, reverse
from django.utils.translation import get_language_from_request
from cms.models.pagemodel import Page
from rest_framework.serializers import CharField, BooleanField
from rest_auth import s... |
import json
from perfkitbenchmarker import resource
from perfkitbenchmarker.providers import aws
from perfkitbenchmarker.providers.aws import util
def GetAwsVpcEndpointClass(aws_service):
"""Returns the AwsVpcEndpoint class for the given service."""
return resource.GetResourceClass(
AwsVpcEndpoint, CLOUD=... |
import threading
import re
import Queue
import diamond.collector
import diamond.metric
import collectd_network
ALIVE = True
class JCollectdCollector(diamond.collector.Collector):
def __init__(self, *args, **kwargs):
super(JCollectdCollector, self).__init__(*args, **kwargs)
self.listener_thre... |
from datetime import timedelta
from requests.exceptions import HTTPError
from homeassistant.components.fritzbox.const import (
ATTR_STATE_DEVICE_LOCKED,
ATTR_STATE_LOCKED,
DOMAIN as FB_DOMAIN,
)
from homeassistant.components.sensor import DOMAIN
from homeassistant.const import (
ATTR_FRIENDLY_NAME,
... |
import typing
from pathlib import Path
import pandas as pd
import matchzoo
def load_data(
stage: str = 'train',
task: str = 'ranking',
return_classes: bool = False
) -> typing.Union[matchzoo.DataPack, typing.Tuple[matchzoo.DataPack, list]]:
"""
Load WikiQA data.
:param stage: One of `train... |
from pygal import Bar, Line
from pygal._compat import u
def test_basic_sparktext():
"""Test basic sparktext"""
chart = Line()
chart.add('_', [1, 5, 22, 13, 53])
assert chart.render_sparktext() == u('▁▁▃▂█')
def test_all_sparktext():
"""Test all character sparktext"""
chart = Line()
char... |
import os
import sys
try:
from cStringIO import StringIO # Python 2.x
except ImportError:
from io import StringIO # Python 3.x
# don't directly use code from this, though we do depend on the
# manifest.Depend data type
import roslib.manifest
import roslib.msgs
import roslib.names
import roslib.packages
imp... |
import unittest
import plotly_express as px
class TestPlotlyExpress(unittest.TestCase):
def test_basic_scatter_plot(self):
gapminder = px.data.gapminder()
gapminder2007 = gapminder.query("year == 2007")
px.scatter(gapminder2007, x="gdpPercap", y="lifeExp")
def test_complex_s... |
import re
import pytest
import requests_mock
from tests.common import load_fixture
from tests.components.light.conftest import mock_light_profiles # noqa
@pytest.fixture(name="requests_mock")
def requests_mock_fixture():
"""Fixture to provide a requests mocker."""
with requests_mock.mock() as mock:
... |
import asyncio
import logging
import re
from abc import ABC
from collections import defaultdict
from typing import List, Tuple, Literal
import discord
from redbot.core.utils import AsyncIter
from redbot.core import Config, modlog, commands
from redbot.core.bot import Red
from redbot.core.i18n import Translator, cog_... |
from collections import defaultdict
from datetime import datetime
from ipaddress import ip_address
import logging
from socket import gethostbyaddr, herror
from typing import List, Optional
from aiohttp.web import middleware
from aiohttp.web_exceptions import HTTPForbidden, HTTPUnauthorized
import voluptuous as vol
f... |
import logging
from kalliope.core.NeuronModule import NeuronModule, MissingParameterException, InvalidParameterException
logging.basicConfig()
logger = logging.getLogger("kalliope")
class Neurotransmitter(NeuronModule):
def __init__(self, **kwargs):
super(Neurotransmitter, self).__init__(**kwargs)
... |
from datetime import timedelta
import pytest
from speedtest import NoMatchedServers
from homeassistant import data_entry_flow
from homeassistant.components import speedtestdotnet
from homeassistant.components.speedtestdotnet.const import (
CONF_MANUAL,
CONF_SERVER_ID,
CONF_SERVER_NAME,
DOMAIN,
SE... |
from datetime import timedelta
from typing import TYPE_CHECKING, Any, Generator
from pytest import raises
from homeassistant.components.switcher_kis import (
CONF_AUTO_OFF,
DATA_DEVICE,
DOMAIN,
SERVICE_SET_AUTO_OFF_NAME,
SERVICE_SET_AUTO_OFF_SCHEMA,
SIGNAL_SWITCHER_DEVICE_UPDATE,
)
from homea... |
import logging
import pywink
from homeassistant.components.water_heater import (
ATTR_TEMPERATURE,
STATE_ECO,
STATE_ELECTRIC,
STATE_GAS,
STATE_HEAT_PUMP,
STATE_HIGH_DEMAND,
STATE_PERFORMANCE,
SUPPORT_AWAY_MODE,
SUPPORT_OPERATION_MODE,
SUPPORT_TARGET_TEMPERATURE,
WaterHeate... |
import json
import pytest
from lemur.tests.factories import UserFactory, RoleFactory
from lemur.users.views import * # noqa
from .vectors import (
VALID_ADMIN_API_TOKEN,
VALID_ADMIN_HEADER_TOKEN,
VALID_USER_HEADER_TOKEN,
)
def test_user_input_schema(client):
from lemur.users.schemas import UserInp... |
from unittest.mock import patch
import iaqualink
import pytest
from homeassistant.components.iaqualink import config_flow
from tests.common import MockConfigEntry, mock_coro
DATA = {"username": "test@example.com", "password": "pass"}
@pytest.mark.parametrize("step", ["import", "user"])
async def test_already_con... |
from tqdm import tqdm
from matchzoo.data_pack import DataPack
from matchzoo.engine.base_preprocessor import BasePreprocessor
from .chain_transform import chain_transform
from .build_vocab_unit import build_vocab_unit
from . import units
tqdm.pandas()
class DSSMPreprocessor(BasePreprocessor):
"""DSSM Model prep... |
from time import sleep
import mock
from behave import then
from behave import when
from itest_utils import get_service_connection_string
from itest_utils import update_context_marathon_config
from marathon.exceptions import MarathonHttpError
from paasta_tools import marathon_tools
from paasta_tools import mesos_main... |
from homeassistant.components.water_heater import (
STATE_ECO,
STATE_OFF,
STATE_ON,
SUPPORT_OPERATION_MODE,
WaterHeaterEntity,
)
from homeassistant.const import TEMP_CELSIUS
from . import DATA_HIVE, DOMAIN, HiveEntity, refresh_system
SUPPORT_FLAGS_HEATER = SUPPORT_OPERATION_MODE
HIVE_TO_HASS_STA... |
import sys
if sys.platform.startswith('win'):
import ctypes
from ctypes import windll
from ctypes.wintypes import (BOOL, DOUBLE, DWORD, HBITMAP, HDC, HGDIOBJ, # noqa
HWND, INT, LPARAM, LONG, UINT, WORD) # noqa
SRCCOPY = 13369376
DIB_RGB_COLORS = BI_RGB = 0
... |
from homeassistant.components.zwave import const, sensor
import homeassistant.const
from tests.mock.zwave import MockEntityValues, MockNode, MockValue, value_changed
def test_get_device_detects_none(mock_openzwave):
"""Test get_device returns None."""
node = MockNode()
value = MockValue(data=0, node=nod... |
import copy
import glob
import os
import os.path as op
import shutil
import pathlib
import numpy as np
from numpy.testing import assert_equal
import pytest
from matplotlib import pyplot as plt
from mne import Epochs, read_events, read_evokeds
from mne.io import read_raw_fif
from mne.datasets import testing
from mne.... |
import unittest
import sys
from collections import namedtuple
from functools import reduce
from operator import add
from functional.util import (
is_namedtuple,
lazy_parallelize,
split_every,
pack,
unpack,
compute_partition_size,
)
Data = namedtuple("Tuple", "x y")
class TestUtil(unittest.T... |
import os
from ..bem import fit_sphere_to_headshape
from ..io import read_raw_fif
from ..utils import logger, verbose, warn
def _mxwarn(msg):
"""Warn about a bug."""
warn('Possible MaxFilter bug: %s, more info: '
'http://imaging.mrc-cbu.cam.ac.uk/meg/maxbugs' % msg)
@verbose
def apply_maxfilter(i... |
from pymyq.const import (
DEVICE_FAMILY as MYQ_DEVICE_FAMILY,
DEVICE_FAMILY_GATEWAY as MYQ_DEVICE_FAMILY_GATEWAY,
DEVICE_STATE as MYQ_DEVICE_STATE,
DEVICE_STATE_ONLINE as MYQ_DEVICE_STATE_ONLINE,
KNOWN_MODELS,
MANUFACTURER,
)
from homeassistant.components.binary_sensor import (
DEVICE_CLAS... |
from .std import tqdm, trange
from .gui import tqdm as tqdm_gui # TODO: remove in v5.0.0
from .gui import trange as tgrange # TODO: remove in v5.0.0
from ._tqdm_pandas import tqdm_pandas
from .cli import main # TODO: remove in v5.0.0
from ._monitor import TMonitor, TqdmSynchronisationWarning
from ._version import _... |
from mock import patch, sentinel, call
from arctic.scripts.arctic_fsck import main
from ...util import run_as_main
def test_main():
with patch('arctic.scripts.arctic_fsck.Arctic') as Arctic, \
patch('arctic.scripts.arctic_fsck.get_mongodb_uri') as get_mongodb_uri, \
patch('arctic.scripts.arcti... |
import datetime
import logging
import os
import signal
import subprocess
import time
import socket
import re
import shlex
from pkg_resources import resource_string
from .reader import JMeterReader
from ..Console import Plugin as ConsolePlugin
from ..Console import screen as ConsoleScreen
from ...common.interfaces im... |
import json
import os
import unittest
from absl import flags
from absl.testing import parameterized
import mock
from perfkitbenchmarker import benchmark_spec
from perfkitbenchmarker import errors
from perfkitbenchmarker import vm_util
from perfkitbenchmarker.linux_benchmarks import netperf_benchmark
FLAGS = flags.FL... |
import diamond.collector
import os
class UDPCollector(diamond.collector.Collector):
PROC = [
'/proc/net/snmp'
]
def process_config(self):
super(UDPCollector, self).process_config()
if self.config['allowed_names'] is None:
self.config['allowed_names'] = []
def ge... |
from copy import copy
from .lalr_analysis import Shift, Reduce
from .. import Token
from ..exceptions import UnexpectedToken
class ParserPuppet(object):
"""ParserPuppet gives you advanced control over error handling when parsing with LALR.
For a simpler, more streamlined interface, see the ``on_error`` arg... |
from datetime import timedelta
import logging
from adguardhome import AdGuardHomeConnectionError, AdGuardHomeError
from homeassistant.components.adguard import AdGuardHomeDeviceEntity
from homeassistant.components.adguard.const import (
DATA_ADGUARD_CLIENT,
DATA_ADGUARD_VERION,
DOMAIN,
)
from homeassista... |
from collections import OrderedDict
import fnmatch
import re
from typing import Any, Dict, Optional, Pattern
from homeassistant.core import split_entity_id
class EntityValues:
"""Class to store entity id based values."""
def __init__(
self,
exact: Optional[Dict] = None,
domain: Opti... |
import datetime
import logging
import os
import tempfile
from absl import flags
from perfkitbenchmarker import configs
from perfkitbenchmarker import sample
from perfkitbenchmarker import spark_service
BENCHMARK_NAME = 'spark'
BENCHMARK_CONFIG = """
spark:
description: Run a jar on a spark cluster.
spark_service... |
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 FPN
def _random_array(xp, shape):
return xp.array(
np.random.uniform(-1, 1, size=shape), dtype=np.float32)
class DummyE... |
import os
import tempfile
from contextlib import contextmanager
from sqlalchemy import types
from cryptography.fernet import Fernet, MultiFernet
from flask import current_app
@contextmanager
def mktempfile():
with tempfile.NamedTemporaryFile(delete=False) as f:
name = f.name
try:
yield name... |
from homeassistant.components.abode.const import DOMAIN as ABODE_DOMAIN
from homeassistant.components.camera import DOMAIN as CAMERA_DOMAIN
from homeassistant.const import ATTR_ENTITY_ID, STATE_IDLE
from .common import setup_platform
from tests.async_mock import patch
async def test_entity_registry(hass):
"""T... |
from datetime import timedelta
from aiounifi.api import SOURCE_DATA, SOURCE_EVENT
from aiounifi.events import (
ACCESS_POINT_UPGRADED,
GATEWAY_UPGRADED,
SWITCH_UPGRADED,
WIRED_CLIENT_CONNECTED,
WIRELESS_CLIENT_CONNECTED,
WIRELESS_CLIENT_ROAM,
WIRELESS_CLIENT_ROAMRADIO,
WIRELESS_GUEST_C... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import codecs
import contextlib
import copy
import os
import re
import subprocess
import sys
import tempfile
import unittest
from absl import app
from absl import flags
from absl._enum_module import enum
from... |
import numpy as np
from ...utils import warn
class _LinkViewer(object):
"""Class to link multiple Brain objects."""
def __init__(self, brains, time=True, camera=False, colorbar=True,
picking=False):
self.brains = brains
self.leader = self.brains[0] # select a brain as leade... |
from typing import List
import voluptuous as vol
from homeassistant.components.automation import AutomationActionType
from homeassistant.components.device_automation import TRIGGER_BASE_SCHEMA
from homeassistant.components.homeassistant.triggers import (
numeric_state as numeric_state_trigger,
state as state... |
import asyncio
from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Set, Tuple
from aioesphomeapi import (
COMPONENT_TYPE_TO_INFO,
BinarySensorInfo,
CameraInfo,
ClimateInfo,
CoverInfo,
DeviceInfo,
EntityInfo,
EntityState,
FanInfo,
LightInfo,
SensorInfo,
... |
from aiohttp import web
import voluptuous as vol
from homeassistant.components.http import HomeAssistantView
from homeassistant.components.http.data_validator import RequestDataValidator
from tests.async_mock import Mock
async def get_client(aiohttp_client, validator):
"""Generate a client that hits a view dec... |
import voluptuous as vol
from homeassistant.components import rpi_pfio
from homeassistant.components.binary_sensor import PLATFORM_SCHEMA, BinarySensorEntity
from homeassistant.const import CONF_NAME, DEVICE_DEFAULT_NAME
import homeassistant.helpers.config_validation as cv
CONF_INVERT_LOGIC = "invert_logic"
CONF_POR... |
import sys
from os import chdir, getcwd
from os.path import join, basename
from tempfile import mkdtemp
from unittest import TestCase
from uuid import uuid4 as uuid
from shutil import rmtree
from shlex import split
from contextlib import contextmanager, nested
from textwrap import dedent
from mock import patch
from g... |
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.matrixproductstates.infinite_mps import InfiniteMPS
import tensorflow as tf
from jax.config import config
@pytest.fixture(
n... |
import enum
import logging
from typing import List
import bellows.zigbee.application
from zigpy.config import CONF_DEVICE_PATH # noqa: F401 # pylint: disable=unused-import
import zigpy_cc.zigbee.application
import zigpy_deconz.zigbee.application
import zigpy_xbee.zigbee.application
import zigpy_zigate.zigbee.applica... |
from .abstract_owm_sensor import AbstractOpenWeatherMapSensor
from .const import (
ATTR_API_THIS_DAY_FORECAST,
DOMAIN,
ENTRY_FORECAST_COORDINATOR,
ENTRY_NAME,
ENTRY_WEATHER_COORDINATOR,
FORECAST_MONITORED_CONDITIONS,
FORECAST_SENSOR_TYPES,
MONITORED_CONDITIONS,
WEATHER_SENSOR_TYPES,... |
from pscript import RawJS
from flexx import flx
# Associate assets needed by this app.
flx.assets.associate_asset(__name__, "http://code.jquery.com/jquery-1.10.2.js")
flx.assets.associate_asset(__name__, "http://code.jquery.com/ui/1.11.4/jquery-ui.js")
flx.assets.associate_asset(__name__,
"http://code.jquery.co... |
from unittest.mock import patch
import pytest
import zigpy.profiles.zha
import zigpy.zcl.clusters.closures as closures
import zigpy.zcl.clusters.general as general
import zigpy.zcl.foundation as zcl_f
from homeassistant.components.lock import DOMAIN
from homeassistant.const import STATE_LOCKED, STATE_UNAVAILABLE, ST... |
from absl import flags
from perfkitbenchmarker.linux_benchmarks import coremark_benchmark
FLAGS = flags.FLAGS
BENCHMARK_NAME = coremark_benchmark.BENCHMARK_NAME
BENCHMARK_CONFIG = coremark_benchmark.BENCHMARK_CONFIG
GetConfig = coremark_benchmark.GetConfig
def Prepare(benchmark_spec):
"""Installs coremark on th... |
from math import log10
from pygal._compat import to_str
from pygal.graph.graph import Graph
from pygal.util import alter, cached_property, decorate, safe_enumerate
from pygal.view import ReverseView, View
class Dot(Graph):
"""Dot graph class"""
def dot(self, serie, r_max):
"""Draw a dot line"""
... |
import urwid
class FibonacciWalker(urwid.ListWalker):
"""ListWalker-compatible class for browsing fibonacci set.
positions returned are (value at position-1, value at position) tuples.
"""
def __init__(self):
self.focus = (0,1)
self.numeric_layout = NumericLayout()
def _get_at_po... |
from typing import Any, Callable, List
import pyvera as veraApi
from homeassistant.components.cover import (
ATTR_POSITION,
DOMAIN as PLATFORM_DOMAIN,
ENTITY_ID_FORMAT,
CoverEntity,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.core import HomeAssistant
from homeassistant.... |
from django.utils.translation import gettext_lazy as _
from cms.plugin_pool import plugin_pool
from cmsplugin_cascade.plugin_base import TransparentContainer
from shop.cascade.plugin_base import ShopPluginBase
class ShopExtendableMixin:
"""
Add this mixin class to the list of ``model_mixins``, in the plugin ... |
import os
from slacker import Slacker
def list_slack():
"""List channels & users in slack."""
try:
token = os.environ['SLACK_TOKEN']
slack = Slacker(token)
# Get channel list
response = slack.channels.list()
channels = response.body['channels']
for channel in ... |
from homeassistant.components.cover import ATTR_CURRENT_POSITION
from homeassistant.components.ozw.cover import VALUE_SELECTED_ID
from .common import setup_ozw
VALUE_ID = "Value"
async def test_cover(hass, cover_data, sent_messages, cover_msg):
"""Test setting up config entry."""
receive_message = await se... |
import pytest
from homeassistant.components.owntracks import helper
from tests.async_mock import patch
@pytest.fixture(name="nacl_imported")
def mock_nacl_imported():
"""Mock a successful import."""
with patch("homeassistant.components.owntracks.helper.nacl"):
yield
@pytest.fixture(name="nacl_not... |
import unittest
import numpy as np
from chainer import testing
from chainercv.transforms import translate_point
class TestTranslatePoint(unittest.TestCase):
def test_translate_point_ndarray(self):
point = np.random.uniform(
low=0., high=32., size=(3, 10, 2))
out = translate_point(... |
import asyncio
import voluptuous as vol
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import CONF_HOST
from homeassistant.core import HomeAssistant
from .const import ALL_PLATFORMS, DOMAIN, UNDO_UPDATE_LISTENER
from .gateway import async_setup_entry_gw
CONFIG_SCHEMA = vol.Schema({DO... |
import logging
from threading import Thread
from kalliope.core import SignalModule
from kalliope.core import Utils
from kalliope.signals.mqtt_subscriber.MqttClient import MqttClient
from kalliope.signals.mqtt_subscriber.models import Broker, Topic
CLIENT_ID = "kalliope"
logging.basicConfig()
logger = logging.getLog... |
from flask import Blueprint
from flask_restful import reqparse, Api
from lemur.common.schema import validate_schema
from lemur.common.utils import paginated_parser
from lemur.auth.service import AuthenticatedResource
from lemur.logs.schemas import logs_output_schema
from lemur.logs import service
mod = Blueprint(... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.