text stringlengths 213 32.3k |
|---|
from homeassistant.components.light import (
ATTR_BRIGHTNESS,
SUPPORT_BRIGHTNESS,
LightEntity,
)
from homeassistant.const import CONF_NAME
from . import LIGHTWAVE_LINK
MAX_BRIGHTNESS = 255
async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
"""Find and return Ligh... |
__author__ = 'p3rf@google.com'
from absl import flags
flags.DEFINE_string('database', None,
'The database within which the command or query executes.')
flags.DEFINE_string('query_timeout', '600', 'Query timeout in seconds.')
flags.DEFINE_string(
'athena_query_output_bucket', None,
'Specif... |
import logging
import time
import psutil
from ...common.util import expand_to_seconds
from ...common.interfaces import AbstractPlugin
from netort.process import execute
class Plugin(AbstractPlugin):
'''Plugin to check system resources'''
SECTION = "rcheck"
@staticmethod
def get_key():
retu... |
from datetime import timedelta
import logging
from horimote import Client, keys
from horimote.exceptions import AuthenticationError
import voluptuous as vol
from homeassistant import util
from homeassistant.components.media_player import PLATFORM_SCHEMA, MediaPlayerEntity
from homeassistant.components.media_player.c... |
import diamond.collector
import os
class ConnTrackCollector(diamond.collector.Collector):
"""
Collector of number of conntrack connections
"""
def get_default_config_help(self):
"""
Return help text for collector configuration
"""
config_help = super(ConnTrackCollecto... |
import voluptuous as vol
from homeassistant.core import HomeAssistant
from homeassistant.helpers.discovery import async_load_platform
from .const import DOMAIN
CONFIG_SCHEMA = vol.Schema(
{vol.Optional(DOMAIN): {}},
extra=vol.ALLOW_EXTRA,
)
async def async_setup(hass: HomeAssistant, config: dict):
"""... |
import json
from django.db import migrations
def fix_enforced_checks(apps, schema_editor):
Component = apps.get_model("trans", "Component")
db_alias = schema_editor.connection.alias
for component in Component.objects.using(db_alias).filter(
enforced_checks__contains="'"
):
component.... |
import pandas as pd
import pytest
import pytz
from qstrader.asset.universe.dynamic import DynamicUniverse
@pytest.mark.parametrize(
'asset_dates,dt,expected',
[
(
{
'EQ:SPY': pd.Timestamp('1993-01-01 14:30:00', tz=pytz.utc),
'EQ:AGG': pd.Timestamp('2003-01... |
from homeassistant.components import mysensors
from homeassistant.components.light import (
ATTR_BRIGHTNESS,
ATTR_HS_COLOR,
ATTR_WHITE_VALUE,
DOMAIN,
SUPPORT_BRIGHTNESS,
SUPPORT_COLOR,
SUPPORT_WHITE_VALUE,
LightEntity,
)
from homeassistant.const import STATE_OFF, STATE_ON
from homeassis... |
import json
import base64
import webruntime
from .. import config, set_log_level
from ._app import App, manager
from ._component2 import PyComponent, JsComponent
from ._server import current_server
from ._assetstore import assets
from ._clientcore import serializer
from . import logger
reprs = json.dumps
## Main ... |
import pytest
from homeassistant.components.huawei_lte import device_tracker
@pytest.mark.parametrize(
("value", "expected"),
(
("HTTP", "http"),
("ID", "id"),
("IPAddress", "ip_address"),
("HTTPResponse", "http_response"),
("foo_bar", "foo_bar"),
),
)
def test_be... |
import contextlib
import datetime
import inspect
import warnings
from distutils.version import LooseVersion
from functools import partial
import numpy as np
import pandas as pd
from . import dask_array_compat, dask_array_ops, dtypes, npcompat, nputils
from .nputils import nanfirst, nanlast
from .pycompat import (
... |
from __future__ import unicode_literals
from rules.BaseTrick import strnumjoin
def SNrule(strs, nums):
for s in strs:
for n in nums:
for _ in strnumjoin(s, n):
yield _
|
import discord
import re
from datetime import timezone
from typing import Union, Set, Literal
from redbot.core import checks, Config, modlog, commands
from redbot.core.bot import Red
from redbot.core.i18n import Translator, cog_i18n, set_contextual_locales_from_guild
from redbot.core.utils import AsyncIter
from redbo... |
import abc
import os
from molecule import status
Status = status.get_status()
class Base(object):
__metaclass__ = abc.ABCMeta
def __init__(self, config):
"""
Base initializer for all :ref:`Driver` classes.
:param config: An instance of a Molecule config.
:returns: None
... |
import os
from babelfish import Language
import pytest
from vcr import VCR
from subliminal.providers.podnapisi import PodnapisiProvider, PodnapisiSubtitle
vcr = VCR(path_transformer=lambda path: path + '.yaml',
record_mode=os.environ.get('VCR_RECORD_MODE', 'once'),
cassette_library_dir=os.path.... |
from datetime import timedelta
import logging
from fastdotcom import fast_com
import voluptuous as vol
from homeassistant.const import CONF_SCAN_INTERVAL
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.discovery import async_load_platform
from homeassistant.helpers.dispatcher import d... |
import logging
import os
import gntp.errors
import gntp.notifier
import voluptuous as vol
from homeassistant.components.notify import (
ATTR_TITLE,
ATTR_TITLE_DEFAULT,
PLATFORM_SCHEMA,
BaseNotificationService,
)
from homeassistant.const import CONF_PASSWORD, CONF_PORT
import homeassistant.helpers.con... |
from rest_framework import serializers
from rest_framework.fields import empty
from shop.models.cart import CartModel
from shop.rest.money import MoneyField
from shop.serializers.bases import AvailabilitySerializer
class AddToCartSerializer(serializers.Serializer):
"""
By default, this serializer is used by ... |
import importlib
from homeassistant.const import CONF_PLATFORM
def _get_trigger_platform(config):
return importlib.import_module(f"..triggers.{config[CONF_PLATFORM]}", __name__)
async def async_validate_trigger_config(hass, config):
"""Validate config."""
platform = _get_trigger_platform(config)
i... |
import re
from sphinx import addnodes
from sphinx.domains.std import Cmdoption
# RE for option descriptions without a '--' prefix
simple_option_desc_re = re.compile(r"([-_a-zA-Z0-9]+)(\s*.*?)(?=,\s+(?:/|-|--)|$)")
def setup(app):
app.add_crossref_type(
directivename="setting", rolename="setting", index... |
import re
from .utils import Str, classify, get_regexp_width, Py36, Serialize, suppress
from .exceptions import UnexpectedCharacters, LexError, UnexpectedToken
###{standalone
from copy import copy
class Pattern(Serialize):
raw = None
def __init__(self, value, flags=(), raw=None):
self.value = valu... |
class JuiceNetApi:
"""Represent a connection to JuiceNet."""
def __init__(self, api):
"""Create an object from the provided API instance."""
self.api = api
self._devices = []
async def setup(self):
"""JuiceNet device setup.""" # noqa: D403
self._devices = await se... |
from typing import (
TYPE_CHECKING, Any, Callable, Dict, Iterator, Optional, Set, Tuple, Union)
from PyQt5.QtCore import QRect, QEventLoop
from PyQt5.QtWidgets import QApplication
from PyQt5.QtWebEngineWidgets import QWebEngineSettings
from qutebrowser.utils import log, javascript, urlutils, usertypes, utils
fro... |
import pywink
import homeassistant.components.alarm_control_panel as alarm
from homeassistant.components.alarm_control_panel.const import (
SUPPORT_ALARM_ARM_AWAY,
SUPPORT_ALARM_ARM_HOME,
)
from homeassistant.const import (
STATE_ALARM_ARMED_AWAY,
STATE_ALARM_ARMED_HOME,
STATE_ALARM_DISARMED,
)
f... |
from django.test import TestCase
from weblate.auth.models import AutoGroup, Group, User
class AutoGroupTest(TestCase):
@staticmethod
def create_user():
return User.objects.create_user("test1", "noreply1@weblate.org", "pass")
def test_default(self):
user = self.create_user()
self... |
from test import CollectorTestCase
from test import get_collector_config
from mock import patch, Mock
from postgres import PostgresqlCollector
class TestPostgresqlCollector(CollectorTestCase):
def setUp(self, allowed_names=None):
if not allowed_names:
allowed_names = []
config = get... |
import os
from flexx import flx
BASE_DIR = os.getcwd()
with open(BASE_DIR + '/static/js/data.json') as f:
geojson = f.read()
ol_cdn = 'https://cdnjs.cloudflare.com/ajax/libs/openlayers/4.6.5/'
flx.assets.associate_asset(__name__, ol_cdn + 'ol.css')
flx.assets.associate_asset(__name__, ol_cdn + 'ol.js')
class ... |
from datetime import timedelta
from typing import Optional
from bond_api import Action, DeviceType, Direction
from homeassistant import core
from homeassistant.components import fan
from homeassistant.components.fan import (
ATTR_DIRECTION,
ATTR_SPEED,
ATTR_SPEED_LIST,
DIRECTION_FORWARD,
DIRECTIO... |
import argparse
import logging
import os
import signal
import socket
import socketserver
import sys
import syslogmp
from paasta_tools.firewall import services_running_here
from paasta_tools.utils import _log
from paasta_tools.utils import configure_log
from paasta_tools.utils import load_system_paasta_config
DEFAUL... |
import numpy as np
import chainer
from chainercv.links.model.faster_rcnn import FasterRCNN
from chainercv.utils import generate_random_bbox
def _random_array(xp, shape):
return xp.array(
np.random.uniform(-1, 1, size=shape), dtype=np.float32)
class DummyExtractor(chainer.Link):
def __init__(self... |
import logging
from typing import Dict, Iterable, Optional
from sharkiqpy import OperatingModes, PowerModes, Properties, SharkIqVacuum
from homeassistant.components.vacuum import (
STATE_CLEANING,
STATE_DOCKED,
STATE_IDLE,
STATE_PAUSED,
STATE_RETURNING,
SUPPORT_BATTERY,
SUPPORT_FAN_SPEED,... |
import os
from collections import defaultdict
from copy import copy
from urllib.parse import urljoin
import blinker
import natsort
from nikola import utils, hierarchy_utils
from nikola.nikola import _enclosure
from nikola.plugin_categories import Task
class RenderTaxonomies(Task):
"""Render taxonomy pages and ... |
__docformat__ = "restructuredtext en"
import sys
import re
import os.path as osp
from warnings import warn
from unicodedata import normalize as _uninormalize
try:
from os import linesep
except ImportError:
linesep = '\n' # gae
from logilab.common.deprecation import deprecated
MANUAL_UNICODE_MAP = {
u'\x... |
import os.path as op
import numpy as np
from numpy.testing import assert_array_equal
from mne.io import read_info
from mne.io.constants import FIFF
base_dir = op.join(op.dirname(__file__), 'data')
raw_fname = op.join(base_dir, 'test_chpi_raw_sss.fif')
def test_maxfilter_io():
"""Test maxfilter io."""
info... |
from __future__ import print_function
import os
import sys
import rospkg
import rosunit
NAME = 'check_test_ran.py'
def usage():
print("""Usage:
\t%s test-file.xml
or
\t%s --rostest pkg-name test-file.xml
""" % (NAME, NAME), file=sys.stderr)
print(sys.argv)
sys.exit(getattr(os, 'EX_USAGE', 1))
def c... |
import logging
import unittest
import os
import zlib
from gensim.corpora.hashdictionary import HashDictionary
from gensim.test.utils import get_tmpfile, common_texts
class TestHashDictionary(unittest.TestCase):
def setUp(self):
self.texts = common_texts
def testDocFreqOneDoc(self):
texts = ... |
from homeassistant.helpers import intent
import homeassistant.helpers.config_validation as cv
from .const import CONF_BOT, DOMAIN, INTENT_HELP
class HelpIntent(intent.IntentHandler):
"""Handle Help intents."""
intent_type = INTENT_HELP
slot_schema = {"conv_id": cv.string}
def __init__(self, hass):... |
try:
import json
except ImportError:
import simplejson as json
import glob
import os
import subprocess
import diamond.collector
def flatten_dictionary(input, sep='.', prefix=None):
"""Produces iterator of pairs where the first value is
the joined key names and the second value is the value
asso... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import logging
from absl import flags
from perfkitbenchmarker import linux_virtual_machine as linux_vm
from perfkitbenchmarker import providers
from perfkitbenchmarker import virtual_machine
from perfkitbench... |
import pyzerproc
from homeassistant import config_entries, setup
from homeassistant.components.zerproc.config_flow import DOMAIN
from tests.async_mock import patch
async def test_flow_success(hass):
"""Test we get the form."""
await setup.async_setup_component(hass, "persistent_notification", {})
resul... |
import uuid
from lxml.html import builder, tostring
from pygal.util import template
class HTML(object):
"""Lower case adapter of lxml builder"""
def __getattribute__(self, attr):
"""Get the uppercase builder attribute"""
return getattr(builder, attr.upper())
class Table(object):
"""T... |
from __future__ import print_function
import tests
from pyVim import connect
class ManagedObjectTests(tests.VCRTestBase):
@tests.VCRTestBase.my_vcr.use_cassette('root_folder_parent.yaml',
cassette_library_dir=tests.fixtures_path,
record_mode='once')
def test_roo... |
from homeassistant.config_entries import ConfigEntry
from homeassistant.helpers.typing import HomeAssistantType
from .const import DATA_SDM
from .sensor_legacy import async_setup_legacy_entry
from .sensor_sdm import async_setup_sdm_entry
async def async_setup_entry(
hass: HomeAssistantType, entry: ConfigEntry, ... |
from datetime import timedelta
from logging import getLogger
from os import remove
from os.path import exists
import time
import unittest
from unittest import mock
from homeassistant.components import feedreader
from homeassistant.components.feedreader import (
CONF_MAX_ENTRIES,
CONF_URLS,
DEFAULT_MAX_ENT... |
from asyncio import run_coroutine_threadsafe
import pyatmo
from homeassistant import config_entries, core
from homeassistant.helpers import config_entry_oauth2_flow
class ConfigEntryNetatmoAuth(pyatmo.auth.NetatmoOAuth2):
"""Provide Netatmo authentication tied to an OAuth2 based config entry."""
def __ini... |
from __future__ import print_function
from __future__ import unicode_literals
import gzip
import os.path as P
import subprocess
import unittest
import mock
import smart_open.hdfs
CURR_DIR = P.dirname(P.abspath(__file__))
#
# We want our mocks to emulate the real implementation as close as possible,
# so we use ... |
import logging
import unittest
import numpy as np
from gensim.corpora.mmcorpus import MmCorpus
from gensim.models import tfidfmodel
from gensim.test.utils import datapath, get_tmpfile, common_dictionary, common_corpus
from gensim.corpora import Dictionary
texts = [
['complier', 'system', 'computer'],
['eu... |
import logging
from homeassistant.const import (
ATTR_ATTRIBUTION,
ATTR_LATITUDE,
ATTR_LONGITUDE,
CURRENCY_EURO,
)
from homeassistant.helpers.update_coordinator import (
CoordinatorEntity,
DataUpdateCoordinator,
UpdateFailed,
)
from .const import DOMAIN, NAME
_LOGGER = logging.getLogger(... |
import numpy as np
import pytest
from keras import backend as K
from matchzoo import layers
from matchzoo.contrib.layers import SpatialGRU
from matchzoo.contrib.layers import MatchingTensorLayer
def test_matching_layers():
s1_value = np.array([[[1, 2], [2, 3], [3, 4]],
[[0.1, 0.2], [0.2... |
from trashcli.trash import TrashDirs
from mock import Mock, call
class TestListTrashinfo:
def test_howto_list_trashdirs(self):
out = Mock()
environ = {'HOME':'/home/user'}
trashdirs = TrashDirs(
environ = environ,
getuid = lambda:123,
list_vo... |
import unittest
import pandas as pd
from pgmpy.models import BayesianModel
from pgmpy.estimators import BicScore
class TestBicScore(unittest.TestCase):
def setUp(self):
self.d1 = pd.DataFrame(
data={"A": [0, 0, 1], "B": [0, 1, 0], "C": [1, 1, 0], "D": ["X", "Y", "Z"]}
)
self... |
from absl import flags
from csapi import API
from six.moves import urllib
try:
from requests.packages import urllib3
urllib3.disable_warnings()
except ImportError:
pass
FLAGS = flags.FLAGS
class CsClient(object):
def __init__(self, url, api_key, secret):
self._cs = API(api_key,
sec... |
import logging
import time
from collections import defaultdict
from threading import RLock
from concurrent.futures import FIRST_COMPLETED
from ._workers_pool import LazySingletonTasksCoordinator
from .async_utils import AsyncRequestType, AsyncRequest
from ..decorators import mongo_retry
from ..exceptions import Asyn... |
from datetime import datetime, timedelta
from typing import Tuple, List
from collections import namedtuple
Interval = Tuple[timedelta, int]
AntiSpamInterval = namedtuple("AntiSpamInterval", ["period", "frequency"])
class AntiSpam:
"""
Custom class which is more flexible than using discord.py's
`commands... |
from __future__ import unicode_literals, division
import sys
import os
import inspect
import codecs
import io
import argparse
import re
import warnings
import random
import tempfile
from multiprocessing import Pool, cpu_count
# hack for python2/3 compatibility
from io import open
argparse.open = open
class BPE(obje... |
from homeassistant.const import (
CONF_NAME,
CONF_TEMPERATURE_UNIT,
POWER_WATT,
TIME_HOURS,
TIME_MINUTES,
TIME_SECONDS,
VOLT,
)
from homeassistant.helpers.entity import Entity
from . import (
CONF_COUNTED_QUANTITY,
CONF_COUNTED_QUANTITY_PER_PULSE,
CONF_MONITOR_SERIAL_NUMBER,
... |
import pytest
import homeassistant.components.automation as automation
from homeassistant.components.tag import async_scan_tag
from homeassistant.components.tag.const import DOMAIN, TAG_ID
from homeassistant.setup import async_setup_component
from tests.common import async_mock_service
@pytest.fixture
def tag_setu... |
from itertools import count
from .imports import symbol_by_name
__all__ = (
'FairCycle', 'priority_cycle', 'round_robin_cycle', 'sorted_cycle',
)
CYCLE_ALIASES = {
'priority': 'kombu.utils.scheduling:priority_cycle',
'round_robin': 'kombu.utils.scheduling:round_robin_cycle',
'sorted': 'kombu.utils.s... |
from datetime import timedelta
import logging
from aiohttp.hdrs import AUTHORIZATION
import requests
import voluptuous as vol
from homeassistant.const import (
CONF_API_KEY,
HTTP_METHOD_NOT_ALLOWED,
HTTP_OK,
HTTP_UNAUTHORIZED,
)
from homeassistant.helpers import discovery
import homeassistant.helpers... |
import pytest
import sh
from molecule import config
from molecule.provisioner import ansible_playbook
@pytest.fixture
def _instance(config_instance):
return ansible_playbook.AnsiblePlaybook('playbook', config_instance)
@pytest.fixture
def _inventory_directory(_instance):
return _instance._config.provision... |
from typing import TYPE_CHECKING
import attr
if TYPE_CHECKING:
# pylint: disable=unused-import
from homeassistant.helpers import ( # noqa: F401
device_registry as dev_reg,
entity_registry as ent_reg,
)
@attr.s(slots=True)
class PermissionLookup:
"""Class to hold data for permission... |
import logging
import voluptuous as vol
from homeassistant.components.weather import (
ATTR_FORECAST_CONDITION,
ATTR_FORECAST_TEMP,
ATTR_FORECAST_TIME,
ATTR_WEATHER_HUMIDITY,
ATTR_WEATHER_PRESSURE,
ATTR_WEATHER_TEMPERATURE,
ATTR_WEATHER_WIND_BEARING,
ATTR_WEATHER_WIND_SPEED,
PLATF... |
from homeassistant.components.binary_sensor import (
DEVICE_CLASS_MOTION,
DOMAIN as BINARY_SENSOR_DOMAIN,
)
from homeassistant.components.ozw.const import DOMAIN
from homeassistant.const import ATTR_DEVICE_CLASS
from .common import setup_ozw
async def test_binary_sensor(hass, generic_data, binary_sensor_msg... |
import json
from airly.exceptions import AirlyError
from homeassistant import data_entry_flow
from homeassistant.components.airly.const import DOMAIN
from homeassistant.config_entries import SOURCE_USER
from homeassistant.const import (
CONF_API_KEY,
CONF_LATITUDE,
CONF_LONGITUDE,
CONF_NAME,
HTTP... |
from weblate.lang.models import Language
from weblate.utils.management.base import BaseCommand
class Command(BaseCommand):
help = "Populates language definitions"
def add_arguments(self, parser):
parser.add_argument(
"--no-update",
action="store_false",
dest="upda... |
import numpy as np
from scipy.sparse import csr_matrix
class CSRMatrixFactory:
''' Factory class to create a csr_matrix.
'''
def __init__(self, dtype=np.int32):
self.rows = []
self.cols = []
self.data = []
self._max_col = 0
self._max_row = 0
self._dtype = dtype
def __setitem__(self, row_col, datum):... |
import os
import os.path as op
from setuptools import setup
# get the version (don't import mne here, so dependencies are not needed)
version = None
with open(op.join('mne', '_version.py'), 'r') as fid:
for line in (line.strip() for line in fid):
if line.startswith('__version__'):
version = l... |
import speech_recognition as sr
from kalliope.core import Utils
from kalliope.stt.Utils import SpeechRecognition
class Apiai(SpeechRecognition):
def __init__(self, callback=None, **kwargs):
"""
Start recording the microphone and analyse audio with Apiai api
:param callback: The callback... |
import numpy as np
from scipy import linalg
from numpy.testing import assert_almost_equal, assert_array_almost_equal
from mne.time_frequency import stft, istft, stftfreq
from mne.time_frequency._stft import stft_norm2
def test_stft():
"""Test stft and istft tight frame property."""
sfreq = 1000. # Hz
f... |
from tests.async_mock import patch
async def test_get_id_empty(hass, hass_storage):
"""Get unique ID."""
uuid = await hass.helpers.instance_id.async_get()
assert uuid is not None
# Assert it's stored
assert hass_storage["core.uuid"]["data"]["uuid"] == uuid
async def test_get_id_migrate(hass, ha... |
class AlexaGlobalCatalog:
"""The Global Alexa catalog.
https://developer.amazon.com/docs/device-apis/resources-and-assets.html#global-alexa-catalog
You can use the global Alexa catalog for pre-defined names of devices, settings, values, and units.
This catalog is localized into all the languages that... |
import io
import contextlib
import urllib.parse
from sys import exc_info as _exc_info
from traceback import format_exception as _format_exception
from xml.sax import saxutils
import html
from more_itertools import always_iterable
import cherrypy
from cherrypy._cpcompat import ntob
from cherrypy._cpcompat import tona... |
import os.path as op
import numpy as np
from numpy.testing import assert_array_almost_equal, assert_equal
import pytest
from mne import io, Epochs, read_events, pick_types
from mne.utils import requires_sklearn, run_tests_if_main
from mne.decoding import compute_ems, EMS
data_dir = op.join(op.dirname(__file__), '..'... |
import inspect
import json
import logging
import os
import sys
import tempfile
from copy import deepcopy
from pathlib import Path
from typing import Any, Dict
import appdirs
from discord.utils import deprecated
from . import commands
__all__ = [
"create_temp_config",
"load_basic_configuration",
"cog_dat... |
from enum import Enum
from homeassistant.components.climate.const import (
HVAC_MODE_AUTO,
HVAC_MODE_COOL,
HVAC_MODE_DRY,
HVAC_MODE_FAN_ONLY,
HVAC_MODE_HEAT,
HVAC_MODE_OFF,
PRESET_AWAY,
PRESET_COMFORT,
PRESET_ECO,
PRESET_SLEEP,
)
DOMAIN = "knx"
CONF_STATE_ADDRESS = "state_add... |
from pprint import pprint
from riko import get_path
from riko.bado import coroutine
from riko.collections import SyncPipe, AsyncPipe
p1_conf = {'url': get_path('gigs.json'), 'path': 'value.items'}
p2_conf = {'uniq_key': 'link'}
p3_conf = {
'combine': 'or',
'mode': 'block',
'rule': [{'field': 'title', 'val... |
import voluptuous as vol
from homeassistant.const import CONF_ICON, CONF_URL
import homeassistant.helpers.config_validation as cv
DOMAIN = "panel_iframe"
CONF_TITLE = "title"
CONF_RELATIVE_URL_ERROR_MSG = "Invalid relative URL. Absolute path required."
CONF_RELATIVE_URL_REGEX = r"\A/"
CONF_REQUIRE_ADMIN = "require... |
from collections import OrderedDict, defaultdict
import json
from typing import Dict
from .model import Config, Integration
BASE = """
\"\"\"Automatically generated by hassfest.
To update, run python3 -m script.hassfest
\"\"\"
# fmt: off
ZEROCONF = {}
HOMEKIT = {}
""".strip()
def generate_and_validate(integrat... |
from typing import cast
import os.path
from PyQt5.QtCore import QUrl
from PyQt5.QtGui import QFont
from PyQt5.QtWebKit import QWebSettings
from PyQt5.QtWebKitWidgets import QWebPage
from qutebrowser.config import config, websettings
from qutebrowser.config.websettings import AttributeInfo as Attr
from qutebrowser.ut... |
from test import CollectorTestCase
from test import get_collector_config
from test import run_only
from mock import patch
from slony import SlonyCollector
def run_only_if_psycopg2_is_available(func):
try:
import psycopg2
except ImportError:
psycopg2 = None
pred = lambda: psycopg2 is not ... |
from typing import Callable, Dict, Union
from pyisy.constants import ISY_VALUE_UNKNOWN
from homeassistant.components.sensor import DOMAIN as SENSOR
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import TEMP_CELSIUS, TEMP_FAHRENHEIT
from homeassistant.helpers.typing import HomeAssistant... |
import io
import pkgutil
from collections import Counter
from re import split
from sys import version_info
import pandas as pd
from scattertext.features.FeatsFromSpacyDoc import FeatsFromSpacyDoc
class FeatsFromMoralFoundationsDictionary(FeatsFromSpacyDoc):
def __init__(self,
use_lemmas=False,... |
import logging
import pytest
def test_log_debug():
logging.debug('foo')
def test_log_warning():
with pytest.raises(pytest.fail.Exception):
logging.warning('foo')
def test_log_expected(caplog):
with caplog.at_level(logging.ERROR):
logging.error('foo')
def test_log_expected_logger(ca... |
from typing import Callable, Sequence, Type, Any, Iterable
from dedupe import predicates
class Variable(object):
def __len__(self):
return 1
def __repr__(self):
return self.name
def __hash__(self):
return hash(self.name)
def __eq__(self, other):
return self.name ==... |
import logging
import sounddevice as sd
import soundfile as sf
from kalliope.core.PlayerModule import PlayerModule
logging.basicConfig()
logger = logging.getLogger("kalliope")
FS = 48000
class Sounddeviceplayer(PlayerModule):
"""
This Class is representing the Player Object used to play the all sound of ... |
from typing import Optional
from homeassistant.components.device_tracker import SOURCE_TYPE_ROUTER
from homeassistant.components.device_tracker.config_entry import ScannerEntity
from homeassistant.config_entries import ConfigEntry
from homeassistant.core import callback
from homeassistant.helpers import entity_regist... |
from datetime import timedelta
import logging
from pyephember.pyephember import (
EphEmber,
ZoneMode,
zone_current_temperature,
zone_is_active,
zone_is_boost_active,
zone_is_hot_water,
zone_mode,
zone_name,
zone_target_temperature,
)
import voluptuous as vol
from homeassistant.com... |
revision = 'b33c838cb669'
down_revision = '318b66568358'
from alembic import op
import sqlalchemy as sa
def upgrade():
# ### commands auto generated by Alembic - please adjust! ###
op.create_index('ix_certificates_not_after', 'certificates', [sa.text('not_after DESC')], unique=False)
# ### end Alembic c... |
import asyncio
import logging
from spiderpy.spiderapi import SpiderApi, UnauthorizedException
import voluptuous as vol
from homeassistant.config_entries import SOURCE_IMPORT
from homeassistant.const import CONF_PASSWORD, CONF_SCAN_INTERVAL, CONF_USERNAME
import homeassistant.helpers.config_validation as cv
from .co... |
import urllib2
import re
import diamond.collector
import json
class NginxCollector(diamond.collector.Collector):
def get_default_config_help(self):
config_help = super(NginxCollector, self).get_default_config_help()
config_help.update({
'precision': 'Number of decimal places to repor... |
from homeassistant.components.smappee.const import DOMAIN
from homeassistant.config_entries import SOURCE_ZEROCONF
from tests.async_mock import patch
from tests.common import MockConfigEntry
async def test_unload_config_entry(hass):
"""Test unload config entry flow."""
with patch("pysmappee.api.SmappeeLocal... |
class PortfolioEvent(object):
"""
Stores an individual instance of a portfolio event used to create
an event trail to track all changes to a portfolio through time.
Parameters
----------
dt : `datetime`
Datetime of the event.
type : `str`
The type of portfolio event, e.g. '... |
import logging
import unittest
import os
import os.path
import tempfile
from collections import defaultdict
from gensim.corpora import Dictionary
import gensim.models.wrappers.ldavowpalwabbit as ldavowpalwabbit
from gensim.models.wrappers.ldavowpalwabbit import LdaVowpalWabbit
from gensim.test.utils import datapath
... |
import logging
import subprocess
import threading
# pylint: disable=import-error
from openrazer_daemon.keyboard import XTE_MAPPING
# This determines if the macro keys are executed with their natural spacing
XTE_SLEEP = False
class MacroObject(object):
"""
Macro base object
"""
def to_dict(self):
... |
from xknx.devices import Sensor as XknxSensor
from homeassistant.components.sensor import DEVICE_CLASSES
from homeassistant.helpers.entity import Entity
from .const import DOMAIN
from .knx_entity import KnxEntity
async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
"""Set up s... |
import itertools
import random
import time
import unittest
import mock
from perfkitbenchmarker.scripts.object_storage_api_test_scripts import object_storage_api_tests
class TestSizeDistributionIterator(unittest.TestCase):
def testPointDistribution(self):
dist = {10: 100.0}
iter = object_storage_api_tes... |
from math import ceil
import numpy as np
from ..fixes import fft, ifft, fftfreq
from ..utils import logger, verbose
@verbose
def stft(x, wsize, tstep=None, verbose=None):
"""STFT Short-Term Fourier Transform using a sine window.
The transformation is designed to be a tight frame that can be
perfectly i... |
from datetime import timedelta
import logging
import async_timeout
from pyowm.exceptions.api_call_error import APICallError
from pyowm.exceptions.api_response_error import UnauthorizedError
from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
from .const import (
ATTR_API_CLO... |
from datetime import date
import logging
import pysaj
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import (
CONF_HOST,
CONF_NAME,
CONF_PASSWORD,
CONF_TYPE,
CONF_USERNAME,
DEVICE_CLASS_POWER,
DEVICE_CLASS_TEMPERATURE,
ENE... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.