text stringlengths 213 32.3k |
|---|
from datetime import datetime, timedelta
import logging
import pytz
import voluptuous as vol
from homeassistant.components.binary_sensor import PLATFORM_SCHEMA, BinarySensorEntity
from homeassistant.const import (
CONF_AFTER,
CONF_BEFORE,
CONF_NAME,
SUN_EVENT_SUNRISE,
SUN_EVENT_SUNSET,
)
from hom... |
import asyncio
import logging
import pathlib
import secrets
import shutil
import typing
from PIL import Image, ImageOps, UnidentifiedImageError
from aiohttp import hdrs, web
from aiohttp.web_request import FileField
import voluptuous as vol
from homeassistant.components.http.static import CACHE_HEADERS
from homeassi... |
import numpy as np
from numpy.testing import assert_almost_equal
from mne.inverse_sparse.mxne_debiasing import compute_bias
def test_compute_debiasing():
"""Test source amplitude debiasing."""
rng = np.random.RandomState(42)
G = rng.randn(10, 4)
X = rng.randn(4, 20)
debias_true = np.arange(1, 5,... |
import pytest
from molecule.model import schema_v2
@pytest.fixture
def _model_platforms_docker_section_data():
return """
---
platforms:
- name: instance
registry:
credentials:
password: $BAR
""".strip()
@pytest.fixture
def _env():
return {}
@pytest.fixture
def _keep_string():
re... |
import os
import unittest
import mock
from perfkitbenchmarker import test_util
from perfkitbenchmarker.linux_benchmarks import nccl_benchmark
from perfkitbenchmarker.sample import Sample
class NcclBenchmarkTest(unittest.TestCase, test_util.SamplesTestMixin):
def setUp(self):
super(NcclBenchmarkTest, self).se... |
import asyncio
from unittest.mock import Mock, patch
import aiohttp
import pytest
from homeassistant.components import ssdp
from tests.common import mock_coro
async def test_scan_match_st(hass):
"""Test matching based on ST."""
scanner = ssdp.Scanner(hass, {"mock-domain": [{"st": "mock-st"}]})
with p... |
import json
from pathlib import Path
import pytest
from redbot.pytest.downloader import *
from redbot.cogs.downloader.installable import Installable, InstallableType
from redbot.core import VersionInfo
def test_process_info_file(installable):
for k, v in INFO_JSON.items():
if k == "type":
a... |
from unittest.mock import patch, Mock
import arrow
from cryptography import x509
from lemur.plugins.lemur_entrust import plugin
from freezegun import freeze_time
def config_mock(*args):
values = {
"ENTRUST_API_CERT": "-----BEGIN CERTIFICATE-----abc-----END CERTIFICATE-----",
"ENTRUST_API_KEY": F... |
import asyncio
import json
import logging
from aiohttp import web
from aiohttp.web_exceptions import HTTPBadRequest
import async_timeout
import voluptuous as vol
from homeassistant.auth.permissions.const import POLICY_READ
from homeassistant.bootstrap import DATA_LOGGING
from homeassistant.components.http import Hom... |
import subprocess
import logging
import os
import sys
import signal
import configparser
import json
import threading
import time
from argparse import ArgumentParser
import queue as q
logger = logging.getLogger("agent")
collector_logger = logging.getLogger("telegraf")
def signal_handler(sig, frame):
""" require... |
import unittest, sys
from lxml.tests.common_imports import make_doctest, HelperTestCase
try:
import lxml.html.soupparser
BS_INSTALLED = True
except ImportError:
if 'bs4' in sys.modules or 'BeautifulSoup' in sys.modules:
raise # seems we managed to import BS but not soupparser
BS_INSTALLED = F... |
from homeassistant.const import (
ATTR_ATTRIBUTION,
ATTR_DEVICE_CLASS,
CONF_NAME,
DEVICE_CLASS_TEMPERATURE,
)
from homeassistant.helpers.update_coordinator import CoordinatorEntity
from .const import (
ATTR_FORECAST,
ATTR_ICON,
ATTR_LABEL,
ATTRIBUTION,
COORDINATOR,
DOMAIN,
... |
import asyncio
import voluptuous as vol
from homeassistant.auth.permissions.const import CAT_ENTITIES, POLICY_READ
from homeassistant.components.websocket_api.const import ERR_NOT_FOUND
from homeassistant.const import EVENT_STATE_CHANGED, EVENT_TIME_CHANGED, MATCH_ALL
from homeassistant.core import DOMAIN as HASS_DO... |
from datetime import timedelta
from urllib.parse import urlparse
import av
import pytest
from homeassistant.components.stream import request_stream
from homeassistant.const import HTTP_NOT_FOUND
from homeassistant.setup import async_setup_component
import homeassistant.util.dt as dt_util
from tests.async_mock impor... |
import pytest
import sys
import os
import socket
import time
import logging
import plumbum
from copy import deepcopy
from plumbum import RemotePath, SshMachine, CommandNotFound, ProcessExecutionError, local, ProcessTimedOut, NOHUP
from plumbum import CommandNotFound
from plumbum.lib import six
from plumbum.machines.se... |
import numpy as np
import unittest
import chainer
from chainer.backends import cuda
from chainer import testing
from chainer.testing import attr
from chainercv.experimental.links import FCISResNet101
from chainercv.experimental.links.model.fcis import FCISTrainChain
from chainercv.utils import mask_to_bbox
from tes... |
import logging
import voluptuous as vol
import yeelight
from homeassistant import config_entries, exceptions
from homeassistant.const import CONF_HOST, CONF_ID, CONF_NAME
from homeassistant.core import callback
import homeassistant.helpers.config_validation as cv
from . import (
CONF_DEVICE,
CONF_MODE_MUSIC... |
try:
from collections.abc import Mapping
except ImportError:
from collections import Mapping
from functools import partial
try:
from urllib.parse import parse_qsl, quote, unquote, urlparse
except ImportError:
from urllib import quote, unquote # noqa
from urlparse import urlparse,... |
from __future__ import print_function
import argparse
import sys
import json
from mlpatches import base
_stash = globals()["_stash"]
from mlpatches import patches
def patch_is_compatible(patch):
"""Return True if the patch is compatible."""
if _stash.PY3:
return patch.PY3
else:
return p... |
import sys
import argparse
import os.path
import subprocess
sys.path.insert(0, os.path.join(os.path.dirname(__file__), os.pardir,
os.pardir))
from scripts import utils
def bump_version(version_leap="patch"):
"""Update qutebrowser release version.
Args:
version_leap:... |
import os.path
import sys
# pylint: disable=import-error,no-member,useless-suppression
from PyInstaller.utils.win32 import versioninfo as vs
# pylint: enable=import-error,no-member,useless-suppression
sys.path.insert(0, os.path.join(os.path.dirname(__file__), os.pardir,
os.pardir))
i... |
from datetime import timedelta
import logging
from tapsaff import TapsAff
import voluptuous as vol
from homeassistant.components.binary_sensor import PLATFORM_SCHEMA, BinarySensorEntity
from homeassistant.const import CONF_NAME
import homeassistant.helpers.config_validation as cv
_LOGGER = logging.getLogger(__name_... |
import os
import random
import string
import tarfile
import backports.lzma as lzma
import base
import mock
from docker_registry.core import compat
from docker_registry.lib import layers
from docker_registry import storage
json = compat.json
StringIO = compat.StringIO
# from mock import patch
# from mockredis impo... |
import argparse
import json
import logging
from collections import defaultdict
from typing import Dict
from typing import List
from typing import Set
from mypy_extensions import TypedDict
from paasta_tools.marathon_tools import get_marathon_clients
from paasta_tools.marathon_tools import get_marathon_servers
from pa... |
from __future__ import print_function
import errno
import os
try:
from cStringIO import StringIO
except ImportError:
from io import StringIO
import signal
import subprocess
import time
import traceback
import unittest
import rospkg
from . import junitxml
from . import pmon
from .core import create_xml_runne... |
import datetime
import sys
import unittest
import mock
from six import StringIO
# These imports are mocked so that we don't need to add them to the
# test dependencies. The script under test for this test module is
# expected to execute only on a client VM which has built tensorflow
# from source.
sys.modules['grpc'... |
import pytest
import homeassistant.components.automation as automation
from homeassistant.components.fan import DOMAIN
from homeassistant.const import STATE_OFF, STATE_ON
from homeassistant.helpers import device_registry
from homeassistant.setup import async_setup_component
from tests.common import (
MockConfigE... |
from homeassistant.components.climate import ClimateEntity
from homeassistant.components.climate.const import (
CURRENT_HVAC_HEAT,
CURRENT_HVAC_IDLE,
CURRENT_HVAC_OFF,
HVAC_MODE_AUTO,
HVAC_MODE_HEAT,
HVAC_MODE_OFF,
PRESET_BOOST,
PRESET_NONE,
SUPPORT_PRESET_MODE,
SUPPORT_TARGET_T... |
try:
from urllib3.connectionpool import HTTPConnection, VerifiedHTTPSConnection
except ImportError:
from requests.packages.urllib3.connectionpool import HTTPConnection, VerifiedHTTPSConnection
from ..stubs import VCRHTTPConnection, VCRHTTPSConnection
# urllib3 defines its own HTTPConnection classes, which re... |
import hangups
from common import run_example
async def get_conversation(client, args):
request = hangups.hangouts_pb2.GetConversationRequest(
request_header=client.get_request_header(),
conversation_spec=hangups.hangouts_pb2.ConversationSpec(
conversation_id=hangups.hangouts_pb2.Con... |
from homeassistant.components.switch import SwitchEntity
from . import DATA_HIVE, DOMAIN, HiveEntity, refresh_system
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up Hive switches."""
if discovery_info is None:
return
session = hass.data.get(DATA_HIVE)
devs = [... |
from openrazer_daemon.dbus_services import endpoint
@endpoint('razer.device.lighting.logo', 'setLogoStatic', in_sig='yyy')
def set_logo_static_naga_hex_v2(self, red, green, blue):
"""
Set the device to static colour
:param red: Red component
:type red: int
:param green: Green component
:typ... |
import json
from homeassistant.components.wled.const import DOMAIN
from homeassistant.const import CONF_HOST, CONF_MAC, CONTENT_TYPE_JSON
from homeassistant.core import HomeAssistant
from tests.common import MockConfigEntry, load_fixture
from tests.test_util.aiohttp import AiohttpClientMocker
async def init_integr... |
from xs1_api_client.api_constants import ActuatorType
from homeassistant.helpers.entity import ToggleEntity
from . import ACTUATORS, DOMAIN as COMPONENT_DOMAIN, XS1DeviceEntity
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the XS1 switch platform."""
actuators = hass.data[C... |
from django.contrib.auth.decorators import login_required
from django.core.exceptions import PermissionDenied
from django.shortcuts import get_object_or_404, redirect
from django.views.decorators.cache import never_cache
from django.views.decorators.http import require_POST
from weblate.trans.forms import LabelForm
f... |
import pytest
from homeassistant.components import automation, zone
from homeassistant.const import ATTR_ENTITY_ID, ENTITY_MATCH_ALL, SERVICE_TURN_OFF
from homeassistant.core import Context
from homeassistant.setup import async_setup_component
from tests.common import async_mock_service, mock_component
@pytest.fix... |
from __future__ import unicode_literals
import operator
import itertools
import functools
import traceback
from core.CONF import get_conf_dic
from lib.fun.filter import encode_filter
from lib.data.data import pystrs, pyoptions
from lib.fun.fun import finalsavepath, finishprinter, cool
from lib.parse.confparse import ... |
import json
import random
import requests
import requests.exceptions
import time
class OpenTSDBClient(object):
"""OpenTSDBClient primary client object to connect OpenTSDB.
The :class:`~.OpenTSDBClient` object holds information necessary to
connect to OpenTSDB. Requests can be made to OpenTSDB directly th... |
from ..grammar import NonTerminal, Terminal
class Item(object):
"An Earley Item, the atom of the algorithm."
__slots__ = ('s', 'rule', 'ptr', 'start', 'is_complete', 'expect', 'previous', 'node', '_hash')
def __init__(self, rule, ptr, start):
self.is_complete = len(rule.expansion) == ptr
... |
import asynctest
from mock import patch
from paasta_tools.monitoring import check_mesos_outdated_tasks
@patch(
"paasta_tools.monitoring.check_mesos_outdated_tasks.get_mesos_master", autospec=True
)
def test_check_mesos_tasks(mock_get_mesos_master):
mock_get_mesos_master.return_value.state = asynctest.Corout... |
import unittest
import numpy as np
from chainer import testing
from chainercv.transforms import resize_bbox
from chainercv.utils.testing.generate_random_bbox import generate_random_bbox
class TestResizeBbox(unittest.TestCase):
def test_resize_bbox(self):
in_size = (32, 24)
out_size = (in_size[... |
import json
import logging
import pyfttt
import requests
import voluptuous as vol
from homeassistant.const import CONF_WEBHOOK_ID, HTTP_OK
from homeassistant.helpers import config_entry_flow
import homeassistant.helpers.config_validation as cv
from .const import DOMAIN
_LOGGER = logging.getLogger(__name__)
EVENT_... |
import asyncio
from copy import copy
import logging
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.const import (
CONF_BINARY_SENSORS,
CONF_LIGHTS,
CONF_MAXIMUM,
CONF_MINIMUM,
CONF_NAME,
CONF_PIN,
CONF_SENSORS,
CONF_SWITCHES,
EVENT_HOMEASSISTA... |
import textwrap
import pytest
from qutebrowser.config import configexc
from qutebrowser.utils import usertypes
def test_validation_error():
e = configexc.ValidationError('val', 'msg')
assert e.option is None
assert str(e) == "Invalid value 'val' - msg"
@pytest.mark.parametrize('deleted, renamed, expe... |
import csv
import typing
import numpy as np
import pandas as pd
import matchzoo as mz
class Embedding(object):
"""
Embedding class.
Examples::
>>> import matchzoo as mz
>>> train_raw = mz.datasets.toy.load_data()
>>> pp = mz.preprocessors.NaivePreprocessor()
>>> train =... |
import diamond.collector
class PingCollector(diamond.collector.ProcessCollector):
def get_default_config_help(self):
config_help = super(PingCollector, self).get_default_config_help()
config_help.update({
'bin': 'The path to the ping binary',
})
return config_... |
import os
import unittest
from perfkitbenchmarker import sample
from perfkitbenchmarker import test_util
from perfkitbenchmarker.windows_packages import diskspd
class DiskspdBenchmarkTestCase(unittest.TestCase, test_util.SamplesTestMixin):
def getDataContents(self, file_name):
path = os.path.join(os.path.dir... |
import os
from babelfish import Language, language_converters
import pytest
from vcr import VCR
from subliminal.providers.shooter import ShooterSubtitle, ShooterProvider
vcr = VCR(path_transformer=lambda path: path + '.yaml',
record_mode=os.environ.get('VCR_RECORD_MODE', 'once'),
match_on=['met... |
import gc
import sys
import time
import asyncio
from flexx.event import loop
from flexx import app
from flexx.event.both_tester import FakeStream, smart_compare
async def roundtrip(*sessions):
""" Coroutine to await a roundtrip to all given sessions.
"""
ok = []
def up():
ok.append(1)
f... |
import bz2
import hashlib
import logging
import struct
import sys
import zlib
from io import BytesIO
logger = logging.getLogger(__name__)
VERSION = 2, 2, 1
__version__ = '.'.join(str(i) for i in VERSION)
# %% The encoder and decoder implementation
# Shorthands
spack = struct.pack
strunpack = struct.unpack
def... |
import re
try: # pragma: no cover
from collections import OrderedDict as _dict
except ImportError:
_dict = dict
def isidentifier(s):
# http://stackoverflow.com/questions/2544972/
if not isinstance(s, str):
return False
return re.match(r'^\w+$', s, re.UNICODE) and re.match(r'^[0-9]', s) ... |
from datetime import datetime
import json
import os
import coverage
from tests.coveragetest import UsingModulesMixin, CoverageTest
class JsonReportTest(UsingModulesMixin, CoverageTest):
"""Tests of the JSON reports from coverage.py."""
def _assert_expected_json_report(self, cov, expected_result):
""... |
import asyncio
from datetime import timedelta
import logging
from pyControl4.error_handling import C4Exception
from pyControl4.light import C4Light
from homeassistant.components.light import (
ATTR_BRIGHTNESS,
ATTR_TRANSITION,
SUPPORT_BRIGHTNESS,
SUPPORT_TRANSITION,
LightEntity,
)
from homeassist... |
import asyncio
from itertools import product
import logging
from homeassistant.const import ATTR_ENTITY_ID, __version__
from homeassistant.util.decorator import Registry
from .const import (
ERR_DEVICE_OFFLINE,
ERR_PROTOCOL_ERROR,
ERR_UNKNOWN_ERROR,
EVENT_COMMAND_RECEIVED,
EVENT_QUERY_RECEIVED,
... |
import json
import pytest
import homeassistant.components.sensor as sensor
from homeassistant.const import CONF_NAME
from homeassistant.setup import async_setup_component
import homeassistant.util.dt as dt_util
from tests.async_mock import AsyncMock, patch
from tests.common import assert_setup_component, load_fixtu... |
import pytest
import numpy as np
import math
import os
import shutil
from tensorflow.keras import backend as K
from tensorflow.keras.models import Sequential, load_model # type: ignore
import tensorflow as tf
from tensornetwork.tn_keras.layers import DenseDecomp
from tensornetwork.tn_keras.layers import DenseMPO
from... |
import unittest
from absl import flags
from absl.testing import flagsaver
import mock
from tests import pkb_common_test_case
from perfkitbenchmarker.traces import tcpdump
FLAGS = flags.FLAGS
_OUTPUT_FILE = '/tmp/x.pcap'
# all vm.RemoteCommands to launch tcpdump look like this
_CMD_FORMAT = ('sudo tcpdump -n -w {out... |
import os.path as op
import pytest
from mne.datasets.testing import data_path
from mne.io import read_raw_nirx
from mne.preprocessing.nirs import optical_density, beer_lambert_law,\
_fnirs_check_bads, _fnirs_spread_bads
from mne.datasets import testing
fname_nirx_15_0 = op.join(data_path(download=False),
... |
import asyncio
from datetime import datetime, timedelta
import enum
from functools import wraps
import random
import re
import socket
import string
import threading
from types import MappingProxyType
from typing import (
Any,
Callable,
Coroutine,
Iterable,
KeysView,
Optional,
TypeVar,
U... |
import ipaddress
import logging
import re
from pdunehd import DuneHDPlayer
import voluptuous as vol
from homeassistant import config_entries, exceptions
from homeassistant.const import CONF_HOST
from .const import DOMAIN # pylint:disable=unused-import
_LOGGER = logging.getLogger(__name__)
def host_valid(host):
... |
import socket
import time
import mock
from behave import given
from behave import then
from behave import when
from marathon import MarathonHttpError
from paasta_tools import bounce_lib
from paasta_tools import drain_lib
from paasta_tools import marathon_tools
from paasta_tools import mesos_maintenance
from paasta_t... |
from unittest.mock import patch
from homeassistant.components.elgato.light import ElgatoError
from homeassistant.components.light import (
ATTR_BRIGHTNESS,
ATTR_COLOR_TEMP,
DOMAIN as LIGHT_DOMAIN,
)
from homeassistant.const import (
ATTR_ENTITY_ID,
SERVICE_TURN_OFF,
SERVICE_TURN_ON,
STATE_... |
from homeassistant.components.cover import (
DEVICE_CLASS_BLIND,
SUPPORT_CLOSE,
SUPPORT_OPEN,
SUPPORT_SET_POSITION,
CoverEntity,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.helpers.typing import HomeAssistantType
from .const import DOMAIN
from .devolo_multi_level_swit... |
import asyncio
from ipaddress import ip_address
from operator import itemgetter
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigEntry
from homeassistant.exceptions import ConfigEntryNotReady
from homeassistant.helpers import config_validation as cv, de... |
import logging
from gsp import GstreamerPlayer
import voluptuous as vol
from homeassistant.components.media_player import PLATFORM_SCHEMA, MediaPlayerEntity
from homeassistant.components.media_player.const import (
MEDIA_TYPE_MUSIC,
SUPPORT_NEXT_TRACK,
SUPPORT_PAUSE,
SUPPORT_PLAY,
SUPPORT_PLAY_ME... |
import json
import logging
import re
import requests
import voluptuous as vol
from homeassistant.components.device_tracker import (
DOMAIN,
PLATFORM_SCHEMA,
DeviceScanner,
)
from homeassistant.const import (
CONF_HOST,
CONF_PASSWORD,
CONF_PORT,
CONF_SSL,
CONF_USERNAME,
CONF_VERIFY... |
import logging
from typing import Dict, Union
import voluptuous as vol
from withings_api.common import AuthScope
from homeassistant import config_entries
from homeassistant.components.withings import const
from homeassistant.helpers import config_entry_oauth2_flow
from homeassistant.util import slugify
class Withi... |
import pytest
from homeassistant.components.NEW_DOMAIN import DOMAIN
import homeassistant.components.automation as automation
from homeassistant.const import STATE_OFF, STATE_ON
from homeassistant.helpers import device_registry
from homeassistant.setup import async_setup_component
from tests.common import (
Mock... |
from __future__ import print_function
import collections
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)
latency_histogram_by_label = collections.defaultdict(
lambda: collections.defaultdict(i... |
from __future__ import unicode_literals
import hashlib
def md5_encode(item):
"""md5 message digest algorithm output 32 char"""
try:
return (hashlib.md5(item.encode("utf-8"))).hexdigest()
except:
return ''
|
from qstrader.broker.fee_model.zero_fee_model import ZeroFeeModel
class AssetMock(object):
def __init__(self):
pass
class BrokerMock(object):
def __init__(self):
pass
def test_commission_is_zero_uniformly():
"""
Tests that each method returns zero commission,
irrespective of a... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import contextlib
import logging
import os
import platform
import posixpath
import random
import re
import string
import subprocess
import tempfile
import threading
import time
from absl import flags
import j... |
import logging
import re
import pexpect
import voluptuous as vol
from homeassistant.components.device_tracker import (
DOMAIN,
PLATFORM_SCHEMA,
DeviceScanner,
)
from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
import homeassistant.helpers.config_validation as cv
_LOGGER = logging.... |
from test import unittest
from test import run_only
from mock import Mock
from mock import patch
import configobj
import diamond.handler.riemann as mod
from diamond.metric import Metric
try:
from riemann_client.client import Client
riemann_client = True
except ImportError:
riemann_client = None
def run... |
import os
import os.path
import pytest
from coverage import files
from coverage.files import (
TreeMatcher, FnmatchMatcher, ModuleMatcher, PathAliases,
find_python_files, abs_file, actual_path, flat_rootname, fnmatches_to_regex,
)
from coverage.misc import CoverageException
from coverage import env
from tes... |
from homeassistant.const import HTTP_FORBIDDEN, HTTP_UNAUTHORIZED
def is_invalid_auth_code(http_status_code):
"""HTTP status codes that mean invalid auth."""
if http_status_code in (HTTP_UNAUTHORIZED, HTTP_FORBIDDEN):
return True
return False
def percent_conv(val):
"""Convert an actual per... |
from homeassistant import config_entries, setup
from homeassistant.components.coronavirus.const import DOMAIN, OPTION_WORLDWIDE
async def test_form(hass):
"""Test we get the form."""
await setup.async_setup_component(hass, "persistent_notification", {})
result = await hass.config_entries.flow.async_init(... |
import unittest
from unittest import mock
from homeassistant.components import dyson
from .common import load_mock_device
from tests.common import get_test_home_assistant
def _get_dyson_account_device_available():
"""Return a valid device provide by Dyson web services."""
device = mock.Mock()
load_moc... |
from typing import Optional
from aioesphomeapi import BinarySensorInfo, BinarySensorState
from homeassistant.components.binary_sensor import BinarySensorEntity
from . import EsphomeEntity, platform_async_setup_entry
async def async_setup_entry(hass, entry, async_add_entities):
"""Set up ESPHome binary sensors... |
import asyncio
from ssl import SSLContext
import sys
from typing import Any, Awaitable, Optional, Union, cast
import aiohttp
from aiohttp import web
from aiohttp.hdrs import CONTENT_TYPE, USER_AGENT
from aiohttp.web_exceptions import HTTPBadGateway, HTTPGatewayTimeout
import async_timeout
from homeassistant.const im... |
import io
import os
import lxml.html
from nikola import shortcodes as sc
from nikola.plugin_categories import PageCompiler
from nikola.utils import LocaleBorg, makedirs, map_metadata, write_metadata
class CompileHtml(PageCompiler):
"""Compile HTML into HTML."""
name = "html"
friendly_name = "HTML"
... |
import numpy as np
import pytest
# pylint: disable=line-too-long
from tensornetwork.contractors.custom_path_solvers.nconinterface import ncon_solver, ncon_to_adj, ord_to_ncon, ncon_cost_check
@pytest.mark.parametrize('chi', range(2, 6))
def test_ncon_solver(chi):
# test against network with known cost
chi = np.r... |
import os
import cherrypy
from cherrypy.test import helper
curdir = os.path.join(os.getcwd(), os.path.dirname(__file__))
class VirtualHostTest(helper.CPWebCase):
@staticmethod
def setup_server():
class Root:
@cherrypy.expose
def index(self):
return 'Hello, ... |
from homeassistant import config_entries, data_entry_flow
from homeassistant.components import ps4
from homeassistant.components.media_player.const import (
ATTR_MEDIA_CONTENT_TYPE,
ATTR_MEDIA_TITLE,
MEDIA_TYPE_GAME,
)
from homeassistant.components.ps4.const import (
ATTR_MEDIA_IMAGE_URL,
COMMANDS,... |
import argparse
import getpass
import os
from homeassistant.util.yaml import _SECRET_NAMESPACE
# mypy: allow-untyped-defs
REQUIREMENTS = ["keyring==21.2.0", "keyrings.alt==3.4.0"]
def run(args):
"""Handle keyring script."""
parser = argparse.ArgumentParser(
description=(
"Modify Home As... |
__docformat__ = "restructuredtext en"
import os
import sys
import logging
from six import string_types
from logilab.common.textutils import colorize_ansi
def set_log_methods(cls, logger):
"""bind standard logger's methods as methods on the class"""
cls.__logger = logger
for attr in ('debug', 'info', '... |
import copy
import datetime
import tempfile
from absl import flags
from perfkitbenchmarker import beam_benchmark_helper
from perfkitbenchmarker import beam_pipeline_options
from perfkitbenchmarker import configs
from perfkitbenchmarker import dpb_service
from perfkitbenchmarker import errors
from perfkitbenchmarker im... |
import asyncio
from ssl import SSLContext
from typing import List, Optional, Union
from aiohttp import web
from yarl import URL
class HomeAssistantTCPSite(web.BaseSite):
"""HomeAssistant specific aiohttp Site.
Vanilla TCPSite accepts only str as host. However, the underlying asyncio's
create_server() i... |
import pytest
from PyQt5.QtCore import QUrl
from qutebrowser.misc import autoupdate, httpclient
INVALID_JSON = ['{"invalid": { "json"}', '{"wrong": "keys"}']
class HTTPGetStub(httpclient.HTTPClient):
"""A stub class for HTTPClient.
Attributes:
url: the last url used by get()
_success: Whe... |
import logging
import blebox_uniapi
import pytest
from homeassistant.components.light import (
ATTR_BRIGHTNESS,
ATTR_HS_COLOR,
ATTR_WHITE_VALUE,
SUPPORT_BRIGHTNESS,
SUPPORT_COLOR,
SUPPORT_WHITE_VALUE,
)
from homeassistant.const import (
ATTR_SUPPORTED_FEATURES,
SERVICE_TURN_OFF,
S... |
from test import CollectorTestCase
from test import get_collector_config
from snmpinterface import SNMPInterfaceCollector
class TestSNMPInterfaceCollector(CollectorTestCase):
def setUp(self, allowed_names=None):
if not allowed_names:
allowed_names = []
config = get_collector_config(... |
import numpy as np
from ..utils import read_str
def _unpack_matrix(fid, rows, cols, dtype, out_dtype):
"""Unpack matrix."""
dtype = np.dtype(dtype)
string = fid.read(int(dtype.itemsize * rows * cols))
out = np.frombuffer(string, dtype=dtype).reshape(
rows, cols).astype(out_dtype)
return... |
import asyncio
from datetime import timedelta
import functools
import logging
from typing import Optional
import aiohttp
from async_upnp_client import UpnpFactory
from async_upnp_client.aiohttp import AiohttpNotifyServer, AiohttpSessionRequester
from async_upnp_client.profiles.dlna import DeviceState, DmrDevice
impor... |
import logging
from devolo_home_control_api.mydevolo import Mydevolo
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from homeassistant.core import callback
from .const import ( # pylint:disable=unused-import
CONF_HOMECONTROL,
C... |
import os
import os.path as op
from shutil import copyfile
import numpy as np
from scipy import sparse
import pytest
from numpy.testing import assert_array_equal, assert_allclose, assert_equal
from mne.datasets import testing
from mne import (read_surface, write_surface, decimate_surface, pick_types,
... |
import io
from setuptools import setup, find_packages # pylint: disable=no-name-in-module,import-error
def dependencies(file):
with open(file) as f:
return f.read().splitlines()
with io.open("README.md", encoding='utf-8') as infile:
long_description = infile.read()
setup(
name='halo',
pac... |
from unittest import TestCase
import numpy as np
import pandas as pd
from scattertext import whitespace_nlp_with_sentences
from scattertext.features.FeatsFromScoredLexicon import FeatsFromScoredLexicon
class TestFeatsFromScoredLexicon(TestCase):
def test_main(self):
lexicon_df = pd.DataFrame({'activatio... |
import asyncio
from datetime import timedelta
import logging
from aiohttp import ClientConnectionError
from async_timeout import timeout
from pydaikin.daikin_base import Appliance
import voluptuous as vol
from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
from homeassistant.const import CONF_API_KEY... |
from openzwavemqtt.const import ATTR_POSITION, ATTR_VALUE
from openzwavemqtt.exceptions import InvalidValueError, NotFoundError, WrongTypeError
import pytest
from .common import setup_ozw
async def test_services(hass, light_data, sent_messages):
"""Test services on lock."""
await setup_ozw(hass, fixture=lig... |
from __future__ import print_function
import configobj
import optparse
import os
import shutil
import sys
import tempfile
import traceback
sys.path.append(os.path.abspath(
os.path.join(os.path.dirname(__file__), 'src')))
def getIncludePaths(path):
for f in os.listdir(path):
cPath = os.path.abspath(o... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.