text stringlengths 213 32.3k |
|---|
import os
import pickle
import shutil
# the name of the S3 bucket to post findings to
FINDINGS_S3_BUCKET = 'deeposm'
# set in Dockerfile as env variable
GEO_DATA_DIR = os.environ.get("GEO_DATA_DIR")
# where training data gets cached/retrieved
RAW_LABEL_DATA_DIR = os.path.join(GEO_DATA_DIR, "openstreetmap")
NAIP_DAT... |
from collections import namedtuple
from pyhap.const import HAP_REPR_AID, HAP_REPR_CHARS, HAP_REPR_IID, HAP_REPR_VALUE
import pytest
from homeassistant.components.fan import (
ATTR_DIRECTION,
ATTR_OSCILLATING,
ATTR_SPEED,
ATTR_SPEED_LIST,
DIRECTION_FORWARD,
DIRECTION_REVERSE,
DOMAIN,
S... |
from __future__ import print_function
import os
import re
import sys
import tensorflow as tf
def write_config():
"""Retrive compile and link information from tensorflow and write to .bazelrc."""
cflags = tf.sysconfig.get_compile_flags()
inc_regex = re.compile("^-I")
opt_regex = re.compile("^-D")
include... |
from google_nest_sdm.device import Device
from google_nest_sdm.event import EventMessage
from .common import async_setup_sdm_platform
PLATFORM = "sensor"
THERMOSTAT_TYPE = "sdm.devices.types.THERMOSTAT"
async def async_setup_sensor(hass, devices={}, structures={}):
"""Set up the platform and prerequisites."""... |
import logging
from deluge_client import DelugeRPCClient, FailedToReconnectException
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import (
CONF_HOST,
CONF_MONITORED_VARIABLES,
CONF_NAME,
CONF_PASSWORD,
CONF_PORT,
CONF_USERNAME,
... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import copy
import functools
from absl._collections_abc import abc
from absl.flags import _argument_parser
from absl.flags import _exceptions
from absl.flags import _helpers
import six
@functools.total_orde... |
from warnings import warn
from .utils import Serialize
from .lexer import TerminalDef
###{standalone
class LexerConf(Serialize):
__serialize_fields__ = 'terminals', 'ignore', 'g_regex_flags', 'use_bytes', 'lexer_type'
__serialize_namespace__ = TerminalDef,
def __init__(self, terminals, re_module, igno... |
import time
import threading
import asyncio
from flexx import flx
class MyComponent1(flx.Component):
foo = flx.Property(0, settable=True)
@flx.reaction('foo')
def on_foo(self, *events):
for ev in events:
print('foo changed to', ev.new_value)
# Create component in main thread
comp ... |
import unittest
import numpy as np
import chainer
from chainer.backends import cuda
from chainer.functions import relu
from chainer import testing
from chainermn import create_communicator
from chainercv.links.model.mobilenet import TFConv2DBNActiv
from chainercv.utils.testing import attr
def _add_one(x):
ret... |
import logging
import sys
from functools import wraps
from time import sleep
from pymongo.errors import (AutoReconnect, OperationFailure, DuplicateKeyError, ServerSelectionTimeoutError,
BulkWriteError)
from .hooks import log_exception as _log_exception
logger = logging.getLogger(__name__... |
import re
import os
from setuptools import setup, find_packages
def fpath(name):
return os.path.join(os.path.dirname(__file__), name)
def read(fname):
return open(fpath(fname)).read()
def desc():
return read('README.md')
# grep flasgger/__init__.py since python 3.x cannot
# import it before using ... |
import datetime
import dill
from nose.tools import raises
import numpy as np
import os
import random
import sys
import warnings
sys.path = [os.path.abspath(os.path.dirname(__file__))] + sys.path
sys.path = [os.path.abspath(os.path.dirname(os.path.dirname(__file__)))] + sys.path
os.environ['is_test_suite'] = 'True'
f... |
import sys
from acme.errors import ClientError
from flask import current_app
from lemur.extensions import sentry, metrics
from lemur.plugins import lemur_aws as aws, ExpirationNotificationPlugin
from lemur.plugins.bases import DestinationPlugin, ExportDestinationPlugin, SourcePlugin
from lemur.plugins.lemur_aws impor... |
from xknx.devices import Climate as XknxClimate, Device as XknxDevice
from homeassistant.helpers.entity import Entity
from .const import DOMAIN
class KnxEntity(Entity):
"""Representation of a KNX entity."""
def __init__(self, device: XknxDevice):
"""Set up device."""
self._device = device
... |
import collections
import itertools
import posixpath
import socket
import xml.etree.ElementTree as ET
from http import client
from radicale import app, httputils, pathutils, rights, storage, xmlutils
from radicale.log import logger
def xml_propfind(base_prefix, path, xml_request, allowed_items, user,
... |
import os
import os.path
import sys
import contextlib
# Import side-effects are an evil thing, but here it's okay so scripts using
# colors work on Windows as well.
try:
import colorama
except ImportError:
colorama = None
else:
colorama.init()
use_color = os.name != 'nt' or colorama
fg_colors = {
... |
from datetime import timedelta
import pytest
import homeassistant.components.automation as automation
from homeassistant.components.remote import DOMAIN
from homeassistant.const import CONF_PLATFORM, STATE_OFF, STATE_ON
from homeassistant.helpers import device_registry
from homeassistant.setup import async_setup_com... |
from django.contrib.contenttypes.models import ContentType
from django.contrib.sites.models import Site
from django.http import HttpResponsePermanentRedirect
from django.shortcuts import get_object_or_404
from django.utils.decorators import method_decorator
from django.views.decorators.csrf import csrf_exempt
from dja... |
import os
import os.path as op
import pytest
import numpy as np
from numpy.testing import (assert_array_equal, assert_equal, assert_allclose,
assert_array_less)
import mne
from mne.datasets import testing
from mne import read_trans, write_trans
from mne.io import read_info
from mne.utils i... |
from contextlib import contextmanager
from json import dumps
from types import SimpleNamespace
from os import getpid
from httpobs.conf import (API_CACHED_RESULT_TIME,
DATABASE_CA_CERT,
DATABASE_DB,
DATABASE_HOST,
D... |
from crispy_forms.helper import FormHelper
from django import forms
from weblate.lang.models import Language, Plural
class LanguageForm(forms.ModelForm):
class Meta:
model = Language
exclude = []
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.hel... |
from homeassistant.components.cover import (
ATTR_CURRENT_POSITION,
ATTR_CURRENT_TILT_POSITION,
ATTR_POSITION,
ATTR_TILT_POSITION,
)
from homeassistant.const import (
SERVICE_CLOSE_COVER,
SERVICE_CLOSE_COVER_TILT,
SERVICE_OPEN_COVER,
SERVICE_OPEN_COVER_TILT,
SERVICE_SET_COVER_POSITI... |
from datetime import timedelta
import logging
from typing import Optional
import async_timeout
from asyncpysupla import SuplaAPI
import voluptuous as vol
from homeassistant.const import CONF_ACCESS_TOKEN
from homeassistant.helpers.aiohttp_client import async_get_clientsession
import homeassistant.helpers.config_vali... |
import sys
import os, os.path
from io import open
import glob, time
from lark import Lark
from lark.indenter import Indenter
# __path__ = os.path.dirname(__file__)
class PythonIndenter(Indenter):
NL_type = '_NEWLINE'
OPEN_PAREN_types = ['LPAR', 'LSQB', 'LBRACE']
CLOSE_PAREN_types = ['RPAR', 'RSQB', 'RBR... |
from flexx.util.testing import run_tests_if_main, skipif, skip, raises
from flexx.event.both_tester import run_in_both
from flexx import event
from flexx.event._dict import isidentifier
loop = event.loop
class Foo(event.Component):
def __init__(self):
super().__init__()
self.r = []
pri... |
import re
from django.utils.translation import gettext_lazy as _
from .format import BaseFormatCheck
ANGULARJS_INTERPOLATION_MATCH = re.compile(
r"""
{{ # start symbol
\s* # ignore whitespace
((.+?))
\s* # ignore whitespace
}} # end symbo... |
import numpy as np
from tensornetwork.block_sparse.index import Index
from tensornetwork.block_sparse.blocksparsetensor import (BlockSparseTensor,
ChargeArray,
tensordot)
from tensornetwork.block_sparse.... |
import keras.layers
from matchzoo.engine.base_model import BaseModel
from matchzoo.engine.param_table import ParamTable
from matchzoo.engine import hyper_spaces
class DenseBaseline(BaseModel):
"""
A simple densely connected baseline model.
Examples:
>>> model = DenseBaseline()
>>> model... |
from collections import Counter
from scattertext.features.FeatsFromSpacyDoc import FeatsFromSpacyDoc
class UseFullDocAsMetadata(FeatsFromSpacyDoc):
def get_feats(self, doc):
return Counter()
def get_doc_metadata(self, doc):
'''
Parameters
----------
doc, Spacy Docs
... |
from datetime import timedelta
from homeassistant.components.rflink import CONF_RECONNECT_INTERVAL
from homeassistant.const import (
EVENT_STATE_CHANGED,
STATE_OFF,
STATE_ON,
STATE_UNAVAILABLE,
)
import homeassistant.core as ha
import homeassistant.util.dt as dt_util
from tests.async_mock import patc... |
import numpy as np
from scattertext.termsignificance import LogOddsRatioUninformativeDirichletPrior
class LogOddsUninformativePriorScore:
@staticmethod
def get_score(cat_word_counts, not_cat_word_counts, alpha_w=0.01):
X = LogOddsUninformativePriorScore. \
_turn_counts_into_matrix(cat_word_counts, not_cat_wo... |
from tensornetwork.network_operations import get_all_edges, get_subgraph_dangling
from tensornetwork.network_components import AbstractNode, Edge
from typing import (Any, Callable, Dict, List, Set, Tuple, Iterable, Text)
# `opt_einsum` algorithm method typing
Algorithm = Callable[[List[Set[Edge]], Set[Edge], Dict[Edge... |
import os
import uuid
import pytest
from homeassistant import data_entry_flow
from homeassistant.auth import AuthManager, auth_store, models as auth_models
from homeassistant.auth.providers import command_line
from homeassistant.const import CONF_TYPE
from tests.async_mock import AsyncMock
@pytest.fixture
def sto... |
import time
from Handler import Handler
try:
from influxdb.client import InfluxDBClient
except ImportError:
InfluxDBClient = None
class InfluxdbHandler(Handler):
"""
Sending data to Influxdb using batched format
"""
def __init__(self, config=None):
"""
Create a new instance ... |
from vine import transform
from kombu.asynchronous.aws.connection import AsyncAWSQueryConnection
from .ext import boto3
from .message import AsyncMessage
from .queue import AsyncQueue
__all__ = ('AsyncSQSConnection',)
class AsyncSQSConnection(AsyncAWSQueryConnection):
"""Async SQS Connection."""
def __i... |
from homeassistant.components.websocket_api.messages import (
_cached_event_message as lru_event_cache,
cached_event_message,
message_to_json,
)
from homeassistant.const import EVENT_STATE_CHANGED
from homeassistant.core import callback
async def test_cached_event_message(hass):
"""Test that we cache... |
from unittest import TestCase
import pandas as pd
from scattertext.TermDocMatrixFromFrequencies import TermDocMatrixFromFrequencies
from scattertext.termcompaction.ClassPercentageCompactor import ClassPercentageCompactor
class TestClassPercentageCompactor(TestCase):
def test_compact(self):
term_doc_mat = TermDocM... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import sys
try:
import faulthandler
except ImportError:
faulthandler = None
from absl import app
from absl import flags
FLAGS = flags.FLAGS
flags.DEFINE_boolean('faulthandler_sigsegv', False, ... |
from nikola.plugin_categories import Taxonomy
class Indexes(Taxonomy):
"""Classify for the blog's main index."""
name = "classify_indexes"
classification_name = "index"
overview_page_variable_name = None
more_than_one_classifications_per_post = False
has_hierarchy = False
show_list_as_i... |
import asyncio
import io
import re
import voluptuous as vol
from homeassistant.components.image_processing import (
ATTR_CONFIDENCE,
ATTR_ENTITY_ID,
CONF_CONFIDENCE,
CONF_ENTITY_ID,
CONF_NAME,
CONF_SOURCE,
PLATFORM_SCHEMA,
ImageProcessingEntity,
)
from homeassistant.const import CONF_... |
from functools import partial
from ...utils import verbose
from ..utils import (has_dataset, _data_path, _data_path_doc,
_get_version, _version_doc)
has_somato_data = partial(has_dataset, name='somato')
@verbose
def data_path(path=None, force_update=False, update_path=True, download=True,
... |
import json
from aiohttp import ClientConnectionError
from py_nightscout.models import SGV, ServerStatus
from homeassistant.components.nightscout.const import DOMAIN
from homeassistant.const import CONF_URL
from tests.async_mock import patch
from tests.common import MockConfigEntry
GLUCOSE_READINGS = [
SGV.new... |
import logging
from functools import partial
import re
import numpy as np
from gensim import interfaces, matutils, utils
from gensim.utils import deprecated
logger = logging.getLogger(__name__)
def resolve_weights(smartirs):
"""Check the validity of `smartirs` parameters.
Parameters
----------
s... |
import logging
import pymsteams
import voluptuous as vol
from homeassistant.components.notify import (
ATTR_DATA,
ATTR_TITLE,
ATTR_TITLE_DEFAULT,
PLATFORM_SCHEMA,
BaseNotificationService,
)
from homeassistant.const import CONF_URL
import homeassistant.helpers.config_validation as cv
_LOGGER = lo... |
import os
import pytest
import sh
from molecule import util
from molecule.command.init import base
from molecule.model import schema_v2
class CommandBase(base.Base):
pass
@pytest.fixture
def _base_class():
return CommandBase
@pytest.fixture
def _instance(_base_class):
return _base_class()
@pytest... |
import asyncio
from datetime import timedelta
from distutils.version import StrictVersion
import logging
import async_timeout
from distro import linux_distribution # pylint: disable=import-error
import voluptuous as vol
from homeassistant.const import __version__ as current_version
from homeassistant.helpers import... |
import unittest
import numpy as np
import chainer
from chainer.backends import cuda
from chainer import testing
from chainermn import create_communicator
from chainercv.links.model.mobilenet import ExpandedConv2D
from chainercv.utils.testing import attr
@testing.parameterize(*testing.product({
'expansion_size... |
import asyncio
import logging
from typing import Any, Dict, Iterable, Optional
from homeassistant.const import (
ATTR_ENTITY_ID,
SERVICE_TURN_OFF,
SERVICE_TURN_ON,
STATE_OFF,
STATE_ON,
)
from homeassistant.core import Context, State
from homeassistant.helpers.typing import HomeAssistantType
from ... |
import sys
import textwrap
from PyQt5.Qt import * # noqa
from PyQt5.Qsci import QsciScintilla
from PyQt5.Qsci import QsciLexerCustom
from lark import Lark
class LexerJson(QsciLexerCustom):
def __init__(self, parent=None):
super().__init__(parent)
self.create_parser()
self.create_styl... |
from smhi.smhi_lib import Smhi, SmhiForecastException
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.const import CONF_LATITUDE, CONF_LONGITUDE, CONF_NAME
from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers import aiohttp_client
import homeassistant.... |
import datetime
import mock
from test import CollectorTestCase
from test import get_collector_config
from test import unittest
from mock import patch
from test import run_only
from mock import Mock
from diamond.collector import Collector
from elb import ElbCollector
def run_only_if_boto_is_available(func):
try... |
import voluptuous as vol
from homeassistant.components import ads
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import CONF_NAME, CONF_UNIT_OF_MEASUREMENT
import homeassistant.helpers.config_validation as cv
from . import CONF_ADS_FACTOR, CONF_ADS_TYPE, CONF_ADS_VAR, STATE_KEY_... |
import unittest
from chainer.testing.attr import check_available
from chainer.testing.attr import gpu # NOQA
from chainer.testing.attr import slow # NOQA
try:
import pytest
pfnci_skip = pytest.mark.pfnci_skip
except ImportError:
from chainer.testing.attr import _dummy_callable
pfnci_skip = _dummy... |
import urwid
def exit_on_q(key):
if key in ('q', 'Q'):
raise urwid.ExitMainLoop()
palette = [
('banner', '', '', '', '#ffa', '#60d'),
('streak', '', '', '', 'g50', '#60a'),
('inside', '', '', '', 'g38', '#808'),
('outside', '', '', '', 'g27', '#a06'),
('bg', '', '', '', 'g7', '#d06'),... |
import pytest
import http.client
from cherrypy.lib import httputil
@pytest.mark.parametrize(
'script_name,path_info,expected_url',
[
('/sn/', '/pi/', '/sn/pi/'),
('/sn/', '/pi', '/sn/pi'),
('/sn/', '/', '/sn/'),
('/sn/', '', '/sn/'),
('/sn', '/pi/', '/sn/pi/'),
... |
import asyncio
import logging
import os
import re
from typing import Dict, Union
import aiohttp
from aiohttp import web
from aiohttp.hdrs import CONTENT_LENGTH, CONTENT_TYPE
from aiohttp.web_exceptions import HTTPBadGateway
import async_timeout
from homeassistant.components.http import KEY_AUTHENTICATED, HomeAssista... |
import io
import os
import threading
import pytest
from yandextank.stepper.main import LoadProfile
from yandextank.common.util import get_test_path
from yandextank.common.util import read_resource
from yandextank.common.interfaces import TankInfo
from yandextank.core import TankCore
from yandextank.stepper import St... |
from homeassistant import config_entries, data_entry_flow, setup
from homeassistant.components.devolo_home_control.const import DOMAIN
from homeassistant.config_entries import SOURCE_USER
from tests.async_mock import patch
from tests.common import MockConfigEntry
async def test_form(hass):
"""Test we get the fo... |
import mock
from paasta_tools import check_services_replication_tools
def test_main_kubernetes():
with mock.patch(
"paasta_tools.check_services_replication_tools.check_services_replication",
autospec=True,
) as mock_check_services_replication, mock.patch(
"paasta_tools.check_services... |
class ThrottlingMiddleware:
def __init__(self, get_response=None):
self.get_response = get_response
def __call__(self, request):
response = self.get_response(request)
if "throttling_state" in request.META:
throttling = request.META["throttling_state"]
response["... |
import logging
import gammu # pylint: disable=import-error, no-member
from homeassistant.const import DEVICE_CLASS_SIGNAL_STRENGTH, SIGNAL_STRENGTH_DECIBELS
from homeassistant.helpers.entity import Entity
from .const import DOMAIN, SMS_GATEWAY
_LOGGER = logging.getLogger(__name__)
async def async_setup_entry(ha... |
import pytest
from homeassistant.components.camera import SUPPORT_STREAM as CAMERA_SUPPORT_STREAM
from homeassistant.components.mobile_app.const import CONF_SECRET
from homeassistant.components.zone import DOMAIN as ZONE_DOMAIN
from homeassistant.const import CONF_WEBHOOK_ID
from homeassistant.core import callback
fr... |
import json
import re
import sys
class TextChunkBuffer:
"""Hold onto text chunks until needed."""
def __init__(self):
self.buffer = []
def append(self, text):
"""Add `text` to the buffer."""
self.buffer.append(text)
def clear(self):
"""Clear the buffer."""
se... |
from __future__ import absolute_import, print_function, division
import os
try:
from .logging import logger
warning, info = logger.warning, logger.info
except Exception:
warning = info = print
try:
from urllib.request import urlopen
except ImportError:
try:
from urllib2 import urlopen #... |
import requests
from nikola.plugin_categories import ShortcodePlugin
class Plugin(ShortcodePlugin):
"""Plugin for gist directive."""
name = "gist"
def get_raw_gist_with_filename(self, gistID, filename):
"""Get raw gist text for a filename."""
url = '/'.join(("https://gist.github.com/ra... |
from __future__ import print_function
# TODO (hartsocks): Introduce logging to remove the need for print function.
"""
This module is for ISO 8601 parsing
"""
__author__ = 'VMware, Inc.'
from six import iteritems
import time
from datetime import datetime, timedelta, tzinfo
import re
""" Regular expression to parse a... |
import voluptuous as vol
from homeassistant.const import (
ATTR_FRIENDLY_NAME,
CONF_ENTITY_ID,
CONF_EVENT,
CONF_PLATFORM,
CONF_ZONE,
)
from homeassistant.core import HassJob, callback
from homeassistant.helpers import condition, config_validation as cv, location
from homeassistant.helpers.event im... |
import pytest
import voluptuous as vol
from homeassistant import config_entries, data_entry_flow
from homeassistant.components.risco.config_flow import (
CannotConnectError,
UnauthorizedError,
)
from homeassistant.components.risco.const import DOMAIN
from tests.async_mock import PropertyMock, patch
from test... |
from datetime import datetime as dt
import pytest
from bson import ObjectId
from mock import patch
from pandas.util.testing import assert_frame_equal
from pymongo.errors import OperationFailure
from arctic._util import mongo_count
from arctic.exceptions import ConcurrentModificationException
from arctic.store.audit ... |
from homeassistant.components.homeassistant import SERVICE_RELOAD_CORE_CONFIG
from homeassistant.config import DATA_CUSTOMIZE
from homeassistant.core import DOMAIN
import homeassistant.helpers.config_validation as cv
from . import EditKeyBasedConfigView
CONFIG_PATH = "customize.yaml"
async def async_setup(hass):
... |
import logging
import numbers
import os
import sys
from logging.handlers import WatchedFileHandler
from .utils.encoding import safe_repr, safe_str
from .utils.functional import maybe_evaluate
from .utils.objects import cached_property
__all__ = ('LogMixin', 'LOG_LEVELS', 'get_loglevel', 'setup_logging')
try:
L... |
import logging
from homeassistant.components.cover import (
ATTR_POSITION,
DOMAIN,
SUPPORT_CLOSE,
SUPPORT_OPEN,
CoverEntity,
)
from homeassistant.core import callback
from homeassistant.helpers.dispatcher import async_dispatcher_connect
from . import (
CONF_INVERT_OPENCLOSE_BUTTONS,
CONF_... |
from homeassistant.helpers.entity import Entity
from . import BleBoxEntity, create_blebox_entities
from .const import BLEBOX_TO_HASS_DEVICE_CLASSES, BLEBOX_TO_UNIT_MAP
async def async_setup_entry(hass, config_entry, async_add_entities):
"""Set up a BleBox entry."""
create_blebox_entities(
hass, con... |
from datetime import timedelta
import logging
import neurio
import requests.exceptions
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import CONF_API_KEY, ENERGY_KILO_WATT_HOUR, POWER_WATT
import homeassistant.helpers.config_validation as cv
from homeass... |
from .const import DOMAIN
async def async_setup(hass, config):
"""Set up devices."""
hass.data[DOMAIN] = {}
return True
async def async_setup_entry(hass, entry):
"""Set up flood monitoring sensors for this config entry."""
hass.async_create_task(
hass.config_entries.async_forward_entry_... |
import datetime
from homeassistant.setup import async_setup_component
from tests.async_mock import patch
VALID_CONFIG_MINIMAL = {
"sensor": {"platform": "rmvtransport", "next_departure": [{"station": "3000010"}]}
}
VALID_CONFIG_NAME = {
"sensor": {
"platform": "rmvtransport",
"next_departur... |
import unittest
import argparse
from credstash import key_value_pair
class TestKeyValuePairExtraction(unittest.TestCase):
def test_key_value_pair_has_two_equals_test(self):
self.assertRaises(argparse.ArgumentTypeError, key_value_pair, "==")
def test_key_value_pair_has_zero_equals(self):
sel... |
import asyncio
from pathlib import Path
from typing import Any, Dict
import aiohttp
from hass_nabucasa.client import CloudClient as Interface
from homeassistant.components.alexa import (
errors as alexa_errors,
smart_home as alexa_sh,
)
from homeassistant.components.google_assistant import const as gc, smart... |
from __future__ import division
from builtins import zip
from builtins import range
import numpy as np
from .format_data import format_data as formatter
def procrustes(source, target, scaling=True, reflection=True, reduction=False,
oblique=False, oblique_rcond=-1, format_data=True):
"""
Func... |
from xknx.devices import Cover as XknxCover
from homeassistant.components.cover import (
ATTR_POSITION,
ATTR_TILT_POSITION,
DEVICE_CLASS_BLIND,
SUPPORT_CLOSE,
SUPPORT_OPEN,
SUPPORT_SET_POSITION,
SUPPORT_SET_TILT_POSITION,
SUPPORT_STOP,
CoverEntity,
)
from homeassistant.core import ... |
from collections import namedtuple
from contextlib import closing
import json
import gpsoauth
import httplib2 # included with oauth2client
import mechanicalsoup
import oauth2client
from oauth2client.client import OAuth2Credentials
import requests
from gmusicapi.exceptions import (
AlreadyLoggedIn, NotLoggedIn, ... |
import os.path as op
import numpy as np
import pytest
from mne import create_info
from mne.datasets import testing
from mne.io import RawArray, read_raw_fif
from mne.preprocessing import annotate_flat
data_path = testing.data_path(download=False)
skip_fname = op.join(data_path, 'misc', 'intervalrecording_raw.fif')
... |
from __future__ import division
from pygal.colors import (
darken, desaturate, hsl_to_rgb, lighten, parse_color, rgb_to_hsl, rotate,
saturate, unparse_color
)
def test_parse_color():
"""Test color parse function"""
assert parse_color('#123') == (17, 34, 51, 1., '#rgb')
assert parse_color('#cdf')... |
from django.utils.translation import gettext_lazy as _
from weblate.wladmin.models import WeblateModelAdmin
class PlanAdmin(WeblateModelAdmin):
list_display = (
"name",
"price",
"limit_strings",
"limit_languages",
"limit_projects",
"display_limit_strings",
... |
import logging
from homeassistant.components.media_player import BrowseError, BrowseMedia
from homeassistant.components.media_player.const import (
MEDIA_CLASS_ALBUM,
MEDIA_CLASS_ARTIST,
MEDIA_CLASS_CHANNEL,
MEDIA_CLASS_DIRECTORY,
MEDIA_CLASS_EPISODE,
MEDIA_CLASS_MOVIE,
MEDIA_CLASS_MUSIC,
... |
from __future__ import division
import unittest
import numpy as np
from chainer import testing
from chainercv.links.model.faster_rcnn import generate_anchor_base
class TestGenerateAnchorBase(unittest.TestCase):
def test_generaete_anchor_base(self):
gt = np.array(
[[-24., -120., 40., 136.... |
import subprocess
import sys
from flask_script import Manager, Command, Server as _Server, Option
from app import SQLAlchemyDB as db, socketio, app, __version__
import os
# import shutil
manager = Manager(app)
class Server(_Server):
help = description = 'Runs the Git-WebHook web server'
def get_options(se... |
import numpy as np
import unittest
from chainer.backends import cuda
from chainer import testing
from chainer.testing import attr
from chainercv.links.model.light_head_rcnn import LightHeadRCNNTrainChain
from chainercv.utils import generate_random_bbox
from tests.links_tests.model_tests.light_head_rcnn_tests.test_l... |
import asyncio
from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
from homeassistant.core import HomeAssistant
from .const import DOMAIN
PLATFORMS = ["light"]
async def async_setup(hass, config):
"""Set up the Zerproc platform."""
hass.async_create_task(
hass.config_entries.flow.a... |
import shutil
import pandas as pd
import pytest
from matchzoo import DataPack, load_data_pack
@pytest.fixture
def data_pack():
relation = [['qid0', 'did0', 1], ['qid1', 'did1', 0]]
left = [['qid0', [1, 2]], ['qid1', [2, 3]]]
right = [['did0', [2, 3, 4]], ['did1', [3, 4, 5]]]
relation = pd.DataFrame... |
import pytest
import arctic.serialization.numpy_records as anr
from tests.unit.serialization.serialization_test_data import _mixed_test_data as input_test_data
df_serializer = anr.DataFrameSerializer()
@pytest.mark.parametrize("input_df", input_test_data().keys())
def test_dataframe_confirm_fast_check_compatibilit... |
from homeassistant.components.advantage_air.const import DOMAIN
from homeassistant.const import CONF_IP_ADDRESS, CONF_PORT
from tests.common import MockConfigEntry, load_fixture
TEST_SYSTEM_DATA = load_fixture("advantage_air/getSystemData.json")
TEST_SET_RESPONSE = load_fixture("advantage_air/setAircon.json")
USER_... |
import logging
import attr
import tp_connected
from homeassistant.components.notify import ATTR_TARGET, BaseNotificationService
from homeassistant.const import CONF_RECIPIENT
from . import DATA_KEY
_LOGGER = logging.getLogger(__name__)
async def async_get_service(hass, config, discovery_info=None):
"""Get th... |
import voluptuous as vol
from homeassistant.const import CONF_HOST
from homeassistant.helpers import discovery
import homeassistant.helpers.config_validation as cv
DOMAIN = "mycroft"
CONFIG_SCHEMA = vol.Schema(
{DOMAIN: vol.Schema({vol.Required(CONF_HOST): cv.string})}, extra=vol.ALLOW_EXTRA
)
def setup(hass,... |
import asyncio
import functools
from functools import partial
import logging
import plexapi.exceptions
from plexapi.gdm import GDM
from plexwebsocket import (
SIGNAL_CONNECTION_STATE,
SIGNAL_DATA,
STATE_CONNECTED,
STATE_DISCONNECTED,
STATE_STOPPED,
PlexWebsocket,
)
import requests.exceptions
i... |
from datetime import datetime
import logging
import time
from nuheat.config import SCHEDULE_HOLD, SCHEDULE_RUN, SCHEDULE_TEMPORARY_HOLD
from nuheat.util import (
celsius_to_nuheat,
fahrenheit_to_nuheat,
nuheat_to_celsius,
nuheat_to_fahrenheit,
)
from homeassistant.components.climate import ClimateEnt... |
import pytest
from homeassistant.components.alarm_control_panel import DOMAIN as ALARM_DOMAIN
from homeassistant.const import (
ATTR_ENTITY_ID,
ATTR_FRIENDLY_NAME,
SERVICE_ALARM_ARM_AWAY,
SERVICE_ALARM_ARM_HOME,
SERVICE_ALARM_DISARM,
STATE_ALARM_ARMED_AWAY,
STATE_ALARM_ARMED_HOME,
STAT... |
import pytest
import voluptuous_serialize
import homeassistant.components.automation as automation
from homeassistant.components.climate import DOMAIN, const, device_action
from homeassistant.helpers import config_validation as cv, device_registry
from homeassistant.setup import async_setup_component
from tests.comm... |
import numpy as np
import chainer
from chainer.functions import average_pooling_2d
from chainer.functions import clipped_relu
from chainer.functions import softmax
from chainer.functions import squeeze
from chainercv.links.model.mobilenet.expanded_conv_2d import ExpandedConv2D
from chainercv.links.model.mobilenet.tf... |
import logging
from kiwiki import KiwiClient, KiwiException
import voluptuous as vol
from homeassistant.components.lock import PLATFORM_SCHEMA, LockEntity
from homeassistant.const import (
ATTR_ID,
ATTR_LATITUDE,
ATTR_LONGITUDE,
CONF_PASSWORD,
CONF_USERNAME,
STATE_LOCKED,
STATE_UNLOCKED,
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.