text stringlengths 213 32.3k |
|---|
import argparse
import logging
import sys
import service_configuration_lib
from kubernetes.client import V1DeleteOptions
from kubernetes.client.rest import ApiException
from paasta_tools.kubernetes_tools import KubeClient
from paasta_tools.kubernetes_tools import paasta_prefixed
from paasta_tools.utils import DEFAUL... |
from __future__ import division, print_function
"""
Urwid tree view
Features:
- custom selectable widgets for trees
- custom list walker for displaying widgets in a tree fashion
"""
import urwid
from urwid.wimp import SelectableIcon
class TreeWidgetError(RuntimeError):
pass
class TreeWidget(urwid.WidgetWra... |
from homeassistant.components.nuheat.const import DOMAIN
from homeassistant.setup import async_setup_component
from .mocks import _get_mock_nuheat
from tests.async_mock import patch
VALID_CONFIG = {
"nuheat": {"username": "warm", "password": "feet", "devices": "thermostat123"}
}
INVALID_CONFIG = {"nuheat": {"us... |
import json
import os
import pytest
from homeassistant.components.demo import DOMAIN
from homeassistant.components.device_tracker.legacy import YAML_DEVICES
from homeassistant.helpers.json import JSONEncoder
from homeassistant.setup import async_setup_component
@pytest.fixture(autouse=True)
def mock_history(hass):... |
import mimetypes
from pathlib import Path
from typing import Tuple
from aiohttp import web
from homeassistant.components.http import HomeAssistantView
from homeassistant.components.media_player.const import MEDIA_CLASS_DIRECTORY
from homeassistant.components.media_player.errors import BrowseError
from homeassistant.... |
import logging
import wave
import pyaudio
from kalliope.core.PlayerModule import PlayerModule
logging.basicConfig()
logger = logging.getLogger("kalliope")
CHUNK = 1024
class Pyaudioplayer(PlayerModule):
"""
This Class is representing the Player Object used to play the all sound of the system.
"""
... |
from kombu.matcher import (
match, register, registry, unregister, fnmatch, rematch,
MatcherNotInstalled
)
import pytest
class test_Matcher:
def test_register_match_unregister_matcher(self):
register("test_matcher", rematch)
registry.matcher_pattern_first.append("test_matcher")
... |
import logging
from datetime import datetime
from datetime import timedelta
from datetime import timezone
from typing import Optional
from typing import Sequence
from marathon.models.task import MarathonTask
from paasta_tools import marathon_tools
from paasta_tools import monitoring_tools
from paasta_tools.check_ser... |
import asyncio
import logging
from pysqueezebox import Server, async_discover
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.const import (
CONF_HOST,
CONF_PASSWORD,
CONF_PORT,
CONF_USERNAME,
HTTP_UNAUTHORIZED,
)
from homeassistant.helpers.aiohttp_client impo... |
from keras.models import Model
from keras.layers import Input, Dot
from matchzoo.engine.param_table import ParamTable
from matchzoo.engine.base_model import BaseModel
from matchzoo import preprocessors
class DSSM(BaseModel):
"""
Deep structured semantic model.
Examples:
>>> model = DSSM()
... |
import argparse
import chainer
from chainer import iterators
import chainermn
from chainercv.utils import apply_to_iterator
from chainercv.utils import ProgressHook
from eval_instance_segmentation import models
from eval_instance_segmentation import setup
def main():
parser = argparse.ArgumentParser()
par... |
import datetime
from typing import Set
from appconf import AppConf
from django.conf import settings
from django.contrib.auth.signals import user_logged_in
from django.core.exceptions import ValidationError
from django.core.validators import MaxValueValidator, MinValueValidator
from django.db import models, transactio... |
from datetime import timedelta
import logging
from math import ceil
import pytankerkoenig
import voluptuous as vol
from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
from homeassistant.const import (
CONF_API_KEY,
CONF_LATITUDE,
CONF_LONGITUDE,
CONF_RADIUS,
CONF_SCAN_INTERVAL,
... |
from datetime import datetime
import mock
from mock import Mock
from paasta_tools.autoscaling import ec2_fitness
from paasta_tools.mesos_tools import SlaveTaskCount
def test_sort_by_total_tasks():
mock_slave_1 = Mock(
task_counts=SlaveTaskCount(count=3, slave=Mock(), batch_count=0)
)
mock_slave... |
from homeassistant.config_entries import ConfigEntry
from homeassistant.helpers.typing import HomeAssistantType
from .camera_legacy import async_setup_legacy_entry
from .camera_sdm import async_setup_sdm_entry
from .const import DATA_SDM
async def async_setup_entry(
hass: HomeAssistantType, entry: ConfigEntry, ... |
from __future__ import absolute_import
import re
xpath_tokenizer_re = re.compile(
"("
"'[^']*'|\"[^\"]*\"|"
"::|"
"//?|"
r"\.\.|"
r"\(\)|"
r"[/.*:\[\]\(\)@=])|"
r"((?:\{[^}]+\})?[^/\[\]\(\)@=\s]+)|"
r"\s+"
)
def xpath_tokenizer(pattern, namespaces=None):
# ElementTree use... |
try:
import yaml
except ImportError:
yaml = None
import diamond.collector
class PuppetAgentCollector(diamond.collector.Collector):
def get_default_config_help(self):
config_help = super(PuppetAgentCollector,
self).get_default_config_help()
config_help.update(... |
import requests
from nikola.plugin_categories import MarkdownExtension
from nikola.utils import get_logger
try:
from markdown.extensions import Extension
from markdown.inlinepatterns import Pattern
from markdown.util import AtomicString
from markdown.util import etree
except ImportError:
# No nee... |
from arctic.arctic import Arctic
from arctic.store.metadata_store import MetadataStore
from arctic.store.version_store import VersionStore
def test_arctic(arctic):
assert isinstance(arctic, Arctic)
def test_library(library):
assert isinstance(library, VersionStore)
assert library._arctic_lib.get_librar... |
import proliphix
import voluptuous as vol
from homeassistant.components.climate import PLATFORM_SCHEMA, ClimateEntity
from homeassistant.components.climate.const import (
CURRENT_HVAC_COOL,
CURRENT_HVAC_HEAT,
CURRENT_HVAC_IDLE,
CURRENT_HVAC_OFF,
HVAC_MODE_COOL,
HVAC_MODE_HEAT,
HVAC_MODE_OF... |
import logging
from agent import AgentConnectionError, AgentError
from agent.a import Agent
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.const import CONF_HOST, CONF_PORT
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from .const import DOMAIN, SERVE... |
import json
import os
import pathlib
import re
import subprocess
from .const import CLI_2_DOCKER_IMAGE, CORE_PROJECT_ID, INTEGRATIONS_DIR
from .error import ExitApp
from .util import get_current_branch, get_lokalise_token
FILENAME_FORMAT = re.compile(r"strings\.(?P<suffix>\w+)\.json")
LOCAL_FILE = pathlib.Path("buil... |
revision = "932525b82f1a"
down_revision = "7f71c0cea31a"
from alembic import op
def upgrade():
op.alter_column("certificates", "active", new_column_name="notify")
def downgrade():
op.alter_column("certificates", "notify", new_column_name="active")
|
import sys, os
sys.path = [os.path.abspath(os.path.dirname(__file__))] + sys.path
import pandas as pd
from sklearn.datasets import load_boston
from sklearn.metrics import brier_score_loss, mean_squared_error
from sklearn.model_selection import train_test_split
from auto_ml import Predictor
def get_boston_regression... |
from __future__ import unicode_literals
from rules.SDrule import SDrule
from lib.data.data import pyoptions
def SB(sname, birth):
for _ in SDrule(sname, birth):
yield _
for sn in sname:
for bd in birth:
# {sname birth SNAME}
yield sn.lower() + bd + sn.upper()
... |
import os
import os.path
import io
import re
import sys
import enum
import json
import datetime
import traceback
import functools
import contextlib
import posixpath
import shlex
import glob
import mimetypes
import ctypes
import ctypes.util
from typing import Any, Callable, IO, Iterator, Optional, Sequence, Tuple, Type... |
import contextlib
import os
import posixpath
import sys
import threading
from tempfile import TemporaryDirectory
if os.name == "nt":
import ctypes
import ctypes.wintypes
import msvcrt
LOCKFILE_EXCLUSIVE_LOCK = 2
if ctypes.sizeof(ctypes.c_void_p) == 4:
ULONG_PTR = ctypes.c_uint32
else:... |
import datetime
import re
import sys
import git
URL = 'https://github.com/miguelgrinberg/flask-migrate'
merges = {}
def format_message(commit):
if commit.message.startswith('Version '):
return ''
if '#nolog' in commit.message:
return ''
if commit.message.startswith('Merge pull request'):... |
from datetime import timedelta
import logging
import requests
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import (
CONF_HOST,
CONF_MONITORED_CONDITIONS,
CONF_NAME,
STATE_UNKNOWN,
TIME_DAYS,
)
import homeassistant.helpers.config_val... |
import pytest
from homeassistant.components.media_player.const import DOMAIN as MP_DOMAIN
from homeassistant.components.vizio.const import DOMAIN
from homeassistant.helpers.typing import HomeAssistantType
from homeassistant.setup import async_setup_component
from .const import MOCK_SPEAKER_CONFIG, MOCK_USER_VALID_TV... |
from dynalite_devices_lib.dynalite_devices import (
CONF_AREA as dyn_CONF_AREA,
CONF_PRESET as dyn_CONF_PRESET,
NOTIFICATION_PACKET,
NOTIFICATION_PRESET,
DynaliteNotification,
)
from homeassistant.components import dynalite
from homeassistant.components.dynalite.const import (
ATTR_AREA,
A... |
import xml.etree.ElementTree as ET
from http import client
from radicale import app, httputils, storage, xmlutils
def xml_delete(base_prefix, path, collection, href=None):
"""Read and answer DELETE requests.
Read rfc4918-9.6 for info.
"""
collection.delete(href)
multistatus = ET.Element(xmlut... |
from datetime import timedelta
import librouteros
import pytest
from homeassistant import data_entry_flow
from homeassistant.components import mikrotik
from homeassistant.const import (
CONF_HOST,
CONF_NAME,
CONF_PASSWORD,
CONF_PORT,
CONF_USERNAME,
CONF_VERIFY_SSL,
)
from tests.async_mock im... |
from homeassistant.components import dynalite
from homeassistant.helpers import entity_registry
from tests.async_mock import AsyncMock, Mock, call, patch
from tests.common import MockConfigEntry
ATTR_SERVICE = "service"
ATTR_METHOD = "method"
ATTR_ARGS = "args"
def create_mock_device(platform, spec):
"""Create... |
from gogogate2_api import GogoGate2Api
from gogogate2_api.common import ApiError
from gogogate2_api.const import GogoGate2ApiErrorCode
from homeassistant import config_entries, setup
from homeassistant.components.gogogate2.const import (
DEVICE_TYPE_GOGOGATE2,
DEVICE_TYPE_ISMARTGATE,
DOMAIN,
)
from homeas... |
from homeassistant.components.alarm_control_panel import AlarmControlPanelEntity
from homeassistant.components.alarm_control_panel.const import (
SUPPORT_ALARM_ARM_AWAY,
SUPPORT_ALARM_ARM_HOME,
SUPPORT_ALARM_ARM_NIGHT,
SUPPORT_ALARM_TRIGGER,
)
from homeassistant.const import (
STATE_ALARM_ARMED_AWA... |
from datetime import timedelta
import logging
import iperf3
import voluptuous as vol
from homeassistant.components.sensor import DOMAIN as SENSOR_DOMAIN
from homeassistant.const import (
CONF_HOST,
CONF_HOSTS,
CONF_MONITORED_CONDITIONS,
CONF_PORT,
CONF_PROTOCOL,
CONF_SCAN_INTERVAL,
DATA_R... |
import aiohttp.web_exceptions
import voluptuous as vol
import voluptuous_serialize
from homeassistant import config_entries, data_entry_flow
from homeassistant.auth.permissions.const import CAT_CONFIG_ENTRIES, POLICY_EDIT
from homeassistant.components import websocket_api
from homeassistant.components.http import Hom... |
from appconf import AppConf
from django.core.cache import cache
from django.db.models.signals import post_save
from django.dispatch import receiver
from weblate.trans.models import Change
from weblate.utils.decorators import disable_for_loaddata
class WeblateConf(AppConf):
WEBLATE_GPG_IDENTITY = None
WEBLAT... |
import numpy as np
import networkx as nx
from pgmpy.models.BayesianModel import BayesianModel
from pgmpy.estimators.LinearModel import LinearEstimator
from pgmpy.utils.sets import _powerset, _variable_or_iterable_to_set
class CausalInference(object):
"""
This is an inference class for performing Causal Infe... |
from cerberus import errors
from cerberus.tests import assert_fail, assert_success
def test_valuesrules_succeds():
assert_success(
document={'a_dict_with_valuesrules': {'an integer': 99, 'another integer': 100}}
)
def test_valuesrules_fails(validator):
assert_fail(
document={'a_dict_wit... |
from ipaddress import ip_address
import logging
import urllib
from doorbirdpy import DoorBird
import voluptuous as vol
from homeassistant import config_entries, core, exceptions
from homeassistant.const import (
CONF_HOST,
CONF_NAME,
CONF_PASSWORD,
CONF_USERNAME,
HTTP_UNAUTHORIZED,
)
from homeass... |
import unittest
import locale
import urwid
from urwid import util
from urwid.compat import B
class CalcWidthTest(unittest.TestCase):
def wtest(self, desc, s, exp):
s = B(s)
result = util.calc_width( s, 0, len(s))
assert result==exp, "%s got:%r expected:%r" % (desc, result, exp)
def ... |
from . import mock_dict
from . import utils
import boto.s3.bucket
import boto.s3.connection
import boto.s3.key
import six
Bucket__init__ = boto.s3.bucket.Bucket.__init__
@six.add_metaclass(utils.monkeypatch_class)
class MultiPartUpload(boto.s3.multipart.MultiPartUpload):
def upload_part_from_file(self, io, num... |
from absl import flags
from perfkitbenchmarker.linux_packages import cuda_toolkit
CUDNN_7_4_9 = 'libcudnn7=7.4.2.24-1+cuda9.0'
CUDNN_7_4_10 = 'libcudnn7=7.4.2.24-1+cuda10.0'
CUDNN_7_6_1 = 'libcudnn7=7.6.1.34-1+cuda10.1'
FLAGS = flags.FLAGS
def AptInstall(vm):
"""Installs the cudnn package on the VM."""
if not ... |
from plumbum import local, cli, FG
from plumbum.path.utils import delete
try:
from plumbum.cmd import twine
except ImportError:
twine = None
class BuildProject(cli.Application):
'Build and optionally upload. For help, see https://packaging.python.org/en/latest/distributing/#uploading-your-project-to-pypi... |
from datetime import timedelta
import logging
import time
from sqlalchemy.exc import OperationalError, SQLAlchemyError
import homeassistant.util.dt as dt_util
from .models import Events, RecorderRuns, States
from .util import execute, session_scope
_LOGGER = logging.getLogger(__name__)
def purge_old_data(instanc... |
import os
import os.path
import sys
import bdb
import pdb # noqa: T002
import signal
import argparse
import functools
import threading
import faulthandler
from typing import TYPE_CHECKING, Optional, MutableMapping, cast
import attr
from PyQt5.QtCore import (pyqtSlot, qInstallMessageHandler, QObject,
... |
class OpenApiException(Exception):
"""The base exception class for all OpenAPIExceptions"""
class ApiTypeError(OpenApiException, TypeError):
def __init__(self, msg, path_to_item=None, valid_classes=None,
key_type=None):
""" Raises an exception for TypeErrors
Args:
... |
import asyncio
from datetime import timedelta
import io
import logging
from PIL import Image
import voluptuous as vol
from homeassistant.components.camera import (
PLATFORM_SCHEMA,
Camera,
async_get_image,
async_get_mjpeg_stream,
async_get_still_stream,
)
from homeassistant.const import CONF_ENTI... |
from typing import Dict, List
import voluptuous as vol
from homeassistant.const import (
ATTR_ENTITY_ID,
CONF_CONDITION,
CONF_DEVICE_ID,
CONF_DOMAIN,
CONF_ENTITY_ID,
CONF_TYPE,
)
from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers import condition, config_validat... |
import errno
import glob
import os
import shutil
import click
import sh
from molecule import config
from molecule import logger
from molecule import migrate
from molecule import scenario
from molecule import util
LOG = logger.get_logger(__name__)
class Convert(object):
def __init__(self, old_molecule_file, dr... |
from homeassistant.components.binary_sensor import PLATFORM_SCHEMA, BinarySensorEntity
from . import edge_detect, read_input, setup_input, setup_mode
from .const import CONF_INVERT_LOGIC, CONF_PIN_MODE, CONF_PORTS, PORT_SCHEMA
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(PORT_SCHEMA)
async def async_setup_platform(has... |
import mock
from scrapy.settings import Settings
from scrapy_redis import defaults
from scrapy_redis.connection import (
from_settings,
get_redis,
get_redis_from_settings,
)
class TestGetRedis(object):
def test_default_instance(self):
server = get_redis()
assert isinstance(server, ... |
import sys
from lark import Lark, Transformer, v_args
json_grammar = r"""
?start: value
?value: object
| array
| string
| SIGNED_NUMBER -> number
| "true" -> true
| "false" -> false
| "null" -> null
arra... |
from datetime import timedelta
import functools as ft
import logging
import voluptuous as vol
from homeassistant.const import (
ATTR_CODE,
ATTR_CODE_FORMAT,
SERVICE_LOCK,
SERVICE_OPEN,
SERVICE_UNLOCK,
STATE_LOCKED,
STATE_UNLOCKED,
)
import homeassistant.helpers.config_validation as cv
fro... |
import pytest
from lemur.tests.vectors import INTERNAL_PRIVATE_KEY_A_STR, INTERNAL_CERTIFICATE_A_STR
def test_export_certificate_to_pkcs12(app):
from lemur.plugins.base import plugins
p = plugins.get("openssl-export")
options = [
{"name": "passphrase", "value": "test1234"},
{"name": "typ... |
import re
from homeassistant.components.aurora import binary_sensor as aurora
from tests.common import load_fixture
def test_setup_and_initial_state(hass, requests_mock):
"""Test that the component is created and initialized as expected."""
uri = re.compile(r"http://services\.swpc\.noaa\.gov/text/aurora-no... |
from weblate.checks.markup import (
BBCodeCheck,
MarkdownLinkCheck,
MarkdownRefLinkCheck,
MarkdownSyntaxCheck,
SafeHTMLCheck,
URLCheck,
XMLTagsCheck,
XMLValidityCheck,
)
from weblate.checks.tests.test_checks import CheckTestCase
from weblate.trans.models import Unit
class BBCodeCheckT... |
from homeassistant.components import sensor
from homeassistant.const import (
CONCENTRATION_PARTS_PER_MILLION,
DEGREE,
ELECTRICAL_CURRENT_AMPERE,
ENERGY_KILO_WATT_HOUR,
LIGHT_LUX,
PERCENTAGE,
POWER_WATT,
VOLT,
)
from .entity import (
BlockAttributeDescription,
ShellyBlockAttrib... |
from __future__ import absolute_import, division, print_function
import numpy.random as random
from numpy.random import randn
import numpy as np
import matplotlib.pyplot as plt
from pytest import approx
from filterpy.kalman import KalmanFilter, update, predict, batch_filter
from filterpy.common import Q_discrete_whi... |
import asyncio
from datetime import timedelta
import logging
import voluptuous as vol
from homeassistant.const import ATTR_ENTITY_ID, ATTR_NAME, CONF_ENTITY_ID, CONF_NAME
from homeassistant.core import callback
from homeassistant.exceptions import HomeAssistantError
import homeassistant.helpers.config_validation as ... |
from typing import Callable, TypeVar
CALLABLE_T = TypeVar("CALLABLE_T", bound=Callable) # pylint: disable=invalid-name
class Registry(dict):
"""Registry of items."""
def register(self, name: str) -> Callable[[CALLABLE_T], CALLABLE_T]:
"""Return decorator to register item with a specific name."""
... |
from homeassistant.exceptions import HomeAssistantError
class CertExpiryException(HomeAssistantError):
"""Base class for cert_expiry exceptions."""
class TemporaryFailure(CertExpiryException):
"""Temporary failure has occurred."""
class ValidationFailure(CertExpiryException):
"""Certificate validatio... |
import logging
from typing import Optional
from homeassistant.components.geo_location import GeolocationEvent
from homeassistant.const import (
ATTR_ATTRIBUTION,
CONF_UNIT_SYSTEM_IMPERIAL,
LENGTH_KILOMETERS,
LENGTH_MILES,
)
from homeassistant.core import callback
from homeassistant.helpers.dispatcher ... |
from test import CollectorTestCase
from test import get_collector_config
from test import unittest
from mock import Mock
from mock import patch
try:
from cStringIO import StringIO
except ImportError:
from StringIO import StringIO
from diamond.collector import Collector
from xfs import XFSCollector
#########... |
import os
from nikola.plugin_categories import Task
from nikola.utils import config_changed, LOGGER
class RenderPages(Task):
"""Render pages into output."""
name = "render_pages"
def gen_tasks(self):
"""Build final pages from metadata and HTML fragments."""
kw = {
"post_pag... |
import logging
import datapoint
from .const import MODE_3HOURLY
_LOGGER = logging.getLogger(__name__)
class MetOfficeData:
"""Get current and forecast data from Datapoint.
Please note that the 'datapoint' library is not asyncio-friendly, so some
calls have had to be wrapped with the standard hassio h... |
from homeassistant import config_entries, data_entry_flow
from homeassistant.components.advantage_air.const import DOMAIN
from tests.async_mock import patch
from tests.components.advantage_air import TEST_SYSTEM_DATA, TEST_SYSTEM_URL, USER_INPUT
async def test_form(hass, aioclient_mock):
"""Test that form shows... |
from absl import flags
FLAGS = flags.FLAGS
CLOUD_TPU_GIT = 'https://github.com/tensorflow/tpu.git'
flags.DEFINE_string('cloud_tpu_commit_hash',
'45f33771f9d9aef6d37386d07b086d7e20be0254',
'git commit hash of desired cloud TPU models commit.')
def Install(vm):
"""Installs cl... |
import unittest
import numpy as np
from chainer.backends import cuda
from chainer import testing
from chainer.testing import attr
from chainercv.utils import generate_random_bbox
from chainercv.utils import non_maximum_suppression
@testing.parameterize(
{'threshold': 1, 'expect': np.array([0, 1, 2, 3])},
... |
import sys
import json
import textwrap
import os
import signal
import time
import pytest
import pytest_bdd as bdd
from PyQt5.QtCore import pyqtSignal, pyqtSlot, QObject, QFileSystemWatcher
bdd.scenarios('editor.feature')
from qutebrowser.utils import utils
@bdd.when(bdd.parsers.parse('I set up a fake editor replac... |
from qutebrowser.config import config
from qutebrowser.utils import utils, log
from qutebrowser.misc import objects
@utils.prevent_exceptions(False) # Runs in I/O thread
def _accept_cookie(request):
"""Check whether the given cookie should be accepted."""
url = request.firstPartyUrl
if not url.isValid()... |
from __future__ import division
import argparse
import functools
import multiprocessing
import numpy as np
import random
import six
import chainer
from chainer.dataset.convert import _concat_arrays
from chainer.dataset.convert import to_device
import chainer.links as L
from chainer.training import extensions
from c... |
import pytest
from mne.viz._figure import _browse_figure, _psd_figure
def test_browse_figure_constructor():
"""Test error handling in MNEBrowseFigure constructor."""
with pytest.raises(TypeError, match='an instance of Raw, Epochs, or ICA'):
_browse_figure('foo')
def test_psd_figure_constructor():
... |
import unittest
from absl import flags
import mock
from perfkitbenchmarker import temp_dir
from perfkitbenchmarker import units
from perfkitbenchmarker import vm_util
from perfkitbenchmarker.linux_benchmarks import fio_benchmark
from tests import pkb_common_test_case
from six.moves import builtins
FLAGS = flags.FLAG... |
from homeassistant.components.london_air.sensor import CONF_LOCATIONS, URL
from homeassistant.const import HTTP_OK, HTTP_SERVICE_UNAVAILABLE
from homeassistant.setup import async_setup_component
from tests.common import load_fixture
VALID_CONFIG = {"sensor": {"platform": "london_air", CONF_LOCATIONS: ["Merton"]}}
... |
import unittest
from absl import flags
import mock
from perfkitbenchmarker import benchmark_spec
from perfkitbenchmarker import context
from perfkitbenchmarker import disk
from perfkitbenchmarker import vm_util
from perfkitbenchmarker.configs import benchmark_config_spec
from perfkitbenchmarker.providers.aws import a... |
from __future__ import print_function
import argparse
import sys
_stash = globals()["_stash"]
class ConsoleQuicklook(object):
def __init__(self, args):
p = argparse.ArgumentParser(description=__doc__)
p.add_argument("file", action="store", help="file to open")
ns = p.parse_args(args)
... |
import mock
from scrapy import Spider
from scrapy.http import Request
from scrapy_redis.queue import Base
class TestBaseQueue(object):
queue_cls = Base
def setup(self):
self.server = mock.Mock()
self.spider = Spider(name='foo')
self.spider.parse_method = lambda x: x
self.k... |
from unittest import TestCase
import numpy as np
import pandas as pd
from scattertext.termscoring.BetaPosterior import BetaPosterior
from scattertext.test.test_termDocMatrixFactory import build_hamlet_jz_corpus
class TestBetaPosterior(TestCase):
def test_get_score_df(self):
corpus = build_hamlet_jz_corp... |
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 ping import PingCollector
##########################################################################
class TestPingCollector(C... |
from flask import Flask, jsonify, Response, request
from flasgger import Swagger, SwaggerView
swagger_config = {
"headers": [],
"openapi": "3.0.2",
"components": {
'schemas': {
'Species': {
'type': 'object',
'properties': {
'id': {
... |
from functools import lru_cache
from aiohttp.helpers import reify
from plexapi.exceptions import NotFound
from homeassistant.components.plex.const import (
CONF_SERVER,
CONF_SERVER_IDENTIFIER,
PLEX_SERVER_CONFIG,
)
from homeassistant.const import CONF_URL
from .const import DEFAULT_DATA, MOCK_SERVERS, M... |
import pytest
import sys
import time
from contextlib import contextmanager
from plumbum.cli.terminal import ask, choose, prompt, hexdump, Progress
from plumbum.lib import StringIO
try:
from collections import OrderedDict
except ImportError:
try:
from ordereddict import OrderedDict
except ImportEr... |
import logging
from requests import RequestException, Session
from schluter.api import Api
from schluter.authenticator import AuthenticationState, Authenticator
import voluptuous as vol
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from homeassistant.helpers import discovery
import homeassistant.helpe... |
import contextlib
import mock
import pytest
from scrapy import signals
from scrapy.exceptions import DontCloseSpider
from scrapy.settings import Settings
from scrapy_redis.spiders import (
RedisCrawlSpider,
RedisSpider,
)
@contextlib.contextmanager
def flushall(server):
try:
yield
finally:
... |
import logging
from homeassistant.const import TIME_MINUTES, UV_INDEX
from homeassistant.core import callback
from homeassistant.util.dt import as_local, parse_datetime
from . import (
DATA_OPENUV_CLIENT,
DATA_UV,
DOMAIN,
TYPE_CURRENT_OZONE_LEVEL,
TYPE_CURRENT_UV_INDEX,
TYPE_CURRENT_UV_LEVEL,... |
import logging
from typing import List
from pyflexit.pyflexit import pyflexit
import voluptuous as vol
from homeassistant.components.climate import PLATFORM_SCHEMA, ClimateEntity
from homeassistant.components.climate.const import (
HVAC_MODE_COOL,
SUPPORT_FAN_MODE,
SUPPORT_TARGET_TEMPERATURE,
)
from home... |
import base64
import logging
import ntpath
import os
import time
import uuid
from absl import flags
from perfkitbenchmarker import disk
from perfkitbenchmarker import errors
from perfkitbenchmarker import os_types
from perfkitbenchmarker import virtual_machine
from perfkitbenchmarker import vm_util
from perfkitbenchm... |
from app.utils import JsonUtil
import flask
from app.utils import RequestUtil
def standard_response(success, data):
'''standard response
'''
rst = {}
rst['success'] = success
rst['data'] = data
return JsonUtil.object_2_json(rst)
# 重写 render_template 写入固定的一些参数
def render_template(*args, **kw... |
import asyncio
from homeassistant import config_entries, core
from .const import DOMAIN
from .hub import PulseHub
CONF_HUBS = "hubs"
PLATFORMS = ["cover", "sensor"]
async def async_setup(hass: core.HomeAssistant, config: dict):
"""Set up the Rollease Acmeda Automate component."""
return True
async def ... |
from typing import Optional
import zigpy.zcl.clusters.homeautomation as homeautomation
from .. import registries
from ..const import (
CHANNEL_ELECTRICAL_MEASUREMENT,
REPORT_CONFIG_DEFAULT,
SIGNAL_ATTR_UPDATED,
)
from .base import ZigbeeChannel
@registries.ZIGBEE_CHANNEL_REGISTRY.register(
homeauto... |
from copy import deepcopy
from homeassistant.components.deconz.deconz_event import CONF_DECONZ_EVENT
from homeassistant.components.deconz.gateway import get_gateway_from_config_entry
from .test_gateway import DECONZ_WEB_REQUEST, setup_deconz_integration
from tests.common import async_capture_events
SENSORS = {
... |
import unittest
from perfkitbenchmarker import errors
from perfkitbenchmarker.configs import option_decoders
import six
_COMPONENT = 'test_component'
_FLAGS = None
_OPTION = 'test_option'
def _ReturnFive():
return 5
class _PassThroughDecoder(option_decoders.ConfigOptionDecoder):
def Decode(self, value, comp... |
import gevent.monkey
gevent.monkey.patch_all()
import logging
import os
from . import driver
from . import lru
from .exceptions import FileNotFoundError
logger = logging.getLogger(__name__)
class Base(driver.Base):
supports_bytes_range = True
def __init__(self, path=None, config=None):
self._con... |
import os
import platform
import sys
# Operating systems.
WINDOWS = sys.platform == "win32"
LINUX = sys.platform.startswith("linux")
# Python versions. We amend version_info with one more value, a zero if an
# official version, or 1 if built from source beyond an official version.
PYVERSION = sys.version_info + (int... |
from homeassistant.components.kodi.const import CONF_WS_PORT, DOMAIN
from homeassistant.const import (
CONF_HOST,
CONF_NAME,
CONF_PASSWORD,
CONF_PORT,
CONF_SSL,
CONF_USERNAME,
)
from .util import MockConnection
from tests.async_mock import patch
from tests.common import MockConfigEntry
asyn... |
import pytest
import homeassistant.components.logentries as logentries
from homeassistant.const import EVENT_STATE_CHANGED, STATE_OFF, STATE_ON
from homeassistant.setup import async_setup_component
from tests.async_mock import MagicMock, call, patch
async def test_setup_config_full(hass):
"""Test setup with al... |
from flask import Flask
from flexx import flx
from flexxamples.howtos.editor_cm import CodeEditor
# Define an app
class MyApp(flx.Widget):
def init(self):
with flx.HBox():
CodeEditor(flex=1)
flx.Widget(flex=1)
# Dump it to a dictionary of assets that we can serve. Make the main... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.