text stringlengths 213 32.3k |
|---|
import logging
from homeassistant.const import (
ATTR_ATTRIBUTION,
ATTR_LATITUDE,
ATTR_LONGITUDE,
CONF_SHOW_ON_MAP,
)
from homeassistant.core import callback
from homeassistant.helpers.dispatcher import async_dispatcher_connect
from homeassistant.helpers.entity import Entity
from . import (
DATA_... |
import gzip
import lzma
import bz2
import io
import builtins
WRITE_MODE = "wt"
class ReusableFile(object):
"""
Class which emulates the builtin file except that calling iter() on it will return separate
iterators on different file handlers (which are automatically closed when iteration stops). This
... |
import aiounifi
from homeassistant import data_entry_flow
from homeassistant.components.unifi.const import (
CONF_ALLOW_BANDWIDTH_SENSORS,
CONF_ALLOW_UPTIME_SENSORS,
CONF_BLOCK_CLIENT,
CONF_CONTROLLER,
CONF_DETECTION_TIME,
CONF_IGNORE_WIRED_BUG,
CONF_POE_CLIENTS,
CONF_SITE_ID,
CONF... |
import pytest
from PyQt5.QtCore import QUrl
from qutebrowser.misc import httpclient, pastebin
@pytest.fixture
def pbclient(stubs):
http_stub = stubs.HTTPPostStub()
client = pastebin.PastebinClient(http_stub)
return client
def test_constructor(qapp):
http_client = httpclient.HTTPClient()
pasteb... |
import unittest
import pandas as pd
class TestPandas(unittest.TestCase):
def test_read_csv(self):
data = pd.read_csv("/input/tests/data/train.csv")
self.assertEqual(100, len(data.index))
def test_read_feather(self):
data = pd.read_feather("/input/tests/data/feather-0_3_1.feather... |
import logging
import voluptuous as vol
from homeassistant.components.media_player import MediaPlayerEntity
from homeassistant.components.media_player.const import (
SUPPORT_BROWSE_MEDIA,
SUPPORT_NEXT_TRACK,
SUPPORT_PAUSE,
SUPPORT_PLAY,
SUPPORT_PLAY_MEDIA,
SUPPORT_PREVIOUS_TRACK,
SUPPORT_... |
import logging
from uuid import uuid4
from .const import (
API_CONTEXT,
API_DIRECTIVE,
API_ENDPOINT,
API_EVENT,
API_HEADER,
API_PAYLOAD,
API_SCOPE,
)
from .entities import ENTITY_ADAPTERS
from .errors import AlexaInvalidEndpointError
_LOGGER = logging.getLogger(__name__)
class AlexaDire... |
import numpy as np
from scipy import linalg
from .. import pick_types
from ..utils import _validate_type, _ensure_int, _check_preload
from ..io import BaseRaw
from ..io.constants import FIFF
from ..epochs import BaseEpochs
from ..evoked import Evoked
from ..bem import fit_sphere_to_headshape
from ..channels.interpol... |
import datetime
import json
import logging
from absl import flags
from perfkitbenchmarker import errors
from perfkitbenchmarker import linux_packages
from perfkitbenchmarker import object_storage_service
from perfkitbenchmarker import vm_util
from perfkitbenchmarker.providers import azure
from perfkitbenchmarker.provi... |
from django.utils.translation import gettext as _
from django.views.generic.list import ListView
from zinnia.models.entry import Entry
from zinnia.settings import PAGINATION
from zinnia.views.mixins.prefetch_related import PrefetchCategoriesAuthorsMixin
class BaseEntrySearch(object):
"""
Mixin providing the... |
import click
from flask.cli import with_appcontext
from flask_migrate import init as _init
from flask_migrate import revision as _revision
from flask_migrate import migrate as _migrate
from flask_migrate import edit as _edit
from flask_migrate import merge as _merge
from flask_migrate import upgrade as _upgrade
from f... |
import sys
import unittest
from unittest.mock import patch
from ReText.editor import ReTextEdit
from ReText.editor import documentIndentMore, documentIndentLess
from PyQt5.QtGui import QImage, QTextCursor, QTextDocument, QKeyEvent
from PyQt5.QtCore import Qt, QMimeData, QEvent
from PyQt5.QtWidgets import QApplication... |
from django.core import exceptions
from django.core.cache import cache
from django.template import TemplateDoesNotExist
from django.template.loader import select_template
from django.utils.html import strip_spaces_between_tags
from django.utils.safestring import mark_safe, SafeText
from django.utils.translation import... |
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 *... |
import os
import re
import roslib.packages
import roslib.stack_manifest
import rospkg
ROS_ROOT = rospkg.environment.ROS_ROOT
ROS_PACKAGE_PATH = rospkg.environment.ROS_PACKAGE_PATH
STACK_FILE = 'stack.xml'
ROS_STACK = 'ros'
class ROSStackException(Exception):
pass
class InvalidROSStackException(ROSStackExce... |
import logging
from aiohue.sensors import TYPE_ZGP_SWITCH, TYPE_ZLL_ROTARY, TYPE_ZLL_SWITCH
from homeassistant.const import CONF_EVENT, CONF_ID, CONF_UNIQUE_ID
from homeassistant.core import callback
from homeassistant.util import slugify
from .sensor_device import GenericHueDevice
_LOGGER = logging.getLogger(__na... |
import argparse
import io
import itertools
import logging
import sys
from contextlib import redirect_stdout
from typing import Mapping
from typing import MutableSequence
from typing import Optional
from typing import Sequence
from typing import Tuple
import a_sync
from marathon.exceptions import MarathonError
from my... |
import logging
from pyxeoma.xeoma import Xeoma, XeomaError
import voluptuous as vol
from homeassistant.components.camera import PLATFORM_SCHEMA, Camera
from homeassistant.const import CONF_HOST, CONF_NAME, CONF_PASSWORD, CONF_USERNAME
from homeassistant.helpers import config_validation as cv
_LOGGER = logging.getLo... |
from scattertext.indexstore import IndexStore
class IndexStoreFromDict(object):
@staticmethod
def build(term_to_index_dict):
'''
Parameters
----------
term_to_index_dict: term -> idx dictionary
Returns
-------
IndexStore
'''
idxstore = IndexStore()
idxstore._val2i = term_to_index_dict
idxsto... |
from unittest import TestCase
import numpy as np
from scattertext.termsignificance import LogOddsRatioUninformativeDirichletPrior
from scattertext.termsignificance.LogOddsRatioUninformativeDirichletPrior import z_to_p_val
from scattertext.test.test_termDocMatrixFactory import build_hamlet_jz_term_doc_mat
class Tes... |
__docformat__ = "restructuredtext en"
import os
import errno
import signal
import sys
import time
import warnings
from six.moves import range
def setugid(user):
"""Change process user and group ID
Argument is a numeric user id or a user name"""
try:
from pwd import getpwuid
passwd = get... |
import csv
from datetime import datetime, timedelta
import gzip
import json
import logging
import os
from aiohttp.hdrs import USER_AGENT
import pytz
import requests
import voluptuous as vol
from homeassistant.const import (
AREA_SQUARE_METERS,
ATTR_ATTRIBUTION,
CONF_LATITUDE,
CONF_LONGITUDE,
CONF... |
import os.path
import re
import textwrap
from coverage import env
from coverage.phystokens import source_token_lines, source_encoding
from coverage.phystokens import neuter_encoding_declaration, compile_unicode
from coverage.python import get_python_source
from tests.coveragetest import CoverageTest, TESTS_DIR
# A... |
import os
from functools import reduce
from uuid import uuid4
from pygal._compat import is_list_like
from pygal.adapters import decimal_to_float, not_zero, positive
from pygal.config import Config, SerieConfig
from pygal.serie import Serie
from pygal.state import State
from pygal.svg import Svg
from pygal.util import... |
import os
import unittest
import mock
from docker_registry.lib import config
fakeenv = {}
def mockget(key, opt=None):
if key in fakeenv:
print('%s key is %s' % (key, fakeenv[key]))
return fakeenv[key]
return opt
@mock.patch('os.environ.get', mockget)
class TestConfig(unittest.TestCase):... |
from datetime import datetime
import json
import logging
from sqlalchemy import (
Boolean,
Column,
DateTime,
ForeignKey,
Index,
Integer,
String,
Text,
distinct,
)
from sqlalchemy.ext.declarative import declarative_base
from homeassistant.core import Event, EventOrigin, State, spli... |
import urwid
class PopUpDialog(urwid.WidgetWrap):
"""A dialog that appears with nothing but a close button """
signals = ['close']
def __init__(self):
close_button = urwid.Button("that's pretty cool")
urwid.connect_signal(close_button, 'click',
lambda button:self._emit("close")... |
import os
import unittest
import mock
from Tests.utils.utils import get_test_path
from kalliope.core.Cortex import Cortex
from kalliope.core.Models import Singleton
from kalliope.core.Models.settings.Tts import Tts
from kalliope import SettingLoader
from kalliope.core.NeuronModule import NeuronModule, TemplateFileNo... |
import six
from chainer import testing
def parameterize(*params):
""":func:`chainer.testing.parameterize` for `pytest-xdist`.
:func:`chainer.testing.parameterize` cannot work with `pytest-xdist`
when the params contain functions (lambdas), classes, and random values.
This wrapper replaces the param... |
import json
import unittest
import mock
from Tests.test_api.base import RestAPITestBase
from kalliope.core.Cortex import Cortex
class TestSynapseView(RestAPITestBase):
def test_get_all_synapses(self):
url = self.get_server_url() + "/synapses"
response = self.client.get(url)
expected_c... |
from time import sleep
from django.contrib.auth.models import AnonymousUser
from django.contrib.messages.storage import default_storage
from django.contrib.sessions.backends.signed_cookies import SessionStore
from django.http.request import HttpRequest
from django.test import SimpleTestCase
from django.test.utils imp... |
import sys
from subprocess import Popen, PIPE
from collections import defaultdict
from boto3 import resource
import credstash
def main():
UPDATED_DIGEST = 'SHA256'
DIGESTS_TO_UPDATE = ['WHIRLPOOL', 'RIPEMD']
keys = defaultdict(lambda:0)
keys_to_update = []
dynamodb_resource = resource('dynamodb... |
from django.conf import settings
from django.db import models
from django.db.models import Q
from django.utils.translation import gettext_lazy as _
from post_office.models import EmailTemplate
from filer.fields.file import FilerFileField
from shop.conf import app_settings
from shop.models.fields import ChoiceEnum, Cho... |
from distutils.version import LooseVersion
import numpy as np
import pytest
from numpy.testing import assert_array_almost_equal
from mne.time_frequency import psd_multitaper
from mne.time_frequency.multitaper import dpss_windows
from mne.utils import requires_nitime
from mne.io import RawArray
from mne import create... |
import itertools
import json
import sys
from collections import defaultdict
from datetime import datetime
def get_datetime_from_ts(ts):
tformat = "%Y-%m-%dT%H:%M:%S.%f"
return datetime.strptime(ts, tformat)
def get_deploy_durations_from_file(filename):
"""
filename: path to a file to be parsed for ... |
from contextlib import contextmanager
import logging
import sys
import threading
try:
import colorlog
except ImportError:
colorlog = None
DEBUG = 'debug'
INFO = 'info'
WARNING = 'warning'
ERROR = 'error'
LOG_LEVELS = {
DEBUG: logging.DEBUG,
INFO: logging.INFO,
WARNING: logging.WARNING,
ERROR: lo... |
import urwid
def main():
urwid.set_encoding('utf8')
term = urwid.Terminal(None, encoding='utf-8')
mainframe = urwid.LineBox(
urwid.Pile([
('weight', 70, term),
('fixed', 1, urwid.Filler(urwid.Edit('focus test edit: '))),
]),
)
def set_title(widget, title):... |
from collections import OrderedDict
import pytest
from homeassistant.components.config import entity_registry
from homeassistant.const import ATTR_ICON
from homeassistant.helpers.entity_registry import RegistryEntry
from tests.common import MockEntity, MockEntityPlatform, mock_registry
@pytest.fixture
def client(... |
import mock
from paasta_tools import generate_deployments_for_service
from paasta_tools.marathon_tools import MarathonServiceConfig
def test_get_deploy_group_mappings():
fake_service = "fake_service"
fake_soa_dir = "/no/yes/maybe"
fake_service_configs = [
MarathonServiceConfig(
serv... |
import json
from weblate.memory.models import Memory
from weblate.utils.management.base import BaseCommand
class Command(BaseCommand):
"""Command for exporting translation memory."""
help = "exports translation memory in JSON format"
def add_arguments(self, parser):
super().add_arguments(parse... |
import os
YUM_PACKAGES = ('bc gengetopt libevent-devel '
'google-perftools-devel scons')
APT_PACKAGES = ('bc gengetopt libevent-dev '
'libgoogle-perftools-dev scons')
OLDISIM_GIT = 'https://github.com/GoogleCloudPlatform/oldisim.git'
OLDISIM_DIR = 'oldisim'
OLDISIM_VERSION = 'v0.1'
BI... |
from .common import setup_platform
WIFI_ENABLED = False
async def test_sensor(hass, requests_mock):
"""Test the Ring sensors."""
await setup_platform(hass, "sensor")
front_battery_state = hass.states.get("sensor.front_battery")
assert front_battery_state is not None
assert front_battery_state.s... |
import logging
import requests
import voluptuous as vol
from homeassistant.components.cover import PLATFORM_SCHEMA, CoverEntity
from homeassistant.const import (
CONF_ACCESS_TOKEN,
CONF_COVERS,
CONF_DEVICE,
CONF_NAME,
CONF_PASSWORD,
CONF_USERNAME,
STATE_CLOSED,
STATE_OPEN,
)
import ho... |
import os
import re
try:
from rfc822 import Message
except ImportError:
# Python 3
from email import message_from_file as Message
import unittest
from lxml.tests.common_imports import doctest
from lxml.doctestcompare import LHTMLOutputChecker
from lxml.html.clean import clean, Cleaner
feed_dirs = [
o... |
from typing import Any, Awaitable, Callable, Dict, Optional, Union
from homeassistant import config_entries
from .typing import HomeAssistantType
DiscoveryFunctionType = Callable[[], Union[Awaitable[bool], bool]]
class DiscoveryFlowHandler(config_entries.ConfigFlow):
"""Handle a discovery config flow."""
... |
import base64
import binascii
import enum
from typing import cast, Optional
from PyQt5.QtWidgets import QWidget
from PyQt5.QtCore import pyqtSignal, pyqtSlot, QObject, QEvent
from PyQt5.QtGui import QCloseEvent
from qutebrowser.browser import eventfilter
from qutebrowser.config import configfiles
from qutebrowser.ut... |
from flexx import flx
# Prepare data array, preferably using Numpy
try:
import numpy as np
data_array = np.random.normal(0, 1, 1000)
except ImportError:
# Fallback to ctypes when numpy is not available
import random
import ctypes
from flexx.app import bsdf_lite
# Create data array
d... |
from __future__ import division
import math
import numpy as np
def tile_images(imgs, n_col, pad=2, fill=0):
"""Make a tile of images
Args:
imgs (numpy.ndarray): A batch of images whose shape is BCHW.
n_col (int): The number of columns in a tile.
pad (int or tuple of two ints): :obj:... |
import os.path as op
import numpy as np
import pytest
from numpy.testing import assert_allclose
from mne.datasets import testing
from mne.io import read_raw_fif
from mne.preprocessing import regress_artifact, create_eog_epochs
data_path = testing.data_path(download=False)
raw_fname = op.join(data_path, 'MEG', 'samp... |
import urwid
palette = [('I say', 'default,bold', 'default', 'bold'),]
ask = urwid.Edit(('I say', u"What is your name?\n"))
reply = urwid.Text(u"")
button = urwid.Button(u'Exit')
div = urwid.Divider()
pile = urwid.Pile([ask, div, reply, div, button])
top = urwid.Filler(pile, valign='top')
def on_ask_change(edit, new... |
from typing import List, Optional
from aioesphomeapi import (
ClimateAction,
ClimateFanMode,
ClimateInfo,
ClimateMode,
ClimateState,
ClimateSwingMode,
)
from homeassistant.components.climate import ClimateEntity
from homeassistant.components.climate.const import (
ATTR_HVAC_MODE,
ATTR... |
class Synapse(object):
"""
This Class is representing a Synapse with its name, and a dict of Neurons and a dict of signals
.. note:: must be defined in the brain.yml
"""
def __init__(self, name=None, neurons=None, signals=None, enabled=True):
self.name = name
self.neurons = neuron... |
from __future__ import print_function
from __future__ import absolute_import
from hyperopt import Trials, rand
from hyperas.ensemble import VotingModel
from hyperas.optim import get_hyperopt_model_string, base_minimizer
import numpy as np
from keras.models import model_from_yaml
import six.moves.cPickle as pickle
from... |
from unittest import TestCase
from django.test.utils import override_settings
from weblate.lang.models import Language
from weblate.trans.specialchars import get_special_chars
class SpecialCharsTest(TestCase):
def check_chars(self, language, count, matches, *args, **kwargs):
result = get_special_chars(... |
from copy import copy
from django.conf import settings
from django.db import models, transaction
from django.db.models import Q, Sum
from django.utils.translation import gettext as _
from weblate.checks.models import CHECKS, Check
from weblate.trans.mixins import UserDisplayMixin
from weblate.trans.models.change imp... |
import unittest
import mock
from perfkitbenchmarker.providers.gcp import gcp_bigtable
from perfkitbenchmarker.providers.gcp import util
from tests import pkb_common_test_case
NAME = 'testcluster'
PROJECT = 'testproject'
ZONE = 'testzone'
VALID_JSON_BASE = """[
{{
"displayName": "not{name}",
"name": ... |
import datetime
import hashlib
from homeassistant.components.asterisk_mbox import (
DOMAIN as ASTERISK_DOMAIN,
SIGNAL_CDR_UPDATE,
)
from homeassistant.components.mailbox import Mailbox
from homeassistant.core import callback
from homeassistant.helpers.dispatcher import async_dispatcher_connect
MAILBOX_NAME =... |
import numpy as np
from numpy.testing import assert_array_almost_equal
from mne.connectivity import phase_slope_index
def test_psi():
"""Test Phase Slope Index (PSI) estimation."""
sfreq = 50.
n_signals = 3
n_epochs = 10
n_times = 500
rng = np.random.RandomState(42)
data = rng.randn(n_ep... |
from zeroconf import (
BadTypeInNameException,
InterfaceChoice,
IPVersion,
ServiceInfo,
ServiceStateChange,
)
from homeassistant.components import zeroconf
from homeassistant.components.zeroconf import CONF_DEFAULT_INTERFACE, CONF_IPV6
from homeassistant.const import (
EVENT_HOMEASSISTANT_STAR... |
from datetime import timedelta
import pytest
import homeassistant.components.automation as automation
from homeassistant.const import ATTR_ENTITY_ID, SERVICE_TURN_OFF
from homeassistant.setup import async_setup_component
import homeassistant.util.dt as dt_util
from tests.async_mock import Mock, patch
from tests.com... |
from chainer.backends import cuda
import numpy as np
def mask_to_bbox(mask):
"""Compute the bounding boxes around the masked regions.
This function accepts both :obj:`numpy.ndarray` and :obj:`cupy.ndarray` as
inputs.
Args:
mask (array): An array whose shape is :math:`(R, H, W)`.
... |
def get_manager(client, hostname=None, port=None, userid=None,
password=None):
"""Get pyrabbit manager."""
import pyrabbit
opt = client.transport_options.get
def get(name, val, default):
return (val if val is not None
else opt('manager_%s' % name) or
... |
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import logging
import os
from absl import flags
from perfkitbenchmarker import events
from perfkitbenchmarker import sample
from perfkitbenchmarker import vm_util
from perfkitbenchmarker.traces import base_col... |
from functools import partial
import logging
import voluptuous as vol
import wakeonlan
from homeassistant.const import CONF_BROADCAST_ADDRESS, CONF_BROADCAST_PORT, CONF_MAC
import homeassistant.helpers.config_validation as cv
_LOGGER = logging.getLogger(__name__)
DOMAIN = "wake_on_lan"
SERVICE_SEND_MAGIC_PACKET =... |
from cerberus import errors
from cerberus.tests import assert_fail, assert_success
def test_schema(validator):
field = 'a_dict'
subschema_field = 'address'
assert_success({field: {subschema_field: 'i live here', 'city': 'in my own town'}})
assert_fail(
schema={
field: {
... |
from __future__ import print_function
import sys
import argparse
def main(args):
ap = argparse.ArgumentParser()
ap.add_argument('expr', nargs='?', help='name=value')
ns = ap.parse_args(args)
app = globals()['_stash']
""":type : StaSh"""
_, current_state = app.runtime.get_current_worker_an... |
import logging
from homeassistant.core import callback
from homeassistant.helpers.dispatcher import async_dispatcher_send
from .const import (
ATTR_EVENT_TYPE,
ATTR_FACE_URL,
ATTR_ID,
ATTR_IS_KNOWN,
ATTR_NAME,
ATTR_PERSONS,
DATA_PERSONS,
DEFAULT_PERSON,
DOMAIN,
NETATMO_EVENT,
... |
import numpy as np
import jax.numpy as jnp
from jax import config
import tensorflow as tf
import torch
import pytest
import tensornetwork
from tensornetwork.block_sparse.charge import charge_equal
from tensornetwork import backends
config.update("jax_enable_x64", True)
np_real = [np.float32, np.float64]
np_complex = ... |
import time
from kazoo.exceptions import NoNodeError
from pyramid.view import view_config
from paasta_tools.api.views.exception import ApiFailure
from paasta_tools.long_running_service_tools import ZK_PAUSE_AUTOSCALE_PATH
from paasta_tools.utils import ZookeeperPool
@view_config(
route_name="service_autoscaler... |
import asyncio
from datetime import timedelta
from functools import partial
import logging
from amcrest import AmcrestError
from haffmpeg.camera import CameraMjpeg
import voluptuous as vol
from homeassistant.components.camera import (
CAMERA_SERVICE_SCHEMA,
SUPPORT_ON_OFF,
SUPPORT_STREAM,
Camera,
)
f... |
import json
from pathlib import Path
from typing import Set
import attr
from .const import COMPONENT_DIR, TESTS_DIR
@attr.s
class Info:
"""Info about new integration."""
domain: str = attr.ib()
name: str = attr.ib()
is_new: bool = attr.ib()
codeowner: str = attr.ib(default=None)
requiremen... |
from rest_framework import serializers
from shop.conf import app_settings
from shop.models.delivery import DeliveryModel, DeliveryItemModel
from shop.modifiers.pool import cart_modifiers_pool
class DeliveryItemSerializer(serializers.ModelSerializer):
class Meta:
model = DeliveryItemModel
exclude ... |
import unittest
from optional_django import six
import mock
from react.conf import Conf
from react import render_server
from react.render import render_component
from react.render_server import RenderedComponent
from react.exceptions import ReactRenderingError, ComponentSourceFileNotFound
from .settings import Compone... |
import numpy as np
from tensornetwork import (connect, contract, contract_between,
flatten_edges_between, Node)
import torch
def test_basic_graphmode():
a = Node(torch.ones(10), backend="pytorch")
b = Node(torch.ones(10), backend="pytorch")
e = connect(a[0], b[0])
actual = contract... |
from datetime import timedelta
import logging
import voluptuous as vol
from homeassistant.const import (
DEVICE_CLASS_BATTERY,
DEVICE_CLASS_CURRENT,
DEVICE_CLASS_ENERGY,
DEVICE_CLASS_HUMIDITY,
DEVICE_CLASS_ILLUMINANCE,
DEVICE_CLASS_POWER,
DEVICE_CLASS_POWER_FACTOR,
DEVICE_CLASS_PRESSU... |
import numpy as np
import pandas as pd
import pytest
import xarray as xr
from xarray.core.groupby import _consolidate_slices
from . import assert_allclose, assert_equal, assert_identical, raises_regex
@pytest.fixture
def dataset():
ds = xr.Dataset(
{"foo": (("x", "y", "z"), np.random.randn(3, 4, 2))},
... |
from __future__ import print_function
import argparse
import string
import sys
import fileinput
def filter_non_printable(s):
return ''.join([c if c.isalnum() or c.isspace() or c in string.punctuation else ' ' for c in s])
def head(f, nlines):
if nlines >= 0:
for i, line in enumerate(f):
... |
from __future__ import absolute_import
import unittest
import logging
import os
import codecs
from lark import logger
from lark.tools.nearley import create_code_for_nearley_grammar, main as nearley_tool_main
logger.setLevel(logging.INFO)
TEST_PATH = os.path.abspath(os.path.dirname(__file__))
NEARLEY_PATH = os.p... |
import pytest
from homeassistant import config_entries
from homeassistant.components import hue
from homeassistant.components.hue import bridge, errors
from homeassistant.components.hue.const import (
CONF_ALLOW_HUE_GROUPS,
CONF_ALLOW_UNREACHABLE,
)
from homeassistant.exceptions import ConfigEntryNotReady
fr... |
import argparse
import json
from .const import FRONTEND_DIR
from .download import DOWNLOAD_DIR, run_download_docker
from .util import get_base_arg_parser
FRONTEND_BACKEND_TRANSLATIONS = FRONTEND_DIR / "translations/backend"
def get_arguments() -> argparse.Namespace:
"""Get parsed passed in arguments."""
pa... |
import os
import argparse
from twisted.internet import reactor
from twisted.internet.defer import inlineCallbacks
from autobahn.twisted.wamp import ApplicationSession, ApplicationRunner
class ClientSession(ApplicationSession):
"""
An application component that subscribes and receives events, and
stop af... |
from . import roomba_reported_state
from .braava import BraavaJet
from .const import BLID, DOMAIN, ROOMBA_SESSION
from .roomba import RoombaVacuum, RoombaVacuumCarpetBoost
async def async_setup_entry(hass, config_entry, async_add_entities):
"""Set up the iRobot Roomba vacuum cleaner."""
domain_data = hass.da... |
import os
import sys
import random
import re
import tensorflow as tf
import cv2
import numpy as np
from datasets.dataset_utils import int64_feature, float_feature, bytes_feature
# TFRecords convertion parameters.
RANDOM_SEED = 4242
SAMPLES_PER_FILES = 200
CLASSES = {
'Pedestrian': 0,
'Cyclist': 1,
'Car'... |
import binascii
import numpy as np
import pytest
from mock import sentinel
from arctic.store._version_store_utils import _split_arrs, checksum, version_base_or_id
def test_split_arrs_empty():
split = _split_arrs(np.empty(0), [])
assert np.all(split == np.empty(0, dtype=np.object))
def test_split_arrs():
... |
from xml.etree import ElementTree
from weblate.trans.tests.test_views import FixtureTestCase
class SitemapTest(FixtureTestCase):
def test_sitemaps(self):
# Get root sitemap
response = self.client.get("/sitemap.xml")
self.assertContains(response, "<sitemapindex")
# Parse it
... |
from datetime import timedelta
import logging
from hydrawiser.core import Hydrawiser
from requests.exceptions import ConnectTimeout, HTTPError
import voluptuous as vol
from homeassistant.components.binary_sensor import (
DEVICE_CLASS_CONNECTIVITY,
DEVICE_CLASS_MOISTURE,
)
from homeassistant.components.sensor... |
from __future__ import print_function
import optparse
from .utils import setup_logging
from ..arctic import Arctic
print = print
def main():
usage = """usage: %prog [options] [prefix ...]
Lists the libraries available in a user's database. If any prefix parameters
are given, list only libraries wit... |
from unittest import mock
import pytest
from homeassistant.components import opnsense
from homeassistant.components.opnsense import CONF_API_SECRET, DOMAIN
from homeassistant.const import CONF_API_KEY, CONF_URL, CONF_VERIFY_SSL
from homeassistant.setup import async_setup_component
@pytest.fixture(name="mocked_opns... |
import urwid
BLACK_FGS = ('light gray', 'dark cyan', 'dark red', 'dark green',
'dark magenta', 'white', 'light blue', 'light cyan', 'light red',
'light green', 'yellow', 'light magenta')
GRAY_FGS = ('black', 'dark blue', 'dark cyan', 'dark red', 'dark green',
'dark magenta', 'white', 'light red', 'yellow'... |
from datetime import datetime, timedelta
import unittest
import requests_mock
from homeassistant import core as ha
import homeassistant.components.google_wifi.sensor as google_wifi
from homeassistant.const import STATE_UNKNOWN
from homeassistant.setup import setup_component
from homeassistant.util import dt as dt_ut... |
import os.path as op
import pytest
from mne.io import read_raw_fif
from mne import pick_types
from mne.preprocessing import find_ecg_events, create_ecg_epochs
data_path = op.join(op.dirname(__file__), '..', '..', 'io', 'tests', 'data')
raw_fname = op.join(data_path, 'test_raw.fif')
event_fname = op.join(data_path, '... |
import logging
import os
import time
from functools import reduce
from typing import Any
from typing import Dict
from typing import Iterable
from typing import List
from typing import Optional
from typing import Set
from typing import Tuple
import pyinotify
from kazoo.protocol.states import EventType
from kazoo.proto... |
from homeassistant.components.remote import (
ATTR_COMMAND,
DOMAIN as REMOTE_DOMAIN,
SERVICE_SEND_COMMAND,
)
from homeassistant.const import ATTR_ENTITY_ID, SERVICE_TURN_OFF, SERVICE_TURN_ON
from homeassistant.helpers.typing import HomeAssistantType
from tests.async_mock import patch
from tests.components... |
import numpy as np
from scattertext.semioticsquare import SemioticSquare
from scattertext.termranking import AbsoluteFrequencyRanker
from scattertext.termscoring.RankDifference import RankDifference
class FourSquareAxes(SemioticSquare):
'''
This creates a semiotic square where the complex term is considered the "... |
import re
from kalliope.core import Utils
from kalliope.core.ConfigurationManager import YAMLLoader
from kalliope.core.Models.Dna import Dna
class InvalidDNAException(Exception):
pass
VALID_DNA_MODULE_TYPE = ["neuron", "stt", "tts", "trigger", "signal"]
class DnaLoader(object):
def __init__(self, file_... |
import urwid
def exit_on_q(key):
if key in ('q', 'Q'):
raise urwid.ExitMainLoop()
class QuestionBox(urwid.Filler):
def keypress(self, size, key):
if key != 'enter':
return super(QuestionBox, self).keypress(size, key)
self.original_widget = urwid.Text(
u"Nice to... |
from __future__ import division, print_function, absolute_import
import sys
import os
from plumbum import local
from .termsize import get_terminal_size
from .progress import Progress
def readline(message=""):
"""Gets a line of input from the user (stdin)"""
sys.stdout.write(message)
sys.stdout.flush()
... |
import os
import sys
import time
import cherrypy
starttime = time.time()
class Root:
@cherrypy.expose
def index(self):
return 'Hello World'
@cherrypy.expose
def mtimes(self):
return repr(cherrypy.engine.publish('Autoreloader', 'mtimes'))
@cherrypy.expose
def pid(self):
... |
from pytest import mark
from cerberus import errors
from cerberus.tests import assert_fail, assert_success
@mark.parametrize('constraint', (('Graham Chapman', 'Eric Idle'), 'Terry Gilliam'))
def test_contains_succeeds(constraint):
assert_success(
schema={'actors': {'contains': constraint}},
docu... |
import os.path as op
import numpy as np
from numpy.testing import assert_array_almost_equal, assert_allclose
from scipy.signal import lfilter
from mne import io
from mne.time_frequency.ar import _yule_walker, fit_iir_model_raw
from mne.utils import requires_version, run_tests_if_main
raw_fname = op.join(op.dirname... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.