text stringlengths 213 32.3k |
|---|
from django import forms
from django.contrib.admin.widgets import RelatedFieldWidgetWrapper
from django.utils.translation import gettext_lazy as _
from mptt.forms import TreeNodeChoiceField
from zinnia.admin.fields import MPTTModelMultipleChoiceField
from zinnia.admin.widgets import MPTTFilteredSelectMultiple
from z... |
import os
import shutil
import tempfile
import unittest
import homeassistant.components.kira as kira
from homeassistant.setup import setup_component
from tests.async_mock import MagicMock, patch
from tests.common import get_test_home_assistant
TEST_CONFIG = {
kira.DOMAIN: {
"sensors": [
{"na... |
import pytest
from vcr.serializers.jsonserializer import serialize
from vcr.request import Request
def test_serialize_binary():
request = Request(method="GET", uri="http://localhost/", body="", headers={})
cassette = {"requests": [request], "responses": [{"body": b"\x8c"}]}
with pytest.raises(Exception)... |
from pprint import pprint
import requests
from .util import get_lokalise_token
def get_api(project_id, debug=False) -> "Lokalise":
"""Get Lokalise API."""
return Lokalise(project_id, get_lokalise_token(), debug)
class Lokalise:
"""Lokalise API."""
def __init__(self, project_id, token, debug):
... |
import json
import logging
import voluptuous as vol
from homeassistant.components.device_tracker import PLATFORM_SCHEMA, SOURCE_TYPE_ROUTER
from homeassistant.components.http import HomeAssistantView
from homeassistant.const import HTTP_BAD_REQUEST, HTTP_UNPROCESSABLE_ENTITY
from homeassistant.core import callback
i... |
import sys
import traceback
#: safe_str takes encoding from this file by default.
#: :func:`set_default_encoding_file` can used to set the
#: default output file.
default_encoding_file = None
def set_default_encoding_file(file):
"""Set file used to get codec information."""
global default_encoding_file
... |
import tensorflow as tf
from tensorflow.keras.layers import Layer # type: ignore
from tensorflow.keras import activations
from tensorflow.keras import initializers
from typing import List, Optional, Text, Tuple
import tensornetwork as tn
from tensornetwork import Node
import numpy as np
import math
# pytype: disabl... |
from datetime import timedelta
import logging
import requests
from homeassistant.components.switch import SwitchEntity
from homeassistant.core import callback
import homeassistant.util.dt as dt_util
from . import DOMAIN
from .entity import RingEntityMixin
_LOGGER = logging.getLogger(__name__)
SIREN_ICON = "mdi:al... |
import logging
from multiprocessing.pool import ThreadPool
try:
from lz4.block import compress as lz4_compress, decompress as lz4_decompress
lz4_compressHC = lambda _str: lz4_compress(_str, mode='high_compression')
except ImportError as e:
from lz4 import compress as lz4_compress, compressHC as lz4_compre... |
from functools import wraps
from typing import Callable, Dict, List, Optional, cast
from .const import SUBCAT_ALL
from .models import PermissionLookup
from .types import CategoryType, SubCategoryDict, ValueType
LookupFunc = Callable[[PermissionLookup, SubCategoryDict, str], Optional[ValueType]]
SubCatLookupType = Di... |
import os
import os.path
import functools
import contextlib
import html
from typing import Any, Callable, FrozenSet, Iterator, List, Set, Tuple
import jinja2
import jinja2.nodes
from PyQt5.QtCore import QUrl
from qutebrowser.utils import utils, urlutils, log, qtutils, javascript
from qutebrowser.misc import debugcac... |
import pytest
from homeassistant import data_entry_flow
from homeassistant.components.forked_daapd.const import (
CONF_LIBRESPOT_JAVA_PORT,
CONF_MAX_PLAYLISTS,
CONF_TTS_PAUSE_TIME,
CONF_TTS_VOLUME,
DOMAIN,
)
from homeassistant.config_entries import (
CONN_CLASS_LOCAL_PUSH,
SOURCE_USER,
... |
import pytest
from homeassistant.components.local_ip import DOMAIN
from homeassistant.setup import async_setup_component
from homeassistant.util import get_local_ip
@pytest.fixture(name="config")
def config_fixture():
"""Create hass config fixture."""
return {DOMAIN: {}}
async def test_basic_setup(hass, c... |
import os
import stat
import sys
from subprocess import PIPE
from subprocess import Popen
from catkin.find_in_workspaces import find_in_workspaces as catkin_find
import roslib.manifest # noqa: F401
import rospkg
SRC_DIR = 'src'
# aliases
ROS_PACKAGE_PATH = rospkg.environment.ROS_PACKAGE_PATH
ROS_ROOT = rospkg.en... |
import os
import sys
import inspect
def get_diamond_version():
try:
from diamond.version import __VERSION__
return __VERSION__
except ImportError:
return "Unknown"
def load_modules_from_path(path):
"""
Import all modules from the given directory
"""
# Check and fix t... |
from urllib.parse import urlparse
import pywilight
from homeassistant.components import ssdp
from homeassistant.config_entries import CONN_CLASS_LOCAL_PUSH, ConfigFlow
from homeassistant.const import CONF_HOST
from .const import DOMAIN # pylint: disable=unused-import
CONF_SERIAL_NUMBER = "serial_number"
CONF_MODE... |
from __future__ import division
import numpy as np
import unittest
from chainer import testing
from chainercv.links.model.ssd import random_crop_with_bbox_constraints
from chainercv.utils import bbox_iou
from chainercv.utils import generate_random_bbox
class TestRandomCropWithBboxConstraints(unittest.TestCase):
... |
from pi4ioe5v9xxxx import pi4ioe5v9xxxx # pylint: disable=import-error
import voluptuous as vol
from homeassistant.components.switch import PLATFORM_SCHEMA, SwitchEntity
from homeassistant.const import DEVICE_DEFAULT_NAME
import homeassistant.helpers.config_validation as cv
CONF_PINS = "pins"
CONF_INVERT_LOGIC = "i... |
import json
import pytest
from homeassistant.components import alexa
from homeassistant.components.alexa import intent
from homeassistant.const import CONTENT_TYPE_JSON
from homeassistant.core import callback
from homeassistant.setup import async_setup_component
SESSION_ID = "amzn1.echo-api.session.0000000-0000-000... |
import os
from log import Log
import sys
import importlib
import importlib.machinery
class GcpModuleFinder(importlib.abc.MetaPathFinder):
_MODULES = ['google.cloud.bigquery', 'google.cloud.storage', 'google.cloud.automl_v1beta1']
_KAGGLE_GCP_PATH = 'kaggle_gcp.py'
def __init__(self):
pass
d... |
import unittest
import copy
import logging
import numbers
import numpy as np
from gensim import matutils
from gensim.models import nmf
from gensim.test import basetmtests
from gensim.test.utils import datapath, get_tmpfile, common_corpus, common_dictionary
class TestNmf(unittest.TestCase, basetmtests.TestBaseTopic... |
from homeassistant.components.rpi_power.const import DOMAIN
from homeassistant.config_entries import SOURCE_USER
from homeassistant.core import HomeAssistant
from homeassistant.data_entry_flow import (
RESULT_TYPE_ABORT,
RESULT_TYPE_CREATE_ENTRY,
RESULT_TYPE_FORM,
)
from tests.async_mock import MagicMock
... |
import asyncio
import logging
import secrets
import pyatmo
import voluptuous as vol
from homeassistant.components import cloud
from homeassistant.components.webhook import (
async_register as webhook_register,
async_unregister as webhook_unregister,
)
from homeassistant.config_entries import ConfigEntry
from... |
import numpy as np
def resize_point(point, in_size, out_size):
"""Adapt point coordinates to the rescaled image space.
Args:
point (~numpy.ndarray or list of arrays): See the table below.
in_size (tuple): A tuple of length 2. The height and the width
of the image before resized.
... |
from datetime import timedelta
import logging
import async_timeout
from pyflick import FlickAPI, FlickPrice
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import ATTR_ATTRIBUTION, ATTR_FRIENDLY_NAME
from homeassistant.core import HomeAssistant
from homeassistant.helpers.entity import E... |
import pytest
from lemur.sources.views import * # noqa
from .vectors import (
VALID_ADMIN_API_TOKEN,
VALID_ADMIN_HEADER_TOKEN,
VALID_USER_HEADER_TOKEN,
WILDCARD_CERT_STR,
WILDCARD_CERT_KEY,
)
def validate_source_schema(client):
from lemur.sources.schemas import SourceInputSchema
input... |
import os
import sys
import unittest
import logging
import tempfile
try:
from StringIO import StringIO
except ImportError:
from io import StringIO
import requests
from stash import stash
from stash.system.shcommon import _STASH_ROOT, PY3
ON_TRAVIS = "TRAVIS" in os.environ
def network_is_available():
... |
from __future__ import print_function
import sqlite3
import os
import cmd
import sys
class SqliteCMD(cmd.Cmd):
'''
Simple sqlite3 shell
'''
prompt = 'sqlite3>'
def __init__(self, db=None):
cmd.Cmd.__init__(self)
self.database = db or ':memory:'
self.separator = '|'
... |
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 mesos import MesosCollector
##########################################################################
class TestMesosCollect... |
import asyncio
from collections import OrderedDict
import logging
import aiobotocore
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.const import ATTR_CREDENTIALS, CONF_NAME, CONF_PROFILE_NAME
from homeassistant.helpers import config_validation as cv, discovery
# Loading the con... |
from datetime import timedelta
from homeassistant.components.nuheat.const import DOMAIN
from homeassistant.const import ATTR_ENTITY_ID
from homeassistant.setup import async_setup_component
import homeassistant.util.dt as dt_util
from .mocks import (
_get_mock_nuheat,
_get_mock_thermostat_run,
_get_mock_t... |
from __future__ import absolute_import
from calendar import HTMLCalendar
from datetime import date
from django.urls import reverse
from django.utils.dates import MONTHS
from django.utils.dates import WEEKDAYS_ABBR
from django.utils.formats import date_format
from django.utils.formats import get_format
from zinnia.m... |
class TemplateError(Exception):
"""Baseclass for all template errors."""
def __init__(self, message=None):
super().__init__(message)
@property
def message(self):
if self.args:
return self.args[0]
class TemplateNotFound(IOError, LookupError, TemplateError):
"""Raised ... |
from django.contrib.auth.hashers import check_password
from django.core.exceptions import ValidationError
from django.utils.translation import gettext as _
from weblate.accounts.models import AuditLog
class CharsPasswordValidator:
"""Validate whether the password is not only whitespace or single char."""
d... |
from ... import event
from .._widget import Widget, create_element
class Slider(Widget):
""" An input widget to select a value in a certain range.
The ``node`` of this widget is a
`<div> <https://developer.mozilla.org/docs/Web/HTML/Element/div>`_
containing a few HTML elements for rendering. It does... |
import logging
import subprocess
_LOGGER = logging.getLogger(__name__)
def call_shell_with_timeout(command, timeout, *, log_return_code=True):
"""Run a shell command with a timeout.
If log_return_code is set to False, it will not print an error if a non-zero
return code is returned.
"""
try:
... |
import datetime
from gi.repository import GObject, Gtk
class CellRendererDate(Gtk.CellRendererText):
__gtype_name__ = "CellRendererDate"
#: We use negative 32-bit Unix timestamp to threshold our valid values
MIN_TIMESTAMP = -2147483648
DATETIME_FORMAT = "%a %d %b %Y %H:%M:%S"
def get_timestam... |
from __future__ import print_function
import os
import sys
import fileinput
import argparse
def main(args):
ap = argparse.ArgumentParser()
ap.add_argument('files', nargs='*', help='files to sort')
ap.add_argument('-r', '--reverse', action='store_true', default=False, help='reverse the result of compariso... |
import os
import time
from datetime import datetime
import pytz
from tzlocal import get_localzone as tzlocal_get_localzone
import paasta_tools.paastaapi.models as paastamodels
from paasta_tools.api import client
def get_localzone():
if "TZ" in os.environ:
return pytz.timezone(os.environ["TZ"])
else... |
import os
import re
import pytest
import testinfra.utils.ansible_runner
testinfra_hosts = testinfra.utils.ansible_runner.AnsibleRunner(
os.environ['MOLECULE_INVENTORY_FILE']).get_hosts('all')
@pytest.mark.skip(reason='Scenario tests not implemented yet')
def test_hostname(host):
assert re.search(r'instanc... |
import pytest
import homeassistant.components.mfi.switch as mfi
import homeassistant.components.switch as switch_component
from homeassistant.setup import async_setup_component
import tests.async_mock as mock
PLATFORM = mfi
COMPONENT = switch_component
THING = "switch"
GOOD_CONFIG = {
"switch": {
"platf... |
import gzip
import io
from unittest import mock
from http.client import IncompleteRead
from urllib.parse import quote as url_quote
import cherrypy
from cherrypy._cpcompat import ntob, ntou
from cherrypy.test import helper
europoundUnicode = ntou('£', encoding='utf-8')
sing = ntou('毛泽东: Sing, Little Birdie?', encod... |
import collections
import json
import logging
import threading
from absl import flags
from perfkitbenchmarker import disk
from perfkitbenchmarker import linux_virtual_machine
from perfkitbenchmarker import os_types
from perfkitbenchmarker import resource
from perfkitbenchmarker import virtual_machine
FLAGS = flags.F... |
import diamond.collector
import diamond.convertor
import os
from decimal import Decimal
try:
import psutil
psutil # workaround for pyflakes issue #13
except ImportError:
psutil = None
_KEY_MAPPING = [
'MemTotal',
'MemFree',
'MemAvailable', # needs kernel 3.14
'Buffers',
'Cached',
... |
import os
import os.path as op
import numpy as np
from distutils.version import LooseVersion
from ...utils import (_fetch_file, verbose, _TempDir, _check_pandas_installed,
_on_missing)
from ..utils import _get_path
AGE_SLEEP_RECORDS = op.join(op.dirname(__file__), 'age_records.csv')
TEMAZEPAM_S... |
from homeassistant.components.light import SUPPORT_BRIGHTNESS, SUPPORT_COLOR
from tests.components.homekit_controller.common import (
Helper,
setup_accessories_from_file,
setup_test_accessories,
)
async def test_aqara_gateway_setup(hass):
"""Test that a Aqara Gateway can be correctly setup in HA."""... |
import pycrfsuite
from flask import current_app as app
from app.nlu import spacy_tokenizer
class EntityExtractor:
"""
Performs NER training, prediction, model import/export
"""
def __init__(self, synonyms=[]):
self.synonyms = synonyms
def replace_synonyms(self, entities):
"""
... |
import logging
import threading
import datetime
import time
try:
import notify2
except ImportError:
notify2 = None
# TODO https://askubuntu.com/questions/110969/notify-send-ignores-timeout
NOTIFY_TIMEOUT = 4000
class BatteryNotifier(threading.Thread):
"""
Thread to notify about battery
"""
... |
from . import nodes
from .visitor import NodeTransformer
def optimize(node, environment):
"""The context hint can be used to perform an static optimization
based on the context given."""
optimizer = Optimizer(environment)
return optimizer.visit(node)
class Optimizer(NodeTransformer):
def __init... |
from __future__ import absolute_import
import unittest
from .common_imports import etree, HelperTestCase, _bytes
from lxml.etree import PythonElementClassLookup
xml_str = _bytes('''\
<obj:root xmlns:obj="objectified" xmlns:other="otherNS">
<obj:c1 a1="A1" a2="A2" other:a3="A3">
<obj:c2>0</obj:c2>
<obj:c... |
import asyncio
import codecs
import json
import logging
import re
import aiohttp
import async_timeout
from hangups import event, exceptions
logger = logging.getLogger(__name__)
Utf8IncrementalDecoder = codecs.getincrementaldecoder('utf-8')
LEN_REGEX = re.compile(r'([0-9]+)\n', re.MULTILINE)
CHANNEL_URL = 'https://0... |
import os
import sys
import time
import warnings
import contextlib
import portend
class Timeouts:
occupied = 5
free = 1
class ServerAdapter(object):
"""Adapter for an HTTP server.
If you need to start more than one HTTP server (to serve on multiple
ports, or protocols, etc.), you can manuall... |
from mock import patch, Mock
from arctic._compression import compress, compress_array, decompress, decompress_array, enable_parallel_lz4
def test_compress():
assert len(compress(b'foobar')) > 0
def test_compress_LZ4():
cfn = Mock()
with patch('arctic._compression.lz4_compress', cfn):
compress(... |
import os.path
import cherrypy
class GeneratorDemo:
def header(self):
return '<html><body><h2>Generators rule!</h2>'
def footer(self):
return '</body></html>'
@cherrypy.expose
def index(self):
# Let's make up a list of users for presentation purposes
users = ['Remi... |
from datetime import datetime, timedelta
import logging
from todoist.api import TodoistAPI
import voluptuous as vol
from homeassistant.components.calendar import PLATFORM_SCHEMA, CalendarEventDevice
from homeassistant.const import CONF_ID, CONF_NAME, CONF_TOKEN
import homeassistant.helpers.config_validation as cv
fr... |
import logging
from typing import Any, Dict, Optional
from canary.api import Api
from requests import ConnectTimeout, HTTPError
import voluptuous as vol
from homeassistant.config_entries import CONN_CLASS_CLOUD_POLL, ConfigFlow, OptionsFlow
from homeassistant.const import CONF_PASSWORD, CONF_TIMEOUT, CONF_USERNAME
f... |
import logging
import voluptuous as vol
from homeassistant.components import fan, mqtt
from homeassistant.components.fan import (
ATTR_SPEED,
SPEED_HIGH,
SPEED_LOW,
SPEED_MEDIUM,
SPEED_OFF,
SUPPORT_OSCILLATE,
SUPPORT_SET_SPEED,
FanEntity,
)
from homeassistant.const import (
CONF_D... |
import asyncio
import logging
import aiohttp
from aiohttp.hdrs import ACCEPT, AUTHORIZATION
import async_timeout
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import CONTENT_TYPE_JSON, HTTP_NOT_FOUND, HTTP_UNAUTHORIZED
from homeassistant.helpers.aiohttp... |
from aioshelly import Block
from homeassistant.components.cover import (
ATTR_POSITION,
SUPPORT_CLOSE,
SUPPORT_OPEN,
SUPPORT_SET_POSITION,
SUPPORT_STOP,
CoverEntity,
)
from homeassistant.core import callback
from . import ShellyDeviceWrapper
from .const import DATA_CONFIG_ENTRY, DOMAIN
from .... |
import logging
import random
import six
from jinja2 import Template
from kalliope.core import OrderListener
from kalliope.core.HookManager import HookManager
from kalliope.core.ConfigurationManager import SettingLoader, BrainLoader
from kalliope.core.Cortex import Cortex
from kalliope.core.Lifo.LifoManager import Li... |
import asyncio
import contextlib
import logging
import time
from enum import Enum, unique
from pathlib import Path
from typing import MutableMapping
import discord
from redbot.core import commands
from redbot.core.i18n import Translator
log = logging.getLogger("red.cogs.Audio.task.callback")
_ = Translator("Audio"... |
from homeassistant.components.media_player import BrowseMedia
from homeassistant.components.media_player.const import (
MEDIA_CLASS_APP,
MEDIA_CLASS_CHANNEL,
MEDIA_CLASS_DIRECTORY,
MEDIA_TYPE_APP,
MEDIA_TYPE_APPS,
MEDIA_TYPE_CHANNEL,
MEDIA_TYPE_CHANNELS,
)
CONTENT_TYPE_MEDIA_CLASS = {
... |
import pytest
from homeassistant import config_entries, data_entry_flow
from homeassistant.components.izone.const import DISPATCH_CONTROLLER_DISCOVERED, IZONE
from tests.async_mock import Mock, patch
@pytest.fixture
def mock_disco():
"""Mock discovery service."""
disco = Mock()
disco.pi_disco = Mock()
... |
import random
from fnvhash import fnv1a_32
from homeassistant.config_entries import ConfigEntry
from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers.entity_registry import RegistryEntry
from homeassistant.helpers.storage import Store
from .util import get_aid_storage_filename_for_entry_... |
import json
from pathlib import Path
from typing import Any, Dict, Tuple
from .info_schemas import REPO_SCHEMA, update_mixin
from .log import log
class RepoJSONMixin:
INFO_FILE_NAME = "info.json"
def __init__(self, repo_folder: Path):
self._repo_folder = repo_folder
self.author: Tuple[str,... |
from homeassistant.helpers.update_coordinator import CoordinatorEntity
class RiscoEntity(CoordinatorEntity):
"""Risco entity base class."""
def _get_data_from_coordinator(self):
raise NotImplementedError
def _refresh_from_coordinator(self):
self._get_data_from_coordinator()
self... |
from sqlalchemy import func
from flask import current_app
from lemur import database
from lemur.models import certificate_destination_associations
from lemur.destinations.models import Destination
from lemur.certificates.models import Certificate
from lemur.sources.service import add_aws_destination_to_sources
def ... |
import json
import logging
from absl import flags
from perfkitbenchmarker import dpb_service
from perfkitbenchmarker import errors
from perfkitbenchmarker import vm_util
from perfkitbenchmarker.providers import aws
from perfkitbenchmarker.providers.aws import aws_network
from perfkitbenchmarker.providers.aws import a... |
import itertools
from absl import flags
PROVISION = 'provision'
PREPARE = 'prepare'
RUN = 'run'
CLEANUP = 'cleanup'
TEARDOWN = 'teardown'
STAGES = [PROVISION, PREPARE, RUN, CLEANUP, TEARDOWN]
_NEXT_STAGE = {PROVISION: PREPARE, PREPARE: RUN, RUN: CLEANUP,
CLEANUP: TEARDOWN}
_ALL = 'all'
_VALID_FLAG_... |
import platform
import os
import diamond.collector
# Detect the architecture of the system
# and set the counters for MAX_VALUES
# appropriately. Otherwise, rolling over
# counters will cause incorrect or
# negative values.
if platform.architecture()[0] == '64bit':
counter = (2 ** 64) - 1
else:
counter = (2 *... |
from typing import Any, Dict
from homematicip.aio.device import (
AsyncBrandSwitchMeasuring,
AsyncFullFlushSwitchMeasuring,
AsyncHeatingThermostat,
AsyncHeatingThermostatCompact,
AsyncLightSensor,
AsyncMotionDetectorIndoor,
AsyncMotionDetectorOutdoor,
AsyncMotionDetectorPushButton,
... |
import asyncio
import time
import pytest
from homeassistant.util.timeout import TimeoutManager
async def test_simple_global_timeout():
"""Test a simple global timeout."""
timeout = TimeoutManager()
with pytest.raises(asyncio.TimeoutError):
async with timeout.async_timeout(0.1):
awa... |
from pscript import window
from ... import event
from ._canvas import CanvasWidget
class PlotWidget(CanvasWidget):
""" Widget to show a plot of x vs y values. Enough for simple
plotting tasks.
"""
DEFAULT_MIN_SIZE = 300, 200
xdata = event.TupleProp((), doc="""
A list of values for ... |
import pytest
from keras.models import Sequential
from elephas.utils import serialization
def test_model_to_dict():
model = Sequential()
dict_model = serialization.model_to_dict(model)
assert dict_model.keys() == ['model', 'weights']
def test_dict_to_model():
model = Sequential()
dict_model = s... |
import os
import testinfra.utils.ansible_runner
testinfra_hosts = testinfra.utils.ansible_runner.AnsibleRunner(
os.environ['MOLECULE_INVENTORY_FILE']).get_hosts('all')
def test_hostname(host):
assert 'instance' == host.check_output('hostname -s')
def test_etc_molecule_directory(host):
f = host.file('... |
import diamond.collector
import os
class KVMCollector(diamond.collector.Collector):
PROC = '/sys/kernel/debug/kvm'
def get_default_config_help(self):
config_help = super(KVMCollector, self).get_default_config_help()
config_help.update({
})
return config_help
def get_def... |
import os
import win32api
import win32con
import win32event
import win32service
import win32serviceutil
from cherrypy.process import wspbus, plugins
class ConsoleCtrlHandler(plugins.SimplePlugin):
"""A WSPBus plugin for handling Win32 console events (like Ctrl-C)."""
def __init__(self, bus):
self.... |
import asyncio
from typing import Dict, Optional
import aiohttp
import async_timeout
from sharkiqpy import SharkIqAuthError, get_ayla_api
import voluptuous as vol
from homeassistant import config_entries, core, exceptions
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from .const import _LOGGER, DOMAI... |
import functools
import logging
from unittest.mock import patch, MagicMock
import httpx
from vcr.request import Request as VcrRequest
from vcr.errors import CannotOverwriteExistingCassetteException
_logger = logging.getLogger(__name__)
def _transform_headers(httpx_reponse):
"""
Some headers can appear mul... |
import logging
from velbus.util import VelbusException
from homeassistant.components.climate import ClimateEntity
from homeassistant.components.climate.const import (
HVAC_MODE_HEAT,
SUPPORT_TARGET_TEMPERATURE,
)
from homeassistant.const import ATTR_TEMPERATURE, TEMP_CELSIUS, TEMP_FAHRENHEIT
from . import V... |
import logging
import opengarage
import voluptuous as vol
from homeassistant.components.cover import (
DEVICE_CLASS_GARAGE,
PLATFORM_SCHEMA,
SUPPORT_CLOSE,
SUPPORT_OPEN,
CoverEntity,
)
from homeassistant.const import (
CONF_COVERS,
CONF_HOST,
CONF_NAME,
CONF_PORT,
CONF_SSL,
... |
from django.conf import settings
from django.contrib.auth.backends import ModelBackend
from django.db.models.signals import pre_save
from django.dispatch.dispatcher import receiver
from weblate.auth.models import User
def try_get_user(username, list_all=False):
"""Wrapper to get User object for authentication."... |
from datetime import timedelta
from homeassistant.components.binary_sensor import BinarySensorEntity
from homeassistant.components.streamlabswater import DOMAIN as STREAMLABSWATER_DOMAIN
from homeassistant.util import Throttle
DEPENDS = ["streamlabswater"]
MIN_TIME_BETWEEN_LOCATION_UPDATES = timedelta(seconds=60)
... |
import asyncio
import logging
import async_timeout
from homeassistant.components.notify import (
ATTR_DATA,
ATTR_MESSAGE,
ATTR_TARGET,
ATTR_TITLE,
ATTR_TITLE_DEFAULT,
BaseNotificationService,
)
from homeassistant.const import (
HTTP_ACCEPTED,
HTTP_CREATED,
HTTP_OK,
HTTP_TOO_MA... |
from abc import ABC, abstractmethod
import pandas as pd
import numpy as np
from scattertext.Scalers import stretch_neg1_to_1
class CategoryProjectionBase(ABC):
'''
'''
def _pseduo_init(self, category_corpus, category_counts, projection, x_dim=0, y_dim=1, term_projection=None):
self.category_c... |
import numpy as np
def create_lut(cmap, n_colors=256, center=None):
"""Return a colormap suitable for setting as a LUT."""
from .._3d import _get_cmap
assert not (isinstance(cmap, str) and cmap == 'auto')
cmap = _get_cmap(cmap)
lut = np.round(cmap(np.linspace(0, 1, n_colors)) * 255.0).astype(np.i... |
import pathlib
from PyQt5.QtCore import QLibraryInfo
from PyQt5.QtWebEngineWidgets import QWebEngineView, QWebEnginePage
from PyQt5.QtWidgets import QWidget
from qutebrowser.browser import inspector
from qutebrowser.browser.webengine import webenginesettings
from qutebrowser.misc import miscwidgets
from qutebrowser.... |
from copy import deepcopy
import pytest
from homeassistant.components.climate import (
DOMAIN as CLIMATE_DOMAIN,
SERVICE_SET_HVAC_MODE,
SERVICE_SET_TEMPERATURE,
)
from homeassistant.components.climate.const import (
ATTR_HVAC_MODE,
ATTR_TARGET_TEMP_HIGH,
ATTR_TARGET_TEMP_LOW,
HVAC_MODE_AU... |
import enum
from typing import Mapping, Optional, Tuple
from gi.repository import Gdk, GtkSource
from meld.conf import _
class MeldStyleScheme(enum.Enum):
base = "meld-base"
dark = "meld-dark"
style_scheme: Optional[GtkSource.StyleScheme] = None
base_style_scheme: Optional[GtkSource.StyleScheme] = None
... |
from datetime import date
from datetime import datetime
import json
class CJsonEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, datetime):
return obj.strftime('%Y-%m-%d %H:%M:%S')
elif isinstance(obj, date):
return obj.strftime('%Y-%m-%d')
else... |
from homeassistant.helpers.deprecation import deprecated_substitute, get_deprecated
from tests.async_mock import MagicMock, patch
class MockBaseClass:
"""Mock base class for deprecated testing."""
@property
@deprecated_substitute("old_property")
def new_property(self):
"""Test property to f... |
from PyQt5.QtCore import pyqtSlot, QSize
from PyQt5.QtWidgets import QProgressBar, QSizePolicy
from qutebrowser.config import stylesheet
from qutebrowser.utils import utils, usertypes
class Progress(QProgressBar):
"""The progress bar part of the status bar."""
STYLESHEET = """
QProgressBar {
... |
from homeassistant.components.fan import (
SPEED_HIGH,
SPEED_LOW,
SPEED_MEDIUM,
SPEED_OFF,
SUPPORT_SET_SPEED,
)
from homeassistant.components.zwave import fan
from tests.mock.zwave import MockEntityValues, MockNode, MockValue, value_changed
def test_get_device_detects_fan(mock_openzwave):
""... |
import logging
from PyTado.interface import Tado
import requests.exceptions
import voluptuous as vol
from homeassistant import config_entries, core, exceptions
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from homeassistant.core import callback
from .const import CONF_FALLBACK, UNIQUE_ID
from .const... |
try:
import colorama
colorama.init()
except ImportError:
pass
from plumbum import cli, colors
class Geet(cli.Application):
SUBCOMMAND_HELPMSG = False
DESCRIPTION = colors.yellow | """The l33t version control"""
PROGNAME = colors.green
VERSION = colors.blue | "1.7.2"
COLOR_USAGE = colo... |
import subprocess
import sys
import logging
import re
import pytest
from PyQt5.QtCore import QProcess
from helpers import utils
ascii_locale = pytest.mark.skipif(sys.hexversion >= 0x03070000,
reason="Python >= 3.7 doesn't force ASCII "
"locale wit... |
import unicodedata
import numpy as np
from .. import coding
from ..core.variable import Variable
# Special characters that are permitted in netCDF names except in the
# 0th position of the string
_specialchars = '_.@+- !"#$%&\\()*,:;<=>?[]^`{|}~'
# The following are reserved names in CDL and may not be used as nam... |
from datetime import timedelta
from pyirishrail.pyirishrail import IrishRailRTPI
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import ATTR_ATTRIBUTION, CONF_NAME, TIME_MINUTES
import homeassistant.helpers.config_validation as cv
from homeassistant.helpe... |
from sqlalchemy import Column, Integer, String, text
from sqlalchemy.dialects.postgresql import JSON
from sqlalchemy.orm import relationship
from sqlalchemy_utils import ArrowType
from lemur.database import db
from lemur.plugins.base import plugins
from lemur.utils import Vault
class DnsProvider(db.Model):
__ta... |
from diamond.convertor import time
import unittest
class TestConvertor(unittest.TestCase):
def test_basic(self):
self.assertEquals(time.convert(60, 's', 's'), 60.0)
self.assertEquals(time.convert(60, 's', 'm'), 1.0)
self.assertEquals(time.convert(60000, 'ms', 'm'), 1.0)
self.ass... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.