text stringlengths 213 32.3k |
|---|
from importlib.abc import MetaPathFinder
import warnings
class SharedLibDeprecationWarning(DeprecationWarning):
pass
warnings.simplefilter("always", SharedLibDeprecationWarning)
class SharedLibImportWarner(MetaPathFinder):
"""
Deprecation warner for shared libraries. This class sits on `sys.meta_path... |
import platform
import sys
def whatever(f):
try:
return f()
except:
return f
def dump_module(mod):
print("\n### {} ---------------------------".format(mod.__name__))
for name in dir(mod):
if name.startswith("_"):
continue
print("{:30s}: {!r:.100}".format... |
from __future__ import unicode_literals
import itertools
from lib.fun.decorator import magic
from lib.data.data import pystrs, pyoptions
from lib.parse.confparse import elementparser, confmatcher
from lib.fun.fun import countchecker, lengthchecker, range_compatible, cool
def build_conf_dic(source=""):
@magic
... |
from typing import Any, Dict
from homematicip.aio.device import (
AsyncAccelerationSensor,
AsyncContactInterface,
AsyncDevice,
AsyncFullFlushContactInterface,
AsyncMotionDetectorIndoor,
AsyncMotionDetectorOutdoor,
AsyncMotionDetectorPushButton,
AsyncPluggableMainsFailureSurveillance,
... |
from django.core.exceptions import ValidationError
from django.utils.translation import gettext as _
from weblate.checks.flags import Flags
def validate_filemask(val):
"""Validate that filemask contains *."""
if "*" not in val:
raise ValidationError(
_("Filemask does not contain * as a l... |
import asyncio
import logging
from typing import Any, Dict, Iterable, Optional
from homeassistant.const import ATTR_ENTITY_ID
from homeassistant.core import Context, State
from homeassistant.helpers.typing import HomeAssistantType
from . import (
ATTR_DURATION,
DOMAIN,
SERVICE_CANCEL,
SERVICE_PAUSE,
... |
from collections import namedtuple
import unittest
from absl import flags
from perfkitbenchmarker import sample
from perfkitbenchmarker import test_util
from perfkitbenchmarker.windows_packages import iperf3
FLAGS = flags.FLAGS
FLAGS.mark_as_parsed()
# Command generating these results:
# ./iperf3.exe --client 10.12... |
import asyncio
from datetime import timedelta
import logging
import urllib.error
import aiohttp
import pytest
import requests
from homeassistant.helpers import update_coordinator
from homeassistant.util.dt import utcnow
from tests.async_mock import AsyncMock, Mock, patch
from tests.common import async_fire_time_cha... |
import logging
from pythonegardia import egardiadevice, egardiaserver
import requests
import voluptuous as vol
from homeassistant.const import (
CONF_HOST,
CONF_NAME,
CONF_PASSWORD,
CONF_PORT,
CONF_USERNAME,
EVENT_HOMEASSISTANT_STOP,
)
from homeassistant.helpers import discovery
import homeas... |
import os
import unittest
def get_test_path():
return os.path.abspath(os.path.dirname(__file__))
class RoslibStackManifestTest(unittest.TestCase):
def _subtest_parse_stack_example1(self, m):
from roslib.manifestlib import _Manifest
self.assert_(isinstance(m, _Manifest))
self.assert... |
import logging
import re
from . import info
from itertools import cycle, repeat, chain
from .util import parse_duration
from .module_exceptions import StepperConfigurationError
from builtins import range
class LoadPlanBuilder(object):
def __init__(self):
self.generators = []
self.steps = []
... |
import hangups
from common import run_example
async def upload_image(client, args):
# Upload image to obtain image_id:
image_file = open(args.image, 'rb')
uploaded_image = await client.upload_image(
image_file, return_uploaded_image=True
)
# Send a chat message referencing the uploaded ... |
import logging
from pencompy.pencompy import Pencompy
import voluptuous as vol
from homeassistant.components.switch import PLATFORM_SCHEMA, SwitchEntity
from homeassistant.const import CONF_HOST, CONF_NAME, CONF_PORT
from homeassistant.exceptions import PlatformNotReady
import homeassistant.helpers.config_validation... |
from flask import Blueprint, request
from app.agents.models import Bot
from app.commons import build_response
bots = Blueprint('bots_blueprint', __name__,
url_prefix='/agents/<bot_name>')
@bots.route('/config', methods=['PUT'])
def set_config(bot_name):
"""
Read bot config
:param bot_n... |
from cms.utils import get_current_site
from cms.utils.page import get_page_from_path
from django.urls import reverse
from filer.models.imagemodels import Image
from rest_framework import serializers
class CMSPagesField(serializers.Field):
"""
A serializer field used to create the many-to-many relations for m... |
from homeassistant.components.sensor import DEVICE_CLASS_TEMPERATURE
from homeassistant.const import PERCENTAGE, TEMP_CELSIUS, VOLT
from homeassistant.helpers.entity import Entity
from homeassistant.helpers.icon import icon_for_battery_level, icon_for_signal_level
from .account import StarlineAccount, StarlineDevice
... |
import functools
from pychromecast.discovery import discover_chromecasts, stop_discovery
from homeassistant import config_entries
from homeassistant.components import zeroconf
from homeassistant.helpers import config_entry_flow
from .const import DOMAIN
from .helpers import ChromeCastZeroconf
async def _async_has... |
import unittest
from homeassistant.components.command_line import sensor as command_line
from homeassistant.helpers.template import Template
from tests.async_mock import patch
from tests.common import get_test_home_assistant
class TestCommandSensorSensor(unittest.TestCase):
"""Test the Command line sensor."""
... |
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 'delegated-instance-vagrant' == host.check_output('hostname -s')
def test_etc_molecule_directory(host):
... |
from tempfile import NamedTemporaryFile
from pygal import (
XY, Bar, Box, Config, DateLine, DateTimeLine, Dot, Funnel, Gauge,
Histogram, HorizontalBar, HorizontalLine, HorizontalStackedBar,
HorizontalStackedLine, Line, Pie, Pyramid, Radar, SolidGauge,
TimeDeltaLine, TimeLine, Treemap, formatters
)
fro... |
from pysmartthings import Attribute, Capability
from homeassistant.components.fan import (
ATTR_SPEED,
ATTR_SPEED_LIST,
DOMAIN as FAN_DOMAIN,
SPEED_HIGH,
SPEED_LOW,
SPEED_MEDIUM,
SPEED_OFF,
SUPPORT_SET_SPEED,
)
from homeassistant.components.smartthings.const import DOMAIN, SIGNAL_SMART... |
def test_battery_icon():
"""Test icon generator for battery sensor."""
from homeassistant.helpers.icon import icon_for_battery_level
assert icon_for_battery_level(None, True) == "mdi:battery-unknown"
assert icon_for_battery_level(None, False) == "mdi:battery-unknown"
assert icon_for_battery_level... |
from uuid import uuid4
from yandextank.plugins.InfluxUploader.decoder import Decoder
class TestDecoder(object):
def test_metrics_cast(self):
test_uuid = str(uuid4())
tank_tag = 'test_tank_tag'
comment = 'test comment'
raw_metrics = {
'metric1': -123,
'metri... |
from aiohomekit.model.characteristics import CharacteristicsTypes
from homeassistant.components.cover import (
ATTR_POSITION,
ATTR_TILT_POSITION,
SUPPORT_CLOSE,
SUPPORT_CLOSE_TILT,
SUPPORT_OPEN,
SUPPORT_OPEN_TILT,
SUPPORT_SET_POSITION,
SUPPORT_SET_TILT_POSITION,
SUPPORT_STOP,
C... |
import sys
import io
import os
import os.path
import subprocess
from distutils.core import Extension
from distutils.errors import CompileError, DistutilsOptionError
from distutils.command.build_ext import build_ext as _build_ext
from versioninfo import get_base_dir
try:
import Cython.Compiler.Version
CYTHON_I... |
import voluptuous as vol
from homeassistant.components.notify import (
ATTR_DATA,
ATTR_MESSAGE,
ATTR_TARGET,
PLATFORM_SCHEMA,
BaseNotificationService,
)
from .const import (
CONF_DEFAULT_CONVERSATIONS,
DOMAIN,
SERVICE_SEND_MESSAGE,
TARGETS_SCHEMA,
)
PLATFORM_SCHEMA = PLATFORM_SCH... |
from datetime import timedelta
import logging
from sleepyq import Sleepyq
import voluptuous as vol
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from homeassistant.helpers import discovery
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.entity import Entity
from homeass... |
from typing import Any
import voluptuous as vol
from homeassistant.const import CONF_PAYLOAD
from homeassistant.helpers import config_validation as cv
from .const import (
ATTR_PAYLOAD,
ATTR_QOS,
ATTR_RETAIN,
ATTR_TOPIC,
DEFAULT_QOS,
DEFAULT_RETAIN,
)
def valid_topic(value: Any) -> str:
... |
import numpy as np
from ._peak_finder import peak_finder
from .. import pick_types, pick_channels
from ..utils import logger, verbose, _pl
from ..filter import filter_data
from ..epochs import Epochs
@verbose
def find_eog_events(raw, event_id=998, l_freq=1, h_freq=10,
filter_length='10s', ch_nam... |
from datetime import datetime
import pytest
import pytz
from sqlalchemy import create_engine
from sqlalchemy.orm import scoped_session, sessionmaker
from homeassistant.components.recorder.models import (
Base,
Events,
RecorderRuns,
States,
process_timestamp,
process_timestamp_to_utc_isoformat... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import sys
from absl.flags import _helpers
from absl.flags.tests import module_bar
from absl.flags.tests import module_foo
from absl.testing import absltest
class FlagSuggestionTest(absltest.TestCase):
d... |
import logging
import typing
import uuid
import voluptuous as vol
from homeassistant.const import CONF_NAME
from homeassistant.core import HomeAssistant, callback
from homeassistant.exceptions import HomeAssistantError
from homeassistant.helpers import collection
import homeassistant.helpers.config_validation as cv
... |
import argparse
import logging
import os.path
import time
from collections import defaultdict
from inotify.adapters import Inotify
from inotify.constants import IN_MODIFY
from inotify.constants import IN_MOVED_TO
from paasta_tools import firewall
from paasta_tools.cli.utils import get_instance_config
from paasta_too... |
from copy import deepcopy
from tempfile import NamedTemporaryFile
from cerberus import Validator
from cerberus.tests import assert_normalized, assert_success
def test_normalized():
schema = {'amount': {'coerce': int}}
document = {'amount': '2'}
expected = {'amount': 2}
assert_normalized(document, ex... |
import tests
from pyVim import connect
from pyVmomi import vim
class ContainerViewTests(tests.VCRTestBase):
@tests.VCRTestBase.my_vcr.use_cassette('basic_container_view.yaml',
cassette_library_dir=tests.fixtures_path,
record_mode='once')
def test_basic_container_... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import tensorflow as tf
from tensorflow.python.ops import control_flow_ops
from datasets import dataset_factory
from deployment import model_deploy
from nets import nets_factory
from preprocessing import prep... |
from decimal import Decimal
import logging
from urllib.parse import urljoin
from django.core import checks
from django.core.exceptions import ImproperlyConfigured
from django.db import models, transaction
from django.db.models.aggregates import Sum
from django.urls import NoReverseMatch, reverse
from django.utils.fun... |
import sys
from collections import defaultdict
import iptc
from paasta_tools import iptables
from paasta_tools.utils import get_docker_client
def list_docker_nat_rules():
chain_name = "DOCKER"
table = iptc.Table(iptc.Table.NAT)
chain = iptc.Chain(table, chain_name)
for rule in chain.rules:
... |
import logging
import unittest
import os
import os.path
import numpy as np
from gensim.corpora import mmcorpus, Dictionary
from gensim.models.wrappers import ldamallet
from gensim import matutils
from gensim.utils import simple_preprocess
from gensim.models import ldamodel
from gensim.test import basetmtests
from ge... |
import errno
import math
import select as __select__
import sys
from numbers import Integral
from . import fileno
from .compat import detect_environment
__all__ = ('poll',)
_selectf = __select__.select
_selecterr = __select__.error
xpoll = getattr(__select__, 'poll', None)
epoll = getattr(__select__, 'epoll', None... |
import logging
import requests
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_PREVIOUS_TRACK,
SUP... |
import sys
from vine import Thenable, promise, maybe_promise
from kombu.exceptions import HttpError
from kombu.utils.compat import coro
from kombu.utils.encoding import bytes_to_str
from kombu.utils.functional import maybe_list, memoize
try: # pragma: no cover
from http.client import responses
except ImportErr... |
from django.db.models.signals import post_save, pre_save
from django.dispatch import receiver
from django.urls import reverse
from weblate.trans.models import Component, Project
from weblate.utils.decorators import disable_for_loaddata
from weblate.utils.site import get_site_url
SUPPORTED_VCS = {
"git",
"ger... |
import asyncio
from os import path
import httpx
import respx
from homeassistant import config as hass_config
import homeassistant.components.sensor as sensor
from homeassistant.const import (
ATTR_UNIT_OF_MEASUREMENT,
CONTENT_TYPE_JSON,
DATA_MEGABYTES,
SERVICE_RELOAD,
STATE_UNKNOWN,
)
from homeas... |
from functools import partial
import logging
from urllib.request import URLError
from panasonic_viera import TV_TYPE_ENCRYPTED, RemoteControl, SOAPError
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.const import CONF_HOST, CONF_NAME, CONF_PIN, CONF_PORT
from .const import ( #... |
import unittest
from category_encoders import CountEncoder
import pandas as pd
## Need to make sure we have CountEncoder available from the category_encoders library
class TestCategoryEncoders(unittest.TestCase):
def test_count_encoder(self):
encoder = CountEncoder(cols="data")
data = pd.DataFr... |
import datetime
import json
import logging
from absl import flags
from perfkitbenchmarker import dpb_service
from perfkitbenchmarker import errors
from perfkitbenchmarker.linux_packages import aws_credentials
from perfkitbenchmarker.providers import gcp
from perfkitbenchmarker.providers.gcp import gcs
from perfkitben... |
from stash.tests.stashtest import StashTestCase
class TermemuTests(StashTestCase):
setup_commands = ['BIN_PATH=$STASH_ROOT/tests/system/data:$BIN_PATH']
def test_201(self):
self.stash('test_201.py')
cmp_str = """[stash]$ The first line
[stash]$ rown fox jumps over the lazy dog"""
as... |
from copy import deepcopy
from aiounifi.controller import MESSAGE_CLIENT_REMOVED, MESSAGE_EVENT
from aiounifi.websocket import SIGNAL_DATA
from homeassistant import config_entries
from homeassistant.components.device_tracker import DOMAIN as TRACKER_DOMAIN
from homeassistant.components.switch import DOMAIN as SWITCH... |
import pandas as pd
class TimeChopper(object):
"""
TimeChopper splits incoming dataframes by index. Chunks are cached and
chunks for same key from different DFs are joined. Then chunks are passed
further as (<timestamp>, <dataframe>) tuples.
"""
def __init__(self, source, cache_size):
... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import argparse
import json
import logging
import time
import py4j
from pyspark import sql
def parse_args():
"""Parse argv."""
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argumen... |
try:
import json
except ImportError:
import simplejson as json
import urllib2
import diamond.collector
class SidekiqWebCollector(diamond.collector.Collector):
def get_default_config_help(self):
config_help = super(SidekiqWebCollector,
self).get_default_config_help()
... |
from datetime import timedelta
import logging
import threading
from jsonpath import jsonpath
import verisure
import voluptuous as vol
from homeassistant.const import (
CONF_PASSWORD,
CONF_SCAN_INTERVAL,
CONF_USERNAME,
EVENT_HOMEASSISTANT_STOP,
HTTP_SERVICE_UNAVAILABLE,
)
from homeassistant.helper... |
from flask import Flask, jsonify
from flasgger import Swagger
app = Flask(__name__)
app.config['SWAGGER'] = {
'title': 'Colors API',
'uiversion': 2
}
swag = Swagger(app, template_file='colors_template.json')
@app.route('/colors/<palette>/')
def colors(palette):
"""
Example using a dictionary as spe... |
import re
import subprocess
import diamond.collector
import diamond.convertor
from diamond.collector import str_to_bool
LINE_PATTERN = re.compile(
'^(?P<source>\S+).*\s+(?P<offset>[+-]\d+)(?P<unit>\w+)\s+')
IP_PATTERN = re.compile('^\d+\.\d+\.\d+\.\d+$')
def cleanup_source(source):
if IP_PATTERN.search(sourc... |
import pickle
import pytest
dask = pytest.importorskip("dask") # isort:skip
distributed = pytest.importorskip("distributed") # isort:skip
from dask.distributed import Client, Lock
from distributed.utils_test import cluster, gen_cluster
from distributed.utils_test import loop
from distributed.client import futures... |
import glob
import os
from chainer.dataset import download
from chainercv.chainer_experimental.datasets.sliceable import GetterDataset
from chainercv.utils import read_image
class CityscapesTestImageDataset(GetterDataset):
"""Image dataset for test split of `Cityscapes dataset`_.
.. _`Cityscapes dataset`... |
import io
import mock
from pytest import raises
from paasta_tools.cli.fsm import autosuggest
class TestGetSmartstackProxyPortFromFile:
@mock.patch("paasta_tools.cli.fsm.autosuggest.read_etc_services", autospec=True)
def test_multiple_stanzas_per_file(self, mock_read_etc_services):
with mock.patch("... |
__docformat__ = "restructuredtext en"
from cgi import escape
from six.moves import range
from logilab.common.ureports import BaseWriter
class HTMLWriter(BaseWriter):
"""format layouts as HTML"""
def __init__(self, snippet=None):
super(HTMLWriter, self).__init__()
self.snippet = snippet
... |
import copy
import logging
import multiprocessing
import sys
import urllib3
from http import client as http_client
from paasta_tools.paastaapi.exceptions import ApiValueError
JSON_SCHEMA_VALIDATION_KEYWORDS = {
'multipleOf', 'maximum', 'exclusiveMaximum',
'minimum', 'exclusiveMinimum', 'maxLength',
'min... |
import asyncio
from homeassistant.config_entries import ConfigEntry
from homeassistant.exceptions import ConfigEntryNotReady
from homeassistant.helpers.typing import HomeAssistantType
from .const import DOMAIN, SUPPORTED_PLATFORMS
from .onewirehub import CannotConnect, OneWireHub
async def async_setup(hass, config... |
from bravia_tv.braviarc import NoIPControl
from homeassistant import data_entry_flow
from homeassistant.components.braviatv.const import CONF_IGNORED_SOURCES, DOMAIN
from homeassistant.config_entries import SOURCE_IMPORT, SOURCE_USER
from homeassistant.const import CONF_HOST, CONF_MAC, CONF_PIN
from tests.async_mock... |
import json
from django.conf import settings
from weblate.machinery.base import (
MachineTranslation,
MachineTranslationError,
MissingConfiguration,
)
GOOGLE_API_ROOT = "https://translation.googleapis.com/language/translate/v2/"
class GoogleBaseTranslation(MachineTranslation):
# Map codes used by ... |
import argparse
import json
from .const import CORE_PROJECT_ID, FRONTEND_DIR, FRONTEND_PROJECT_ID, INTEGRATIONS_DIR
from .error import ExitApp
from .lokalise import get_api
from .util import get_base_arg_parser
def get_arguments() -> argparse.Namespace:
"""Get parsed passed in arguments."""
parser = get_bas... |
from __future__ import division
import numpy as np
import unittest
import chainer
from chainer.datasets import TupleDataset
from chainer.iterators import SerialIterator
from chainer import testing
from chainercv.extensions import SemanticSegmentationEvaluator
from chainercv.utils.testing import attr
from chainermn... |
from datetime import datetime
from functools import partial
import voluptuous as vol
from homeassistant.const import CONF_AT, CONF_PLATFORM
from homeassistant.core import HassJob, callback
from homeassistant.helpers import config_validation as cv
from homeassistant.helpers.event import (
async_track_point_in_tim... |
import diamond.collector
import diamond.convertor
import os
import subprocess
class UserScriptsCollector(diamond.collector.Collector):
def get_default_config_help(self):
config_help = super(UserScriptsCollector,
self).get_default_config_help()
config_help.update({
... |
import warnings
from urllib.parse import parse_qsl, urlparse
import gmusicapi
from gmusicapi.clients.shared import _Base
from gmusicapi.exceptions import GmusicapiWarning
from gmusicapi.protocol import webclient
from gmusicapi.utils import utils
import gmusicapi.session
class Webclient(_Base):
"""Allows library... |
from homeassistant.components.ozw.const import DOMAIN
from homeassistant.components.sensor import (
DEVICE_CLASS_HUMIDITY,
DEVICE_CLASS_POWER,
DEVICE_CLASS_PRESSURE,
DOMAIN as SENSOR_DOMAIN,
)
from homeassistant.const import ATTR_DEVICE_CLASS
from .common import setup_ozw
async def test_sensor(hass,... |
import os
from weblate.fonts.models import FONT_STORAGE, Font
from weblate.trans.tests.test_views import FixtureTestCase
FONT = os.path.join(
os.path.dirname(os.path.dirname(__file__)),
"static",
"font-droid",
"DroidSansFallback.ttf",
)
class FontTestCase(FixtureTestCase):
def add_font(self):
... |
import numpy as np
from scipy.linalg import eigh
from ..filter import filter_data
from ..cov import _regularized_covariance
from . import TransformerMixin, BaseEstimator
from ..time_frequency import psd_array_welch
from ..utils import _time_mask, fill_doc, _validate_type, _check_option
from ..io.pick import _get_chann... |
from asyncio import Event
import logging
from threading import Thread
from typing import Optional
import debugpy
import voluptuous as vol
from homeassistant.const import CONF_HOST, CONF_PORT
from homeassistant.core import HomeAssistant, ServiceCall
import homeassistant.helpers.config_validation as cv
from homeassist... |
from weblate.checks.render import MaxSizeCheck
from weblate.fonts.models import FontGroup, FontOverride
from weblate.fonts.tests.utils import FontTestCase
from weblate.utils.state import STATE_TRANSLATED
class MaxSizeCheckTest(FontTestCase):
def setUp(self):
super().setUp()
self.check = MaxSizeCh... |
import os
import sys
import time
import tempfile
import shutil
from flexx.util.testing import run_tests_if_main, raises
from flexx.util.logging import capture_log
from flexx import app
from flexx.app._modules import JSModule
tempdirname = os.path.join(tempfile.gettempdir(), 'flexx_module_test')
files = {}
files['... |
import os.path as op
import numpy as np
from numpy.testing import (assert_equal, assert_array_almost_equal,
assert_array_equal, assert_allclose)
import mne
from mne.datasets import testing
from mne.minimum_norm.resolution_matrix import (make_inverse_resolution_matrix,
... |
import logging
from hole.exceptions import HoleError
from homeassistant.components import pi_hole, switch
from homeassistant.components.pi_hole.const import (
CONF_LOCATION,
DEFAULT_LOCATION,
DEFAULT_NAME,
DEFAULT_SSL,
DEFAULT_VERIFY_SSL,
SERVICE_DISABLE,
SERVICE_DISABLE_ATTR_DURATION,
)
... |
from collections import namedtuple
import os
import time
from unittest.mock import MagicMock
from proboscis.asserts import (
assert_raises, assert_true, assert_false, assert_equal,
assert_is_not, Check
)
from proboscis import test
import gmusicapi.session
from gmusicapi.clients import Mobileclient, Musicmana... |
from logilab.common.testlib import TestCase, unittest_main
from logilab.common.tasksqueue import *
class TaskTC(TestCase):
def test_eq(self):
self.assertFalse(Task('t1') == Task('t2'))
self.assertTrue(Task('t1') == Task('t1'))
def test_cmp(self):
self.assertTrue(Task('t1', LOW) < Ta... |
from datetime import timedelta
from adguardhome import AdGuardHomeConnectionError
from homeassistant.components.adguard import AdGuardHomeDeviceEntity
from homeassistant.components.adguard.const import (
DATA_ADGUARD_CLIENT,
DATA_ADGUARD_VERION,
DOMAIN,
)
from homeassistant.config_entries import ConfigEn... |
from __future__ import print_function, absolute_import
from .factories import StyleFactory
from .styles import Style, ANSIStyle, HTMLStyle, ColorNotFound
ansicolors = StyleFactory(ANSIStyle)
htmlcolors = StyleFactory(HTMLStyle)
def load_ipython_extension(ipython): # pragma: no cover
try:
from ._ipytho... |
import logging
from typing import Callable, List, Optional
from directv import DIRECTV
from homeassistant.components.media_player import (
DEVICE_CLASS_RECEIVER,
MediaPlayerEntity,
)
from homeassistant.components.media_player.const import (
MEDIA_TYPE_CHANNEL,
MEDIA_TYPE_MOVIE,
MEDIA_TYPE_MUSIC,
... |
from datetime import timedelta
import logging
from homeassistant.components.binary_sensor import (
DEVICE_CLASS_SMOKE,
BinarySensorEntity,
)
from homeassistant.const import ATTR_BATTERY_LEVEL, STATE_OFF, STATE_ON
from . import DOMAIN as TAHOMA_DOMAIN, TahomaDevice
_LOGGER = logging.getLogger(__name__)
SCAN... |
import logging
import unittest
from collections import namedtuple
from gensim.topic_coherence import direct_confirmation_measure
from gensim.topic_coherence import text_analysis
class TestDirectConfirmationMeasure(unittest.TestCase):
def setUp(self):
# Set up toy example for better understanding and tes... |
import pytest
from jinja2 import DictLoader
from jinja2 import Environment
from jinja2 import TemplateRuntimeError
LAYOUTTEMPLATE = """\
|{% block block1 %}block 1 from layout{% endblock %}
|{% block block2 %}block 2 from layout{% endblock %}
|{% block block3 %}
{% block block4 %}nested block 4 from layout{% endbloc... |
import asyncio
import async_timeout
from sharkiqpy import (
AylaApi,
SharkIqAuthError,
SharkIqAuthExpiringError,
SharkIqNotAuthedError,
get_ayla_api,
)
from homeassistant import exceptions
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from .const import _LOGGER, API_TIMEOUT, COMPO... |
from __future__ import print_function
import json
import tempfile
from perfkitbenchmarker import resource
from perfkitbenchmarker import vm_util
from perfkitbenchmarker.providers.aws import util
class LogGroup(resource.BaseResource):
"""Class representing a CloudWatch log group."""
def __init__(self, region, na... |
import datetime
import logging
import math
import voluptuous as vol
from homeassistant.components import history
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import (
CONF_ENTITY_ID,
CONF_NAME,
CONF_STATE,
CONF_TYPE,
EVENT_HOMEASSISTANT_START,
PERCENTAG... |
from pyowm import OWM
from pyowm.exceptions.api_call_error import APICallError
from pyowm.exceptions.api_response_error import UnauthorizedError
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.const import (
CONF_API_KEY,
CONF_LATITUDE,
CONF_LONGITUDE,
CONF_MODE,
... |
import logging
from typing import Any, Dict, List
from surepy import (
SurePetcare,
SurePetcareAuthenticationError,
SurePetcareError,
SureProductID,
)
import voluptuous as vol
from homeassistant.const import (
CONF_ID,
CONF_PASSWORD,
CONF_SCAN_INTERVAL,
CONF_TYPE,
CONF_USERNAME,
)... |
import asyncio
from agent import AgentError
from agent.a import Agent
from homeassistant.exceptions import ConfigEntryNotReady
from homeassistant.helpers import device_registry as dr
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from .const import CONNECTION, DOMAIN as AGENT_DOMAIN, SERVE... |
import numpy as np
import tensorflow as tf
from tensornetwork.backends.tensorflow import tensordot2
import pytest
_MAXDIM = 5
class TensordotTest(tf.compat.v1.test.TestCase):
def test_invalid_shape(self):
a = [[1, 2], [3, 4]]
b = [[1, 2], [3, 4], [5, 6]]
a_axes = [1]
b_axes = [0]
# Invalid st... |
import itertools
from typing import cast, overload, Iterable, Iterator, List, Mapping, Optional, Union
import attr
from PyQt5.QtCore import Qt, QEvent
from PyQt5.QtGui import QKeySequence, QKeyEvent
from qutebrowser.utils import utils
# Map Qt::Key values to their Qt::KeyboardModifier value.
_MODIFIER_MAP = {
... |
from flexx import flx
class Example(flx.HFix):
def init(self):
with flx.VBox():
self.b1 = flx.Button(text='apple')
self.b2 = flx.Button(text='banana')
self.b3 = flx.Button(text='pear')
self.buttonlabel= flx.Label(text='...')
with flx.VBox():
... |
from marshmallow import fields, validates_schema, post_load
from marshmallow.exceptions import ValidationError
from lemur.common import utils, validators
from lemur.authorities.schemas import AuthorityNestedOutputSchema
from lemur.certificates.schemas import CertificateNestedOutputSchema
from lemur.common.schema impo... |
import importlib.util
import os
import sys
import weakref
import zipimport
from collections import abc
from hashlib import sha1
from importlib import import_module
from types import ModuleType
from .exceptions import TemplateNotFound
from .utils import internalcode
from .utils import open_if_exists
def split_templa... |
import asyncio
from contextlib import contextmanager
import json as _json
import re
from unittest import mock
from urllib.parse import parse_qs
from aiohttp import ClientSession
from aiohttp.client_exceptions import ClientError, ClientResponseError
from aiohttp.streams import StreamReader
from yarl import URL
from h... |
from cryptography import x509
from cryptography.hazmat.backends import default_backend
from marshmallow.exceptions import ValidationError
from cryptography.hazmat.primitives.asymmetric import rsa, ec
from lemur.common.utils import get_key_type_from_ec_curve
def get_sans_from_csr(data):
"""
Fetches SubjectAlt... |
from stash.tests.stashtest import StashTestCase
class CompleterTests(StashTestCase):
def setUp(self):
StashTestCase.setUp(self)
self.complete = self.stash.completer.complete
def test_completion_01(self):
newline, possibilities = self.complete('pw')
assert newline == 'pwd.py '... |
version_info = (5, 3, 2, "alpha", 0)
def _make_version(major, minor, micro, releaselevel, serial):
"""Create a readable version string from version_info tuple components."""
assert releaselevel in ['alpha', 'beta', 'candidate', 'final']
version = "%d.%d" % (major, minor)
if micro:
version += ... |
import base64
import functools
import hashlib
import logging
import os
import random
import re
import string
import time
import urllib
import flask
from M2Crypto import RSA
import requests
from docker_registry.core import compat
json = compat.json
from . import storage
from .lib import config
cfg = config.load()
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.