text stringlengths 213 32.3k |
|---|
from typing import Callable
import pysesame2
import voluptuous as vol
from homeassistant.components.lock import PLATFORM_SCHEMA, LockEntity
from homeassistant.const import (
ATTR_BATTERY_LEVEL,
CONF_API_KEY,
STATE_LOCKED,
STATE_UNLOCKED,
)
import homeassistant.helpers.config_validation as cv
from hom... |
import asyncio
from datetime import timedelta
import threading
import pytest
from homeassistant.const import ATTR_DEVICE_CLASS, STATE_UNAVAILABLE
from homeassistant.core import Context
from homeassistant.helpers import entity, entity_registry
from tests.async_mock import MagicMock, PropertyMock, patch
from tests.co... |
from datetime import timedelta
from functools import partial
import logging
import voluptuous as vol
from homeassistant.const import ( # noqa: F401 # STATE_PAUSED/IDLE are API
ATTR_BATTERY_LEVEL,
ATTR_COMMAND,
SERVICE_TOGGLE,
SERVICE_TURN_OFF,
SERVICE_TURN_ON,
STATE_IDLE,
STATE_ON,
S... |
import pytest
from homeassistant import config_entries
from homeassistant.components import dynalite
from tests.async_mock import AsyncMock, patch
from tests.common import MockConfigEntry
@pytest.mark.parametrize(
"first_con, second_con,exp_type, exp_result, exp_reason",
[
(True, True, "create_entr... |
import webbrowser
import voluptuous as vol
ATTR_URL = "url"
ATTR_URL_DEFAULT = "https://www.google.com"
DOMAIN = "browser"
SERVICE_BROWSE_URL = "browse_url"
SERVICE_BROWSE_URL_SCHEMA = vol.Schema(
{
# pylint: disable=no-value-for-parameter
vol.Required(ATTR_URL, default=ATTR_URL_DEFAULT): vol.... |
import re
import sys
import json
import time
import types
import logging
from pscript import (py2js, JSString, RawJS, JSConstant, create_js_module,
get_all_std_names)
from pscript.stdlib import FUNCTION_PREFIX, METHOD_PREFIX
from .. import event
from ..event import Component, Property, loop
f... |
import os
from stash.tests.stashtest import StashTestCase
class Md5sumTests(StashTestCase):
"""tests for the md5sum command."""
def setUp(self):
"""setup the tests"""
self.cwd = self.get_data_path()
StashTestCase.setUp(self)
def get_data_path(self):
"""return the data/ ... |
import argparse
import matplotlib.pyplot as plt
import chainer
from chainercv.datasets import coco_bbox_label_names
from chainercv.links import LightHeadRCNNResNet101
from chainercv import utils
from chainercv.visualizations import vis_bbox
def main():
parser = argparse.ArgumentParser()
parser.add_argument(... |
import pyvera as pv
from homeassistant.core import HomeAssistant
from .common import ComponentFactory, new_simple_controller_config
from tests.async_mock import MagicMock
async def test_cover(
hass: HomeAssistant, vera_component_factory: ComponentFactory
) -> None:
"""Test function."""
vera_device = M... |
from __future__ import division
import argparse
import numpy as np
import six
import chainer
from chainer.dataset.convert import _concat_arrays
from chainer.dataset.convert import to_device
from chainer.datasets import TransformDataset
from chainer.training import extensions
from chainer.training.triggers import Man... |
import logging
import voluptuous as vol
from zoneminder.monitor import TimePeriod
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import CONF_MONITORED_CONDITIONS
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.entity import Entity
from . import D... |
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import (
AREA_SQUARE_METERS,
CONF_MONITORED_CONDITIONS,
PERCENTAGE,
PRESSURE_INHG,
PRESSURE_MBAR,
TEMP_CELSIUS,
TEMP_FAHRENHEIT,
)
import homeassistant.helpers.config_validation as... |
__docformat__ = "restructuredtext en"
class Interface(object):
"""Base class for interfaces."""
def is_implemented_by(cls, instance):
return implements(instance, cls)
is_implemented_by = classmethod(is_implemented_by)
def implements(obj, interface):
"""Return true if the give object (maybe ... |
import logging
import voluptuous as vol
from homeassistant.components import frontend
from homeassistant.config import async_hass_config_yaml, async_process_component_config
from homeassistant.const import CONF_FILENAME
from homeassistant.core import callback
from homeassistant.exceptions import HomeAssistantError
f... |
from gitsweep.tests.testcases import (GitSweepTestCase, InspectorTestCase,
DeleterTestCase)
class TestDeleter(GitSweepTestCase, InspectorTestCase, DeleterTestCase):
"""
Can delete remote refs from a remote.
"""
def setUp(self):
super(TestDeleter, self).setUp()
for i in range(1,... |
from datetime import timedelta
from typing import Optional
import voluptuous as vol
from homeassistant.components import websocket_api
from homeassistant.components.http.auth import async_sign_path
from homeassistant.components.media_player.const import ATTR_MEDIA_CONTENT_ID
from homeassistant.components.media_playe... |
import plumbum
#from plumbum.colorlib import HTMLStyle, StyleFactory
#plumbum.colors = StyleFactory(HTMLStyle)
from plumbum import cli, colors
class MyApp(cli.Application):
PROGNAME = colors.green
VERSION = colors.blue | "1.0.2"
COLOR_GROUPS = {"Meta-switches" : colors.bold & colors.yellow}
opts = c... |
import re
import click
from molecule import logger
from molecule import util
from molecule.command import base
LOG = logger.get_logger(__name__)
class Idempotence(base.Base):
"""
Runs the converge step a second time. If no tasks will be marked as changed
the scenario will be considered idempotent.
... |
from unittest import mock
import contextlib
import shutil
import attr
from PyQt5.QtCore import pyqtSignal, QPoint, QProcess, QObject, QUrl
from PyQt5.QtGui import QIcon
from PyQt5.QtNetwork import (QNetworkRequest, QAbstractNetworkCache,
QNetworkCacheMetaData)
from PyQt5.QtWidgets import ... |
import itertools
import operator
from datetime import datetime as dt
import pytest
import six
from arctic.date import DateRange, string_to_daterange, CLOSED_CLOSED, CLOSED_OPEN, OPEN_CLOSED, OPEN_OPEN
test_ranges_for_bounding = {
"unbounded": (DateRange(),
None, None, True, Non... |
import logging
import voluptuous as vol
from homeassistant.components.switch import PLATFORM_SCHEMA, SwitchEntity
from homeassistant.const import ATTR_ATTRIBUTION, CONF_MONITORED_CONDITIONS
import homeassistant.helpers.config_validation as cv
from . import (
ALLOWED_WATERING_TIME,
ATTRIBUTION,
CONF_WATE... |
from django.shortcuts import get_object_or_404
from django.views.generic.base import RedirectView
from zinnia.models.entry import Entry
class EntryShortLink(RedirectView):
"""
View for handling the shortlink of an Entry,
simply do a redirection.
"""
permanent = True
def get_redirect_url(sel... |
import asyncio
import logging
import voluptuous as vol
from zigpy.config import CONF_DEVICE, CONF_DEVICE_PATH
from homeassistant import config_entries, const as ha_const
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.device_registry import CONNECTION_ZIGBEE
from homeassistant.helpers... |
import lemur_statsd as plug
from flask import current_app
from lemur.plugins.bases.metric import MetricPlugin
from datadog import DogStatsd
class StatsdMetricPlugin(MetricPlugin):
title = "Statsd"
slug = "statsd-metrics"
description = "Adds support for sending metrics to Statsd"
version = plug.VERSI... |
import logging
from collections import namedtuple
from datetime import datetime
from time import time as get_time
from kazoo.client import KazooClient
from kazoo.exceptions import NoNodeError
from paasta_tools.clusterman import get_clusterman_metrics
from paasta_tools.utils import load_system_paasta_config
from paas... |
import contextlib
import inspect
from io import StringIO
import re
import sys
import logging
import os.path as op
import warnings
from ..externals.decorator import FunctionMaker
logger = logging.getLogger('mne') # one selection here used across mne-python
logger.propagate = False # don't propagate (in case of mul... |
import os
import sys
# -- Path setup --------------------------------------------------------------
# sys.path.insert(0, os.path.abspath('.'))
# Our extension
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "_ext")))
# Weblate code
sys.path.append(os.path.abspath(os.path.join(os.path.dirname(... |
from __future__ import absolute_import
from __future__ import unicode_literals
import datetime
import typing
import six
from .pages import PageIterator
if typing.TYPE_CHECKING:
from typing import Any, Dict, List, Optional, Iterable, Set, Text
_I = typing.TypeVar('_I', bound='MediasIterator')
__all__ = [
... |
from cerberus import errors
from cerberus.tests import assert_fail, assert_success
def test_check_with_rule(validator):
def check_with_name(field, value, error):
if not value.islower():
error(field, 'must be lowercase')
validator.schema = {
'name': {'check_with': check_with_name}... |
from homeassistant import data_entry_flow
from homeassistant.components.totalconnect.const import DOMAIN
from homeassistant.config_entries import SOURCE_IMPORT, SOURCE_USER
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from tests.async_mock import patch
from tests.common import MockConfigEntry
USERNAM... |
from homeassistant import config_entries
from . import home_assistant_cast
from .const import DOMAIN
async def async_setup(hass, config):
"""Set up the Cast component."""
conf = config.get(DOMAIN)
hass.data[DOMAIN] = conf or {}
if conf is not None:
hass.async_create_task(
hass.... |
from __future__ import print_function
import os
import select
import socket
import struct
import sys
import time
import argparse
from six.moves import xrange
# On Windows, the best timer is time.clock()
# On most other platforms the best timer is time.time()
default_timer = time.clock if sys.platform == "win32" els... |
from django.core.exceptions import ObjectDoesNotExist
from django.http import HttpResponsePermanentRedirect
from django.template.defaultfilters import slugify
from django.views.generic.base import TemplateResponseMixin
from django.views.generic.base import View
import django_comments as comments
class CommentSucces... |
import sys
import time
from uuid import UUID
import pytest
from cherrypy._cpcompat import text_or_bytes
try:
# On Windows, msvcrt.getch reads a single char without output.
import msvcrt
def getchar():
return msvcrt.getch()
except ImportError:
# Unix getchr
import tty
import termios... |
import asyncio
from datetime import timedelta
from avri.api import Avri
from homeassistant.config_entries import ConfigEntry
from homeassistant.core import HomeAssistant
from .const import (
CONF_COUNTRY_CODE,
CONF_HOUSE_NUMBER,
CONF_HOUSE_NUMBER_EXTENSION,
CONF_ZIP_CODE,
DOMAIN,
)
PLATFORMS = ... |
import mock
from pyramid import testing
from paasta_tools.api.views import pause_autoscaler
def test_get_service_autoscaler_pause():
with mock.patch(
"paasta_tools.utils.KazooClient", autospec=True
) as mock_zk, mock.patch(
"paasta_tools.utils.load_system_paasta_config", autospec=True
):... |
import concurrent.futures
import logging
from multiprocessing import pool as pool_lib
import time
from absl import flags
from perfkitbenchmarker import configs
from perfkitbenchmarker import errors
from perfkitbenchmarker import vm_util
from perfkitbenchmarker.linux_packages import ycsb
from google.cloud import datas... |
from test import CollectorTestCase
from test import get_collector_config
from test import unittest
from mock import Mock
from mock import patch
try:
from cStringIO import StringIO
except ImportError:
from StringIO import StringIO
from diamond.collector import Collector
from proc import ProcessStatCollector
... |
from mlpatches import os_popen
from mlpatches.l2c import _get_str
def popen2(cmd, bufsize=0, mode="t"):
"""Executes cmd as a sub-process. Returns the file objects (child_stdout, child_stdin)."""
command = _get_str(cmd)
i, o = os_popen.popen2(None, command, mode, bufsize)
return o, i
def popen3(cmd,... |
import inspect
import marshal
import os
import struct
import sys
import types
from coverage import env
from coverage.backward import BUILTINS
from coverage.backward import PYC_MAGIC_NUMBER, imp, importlib_util_find_spec
from coverage.files import canonical_filename, python_reported_file
from coverage.misc import Cove... |
import mock
from pyramid import testing
from paasta_tools.api.views import autoscaler
from paasta_tools.kubernetes_tools import KubernetesDeploymentConfig
from paasta_tools.marathon_tools import MarathonServiceConfig
@mock.patch("paasta_tools.api.views.autoscaler.get_instance_config", autospec=True)
def test_get_au... |
from typing import List
import voluptuous as vol
from homeassistant.components.automation import AutomationActionType
from homeassistant.components.device_automation import TRIGGER_BASE_SCHEMA
from homeassistant.components.homeassistant.triggers import state as state_trigger
from homeassistant.const import (
CON... |
from datetime import timedelta
from bond_api import Action, DeviceType
from homeassistant import core
from homeassistant.components.switch import DOMAIN as SWITCH_DOMAIN
from homeassistant.const import ATTR_ENTITY_ID, SERVICE_TURN_OFF, SERVICE_TURN_ON
from homeassistant.helpers.entity_registry import EntityRegistry
... |
from pysmartthings import Attribute, Capability
from homeassistant.components.smartthings.const import DOMAIN, SIGNAL_SMARTTHINGS_UPDATE
from homeassistant.components.switch import (
ATTR_CURRENT_POWER_W,
ATTR_TODAY_ENERGY_KWH,
DOMAIN as SWITCH_DOMAIN,
)
from homeassistant.helpers.dispatcher import async_... |
import logging
from paasta_tools.cli.cmds.mark_for_deployment import NoSuchCluster
from paasta_tools.cli.cmds.mark_for_deployment import report_waiting_aborted
from paasta_tools.cli.cmds.mark_for_deployment import wait_for_deployment
from paasta_tools.cli.utils import lazy_choices_completer
from paasta_tools.cli.util... |
import os
import unittest
import numpy as np
import numpy.testing as np_test
import networkx as nx
from pgmpy.readwrite import BIFReader, BIFWriter
from pgmpy.models import BayesianModel
from pgmpy.factors.discrete import TabularCPD
class TestBIFReader(unittest.TestCase):
def setUp(self):
self.reader =... |
import builtins
import operator
from typing import Union
import numpy as np
# Vendored from NumPy 1.12; we need a version that support duck typing, even
# on dask arrays with __array_function__ enabled.
def _validate_axis(axis, ndim, argname):
try:
axis = [operator.index(axis)]
except TypeError:
... |
from django.contrib.sites.models import Site
from django.test import TestCase
from django.utils import timezone
import django_comments as comments
from zinnia.managers import PUBLISHED
from zinnia.models.entry import Entry
from zinnia.signals import connect_discussion_signals
from zinnia.signals import disconnect_di... |
import posixpath
from perfkitbenchmarker import linux_packages
# Use this directory for all data stored in the VM for this test.
PATH = '{0}/scimark2'.format(linux_packages.INSTALL_DIR)
# Download location for both the C and Java tests.
BASE_URL = 'https://math.nist.gov/scimark2'
# Java-specific constants.
JAVA_JAR... |
from datetime import timedelta
import logging
import voluptuous as vol
import whois
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import CONF_NAME, TIME_DAYS
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.entity import Entity
_LOGGER = logging.... |
from __future__ import print_function
import sys
from argparse import ArgumentParser
def main(args):
ap = ArgumentParser(description="Read and execute commands from a shell script in the current environment")
ap.add_argument('file', action="store", help='file to be sourced')
ap.add_argument('args', narg... |
from homeassistant.const import STATE_CLOSED
from .util import async_init_integration
async def test_create_covers(hass):
"""Test creation of covers."""
await async_init_integration(hass)
state = hass.states.get("cover.large_garage_door")
assert state.state == STATE_CLOSED
expected_attributes ... |
import pytest
from homeassistant.components.demo import DOMAIN
from homeassistant.components.lock import (
DOMAIN as LOCK_DOMAIN,
SERVICE_LOCK,
SERVICE_OPEN,
SERVICE_UNLOCK,
STATE_LOCKED,
STATE_UNLOCKED,
)
from homeassistant.const import ATTR_ENTITY_ID
from homeassistant.setup import async_set... |
from datetime import timedelta
from axis.event_stream import (
CLASS_INPUT,
CLASS_LIGHT,
CLASS_MOTION,
CLASS_OUTPUT,
CLASS_SOUND,
FenceGuard,
LoiteringGuard,
MotionGuard,
Vmd4,
)
from homeassistant.components.binary_sensor import (
DEVICE_CLASS_CONNECTIVITY,
DEVICE_CLASS_L... |
from pydeconz.sensor import (
Battery,
Consumption,
Daylight,
Humidity,
LightLevel,
Power,
Pressure,
Switch,
Temperature,
Thermostat,
)
from homeassistant.components.sensor import DOMAIN
from homeassistant.const import (
ATTR_TEMPERATURE,
ATTR_VOLTAGE,
DEVICE_CLASS_... |
import logging
from babelfish import Language, language_converters
from requests import Session
from . import Provider
from .. import __short_version__
from ..subtitle import Subtitle, fix_line_ending
logger = logging.getLogger(__name__)
language_converters.register('thesubdb = subliminal.converters.thesubdb:TheSu... |
import logging
import pytest
pytest.importorskip('PyQt5.QtWebEngineWidgets')
from qutebrowser.browser.webengine import webenginesettings
from qutebrowser.utils import usertypes
from qutebrowser.misc import objects
@pytest.fixture(autouse=True)
def init(qapp, config_stub, cache_tmpdir, data_tmpdir, monkeypatch):
... |
import threading
import os
from yandextank.common.util import get_test_path
from yandextank.core.tankcore import TankCore
from yandextank.core.tankworker import TankInfo
from yandextank.plugins.Telegraf import Plugin as TelegrafPlugin
class TestTelegrafPlugin(object):
def test_plugin_configuration(self):
... |
from homeassistant.components.homematicip_cloud.const import (
DOMAIN as HMIPC_DOMAIN,
HMIPC_AUTHTOKEN,
HMIPC_HAPID,
HMIPC_NAME,
HMIPC_PIN,
)
from tests.async_mock import patch
from tests.common import MockConfigEntry
DEFAULT_CONFIG = {HMIPC_HAPID: "ABC123", HMIPC_PIN: "123", HMIPC_NAME: "hmip"}
... |
import io
import os
import azure.storage.blob
from pytest import fixture
import smart_open
_AZURE_CONTAINER = os.environ.get('SO_AZURE_CONTAINER')
_AZURE_STORAGE_CONNECTION_STRING = os.environ.get('AZURE_STORAGE_CONNECTION_STRING')
_FILE_PREFIX = '%s://%s' % (smart_open.azure.SCHEME, _AZURE_CONTAINER)
assert _AZU... |
import bz2
import logging
import multiprocessing
import re
import signal
from pickle import PicklingError
# LXML isn't faster, so let's go with the built-in solution
from xml.etree.ElementTree import iterparse
from gensim import utils
# cannot import whole gensim.corpora, because that imports wikicorpus...
from gens... |
import datetime
from six import string_types
from ._generalslice import OPEN_OPEN, CLOSED_CLOSED, OPEN_CLOSED, CLOSED_OPEN, GeneralSlice
from ._parse import parse
INTERVAL_LOOKUP = {(True, True): OPEN_OPEN,
(False, False): CLOSED_CLOSED,
(True, False): OPEN_CLOSED,
... |
from . import html5
from .examples import examples
from lark import Lark
from lark.tree import Tree
class App(html5.Div):
def __init__(self):
super().__init__("""
<h1>
<img src="lark-logo.png"> IDE
</h1>
<main>
<menu>
<select [name]="examples">
<option disabled selected>Examples</option... |
from __future__ import annotations
import logging
from typing import Any, Dict, Optional
from sentry_sdk.utils import BadDsn, Dsn
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.core import callback
from .const import ( # pylint: disable=unused-import
CONF_DSN,
CONF_EN... |
from typing import Any
from homeassistant.components.scene import Scene
from . import LUTRON_CONTROLLER, LUTRON_DEVICES, LutronDevice
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the Lutron scenes."""
devs = []
for scene_data in hass.data[LUTRON_DEVICES]["scene"]:
... |
import numpy as np
from .fixes import rfft, irfft
from .utils import (sizeof_fmt, logger, get_config, warn, _explain_exception,
verbose)
_cuda_capable = False
def get_cuda_memory(kind='available'):
"""Get the amount of free memory for CUDA operations.
Parameters
----------
kin... |
from collections import deque
import random
import functools
import itertools
import logging
from collections import defaultdict
logger = logging.getLogger(__name__)
def blockedSample(sampler, sample_size, predicates, *args):
blocked_sample = set()
remaining_sample = sample_size - len(blocked_sample)
p... |
from collections import OrderedDict
import datetime
import time
from typing import MutableMapping, Optional, cast
import attr
from homeassistant.core import callback
from homeassistant.helpers.typing import HomeAssistantType
from homeassistant.loader import bind_hass
from .typing import ZhaDeviceType
DATA_REGISTRY... |
import voluptuous as vol
from homeassistant.const import (
CONF_API_KEY,
CONF_DEVICE_ID,
CONF_DEVICES,
CONF_NAME,
CONF_SCAN_INTERVAL,
CONF_TYPE,
)
from homeassistant.helpers import config_validation as cv
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from homeassista... |
from __future__ import division
from datetime import datetime, timedelta
import logging
import os
from guessit import guessit
from rebulk.loose import ensure_list
from subliminal.utils import matches_title
logger = logging.getLogger(__name__)
#: Video extensions
VIDEO_EXTENSIONS = ('.3g2', '.3gp', '.3gp2', '.3gpp'... |
import functools
import inspect
import itertools
import logging
import typing as T
import warnings
import pkg_resources
from .cfgrib_ import cfgrib_backend
from .common import BackendEntrypoint
from .h5netcdf_ import h5netcdf_backend
from .netCDF4_ import netcdf4_backend
from .pseudonetcdf_ import pseudonetcdf_backe... |
from pscript import window
from ... import event, app
from .._widget import Widget, create_element
# todo: some form of autocompletetion?
class BaseDropdown(Widget):
""" Base class for drop-down-like widgets.
"""
DEFAULT_MIN_SIZE = 50, 28
CSS = """
.flx-BaseDropdown {
displa... |
import json
import voluptuous as vol
from homeassistant.components.mqtt import valid_publish_topic, valid_subscribe_topic
from homeassistant.const import (
ATTR_SERVICE_DATA,
EVENT_CALL_SERVICE,
EVENT_STATE_CHANGED,
EVENT_TIME_CHANGED,
MATCH_ALL,
)
from homeassistant.core import EventOrigin, Stat... |
import types
import dbus
import dbus.service
def copy_func(function_reference, name=None):
"""
Copy function
:param function_reference: Function
:type function_reference: func
:param name: Name of function
:type name: str
:return: Copy of function
:rtype: func
"""
if hasatt... |
from datetime import timedelta
import pytest
from homeassistant.components.cover import (
ATTR_CURRENT_POSITION,
ATTR_CURRENT_TILT_POSITION,
ATTR_POSITION,
ATTR_TILT_POSITION,
DOMAIN,
)
from homeassistant.components.group.cover import DEFAULT_NAME
from homeassistant.const import (
ATTR_ASSUME... |
from datetime import timedelta
import logging
from agent import AgentError
from homeassistant.components.camera import SUPPORT_ON_OFF
from homeassistant.components.mjpeg.camera import (
CONF_MJPEG_URL,
CONF_STILL_IMAGE_URL,
MjpegCamera,
filter_urllib3_logging,
)
from homeassistant.const import ATTR_A... |
from datetime import timedelta
import logging
import socialbladeclient
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import CONF_NAME
from homeassistant.helpers import config_validation as cv
from homeassistant.helpers.entity import Entity
from homeassi... |
from homeassistant.const import TEMP_CELSIUS, VOLUME_CUBIC_METERS
from homeassistant.core import callback
from homeassistant.helpers.dispatcher import async_dispatcher_connect
from . import RainMachineEntity
from .const import (
DATA_CLIENT,
DATA_PROVISION_SETTINGS,
DATA_RESTRICTIONS_UNIVERSAL,
DOMAIN... |
from mock import patch
from paasta_tools.adhoc_tools import AdhocJobConfig
from paasta_tools.adhoc_tools import load_adhoc_job_config
from paasta_tools.marathon_tools import load_marathon_service_config
from paasta_tools.marathon_tools import MarathonServiceConfig
from paasta_tools.paasta_service_config_loader import... |
import pandas as pd
from scipy.stats import rankdata
from scattertext.Scalers import scale
from scattertext.frequencyreaders.DefaultBackgroundFrequencies import DefaultBackgroundFrequencies
from scattertext.termranking import AbsoluteFrequencyRanker
from scattertext.termscoring.RankDifference import RankDifference
... |
import numpy as np
def rotate_bbox(bbox, angle, size):
"""Rotate bounding boxes by degrees.
Args:
bbox (~numpy.ndarray): See the table below.
angle (float): Counter clock-wise rotation angle (degree).
image is rotated by 90 degrees.
size (tuple): A tuple of length 2. The ... |
import sys
import tempfile
import itertools
import textwrap
import unittest.mock
import types
import mimetypes
import os.path
import attr
import pytest
import py.path # pylint: disable=no-name-in-module
from PyQt5.QtCore import QSize, Qt
from PyQt5.QtWidgets import QWidget, QHBoxLayout, QVBoxLayout
from PyQt5.QtNetw... |
import asyncio
from datetime import timedelta
import json
import logging
import aiohttp
import async_timeout
import voluptuous as vol
from homeassistant.components.sensor import PLATFORM_SCHEMA
from homeassistant.const import ATTR_ATTRIBUTION, CONF_NAME, CONF_OFFSET
from homeassistant.helpers.aiohttp_client import a... |
import contextlib
import socket
import threading
import queue
import webbrowser
import six
import pkg_resources
class UserAgentRequestHandler(six.moves.BaseHTTPServer.BaseHTTPRequestHandler):
def do_GET(self):
"""Serve a GET request."""
self.do_HEAD()
template = pkg_resources.resource_st... |
def get_context_first_matching_object(context, context_lookups):
"""
Return the first object found in the context,
from a list of keys, with the matching key.
"""
for key in context_lookups:
context_object = context.get(key)
if context_object:
return key, context_object
... |
import cherrypy
from cherrypy import _json as json
from cherrypy._cpcompat import text_or_bytes, ntou
def json_processor(entity):
"""Read application/json data into request.json."""
if not entity.headers.get(ntou('Content-Length'), ntou('')):
raise cherrypy.HTTPError(411)
body = entity.fp.read()... |
import pytest
from arctic.tickstore import tickstore
from arctic.tickstore import toplevel
def pytest_generate_tests(metafunc):
if 'tickstore_lib' in metafunc.fixturenames:
metafunc.parametrize("tickstore_lib", ['tickstore'], indirect=True)
@pytest.fixture(scope='function')
def tickstore_lib(arctic, r... |
from __future__ import absolute_import, unicode_literals
import os
import pytest
import kaptan
from tmuxp import config
from .fixtures import config_teamocil as fixtures
TMUXP_DIR = os.path.join(os.path.dirname(__file__), '.tmuxp')
@pytest.mark.parametrize(
"teamocil_yaml,teamocil_dict,tmuxp_dict",
[
... |
import pickle
from mne.utils import BunchConstNamed
from mne.utils._bunch import NamedInt, NamedFloat
def test_pickle():
"""Test if BunchConstNamed object can be pickled."""
b1 = BunchConstNamed()
b1.x = 1
b1.y = 2.12
assert isinstance(b1.x, int)
assert isinstance(b1.x, NamedInt)
assert r... |
import logging
from miio import DeviceException, gateway
from homeassistant.helpers.entity import Entity
from .const import DOMAIN
_LOGGER = logging.getLogger(__name__)
class ConnectXiaomiGateway:
"""Class to async connect to a Xiaomi Gateway."""
def __init__(self, hass):
"""Initialize the entit... |
from homeassistant.helpers.update_coordinator import CoordinatorEntity
from .const import DOMAIN
class AdvantageAirEntity(CoordinatorEntity):
"""Parent class for Advantage Air Entities."""
def __init__(self, instance, ac_key, zone_key=None):
"""Initialize common aspects of an Advantage Air sensor."... |
from asyncio import gather
from typing import Any, Optional
from async_timeout import timeout
from python_awair import Awair
from python_awair.exceptions import AuthError
from homeassistant.const import CONF_ACCESS_TOKEN
from homeassistant.core import Config, HomeAssistant
from homeassistant.exceptions import Config... |
from datetime import timedelta
import logging
from clearpasspy import ClearPass
import voluptuous as vol
from homeassistant.components.device_tracker import (
DOMAIN,
PLATFORM_SCHEMA,
DeviceScanner,
)
from homeassistant.const import CONF_API_KEY, CONF_CLIENT_ID, CONF_HOST
import homeassistant.helpers.con... |
import logging
from scsgate.messages import ScenarioTriggeredMessage, StateMessage
from scsgate.tasks import ToggleStatusTask
import voluptuous as vol
from homeassistant.components.switch import PLATFORM_SCHEMA, SwitchEntity
from homeassistant.const import ATTR_ENTITY_ID, ATTR_STATE, CONF_DEVICES, CONF_NAME
import h... |
from abc import abstractmethod
from datetime import timedelta
import functools as ft
import logging
from typing import Any, Dict, List, Optional
import voluptuous as vol
from homeassistant.const import (
ATTR_TEMPERATURE,
PRECISION_TENTHS,
PRECISION_WHOLE,
SERVICE_TURN_OFF,
SERVICE_TURN_ON,
S... |
import pytest
from cryptography import x509
from cryptography.hazmat.backends import default_backend
from cryptography.hazmat.primitives import serialization, hashes
from cryptography.x509 import UniformResourceIdentifier
from lemur.certificates.verify import verify_string, crl_verify
from lemur.utils import mktempfi... |
import os
from os import path as op
import shutil
import zipfile
import sys
import pytest
from mne import datasets, read_labels_from_annot, write_labels_to_annot
from mne.datasets import testing
from mne.datasets._fsaverage.base import _set_montage_coreg_path
from mne.datasets.utils import _manifest_check_download
... |
import logging
import requests
from homeassistant.components.binary_sensor import (
DEVICE_CLASS_POWER,
BinarySensorEntity,
)
from homeassistant.const import CONF_DEVICE_CLASS, CONF_NAME
from . import (
DOMAIN as VICARE_DOMAIN,
PYVICARE_ERROR,
VICARE_API,
VICARE_HEATING_TYPE,
VICARE_NAME... |
import argparse
import sys
import time
from kazoo.client import KazooClient
from service_configuration_lib import DEFAULT_SOA_DIR
from paasta_tools.deployd.common import ServiceInstance
from paasta_tools.deployd.queue import ZKDelayDeadlineQueue
from paasta_tools.utils import load_system_paasta_config
from paasta_to... |
import hangups
from common import run_example
async def retrieve_suggested_contacts(client, _):
request = hangups.hangouts_pb2.GetSuggestedEntitiesRequest(
request_header=client.get_request_header(),
max_count=100,
)
res = await client.get_suggested_entities(request)
# Print the lis... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.