text stringlengths 213 32.3k |
|---|
import unittest
from unittest import mock
from homeassistant.components.ecobee import climate as ecobee
import homeassistant.const as const
from homeassistant.const import STATE_OFF
class TestEcobee(unittest.TestCase):
"""Tests for Ecobee climate."""
def setUp(self):
"""Set up test variables."""
... |
from unittest import TestCase
from httpobs.scanner.utils import sanitize_headers
class TestValidHostname(TestCase):
def test_valid_size_headers(self):
# TODO: Try to find a site with www.site.foo but not site.foo
headers = {
'Content-Type': 'text/html',
'Location': '/what... |
from django.apps import AppConfig
from django.core.checks import Warning, register
from weblate.utils.checks import weblate_check
def check_formats(app_configs, **kwargs):
from weblate.formats.models import FILE_FORMATS
message = "Failure in loading handler for {} file format: {}"
return [
webl... |
import unicodedata
from django.conf import settings
from django.utils.translation import gettext as _
from django.utils.translation import gettext_lazy
# Names of hardcoded characters
CHAR_NAMES = {
"\t": gettext_lazy("Insert tab character"),
"\n": gettext_lazy("Insert new line"),
"…": gettext_lazy("Inse... |
import asyncio
from base64 import b64encode
import logging
import aiohttp
import async_timeout
import voluptuous as vol
from homeassistant.components.image_processing import (
CONF_CONFIDENCE,
CONF_ENTITY_ID,
CONF_NAME,
CONF_SOURCE,
PLATFORM_SCHEMA,
)
from homeassistant.components.openalpr_local.... |
from homeassistant.components.water_heater import (
ATTR_TEMPERATURE,
STATE_ECO,
STATE_PERFORMANCE,
WaterHeaterEntity,
)
from homeassistant.const import STATE_OFF, TEMP_CELSIUS
from . import DOMAIN, WATER_HEATER, AtagEntity
SUPPORT_FLAGS_HEATER = 0
OPERATION_LIST = [STATE_OFF, STATE_ECO, STATE_PERFOR... |
from itertools import combinations, groupby
import csv
import os
import time
import optparse
import logging
import dedupe
import exampleIO
def canonicalImport(filename):
preProcess = exampleIO.preProcess
data_d = {}
with open(filename) as f:
reader = csv.DictReader(f)
for (i, row) in ... |
import argparse
import logging
import sys
from typing import List
from typing import Sequence
from typing import Tuple
import boto3
from boto3_type_annotations.ec2 import Client
from botocore.exceptions import ClientError
from kubernetes.client import V1DeleteOptions
from kubernetes.client import V1Node
from kubernet... |
import time
def uts(dt):
return int(time.mktime(dt.timetuple()))
class Decoder(object):
"""
Decode metrics incoming from tank into points for InfluxDB client
Parameters
----------
parent_tags : dict
common per-test tags
tank_tag : str
tank identifier tag
uuid : str
... |
import unittest
import numpy as np
from pykalman import KalmanFilter
from pykalman import UnscentedKalmanFilter
from pykalman.sqrt import CholeskyKalmanFilter, AdditiveUnscentedKalmanFilter
class TestPyKalman(unittest.TestCase):
def test_kalman_filter(self):
kf = KalmanFilter(transition_matrices = [[1, 1]... |
from rumps import *
@clicked('Testing')
def tester(sender):
sender.state = not sender.state
class SomeApp(rumps.App):
def __init__(self):
super(SomeApp, self).__init__(type(self).__name__, menu=['On', 'Testing'])
rumps.debug_mode(True)
@clicked('On')
def button(self, sender):
... |
import unittest
import chainer
from chainer import testing
from chainer.testing import attr
from chainercv.links.model.deeplab import SeparableASPP
class TestSeparableASPP(unittest.TestCase):
def setUp(self):
self.in_channels = 128
self.out_channels = 32
self.link = SeparableASPP(
... |
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
import unittest
from Tests.test_api.base import RestAPITestBase
from kalliope._version import version_str
class TestMainView(RestAPITestBase):
def test_server_is_up_and_running(self):
# response = urllib2.urlopen(self.get_server_url())
response = self.client.get(self.get_server_url(... |
import logging
from pprint import pformat
from homeassistant.components.cover import (
ATTR_POSITION,
DEVICE_CLASS_GARAGE,
CoverEntity,
)
from homeassistant.components.supla import (
DOMAIN,
SUPLA_COORDINATORS,
SUPLA_SERVERS,
SuplaChannel,
)
_LOGGER = logging.getLogger(__name__)
SUPLA_SH... |
import sys
from json_parser import Lark_StandAlone, Transformer, inline_args
class TreeToJson(Transformer):
@inline_args
def string(self, s):
return s[1:-1].replace('\\"', '"')
array = list
pair = tuple
object = dict
number = inline_args(float)
null = lambda self, _: None
tr... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import posixpath
PACKAGE_NAME = 'openfoam'
OPENFOAM_ROOT = '/opt/openfoam7'
"""Needed for downloading OpenFOAM."""
_OPENFOAM_REPOSITORY_URL = 'http://dl.openfoam.org/ubuntu'
_OPENFOAM_REPOSITORY_KEY = 'o... |
import time
import dns
import dns.exception
import dns.name
import dns.query
import dns.resolver
from dyn.tm.errors import (
DynectCreateError,
DynectDeleteError,
DynectGetError,
DynectUpdateError,
)
from dyn.tm.session import DynectSession
from dyn.tm.zones import Node, Zone, get_all_zones
from flask... |
import os
import threading
import sys
import atexit
from contextlib import contextmanager
from plumbum.machines.local import local
from plumbum.lib import six
if not hasattr(threading, "get_ident"):
try:
import thread
except ImportError:
import _thread as thread
threading.get_ident = threa... |
from docutils import nodes
from docutils.parsers.rst import Directive, directives
from nikola.plugin_categories import RestExtension
from nikola.utils import req_missing
try:
import micawber
except ImportError:
micawber = None
class Plugin(RestExtension):
"""Plugin for reST media directive."""
nam... |
from datetime import timedelta
import logging
from fixerio import Fixerio
from fixerio.exceptions import FixerioException
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import ATTR_ATTRIBUTION, CONF_API_KEY, CONF_NAME
import homeassistant.helpers.config_... |
from flask_sqlalchemy import SQLAlchemy as SA
class SQLAlchemy(SA):
def apply_pool_defaults(self, app, options):
SA.apply_pool_defaults(self, app, options)
options["pool_pre_ping"] = True
db = SQLAlchemy()
from flask_migrate import Migrate
migrate = Migrate()
from flask_bcrypt import Bcrypt
... |
from datetime import datetime
import logging
from typing import Any, Dict, Optional
from surepy import SureLocationID, SureProductID
from homeassistant.components.binary_sensor import (
DEVICE_CLASS_CONNECTIVITY,
DEVICE_CLASS_PRESENCE,
BinarySensorEntity,
)
from homeassistant.const import CONF_ID, CONF_T... |
import datetime
import re
from typing import Any
from urllib.parse import urlparse
from aiohttp.test_utils import TestClient
import pytest
import requests_mock
from withings_api.common import NotifyAppli, NotifyListProfile, NotifyListResponse
from homeassistant.components.withings.common import (
ConfigEntryWith... |
import voluptuous as vol
from homeassistant.components.switch import PLATFORM_SCHEMA, SwitchEntity
from homeassistant.const import CONF_NAME
import homeassistant.helpers.config_validation as cv
from . import (
CONF_ALIASES,
CONF_DEVICE_DEFAULTS,
CONF_DEVICES,
CONF_FIRE_EVENT,
CONF_GROUP,
CONF... |
from kalliope.core.NeuronModule import NeuronModule, MissingParameterException
class Say(NeuronModule):
def __init__(self, **kwargs):
super(Say, self).__init__(**kwargs)
self.message = kwargs.get('message', None)
self.file_template = kwargs.get('file_template', None)
self.paramete... |
import asyncio
import logging
import secrets
from rachiopy import Rachio
from requests.exceptions import ConnectTimeout
import voluptuous as vol
from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
from homeassistant.const import CONF_API_KEY
from homeassistant.core import HomeAssistant
from homeassis... |
import os
import pytest
from molecule import config
from molecule import util
from molecule.command import base
class ExtendedBase(base.Base):
def execute():
pass
# NOTE(retr0h): The use of the `patched_config_validate` fixture, disables
# config.Config._validate from executing. Thus preventing odd ... |
import unittest
from unittest.mock import patch, MagicMock
from credstash import get_session, reset_sessions
class TestGetSession(unittest.TestCase):
def setUp(self):
reset_sessions()
@patch('boto3.Session')
def test_get_session_initial_session(self, mock_session):
mock_session.return_val... |
from ipaddress import ip_address, ip_network
import pytest
import voluptuous as vol
from homeassistant import auth
from homeassistant.auth import auth_store
from homeassistant.auth.providers import trusted_networks as tn_auth
@pytest.fixture
def store(hass):
"""Mock store."""
return auth_store.AuthStore(ha... |
from datetime import timedelta
from homeassistant.const import (
ATTR_UNIT_OF_MEASUREMENT,
DATA_MEGABYTES,
DATA_RATE_MEGABYTES_PER_SECOND,
DEVICE_CLASS_TIMESTAMP,
)
from homeassistant.util import dt as dt_util
from . import init_integration
from tests.async_mock import patch
async def test_sensors... |
from nikola.plugin_categories import Taxonomy
class PageIndex(Taxonomy):
"""Classify for the page index."""
name = "classify_page_index"
classification_name = "page_index_folder"
overview_page_variable_name = "page_folder"
more_than_one_classifications_per_post = False
has_hierarchy = True
... |
from django.test import TestCase
from django.utils.translation import activate
from django.utils.translation import deactivate
from zinnia.urls import i18n_url
class TranslatedURLsTestCase(TestCase):
"""Test cases for translated URLs"""
def test_translated_urls(self):
deactivate()
self.asse... |
from unittest.mock import call
import pytest
from homeassistant.components.light import ATTR_BRIGHTNESS
from homeassistant.components.rfxtrx import DOMAIN
from homeassistant.core import State
from tests.common import MockConfigEntry, mock_restore_cache
from tests.components.rfxtrx.conftest import create_rfx_test_cf... |
from test import CollectorTestCase
from test import get_collector_config
from test import unittest
from vmsdoms import VMSDomsCollector
###############################################################################
class TestVMSDomsCollector(CollectorTestCase):
def setUp(self):
config = get_collector... |
import os
import sh
from molecule import logger
from molecule import util
from molecule.verifier.lint import base
LOG = logger.get_logger(__name__)
class Flake8(base.Base):
"""
`Flake8`_ is the default verifier linter.
`Flake8`_ is a linter for python files.
Additional options can be passed to `... |
import os
import unittest
from absl import flags
from perfkitbenchmarker.linux_benchmarks import horovod_benchmark
from tests import pkb_common_test_case
FLAGS = flags.FLAGS
class HorovodBenchmarkTestCase(pkb_common_test_case.PkbCommonTestCase):
def setUp(self):
super(HorovodBenchmarkTestCase, self).setUp()
... |
from datetime import timedelta
from typing import Mapping, Optional
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.components import ssdp
from homeassistant.const import CONF_SCAN_INTERVAL
from homeassistant.core import callback
from .const import ( # pylint: disable=unused-im... |
from django.db import migrations
def update_name(apps, schema_editor):
Group = apps.get_model("weblate_auth", "Group")
db_alias = schema_editor.connection.alias
for group in Group.objects.using(db_alias).filter(
name__endswith="@Template", internal=True
):
group.name = "{}@Sources".fo... |
from pygti.gti import GTI, Auth
class GTIHub:
"""GTI Hub."""
def __init__(self, host, username, password, session):
"""Initialize."""
self.host = host
self.username = username
self.password = password
self.gti = GTI(Auth(session, self.username, self.password, self.ho... |
import diamond.collector
import os
class NfsCollector(diamond.collector.Collector):
PROC = '/proc/net/rpc/nfs'
def get_default_config_help(self):
config_help = super(NfsCollector, self).get_default_config_help()
config_help.update({
})
return config_help
def get_default... |
from django.conf import settings
from django.contrib.auth import logout
from django.core.cache import cache
from django.middleware.csrf import rotate_token
from django.shortcuts import redirect
from django.template.loader import render_to_string
from weblate.utils import messages
from weblate.utils.hash import calcul... |
from typing import TYPE_CHECKING, Callable, Dict
from aioswitcher.api import SwitcherV2Api
from aioswitcher.consts import (
COMMAND_OFF,
COMMAND_ON,
STATE_OFF as SWITCHER_STATE_OFF,
STATE_ON as SWITCHER_STATE_ON,
WAITING_TEXT,
)
from homeassistant.components.switch import ATTR_CURRENT_POWER_W, Sw... |
from flask import Flask
try:
from http import HTTPStatus
except ImportError:
import httplib as HTTPStatus
from flasgger import Swagger
swagger_config = {
'headers': [
],
'specs': [
{
'endpoint': 'apispec',
'route': '/apispec.json',
'rule_filter': lambda ... |
from elgato import Elgato, ElgatoConnectionError
from homeassistant.components.light import DOMAIN as LIGHT_DOMAIN
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import CONF_HOST, CONF_PORT
from homeassistant.core import HomeAssistant
from homeassistant.exceptions import ConfigEntryNotR... |
import importlib
import logging
import smart_open.local_file
logger = logging.getLogger(__name__)
NO_SCHEME = ''
_REGISTRY = {NO_SCHEME: smart_open.local_file}
_ERRORS = {}
_MISSING_DEPS_ERROR = """You are trying to use the %(module)s functionality of smart_open
but you do not have the correct %(module)s dependenc... |
from abc import ABC, abstractmethod
class Index(ABC):
@abstractmethod
def __init__(self): # pragma: no cover
pass
@abstractmethod
def index(self, doc): # pragma: no cover
pass
@abstractmethod
def unindex(self, doc): # pragma: no cover
pass
@abstractmethod # ... |
from homeassistant.components.homekit.const import (
ATTR_KEY_NAME,
ATTR_VALUE,
CHAR_REMOTE_KEY,
CONF_FEATURE_LIST,
EVENT_HOMEKIT_TV_REMOTE_KEY_PRESSED,
FEATURE_ON_OFF,
FEATURE_PLAY_PAUSE,
FEATURE_PLAY_STOP,
FEATURE_TOGGLE_MUTE,
KEY_ARROW_RIGHT,
)
from homeassistant.components.h... |
import requests
from homeassistant.const import CONF_DEVICES, TEMP_CELSIUS
from homeassistant.helpers.entity import Entity
from .const import (
ATTR_STATE_DEVICE_LOCKED,
ATTR_STATE_LOCKED,
CONF_CONNECTIONS,
DOMAIN as FRITZBOX_DOMAIN,
LOGGER,
)
async def async_setup_entry(hass, config_entry, asy... |
import asyncio
import logging
import ambiclimate
import voluptuous as vol
from homeassistant.components.climate import ClimateEntity
from homeassistant.components.climate.const import (
HVAC_MODE_HEAT,
HVAC_MODE_OFF,
SUPPORT_TARGET_TEMPERATURE,
)
from homeassistant.const import (
ATTR_NAME,
ATTR_... |
import os
import aiohttp
from pyipp import IPPConnectionUpgradeRequired, IPPError
from homeassistant.components.ipp.const import CONF_BASE_PATH, CONF_UUID, DOMAIN
from homeassistant.const import (
CONF_HOST,
CONF_NAME,
CONF_PORT,
CONF_SSL,
CONF_TYPE,
CONF_VERIFY_SSL,
)
from homeassistant.core... |
from datetime import datetime, timedelta
import logging
import re
import requests
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import CONF_MODE, HTTP_OK, TIME_MINUTES
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.entit... |
from contextlib import contextmanager
from homeassistant.components.lock import (
DOMAIN as LOCK_DOMAIN,
SERVICE_LOCK,
SERVICE_UNLOCK,
)
from homeassistant.components.verisure import DOMAIN as VERISURE_DOMAIN
from homeassistant.const import STATE_UNLOCKED
from homeassistant.setup import async_setup_compon... |
from django.views.generic.dates import BaseDateDetailView
from zinnia.models.entry import Entry
from zinnia.views.mixins.archives import ArchiveMixin
from zinnia.views.mixins.callable_queryset import CallableQuerysetMixin
from zinnia.views.mixins.entry_cache import EntryCacheMixin
from zinnia.views.mixins.entry_previ... |
from homeassistant.const import CURRENCY_CENT, ENERGY_KILO_WATT_HOUR
from homeassistant.helpers.update_coordinator import CoordinatorEntity
from .const import CONF_LOADZONE, DOMAIN
async def async_setup_entry(hass, config_entry, async_add_entities):
"""Set up the August sensors."""
coordinator = hass.data[D... |
import unittest
import pandas as pd
import numpy as np
from pgmpy.models import BayesianModel
from pgmpy.estimators import MaximumLikelihoodEstimator
from pgmpy.factors.discrete import TabularCPD
class TestMLE(unittest.TestCase):
def setUp(self):
self.m1 = BayesianModel([("A", "C"), ("B", "C")])
... |
import mock
import requests
from docker_registry.lib import config
from docker_registry.lib import mirroring
import base
from docker_registry.core import compat
json = compat.json
def mock_lookup_source(path, stream=False, source=None):
resp = requests.Response()
resp.status_code = 200
resp._content_c... |
import time
from kombu import Connection, Exchange, Queue, Consumer
media_exchange = Exchange('media', 'direct')
video_queue = Queue('video', exchange=media_exchange, routing_key='video')
task_queues = [video_queue]
def handle_message(body, message):
print(f"{time.time()} RECEIVED MESSAGE: {body!r}")
messa... |
import os
import sys
import docutils
import pytest
from nikola.utils import LocaleBorg
from ..helper import FakeSite
@pytest.fixture(scope="module")
def test_dir():
"""
Absolute path to the directory with the tests.
"""
return os.path.abspath(os.path.dirname(__file__))
@pytest.fixture(scope="sess... |
import json
import logging
import re
from absl import flags
from perfkitbenchmarker import disk
from perfkitbenchmarker import errors
from perfkitbenchmarker import flag_util
from perfkitbenchmarker import kubernetes_helper
from perfkitbenchmarker import providers
from perfkitbenchmarker import resource
from perfkitbe... |
import lakeside
from homeassistant.components.light import (
ATTR_BRIGHTNESS,
ATTR_COLOR_TEMP,
ATTR_HS_COLOR,
SUPPORT_BRIGHTNESS,
SUPPORT_COLOR,
SUPPORT_COLOR_TEMP,
LightEntity,
)
import homeassistant.util.color as color_util
from homeassistant.util.color import (
color_temperature_kel... |
import os
import os.path
import sys
import argparse
import subprocess
import tempfile
import attr
sys.path.insert(0, os.path.join(os.path.dirname(__file__), os.pardir,
os.pardir))
from scripts import utils
@attr.s
class Line:
"""A line in "coredumpctl list"."""
time = att... |
import os
from gi.module import get_introspection_module
from gi.repository import Gdk, GLib, GObject, Pango
from meld.style import colour_lookup_with_fallback
from meld.treehelpers import SearchableTreeStore
from meld.vc._vc import ( # noqa: F401
CONFLICT_BASE,
CONFLICT_LOCAL,
CONFLICT_MERGED,
CONF... |
from ..core import driver
from ..core import exceptions
from nose import tools
class Query(object):
def __init__(self, scheme=None):
self.scheme = scheme
def testDriverIsAvailable(self):
drvs = driver.available()
assert self.scheme in drvs
def testFetchingDriver(self):
... |
import asyncio
from typing import Any, Dict, Iterable, Optional
from homeassistant.const import ATTR_TEMPERATURE
from homeassistant.core import Context, State
from homeassistant.helpers.typing import HomeAssistantType
from .const import (
ATTR_AUX_HEAT,
ATTR_HUMIDITY,
ATTR_HVAC_MODE,
ATTR_PRESET_MODE... |
import socket
from threading import Thread, Event
import pytest
from queue import Queue
from yandextank.common.util import FileScanner, FileMultiReader
from yandextank.common.util import AddressWizard
from netort.data_processing import Drain, Chopper
class TestDrain(object):
def test_run(self):
"""
... |
import asyncio
import functools as ft
import importlib
import json
import logging
import pathlib
import sys
from types import ModuleType
from typing import (
TYPE_CHECKING,
Any,
Callable,
Dict,
List,
Optional,
Set,
TypeVar,
Union,
cast,
)
from homeassistant.generated.mqtt impor... |
import unittest
import os
import json
from unittest.mock import patch
import threading
from test.support import EnvironmentVarGuard
from urllib.parse import urlparse
from http.server import BaseHTTPRequestHandler, HTTPServer
from google.cloud import bigquery
from google.auth.exceptions import DefaultCredentialsError... |
import numpy as np
from ...utils import verbose
from ._utils import _fetch_one, _data_path, TEMAZEPAM_SLEEP_RECORDS
from ._utils import _check_subjects
data_path = _data_path # expose _data_path(..) as data_path(..)
BASE_URL = 'https://physionet.org/physiobank/database/sleep-edfx/sleep-telemetry/' # noqa: E501
... |
__all__ = ['default_environment', 'compile', 'interpret']
import ast
import os
import platform
import sys
import weakref
_builtin_compile = compile
try:
from platform import python_implementation
except ImportError:
if os.name == "java":
# Jython 2.5 has ast module, but not platform.python_implement... |
import json
from collections import Counter
from pathlib import Path
from random import choice, randrange
from typing import Callable, Dict, List, Mapping, Optional, Union
from typing import Counter as CounterType
from pytest import mark
from cerberus import rules_set_registry, schema_registry, TypeDefinition, Valid... |
import math
import numpy as np
from ..utils import logger, verbose, check_random_state, random_permutation
@verbose
def infomax(data, weights=None, l_rate=None, block=None, w_change=1e-12,
anneal_deg=60., anneal_step=0.9, extended=True, n_subgauss=1,
kurt_size=6000, ext_blocks=1, max_iter=2... |
import os.path as op
import numpy as np
import pytest
from numpy.testing import assert_allclose
from scipy.io import loadmat
from scipy import linalg
from mne.channels import make_dig_montage
from mne import create_info, EvokedArray, pick_types, Epochs
from mne.io import read_raw_fif, RawArray
from mne.io.constants... |
from dataclasses import dataclass
from typing import Any, List
@dataclass
class DeviceInfo:
"""Represent device information."""
manufacturer: str = None
model: str = None
fw_version: str = None
serial_number: str = None
mac: str = None
@dataclass
class Resolution:
"""Represent video re... |
from unittest.mock import call
import pytest
from homeassistant.components.rfxtrx import DOMAIN
from homeassistant.core import State
from tests.common import MockConfigEntry, mock_restore_cache
from tests.components.rfxtrx.conftest import create_rfx_test_cfg
EVENT_RFY_ENABLE_SUN_AUTO = "081a00000301010113"
EVENT_R... |
from homeassistant.components.cover import (
SERVICE_CLOSE_COVER,
SERVICE_OPEN_COVER,
intent as cover_intent,
)
from homeassistant.helpers import intent
from tests.common import async_mock_service
async def test_open_cover_intent(hass):
"""Test HassOpenCover intent."""
await cover_intent.async_s... |
from math import sqrt
from django.contrib.sites.models import Site
from django.core.cache import InvalidCacheBackendError
from django.core.cache import caches
from django.utils.functional import cached_property
from django.utils.html import strip_tags
import regex as re
from zinnia.models.entry import Entry
from zi... |
import functools
import logging
import sys
import time
debug = logging.debug
def fatal(msg, code=1):
print(msg + "\n")
logging.error(msg)
sys.exit(code)
def fn(f, *args, **kwargs):
logging.debug("{}: {} {}".format(repr(f), args, kwargs))
return f(*args, **kwargs)
def duration(fn):
@funct... |
from collections import defaultdict
from datetime import timedelta
import logging
import uuid
import brottsplatskartan
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import (
ATTR_ATTRIBUTION,
CONF_LATITUDE,
CONF_LONGITUDE,
CONF_NAME,
)
i... |
from datetime import timedelta
import json
from gios import ApiError
from homeassistant.components.air_quality import (
ATTR_AQI,
ATTR_CO,
ATTR_NO2,
ATTR_OZONE,
ATTR_PM_2_5,
ATTR_PM_10,
ATTR_SO2,
)
from homeassistant.components.gios.air_quality import ATTRIBUTION
from homeassistant.compon... |
from unittest import TestCase
from django.http.request import HttpRequest
from django.test.utils import override_settings
from weblate.middleware import ProxyMiddleware
class ProxyTest(TestCase):
def get_response(self, request):
self.assertEqual(request.META["REMOTE_ADDR"], "1.2.3.4")
return "r... |
import colorsys
import random
from openrazer.client import DeviceManager
from openrazer.client import constants as razer_constants
# Create a DeviceManager. This is used to get specific devices
device_manager = DeviceManager()
print("Found {} Razer devices".format(len(device_manager.devices)))
devices = device_ma... |
import logging
import random
import warnings
import tempfile
import os
from subprocess import PIPE
import numpy as np
from gensim import utils, corpora, matutils
from gensim.utils import check_output
logger = logging.getLogger(__name__)
class DtmModel(utils.SaveLoad):
"""Python wrapper using `DTM implementatio... |
import copy
import hmac
import logging
import uuid
from homeassistant.components import http
from homeassistant.const import HTTP_NOT_FOUND, HTTP_UNAUTHORIZED
from homeassistant.core import callback
from homeassistant.helpers import template
import homeassistant.util.dt as dt_util
from .const import (
API_PASSWO... |
from hatasmota.const import AUTOMATION_TYPE_TRIGGER
from homeassistant.helpers.device_registry import EVENT_DEVICE_REGISTRY_UPDATED
from homeassistant.helpers.dispatcher import async_dispatcher_connect
from . import device_trigger
from .const import DATA_REMOVE_DISCOVER_COMPONENT, DATA_UNSUB
from .discovery import T... |
import asyncio
import logging
from pymonoprice import get_monoprice
from serial import SerialException
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import CONF_PORT
from homeassistant.core import HomeAssistant
from homeassistant.exceptions import ConfigEntryNotReady
from .const impo... |
import zipfile
import os
import tempfile
import time
import shutil
import datetime
import stat
from io import BytesIO
from stashutils.fsi import base
from stashutils.fsi import errors
# TODO: check filename bug when writing
class ZipfileFSI(base.BaseFSI):
"""FSI for zipfiles"""
def __init__(self, logger)... |
import logging
from urllib.parse import urljoin
import re
import pandas
import requests
from netort.data_manager import DataSession, thread_safe_property
import threading as th
from requests import ConnectionError
from yandextank.plugins.Phantom.reader import string_to_df_microsec
from yandextank.common.interfaces ... |
from homeassistant.components.abode import ATTR_DEVICE_ID
from homeassistant.components.cover import DOMAIN as COVER_DOMAIN
from homeassistant.const import (
ATTR_ENTITY_ID,
ATTR_FRIENDLY_NAME,
SERVICE_CLOSE_COVER,
SERVICE_OPEN_COVER,
STATE_CLOSED,
)
from .common import setup_platform
from tests.... |
from kombu import Connection, Exchange, Queue, Producer, Consumer
from kombu.asynchronous import Hub
hub = Hub()
exchange = Exchange('asynt')
queue = Queue('asynt', exchange, 'asynt')
def send_message(conn):
producer = Producer(conn)
producer.publish('hello world', exchange=exchange, routing_key='asynt')
... |
import sys
import mne
def run():
"""Run command."""
parser = mne.commands.utils.get_optparser(
__file__, usage='mne show_fiff <file>')
parser.add_option("-t", "--tag", dest="tag",
help="provide information about this tag", metavar="TAG")
options, args = parser.parse_args... |
try:
# Importing hunter to register its atexit handler early so it gets called
# late.
import hunter # pylint: disable=unused-import
except ImportError:
hunter = None
import sys
import faulthandler
import traceback
import signal
import importlib
import datetime
try:
import tkinter
except ImportEr... |
import os
import click
from molecule import config
from molecule import logger
from molecule import util
from molecule.command import base as command_base
from molecule.command.init import base
LOG = logger.get_logger(__name__)
class Scenario(base.Base):
"""
.. program:: molecule init scenario --scenario-... |
import unittest
import mock
from kalliope.core.NeuronModule import MissingParameterException
from kalliope.neurons.brain.brain import Brain
class TestBrain(unittest.TestCase):
def test_is_parameters_ok(self):
# valid neuron with boolean
synapse_name = "synapse_name"
enabled = True
... |
import logging
import os
from . import get_config
from .utils import logger, verbose, warn, ProgressBar
from .utils.check import int_like
from .fixes import _get_args
if 'MNE_FORCE_SERIAL' in os.environ:
_force_serial = True
else:
_force_serial = None
@verbose
def parallel_func(func, n_jobs, max_nbytes='au... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
from compare_gan.architectures import arch_ops as ops
from compare_gan.architectures import resnet_ops
import numpy as np
from six.moves import range
import tensorflow as tf
class Generator(resnet_ops.ResNe... |
from homeassistant.setup import async_setup_component
from tests.async_mock import patch
async def test_random_binary_sensor_on(hass):
"""Test the Random binary sensor."""
config = {"binary_sensor": {"platform": "random", "name": "test"}}
with patch(
"homeassistant.components.random.binary_sens... |
from homeassistant.const import PERCENTAGE, SIGNAL_STRENGTH_DECIBELS_MILLIWATT
from homeassistant.core import callback
from homeassistant.helpers.entity import Entity
from homeassistant.helpers.icon import icon_for_battery_level
from . import DOMAIN
from .entity import RingEntityMixin
async def async_setup_entry(ha... |
import unittest
import ast
import mock
from kalliope.core.Models.settings.Options import Options
from kalliope.core.Models.settings.Player import Player
from kalliope.core.Models.Signal import Signal
from kalliope.core.Models.settings.Tts import Tts
from kalliope.core.Models.settings.Trigger import Trigger
from kal... |
from PyQt5.QtCore import Qt
from PyQt5.QtWidgets import QLabel, QSizePolicy
from PyQt5.QtGui import QPainter
from qutebrowser.utils import qtutils, utils
class TextBase(QLabel):
"""A text in the statusbar.
Unlike QLabel, the text will get elided.
Eliding is loosely based on
http://gedgedev.blogsp... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.