text
stringlengths 213
32.3k
|
|---|
from datetime import datetime, timedelta
import logging
import pytz
import voluptuous as vol
from homeassistant.components.binary_sensor import PLATFORM_SCHEMA, BinarySensorEntity
from homeassistant.const import (
CONF_AFTER,
CONF_BEFORE,
CONF_NAME,
SUN_EVENT_SUNRISE,
SUN_EVENT_SUNSET,
)
from homeassistant.core import callback
from homeassistant.helpers import config_validation as cv, event
from homeassistant.helpers.sun import get_astral_event_date, get_astral_event_next
from homeassistant.util import dt as dt_util
_LOGGER = logging.getLogger(__name__)
ATTR_AFTER = "after"
ATTR_BEFORE = "before"
ATTR_NEXT_UPDATE = "next_update"
CONF_AFTER_OFFSET = "after_offset"
CONF_BEFORE_OFFSET = "before_offset"
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
{
vol.Required(CONF_AFTER): vol.Any(cv.time, vol.All(vol.Lower, cv.sun_event)),
vol.Required(CONF_BEFORE): vol.Any(cv.time, vol.All(vol.Lower, cv.sun_event)),
vol.Required(CONF_NAME): cv.string,
vol.Optional(CONF_AFTER_OFFSET, default=timedelta(0)): cv.time_period,
vol.Optional(CONF_BEFORE_OFFSET, default=timedelta(0)): cv.time_period,
}
)
async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
"""Set up the ToD sensors."""
if hass.config.time_zone is None:
_LOGGER.error("Timezone is not set in Home Assistant configuration")
return
after = config[CONF_AFTER]
after_offset = config[CONF_AFTER_OFFSET]
before = config[CONF_BEFORE]
before_offset = config[CONF_BEFORE_OFFSET]
name = config[CONF_NAME]
sensor = TodSensor(name, after, after_offset, before, before_offset)
async_add_entities([sensor])
def is_sun_event(sun_event):
"""Return true if event is sun event not time."""
return sun_event in (SUN_EVENT_SUNRISE, SUN_EVENT_SUNSET)
class TodSensor(BinarySensorEntity):
"""Time of the Day Sensor."""
def __init__(self, name, after, after_offset, before, before_offset):
"""Init the ToD Sensor..."""
self._name = name
self._time_before = self._time_after = self._next_update = None
self._after_offset = after_offset
self._before_offset = before_offset
self._before = before
self._after = after
@property
def should_poll(self):
"""Sensor does not need to be polled."""
return False
@property
def name(self):
"""Return the name of the sensor."""
return self._name
@property
def after(self):
"""Return the timestamp for the beginning of the period."""
return self._time_after
@property
def before(self):
"""Return the timestamp for the end of the period."""
return self._time_before
@property
def is_on(self):
"""Return True is sensor is on."""
if self.after < self.before:
return self.after <= self.current_datetime < self.before
return False
@property
def current_datetime(self):
"""Return local current datetime according to hass configuration."""
return dt_util.utcnow()
@property
def next_update(self):
"""Return the next update point in the UTC time."""
return self._next_update
@property
def device_state_attributes(self):
"""Return the state attributes of the sensor."""
return {
ATTR_AFTER: self.after.astimezone(self.hass.config.time_zone).isoformat(),
ATTR_BEFORE: self.before.astimezone(self.hass.config.time_zone).isoformat(),
ATTR_NEXT_UPDATE: self.next_update.astimezone(
self.hass.config.time_zone
).isoformat(),
}
def _naive_time_to_utc_datetime(self, naive_time):
"""Convert naive time from config to utc_datetime with current day."""
# get the current local date from utc time
current_local_date = self.current_datetime.astimezone(
self.hass.config.time_zone
).date()
# calculate utc datetime corecponding to local time
utc_datetime = self.hass.config.time_zone.localize(
datetime.combine(current_local_date, naive_time)
).astimezone(tz=pytz.UTC)
return utc_datetime
def _calculate_initial_boudary_time(self):
"""Calculate internal absolute time boundaries."""
nowutc = self.current_datetime
# If after value is a sun event instead of absolute time
if is_sun_event(self._after):
# Calculate the today's event utc time or
# if not available take next
after_event_date = get_astral_event_date(
self.hass, self._after, nowutc
) or get_astral_event_next(self.hass, self._after, nowutc)
else:
# Convert local time provided to UTC today
# datetime.combine(date, time, tzinfo) is not supported
# in python 3.5. The self._after is provided
# with hass configured TZ not system wide
after_event_date = self._naive_time_to_utc_datetime(self._after)
self._time_after = after_event_date
# If before value is a sun event instead of absolute time
if is_sun_event(self._before):
# Calculate the today's event utc time or if not available take
# next
before_event_date = get_astral_event_date(
self.hass, self._before, nowutc
) or get_astral_event_next(self.hass, self._before, nowutc)
# Before is earlier than after
if before_event_date < after_event_date:
# Take next day for before
before_event_date = get_astral_event_next(
self.hass, self._before, after_event_date
)
else:
# Convert local time provided to UTC today, see above
before_event_date = self._naive_time_to_utc_datetime(self._before)
# It is safe to add timedelta days=1 to UTC as there is no DST
if before_event_date < after_event_date + self._after_offset:
before_event_date += timedelta(days=1)
self._time_before = before_event_date
# We are calculating the _time_after value assuming that it will happen today
# But that is not always true, e.g. after 23:00, before 12:00 and now is 10:00
# If _time_before and _time_after are ahead of current_datetime:
# _time_before is set to 12:00 next day
# _time_after is set to 23:00 today
# current_datetime is set to 10:00 today
if (
self._time_after > self.current_datetime
and self._time_before > self.current_datetime + timedelta(days=1)
):
# remove one day from _time_before and _time_after
self._time_after -= timedelta(days=1)
self._time_before -= timedelta(days=1)
# Add offset to utc boundaries according to the configuration
self._time_after += self._after_offset
self._time_before += self._before_offset
def _turn_to_next_day(self):
"""Turn to to the next day."""
if is_sun_event(self._after):
self._time_after = get_astral_event_next(
self.hass, self._after, self._time_after - self._after_offset
)
self._time_after += self._after_offset
else:
# Offset is already there
self._time_after += timedelta(days=1)
if is_sun_event(self._before):
self._time_before = get_astral_event_next(
self.hass, self._before, self._time_before - self._before_offset
)
self._time_before += self._before_offset
else:
# Offset is already there
self._time_before += timedelta(days=1)
async def async_added_to_hass(self):
"""Call when entity about to be added to Home Assistant."""
self._calculate_initial_boudary_time()
self._calculate_next_update()
self._point_in_time_listener(dt_util.now())
def _calculate_next_update(self):
"""Datetime when the next update to the state."""
now = self.current_datetime
if now < self.after:
self._next_update = self.after
return
if now < self.before:
self._next_update = self.before
return
self._turn_to_next_day()
self._next_update = self.after
@callback
def _point_in_time_listener(self, now):
"""Run when the state of the sensor should be updated."""
self._calculate_next_update()
self.async_write_ha_state()
event.async_track_point_in_utc_time(
self.hass, self._point_in_time_listener, self.next_update
)
|
import asyncio
import logging
import pathlib
import secrets
import shutil
import typing
from PIL import Image, ImageOps, UnidentifiedImageError
from aiohttp import hdrs, web
from aiohttp.web_request import FileField
import voluptuous as vol
from homeassistant.components.http.static import CACHE_HEADERS
from homeassistant.components.http.view import HomeAssistantView
from homeassistant.const import CONF_ID
from homeassistant.core import HomeAssistant, callback
from homeassistant.helpers import collection
from homeassistant.helpers.storage import Store
import homeassistant.util.dt as dt_util
from .const import DOMAIN
_LOGGER = logging.getLogger(__name__)
STORAGE_KEY = DOMAIN
STORAGE_VERSION = 1
VALID_SIZES = {256, 512}
MAX_SIZE = 1024 * 1024 * 10
CREATE_FIELDS = {
vol.Required("file"): FileField,
}
UPDATE_FIELDS = {
vol.Optional("name"): vol.All(str, vol.Length(min=1)),
}
async def async_setup(hass: HomeAssistant, config: dict):
"""Set up the Image integration."""
image_dir = pathlib.Path(hass.config.path(DOMAIN))
hass.data[DOMAIN] = storage_collection = ImageStorageCollection(hass, image_dir)
await storage_collection.async_load()
collection.StorageCollectionWebsocket(
storage_collection,
DOMAIN,
DOMAIN,
CREATE_FIELDS,
UPDATE_FIELDS,
).async_setup(hass, create_create=False)
hass.http.register_view(ImageUploadView)
hass.http.register_view(ImageServeView(image_dir, storage_collection))
return True
class ImageStorageCollection(collection.StorageCollection):
"""Image collection stored in storage."""
CREATE_SCHEMA = vol.Schema(CREATE_FIELDS)
UPDATE_SCHEMA = vol.Schema(UPDATE_FIELDS)
def __init__(self, hass: HomeAssistant, image_dir: pathlib.Path) -> None:
"""Initialize media storage collection."""
super().__init__(
Store(hass, STORAGE_VERSION, STORAGE_KEY),
logging.getLogger(f"{__name__}.storage_collection"),
)
self.async_add_listener(self._change_listener)
self.image_dir = image_dir
async def _process_create_data(self, data: typing.Dict) -> typing.Dict:
"""Validate the config is valid."""
data = self.CREATE_SCHEMA(dict(data))
uploaded_file: FileField = data["file"]
if not uploaded_file.content_type.startswith("image/"):
raise vol.Invalid("Only images are allowed")
data[CONF_ID] = secrets.token_hex(16)
data["filesize"] = await self.hass.async_add_executor_job(self._move_data, data)
data["content_type"] = uploaded_file.content_type
data["name"] = uploaded_file.filename
data["uploaded_at"] = dt_util.utcnow().isoformat()
return data
def _move_data(self, data):
"""Move data."""
uploaded_file: FileField = data.pop("file")
# Verify we can read the image
try:
image = Image.open(uploaded_file.file)
except UnidentifiedImageError as err:
raise vol.Invalid("Unable to identify image file") from err
# Reset content
uploaded_file.file.seek(0)
media_folder: pathlib.Path = self.image_dir / data[CONF_ID]
media_folder.mkdir(parents=True)
media_file = media_folder / "original"
# Raises if path is no longer relative to the media dir
media_file.relative_to(media_folder)
_LOGGER.debug("Storing file %s", media_file)
with media_file.open("wb") as target:
shutil.copyfileobj(uploaded_file.file, target)
image.close()
return media_file.stat().st_size
@callback
def _get_suggested_id(self, info: typing.Dict) -> str:
"""Suggest an ID based on the config."""
return info[CONF_ID]
async def _update_data(self, data: dict, update_data: typing.Dict) -> typing.Dict:
"""Return a new updated data object."""
return {**data, **self.UPDATE_SCHEMA(update_data)}
async def _change_listener(self, change_type, item_id, data):
"""Handle change."""
if change_type != collection.CHANGE_REMOVED:
return
await self.hass.async_add_executor_job(shutil.rmtree, self.image_dir / item_id)
class ImageUploadView(HomeAssistantView):
"""View to upload images."""
url = "/api/image/upload"
name = "api:image:upload"
async def post(self, request):
"""Handle upload."""
# Increase max payload
request._client_max_size = MAX_SIZE # pylint: disable=protected-access
data = await request.post()
item = await request.app["hass"].data[DOMAIN].async_create_item(data)
return self.json(item)
class ImageServeView(HomeAssistantView):
"""View to download images."""
url = "/api/image/serve/{image_id}/{filename}"
name = "api:image:serve"
requires_auth = False
def __init__(
self, image_folder: pathlib.Path, image_collection: ImageStorageCollection
):
"""Initialize image serve view."""
self.transform_lock = asyncio.Lock()
self.image_folder = image_folder
self.image_collection = image_collection
async def get(self, request: web.Request, image_id: str, filename: str):
"""Serve image."""
image_size = filename.split("-", 1)[0]
try:
parts = image_size.split("x", 1)
width = int(parts[0])
height = int(parts[1])
except (ValueError, IndexError) as err:
raise web.HTTPBadRequest from err
if not width or width != height or width not in VALID_SIZES:
raise web.HTTPBadRequest
image_info = self.image_collection.data.get(image_id)
if image_info is None:
raise web.HTTPNotFound()
hass = request.app["hass"]
target_file = self.image_folder / image_id / f"{width}x{height}"
if not target_file.is_file():
async with self.transform_lock:
# Another check in case another request already finished it while waiting
if not target_file.is_file():
await hass.async_add_executor_job(
_generate_thumbnail,
self.image_folder / image_id / "original",
image_info["content_type"],
target_file,
(width, height),
)
return web.FileResponse(
target_file,
headers={**CACHE_HEADERS, hdrs.CONTENT_TYPE: image_info["content_type"]},
)
def _generate_thumbnail(original_path, content_type, target_path, target_size):
"""Generate a size."""
image = ImageOps.exif_transpose(Image.open(original_path))
image.thumbnail(target_size)
image.save(target_path, format=content_type.split("/", 1)[1])
|
import numpy as np
from numpy.testing import assert_almost_equal
from mne.inverse_sparse.mxne_debiasing import compute_bias
def test_compute_debiasing():
"""Test source amplitude debiasing."""
rng = np.random.RandomState(42)
G = rng.randn(10, 4)
X = rng.randn(4, 20)
debias_true = np.arange(1, 5, dtype=np.float64)
M = np.dot(G, X * debias_true[:, np.newaxis])
debias = compute_bias(M, G, X, max_iter=10000, n_orient=1, tol=1e-7)
assert_almost_equal(debias, debias_true, decimal=5)
debias = compute_bias(M, G, X, max_iter=10000, n_orient=2, tol=1e-5)
assert_almost_equal(debias, [1.8, 1.8, 3.72, 3.72], decimal=2)
|
import pytest
from molecule.model import schema_v2
@pytest.fixture
def _model_platforms_docker_section_data():
return """
---
platforms:
- name: instance
registry:
credentials:
password: $BAR
""".strip()
@pytest.fixture
def _env():
return {}
@pytest.fixture
def _keep_string():
return 'MOLECULE_'
@pytest.mark.parametrize('_stream', [(_model_platforms_docker_section_data)])
def test_platforms_docker(_stream, _env, _keep_string):
assert {} == schema_v2.pre_validate(_stream(), _env, _keep_string)
@pytest.fixture
def _model_platforms_docker_errors_section_data():
return """
---
platforms:
- name: instance
registry:
credentials:
password: foo
""".strip()
@pytest.mark.parametrize('_stream',
[_model_platforms_docker_errors_section_data])
def test_platforms_docker_has_errors(_stream, _env, _keep_string):
x = {
'platforms': [{
0: [{
'registry': [{
'credentials': [{
'password': [
('value does not match regex '
"'^[{$]+[a-z0-9A-Z]+[}]*$'"),
]
}]
}]
}]
}]
}
assert x == schema_v2.pre_validate(_stream(), _env, _keep_string)
@pytest.fixture
def _model_molecule_env_errors_section_data():
return """
---
dependency:
name: $MOLECULE_DEPENDENCY_NAME
driver:
name: $MOLECULE_DRIVER_NAME
lint:
name: $MOLECULE_LINT_NAME
platforms:
- name: instance
image: centos:latest
networks:
- name: foo
- name: bar
provisioner:
name: $MOLECULE_PROVISIONER_NAME
lint:
name: $MOLECULE_PROVISIONER_LINT_NAME
scenario:
name: $MOLECULE_SCENARIO_NAME
verifier:
name: $MOLECULE_VERIFIER_NAME
lint:
name: $MOLECULE_VERIFIER_LINT_NAME
""".strip()
@pytest.mark.parametrize('_stream',
[(_model_molecule_env_errors_section_data)])
def test_has_errors_when_molecule_env_var_referenced_in_unallowed_sections(
_stream, _env, _keep_string):
x = {
'scenario': [{
'name':
['cannot reference $MOLECULE special variables in this section']
}],
'lint': [{
'name': [
'cannot reference $MOLECULE special variables in this section',
'unallowed value $MOLECULE_LINT_NAME'
]
}],
'driver': [{
'name': [
'cannot reference $MOLECULE special variables in this section',
'unallowed value $MOLECULE_DRIVER_NAME'
]
}],
'dependency': [{
'name': [
'cannot reference $MOLECULE special variables in this section',
'unallowed value $MOLECULE_DEPENDENCY_NAME'
]
}],
'verifier': [{
'lint': [{
'name':
[('cannot reference $MOLECULE special variables in this '
'section'), 'unallowed value $MOLECULE_VERIFIER_LINT_NAME']
}],
'name': [
'cannot reference $MOLECULE special variables in this section',
'unallowed value $MOLECULE_VERIFIER_NAME'
]
}],
'provisioner': [{
'lint': [{
'name':
[('cannot reference $MOLECULE special variables in this '
'section'),
'unallowed value $MOLECULE_PROVISIONER_LINT_NAME']
}],
'name': [
'cannot reference $MOLECULE special variables in this section',
'unallowed value $MOLECULE_PROVISIONER_NAME'
]
}]
}
assert x == schema_v2.pre_validate(_stream(), _env, _keep_string)
|
import os
import unittest
import mock
from perfkitbenchmarker import test_util
from perfkitbenchmarker.linux_benchmarks import nccl_benchmark
from perfkitbenchmarker.sample import Sample
class NcclBenchmarkTest(unittest.TestCase, test_util.SamplesTestMixin):
def setUp(self):
super(NcclBenchmarkTest, self).setUp()
path = os.path.join(os.path.dirname(__file__), '..', 'data',
'nccl_output.txt')
with open(path) as fp:
self.contents = fp.read()
@mock.patch('time.time', mock.MagicMock(return_value=1550279509.59))
def testNcclResults(self):
samples, bandwidth = nccl_benchmark.MakeSamplesFromOutput({}, self.contents)
metadata = {
'nThread': '1',
'nGpus': '1',
'minBytes': '8',
'maxBytes': '8589934592',
'step': '2(factor)',
'warmup_iters': '5',
'iters': '100',
'validation': '1',
'Rank 0': 'Pid 40529 on ip-172-31-20-44 device 0 [0x00] Tesla '
'V100-SXM2-32GB',
'Rank 1': 'Pid 40530 on ip-172-31-20-44 device 1 [0x00] Tesla '
'V100-SXM2-32GB',
'Rank 2': 'Pid 40531 on ip-172-31-20-44 device 2 [0x00] Tesla '
'V100-SXM2-32GB',
'Rank 3': 'Pid 40532 on ip-172-31-20-44 device 3 [0x00] Tesla '
'V100-SXM2-32GB',
'Rank 4': 'Pid 40533 on ip-172-31-20-44 device 4 [0x00] Tesla '
'V100-SXM2-32GB',
'Rank 5': 'Pid 40534 on ip-172-31-20-44 device 5 [0x00] Tesla '
'V100-SXM2-32GB',
'Rank 6': 'Pid 40535 on ip-172-31-20-44 device 6 [0x00] Tesla '
'V100-SXM2-32GB',
'Rank 7': 'Pid 40536 on ip-172-31-20-44 device 7 [0x00] Tesla '
'V100-SXM2-32GB',
'Rank 8': 'Pid 25655 on ip-172-31-26-32 device 0 [0x00] Tesla '
'V100-SXM2-32GB',
'Rank 9': 'Pid 25656 on ip-172-31-26-32 device 1 [0x00] Tesla '
'V100-SXM2-32GB',
'Rank 10': 'Pid 25657 on ip-172-31-26-32 device 2 [0x00] Tesla '
'V100-SXM2-32GB',
'Rank 11': 'Pid 25658 on ip-172-31-26-32 device 3 [0x00] Tesla '
'V100-SXM2-32GB',
'Rank 12': 'Pid 25659 on ip-172-31-26-32 device 4 [0x00] Tesla '
'V100-SXM2-32GB',
'Rank 13': 'Pid 25660 on ip-172-31-26-32 device 5 [0x00] Tesla '
'V100-SXM2-32GB',
'Rank 14': 'Pid 25661 on ip-172-31-26-32 device 6 [0x00] Tesla '
'V100-SXM2-32GB',
'Rank 15': 'Pid 25664 on ip-172-31-26-32 device 7 [0x00] Tesla '
'V100-SXM2-32GB',
'size': '8',
'count': '2',
'nccl_type': 'float',
'redop': 'sum',
'out_of_place_time': '58.10',
'out_of_place_algbw': '0.00',
'out_of_place_busbw': '0.00',
'out_of_place_error': '4e-07',
'in_place_time': '57.87',
'in_place_algbw': '0.00',
'in_place_busbw': '0.00',
'in_place_error': '4e-07'}
golden = Sample(metric='In place algorithm bandwidth', value=0.0,
unit='GB/s', metadata=metadata)
self.assertIn(golden, samples)
self.assertAlmostEqual(bandwidth, 8.43)
if __name__ == '__main__':
unittest.main()
|
import asyncio
from unittest.mock import Mock, patch
import aiohttp
import pytest
from homeassistant.components import ssdp
from tests.common import mock_coro
async def test_scan_match_st(hass):
"""Test matching based on ST."""
scanner = ssdp.Scanner(hass, {"mock-domain": [{"st": "mock-st"}]})
with patch(
"netdisco.ssdp.scan",
return_value=[
Mock(
st="mock-st",
location=None,
values={"usn": "mock-usn", "server": "mock-server", "ext": ""},
)
],
), patch.object(
hass.config_entries.flow, "async_init", return_value=mock_coro()
) as mock_init:
await scanner.async_scan(None)
assert len(mock_init.mock_calls) == 1
assert mock_init.mock_calls[0][1][0] == "mock-domain"
assert mock_init.mock_calls[0][2]["context"] == {"source": "ssdp"}
assert mock_init.mock_calls[0][2]["data"] == {
ssdp.ATTR_SSDP_ST: "mock-st",
ssdp.ATTR_SSDP_LOCATION: None,
ssdp.ATTR_SSDP_USN: "mock-usn",
ssdp.ATTR_SSDP_SERVER: "mock-server",
ssdp.ATTR_SSDP_EXT: "",
}
@pytest.mark.parametrize(
"key", (ssdp.ATTR_UPNP_MANUFACTURER, ssdp.ATTR_UPNP_DEVICE_TYPE)
)
async def test_scan_match_upnp_devicedesc(hass, aioclient_mock, key):
"""Test matching based on UPnP device description data."""
aioclient_mock.get(
"http://1.1.1.1",
text=f"""
<root>
<device>
<{key}>Paulus</{key}>
</device>
</root>
""",
)
scanner = ssdp.Scanner(hass, {"mock-domain": [{key: "Paulus"}]})
with patch(
"netdisco.ssdp.scan",
return_value=[Mock(st="mock-st", location="http://1.1.1.1", values={})],
), patch.object(
hass.config_entries.flow, "async_init", return_value=mock_coro()
) as mock_init:
await scanner.async_scan(None)
assert len(mock_init.mock_calls) == 1
assert mock_init.mock_calls[0][1][0] == "mock-domain"
assert mock_init.mock_calls[0][2]["context"] == {"source": "ssdp"}
async def test_scan_not_all_present(hass, aioclient_mock):
"""Test match fails if some specified attributes are not present."""
aioclient_mock.get(
"http://1.1.1.1",
text="""
<root>
<device>
<deviceType>Paulus</deviceType>
</device>
</root>
""",
)
scanner = ssdp.Scanner(
hass,
{
"mock-domain": [
{
ssdp.ATTR_UPNP_DEVICE_TYPE: "Paulus",
ssdp.ATTR_UPNP_MANUFACTURER: "Paulus",
}
]
},
)
with patch(
"netdisco.ssdp.scan",
return_value=[Mock(st="mock-st", location="http://1.1.1.1", values={})],
), patch.object(
hass.config_entries.flow, "async_init", return_value=mock_coro()
) as mock_init:
await scanner.async_scan(None)
assert not mock_init.mock_calls
async def test_scan_not_all_match(hass, aioclient_mock):
"""Test match fails if some specified attribute values differ."""
aioclient_mock.get(
"http://1.1.1.1",
text="""
<root>
<device>
<deviceType>Paulus</deviceType>
<manufacturer>Paulus</manufacturer>
</device>
</root>
""",
)
scanner = ssdp.Scanner(
hass,
{
"mock-domain": [
{
ssdp.ATTR_UPNP_DEVICE_TYPE: "Paulus",
ssdp.ATTR_UPNP_MANUFACTURER: "Not-Paulus",
}
]
},
)
with patch(
"netdisco.ssdp.scan",
return_value=[Mock(st="mock-st", location="http://1.1.1.1", values={})],
), patch.object(
hass.config_entries.flow, "async_init", return_value=mock_coro()
) as mock_init:
await scanner.async_scan(None)
assert not mock_init.mock_calls
@pytest.mark.parametrize("exc", [asyncio.TimeoutError, aiohttp.ClientError])
async def test_scan_description_fetch_fail(hass, aioclient_mock, exc):
"""Test failing to fetch description."""
aioclient_mock.get("http://1.1.1.1", exc=exc)
scanner = ssdp.Scanner(hass, {})
with patch(
"netdisco.ssdp.scan",
return_value=[Mock(st="mock-st", location="http://1.1.1.1", values={})],
):
await scanner.async_scan(None)
async def test_scan_description_parse_fail(hass, aioclient_mock):
"""Test invalid XML."""
aioclient_mock.get(
"http://1.1.1.1",
text="""
<root>INVALIDXML
""",
)
scanner = ssdp.Scanner(hass, {})
with patch(
"netdisco.ssdp.scan",
return_value=[Mock(st="mock-st", location="http://1.1.1.1", values={})],
):
await scanner.async_scan(None)
|
import json
from pathlib import Path
import pytest
from redbot.pytest.downloader import *
from redbot.cogs.downloader.installable import Installable, InstallableType
from redbot.core import VersionInfo
def test_process_info_file(installable):
for k, v in INFO_JSON.items():
if k == "type":
assert installable.type == InstallableType.COG
elif k in ("min_bot_version", "max_bot_version"):
assert getattr(installable, k) == VersionInfo.from_str(v)
else:
assert getattr(installable, k) == v
def test_process_lib_info_file(library_installable):
for k, v in LIBRARY_INFO_JSON.items():
if k == "type":
assert library_installable.type == InstallableType.SHARED_LIBRARY
elif k in ("min_bot_version", "max_bot_version"):
assert getattr(library_installable, k) == VersionInfo.from_str(v)
elif k == "hidden":
# libraries are always hidden, even if False
assert library_installable.hidden is True
else:
assert getattr(library_installable, k) == v
# noinspection PyProtectedMember
def test_location_is_dir(installable):
assert installable._location.exists()
assert installable._location.is_dir()
# noinspection PyProtectedMember
def test_info_file_is_file(installable):
assert installable._info_file.exists()
assert installable._info_file.is_file()
def test_name(installable):
assert installable.name == "test_cog"
def test_repo_name(installable):
assert installable.repo_name == "test_repo"
def test_serialization(installed_cog):
data = installed_cog.to_json()
cog_name = data["module_name"]
assert cog_name == "test_installed_cog"
|
from unittest.mock import patch, Mock
import arrow
from cryptography import x509
from lemur.plugins.lemur_entrust import plugin
from freezegun import freeze_time
def config_mock(*args):
values = {
"ENTRUST_API_CERT": "-----BEGIN CERTIFICATE-----abc-----END CERTIFICATE-----",
"ENTRUST_API_KEY": False,
"ENTRUST_API_USER": "test",
"ENTRUST_API_PASS": "password",
"ENTRUST_URL": "http",
"ENTRUST_ROOT": None,
"ENTRUST_NAME": "test",
"ENTRUST_EMAIL": "test@lemur.net",
"ENTRUST_PHONE": "0123456",
"ENTRUST_PRODUCT_ENTRUST": "ADVANTAGE_SSL"
}
return values[args[0]]
@patch("lemur.plugins.lemur_digicert.plugin.current_app")
def test_determine_end_date(mock_current_app):
with freeze_time(time_to_freeze=arrow.get(2016, 11, 3).datetime):
assert arrow.get(2017, 12, 3).format('YYYY-MM-DD') == plugin.determine_end_date(0) # 1 year + 1 month
assert arrow.get(2017, 3, 5).format('YYYY-MM-DD') == plugin.determine_end_date(arrow.get(2017, 3, 5))
assert arrow.get(2017, 12, 3).format('YYYY-MM-DD') == plugin.determine_end_date(arrow.get(2020, 5, 7))
@patch("lemur.plugins.lemur_entrust.plugin.current_app")
def test_process_options(mock_current_app, authority):
mock_current_app.config.get = Mock(side_effect=config_mock)
plugin.determine_end_date = Mock(return_value=arrow.get(2017, 11, 5).format('YYYY-MM-DD'))
authority.name = "Entrust"
names = [u"one.example.com", u"two.example.com", u"three.example.com"]
options = {
"common_name": "example.com",
"owner": "bob@example.com",
"description": "test certificate",
"extensions": {"sub_alt_names": {"names": [x509.DNSName(x) for x in names]}},
"organization": "Example, Inc.",
"organizational_unit": "Example Org",
"validity_end": arrow.utcnow().shift(years=1, months=+1),
"authority": authority,
}
expected = {
"signingAlg": "SHA-2",
"eku": "SERVER_AND_CLIENT_AUTH",
"certType": "ADVANTAGE_SSL",
"certExpiryDate": arrow.get(2017, 11, 5).format('YYYY-MM-DD'),
"tracking": {
"requesterName": mock_current_app.config.get("ENTRUST_NAME"),
"requesterEmail": mock_current_app.config.get("ENTRUST_EMAIL"),
"requesterPhone": mock_current_app.config.get("ENTRUST_PHONE")
},
"org": "Example, Inc.",
"clientId": 1
}
client_id = 1
assert expected == plugin.process_options(options, client_id)
|
import asyncio
import json
import logging
from aiohttp import web
from aiohttp.web_exceptions import HTTPBadRequest
import async_timeout
import voluptuous as vol
from homeassistant.auth.permissions.const import POLICY_READ
from homeassistant.bootstrap import DATA_LOGGING
from homeassistant.components.http import HomeAssistantView
from homeassistant.const import (
EVENT_HOMEASSISTANT_STOP,
EVENT_TIME_CHANGED,
HTTP_BAD_REQUEST,
HTTP_CREATED,
HTTP_NOT_FOUND,
HTTP_OK,
MATCH_ALL,
URL_API,
URL_API_COMPONENTS,
URL_API_CONFIG,
URL_API_DISCOVERY_INFO,
URL_API_ERROR_LOG,
URL_API_EVENTS,
URL_API_SERVICES,
URL_API_STATES,
URL_API_STREAM,
URL_API_TEMPLATE,
__version__,
)
import homeassistant.core as ha
from homeassistant.exceptions import ServiceNotFound, TemplateError, Unauthorized
from homeassistant.helpers import template
from homeassistant.helpers.json import JSONEncoder
from homeassistant.helpers.network import NoURLAvailableError, get_url
from homeassistant.helpers.service import async_get_all_descriptions
from homeassistant.helpers.state import AsyncTrackStates
from homeassistant.helpers.system_info import async_get_system_info
_LOGGER = logging.getLogger(__name__)
ATTR_BASE_URL = "base_url"
ATTR_EXTERNAL_URL = "external_url"
ATTR_INTERNAL_URL = "internal_url"
ATTR_LOCATION_NAME = "location_name"
ATTR_INSTALLATION_TYPE = "installation_type"
ATTR_REQUIRES_API_PASSWORD = "requires_api_password"
ATTR_UUID = "uuid"
ATTR_VERSION = "version"
DOMAIN = "api"
STREAM_PING_PAYLOAD = "ping"
STREAM_PING_INTERVAL = 50 # seconds
def setup(hass, config):
"""Register the API with the HTTP interface."""
hass.http.register_view(APIStatusView)
hass.http.register_view(APIEventStream)
hass.http.register_view(APIConfigView)
hass.http.register_view(APIDiscoveryView)
hass.http.register_view(APIStatesView)
hass.http.register_view(APIEntityStateView)
hass.http.register_view(APIEventListenersView)
hass.http.register_view(APIEventView)
hass.http.register_view(APIServicesView)
hass.http.register_view(APIDomainServicesView)
hass.http.register_view(APIComponentsView)
hass.http.register_view(APITemplateView)
if DATA_LOGGING in hass.data:
hass.http.register_view(APIErrorLog)
return True
class APIStatusView(HomeAssistantView):
"""View to handle Status requests."""
url = URL_API
name = "api:status"
@ha.callback
def get(self, request):
"""Retrieve if API is running."""
return self.json_message("API running.")
class APIEventStream(HomeAssistantView):
"""View to handle EventStream requests."""
url = URL_API_STREAM
name = "api:stream"
async def get(self, request):
"""Provide a streaming interface for the event bus."""
if not request["hass_user"].is_admin:
raise Unauthorized()
hass = request.app["hass"]
stop_obj = object()
to_write = asyncio.Queue()
restrict = request.query.get("restrict")
if restrict:
restrict = restrict.split(",") + [EVENT_HOMEASSISTANT_STOP]
async def forward_events(event):
"""Forward events to the open request."""
if event.event_type == EVENT_TIME_CHANGED:
return
if restrict and event.event_type not in restrict:
return
_LOGGER.debug("STREAM %s FORWARDING %s", id(stop_obj), event)
if event.event_type == EVENT_HOMEASSISTANT_STOP:
data = stop_obj
else:
data = json.dumps(event, cls=JSONEncoder)
await to_write.put(data)
response = web.StreamResponse()
response.content_type = "text/event-stream"
await response.prepare(request)
unsub_stream = hass.bus.async_listen(MATCH_ALL, forward_events)
try:
_LOGGER.debug("STREAM %s ATTACHED", id(stop_obj))
# Fire off one message so browsers fire open event right away
await to_write.put(STREAM_PING_PAYLOAD)
while True:
try:
with async_timeout.timeout(STREAM_PING_INTERVAL):
payload = await to_write.get()
if payload is stop_obj:
break
msg = f"data: {payload}\n\n"
_LOGGER.debug("STREAM %s WRITING %s", id(stop_obj), msg.strip())
await response.write(msg.encode("UTF-8"))
except asyncio.TimeoutError:
await to_write.put(STREAM_PING_PAYLOAD)
except asyncio.CancelledError:
_LOGGER.debug("STREAM %s ABORT", id(stop_obj))
finally:
_LOGGER.debug("STREAM %s RESPONSE CLOSED", id(stop_obj))
unsub_stream()
return response
class APIConfigView(HomeAssistantView):
"""View to handle Configuration requests."""
url = URL_API_CONFIG
name = "api:config"
@ha.callback
def get(self, request):
"""Get current configuration."""
return self.json(request.app["hass"].config.as_dict())
class APIDiscoveryView(HomeAssistantView):
"""View to provide Discovery information."""
requires_auth = False
url = URL_API_DISCOVERY_INFO
name = "api:discovery"
async def get(self, request):
"""Get discovery information."""
hass = request.app["hass"]
uuid = await hass.helpers.instance_id.async_get()
system_info = await async_get_system_info(hass)
data = {
ATTR_UUID: uuid,
ATTR_BASE_URL: None,
ATTR_EXTERNAL_URL: None,
ATTR_INTERNAL_URL: None,
ATTR_LOCATION_NAME: hass.config.location_name,
ATTR_INSTALLATION_TYPE: system_info[ATTR_INSTALLATION_TYPE],
# always needs authentication
ATTR_REQUIRES_API_PASSWORD: True,
ATTR_VERSION: __version__,
}
try:
data["external_url"] = get_url(hass, allow_internal=False)
except NoURLAvailableError:
pass
try:
data["internal_url"] = get_url(hass, allow_external=False)
except NoURLAvailableError:
pass
# Set old base URL based on external or internal
data["base_url"] = data["external_url"] or data["internal_url"]
return self.json(data)
class APIStatesView(HomeAssistantView):
"""View to handle States requests."""
url = URL_API_STATES
name = "api:states"
@ha.callback
def get(self, request):
"""Get current states."""
user = request["hass_user"]
entity_perm = user.permissions.check_entity
states = [
state
for state in request.app["hass"].states.async_all()
if entity_perm(state.entity_id, "read")
]
return self.json(states)
class APIEntityStateView(HomeAssistantView):
"""View to handle EntityState requests."""
url = "/api/states/{entity_id}"
name = "api:entity-state"
@ha.callback
def get(self, request, entity_id):
"""Retrieve state of entity."""
user = request["hass_user"]
if not user.permissions.check_entity(entity_id, POLICY_READ):
raise Unauthorized(entity_id=entity_id)
state = request.app["hass"].states.get(entity_id)
if state:
return self.json(state)
return self.json_message("Entity not found.", HTTP_NOT_FOUND)
async def post(self, request, entity_id):
"""Update state of entity."""
if not request["hass_user"].is_admin:
raise Unauthorized(entity_id=entity_id)
hass = request.app["hass"]
try:
data = await request.json()
except ValueError:
return self.json_message("Invalid JSON specified.", HTTP_BAD_REQUEST)
new_state = data.get("state")
if new_state is None:
return self.json_message("No state specified.", HTTP_BAD_REQUEST)
attributes = data.get("attributes")
force_update = data.get("force_update", False)
is_new_state = hass.states.get(entity_id) is None
# Write state
hass.states.async_set(
entity_id, new_state, attributes, force_update, self.context(request)
)
# Read the state back for our response
status_code = HTTP_CREATED if is_new_state else HTTP_OK
resp = self.json(hass.states.get(entity_id), status_code)
resp.headers.add("Location", f"/api/states/{entity_id}")
return resp
@ha.callback
def delete(self, request, entity_id):
"""Remove entity."""
if not request["hass_user"].is_admin:
raise Unauthorized(entity_id=entity_id)
if request.app["hass"].states.async_remove(entity_id):
return self.json_message("Entity removed.")
return self.json_message("Entity not found.", HTTP_NOT_FOUND)
class APIEventListenersView(HomeAssistantView):
"""View to handle EventListeners requests."""
url = URL_API_EVENTS
name = "api:event-listeners"
@ha.callback
def get(self, request):
"""Get event listeners."""
return self.json(async_events_json(request.app["hass"]))
class APIEventView(HomeAssistantView):
"""View to handle Event requests."""
url = "/api/events/{event_type}"
name = "api:event"
async def post(self, request, event_type):
"""Fire events."""
if not request["hass_user"].is_admin:
raise Unauthorized()
body = await request.text()
try:
event_data = json.loads(body) if body else None
except ValueError:
return self.json_message(
"Event data should be valid JSON.", HTTP_BAD_REQUEST
)
if event_data is not None and not isinstance(event_data, dict):
return self.json_message(
"Event data should be a JSON object", HTTP_BAD_REQUEST
)
# Special case handling for event STATE_CHANGED
# We will try to convert state dicts back to State objects
if event_type == ha.EVENT_STATE_CHANGED and event_data:
for key in ("old_state", "new_state"):
state = ha.State.from_dict(event_data.get(key))
if state:
event_data[key] = state
request.app["hass"].bus.async_fire(
event_type, event_data, ha.EventOrigin.remote, self.context(request)
)
return self.json_message(f"Event {event_type} fired.")
class APIServicesView(HomeAssistantView):
"""View to handle Services requests."""
url = URL_API_SERVICES
name = "api:services"
async def get(self, request):
"""Get registered services."""
services = await async_services_json(request.app["hass"])
return self.json(services)
class APIDomainServicesView(HomeAssistantView):
"""View to handle DomainServices requests."""
url = "/api/services/{domain}/{service}"
name = "api:domain-services"
async def post(self, request, domain, service):
"""Call a service.
Returns a list of changed states.
"""
hass = request.app["hass"]
body = await request.text()
try:
data = json.loads(body) if body else None
except ValueError:
return self.json_message("Data should be valid JSON.", HTTP_BAD_REQUEST)
with AsyncTrackStates(hass) as changed_states:
try:
await hass.services.async_call(
domain, service, data, True, self.context(request)
)
except (vol.Invalid, ServiceNotFound) as ex:
raise HTTPBadRequest() from ex
return self.json(changed_states)
class APIComponentsView(HomeAssistantView):
"""View to handle Components requests."""
url = URL_API_COMPONENTS
name = "api:components"
@ha.callback
def get(self, request):
"""Get current loaded components."""
return self.json(request.app["hass"].config.components)
class APITemplateView(HomeAssistantView):
"""View to handle Template requests."""
url = URL_API_TEMPLATE
name = "api:template"
async def post(self, request):
"""Render a template."""
if not request["hass_user"].is_admin:
raise Unauthorized()
try:
data = await request.json()
tpl = template.Template(data["template"], request.app["hass"])
return tpl.async_render(variables=data.get("variables"), parse_result=False)
except (ValueError, TemplateError) as ex:
return self.json_message(
f"Error rendering template: {ex}", HTTP_BAD_REQUEST
)
class APIErrorLog(HomeAssistantView):
"""View to fetch the API error log."""
url = URL_API_ERROR_LOG
name = "api:error_log"
async def get(self, request):
"""Retrieve API error log."""
if not request["hass_user"].is_admin:
raise Unauthorized()
return web.FileResponse(request.app["hass"].data[DATA_LOGGING])
async def async_services_json(hass):
"""Generate services data to JSONify."""
descriptions = await async_get_all_descriptions(hass)
return [{"domain": key, "services": value} for key, value in descriptions.items()]
@ha.callback
def async_events_json(hass):
"""Generate event data to JSONify."""
return [
{"event": key, "listener_count": value}
for key, value in hass.bus.async_listeners().items()
]
|
import subprocess
import logging
import os
import sys
import signal
import configparser
import json
import threading
import time
from argparse import ArgumentParser
import queue as q
logger = logging.getLogger("agent")
collector_logger = logging.getLogger("telegraf")
def signal_handler(sig, frame):
""" required for non-tty python runs to interrupt """
logger.warning("Got signal %s, going to stop", sig)
raise KeyboardInterrupt()
def ignore_handler(sig, frame):
logger.warning("Got signal %s, ignoring", sig)
def set_sig_handler():
uncatchable = ['SIG_DFL', 'SIGSTOP', 'SIGKILL']
ignore = ['SIGCHLD', 'SIGCLD']
all_sig = [s for s in dir(signal) if s.startswith("SIG")]
for sig_name in ignore:
try:
sig_num = getattr(signal, sig_name)
signal.signal(sig_num, ignore_handler)
except Exception:
pass
for sig_name in [s for s in all_sig if s not in (uncatchable + ignore)]:
try:
sig_num = getattr(signal, sig_name)
signal.signal(sig_num, signal_handler)
except Exception as ex:
logger.error("Can't set handler for %s, %s", sig_name, ex)
class DataReader(object):
"""generator reads from source line-by-line"""
def __init__(self, filename, pipe=False):
self.buffer = ""
self.closed = False
self.broken = False
self.pipe = pipe
if not self.pipe:
try:
self.monout = open(filename, 'rb')
except Exception:
logger.error("Can't open source file %s: %s", filename, exc_info=True)
self.broken = True
else:
self.monout = filename
def __iter__(self):
while not self.closed:
if self.broken:
data = ''
else:
data = self.monout.readline().decode('utf8')
if data:
parts = data.rsplit('\n', 1)
if len(parts) > 1:
ready_chunk = self.buffer + parts[0] + '\n'
self.buffer = parts[1]
yield ready_chunk
else:
self.buffer += parts[0]
else:
yield None
if not self.pipe:
self.monout.close()
def close(self):
self.closed = True
class Consolidator(object):
"""generator consolidates data from source, cache it by timestamp"""
def __init__(self, sources):
self.sources = sources
self.results = {}
def append_chunk(self, source, chunk):
try:
data = json.loads(chunk)
except ValueError:
logger.error('unable to decode chunk %s', chunk, exc_info=True)
else:
try:
ts = data['timestamp']
self.results.setdefault(ts, {})
for key, value in data['fields'].items():
if data['name'] == 'diskio':
data['name'] = "{metric_name}-{disk_id}".format(
metric_name=data['name'],
disk_id=data['tags']['name'])
elif data['name'] == 'net':
data['name'] = "{metric_name}-{interface}".format(
metric_name=data['name'],
interface=data['tags']['interface'])
elif data['name'] == 'cpu':
data['name'] = "{metric_name}-{cpu_id}".format(
metric_name=data['name'],
cpu_id=data['tags']['cpu'])
key = data['name'] + "_" + key
if key.endswith('_exec_value'):
key = key.replace('_exec_value', '')
self.results[ts][key] = value
except KeyError:
logger.error(
'Malformed json from source %s: %s',
source,
chunk,
exc_info=True)
except BaseException:
logger.error(
'Something nasty happend in consolidator work',
exc_info=True)
def __iter__(self):
while True:
for s in self.sources:
chunk_limit = 10
chunks_done = 0
chunk = next(s)
while chunk and chunks_done < chunk_limit:
self.append_chunk(s, chunk)
chunk = next(s)
if len(self.results) > 2:
logger.debug(
'Now in buffer: %s', list(self.results.keys()))
dump_seconds = sorted(
list(self.results.keys()))[:-2]
for ready_second in dump_seconds:
yield json.dumps({
ready_second: self.results.pop(ready_second, None)
})
time.sleep(0.5)
class Drain(threading.Thread):
"""
Drain a generator to a destination that answers to put(), in a thread
"""
def __init__(self, source, destination):
super(Drain, self).__init__()
self.source = source
self.destination = destination
self._finished = threading.Event()
self._interrupted = threading.Event()
def run(self):
for item in self.source:
self.destination.put(item)
if self._interrupted.is_set():
break
self._finished.set()
def wait(self, timeout=None):
self._finished.wait(timeout=timeout)
def close(self):
self._interrupted.set()
class AgentWorker(threading.Thread):
def __init__(self, telegraf_path):
super(AgentWorker, self).__init__()
self.working_dir = os.path.dirname(__file__)
self.startups = []
self.startup_processes = []
self.shutdowns = []
self.custom_sources = []
self.daemon = True # Thread auto-shutdown
self.finished = False
self.drain = None
self.drain_stdout = None
self.drain_err = None
self.data_reader = None
self.telegraf_path = telegraf_path
self.results = q.Queue()
self.results_stdout = q.Queue()
self.results_err = q.Queue()
@staticmethod
def __popen(cmnd, shell=False):
logger.info('Starting telegraf binary:\n{}'.format(' '.join(cmnd)))
return subprocess.Popen(
cmnd,
bufsize=0,
preexec_fn=os.setsid,
close_fds=True,
shell=shell,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
stdin=subprocess.PIPE, )
def read_startup_config(self, cfg_file='agent_startup.cfg'):
try:
config = configparser.RawConfigParser(strict=False)
with open(os.path.join(self.working_dir, cfg_file), 'r') as f:
config.read_file(f)
if config.has_section('startup'):
for option in config.options('startup'):
if option.startswith('cmd'):
self.startups.append(config.get('startup', option))
if config.has_section('shutdown'):
for option in config.options('shutdown'):
if option.startswith('cmd'):
self.shutdowns.append(config.get('shutdown', option))
if config.has_section('source'):
for option in config.options('source'):
if option.startswith('file'):
self.custom_sources.append(
config.get('source', option))
logger.info(
'Successfully loaded startup config.\n'
'Startups: %s\n'
'Shutdowns: %s\n', self.startups, self.shutdowns)
except BaseException:
logger.error(
'Error trying to read agent startup config', exc_info=True)
def run(self):
logger.info("Running startup commands")
for cmnd in self.startups:
logger.debug("Run: %s", cmnd)
# fixme: shell=True is insecure, should save startup script and
# launch directly
proc = self.__popen(cmnd, shell=True)
logger.info('Started with pid %d', proc.pid)
self.startup_processes.append(proc)
logger.info('Starting metrics collector..')
# todo: add identificators into {} for python 2.6
args = [self.telegraf_path, '-config',
'{0}/agent.cfg'.format(self.working_dir)]
self.collector = self.__popen(cmnd=args)
logger.info('Started with pid %d', self.collector.pid)
telegraf_output = self.working_dir + '/monitoring.rawdata'
sources = [telegraf_output] + self.custom_sources
for _ in range(10):
self.collector.poll()
if not self.collector.returncode:
logger.info("Waiting for telegraf...")
else:
logger.info(
"Telegraf with pid %d ended with code %d",
self.collector.pid, self.collector.returncode)
if os.path.isfile(telegraf_output):
break
time.sleep(1)
self.drain = Drain(
Consolidator([iter(DataReader(f)) for f in sources]), self.results)
self.drain.start()
self.drain_stdout = Drain(
DataReader(
self.collector.stdout, pipe=True), self.results_stdout)
self.drain_stdout.start()
self.drain_err = Drain(
DataReader(
self.collector.stderr, pipe=True), self.results_err)
self.drain_err.start()
while not self.finished:
for _ in range(self.results.qsize()):
try:
data = self.results.get_nowait()
logger.debug(
'send %s bytes of data to collector', len(data))
sys.stdout.write(str(data) + '\n')
sys.stdout.flush()
except q.Empty:
break
except BaseException:
logger.error(
'Something nasty happend trying to send data',
exc_info=True)
for _ in range(self.results_stdout.qsize()):
try:
data = self.results_stdout.get_nowait()
if data:
collector_logger.info("STDOUT: %s", data)
except q.Empty:
break
for _ in range(self.results_err.qsize()):
try:
data = self.results_err.get_nowait()
if data:
collector_logger.info("STDERR: %s", data.rstrip('\n'))
except q.Empty:
break
time.sleep(1)
self.drain.close()
self.drain_stdout.close()
self.drain_err.close()
self.stop()
@staticmethod
def proc_stop(proc, kill=False):
proc.poll()
if proc.returncode is None:
try:
if kill:
logger.info("Killing PID %s", proc.pid)
os.killpg(proc.pid, signal.SIGKILL)
else:
logger.debug("Terminating: %s", proc.pid)
os.killpg(proc.pid, signal.SIGTERM)
proc.wait()
logger.info(
'Retcode for PID %s %s', proc.pid, proc.returncode)
except OSError as ex:
if ex.errno == 3:
logger.info("PID %s already died", proc.pid)
def kill(self):
logger.info("Forced stop")
for proc in self.startup_processes:
self.proc_stop(proc, kill=True)
self.proc_stop(self.collector, kill=True)
def stop(self):
logger.info("Terminating startup commands")
for proc in self.startup_processes:
self.proc_stop(proc)
logger.info('Terminating collector process: %s', self.collector)
self.proc_stop(self.collector)
logger.info("Running shutdown commands")
for cmnd in self.shutdowns:
logger.debug("Run: %s", cmnd)
subprocess.call(cmnd, shell=True)
self.finished = True
logger.info("Worker thread finished")
sys.stderr.write('stopped\n')
def kill_old_agents(telegraf_path):
my_pid = os.getpid()
parent = os.getppid()
logger.info('My pid: {0} Parent pid: {1}'.format(my_pid, parent))
ps_output = subprocess.check_output(['ps', 'aux'])
for line in ps_output.splitlines():
if telegraf_path in line:
pid = int(line.split()[1])
logger.info('Found pid: {0}'.format(pid))
if pid not in [my_pid, parent]:
logger.info('Killing process {0}:\n{1}'.format(pid, line))
os.kill(pid, signal.SIGKILL)
def main():
fname = os.path.dirname(__file__) + "/_agent.log"
logging.basicConfig(
level=logging.DEBUG,
filename=fname,
format='%(asctime)s [%(levelname)s] %(name)s:%(lineno)d %(message)s')
parser = ArgumentParser()
parser.add_argument(
"--telegraf",
dest="telegraf_path",
help="telegraf_path",
default="/tmp/telegraf")
parser.add_argument(
"--host",
dest="hostname_path",
help="telegraf_path",
default="/usr/bin/telegraf")
parser.add_argument(
"-k", "--kill-old",
action="store_true",
dest="kill_old"
)
options = parser.parse_args()
logger.info('Init')
customs_script = os.path.dirname(__file__) + '/agent_customs.sh'
# todo: deprecate
if options.kill_old:
kill_old_agents(options.telegraf_path)
try:
logger.info(
'Trying to make telegraf executable: %s', options.telegraf_path)
# 0o755 compatible with old python versions. 744 is NOT enough
os.chmod(options.telegraf_path, 493)
except OSError:
logger.warning(
'Unable to set %s access rights to execute.',
options.telegraf_path,
exc_info=True)
try:
logger.info(
'Trying to make customs script executable: %s', customs_script)
# 0o755 compatible with old python versions. 744 is NOT enough
os.chmod(customs_script, 493)
except OSError:
logger.warning(
'Unable to set %s access rights to execute.',
customs_script,
exc_info=True)
worker = AgentWorker(options.telegraf_path)
worker.read_startup_config()
logger.info('Starting AgentWorker: %s', worker)
worker.start()
try:
logger.debug("Check for any stdin command for shutdown")
cmd = sys.stdin.readline()
if cmd:
logger.info("Stdin cmd received: %s", cmd)
except KeyboardInterrupt:
logger.debug("Interrupted")
except BaseException:
logger.error(
"Something nasty happened while waiting for stop", exc_info=True)
worker.finished = True
agent_finished = False
while not agent_finished:
try:
if worker.isAlive():
logger.debug("Join the worker thread, waiting for cleanup")
worker.join(10)
if worker.isAlive():
logger.error(
"Worker have not finished shutdown in 10 seconds, going to exit anyway"
)
worker.kill()
agent_finished = True
else:
agent_finished = True
except BaseException:
logger.info(
"Something nasty happened while waiting for worker shutdown",
exc_info=True)
if __name__ == '__main__':
set_sig_handler()
main()
|
import unittest, sys
from lxml.tests.common_imports import make_doctest, HelperTestCase
try:
import lxml.html.soupparser
BS_INSTALLED = True
except ImportError:
if 'bs4' in sys.modules or 'BeautifulSoup' in sys.modules:
raise # seems we managed to import BS but not soupparser
BS_INSTALLED = False
from lxml.html import tostring
if BS_INSTALLED:
class SoupParserTestCase(HelperTestCase):
soupparser = lxml.html.soupparser
def test_broken_attribute(self):
html = """\
<html><head></head><body>
<form><input type='text' disabled size='10'></form>
</body></html>
"""
root = self.soupparser.fromstring(html)
self.assertTrue(root.find('.//input').get('disabled') is not None)
def test_empty(self):
tree = self.soupparser.fromstring('')
res = b'''<html></html>'''
self.assertEqual(tostring(tree), res)
def test_text(self):
tree = self.soupparser.fromstring('huhu')
res = b'''<html>huhu</html>'''
self.assertEqual(tostring(tree), res)
def test_body(self):
html = '''<body><p>test</p></body>'''
res = b'''<html><body><p>test</p></body></html>'''
tree = self.soupparser.fromstring(html)
self.assertEqual(tostring(tree), res)
def test_head_body(self):
# HTML tag missing, parser should fix that
html = '<head><title>test</title></head><body><p>test</p></body>'
res = b'<html><head><title>test</title></head><body><p>test</p></body></html>'
tree = self.soupparser.fromstring(html)
self.assertEqual(tostring(tree), res)
def test_wrap_html(self):
# <head> outside <html>, parser should fix that
html = '<head><title>title</test></head><html><body/></html>'
res = b'<html><head><title>title</title></head><body></body></html>'
tree = self.soupparser.fromstring(html)
self.assertEqual(tostring(tree), res)
def test_comment_hyphen(self):
# These are really invalid XML as per specification
# https://www.w3.org/TR/REC-xml/#sec-comments
html = b'<html><!-- comment -- with double-hyphen --></html>'
tree = self.soupparser.fromstring(html)
self.assertEqual(tostring(tree), html)
html = b'<html><!-- comment ends with hyphen ---></html>'
tree = self.soupparser.fromstring(html)
self.assertEqual(tostring(tree), html)
def test_comment_pi(self):
html = '''<!-- comment -->
<?test asdf?>
<head><title>test</title></head><body><p>test</p></body>
<!-- another comment -->'''
res = b'''<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/loose.dtd">
<!-- comment --><?test asdf?><html><head><title>test</title></head><body><p>test</p></body></html><!-- another comment -->'''
tree = self.soupparser.fromstring(html).getroottree()
self.assertEqual(tostring(tree, method='html'), res)
def test_doctype1(self):
# Test document type declaration, comments and PI's
# outside the root
html = \
'''<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<!--another comment--><html><head><title>My first HTML document</title></head><body><p>Hello world!</p></body></html><?foo bar>'''
res = \
b'''<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<!--another comment--><html><head><title>My first HTML document</title></head><body><p>Hello world!</p></body></html><?foo bar?>'''
tree = self.soupparser.fromstring(html).getroottree()
self.assertEqual(tree.docinfo.public_id, "-//W3C//DTD HTML 4.01//EN")
self.assertEqual(tostring(tree), res)
def test_doctype2(self):
# Test document type declaration, comments and PI's
# outside the root
html = \
'''<!DOCTYPE html PUBLIC "-//IETF//DTD HTML//EN">
<!--another comment--><html><head><title>My first HTML document</title></head><body><p>Hello world!</p></body></html><?foo bar?>'''
res = \
b'''<!DOCTYPE html PUBLIC "-//IETF//DTD HTML//EN">
<!--another comment--><html><head><title>My first HTML document</title></head><body><p>Hello world!</p></body></html><?foo bar?>'''
tree = self.soupparser.fromstring(html).getroottree()
self.assertEqual(tree.docinfo.public_id, "-//IETF//DTD HTML//EN")
self.assertEqual(tostring(tree), res)
def test_doctype_html5(self):
# html 5 doctype declaration
html = b'<!DOCTYPE html>\n<html lang="en"></html>'
tree = self.soupparser.fromstring(html).getroottree()
self.assertTrue(tree.docinfo.public_id is None)
self.assertEqual(tostring(tree), html)
def test_suite():
suite = unittest.TestSuite()
if BS_INSTALLED:
suite.addTests([unittest.makeSuite(SoupParserTestCase)])
if sys.version_info[0] < 3:
suite.addTests([make_doctest('../../../../doc/elementsoup.txt')])
return suite
if __name__ == '__main__':
unittest.main()
|
from homeassistant.const import (
ATTR_ATTRIBUTION,
ATTR_DEVICE_CLASS,
CONF_NAME,
DEVICE_CLASS_TEMPERATURE,
)
from homeassistant.helpers.update_coordinator import CoordinatorEntity
from .const import (
ATTR_FORECAST,
ATTR_ICON,
ATTR_LABEL,
ATTRIBUTION,
COORDINATOR,
DOMAIN,
FORECAST_DAYS,
FORECAST_SENSOR_TYPES,
MANUFACTURER,
NAME,
OPTIONAL_SENSORS,
SENSOR_TYPES,
)
PARALLEL_UPDATES = 1
async def async_setup_entry(hass, config_entry, async_add_entities):
"""Add AccuWeather entities from a config_entry."""
name = config_entry.data[CONF_NAME]
coordinator = hass.data[DOMAIN][config_entry.entry_id][COORDINATOR]
sensors = []
for sensor in SENSOR_TYPES:
sensors.append(AccuWeatherSensor(name, sensor, coordinator))
if coordinator.forecast:
for sensor in FORECAST_SENSOR_TYPES:
for day in FORECAST_DAYS:
# Some air quality/allergy sensors are only available for certain
# locations.
if sensor in coordinator.data[ATTR_FORECAST][0]:
sensors.append(
AccuWeatherSensor(name, sensor, coordinator, forecast_day=day)
)
async_add_entities(sensors, False)
class AccuWeatherSensor(CoordinatorEntity):
"""Define an AccuWeather entity."""
def __init__(self, name, kind, coordinator, forecast_day=None):
"""Initialize."""
super().__init__(coordinator)
self._name = name
self.kind = kind
self._device_class = None
self._attrs = {ATTR_ATTRIBUTION: ATTRIBUTION}
self._unit_system = "Metric" if self.coordinator.is_metric else "Imperial"
self.forecast_day = forecast_day
@property
def name(self):
"""Return the name."""
if self.forecast_day is not None:
return f"{self._name} {FORECAST_SENSOR_TYPES[self.kind][ATTR_LABEL]} {self.forecast_day}d"
return f"{self._name} {SENSOR_TYPES[self.kind][ATTR_LABEL]}"
@property
def unique_id(self):
"""Return a unique_id for this entity."""
if self.forecast_day is not None:
return f"{self.coordinator.location_key}-{self.kind}-{self.forecast_day}".lower()
return f"{self.coordinator.location_key}-{self.kind}".lower()
@property
def device_info(self):
"""Return the device info."""
return {
"identifiers": {(DOMAIN, self.coordinator.location_key)},
"name": NAME,
"manufacturer": MANUFACTURER,
"entry_type": "service",
}
@property
def state(self):
"""Return the state."""
if self.forecast_day is not None:
if (
FORECAST_SENSOR_TYPES[self.kind][ATTR_DEVICE_CLASS]
== DEVICE_CLASS_TEMPERATURE
):
return self.coordinator.data[ATTR_FORECAST][self.forecast_day][
self.kind
]["Value"]
if self.kind in ["WindGustDay", "WindGustNight"]:
return self.coordinator.data[ATTR_FORECAST][self.forecast_day][
self.kind
]["Speed"]["Value"]
if self.kind in ["Grass", "Mold", "Ragweed", "Tree", "UVIndex", "Ozone"]:
return self.coordinator.data[ATTR_FORECAST][self.forecast_day][
self.kind
]["Value"]
return self.coordinator.data[ATTR_FORECAST][self.forecast_day][self.kind]
if self.kind == "Ceiling":
return round(self.coordinator.data[self.kind][self._unit_system]["Value"])
if self.kind == "PressureTendency":
return self.coordinator.data[self.kind]["LocalizedText"].lower()
if SENSOR_TYPES[self.kind][ATTR_DEVICE_CLASS] == DEVICE_CLASS_TEMPERATURE:
return self.coordinator.data[self.kind][self._unit_system]["Value"]
if self.kind == "Precipitation":
return self.coordinator.data["PrecipitationSummary"][self.kind][
self._unit_system
]["Value"]
if self.kind == "WindGust":
return self.coordinator.data[self.kind]["Speed"][self._unit_system]["Value"]
return self.coordinator.data[self.kind]
@property
def icon(self):
"""Return the icon."""
if self.forecast_day is not None:
return FORECAST_SENSOR_TYPES[self.kind][ATTR_ICON]
return SENSOR_TYPES[self.kind][ATTR_ICON]
@property
def device_class(self):
"""Return the device_class."""
if self.forecast_day is not None:
return FORECAST_SENSOR_TYPES[self.kind][ATTR_DEVICE_CLASS]
return SENSOR_TYPES[self.kind][ATTR_DEVICE_CLASS]
@property
def unit_of_measurement(self):
"""Return the unit the value is expressed in."""
if self.forecast_day is not None:
return FORECAST_SENSOR_TYPES[self.kind][self._unit_system]
return SENSOR_TYPES[self.kind][self._unit_system]
@property
def device_state_attributes(self):
"""Return the state attributes."""
if self.forecast_day is not None:
if self.kind in ["WindGustDay", "WindGustNight"]:
self._attrs["direction"] = self.coordinator.data[ATTR_FORECAST][
self.forecast_day
][self.kind]["Direction"]["English"]
elif self.kind in ["Grass", "Mold", "Ragweed", "Tree", "UVIndex", "Ozone"]:
self._attrs["level"] = self.coordinator.data[ATTR_FORECAST][
self.forecast_day
][self.kind]["Category"]
return self._attrs
if self.kind == "UVIndex":
self._attrs["level"] = self.coordinator.data["UVIndexText"]
elif self.kind == "Precipitation":
self._attrs["type"] = self.coordinator.data["PrecipitationType"]
return self._attrs
@property
def entity_registry_enabled_default(self):
"""Return if the entity should be enabled when first added to the entity registry."""
return bool(self.kind not in OPTIONAL_SENSORS)
|
import asyncio
import voluptuous as vol
from homeassistant.auth.permissions.const import CAT_ENTITIES, POLICY_READ
from homeassistant.components.websocket_api.const import ERR_NOT_FOUND
from homeassistant.const import EVENT_STATE_CHANGED, EVENT_TIME_CHANGED, MATCH_ALL
from homeassistant.core import DOMAIN as HASS_DOMAIN, callback
from homeassistant.exceptions import (
HomeAssistantError,
ServiceNotFound,
TemplateError,
Unauthorized,
)
from homeassistant.helpers import config_validation as cv, entity
from homeassistant.helpers.event import TrackTemplate, async_track_template_result
from homeassistant.helpers.service import async_get_all_descriptions
from homeassistant.helpers.template import Template
from homeassistant.loader import IntegrationNotFound, async_get_integration
from . import const, decorators, messages
# mypy: allow-untyped-calls, allow-untyped-defs
@callback
def async_register_commands(hass, async_reg):
"""Register commands."""
async_reg(hass, handle_subscribe_events)
async_reg(hass, handle_unsubscribe_events)
async_reg(hass, handle_call_service)
async_reg(hass, handle_get_states)
async_reg(hass, handle_get_services)
async_reg(hass, handle_get_config)
async_reg(hass, handle_ping)
async_reg(hass, handle_render_template)
async_reg(hass, handle_manifest_list)
async_reg(hass, handle_manifest_get)
async_reg(hass, handle_entity_source)
async_reg(hass, handle_subscribe_trigger)
async_reg(hass, handle_test_condition)
def pong_message(iden):
"""Return a pong message."""
return {"id": iden, "type": "pong"}
@callback
@decorators.websocket_command(
{
vol.Required("type"): "subscribe_events",
vol.Optional("event_type", default=MATCH_ALL): str,
}
)
def handle_subscribe_events(hass, connection, msg):
"""Handle subscribe events command."""
# Circular dep
# pylint: disable=import-outside-toplevel
from .permissions import SUBSCRIBE_WHITELIST
event_type = msg["event_type"]
if event_type not in SUBSCRIBE_WHITELIST and not connection.user.is_admin:
raise Unauthorized
if event_type == EVENT_STATE_CHANGED:
@callback
def forward_events(event):
"""Forward state changed events to websocket."""
if not connection.user.permissions.check_entity(
event.data["entity_id"], POLICY_READ
):
return
connection.send_message(messages.cached_event_message(msg["id"], event))
else:
@callback
def forward_events(event):
"""Forward events to websocket."""
if event.event_type == EVENT_TIME_CHANGED:
return
connection.send_message(messages.cached_event_message(msg["id"], event))
connection.subscriptions[msg["id"]] = hass.bus.async_listen(
event_type, forward_events
)
connection.send_message(messages.result_message(msg["id"]))
@callback
@decorators.websocket_command(
{
vol.Required("type"): "unsubscribe_events",
vol.Required("subscription"): cv.positive_int,
}
)
def handle_unsubscribe_events(hass, connection, msg):
"""Handle unsubscribe events command."""
subscription = msg["subscription"]
if subscription in connection.subscriptions:
connection.subscriptions.pop(subscription)()
connection.send_message(messages.result_message(msg["id"]))
else:
connection.send_message(
messages.error_message(
msg["id"], const.ERR_NOT_FOUND, "Subscription not found."
)
)
@decorators.websocket_command(
{
vol.Required("type"): "call_service",
vol.Required("domain"): str,
vol.Required("service"): str,
vol.Optional("service_data"): dict,
}
)
@decorators.async_response
async def handle_call_service(hass, connection, msg):
"""Handle call service command."""
blocking = True
if msg["domain"] == HASS_DOMAIN and msg["service"] in ["restart", "stop"]:
blocking = False
try:
await hass.services.async_call(
msg["domain"],
msg["service"],
msg.get("service_data"),
blocking,
connection.context(msg),
)
connection.send_message(
messages.result_message(msg["id"], {"context": connection.context(msg)})
)
except ServiceNotFound as err:
if err.domain == msg["domain"] and err.service == msg["service"]:
connection.send_message(
messages.error_message(
msg["id"], const.ERR_NOT_FOUND, "Service not found."
)
)
else:
connection.send_message(
messages.error_message(
msg["id"], const.ERR_HOME_ASSISTANT_ERROR, str(err)
)
)
except HomeAssistantError as err:
connection.logger.exception(err)
connection.send_message(
messages.error_message(msg["id"], const.ERR_HOME_ASSISTANT_ERROR, str(err))
)
except Exception as err: # pylint: disable=broad-except
connection.logger.exception(err)
connection.send_message(
messages.error_message(msg["id"], const.ERR_UNKNOWN_ERROR, str(err))
)
@callback
@decorators.websocket_command({vol.Required("type"): "get_states"})
def handle_get_states(hass, connection, msg):
"""Handle get states command."""
if connection.user.permissions.access_all_entities("read"):
states = hass.states.async_all()
else:
entity_perm = connection.user.permissions.check_entity
states = [
state
for state in hass.states.async_all()
if entity_perm(state.entity_id, "read")
]
connection.send_message(messages.result_message(msg["id"], states))
@decorators.websocket_command({vol.Required("type"): "get_services"})
@decorators.async_response
async def handle_get_services(hass, connection, msg):
"""Handle get services command."""
descriptions = await async_get_all_descriptions(hass)
connection.send_message(messages.result_message(msg["id"], descriptions))
@callback
@decorators.websocket_command({vol.Required("type"): "get_config"})
def handle_get_config(hass, connection, msg):
"""Handle get config command."""
connection.send_message(messages.result_message(msg["id"], hass.config.as_dict()))
@decorators.websocket_command({vol.Required("type"): "manifest/list"})
@decorators.async_response
async def handle_manifest_list(hass, connection, msg):
"""Handle integrations command."""
integrations = await asyncio.gather(
*[
async_get_integration(hass, domain)
for domain in hass.config.components
# Filter out platforms.
if "." not in domain
]
)
connection.send_result(
msg["id"], [integration.manifest for integration in integrations]
)
@decorators.websocket_command(
{vol.Required("type"): "manifest/get", vol.Required("integration"): str}
)
@decorators.async_response
async def handle_manifest_get(hass, connection, msg):
"""Handle integrations command."""
try:
integration = await async_get_integration(hass, msg["integration"])
connection.send_result(msg["id"], integration.manifest)
except IntegrationNotFound:
connection.send_error(msg["id"], const.ERR_NOT_FOUND, "Integration not found")
@callback
@decorators.websocket_command({vol.Required("type"): "ping"})
def handle_ping(hass, connection, msg):
"""Handle ping command."""
connection.send_message(pong_message(msg["id"]))
@decorators.websocket_command(
{
vol.Required("type"): "render_template",
vol.Required("template"): str,
vol.Optional("entity_ids"): cv.entity_ids,
vol.Optional("variables"): dict,
vol.Optional("timeout"): vol.Coerce(float),
}
)
@decorators.async_response
async def handle_render_template(hass, connection, msg):
"""Handle render_template command."""
template_str = msg["template"]
template = Template(template_str, hass)
variables = msg.get("variables")
timeout = msg.get("timeout")
info = None
if timeout:
try:
timed_out = await template.async_render_will_timeout(timeout)
except TemplateError as ex:
connection.send_error(msg["id"], const.ERR_TEMPLATE_ERROR, str(ex))
return
if timed_out:
connection.send_error(
msg["id"],
const.ERR_TEMPLATE_ERROR,
f"Exceeded maximum execution time of {timeout}s",
)
return
@callback
def _template_listener(event, updates):
nonlocal info
track_template_result = updates.pop()
result = track_template_result.result
if isinstance(result, TemplateError):
connection.send_error(msg["id"], const.ERR_TEMPLATE_ERROR, str(result))
return
connection.send_message(
messages.event_message(
msg["id"], {"result": result, "listeners": info.listeners} # type: ignore
)
)
try:
info = async_track_template_result(
hass,
[TrackTemplate(template, variables)],
_template_listener,
raise_on_template_error=True,
)
except TemplateError as ex:
connection.send_error(msg["id"], const.ERR_TEMPLATE_ERROR, str(ex))
return
connection.subscriptions[msg["id"]] = info.async_remove
connection.send_result(msg["id"])
hass.loop.call_soon_threadsafe(info.async_refresh)
@callback
@decorators.websocket_command(
{vol.Required("type"): "entity/source", vol.Optional("entity_id"): [cv.entity_id]}
)
def handle_entity_source(hass, connection, msg):
"""Handle entity source command."""
raw_sources = entity.entity_sources(hass)
entity_perm = connection.user.permissions.check_entity
if "entity_id" not in msg:
if connection.user.permissions.access_all_entities("read"):
sources = raw_sources
else:
sources = {
entity_id: source
for entity_id, source in raw_sources.items()
if entity_perm(entity_id, "read")
}
connection.send_message(messages.result_message(msg["id"], sources))
return
sources = {}
for entity_id in msg["entity_id"]:
if not entity_perm(entity_id, "read"):
raise Unauthorized(
context=connection.context(msg),
permission=POLICY_READ,
perm_category=CAT_ENTITIES,
)
source = raw_sources.get(entity_id)
if source is None:
connection.send_error(msg["id"], ERR_NOT_FOUND, "Entity not found")
return
sources[entity_id] = source
connection.send_result(msg["id"], sources)
@callback
@decorators.websocket_command(
{
vol.Required("type"): "subscribe_trigger",
vol.Required("trigger"): cv.TRIGGER_SCHEMA,
vol.Optional("variables"): dict,
}
)
@decorators.require_admin
@decorators.async_response
async def handle_subscribe_trigger(hass, connection, msg):
"""Handle subscribe trigger command."""
# Circular dep
# pylint: disable=import-outside-toplevel
from homeassistant.helpers import trigger
trigger_config = await trigger.async_validate_trigger_config(hass, msg["trigger"])
@callback
def forward_triggers(variables, context=None):
"""Forward events to websocket."""
connection.send_message(
messages.event_message(
msg["id"], {"variables": variables, "context": context}
)
)
connection.subscriptions[msg["id"]] = (
await trigger.async_initialize_triggers(
hass,
trigger_config,
forward_triggers,
const.DOMAIN,
const.DOMAIN,
connection.logger.log,
variables=msg.get("variables"),
)
) or (
# Some triggers won't return an unsub function. Since the caller expects
# a subscription, we're going to fake one.
lambda: None
)
connection.send_result(msg["id"])
@decorators.websocket_command(
{
vol.Required("type"): "test_condition",
vol.Required("condition"): cv.CONDITION_SCHEMA,
vol.Optional("variables"): dict,
}
)
@decorators.require_admin
@decorators.async_response
async def handle_test_condition(hass, connection, msg):
"""Handle test condition command."""
# Circular dep
# pylint: disable=import-outside-toplevel
from homeassistant.helpers import condition
check_condition = await condition.async_from_config(hass, msg["condition"])
connection.send_result(
msg["id"], {"result": check_condition(hass, msg.get("variables"))}
)
|
from datetime import timedelta
from urllib.parse import urlparse
import av
import pytest
from homeassistant.components.stream import request_stream
from homeassistant.const import HTTP_NOT_FOUND
from homeassistant.setup import async_setup_component
import homeassistant.util.dt as dt_util
from tests.async_mock import patch
from tests.common import async_fire_time_changed
from tests.components.stream.common import generate_h264_video, preload_stream
@pytest.mark.skip("Flaky in CI")
async def test_hls_stream(hass, hass_client):
"""
Test hls stream.
Purposefully not mocking anything here to test full
integration with the stream component.
"""
await async_setup_component(hass, "stream", {"stream": {}})
# Setup demo HLS track
source = generate_h264_video()
stream = preload_stream(hass, source)
stream.add_provider("hls")
# Request stream
url = request_stream(hass, source)
http_client = await hass_client()
# Fetch playlist
parsed_url = urlparse(url)
playlist_response = await http_client.get(parsed_url.path)
assert playlist_response.status == 200
# Fetch init
playlist = await playlist_response.text()
playlist_url = "/".join(parsed_url.path.split("/")[:-1])
init_url = playlist_url + "/init.mp4"
init_response = await http_client.get(init_url)
assert init_response.status == 200
# Fetch segment
playlist = await playlist_response.text()
playlist_url = "/".join(parsed_url.path.split("/")[:-1])
segment_url = playlist_url + playlist.splitlines()[-1][1:]
segment_response = await http_client.get(segment_url)
assert segment_response.status == 200
# Stop stream, if it hasn't quit already
stream.stop()
# Ensure playlist not accessible after stream ends
fail_response = await http_client.get(parsed_url.path)
assert fail_response.status == HTTP_NOT_FOUND
@pytest.mark.skip("Flaky in CI")
async def test_stream_timeout(hass, hass_client):
"""Test hls stream timeout."""
await async_setup_component(hass, "stream", {"stream": {}})
# Setup demo HLS track
source = generate_h264_video()
stream = preload_stream(hass, source)
stream.add_provider("hls")
# Request stream
url = request_stream(hass, source)
http_client = await hass_client()
# Fetch playlist
parsed_url = urlparse(url)
playlist_response = await http_client.get(parsed_url.path)
assert playlist_response.status == 200
# Wait a minute
future = dt_util.utcnow() + timedelta(minutes=1)
async_fire_time_changed(hass, future)
# Fetch again to reset timer
playlist_response = await http_client.get(parsed_url.path)
assert playlist_response.status == 200
# Wait 5 minutes
future = dt_util.utcnow() + timedelta(minutes=5)
async_fire_time_changed(hass, future)
# Ensure playlist not accessible
fail_response = await http_client.get(parsed_url.path)
assert fail_response.status == HTTP_NOT_FOUND
@pytest.mark.skip("Flaky in CI")
async def test_stream_ended(hass):
"""Test hls stream packets ended."""
await async_setup_component(hass, "stream", {"stream": {}})
# Setup demo HLS track
source = generate_h264_video()
stream = preload_stream(hass, source)
track = stream.add_provider("hls")
# Request stream
request_stream(hass, source)
# Run it dead
while True:
segment = await track.recv()
if segment is None:
break
segments = segment.sequence
assert segments > 1
assert not track.get_segment()
# Stop stream, if it hasn't quit already
stream.stop()
async def test_stream_keepalive(hass):
"""Test hls stream retries the stream when keepalive=True."""
await async_setup_component(hass, "stream", {"stream": {}})
# Setup demo HLS track
source = "test_stream_keepalive_source"
stream = preload_stream(hass, source)
track = stream.add_provider("hls")
track.num_segments = 2
cur_time = 0
def time_side_effect():
nonlocal cur_time
if cur_time >= 80:
stream.keepalive = False # Thread should exit and be joinable.
cur_time += 40
return cur_time
with patch("av.open") as av_open, patch(
"homeassistant.components.stream.worker.time"
) as mock_time:
av_open.side_effect = av.error.InvalidDataError(-2, "error")
mock_time.time.side_effect = time_side_effect
# Request stream
request_stream(hass, source, keepalive=True)
stream._thread.join()
stream._thread = None
assert av_open.call_count == 2
# Stop stream, if it hasn't quit already
stream.stop()
|
import pytest
import sys
import os
import socket
import time
import logging
import plumbum
from copy import deepcopy
from plumbum import RemotePath, SshMachine, CommandNotFound, ProcessExecutionError, local, ProcessTimedOut, NOHUP
from plumbum import CommandNotFound
from plumbum.lib import six
from plumbum.machines.session import IncorrectLogin, HostPublicKeyUnknown
from plumbum._testtools import skip_without_chown, skip_on_windows
try:
import paramiko
except ImportError:
paramiko = None
else:
from plumbum.machines.paramiko_machine import ParamikoMachine
def strassert(one, two):
assert str(one) == str(two)
#TEST_HOST = "192.168.1.143"
TEST_HOST = "127.0.0.1"
if TEST_HOST not in ("::1", "127.0.0.1", "localhost"):
plumbum.local.env.path.append("c:\\Program Files\\Git\\bin")
@pytest.fixture(scope='session')
def sshpass():
try:
return plumbum.local['sshpass']
except CommandNotFound:
pytest.skip('Test requires sshpass')
@skip_on_windows
def test_connection():
SshMachine(TEST_HOST)
def test_incorrect_login(sshpass):
def connect():
SshMachine(TEST_HOST, password='swordfish',
ssh_opts=['-o', 'PubkeyAuthentication=no',
'-o', 'PreferredAuthentications=password'])
pytest.raises(IncorrectLogin, connect)
def test_hostpubkey_unknown(sshpass):
def connect():
SshMachine(TEST_HOST, password='swordfish',
ssh_opts=['-o', 'UserKnownHostsFile=/dev/null',
'-o', 'UpdateHostKeys=no'])
pytest.raises(HostPublicKeyUnknown, connect)
@skip_on_windows
class TestRemotePath:
def _connect(self):
return SshMachine(TEST_HOST)
def test_name(self):
name = RemotePath(self._connect(), "/some/long/path/to/file.txt").name
assert isinstance(name, six.string_types)
assert "file.txt" == str(name)
def test_dirname(self):
name = RemotePath(self._connect(), "/some/long/path/to/file.txt").dirname
assert isinstance(name, RemotePath)
assert "/some/long/path/to" == str(name)
def test_uri(self):
p1 = RemotePath(self._connect(), "/some/long/path/to/file.txt")
assert "ftp://" == p1.as_uri('ftp')[:6]
assert "ssh://" == p1.as_uri('ssh')[:6]
assert "/some/long/path/to/file.txt" == p1.as_uri()[-27:]
def test_stem(self):
p = RemotePath(self._connect(), "/some/long/path/to/file.txt")
assert p.stem == "file"
p = RemotePath(self._connect(), "/some/long/path/")
assert p.stem == "path"
def test_suffix(self):
p1 = RemotePath(self._connect(), "/some/long/path/to/file.txt")
p2 = RemotePath(self._connect(), "file.tar.gz")
assert p1.suffix == ".txt"
assert p1.suffixes == [".txt"]
assert p2.suffix == ".gz"
assert p2.suffixes == [".tar",".gz"]
strassert(p1.with_suffix(".tar.gz"), RemotePath(self._connect(), "/some/long/path/to/file.tar.gz"))
strassert(p2.with_suffix(".other"), RemotePath(self._connect(), "file.tar.other"))
strassert(p2.with_suffix(".other", 2), RemotePath(self._connect(), "file.other"))
strassert(p2.with_suffix(".other", 0), RemotePath(self._connect(), "file.tar.gz.other"))
strassert(p2.with_suffix(".other", None), RemotePath(self._connect(), "file.other"))
def test_newname(self):
p1 = RemotePath(self._connect(), "/some/long/path/to/file.txt")
p2 = RemotePath(self._connect(), "file.tar.gz")
strassert(p1.with_name("something.tar"), RemotePath(self._connect(), "/some/long/path/to/something.tar"))
strassert(p2.with_name("something.tar"), RemotePath(self._connect(), "something.tar"))
@skip_without_chown
def test_chown(self):
with self._connect() as rem:
with rem.tempdir() as dir:
p = dir / "foo.txt"
p.write(six.b("hello"))
# because we're connected to localhost, we expect UID and GID to be the same
assert p.uid == os.getuid()
assert p.gid == os.getgid()
p.chown(p.uid.name)
assert p.uid == os.getuid()
def test_parent(self):
p1 = RemotePath(self._connect(), "/some/long/path/to/file.txt")
p2 = p1.parent
assert str(p2) == "/some/long/path/to"
def test_mkdir(self):
# (identical to test_local.TestLocalPath.test_mkdir)
with self._connect() as rem:
with rem.tempdir() as tmp:
(tmp / "a").mkdir(exist_ok=False, parents=False)
assert (tmp / "a").exists()
assert (tmp / "a").is_dir()
(tmp / "a").mkdir(exist_ok=True, parents=False)
(tmp / "a").mkdir(exist_ok=True, parents=True)
with pytest.raises(OSError):
(tmp / "a").mkdir(exist_ok=False, parents=False)
with pytest.raises(OSError):
(tmp / "a").mkdir(exist_ok=False, parents=True)
(tmp / "b" / "bb").mkdir(exist_ok=False, parents=True)
assert (tmp / "b" / "bb").exists()
assert (tmp / "b" / "bb").is_dir()
assert not tmp.exists()
@pytest.mark.xfail(reason="mkdir's mode argument is not yet implemented "\
"for remote paths", strict=True)
def test_mkdir_mode(self):
# (identical to test_local.TestLocalPath.test_mkdir_mode)
with self._connect() as rem:
with rem.tempdir() as tmp:
# just verify that mode argument works the same way it does for
# Python's own os.mkdir, which takes into account the umask
# (different from shell mkdir mode argument!); umask on my
# system is 022 by default, so 033 is ok for testing this
try:
(tmp / "pb_333").mkdir(exist_ok=False, parents=False,
mode=0o333)
rem.python('-c', 'import os; os.mkdir({0}, 0o333)'.format(
repr(str(tmp / "py_333"))))
pb_final_mode = oct((tmp / "pb_333").stat().st_mode)
py_final_mode = oct((tmp / "py_333").stat().st_mode)
assert pb_final_mode == py_final_mode
finally:
# we have to revert this so the tempdir deletion works
if (tmp / "pb_333").exists():
(tmp / "pb_333").chmod(0o777)
if (tmp / "py_333").exists():
(tmp / "py_333").chmod(0o777)
assert not tmp.exists()
def test_copy(self):
"""
tests `RemotePath.copy` for the following scenarios:
* copying a simple file from `file_a` to `copy_of_a` succeeds
* copying file `file_a` into a directory `a_dir/copy_of_a` succeeds
* copying a directory `a_dir` over an existing directory path with
`override=False` fails
* copying a directory `a_dir` over an existing directory path with
`override=True` succeeds
"""
with self._connect() as rem:
with rem.tempdir() as tmp:
# setup a file and make sure it exists...
(tmp / "file_a").touch()
assert (tmp / "file_a").exists()
assert (tmp / "file_a").is_file()
# setup a directory for copying into...
(tmp / "a_dir").mkdir(exist_ok=False, parents=False)
assert (tmp / "a_dir").exists()
assert (tmp / "a_dir").is_dir()
# setup a 2nd directory for testing `override=False`
(tmp / "b_dir").mkdir(exist_ok=False, parents=False)
assert (tmp / "b_dir").exists()
assert (tmp / "b_dir").is_dir()
# copying a simple file
(tmp / "file_a").copy(tmp / "copy_of_a")
assert (tmp / "copy_of_a").exists()
assert (tmp / "copy_of_a").is_file()
# copying into a directory
(tmp / "file_a").copy(tmp / "a_dir/copy_of_a")
assert (tmp / "a_dir/copy_of_a").exists()
assert (tmp / "a_dir/copy_of_a").is_file()
# copying a directory on top of an existing directory using
# `override=False` (should fail with TypeError)
with pytest.raises(TypeError):
(tmp / "a_dir").copy(tmp / "b_dir", override=False)
# copying a directory on top of an existing directory using
# `override=True` (should copy transparently)
(tmp / "a_dir").copy(tmp / "b_dir", override=True)
assert "copy_of_a" in (tmp / "b_dir")
assert not tmp.exists()
class BaseRemoteMachineTest(object):
TUNNEL_PROG = r"""import sys, socket
s = socket.socket()
s.bind(("", 0))
s.listen(1)
sys.stdout.write("{0}\n".format( s.getsockname()[1]))
sys.stdout.flush()
s2, _ = s.accept()
data = s2.recv(100)
s2.send(b"hello " + data)
s2.close()
s.close()
"""
def test_basic(self):
with self._connect() as rem:
r_ssh = rem["ssh"]
r_ls = rem["ls"]
r_grep = rem["grep"]
lines = r_ls("-a").splitlines()
assert ".bashrc" in lines or ".bash_profile" in lines
with rem.cwd(os.path.dirname(os.path.abspath(__file__))):
cmd = r_ssh["localhost", "cd", rem.cwd, "&&", r_ls, "|", r_grep["\\.py"]]
assert "'|'" in str(cmd)
assert "test_remote.py" in cmd()
assert "test_remote.py" in [f.name for f in rem.cwd // "*.py"]
# Testing for #271
def test_double_chdir(self):
with self._connect() as rem:
with rem.cwd(os.path.dirname(os.path.abspath(__file__))):
rem["ls"]()
with rem.cwd("/tmp"):
rem["pwd"]()
def test_glob(self):
with self._connect() as rem:
with rem.cwd(os.path.dirname(os.path.abspath(__file__))):
filenames = [f.name for f in rem.cwd // ("*.py", "*.bash")]
assert "test_remote.py" in filenames
assert "slow_process.bash" in filenames
def test_glob_spaces(self):
with self._connect() as rem:
with rem.cwd(os.path.dirname(os.path.abspath(__file__))):
filenames = [f.name for f in rem.cwd // ("*space.txt")]
assert "file with space.txt" in filenames
filenames = [f.name for f in rem.cwd // ("*with space.txt")]
assert "file with space.txt" in filenames
def test_cmd(self):
with self._connect() as rem:
rem.cmd.ls("/tmp")
@pytest.mark.usefixtures("testdir")
def test_download_upload(self):
with self._connect() as rem:
rem.upload("test_remote.py", "/tmp")
r_ls = rem["ls"]
r_rm = rem["rm"]
assert "test_remote.py" in r_ls("/tmp").splitlines()
rem.download("/tmp/test_remote.py", "/tmp/test_download.txt")
r_rm("/tmp/test_remote.py")
r_rm("/tmp/test_download.txt")
def test_session(self):
with self._connect() as rem:
sh = rem.session()
for _ in range(4):
_, out, _ = sh.run("ls -a")
assert ".bashrc" in out or ".bash_profile" in out
def test_env(self):
with self._connect() as rem:
with pytest.raises(ProcessExecutionError):
rem.python("-c", "import os;os.environ['FOOBAR72']")
with rem.env(FOOBAR72 = "lala"):
with rem.env(FOOBAR72 = "baba"):
out = rem.python("-c", "import os;print(os.environ['FOOBAR72'])")
assert out.strip() == "baba"
out = rem.python("-c", "import os;print(os.environ['FOOBAR72'])")
assert out.strip() == "lala"
# path manipulation
with pytest.raises(CommandNotFound):
rem.which("dummy-executable")
with rem.cwd(os.path.dirname(os.path.abspath(__file__))):
rem.env.path.insert(0, rem.cwd / "not-in-path")
p = rem.which("dummy-executable")
assert p == rem.cwd / "not-in-path" / "dummy-executable"
@pytest.mark.parametrize(
"env",
["lala", "-Wl,-O2 -Wl,--sort-common", "{{}}", "''", "!@%_-+=:", "'",
"`", "$", "\\"])
def test_env_special_characters(self, env):
with self._connect() as rem:
with pytest.raises(ProcessExecutionError):
rem.python("-c", "import os;print(os.environ['FOOBAR72'])")
rem.env["FOOBAR72"] = env
out = rem.python("-c", "import os;print(os.environ['FOOBAR72'])")
assert out.strip() == env
def test_read_write(self):
with self._connect() as rem:
with rem.tempdir() as dir:
assert dir.is_dir()
data = six.b("hello world")
(dir / "foo.txt").write(data)
assert (dir / "foo.txt").read() == data
assert not dir.exists()
def test_contains(self):
with self._connect() as rem:
assert "ls" in rem
def test_iter_lines_timeout(self):
with self._connect() as rem:
try:
for i, (out, err) in enumerate(rem["ping"]["-i", 0.5, "127.0.0.1"].popen().iter_lines(timeout=4)):
print("out:", out)
print("err:", err)
except NotImplementedError:
try:
pytest.skip(str(sys.exc_info()[1]))
except AttributeError:
return
except ProcessTimedOut:
assert i > 3
else:
pytest.fail("Expected a timeout")
def test_iter_lines_error(self):
with self._connect() as rem:
with pytest.raises(ProcessExecutionError) as ex:
for i, lines in enumerate(rem["ls"]["--bla"].popen()):
pass
assert i == 1
assert "/bin/ls: " in ex.value.stderr
def test_touch(self):
with self._connect() as rem:
rfile = rem.cwd / 'sillyfile'
assert not rfile.exists()
rfile.touch()
assert rfile.exists()
rfile.delete()
@skip_on_windows
class TestRemoteMachine(BaseRemoteMachineTest):
def _connect(self):
return SshMachine(TEST_HOST)
def test_tunnel(self):
with self._connect() as rem:
p = (rem.python["-u"] << self.TUNNEL_PROG).popen()
try:
port = int(p.stdout.readline().decode("ascii").strip())
except ValueError:
print(p.communicate())
raise
with rem.tunnel(12222, port) as tun:
s = socket.socket()
s.connect(("localhost", 12222))
s.send(six.b("world"))
data = s.recv(100)
s.close()
print(p.communicate())
assert data == b"hello world"
def test_get(self):
with self._connect() as rem:
assert str(rem['ls']) == str(rem.get('ls'))
assert str(rem['ls']) == str(rem.get('not_a_valid_process_234','ls'))
assert 'ls' in rem
assert 'not_a_valid_process_234' not in rem
def test_list_processes(self):
with self._connect() as rem:
assert list(rem.list_processes())
def test_pgrep(self):
with self._connect() as rem:
assert list(rem.pgrep("ssh"))
@pytest.mark.xfail(reason="Randomly does not work on Travis, not sure why")
def test_nohup(self):
with self._connect() as rem:
sleep = rem["sleep"]
sleep["5.793817"] & NOHUP(stdout = None, append=False)
time.sleep(.5)
print(rem["ps"]("aux"))
assert list(rem.pgrep("5.793817"))
time.sleep(6)
assert not list(rem.pgrep("5.793817"))
def test_bound_env(self):
with self._connect() as rem:
printenv = rem["printenv"]
with rem.env(FOO = "hello"):
assert printenv.with_env(BAR = "world")("FOO") == "hello\n"
assert printenv.with_env(BAR = "world")("BAR") == "world\n"
assert printenv.with_env(FOO = "sea", BAR = "world")("FOO") == "sea\n"
assert printenv.with_env(FOO = "sea", BAR = "world")("BAR") == "world\n"
@pytest.mark.skipif('useradd' not in local,
reason = "System does not have useradd (Mac?)")
def test_sshpass(self):
with local.as_root():
local["useradd"]("-m", "-b", "/tmp", "testuser")
try:
with local.as_root():
try:
(local["passwd"] << "123456")("--stdin", "testuser")
except ProcessExecutionError:
# some versions of passwd don't support --stdin, nothing to do in this case
logging.warn("passwd failed")
return
with SshMachine("localhost", user = "testuser", password = "123456") as rem:
assert rem["pwd"]().strip() == "/tmp/testuser"
finally:
with local.as_root():
local["userdel"]("-r", "testuser")
@skip_on_windows
class TestParamikoMachine(BaseRemoteMachineTest):
def _connect(self):
if paramiko is None:
pytest.skip("System does not have paramiko installed")
return ParamikoMachine(TEST_HOST, missing_host_policy = paramiko.AutoAddPolicy())
def test_tunnel(self):
with self._connect() as rem:
p = rem.python["-c", self.TUNNEL_PROG].popen()
try:
port = int(p.stdout.readline().strip())
except ValueError:
print(p.communicate())
raise
s = rem.connect_sock(port)
s.send(b"world")
data = s.recv(100)
s.close()
print(p.communicate())
assert data == b"hello world"
def test_piping(self):
with self._connect() as rem:
try:
cmd = rem["ls"] | rem["cat"]
except NotImplementedError:
pass
else:
pytest.fail("Should not pipe")
@pytest.mark.xfail(message="Not working yet")
def test_encoding(self):
with self._connect() as rem:
unicode_half = b"\xc2\xbd".decode("utf8")
ret = rem['bash']("-c", 'echo -e "\xC2\xBD"')
assert ret == "%s\n" % unicode_half
ret = list(rem['bash']["-c", 'echo -e "\xC2\xBD"'].popen())
assert ret == [["%s\n" % unicode_half, None]]
def test_path_open_remote_write_local_read(self):
with self._connect() as rem:
# TODO: once Python 2.6 support is dropped, the nested
# with-statements below can be combined using "with x as a, y as b"
with rem.tempdir() as remote_tmpdir:
with local.tempdir() as tmpdir:
assert remote_tmpdir.is_dir()
assert tmpdir.is_dir()
data = six.b("hello world")
with (remote_tmpdir / "bar.txt").open("wb") as f:
f.write(data)
rem.download(
(remote_tmpdir / "bar.txt"),
(tmpdir / "bar.txt")
)
assert (tmpdir / "bar.txt").open("rb").read() == data
assert not remote_tmpdir.exists()
assert not tmpdir.exists()
def test_path_open_local_write_remote_read(self):
with self._connect() as rem:
# TODO: cf. note on Python 2.6 support above
with rem.tempdir() as remote_tmpdir:
with local.tempdir() as tmpdir:
assert remote_tmpdir.is_dir()
assert tmpdir.is_dir()
data = six.b("hello world")
with (tmpdir / "bar.txt").open("wb") as f:
f.write(data)
rem.upload(
(tmpdir / "bar.txt"),
(remote_tmpdir / "bar.txt")
)
assert (remote_tmpdir / "bar.txt").open("rb").read() == data
assert not remote_tmpdir.exists()
assert not tmpdir.exists()
|
import numpy as np
import unittest
import chainer
from chainer.backends import cuda
from chainer import testing
from chainer.testing import attr
from chainercv.experimental.links import FCISResNet101
from chainercv.experimental.links.model.fcis import FCISTrainChain
from chainercv.utils import mask_to_bbox
from tests.experimental_tests.links_tests.model_tests.fcis_tests.test_fcis \
import _random_array
@testing.parameterize(
{'train': False, 'iter2': True},
{'train': True, 'iter2': False}
)
class TestFCISResNet101(unittest.TestCase):
B = 1
n_fg_class = 20
n_class = n_fg_class + 1
n_anchor = 9
n_train_post_nms = 12
n_test_post_nms = 8
def setUp(self):
proposal_creator_params = {
'n_train_post_nms': self.n_train_post_nms,
'n_test_post_nms': self.n_test_post_nms,
}
self.link = FCISResNet101(
self.n_fg_class, pretrained_model=None,
iter2=self.iter2,
proposal_creator_params=proposal_creator_params)
def check_call(self):
xp = self.link.xp
feat_size = (12, 16)
x = chainer.Variable(
xp.random.uniform(
low=-1., high=1.,
size=(self.B, 3, feat_size[0] * 16, feat_size[1] * 16)
).astype(np.float32))
with chainer.using_config('train', self.train):
(roi_ag_seg_scores, roi_ag_locs, roi_cls_scores,
rois, roi_indices) = self.link(x)
n_roi = roi_ag_seg_scores.shape[0]
if self.train:
self.assertGreaterEqual(self.B * self.n_train_post_nms, n_roi)
else:
self.assertGreaterEqual(self.B * self.n_test_post_nms * 2, n_roi)
self.assertIsInstance(roi_ag_seg_scores, chainer.Variable)
self.assertIsInstance(roi_ag_seg_scores.array, xp.ndarray)
self.assertEqual(
roi_ag_seg_scores.shape, (n_roi, 2, 21, 21))
self.assertIsInstance(roi_ag_locs, chainer.Variable)
self.assertIsInstance(roi_ag_locs.array, xp.ndarray)
self.assertEqual(roi_ag_locs.shape, (n_roi, 2, 4))
self.assertIsInstance(roi_cls_scores, chainer.Variable)
self.assertIsInstance(roi_cls_scores.array, xp.ndarray)
self.assertEqual(roi_cls_scores.shape, (n_roi, self.n_class))
self.assertIsInstance(rois, xp.ndarray)
self.assertEqual(rois.shape, (n_roi, 4))
self.assertIsInstance(roi_indices, xp.ndarray)
self.assertEqual(roi_indices.shape, (n_roi,))
@attr.slow
def test_call_cpu(self):
self.check_call()
@attr.gpu
@attr.slow
def test_call_gpu(self):
self.link.to_gpu()
self.check_call()
class TestFCISResNet101Loss(unittest.TestCase):
B = 1
n_fg_class = 20
n_bbox = 3
n_anchor = 9
n_train_post_nms = 12
n_test_post_nms = 8
def setUp(self):
proposal_creator_params = {
'n_train_post_nms': self.n_train_post_nms,
'n_test_post_nms': self.n_test_post_nms,
}
self.model = FCISTrainChain(
FCISResNet101(
self.n_fg_class, pretrained_model=None, iter2=False,
proposal_creator_params=proposal_creator_params))
self.masks = np.random.randint(
0, 2, size=(1, self.n_bbox, 600, 800)).astype(np.bool)
self.labels = np.random.randint(
0, self.n_fg_class, size=(1, self.n_bbox)).astype(np.int32)
self.imgs = _random_array(np, (1, 3, 600, 800))
self.scale = np.array(1.)
def check_call(self, model, imgs, masks, labels, scale):
bboxes = mask_to_bbox(masks[0])[None]
loss = model(imgs, masks, labels, bboxes, scale)
self.assertEqual(loss.shape, ())
def test_call_cpu(self):
self.check_call(
self.model, self.imgs, self.masks, self.labels, self.scale)
@attr.gpu
def test_call_gpu(self):
self.model.to_gpu()
self.check_call(
self.model, cuda.to_gpu(self.imgs),
self.masks, self.labels, self.scale)
@testing.parameterize(*testing.product({
'n_fg_class': [None, 10, 20, 80],
'anchor_scales': [(8, 16, 32), (4, 8, 16, 32)],
'pretrained_model': ['sbd', 'sbd_converted', 'coco', 'coco_converted'],
}))
class TestFCISResNet101Pretrained(unittest.TestCase):
@attr.slow
def test_pretrained(self):
kwargs = {
'n_fg_class': self.n_fg_class,
'anchor_scales': self.anchor_scales,
'pretrained_model': self.pretrained_model,
}
if self.pretrained_model.startswith('sbd'):
valid = self.n_fg_class in [None, 20]
valid = valid and self.anchor_scales == (8, 16, 32)
elif self.pretrained_model.startswith('coco'):
valid = self.n_fg_class in [None, 80]
valid = valid and self.anchor_scales == (4, 8, 16, 32)
if valid:
FCISResNet101(**kwargs)
else:
with self.assertRaises(ValueError):
FCISResNet101(**kwargs)
testing.run_module(__name__, __file__)
|
import logging
import voluptuous as vol
import yeelight
from homeassistant import config_entries, exceptions
from homeassistant.const import CONF_HOST, CONF_ID, CONF_NAME
from homeassistant.core import callback
import homeassistant.helpers.config_validation as cv
from . import (
CONF_DEVICE,
CONF_MODE_MUSIC,
CONF_MODEL,
CONF_NIGHTLIGHT_SWITCH,
CONF_NIGHTLIGHT_SWITCH_TYPE,
CONF_SAVE_ON_CHANGE,
CONF_TRANSITION,
NIGHTLIGHT_SWITCH_TYPE_LIGHT,
_async_unique_name,
)
from . import DOMAIN # pylint:disable=unused-import
_LOGGER = logging.getLogger(__name__)
class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Yeelight."""
VERSION = 1
CONNECTION_CLASS = config_entries.CONN_CLASS_LOCAL_POLL
@staticmethod
@callback
def async_get_options_flow(config_entry):
"""Return the options flow."""
return OptionsFlowHandler(config_entry)
def __init__(self):
"""Initialize the config flow."""
self._discovered_devices = {}
async def async_step_user(self, user_input=None):
"""Handle the initial step."""
errors = {}
if user_input is not None:
if user_input.get(CONF_HOST):
try:
await self._async_try_connect(user_input[CONF_HOST])
return self.async_create_entry(
title=user_input[CONF_HOST],
data=user_input,
)
except CannotConnect:
errors["base"] = "cannot_connect"
except AlreadyConfigured:
return self.async_abort(reason="already_configured")
else:
return await self.async_step_pick_device()
user_input = user_input or {}
return self.async_show_form(
step_id="user",
data_schema=vol.Schema(
{vol.Optional(CONF_HOST, default=user_input.get(CONF_HOST, "")): str}
),
errors=errors,
)
async def async_step_pick_device(self, user_input=None):
"""Handle the step to pick discovered device."""
if user_input is not None:
unique_id = user_input[CONF_DEVICE]
capabilities = self._discovered_devices[unique_id]
await self.async_set_unique_id(unique_id)
self._abort_if_unique_id_configured()
return self.async_create_entry(
title=_async_unique_name(capabilities),
data={CONF_ID: unique_id},
)
configured_devices = {
entry.data[CONF_ID]
for entry in self._async_current_entries()
if entry.data[CONF_ID]
}
devices_name = {}
# Run 3 times as packets can get lost
for _ in range(3):
devices = await self.hass.async_add_executor_job(yeelight.discover_bulbs)
for device in devices:
capabilities = device["capabilities"]
unique_id = capabilities["id"]
if unique_id in configured_devices:
continue # ignore configured devices
model = capabilities["model"]
host = device["ip"]
name = f"{host} {model} {unique_id}"
self._discovered_devices[unique_id] = capabilities
devices_name[unique_id] = name
# Check if there is at least one device
if not devices_name:
return self.async_abort(reason="no_devices_found")
return self.async_show_form(
step_id="pick_device",
data_schema=vol.Schema({vol.Required(CONF_DEVICE): vol.In(devices_name)}),
)
async def async_step_import(self, user_input=None):
"""Handle import step."""
host = user_input[CONF_HOST]
try:
await self._async_try_connect(host)
except CannotConnect:
_LOGGER.error("Failed to import %s: cannot connect", host)
return self.async_abort(reason="cannot_connect")
except AlreadyConfigured:
return self.async_abort(reason="already_configured")
if CONF_NIGHTLIGHT_SWITCH_TYPE in user_input:
user_input[CONF_NIGHTLIGHT_SWITCH] = (
user_input.pop(CONF_NIGHTLIGHT_SWITCH_TYPE)
== NIGHTLIGHT_SWITCH_TYPE_LIGHT
)
return self.async_create_entry(title=user_input[CONF_NAME], data=user_input)
async def _async_try_connect(self, host):
"""Set up with options."""
for entry in self._async_current_entries():
if entry.data.get(CONF_HOST) == host:
raise AlreadyConfigured
bulb = yeelight.Bulb(host)
try:
capabilities = await self.hass.async_add_executor_job(bulb.get_capabilities)
if capabilities is None: # timeout
_LOGGER.debug("Failed to get capabilities from %s: timeout", host)
else:
_LOGGER.debug("Get capabilities: %s", capabilities)
await self.async_set_unique_id(capabilities["id"])
self._abort_if_unique_id_configured()
return
except OSError as err:
_LOGGER.debug("Failed to get capabilities from %s: %s", host, err)
# Ignore the error since get_capabilities uses UDP discovery packet
# which does not work in all network environments
# Fallback to get properties
try:
await self.hass.async_add_executor_job(bulb.get_properties)
except yeelight.BulbException as err:
_LOGGER.error("Failed to get properties from %s: %s", host, err)
raise CannotConnect from err
_LOGGER.debug("Get properties: %s", bulb.last_properties)
class OptionsFlowHandler(config_entries.OptionsFlow):
"""Handle a option flow for Yeelight."""
def __init__(self, config_entry):
"""Initialize the option flow."""
self._config_entry = config_entry
async def async_step_init(self, user_input=None):
"""Handle the initial step."""
if user_input is not None:
options = {**self._config_entry.options}
options.update(user_input)
return self.async_create_entry(title="", data=options)
options = self._config_entry.options
return self.async_show_form(
step_id="init",
data_schema=vol.Schema(
{
vol.Optional(CONF_MODEL, default=options[CONF_MODEL]): str,
vol.Required(
CONF_TRANSITION,
default=options[CONF_TRANSITION],
): cv.positive_int,
vol.Required(
CONF_MODE_MUSIC, default=options[CONF_MODE_MUSIC]
): bool,
vol.Required(
CONF_SAVE_ON_CHANGE,
default=options[CONF_SAVE_ON_CHANGE],
): bool,
vol.Required(
CONF_NIGHTLIGHT_SWITCH,
default=options[CONF_NIGHTLIGHT_SWITCH],
): bool,
}
),
)
class CannotConnect(exceptions.HomeAssistantError):
"""Error to indicate we cannot connect."""
class AlreadyConfigured(exceptions.HomeAssistantError):
"""Indicate the ip address is already configured."""
|
try:
from collections.abc import Mapping
except ImportError:
from collections import Mapping
from functools import partial
try:
from urllib.parse import parse_qsl, quote, unquote, urlparse
except ImportError:
from urllib import quote, unquote # noqa
from urlparse import urlparse, parse_qsl # noqa
try:
import ssl
ssl_available = True
except ImportError: # pragma: no cover
ssl_available = False
from .compat import NamedTuple
from ..log import get_logger
safequote = partial(quote, safe='')
logger = get_logger(__name__)
urlparts = NamedTuple('urlparts', [
('scheme', str),
('hostname', str),
('port', int),
('username', str),
('password', str),
('path', str),
('query', Mapping),
])
def parse_url(url):
# type: (str) -> Dict
"""Parse URL into mapping of components."""
scheme, host, port, user, password, path, query = _parse_url(url)
if query:
keys = [key for key in query.keys() if key.startswith('ssl_')]
for key in keys:
if key == 'ssl_cert_reqs':
query[key] = parse_ssl_cert_reqs(query[key])
if query[key] is None:
logger.warning('Defaulting to insecure SSL behaviour.')
if 'ssl' not in query:
query['ssl'] = {}
query['ssl'][key] = query[key]
del query[key]
return dict(transport=scheme, hostname=host,
port=port, userid=user,
password=password, virtual_host=path, **query)
def url_to_parts(url):
# type: (str) -> urlparts
"""Parse URL into :class:`urlparts` tuple of components."""
scheme = urlparse(url).scheme
schemeless = url[len(scheme) + 3:]
# parse with HTTP URL semantics
parts = urlparse('http://' + schemeless)
path = parts.path or ''
path = path[1:] if path and path[0] == '/' else path
return urlparts(
scheme,
unquote(parts.hostname or '') or None,
parts.port,
unquote(parts.username or '') or None,
unquote(parts.password or '') or None,
unquote(path or '') or None,
dict(parse_qsl(parts.query)),
)
_parse_url = url_to_parts # noqa
def as_url(scheme, host=None, port=None, user=None, password=None,
path=None, query=None, sanitize=False, mask='**'):
# type: (str, str, int, str, str, str, str, bool, str) -> str
"""Generate URL from component parts."""
parts = [f'{scheme}://']
if user or password:
if user:
parts.append(safequote(user))
if password:
if sanitize:
parts.extend([':', mask] if mask else [':'])
else:
parts.extend([':', safequote(password)])
parts.append('@')
parts.append(safequote(host) if host else '')
if port:
parts.extend([':', port])
parts.extend(['/', path])
return ''.join(str(part) for part in parts if part)
def sanitize_url(url, mask='**'):
# type: (str, str) -> str
"""Return copy of URL with password removed."""
return as_url(*_parse_url(url), sanitize=True, mask=mask)
def maybe_sanitize_url(url, mask='**'):
# type: (Any, str) -> Any
"""Sanitize url, or do nothing if url undefined."""
if isinstance(url, str) and '://' in url:
return sanitize_url(url, mask)
return url
def parse_ssl_cert_reqs(query_value):
# type: (str) -> Any
"""Given the query parameter for ssl_cert_reqs, return the SSL constant or None."""
if ssl_available:
query_value_to_constant = {
'CERT_REQUIRED': ssl.CERT_REQUIRED,
'CERT_OPTIONAL': ssl.CERT_OPTIONAL,
'CERT_NONE': ssl.CERT_NONE,
'required': ssl.CERT_REQUIRED,
'optional': ssl.CERT_OPTIONAL,
'none': ssl.CERT_NONE,
}
return query_value_to_constant[query_value]
else:
return None
|
from __future__ import print_function
import argparse
import sys
import json
from mlpatches import base
_stash = globals()["_stash"]
from mlpatches import patches
def patch_is_compatible(patch):
"""Return True if the patch is compatible."""
if _stash.PY3:
return patch.PY3
else:
return patch.PY2
def save_config(path):
"""save the current config to path."""
ts = {}
for k in patches.PATCHES:
v = patches.PATCHES[k].enabled
ts[k] = v
with open(path, "w") as f:
json.dump(ts, f)
def load_config(path):
"""load the config from path"""
with open(path, "rU") as f:
tl = json.load(f)
patches.PATCHES["ALL"].disable()
for k in sorted(tl): # sort is important to load groups first
v = tl[k]
p = patches.PATCHES[k]
if v:
p.enable()
else:
p.disable()
def main(ns):
if (ns.name is None):
if ns.action == "enable":
name = "STABLE"
elif ns.action == "disable":
name = "ALL"
elif (ns.action == "loadconf") or (ns.action == "saveconf"):
print(_stash.text_color("Name/Path needs to be specified for this action!", "red"))
sys.exit(2)
else:
name = "ALL"
else:
name = ns.name
if ns.action == "enable":
# enable a patch
if name not in patches.PATCHES:
print(_stash.text_color("Error: Patch '{n}' not found!".format(n=name), "red"))
sys.exit(1)
patch = patches.PATCHES[name]
if not patch_is_compatible(patch):
print(_stash.text_color("Error: Patch '{n}' not compatible with this python version!".format(n=name), "red"))
sys.exit(1)
patch.enable()
elif ns.action == "disable":
# disable a patch
if name not in patches.PATCHES:
print(_stash.text_color("Error: Patch '{n}' not found!".format(n=name), "red"))
sys.exit(1)
patch = patches.PATCHES[name]
if not patch_is_compatible(patch):
print(_stash.text_color("Error: Patch '{n}' not compatible with this python version!".format(n=name), "red"))
sys.exit(1)
patch.disable()
elif ns.action == "list":
# show monkeypatches and their state
print(_stash.text_bold("Available Monkeypatches:"))
mlength = max([len(e) for e in patches.PATCHES.keys()]) + 2
for pn in sorted(patches.PATCHES.keys()):
patch = patches.PATCHES[pn]
if not patch_is_compatible(patch):
continue
if patch.enabled:
t = "[enabled]"
c = "green"
else:
t = "[disabled]"
c = "red"
print("{n}{e}{s}".format(n=pn, e=" " * (mlength - len(pn)), s=_stash.text_color(t, c)))
elif ns.action == "saveconf":
save_config(name)
elif ns.action == "loadconf":
load_config(name)
if __name__ == "__main__":
# main code
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument(
"action",
choices=["enable",
"disable",
"list",
"loadconf",
"saveconf"],
help="What to do",
)
parser.add_argument(
"name",
help="patch to perform action on",
nargs="?",
default=None,
)
ns = parser.parse_args()
main(ns)
|
import sys
import argparse
import os.path
import subprocess
sys.path.insert(0, os.path.join(os.path.dirname(__file__), os.pardir,
os.pardir))
from scripts import utils
def bump_version(version_leap="patch"):
"""Update qutebrowser release version.
Args:
version_leap: define the jump between versions
("major", "minor", "patch")
"""
subprocess.run([sys.executable, '-m', 'bumpversion', version_leap],
check=True)
def show_commit():
subprocess.run(['git', 'show'], check=True)
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Update release version.")
parser.add_argument('bump', action="store",
choices=["major", "minor", "patch"],
help="Update release version")
parser.add_argument('--commands', action="store_true",
help="Only show commands to run post-release.")
args = parser.parse_args()
utils.change_cwd()
if not args.commands:
bump_version(args.bump)
show_commit()
import qutebrowser
version = qutebrowser.__version__
x_version = '.'.join([str(p) for p in qutebrowser.__version_info__[:-1]] +
['x'])
print("Run the following commands to create a new release:")
print("* git push origin; git push origin v{v}".format(v=version))
if args.bump == 'patch':
print("* git checkout master && git cherry-pick v{v} && "
"git push origin".format(v=version))
else:
print("* git branch v{x} v{v} && git push --set-upstream origin v{x}"
.format(v=version, x=x_version))
print("* Create new release via GitHub (required to upload release "
"artifacts)")
print("* Linux: git fetch && git checkout v{v} && "
"tox -e build-release -- --upload"
.format(v=version))
print("* Windows: git fetch; git checkout v{v}; "
"py -3.7 -m tox -e build-release -- --asciidoc "
"$env:userprofile\\bin\\asciidoc-9.0.2\\asciidoc.py --upload"
.format(v=version))
print("* macOS: git fetch && git checkout v{v} && "
"tox -e build-release -- --upload"
.format(v=version))
|
import os.path
import sys
# pylint: disable=import-error,no-member,useless-suppression
from PyInstaller.utils.win32 import versioninfo as vs
# pylint: enable=import-error,no-member,useless-suppression
sys.path.insert(0, os.path.join(os.path.dirname(__file__), os.pardir,
os.pardir))
import qutebrowser
from scripts import utils
def main():
utils.change_cwd()
out_filename = 'misc/file_version_info.txt'
filevers = qutebrowser.__version_info__ + (0,)
prodvers = qutebrowser.__version_info__ + (0,)
str_filevers = qutebrowser.__version__
str_prodvers = qutebrowser.__version__
comment_text = qutebrowser.__doc__
copyright_text = qutebrowser.__copyright__
trademark_text = ("qutebrowser is free software under the GNU General "
"Public License")
# https://www.science.co.il/language/Locale-codes.php#definitions
# https://msdn.microsoft.com/en-us/library/windows/desktop/dd317756.aspx
en_us = 1033 # 0x0409
utf_16 = 1200 # 0x04B0
ffi = vs.FixedFileInfo(filevers, prodvers)
kids = [
vs.StringFileInfo([
# 0x0409: MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US)
# 0x04B0: codepage 1200 (UTF-16LE)
vs.StringTable('040904B0', [
vs.StringStruct('Comments', comment_text),
vs.StringStruct('CompanyName', "qutebrowser.org"),
vs.StringStruct('FileDescription', "qutebrowser"),
vs.StringStruct('FileVersion', str_filevers),
vs.StringStruct('InternalName', "qutebrowser"),
vs.StringStruct('LegalCopyright', copyright_text),
vs.StringStruct('LegalTrademarks', trademark_text),
vs.StringStruct('OriginalFilename', "qutebrowser.exe"),
vs.StringStruct('ProductName', "qutebrowser"),
vs.StringStruct('ProductVersion', str_prodvers)
]),
]),
vs.VarFileInfo([vs.VarStruct('Translation', [en_us, utf_16])]),
]
file_version_info = vs.VSVersionInfo(ffi, kids)
with open(out_filename, 'w', encoding='utf-8') as f:
f.write(str(file_version_info))
if __name__ == '__main__':
main()
|
from datetime import timedelta
import logging
from tapsaff import TapsAff
import voluptuous as vol
from homeassistant.components.binary_sensor import PLATFORM_SCHEMA, BinarySensorEntity
from homeassistant.const import CONF_NAME
import homeassistant.helpers.config_validation as cv
_LOGGER = logging.getLogger(__name__)
CONF_LOCATION = "location"
DEFAULT_NAME = "Taps Aff"
SCAN_INTERVAL = timedelta(minutes=30)
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
{
vol.Required(CONF_LOCATION): cv.string,
vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
}
)
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the Taps Aff binary sensor."""
name = config.get(CONF_NAME)
location = config.get(CONF_LOCATION)
taps_aff_data = TapsAffData(location)
add_entities([TapsAffSensor(taps_aff_data, name)], True)
class TapsAffSensor(BinarySensorEntity):
"""Implementation of a Taps Aff binary sensor."""
def __init__(self, taps_aff_data, name):
"""Initialize the Taps Aff sensor."""
self.data = taps_aff_data
self._name = name
@property
def name(self):
"""Return the name of the sensor."""
return f"{self._name}"
@property
def is_on(self):
"""Return true if taps aff."""
return self.data.is_taps_aff
def update(self):
"""Get the latest data."""
self.data.update()
class TapsAffData:
"""Class for handling the data retrieval for pins."""
def __init__(self, location):
"""Initialize the data object."""
self._is_taps_aff = None
self.taps_aff = TapsAff(location)
@property
def is_taps_aff(self):
"""Return true if taps aff."""
return self._is_taps_aff
def update(self):
"""Get the latest data from the Taps Aff API and updates the states."""
try:
self._is_taps_aff = self.taps_aff.is_taps_aff
except RuntimeError:
_LOGGER.error("Update failed. Check configured location")
|
import os
import random
import string
import tarfile
import backports.lzma as lzma
import base
import mock
from docker_registry.core import compat
from docker_registry.lib import layers
from docker_registry import storage
json = compat.json
StringIO = compat.StringIO
# from mock import patch
# from mockredis import mock_strict_redis_client
def comp(n, f, *args, **kwargs):
return (f(*args, **kwargs) for i in xrange(n))
def rndstr(length=5):
palette = string.ascii_uppercase + string.digits
return ''.join(comp(length, random.choice, palette))
def _get_tarfile(filenames):
tfobj = StringIO()
tar = tarfile.TarFile(fileobj=tfobj, mode='w')
data = rndstr(512)
for filename in filenames:
tarinfo = tarfile.TarInfo(filename)
tarinfo.size = len(data)
io = StringIO()
io.write(data)
io.seek(0)
tar.addfile(tarinfo, io)
tfobj.seek(0)
return tfobj
def _get_xzfile(filenames):
tar_data = _get_tarfile(filenames)
lzma_fobj = StringIO()
xz_file = lzma.open(lzma_fobj, 'w')
xz_file.write(tar_data.read())
xz_file.close()
lzma_fobj.seek(0)
return lzma_fobj
class TestHelpers(base.TestCase):
@mock.patch.object(layers.cache, 'redis_conn')
@mock.patch.object(layers.diff_queue, 'push')
@mock.patch.object(layers.logger, 'warning')
def test_enqueue_diff(self, logger, diff_queue, redis):
redis.return_value = False
self.assertEqual(logger.call_count, 0)
diff_queue.return_value = mock.MagicMock()
redis.return_value = True
image_id = 'abcd'
layers.enqueue_diff(image_id)
diff_queue.assert_called_once_with(image_id)
self.assertEqual(logger.call_count, 0)
diff_queue.side_effect = layers.cache.redis.exceptions.ConnectionError
layers.enqueue_diff(image_id)
self.assertEqual(logger.call_count, 1)
class TestArchive(base.TestCase):
def setUp(self):
self.archive = layers.Archive(_get_tarfile(list(comp(5, rndstr))))
def test_properties(self):
self.assertEqual(self.archive.seekable(), True)
self.assertEqual(self.archive.readable(), True)
self.assertEqual(self.archive._check_can_seek(), True)
class TestTarFilesInfo(base.TestCase):
def setUp(self):
self.tar_files_info = layers.TarFilesInfo()
def test__init__(self):
self.assertEqual(type(self.tar_files_info.infos), list)
@mock.patch('docker_registry.lib.layers.serialize_tar_info')
def test_append(self, serialize_tar_info):
tar_info = ('test', True)
serialize_tar_info.return_value = tar_info
self.assertEqual(len(self.tar_files_info.infos), 0)
self.assertEqual(self.tar_files_info.append('test'), None)
self.assertNotEqual(len(self.tar_files_info.infos), 0)
self.assertTrue(tar_info in self.tar_files_info.infos)
def test_json(self):
self.assertEqual(type(self.tar_files_info.json()), str)
self.assertEqual(self.tar_files_info.json(), '[]')
class TestLayers(base.TestCase):
def setUp(self):
self.store = storage.load(kind='file')
self.filenames = list(comp(5, rndstr))
def test_tar_archive(self):
tfobj = _get_tarfile(self.filenames)
archive = layers.Archive(tfobj)
tar = tarfile.open(fileobj=archive)
members = tar.getmembers()
for tarinfo in members:
assert tarinfo.name in self.filenames
def test_xz_archive(self):
tfobj = _get_xzfile(self.filenames)
archive = layers.Archive(tfobj)
tar = tarfile.open(fileobj=archive)
members = tar.getmembers()
for tarinfo in members:
assert tarinfo.name in self.filenames
def test_info_serialization(self):
tfobj = _get_tarfile(self.filenames)
archive = layers.Archive(tfobj)
tar = tarfile.open(fileobj=archive)
members = tar.getmembers()
for tarinfo in members:
sinfo = layers.serialize_tar_info(tarinfo)
assert sinfo[0] in self.filenames
assert sinfo[1:] == ('f', False, 512, 0, 420, 0, 0)
tar_info = mock.MagicMock()
expectations = [(".", "/"), ("./", "/"), ("./ab", "/ab")]
for name_in, name_out in expectations:
tar_info.name = name_in
out = layers.serialize_tar_info(tar_info)
self.assertEqual(out[0], name_out)
self.assertEqual(out[2], False)
tar_info.name = "./.wh..wh."
self.assertEqual(layers.serialize_tar_info(tar_info), None)
expectations = [("./.wh.", "/"), ("/.wh.", "/")]
for name_in, name_out in expectations:
tar_info.name = name_in
out = layers.serialize_tar_info(tar_info)
self.assertEqual(out[0], name_out)
self.assertEqual(out[2], True)
def test_tar_serialization(self):
tfobj = _get_tarfile(self.filenames)
archive = layers.Archive(tfobj)
tar = tarfile.open(fileobj=archive)
infos = layers.read_tarfile(tar)
for tarinfo in infos:
assert tarinfo[0] in self.filenames
assert tarinfo[1:] == ('f', False, 512, 0, 420, 0, 0)
def test_layer_cache(self):
layer_id = rndstr(16)
layers.set_image_files_cache(layer_id, "{}")
fetched_json = layers.get_image_files_cache(layer_id)
assert fetched_json == "{}"
def test_tar_from_fobj(self):
tfobj = _get_tarfile(self.filenames)
files = layers.get_image_files_from_fobj(tfobj)
for file in files:
assert file[0] in self.filenames
assert file[1:] == ('f', False, 512, 0, 420, 0, 0)
def test_get_image_files_json_cached(self):
layer_id = rndstr(16)
layers.set_image_files_cache(layer_id, "{}")
files_json = layers.get_image_files_json(layer_id)
assert files_json == "{}"
def test_get_image_files_json(self):
layer_id = rndstr(16)
tfobj = _get_tarfile(self.filenames)
layer_path = self.store.image_layer_path(layer_id)
layer_path = os.path.join(self.store._root_path, layer_path)
os.makedirs(os.path.dirname(layer_path))
with open(layer_path, 'w') as fobj:
fobj.write(tfobj.read())
files_json = layers.get_image_files_json(layer_id)
file_infos = json.loads(files_json)
for info in file_infos:
assert info[0] in self.filenames
assert info[1:] == [u"f", False, 512, 0, 420, 0, 0]
def test_get_file_info_map(self):
files = (
("test", "f", False, 512, 0, 420, 0, 0),
)
map = layers.get_file_info_map(files)
assert "test" in map
assert map['test'] == ("f", False, 512, 0, 420, 0, 0)
def test_image_diff_cache(self):
layer_id = rndstr(16)
layers.set_image_diff_cache(layer_id, layer_id)
diff_json = layers.get_image_diff_cache(layer_id)
assert layer_id == diff_json
def test_image_diff_json(self):
layer_1 = (
("deleted", "f", False, 512, 0, 420, 0, 0),
("changed", "f", False, 512, 0, 420, 0, 0),
)
layer_2 = (
("deleted", "f", True, 512, 0, 420, 0, 0),
("changed", "f", False, 512, 0, 420, 0, 0),
("created", "f", False, 512, 0, 420, 0, 0),
)
layer_1_id = rndstr(16)
layer_2_id = rndstr(16)
ancestry = json.dumps([layer_2_id, layer_1_id])
ancestry_path = self.store.image_ancestry_path(layer_2_id)
self.store.put_content(ancestry_path, ancestry)
layer_1_files_path = self.store.image_files_path(layer_1_id)
self.store.put_content(layer_1_files_path, json.dumps(layer_1))
layer_2_files_path = self.store.image_files_path(layer_2_id)
self.store.put_content(layer_2_files_path, json.dumps(layer_2))
diff_json = layers.get_image_diff_json(layer_2_id)
diff = json.loads(diff_json)
for type in ("deleted", "changed", "created"):
assert type in diff
assert type in diff[type]
@mock.patch('docker_registry.lib.layers.get_image_diff_cache')
def test_get_image_diff_json(self, get_image_diff_cache):
diff_json = 'test'
get_image_diff_cache.return_value = diff_json
self.assertEqual(layers.get_image_diff_json(1), diff_json)
|
import argparse
import json
import logging
from collections import defaultdict
from typing import Dict
from typing import List
from typing import Set
from mypy_extensions import TypedDict
from paasta_tools.marathon_tools import get_marathon_clients
from paasta_tools.marathon_tools import get_marathon_servers
from paasta_tools.marathon_tools import MarathonClient
from paasta_tools.marathon_tools import MarathonClients
from paasta_tools.marathon_tools import MarathonServiceConfig
from paasta_tools.paasta_service_config_loader import PaastaServiceConfigLoader
from paasta_tools.utils import DEFAULT_SOA_DIR
from paasta_tools.utils import get_services_for_cluster
from paasta_tools.utils import load_system_paasta_config
from paasta_tools.utils import SystemPaastaConfig
log = logging.getLogger(__name__)
def parse_args(argv) -> argparse.Namespace:
parser = argparse.ArgumentParser(
description="Generates links from marathon instances to their respective web dashboard."
)
parser.add_argument(
"-c",
"--cluster",
dest="cluster",
metavar="CLUSTER",
default=None,
help="define a specific cluster to read from",
)
parser.add_argument(
"-d",
"--soa-dir",
dest="soa_dir",
metavar="SOA_DIR",
default=DEFAULT_SOA_DIR,
help="define a different soa config directory",
)
args = parser.parse_args(argv)
return args
Marathon_Dashboard_Item = TypedDict(
"Marathon_Dashboard_Item", {"service": str, "instance": str, "shard_url": str}
)
Marathon_Dashboard = Dict[str, List[Marathon_Dashboard_Item]]
def create_marathon_dashboard(
cluster: str,
soa_dir: str = DEFAULT_SOA_DIR,
marathon_clients: MarathonClients = None,
system_paasta_config: SystemPaastaConfig = None,
) -> Marathon_Dashboard:
try:
instances: List = get_services_for_cluster(
cluster=cluster, instance_type="marathon", soa_dir=soa_dir
)
except FileNotFoundError:
instances = []
dashboard: Marathon_Dashboard = {cluster: []}
if system_paasta_config is None:
system_paasta_config = load_system_paasta_config()
marathon_servers = get_marathon_servers(system_paasta_config=system_paasta_config)
if marathon_clients is None:
marathon_clients = get_marathon_clients(
marathon_servers=marathon_servers, cached=False
)
dashboard_links = system_paasta_config.get_dashboard_links()
marathon_links = dashboard_links.get(cluster, {}).get("Marathon RO")
# e.g. 'http://10.64.97.75:5052': 'http://marathon-norcal-prod.yelpcorp.com'
shard_url_to_marathon_link_dict: Dict[str, str] = {}
if isinstance(marathon_links, list):
# Sanity check and log error if necessary
if len(marathon_links) != len(marathon_servers.current):
log.error(
"len(marathon_links) != len(marathon_servers.current). This may be a cause of concern"
)
for shard_number, shard in enumerate(marathon_servers.current):
shard_url_to_marathon_link_dict[shard.url[0]] = marathon_links[shard_number]
elif isinstance(marathon_links, str):
# In this case, the shard url will be the same for every service instance
static_shard_url = marathon_links.split(" ")[0]
return {
cluster: [
{"service": si[0], "instance": si[1], "shard_url": static_shard_url}
for si in instances
]
}
# Setup with service as key since will instantiate 1 PSCL per service
service_instances_dict: Dict[str, Set[str]] = defaultdict(set)
for si in instances:
service, instance = si[0], si[1]
service_instances_dict[service].add(instance)
for service, instance_set in service_instances_dict.items():
pscl = PaastaServiceConfigLoader(
service=service, soa_dir=soa_dir, load_deployments=False
)
for marathon_service_config in pscl.instance_configs(
cluster, MarathonServiceConfig
):
if marathon_service_config.get_instance() in instance_set:
client: MarathonClient = marathon_clients.get_current_client_for_service(
job_config=marathon_service_config
)
ip_url: str = client.servers[0]
# Convert to a marathon link if possible else default to the originalIP address
shard_url: str = shard_url_to_marathon_link_dict.get(ip_url, ip_url)
service_info: Marathon_Dashboard_Item = {
"service": service,
"instance": marathon_service_config.get_instance(),
"shard_url": shard_url,
}
dashboard[cluster].append(service_info)
return dashboard
def main(argv=None) -> None:
args = parse_args(argv)
dashboard: Marathon_Dashboard = create_marathon_dashboard(
cluster=args.cluster, soa_dir=args.soa_dir
)
print(json.dumps(dashboard))
if __name__ == "__main__":
main()
|
from __future__ import print_function
import errno
import os
try:
from cStringIO import StringIO
except ImportError:
from io import StringIO
import signal
import subprocess
import time
import traceback
import unittest
import rospkg
from . import junitxml
from . import pmon
from .core import create_xml_runner # noqa: F401
from .core import printerrlog
from .core import printlog
from .core import printlog_bold
from .core import rostest_name_from_path # noqa: F401
from .core import xml_results_file
BARE_TIME_LIMIT = 60.
TIMEOUT_SIGINT = 15.0 # seconds
TIMEOUT_SIGTERM = 2.0 # seconds
class TestTimeoutException(Exception):
pass
class BareTestCase(unittest.TestCase):
def __init__(self, exe, args, retry=0, time_limit=None, test_name=None, text_mode=False, package_name=None):
"""
@param exe: path to executable to run
@type exe: str
@param args: arguments to exe
@type args: [str]
@type retry: int
@param time_limit: (optional) time limit for test. Defaults to BARE_TIME_LIMIT.
@type time_limit: float
@param test_name: (optional) override automatically generated test name
@type test_name: str
@param package_name: (optional) override automatically inferred package name
@type package_name: str
"""
super(BareTestCase, self).__init__()
self.text_mode = text_mode
if package_name:
self.package = package_name
else:
self.package = rospkg.get_package_name(exe)
self.exe = os.path.abspath(exe)
if test_name is None:
self.test_name = os.path.basename(exe)
else:
self.test_name = test_name
# invoke pyunit tests with python executable
if self.exe.endswith('.py'):
self.args = ['python', self.exe] + args
else:
self.args = [self.exe] + args
if text_mode:
self.args = self.args + ['--text']
self.retry = retry
self.time_limit = time_limit or BARE_TIME_LIMIT
self.pmon = None
self.results = junitxml.Result(self.test_name)
def setUp(self):
self.pmon = pmon.start_process_monitor()
def tearDown(self):
if self.pmon is not None:
pmon.shutdown_process_monitor(self.pmon)
self.pmon = None
def runTest(self):
self.failIf(self.package is None, 'unable to determine package of executable')
done = False
while not done:
test_name = self.test_name
printlog('Running test [%s]', test_name)
# setup the test
# - we pass in the output test_file name so we can scrape it
test_file = xml_results_file(self.package, test_name, False)
if os.path.exists(test_file):
printlog('removing previous test results file [%s]', test_file)
os.remove(test_file)
self.args.append('--gtest_output=xml:%s' % test_file)
# run the test, blocks until completion
printlog('running test %s' % test_name)
timeout_failure = False
run_id = None
# TODO: really need different, non-node version of LocalProcess instead of these extra args
process = LocalProcess(run_id, self.package, self.test_name, self.args, os.environ, False, cwd='cwd', is_node=False)
pm = self.pmon
pm.register(process)
success = process.start()
self.assert_(success, 'test failed to start')
# poll until test terminates or alloted time exceed
timeout_t = time.time() + self.time_limit
try:
while process.is_alive():
# test fails on timeout
if time.time() > timeout_t:
raise TestTimeoutException('test max time allotted')
time.sleep(0.1)
except TestTimeoutException:
if self.retry:
timeout_failure = True
else:
raise
if not timeout_failure:
printlog('test [%s] finished' % test_name)
else:
printerrlog('test [%s] timed out' % test_name)
if self.text_mode:
results = self.results
elif not self.text_mode:
# load in test_file
if not timeout_failure:
self.assert_(os.path.isfile(test_file), 'test [%s] did not generate test results' % test_name)
printlog('test [%s] results are in [%s]', test_name, test_file)
results = junitxml.read(test_file, test_name)
test_fail = results.num_errors or results.num_failures
else:
test_fail = True
if self.retry > 0 and test_fail:
self.retry -= 1
printlog('test [%s] failed, retrying. Retries left: %s' % (test_name, self.retry))
else:
done = True
self.results = results
printlog('test [%s] results summary: %s errors, %s failures, %s tests',
test_name, results.num_errors, results.num_failures, results.num_tests)
printlog('[ROSTEST] test [%s] done', test_name)
# TODO: this is a straight copy from roslaunch. Need to reduce, refactor
class LocalProcess(pmon.Process):
"""
Process launched on local machine
"""
def __init__(self, run_id, package, name, args, env, log_output, respawn=False, required=False, cwd=None, is_node=True):
"""
@param run_id: unique run ID for this roslaunch. Used to
generate log directory location. run_id may be None if this
feature is not being used.
@type run_id: str
@param package: name of package process is part of
@type package: str
@param name: name of process
@type name: str
@param args: list of arguments to process
@type args: [str]
@param env: environment dictionary for process
@type env: {str : str}
@param log_output: if True, log output streams of process
@type log_output: bool
@param respawn: respawn process if it dies (default is False)
@type respawn: bool
@param cwd: working directory of process, or None
@type cwd: str
@param is_node: (optional) if True, process is ROS node and accepts ROS node command-line arguments. Default: True
@type is_node: False
"""
super(LocalProcess, self).__init__(package, name, args, env, respawn, required)
self.run_id = run_id
self.popen = None
self.log_output = log_output
self.started = False
self.stopped = False
self.cwd = cwd
self.log_dir = None
self.pid = -1
self.is_node = is_node
# NOTE: in the future, info() is going to have to be sufficient for relaunching a process
def get_info(self):
"""
Get all data about this process in dictionary form
"""
info = super(LocalProcess, self).get_info()
info['pid'] = self.pid
if self.run_id:
info['run_id'] = self.run_id
info['log_output'] = self.log_output
if self.cwd is not None:
info['cwd'] = self.cwd
return info
def _configure_logging(self):
"""
Configure logging of node's log file and stdout/stderr
@return: stdout log file name, stderr log file
name. Values are None if stdout/stderr are not logged.
@rtype: str, str
"""
log_dir = rospkg.get_log_dir(env=os.environ)
if self.run_id:
log_dir = os.path.join(log_dir, self.run_id)
if not os.path.exists(log_dir):
try:
os.makedirs(log_dir)
except OSError as e:
if e.errno == errno.EACCES:
raise RLException('unable to create directory for log file [%s].\nPlease check permissions.' % log_dir)
else:
raise RLException('unable to create directory for log file [%s]: %s' % (log_dir, e.strerror))
# #973: save log dir for error messages
self.log_dir = log_dir
# send stdout/stderr to file. in the case of respawning, we have to
# open in append mode
# note: logfileerr: disabling in favor of stderr appearing in the console.
# will likely reinstate once roserr/rosout is more properly used.
logfileout = logfileerr = None
if self.log_output:
outf, errf = [os.path.join(log_dir, '%s-%s.log' % (self.name, n)) for n in ['stdout', 'stderr']]
if self.respawn:
mode = 'a'
else:
mode = 'w'
logfileout = open(outf, mode)
if is_child_mode():
logfileerr = open(errf, mode)
# #986: pass in logfile name to node
if self.is_node:
# #1595: on respawn, these keep appending
self.args = _cleanup_remappings(self.args, '__log:=')
self.args.append('__log:=%s' % os.path.join(log_dir, '%s.log' % self.name))
return logfileout, logfileerr
def start(self):
"""
Start the process.
@raise pmon.FatalProcessLaunch: if process cannot be started and it
is not likely to ever succeed
"""
super(LocalProcess, self).start()
try:
self.lock.acquire()
self.started = self.stopped = False
full_env = self.env
# _configure_logging() can mutate self.args
try:
logfileout, logfileerr = self._configure_logging()
except Exception as e:
printerrlog('[%s] ERROR: unable to configure logging [%s]' % (self.name, str(e)))
# it's not safe to inherit from this process as
# rostest changes stdout to a StringIO, which is not a
# proper file.
logfileout, logfileerr = subprocess.PIPE, subprocess.PIPE
if self.cwd == 'node':
cwd = os.path.dirname(self.args[0])
elif self.cwd == 'cwd':
cwd = os.getcwd()
elif self.cwd == 'ros-root':
from roslib.rosenv import get_ros_root
cwd = get_ros_root()
else:
cwd = rospkg.get_ros_home()
if not os.path.exists(cwd):
try:
os.makedirs(cwd)
except OSError:
# exist_ok=True
pass
try:
self.popen = subprocess.Popen(self.args, cwd=cwd, stdout=logfileout, stderr=logfileerr, env=full_env, close_fds=True, preexec_fn=os.setsid)
except OSError as e:
self.started = True # must set so is_alive state is correct
if e.errno == errno.ENOEXEC: # Exec format error
raise pmon.FatalProcessLaunch("Unable to launch [%s]. \nIf it is a script, you may be missing a '#!' declaration at the top." % self.name)
elif e.errno == errno.ENOENT: # no such file or directory
raise pmon.FatalProcessLaunch("""Roslaunch got a '%s' error while attempting to run:
%s
Please make sure that all the executables in this command exist and have
executable permission. This is often caused by a bad launch-prefix.""" % (msg, ' '.join(self.args)))
else:
raise pmon.FatalProcessLaunch('unable to launch [%s]: %s' % (' '.join(self.args), msg))
self.started = True
# Check that the process is either still running (poll returns
# None) or that it completed successfully since when we
# launched it above (poll returns the return code, 0).
poll_result = self.popen.poll()
if poll_result is None or poll_result == 0:
self.pid = self.popen.pid
printlog_bold('process[%s]: started with pid [%s]' % (self.name, self.pid))
return True
else:
printerrlog('failed to start local process: %s' % (' '.join(self.args)))
return False
finally:
self.lock.release()
def is_alive(self):
"""
@return: True if process is still running
@rtype: bool
"""
if not self.started: # not started yet
return True
if self.stopped or self.popen is None:
return False
self.exit_code = self.popen.poll()
if self.exit_code is not None:
return False
return True
def get_exit_description(self):
"""
@return: human-readable description of exit state
@rtype: str
"""
# #973: include location of output location in message
if self.exit_code is not None:
if self.exit_code:
if self.log_dir:
return 'process has died [pid %s, exit code %s].\nlog files: %s*.log' % (self.pid, self.exit_code, os.path.join(self.log_dir, self.name))
else:
return 'process has died [pid %s, exit code %s]' % (self.pid, self.exit_code)
else:
if self.log_dir:
return 'process has finished cleanly.\nlog file: %s*.log' % (os.path.join(self.log_dir, self.name))
else:
return 'process has finished cleanly'
else:
return 'process has died'
def _stop_unix(self, errors):
"""
UNIX implementation of process killing
@param errors: error messages. stop() will record messages into this list.
@type errors: [str]
"""
self.exit_code = self.popen.poll()
if self.exit_code is not None:
# print "process[%s].stop(): process has already returned %s"%(self.name, self.exit_code)
self.popen = None
self.stopped = True
return
pid = self.popen.pid
pgid = os.getpgid(pid)
try:
# Start with SIGINT and escalate from there.
os.killpg(pgid, signal.SIGINT)
timeout_t = time.time() + TIMEOUT_SIGINT
retcode = self.popen.poll()
while time.time() < timeout_t and retcode is None:
time.sleep(0.1)
retcode = self.popen.poll()
# Escalate non-responsive process
if retcode is None:
printerrlog('[%s] escalating to SIGTERM' % self.name)
timeout_t = time.time() + TIMEOUT_SIGTERM
os.killpg(pgid, signal.SIGTERM)
retcode = self.popen.poll()
while time.time() < timeout_t and retcode is None:
time.sleep(0.2)
retcode = self.popen.poll()
if retcode is None:
printerrlog('[%s] escalating to SIGKILL' % self.name)
errors.append('process[%s, pid %s]: required SIGKILL. May still be running.' % (self.name, pid))
try:
os.killpg(pgid, signal.SIGKILL)
# #2096: don't block on SIGKILL, because this results in more orphaned processes overall
except OSError as e:
if e.args[0] == 3:
printerrlog('no [%s] process with pid [%s]' % (self.name, pid))
else:
printerrlog('errors shutting down [%s]: %s' % (self.name, e))
finally:
self.popen = None
def stop(self, errors=[]):
"""
Stop the process. Record any significant error messages in the errors parameter
@param errors: error messages. stop() will record messages into this list.
@type errors: [str]
"""
super(LocalProcess, self).stop(errors)
self.lock.acquire()
try:
try:
if self.popen is None:
return
# NOTE: currently POSIX-only. Need to add in Windows code once I have a test environment:
# http://aspn.activestate.com/ASPN/Cookbook/Python/Recipe/347462
self._stop_unix(errors)
except Exception:
printerrlog('[%s] EXCEPTION %s' % (self.name, traceback.format_exc()))
finally:
self.stopped = True
self.lock.release()
def print_runner_summary(runner_results, junit_results, runner_name='ROSUNIT'):
"""
Print summary of runner results and actual test results to
stdout. For rosunit and rostest, the test is wrapped in an
external runner. The results from this runner are important if the
runner itself has a failure.
@param runner_result: unittest runner result object
@type runner_result: _XMLTestResult
@param junit_results: Parsed JUnit test results
@type junit_results: rosunit.junitxml.Result
"""
# we have two separate result objects, which can be a bit
# confusing. 'result' counts successful _running_ of tests
# (i.e. doesn't check for actual test success). The 'r' result
# object contains results of the actual tests.
buff = StringIO()
buff.write('[%s]' % (runner_name) + '-' * 71 + '\n\n')
for tc_result in junit_results.test_case_results:
buff.write(tc_result.description)
for tc_result in runner_results.failures:
buff.write('[%s][failed]\n' % tc_result[0]._testMethodName)
buff.write('\nSUMMARY\n')
if runner_results.wasSuccessful() and (junit_results.num_errors + junit_results.num_failures) == 0:
buff.write('\033[32m * RESULT: SUCCESS\033[0m\n')
else:
buff.write('\033[1;31m * RESULT: FAIL\033[0m\n')
# TODO: still some issues with the numbers adding up if tests fail to launch
# number of errors from the inner tests, plus add in count for tests
# that didn't run properly ('result' object).
buff.write(' * TESTS: %s\n' % junit_results.num_tests)
num_errors = junit_results.num_errors+len(runner_results.errors)
if num_errors:
buff.write('\033[1;31m * ERRORS: %s\033[0m\n' % num_errors)
else:
buff.write(' * ERRORS: 0\n')
num_failures = junit_results.num_failures+len(runner_results.failures)
if num_failures:
buff.write('\033[1;31m * FAILURES: %s\033[0m\n' % num_failures)
else:
buff.write(' * FAILURES: 0\n')
if runner_results.failures:
buff.write('\nERROR: The following tests failed to run:\n')
for tc_result in runner_results.failures:
buff.write(' * ' + tc_result[0]._testMethodName + '\n')
print(buff.getvalue())
def _format_errors(errors):
formatted = []
for e in errors:
if '_testMethodName' in e[0].__dict__:
formatted.append(e[0]._testMethodName)
elif 'description' in e[0].__dict__:
formatted.append('%s: %s\n' % (str(e[0].description), str(e[1])))
else:
formatted.append(str(e[0].__dict__))
return formatted
def print_unittest_summary(result):
"""
Print summary of python unittest result to stdout
@param result: test results
"""
buff = StringIO()
buff.write('-------------------------------------------------------------\nSUMMARY:\n')
if result.wasSuccessful():
buff.write('\033[32m * RESULT: SUCCESS\033[0m\n')
else:
buff.write(' * RESULT: FAIL\n')
buff.write(' * TESTS: %s\n' % result.testsRun)
buff.write(' * ERRORS: %s [%s]\n' % (len(result.errors), ', '.join(_format_errors(result.errors))))
buff.write(' * FAILURES: %s [%s]\n' % (len(result.failures), ', '.join(_format_errors(result.failures))))
print(buff.getvalue())
|
import datetime
import sys
import unittest
import mock
from six import StringIO
# These imports are mocked so that we don't need to add them to the
# test dependencies. The script under test for this test module is
# expected to execute only on a client VM which has built tensorflow
# from source.
sys.modules['grpc'] = mock.Mock()
sys.modules['grpc.beta'] = mock.Mock()
sys.modules['grpc.framework'] = mock.Mock()
sys.modules['grpc.framework.interfaces'] = mock.Mock()
sys.modules['grpc.framework.interfaces.face'] = mock.Mock()
sys.modules['grpc.framework.interfaces.face.face'] = mock.Mock()
sys.modules['tensorflow'] = mock.Mock()
sys.modules['tensorflow_serving'] = mock.Mock()
sys.modules['tensorflow_serving.apis'] = mock.Mock()
from perfkitbenchmarker.scripts import tensorflow_serving_client_workload # pylint: disable=g-import-not-at-top,g-bad-import-order
class TestTensorflowServingClientWorkload(unittest.TestCase):
def setUp(self):
flag_values = {
'server': '123:456',
'image_directory': '/fake',
'num_threads': 16,
'runtime': 20,
}
p = mock.patch(tensorflow_serving_client_workload.__name__ + '.FLAGS')
flags_mock = p.start()
flags_mock.configure_mock(**flag_values)
self.addCleanup(p.stop)
os_patch = mock.patch(tensorflow_serving_client_workload.__name__ + '.os')
os_patch.start()
self.addCleanup(os_patch.stop)
self.client_workload = (
tensorflow_serving_client_workload.TfServingClientWorkload())
def testPrintOutput(self):
self.client_workload.num_completed_requests = 10
self.client_workload.num_failed_requests = 2
self.client_workload.latencies = [1.1, 2.2, 3.3]
# Set start_time to an arbitarty datetime, and set end_time to 20 seconds
# after start_time.
self.client_workload.start_time = datetime.datetime(2000, 1, 1, 1, 1, 1, 1)
self.client_workload.end_time = datetime.datetime(2000, 1, 1, 1, 1, 21, 1)
expected_output = """
Completed requests: 10
Failed requests: 2
Runtime: 20.0
Number of threads: 16
Throughput: 0.5
Latency:
1.1
2.2
3.3""".strip()
out = StringIO()
self.client_workload.print_results(out=out)
actual_output = out.getvalue().strip()
self.assertEqual(expected_output, actual_output)
if __name__ == '__main__':
unittest.main()
|
import pytest
import homeassistant.components.automation as automation
from homeassistant.components.fan import DOMAIN
from homeassistant.const import STATE_OFF, STATE_ON
from homeassistant.helpers import device_registry
from homeassistant.setup import async_setup_component
from tests.common import (
MockConfigEntry,
assert_lists_same,
async_get_device_automations,
async_mock_service,
mock_device_registry,
mock_registry,
)
@pytest.fixture
def device_reg(hass):
"""Return an empty, loaded, registry."""
return mock_device_registry(hass)
@pytest.fixture
def entity_reg(hass):
"""Return an empty, loaded, registry."""
return mock_registry(hass)
@pytest.fixture
def calls(hass):
"""Track calls to a mock service."""
return async_mock_service(hass, "test", "automation")
async def test_get_conditions(hass, device_reg, entity_reg):
"""Test we get the expected conditions from a fan."""
config_entry = MockConfigEntry(domain="test", data={})
config_entry.add_to_hass(hass)
device_entry = device_reg.async_get_or_create(
config_entry_id=config_entry.entry_id,
connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")},
)
entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id)
expected_conditions = [
{
"condition": "device",
"domain": DOMAIN,
"type": "is_off",
"device_id": device_entry.id,
"entity_id": f"{DOMAIN}.test_5678",
},
{
"condition": "device",
"domain": DOMAIN,
"type": "is_on",
"device_id": device_entry.id,
"entity_id": f"{DOMAIN}.test_5678",
},
]
conditions = await async_get_device_automations(hass, "condition", device_entry.id)
assert_lists_same(conditions, expected_conditions)
async def test_if_state(hass, calls):
"""Test for turn_on and turn_off conditions."""
hass.states.async_set("fan.entity", STATE_ON)
assert await async_setup_component(
hass,
automation.DOMAIN,
{
automation.DOMAIN: [
{
"trigger": {"platform": "event", "event_type": "test_event1"},
"condition": [
{
"condition": "device",
"domain": DOMAIN,
"device_id": "",
"entity_id": "fan.entity",
"type": "is_on",
}
],
"action": {
"service": "test.automation",
"data_template": {
"some": "is_on - {{ trigger.platform }} - {{ trigger.event.event_type }}"
},
},
},
{
"trigger": {"platform": "event", "event_type": "test_event2"},
"condition": [
{
"condition": "device",
"domain": DOMAIN,
"device_id": "",
"entity_id": "fan.entity",
"type": "is_off",
}
],
"action": {
"service": "test.automation",
"data_template": {
"some": "is_off - {{ trigger.platform }} - {{ trigger.event.event_type }}"
},
},
},
]
},
)
hass.bus.async_fire("test_event1")
hass.bus.async_fire("test_event2")
await hass.async_block_till_done()
assert len(calls) == 1
assert calls[0].data["some"] == "is_on - event - test_event1"
hass.states.async_set("fan.entity", STATE_OFF)
hass.bus.async_fire("test_event1")
hass.bus.async_fire("test_event2")
await hass.async_block_till_done()
assert len(calls) == 2
assert calls[1].data["some"] == "is_off - event - test_event2"
|
from homeassistant.components.climate import ClimateEntity
from homeassistant.components.climate.const import (
CURRENT_HVAC_HEAT,
CURRENT_HVAC_IDLE,
CURRENT_HVAC_OFF,
HVAC_MODE_AUTO,
HVAC_MODE_HEAT,
HVAC_MODE_OFF,
PRESET_BOOST,
PRESET_NONE,
SUPPORT_PRESET_MODE,
SUPPORT_TARGET_TEMPERATURE,
)
from homeassistant.const import ATTR_TEMPERATURE, TEMP_CELSIUS
from . import DATA_HIVE, DOMAIN, HiveEntity, refresh_system
HIVE_TO_HASS_STATE = {
"SCHEDULE": HVAC_MODE_AUTO,
"MANUAL": HVAC_MODE_HEAT,
"OFF": HVAC_MODE_OFF,
}
HASS_TO_HIVE_STATE = {
HVAC_MODE_AUTO: "SCHEDULE",
HVAC_MODE_HEAT: "MANUAL",
HVAC_MODE_OFF: "OFF",
}
HIVE_TO_HASS_HVAC_ACTION = {
"UNKNOWN": CURRENT_HVAC_OFF,
False: CURRENT_HVAC_IDLE,
True: CURRENT_HVAC_HEAT,
}
SUPPORT_FLAGS = SUPPORT_TARGET_TEMPERATURE | SUPPORT_PRESET_MODE
SUPPORT_HVAC = [HVAC_MODE_AUTO, HVAC_MODE_HEAT, HVAC_MODE_OFF]
SUPPORT_PRESET = [PRESET_NONE, PRESET_BOOST]
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up Hive climate devices."""
if discovery_info is None:
return
session = hass.data.get(DATA_HIVE)
devs = []
for dev in discovery_info:
devs.append(HiveClimateEntity(session, dev))
add_entities(devs)
class HiveClimateEntity(HiveEntity, ClimateEntity):
"""Hive Climate Device."""
def __init__(self, hive_session, hive_device):
"""Initialize the Climate device."""
super().__init__(hive_session, hive_device)
self.thermostat_node_id = hive_device["Thermostat_NodeID"]
@property
def unique_id(self):
"""Return unique ID of entity."""
return self._unique_id
@property
def device_info(self):
"""Return device information."""
return {"identifiers": {(DOMAIN, self.unique_id)}, "name": self.name}
@property
def supported_features(self):
"""Return the list of supported features."""
return SUPPORT_FLAGS
@property
def name(self):
"""Return the name of the Climate device."""
friendly_name = "Heating"
if self.node_name is not None:
if self.device_type == "TRV":
friendly_name = self.node_name
else:
friendly_name = f"{self.node_name} {friendly_name}"
return friendly_name
@property
def device_state_attributes(self):
"""Show Device Attributes."""
return self.attributes
@property
def hvac_modes(self):
"""Return the list of available hvac operation modes.
Need to be a subset of HVAC_MODES.
"""
return SUPPORT_HVAC
@property
def hvac_mode(self):
"""Return hvac operation ie. heat, cool mode.
Need to be one of HVAC_MODE_*.
"""
return HIVE_TO_HASS_STATE[self.session.heating.get_mode(self.node_id)]
@property
def hvac_action(self):
"""Return current HVAC action."""
return HIVE_TO_HASS_HVAC_ACTION[
self.session.heating.operational_status(self.node_id, self.device_type)
]
@property
def temperature_unit(self):
"""Return the unit of measurement."""
return TEMP_CELSIUS
@property
def current_temperature(self):
"""Return the current temperature."""
return self.session.heating.current_temperature(self.node_id)
@property
def target_temperature(self):
"""Return the target temperature."""
return self.session.heating.get_target_temperature(self.node_id)
@property
def min_temp(self):
"""Return minimum temperature."""
return self.session.heating.min_temperature(self.node_id)
@property
def max_temp(self):
"""Return the maximum temperature."""
return self.session.heating.max_temperature(self.node_id)
@property
def preset_mode(self):
"""Return the current preset mode, e.g., home, away, temp."""
if (
self.device_type == "Heating"
and self.session.heating.get_boost(self.node_id) == "ON"
):
return PRESET_BOOST
return None
@property
def preset_modes(self):
"""Return a list of available preset modes."""
return SUPPORT_PRESET
@refresh_system
def set_hvac_mode(self, hvac_mode):
"""Set new target hvac mode."""
new_mode = HASS_TO_HIVE_STATE[hvac_mode]
self.session.heating.set_mode(self.node_id, new_mode)
@refresh_system
def set_temperature(self, **kwargs):
"""Set new target temperature."""
new_temperature = kwargs.get(ATTR_TEMPERATURE)
if new_temperature is not None:
self.session.heating.set_target_temperature(self.node_id, new_temperature)
@refresh_system
def set_preset_mode(self, preset_mode):
"""Set new preset mode."""
if preset_mode == PRESET_NONE and self.preset_mode == PRESET_BOOST:
self.session.heating.turn_boost_off(self.node_id)
elif preset_mode == PRESET_BOOST:
curtemp = round(self.current_temperature * 2) / 2
temperature = curtemp + 0.5
self.session.heating.turn_boost_on(self.node_id, 30, temperature)
def update(self):
"""Update all Node data from Hive."""
self.session.core.update_data(self.node_id)
self.attributes = self.session.attributes.state_attributes(
self.thermostat_node_id
)
|
try:
from urllib3.connectionpool import HTTPConnection, VerifiedHTTPSConnection
except ImportError:
from requests.packages.urllib3.connectionpool import HTTPConnection, VerifiedHTTPSConnection
from ..stubs import VCRHTTPConnection, VCRHTTPSConnection
# urllib3 defines its own HTTPConnection classes, which requests goes ahead and assumes
# you're using. It includes some polyfills for newer features missing in older pythons.
class VCRRequestsHTTPConnection(VCRHTTPConnection, HTTPConnection):
_baseclass = HTTPConnection
class VCRRequestsHTTPSConnection(VCRHTTPSConnection, VerifiedHTTPSConnection):
_baseclass = VerifiedHTTPSConnection
|
import hangups
from common import run_example
async def get_conversation(client, args):
request = hangups.hangouts_pb2.GetConversationRequest(
request_header=client.get_request_header(),
conversation_spec=hangups.hangouts_pb2.ConversationSpec(
conversation_id=hangups.hangouts_pb2.ConversationId(
id=args.conversation_id
),
),
include_event=True,
max_events_per_conversation=10,
)
res = await client.get_conversation(request)
print(res)
if __name__ == '__main__':
run_example(get_conversation, '--conversation-id')
|
from homeassistant.components.switch import SwitchEntity
from . import DATA_HIVE, DOMAIN, HiveEntity, refresh_system
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up Hive switches."""
if discovery_info is None:
return
session = hass.data.get(DATA_HIVE)
devs = []
for dev in discovery_info:
devs.append(HiveDevicePlug(session, dev))
add_entities(devs)
class HiveDevicePlug(HiveEntity, SwitchEntity):
"""Hive Active Plug."""
@property
def unique_id(self):
"""Return unique ID of entity."""
return self._unique_id
@property
def device_info(self):
"""Return device information."""
return {"identifiers": {(DOMAIN, self.unique_id)}, "name": self.name}
@property
def name(self):
"""Return the name of this Switch device if any."""
return self.node_name
@property
def device_state_attributes(self):
"""Show Device Attributes."""
return self.attributes
@property
def current_power_w(self):
"""Return the current power usage in W."""
return self.session.switch.get_power_usage(self.node_id)
@property
def is_on(self):
"""Return true if switch is on."""
return self.session.switch.get_state(self.node_id)
@refresh_system
def turn_on(self, **kwargs):
"""Turn the switch on."""
self.session.switch.turn_on(self.node_id)
@refresh_system
def turn_off(self, **kwargs):
"""Turn the device off."""
self.session.switch.turn_off(self.node_id)
def update(self):
"""Update all Node data from Hive."""
self.session.core.update_data(self.node_id)
self.attributes = self.session.attributes.state_attributes(self.node_id)
|
from openrazer_daemon.dbus_services import endpoint
@endpoint('razer.device.lighting.logo', 'setLogoStatic', in_sig='yyy')
def set_logo_static_naga_hex_v2(self, red, green, blue):
"""
Set the device to static colour
:param red: Red component
:type red: int
:param green: Green component
:type green: int
:param blue: Blue component
:type blue: int
"""
self.logger.debug("DBus call set_static_effect")
# Notify others
self.send_effect_event('setStatic', red, green, blue)
# remember effect
self.set_persistence("logo", "effect", 'static')
self.zone["logo"]["colors"][0:3] = int(red), int(green), int(blue)
rgb_driver_path = self.get_driver_path('logo_matrix_effect_static')
payload = bytes([red, green, blue])
with open(rgb_driver_path, 'wb') as rgb_driver_file:
rgb_driver_file.write(payload)
@endpoint('razer.device.lighting.logo', 'setLogoSpectrum')
def set_logo_spectrum_naga_hex_v2(self):
"""
Set the device to spectrum mode
"""
self.logger.debug("DBus call set_logo_spectrum")
# Notify others
self.send_effect_event('setSpectrum')
# remember effect
self.set_persistence("logo", "effect", 'spectrum')
effect_driver_path = self.get_driver_path('logo_matrix_effect_spectrum')
with open(effect_driver_path, 'w') as effect_driver_file:
effect_driver_file.write('1')
@endpoint('razer.device.lighting.logo', 'setLogoNone')
def set_logo_none_naga_hex_v2(self):
"""
Set the device to effect none
"""
self.logger.debug("DBus call set_none_effect")
# Notify others
self.send_effect_event('setNone')
# remember effect
self.set_persistence("logo", "effect", 'none')
driver_path = self.get_driver_path('logo_matrix_effect_none')
with open(driver_path, 'w') as driver_file:
driver_file.write('1')
@endpoint('razer.device.lighting.logo', 'setLogoReactive', in_sig='yyyy')
def set_logo_reactive_naga_hex_v2(self, red, green, blue, speed):
"""
Set the device to reactive effect
:param red: Red component
:type red: int
:param green: Green component
:type green: int
:param blue: Blue component
:type blue: int
:param speed: Speed
:type speed: int
"""
self.logger.debug("DBus call set_reactive_effect")
driver_path = self.get_driver_path('logo_matrix_effect_reactive')
# Notify others
self.send_effect_event('setReactive', red, green, blue, speed)
# remember effect
self.set_persistence("logo", "effect", 'reactive')
self.zone["logo"]["colors"][0:3] = int(red), int(green), int(blue)
self.set_persistence("logo", "speed", int(speed))
if speed not in (1, 2, 3, 4):
speed = 4
payload = bytes([speed, red, green, blue])
with open(driver_path, 'wb') as driver_file:
driver_file.write(payload)
@endpoint('razer.device.lighting.logo', 'setLogoBreathRandom')
def set_logo_breath_random_naga_hex_v2(self):
"""
Set the device to random colour breathing effect
"""
self.logger.debug("DBus call set_breath_random_effect")
# Notify others
self.send_effect_event('setBreathRandom')
# remember effect
self.set_persistence("logo", "effect", 'breathRandom')
driver_path = self.get_driver_path('logo_matrix_effect_breath')
payload = b'1'
with open(driver_path, 'wb') as driver_file:
driver_file.write(payload)
@endpoint('razer.device.lighting.logo', 'setLogoBreathSingle', in_sig='yyy')
def set_logo_breath_single_naga_hex_v2(self, red, green, blue):
"""
Set the device to single colour breathing effect
:param red: Red component
:type red: int
:param green: Green component
:type green: int
:param blue: Blue component
:type blue: int
"""
self.logger.debug("DBus call set_breath_single_effect")
# Notify others
self.send_effect_event('setBreathSingle', red, green, blue)
# remember effect
self.set_persistence("logo", "effect", 'breathSingle')
self.zone["logo"]["colors"][0:3] = int(red), int(green), int(blue)
driver_path = self.get_driver_path('logo_matrix_effect_breath')
payload = bytes([red, green, blue])
with open(driver_path, 'wb') as driver_file:
driver_file.write(payload)
@endpoint('razer.device.lighting.logo', 'setLogoBreathDual', in_sig='yyyyyy')
def set_logo_breath_dual_naga_hex_v2(self, red1, green1, blue1, red2, green2, blue2):
"""
Set the device to dual colour breathing effect
:param red1: Red component
:type red1: int
:param green1: Green component
:type green1: int
:param blue1: Blue component
:type blue1: int
:param red2: Red component
:type red2: int
:param green2: Green component
:type green2: int
:param blue2: Blue component
:type blue2: int
"""
self.logger.debug("DBus call set_breath_dual_effect")
# Notify others
self.send_effect_event('setBreathDual', red1, green1, blue1, red2, green2, blue2)
# remember effect
self.set_persistence("logo", "effect", 'breathDual')
self.zone["logo"]["colors"][0:6] = int(red1), int(green1), int(blue1), int(red2), int(green2), int(blue2)
driver_path = self.get_driver_path('logo_matrix_effect_breath')
payload = bytes([red1, green1, blue1, red2, green2, blue2])
with open(driver_path, 'wb') as driver_file:
driver_file.write(payload)
@endpoint('razer.device.lighting.scroll', 'setScrollStatic', in_sig='yyy')
def set_scroll_static_naga_hex_v2(self, red, green, blue):
"""
Set the device to static colour
:param red: Red component
:type red: int
:param green: Green component
:type green: int
:param blue: Blue component
:type blue: int
"""
self.logger.debug("DBus call set_static_effect")
# Notify others
self.send_effect_event('setStatic', red, green, blue)
# remember effect
self.set_persistence("scroll", "effect", 'static')
self.zone["scroll"]["colors"][0:3] = int(red), int(green), int(blue)
rgb_driver_path = self.get_driver_path('scroll_matrix_effect_static')
payload = bytes([red, green, blue])
with open(rgb_driver_path, 'wb') as rgb_driver_file:
rgb_driver_file.write(payload)
@endpoint('razer.device.lighting.scroll', 'setScrollSpectrum')
def set_scroll_spectrum_naga_hex_v2(self):
"""
Set the device to spectrum mode
"""
self.logger.debug("DBus call set_scroll_spectrum")
# Notify others
self.send_effect_event('setSpectrum')
self.set_persistence("scroll", "effect", 'spectrum')
effect_driver_path = self.get_driver_path('scroll_matrix_effect_spectrum')
with open(effect_driver_path, 'w') as effect_driver_file:
effect_driver_file.write('1')
@endpoint('razer.device.lighting.scroll', 'setScrollNone')
def set_scroll_none_naga_hex_v2(self):
"""
Set the device to effect none
"""
self.logger.debug("DBus call set_none_effect")
# Notify others
self.send_effect_event('setNone')
self.set_persistence("scroll", "effect", 'none')
driver_path = self.get_driver_path('scroll_matrix_effect_none')
with open(driver_path, 'w') as driver_file:
driver_file.write('1')
@endpoint('razer.device.lighting.scroll', 'setScrollReactive', in_sig='yyyy')
def set_scroll_reactive_naga_hex_v2(self, red, green, blue, speed):
"""
Set the device to reactive effect
:param red: Red component
:type red: int
:param green: Green component
:type green: int
:param blue: Blue component
:type blue: int
:param speed: Speed
:type speed: int
"""
self.logger.debug("DBus call set_reactive_effect")
driver_path = self.get_driver_path('scroll_matrix_effect_reactive')
# Notify others
self.send_effect_event('setReactive', red, green, blue, speed)
# remember effect
self.set_persistence("scroll", "effect", 'reactive')
self.zone["scroll"]["colors"][0:3] = int(red), int(green), int(blue)
self.set_persistence("scroll", "speed", int(speed))
if speed not in (1, 2, 3, 4):
speed = 4
payload = bytes([speed, red, green, blue])
with open(driver_path, 'wb') as driver_file:
driver_file.write(payload)
@endpoint('razer.device.lighting.scroll', 'setScrollBreathRandom')
def set_scroll_breath_random_naga_hex_v2(self):
"""
Set the device to random colour breathing effect
"""
self.logger.debug("DBus call set_breath_random_effect")
# Notify others
self.send_effect_event('setBreathRandom')
# remember effect
self.set_persistence("scroll", "effect", 'breathRandom')
driver_path = self.get_driver_path('scroll_matrix_effect_breath')
payload = b'1'
with open(driver_path, 'wb') as driver_file:
driver_file.write(payload)
@endpoint('razer.device.lighting.scroll', 'setScrollBreathSingle', in_sig='yyy')
def set_scroll_breath_single_naga_hex_v2(self, red, green, blue):
"""
Set the device to single colour breathing effect
:param red: Red component
:type red: int
:param green: Green component
:type green: int
:param blue: Blue component
:type blue: int
"""
self.logger.debug("DBus call set_breath_single_effect")
# Notify others
self.send_effect_event('setBreathSingle', red, green, blue)
# remember effect
self.set_persistence("scroll", "effect", 'breathSingle')
self.zone["scroll"]["colors"][0:3] = int(red), int(green), int(blue)
driver_path = self.get_driver_path('scroll_matrix_effect_breath')
payload = bytes([red, green, blue])
with open(driver_path, 'wb') as driver_file:
driver_file.write(payload)
@endpoint('razer.device.lighting.scroll', 'setScrollBreathDual', in_sig='yyyyyy')
def set_scroll_breath_dual_naga_hex_v2(self, red1, green1, blue1, red2, green2, blue2):
"""
Set the device to dual colour breathing effect
:param red1: Red component
:type red1: int
:param green1: Green component
:type green1: int
:param blue1: Blue component
:type blue1: int
:param red2: Red component
:type red2: int
:param green2: Green component
:type green2: int
:param blue2: Blue component
:type blue2: int
"""
self.logger.debug("DBus call set_breath_dual_effect")
# Notify others
self.send_effect_event('setBreathDual', red1, green1, blue1, red2, green2, blue2)
# remember effect
self.set_persistence("scroll", "effect", 'breathDual')
self.zone["scroll"]["colors"][0:6] = int(red1), int(green1), int(blue1), int(red2), int(green2), int(blue2)
driver_path = self.get_driver_path('scroll_matrix_effect_breath')
payload = bytes([red1, green1, blue1, red2, green2, blue2])
with open(driver_path, 'wb') as driver_file:
driver_file.write(payload)
|
import json
from homeassistant.components.wled.const import DOMAIN
from homeassistant.const import CONF_HOST, CONF_MAC, CONTENT_TYPE_JSON
from homeassistant.core import HomeAssistant
from tests.common import MockConfigEntry, load_fixture
from tests.test_util.aiohttp import AiohttpClientMocker
async def init_integration(
hass: HomeAssistant,
aioclient_mock: AiohttpClientMocker,
rgbw: bool = False,
skip_setup: bool = False,
) -> MockConfigEntry:
"""Set up the WLED integration in Home Assistant."""
fixture = "wled/rgb.json" if not rgbw else "wled/rgbw.json"
data = json.loads(load_fixture(fixture))
aioclient_mock.get(
"http://192.168.1.123:80/json/",
json=data,
headers={"Content-Type": CONTENT_TYPE_JSON},
)
aioclient_mock.post(
"http://192.168.1.123:80/json/state",
json=data["state"],
headers={"Content-Type": CONTENT_TYPE_JSON},
)
aioclient_mock.get(
"http://192.168.1.123:80/json/info",
json=data["info"],
headers={"Content-Type": CONTENT_TYPE_JSON},
)
aioclient_mock.get(
"http://192.168.1.123:80/json/state",
json=data["state"],
headers={"Content-Type": CONTENT_TYPE_JSON},
)
entry = MockConfigEntry(
domain=DOMAIN, data={CONF_HOST: "192.168.1.123", CONF_MAC: "aabbccddeeff"}
)
entry.add_to_hass(hass)
if not skip_setup:
await hass.config_entries.async_setup(entry.entry_id)
await hass.async_block_till_done()
return entry
|
from xs1_api_client.api_constants import ActuatorType
from homeassistant.helpers.entity import ToggleEntity
from . import ACTUATORS, DOMAIN as COMPONENT_DOMAIN, XS1DeviceEntity
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the XS1 switch platform."""
actuators = hass.data[COMPONENT_DOMAIN][ACTUATORS]
switch_entities = []
for actuator in actuators:
if (actuator.type() == ActuatorType.SWITCH) or (
actuator.type() == ActuatorType.DIMMER
):
switch_entities.append(XS1SwitchEntity(actuator))
add_entities(switch_entities)
class XS1SwitchEntity(XS1DeviceEntity, ToggleEntity):
"""Representation of a XS1 switch actuator."""
@property
def name(self):
"""Return the name of the device if any."""
return self.device.name()
@property
def is_on(self):
"""Return true if switch is on."""
return self.device.value() == 100
def turn_on(self, **kwargs):
"""Turn the device on."""
self.device.turn_on()
def turn_off(self, **kwargs):
"""Turn the device off."""
self.device.turn_off()
|
from django.contrib.auth.decorators import login_required
from django.core.exceptions import PermissionDenied
from django.shortcuts import get_object_or_404, redirect
from django.views.decorators.cache import never_cache
from django.views.decorators.http import require_POST
from weblate.trans.forms import LabelForm
from weblate.trans.models import Label
from weblate.trans.util import render
from weblate.utils.views import get_project
@login_required
@never_cache
def project_labels(request, project):
obj = get_project(request, project)
if not request.user.has_perm("project.edit", obj):
raise PermissionDenied()
if request.method == "POST":
form = LabelForm(request.POST)
if form.is_valid():
form.instance.project = obj
form.save()
return redirect("labels", project=project)
else:
form = LabelForm()
return render(
request, "project-labels.html", {"object": obj, "project": obj, "form": form}
)
@login_required
@never_cache
def label_edit(request, project, pk):
obj = get_project(request, project)
if not request.user.has_perm("project.edit", obj):
raise PermissionDenied()
label = get_object_or_404(Label, pk=pk, project=obj)
if request.method == "POST":
form = LabelForm(request.POST, instance=label)
if form.is_valid():
form.save()
return redirect("labels", project=project)
else:
form = LabelForm(instance=label)
return render(
request,
"project-label-edit.html",
{"object": obj, "project": obj, "form": form},
)
@login_required
@never_cache
@require_POST
def label_delete(request, project, pk):
obj = get_project(request, project)
if not request.user.has_perm("project.edit", obj):
raise PermissionDenied()
label = get_object_or_404(Label, pk=pk, project=obj)
label.delete()
return redirect("labels", project=project)
|
import pytest
from homeassistant.components import automation, zone
from homeassistant.const import ATTR_ENTITY_ID, ENTITY_MATCH_ALL, SERVICE_TURN_OFF
from homeassistant.core import Context
from homeassistant.setup import async_setup_component
from tests.common import async_mock_service, mock_component
@pytest.fixture
def calls(hass):
"""Track calls to a mock service."""
return async_mock_service(hass, "test", "automation")
@pytest.fixture(autouse=True)
def setup_comp(hass):
"""Initialize components."""
mock_component(hass, "group")
hass.loop.run_until_complete(
async_setup_component(
hass,
zone.DOMAIN,
{
"zone": {
"name": "test",
"latitude": 32.880837,
"longitude": -117.237561,
"radius": 250,
}
},
)
)
async def test_if_fires_on_zone_enter(hass, calls):
"""Test for firing on zone enter."""
context = Context()
hass.states.async_set(
"geo_location.entity",
"hello",
{"latitude": 32.881011, "longitude": -117.234758, "source": "test_source"},
)
await hass.async_block_till_done()
assert await async_setup_component(
hass,
automation.DOMAIN,
{
automation.DOMAIN: {
"trigger": {
"platform": "geo_location",
"source": "test_source",
"zone": "zone.test",
"event": "enter",
},
"action": {
"service": "test.automation",
"data_template": {
"some": "{{ trigger.%s }}"
% "}} - {{ trigger.".join(
(
"platform",
"entity_id",
"from_state.state",
"to_state.state",
"zone.name",
)
)
},
},
}
},
)
hass.states.async_set(
"geo_location.entity",
"hello",
{"latitude": 32.880586, "longitude": -117.237564},
context=context,
)
await hass.async_block_till_done()
assert len(calls) == 1
assert calls[0].context.parent_id == context.id
assert (
calls[0].data["some"]
== "geo_location - geo_location.entity - hello - hello - test"
)
# Set out of zone again so we can trigger call
hass.states.async_set(
"geo_location.entity",
"hello",
{"latitude": 32.881011, "longitude": -117.234758},
)
await hass.async_block_till_done()
await hass.services.async_call(
automation.DOMAIN,
SERVICE_TURN_OFF,
{ATTR_ENTITY_ID: ENTITY_MATCH_ALL},
blocking=True,
)
hass.states.async_set(
"geo_location.entity",
"hello",
{"latitude": 32.880586, "longitude": -117.237564},
)
await hass.async_block_till_done()
assert len(calls) == 1
async def test_if_not_fires_for_enter_on_zone_leave(hass, calls):
"""Test for not firing on zone leave."""
hass.states.async_set(
"geo_location.entity",
"hello",
{"latitude": 32.880586, "longitude": -117.237564, "source": "test_source"},
)
await hass.async_block_till_done()
assert await async_setup_component(
hass,
automation.DOMAIN,
{
automation.DOMAIN: {
"trigger": {
"platform": "geo_location",
"source": "test_source",
"zone": "zone.test",
"event": "enter",
},
"action": {"service": "test.automation"},
}
},
)
hass.states.async_set(
"geo_location.entity",
"hello",
{"latitude": 32.881011, "longitude": -117.234758},
)
await hass.async_block_till_done()
assert len(calls) == 0
async def test_if_fires_on_zone_leave(hass, calls):
"""Test for firing on zone leave."""
hass.states.async_set(
"geo_location.entity",
"hello",
{"latitude": 32.880586, "longitude": -117.237564, "source": "test_source"},
)
await hass.async_block_till_done()
assert await async_setup_component(
hass,
automation.DOMAIN,
{
automation.DOMAIN: {
"trigger": {
"platform": "geo_location",
"source": "test_source",
"zone": "zone.test",
"event": "leave",
},
"action": {"service": "test.automation"},
}
},
)
hass.states.async_set(
"geo_location.entity",
"hello",
{"latitude": 32.881011, "longitude": -117.234758, "source": "test_source"},
)
await hass.async_block_till_done()
assert len(calls) == 1
async def test_if_not_fires_for_leave_on_zone_enter(hass, calls):
"""Test for not firing on zone enter."""
hass.states.async_set(
"geo_location.entity",
"hello",
{"latitude": 32.881011, "longitude": -117.234758, "source": "test_source"},
)
await hass.async_block_till_done()
assert await async_setup_component(
hass,
automation.DOMAIN,
{
automation.DOMAIN: {
"trigger": {
"platform": "geo_location",
"source": "test_source",
"zone": "zone.test",
"event": "leave",
},
"action": {"service": "test.automation"},
}
},
)
hass.states.async_set(
"geo_location.entity",
"hello",
{"latitude": 32.880586, "longitude": -117.237564},
)
await hass.async_block_till_done()
assert len(calls) == 0
async def test_if_fires_on_zone_appear(hass, calls):
"""Test for firing if entity appears in zone."""
assert await async_setup_component(
hass,
automation.DOMAIN,
{
automation.DOMAIN: {
"trigger": {
"platform": "geo_location",
"source": "test_source",
"zone": "zone.test",
"event": "enter",
},
"action": {
"service": "test.automation",
"data_template": {
"some": "{{ trigger.%s }}"
% "}} - {{ trigger.".join(
(
"platform",
"entity_id",
"from_state.state",
"to_state.state",
"zone.name",
)
)
},
},
}
},
)
# Entity appears in zone without previously existing outside the zone.
context = Context()
hass.states.async_set(
"geo_location.entity",
"hello",
{"latitude": 32.880586, "longitude": -117.237564, "source": "test_source"},
context=context,
)
await hass.async_block_till_done()
assert len(calls) == 1
assert calls[0].context.parent_id == context.id
assert (
calls[0].data["some"] == "geo_location - geo_location.entity - - hello - test"
)
async def test_if_fires_on_zone_disappear(hass, calls):
"""Test for firing if entity disappears from zone."""
hass.states.async_set(
"geo_location.entity",
"hello",
{"latitude": 32.880586, "longitude": -117.237564, "source": "test_source"},
)
await hass.async_block_till_done()
assert await async_setup_component(
hass,
automation.DOMAIN,
{
automation.DOMAIN: {
"trigger": {
"platform": "geo_location",
"source": "test_source",
"zone": "zone.test",
"event": "leave",
},
"action": {
"service": "test.automation",
"data_template": {
"some": "{{ trigger.%s }}"
% "}} - {{ trigger.".join(
(
"platform",
"entity_id",
"from_state.state",
"to_state.state",
"zone.name",
)
)
},
},
}
},
)
# Entity disappears from zone without new coordinates outside the zone.
hass.states.async_remove("geo_location.entity")
await hass.async_block_till_done()
assert len(calls) == 1
assert (
calls[0].data["some"] == "geo_location - geo_location.entity - hello - - test"
)
|
from __future__ import unicode_literals
import operator
import itertools
import functools
import traceback
from core.CONF import get_conf_dic
from lib.fun.filter import encode_filter
from lib.data.data import pystrs, pyoptions
from lib.fun.fun import finalsavepath, finishprinter, cool
from lib.parse.confparse import elementparser, confmatcher
def build_pattern_dic(source=""):
buffer = []
buffer_size = 512
storepath = finalsavepath("pattern")
pattern_set = patterncore(source)
char_list = [sorted(set(i)) for i in pattern_set.values()]
try:
with open(storepath, "w") as f:
for item in map("".join, itertools.product(*char_list)):
item = pyoptions.head + item + pyoptions.tail
buffer.append(item if pyoptions.encode == "none" else encode_filter(item, encode=pyoptions.encode))
if len(buffer) == buffer_size:
f.write(pyoptions.CRLF.join(buffer) + pyoptions.CRLF)
buffer = []
f.write(pyoptions.CRLF.join(buffer))
finishprinter(storepath)
except Exception as e:
print(cool.red('[-] Exception as following:') + pyoptions.CRLF)
print(traceback.print_exc())
def patterncore(resource):
pattern_set = {}
try:
confdicts = elementparser(confmatcher(resource))
except IndexError:
confdicts = {}
exit(cool.red("[-] parse element error, please check your parsing element"))
finalen = len(confdicts[pystrs.conf_head])
for x in range(0, finalen):
# pattern_set_list = confdicts[pystrs.conf_char][x]
# keep parsing head and tail
pattern_set_list = get_conf_dic(int(confdicts[pystrs.conf_minlen][x]),
int(confdicts[pystrs.conf_maxlen][x]),
confdicts[pystrs.conf_char][x],
confdicts[pystrs.conf_encode][x],
confdicts[pystrs.conf_head][x],
confdicts[pystrs.conf_tail][x])
pattern_set[x] = "".join(pattern_set_list)
count = functools.reduce(operator.mul, [len(i) for i in pattern_set.values()], 1)
if count >= pyoptions.count_switcher:
exit_msg = pyoptions.CRLF + cool.fuchsia("[!] Build items more than pyoptions.count_switcher: %s%s"
"[!] Modify /lib/data/data.py count_switcher to adjust it" %
(str(pyoptions.count_switcher), pyoptions.CRLF))
exit(exit_msg)
return pattern_set
|
import json
import random
import requests
import requests.exceptions
import time
class OpenTSDBClient(object):
"""OpenTSDBClient primary client object to connect OpenTSDB.
The :class:`~.OpenTSDBClient` object holds information necessary to
connect to OpenTSDB. Requests can be made to OpenTSDB directly through
the client.
:param host: hostname to connect to OpenTSDB, defaults to 'localhost'
:type host: str
:param port: port to connect to OpenTSDB, defaults to 4242
:type port: int
:param username: user to connect, defaults to 'root'
:type username: str
:param password: password of the user, defaults to 'root'
:type password: str
:param pool_size: urllib3 connection pool size, defaults to 10.
:type pool_size: int
:param ssl: use https instead of http to connect to OpenTSDB, defaults to
False
:type ssl: bool
:param verify_ssl: verify SSL certificates for HTTPS requests, defaults to
False
:type verify_ssl: bool
:param timeout: number of seconds Requests will wait for your client to
establish a connection, defaults to None
:type timeout: int
:param retries: number of retries your client will try before aborting,
defaults to 3. 0 indicates try until success
:type retries: int
:param proxies: HTTP(S) proxy to use for Requests, defaults to {}
:type proxies: dict
:param cert: Path to client certificate information to use for mutual TLS
authentication. You can specify a local cert to use
as a single file containing the private key and the certificate, or as
a tuple of both files’ paths, defaults to None
:type cert: str
:raises ValueError: if cert is provided but ssl is disabled (set to False)
"""
def __init__(
self,
host='localhost',
port=4242,
username='root',
password='root',
ssl=False,
verify_ssl=False,
timeout=None,
retries=3,
proxies=None,
pool_size=10,
cert=None,
):
"""Construct a new OpenTSDBClient object."""
self._host = host
self._port = int(port)
self._username = username
self._password = password
self._timeout = timeout
self._retries = retries
self._verify_ssl = verify_ssl
self._session = requests.Session()
adapter = requests.adapters.HTTPAdapter(
pool_connections=int(pool_size), pool_maxsize=int(pool_size))
self._scheme = "http"
if ssl is True:
self._scheme = "https"
self._session.mount(self._scheme + '://', adapter)
if proxies is None:
self._proxies = {}
else:
self._proxies = proxies
if cert:
if not ssl:
raise ValueError(
"Client certificate provided but ssl is disabled.")
else:
self._session.cert = cert
self._baseurl = "{0}://{1}:{2}".format(
self._scheme, self._host, self._port)
self._headers = {
'Content-Type': 'application/json',
'Accept': 'application/json'
}
def write(self, data, expected_response_code=204):
"""Write data to OpenTSDB.
:param data: the data to be written
:param expected_response_code: the expected response code of the write
operation, defaults to 204
:type expected_response_code: int
:returns: True, if the write operation is successful
:rtype: bool
"""
headers = self._headers
headers['Content-Type'] = 'application/json'
self.request(
url="api/put",
method='POST',
data=data,
expected_response_code=expected_response_code,
headers=headers)
return True
def request(
self,
url,
method='GET',
params=None,
data=None,
expected_response_code=200,
headers=None):
"""Make a HTTP request to the OpenTSDB API.
:param url: the path of the HTTP request
:type url: str
:param method: the HTTP method for the request, defaults to GET
:type method: str
:param params: additional parameters for the request, defaults to None
:type params: dict
:param data: the data of the request, defaults to None
:type data: str
:param expected_response_code: the expected response code of
the request, defaults to 200
:type expected_response_code: int
:param headers: headers to add to the request
:type headers: dict
:returns: the response from the request
:rtype: :class:`requests.Response`
:raises OpenTSDBServerError: if the response code is any server error
code (5xx)
:raises OpenTSDBClientError: if the response code is not the
same as `expected_response_code` and is not a server error code
"""
url = "{0}/{1}".format(self._baseurl, url)
if headers is None:
headers = self._headers
if params is None:
params = {}
if isinstance(data, (dict, list)):
data = json.dumps(data)
# Try to send the request more than once by default (see #103)
retry = True
_try = 0
while retry:
try:
response = self._session.request(
method=method,
url=url,
auth=(self._username, self._password),
params=params,
data=data,
headers=headers,
proxies=self._proxies,
verify=self._verify_ssl,
timeout=self._timeout)
break
except (requests.exceptions.ConnectionError,
requests.exceptions.HTTPError, requests.exceptions.Timeout):
_try += 1
if self._retries != 0:
retry = _try < self._retries
if method == "POST":
time.sleep((2**_try) * random.random() / 100.0)
if not retry:
raise
# if there's not an error, there must have been a successful response
if 500 <= response.status_code < 600:
raise Exception(response.content)
elif response.status_code == expected_response_code:
return response
else:
raise Exception(response.content, response.status_code)
|
from ..grammar import NonTerminal, Terminal
class Item(object):
"An Earley Item, the atom of the algorithm."
__slots__ = ('s', 'rule', 'ptr', 'start', 'is_complete', 'expect', 'previous', 'node', '_hash')
def __init__(self, rule, ptr, start):
self.is_complete = len(rule.expansion) == ptr
self.rule = rule # rule
self.ptr = ptr # ptr
self.start = start # j
self.node = None # w
if self.is_complete:
self.s = rule.origin
self.expect = None
self.previous = rule.expansion[ptr - 1] if ptr > 0 and len(rule.expansion) else None
else:
self.s = (rule, ptr)
self.expect = rule.expansion[ptr]
self.previous = rule.expansion[ptr - 1] if ptr > 0 and len(rule.expansion) else None
self._hash = hash((self.s, self.start))
def advance(self):
return Item(self.rule, self.ptr + 1, self.start)
def __eq__(self, other):
return self is other or (self.s == other.s and self.start == other.start)
def __hash__(self):
return self._hash
def __repr__(self):
before = ( expansion.name for expansion in self.rule.expansion[:self.ptr] )
after = ( expansion.name for expansion in self.rule.expansion[self.ptr:] )
symbol = "{} ::= {}* {}".format(self.rule.origin.name, ' '.join(before), ' '.join(after))
return '%s (%d)' % (symbol, self.start)
class TransitiveItem(Item):
__slots__ = ('recognized', 'reduction', 'column', 'next_titem')
def __init__(self, recognized, trule, originator, start):
super(TransitiveItem, self).__init__(trule.rule, trule.ptr, trule.start)
self.recognized = recognized
self.reduction = originator
self.column = start
self.next_titem = None
self._hash = hash((self.s, self.start, self.recognized))
def __eq__(self, other):
if not isinstance(other, TransitiveItem):
return False
return self is other or (type(self.s) == type(other.s) and self.s == other.s and self.start == other.start and self.recognized == other.recognized)
def __hash__(self):
return self._hash
def __repr__(self):
before = ( expansion.name for expansion in self.rule.expansion[:self.ptr] )
after = ( expansion.name for expansion in self.rule.expansion[self.ptr:] )
return '{} : {} -> {}* {} ({}, {})'.format(self.recognized.name, self.rule.origin.name, ' '.join(before), ' '.join(after), self.column, self.start)
|
import asynctest
from mock import patch
from paasta_tools.monitoring import check_mesos_outdated_tasks
@patch(
"paasta_tools.monitoring.check_mesos_outdated_tasks.get_mesos_master", autospec=True
)
def test_check_mesos_tasks(mock_get_mesos_master):
mock_get_mesos_master.return_value.state = asynctest.CoroutineMock(
func=asynctest.CoroutineMock(),
return_value={
"slaves": [
{
"id": "4abbb181-fd06-4729-815b-6b55cebdf8ee-S2",
"hostname": "mesos-slave1.example.com",
}
],
"frameworks": [
{
"name": "marathon",
"tasks": [
{
"state": "TASK_RUNNING",
"name": "service.instance.gitlast_SHA.config3f15fefe",
"slave_id": "4abbb181-fd06-4729-815b-6b55cebdf8ee-S2",
"statuses": [
{
"state": "TASK_RUNNING",
"timestamp": 1509392500.9267,
"container_status": {
"container_id": {
"value": "a69b426d-f283-4287-9bee-6b8811386e1a"
}
},
}
],
},
{
"state": "TASK_RUNNING",
"name": "service.instance.gitold_SHA.config3f15fefe",
"slave_id": "4abbb181-fd06-4729-815b-6b55cebdf8ee-S2",
"statuses": [
{
"state": "TASK_RUNNING",
"timestamp": 1509342500.9267,
"container_status": {
"container_id": {
"value": "a69b426d-f283-4287-9bee-6b8811386e1b"
}
},
}
],
},
],
}
],
},
)
output, remedy = check_mesos_outdated_tasks.check_mesos_tasks()
assert len(output) == 1
assert "a69b426d-f283-4287-9bee-6b8811386e1b" in output[0]
assert "old_SHA" in output[0]
|
import unittest
import numpy as np
from chainer import testing
from chainercv.transforms import resize_bbox
from chainercv.utils.testing.generate_random_bbox import generate_random_bbox
class TestResizeBbox(unittest.TestCase):
def test_resize_bbox(self):
in_size = (32, 24)
out_size = (in_size[0] * 2, in_size[1] * 4)
bbox = generate_random_bbox(10, in_size, 0, min(in_size))
out = resize_bbox(bbox, in_size=in_size, out_size=out_size)
bbox_expected = bbox.copy()
bbox_expected[:, 0] = bbox[:, 0] * 2
bbox_expected[:, 1] = bbox[:, 1] * 4
bbox_expected[:, 2] = bbox[:, 2] * 2
bbox_expected[:, 3] = bbox[:, 3] * 4
np.testing.assert_equal(out, bbox_expected)
testing.run_module(__name__, __file__)
|
import json
import logging
import pyfttt
import requests
import voluptuous as vol
from homeassistant.const import CONF_WEBHOOK_ID, HTTP_OK
from homeassistant.helpers import config_entry_flow
import homeassistant.helpers.config_validation as cv
from .const import DOMAIN
_LOGGER = logging.getLogger(__name__)
EVENT_RECEIVED = "ifttt_webhook_received"
ATTR_EVENT = "event"
ATTR_TARGET = "target"
ATTR_VALUE1 = "value1"
ATTR_VALUE2 = "value2"
ATTR_VALUE3 = "value3"
CONF_KEY = "key"
SERVICE_PUSH_ALARM_STATE = "push_alarm_state"
SERVICE_TRIGGER = "trigger"
SERVICE_TRIGGER_SCHEMA = vol.Schema(
{
vol.Required(ATTR_EVENT): cv.string,
vol.Optional(ATTR_TARGET): vol.All(cv.ensure_list, [cv.string]),
vol.Optional(ATTR_VALUE1): cv.string,
vol.Optional(ATTR_VALUE2): cv.string,
vol.Optional(ATTR_VALUE3): cv.string,
}
)
CONFIG_SCHEMA = vol.Schema(
{
vol.Optional(DOMAIN): vol.Schema(
{vol.Required(CONF_KEY): vol.Any({cv.string: cv.string}, cv.string)}
)
},
extra=vol.ALLOW_EXTRA,
)
async def async_setup(hass, config):
"""Set up the IFTTT service component."""
if DOMAIN not in config:
return True
api_keys = config[DOMAIN][CONF_KEY]
if isinstance(api_keys, str):
api_keys = {"default": api_keys}
def trigger_service(call):
"""Handle IFTTT trigger service calls."""
event = call.data[ATTR_EVENT]
targets = call.data.get(ATTR_TARGET, list(api_keys))
value1 = call.data.get(ATTR_VALUE1)
value2 = call.data.get(ATTR_VALUE2)
value3 = call.data.get(ATTR_VALUE3)
target_keys = {}
for target in targets:
if target not in api_keys:
_LOGGER.error("No IFTTT api key for %s", target)
continue
target_keys[target] = api_keys[target]
try:
for target, key in target_keys.items():
res = pyfttt.send_event(key, event, value1, value2, value3)
if res.status_code != HTTP_OK:
_LOGGER.error("IFTTT reported error sending event to %s", target)
except requests.exceptions.RequestException:
_LOGGER.exception("Error communicating with IFTTT")
hass.services.async_register(
DOMAIN, SERVICE_TRIGGER, trigger_service, schema=SERVICE_TRIGGER_SCHEMA
)
return True
async def handle_webhook(hass, webhook_id, request):
"""Handle webhook callback."""
body = await request.text()
try:
data = json.loads(body) if body else {}
except ValueError:
_LOGGER.error(
"Received invalid data from IFTTT. Data needs to be formatted as JSON: %s",
body,
)
return
if not isinstance(data, dict):
_LOGGER.error(
"Received invalid data from IFTTT. Data needs to be a dictionary: %s", data
)
return
data["webhook_id"] = webhook_id
hass.bus.async_fire(EVENT_RECEIVED, data)
async def async_setup_entry(hass, entry):
"""Configure based on config entry."""
hass.components.webhook.async_register(
DOMAIN, "IFTTT", entry.data[CONF_WEBHOOK_ID], handle_webhook
)
return True
async def async_unload_entry(hass, entry):
"""Unload a config entry."""
hass.components.webhook.async_unregister(entry.data[CONF_WEBHOOK_ID])
return True
async_remove_entry = config_entry_flow.webhook_async_remove_entry
|
import asyncio
from copy import copy
import logging
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.const import (
CONF_BINARY_SENSORS,
CONF_LIGHTS,
CONF_MAXIMUM,
CONF_MINIMUM,
CONF_NAME,
CONF_PIN,
CONF_SENSORS,
CONF_SWITCHES,
EVENT_HOMEASSISTANT_STOP,
)
from homeassistant.core import HomeAssistant
from homeassistant.helpers import config_validation as cv, device_registry as dr
from .board import FirmataBoard
from .const import (
CONF_ARDUINO_INSTANCE_ID,
CONF_ARDUINO_WAIT,
CONF_DIFFERENTIAL,
CONF_INITIAL_STATE,
CONF_NEGATE_STATE,
CONF_PIN_MODE,
CONF_PLATFORM_MAP,
CONF_SAMPLING_INTERVAL,
CONF_SERIAL_BAUD_RATE,
CONF_SERIAL_PORT,
CONF_SLEEP_TUNE,
DOMAIN,
FIRMATA_MANUFACTURER,
PIN_MODE_ANALOG,
PIN_MODE_INPUT,
PIN_MODE_OUTPUT,
PIN_MODE_PULLUP,
PIN_MODE_PWM,
)
_LOGGER = logging.getLogger(__name__)
DATA_CONFIGS = "board_configs"
ANALOG_PIN_SCHEMA = vol.All(cv.string, vol.Match(r"^A[0-9]+$"))
SWITCH_SCHEMA = vol.Schema(
{
vol.Required(CONF_NAME): cv.string,
# Both digital and analog pins may be used as digital output
vol.Required(CONF_PIN): vol.Any(cv.positive_int, ANALOG_PIN_SCHEMA),
vol.Required(CONF_PIN_MODE): PIN_MODE_OUTPUT,
vol.Optional(CONF_INITIAL_STATE, default=False): cv.boolean,
vol.Optional(CONF_NEGATE_STATE, default=False): cv.boolean,
},
required=True,
)
LIGHT_SCHEMA = vol.Schema(
{
vol.Required(CONF_NAME): cv.string,
# Both digital and analog pins may be used as PWM/analog output
vol.Required(CONF_PIN): vol.Any(cv.positive_int, ANALOG_PIN_SCHEMA),
vol.Required(CONF_PIN_MODE): PIN_MODE_PWM,
vol.Optional(CONF_INITIAL_STATE, default=0): cv.positive_int,
vol.Optional(CONF_MINIMUM, default=0): cv.positive_int,
vol.Optional(CONF_MAXIMUM, default=255): cv.positive_int,
},
required=True,
)
BINARY_SENSOR_SCHEMA = vol.Schema(
{
vol.Required(CONF_NAME): cv.string,
# Both digital and analog pins may be used as digital input
vol.Required(CONF_PIN): vol.Any(cv.positive_int, ANALOG_PIN_SCHEMA),
vol.Required(CONF_PIN_MODE): vol.Any(PIN_MODE_INPUT, PIN_MODE_PULLUP),
vol.Optional(CONF_NEGATE_STATE, default=False): cv.boolean,
},
required=True,
)
SENSOR_SCHEMA = vol.Schema(
{
vol.Required(CONF_NAME): cv.string,
# Currently only analog input sensor is implemented
vol.Required(CONF_PIN): ANALOG_PIN_SCHEMA,
vol.Required(CONF_PIN_MODE): PIN_MODE_ANALOG,
# Default differential is 40 to avoid a flood of messages on initial setup
# in case pin is unplugged. Firmata responds really really fast
vol.Optional(CONF_DIFFERENTIAL, default=40): vol.All(
cv.positive_int, vol.Range(min=1)
),
},
required=True,
)
BOARD_CONFIG_SCHEMA = vol.Schema(
{
vol.Required(CONF_SERIAL_PORT): cv.string,
vol.Optional(CONF_SERIAL_BAUD_RATE): cv.positive_int,
vol.Optional(CONF_ARDUINO_INSTANCE_ID): cv.positive_int,
vol.Optional(CONF_ARDUINO_WAIT): cv.positive_int,
vol.Optional(CONF_SLEEP_TUNE): vol.All(
vol.Coerce(float), vol.Range(min=0.0001)
),
vol.Optional(CONF_SAMPLING_INTERVAL): cv.positive_int,
vol.Optional(CONF_SWITCHES): [SWITCH_SCHEMA],
vol.Optional(CONF_LIGHTS): [LIGHT_SCHEMA],
vol.Optional(CONF_BINARY_SENSORS): [BINARY_SENSOR_SCHEMA],
vol.Optional(CONF_SENSORS): [SENSOR_SCHEMA],
},
required=True,
)
CONFIG_SCHEMA = vol.Schema(
{DOMAIN: vol.All(cv.ensure_list, [BOARD_CONFIG_SCHEMA])}, extra=vol.ALLOW_EXTRA
)
async def async_setup(hass: HomeAssistant, config: dict) -> bool:
"""Set up the Firmata domain."""
# Delete specific entries that no longer exist in the config
if hass.config_entries.async_entries(DOMAIN):
for entry in hass.config_entries.async_entries(DOMAIN):
remove = True
for board in config[DOMAIN]:
if entry.data[CONF_SERIAL_PORT] == board[CONF_SERIAL_PORT]:
remove = False
break
if remove:
await hass.config_entries.async_remove(entry.entry_id)
# Setup new entries and update old entries
for board in config[DOMAIN]:
firmata_config = copy(board)
existing_entry = False
for entry in hass.config_entries.async_entries(DOMAIN):
if board[CONF_SERIAL_PORT] == entry.data[CONF_SERIAL_PORT]:
existing_entry = True
firmata_config[CONF_NAME] = entry.data[CONF_NAME]
hass.config_entries.async_update_entry(entry, data=firmata_config)
break
if not existing_entry:
hass.async_create_task(
hass.config_entries.flow.async_init(
DOMAIN,
context={"source": config_entries.SOURCE_IMPORT},
data=firmata_config,
)
)
return True
async def async_setup_entry(
hass: HomeAssistant, config_entry: config_entries.ConfigEntry
) -> bool:
"""Set up a Firmata board for a config entry."""
if DOMAIN not in hass.data:
hass.data[DOMAIN] = {}
_LOGGER.debug(
"Setting up Firmata id %s, name %s, config %s",
config_entry.entry_id,
config_entry.data[CONF_NAME],
config_entry.data,
)
board = FirmataBoard(config_entry.data)
if not await board.async_setup():
return False
hass.data[DOMAIN][config_entry.entry_id] = board
async def handle_shutdown(event) -> None:
"""Handle shutdown of board when Home Assistant shuts down."""
# Ensure board was not already removed previously before shutdown
if config_entry.entry_id in hass.data[DOMAIN]:
await board.async_reset()
hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, handle_shutdown)
device_registry = await dr.async_get_registry(hass)
device_registry.async_get_or_create(
config_entry_id=config_entry.entry_id,
connections={},
identifiers={(DOMAIN, board.name)},
manufacturer=FIRMATA_MANUFACTURER,
name=board.name,
sw_version=board.firmware_version,
)
for (conf, platform) in CONF_PLATFORM_MAP.items():
if conf in config_entry.data:
hass.async_create_task(
hass.config_entries.async_forward_entry_setup(config_entry, platform)
)
return True
async def async_unload_entry(
hass: HomeAssistant, config_entry: config_entries.ConfigEntry
) -> None:
"""Shutdown and close a Firmata board for a config entry."""
_LOGGER.debug("Closing Firmata board %s", config_entry.data[CONF_NAME])
unload_entries = []
for (conf, platform) in CONF_PLATFORM_MAP.items():
if conf in config_entry.data:
unload_entries.append(
hass.config_entries.async_forward_entry_unload(config_entry, platform)
)
results = []
if unload_entries:
results = await asyncio.gather(*unload_entries)
results.append(await hass.data[DOMAIN].pop(config_entry.entry_id).async_reset())
return False not in results
|
import textwrap
import pytest
from qutebrowser.config import configexc
from qutebrowser.utils import usertypes
def test_validation_error():
e = configexc.ValidationError('val', 'msg')
assert e.option is None
assert str(e) == "Invalid value 'val' - msg"
@pytest.mark.parametrize('deleted, renamed, expected', [
(False, None, "No option 'opt'"),
(True, None, "No option 'opt' (this option was removed from qutebrowser)"),
(False, 'new', "No option 'opt' (this option was renamed to 'new')"),
])
def test_no_option_error(deleted, renamed, expected):
e = configexc.NoOptionError('opt', deleted=deleted, renamed=renamed)
assert e.option == 'opt'
assert str(e) == expected
def test_no_option_error_clash():
with pytest.raises(AssertionError):
configexc.NoOptionError('opt', deleted=True, renamed='foo')
def test_no_autoconfig_error():
e = configexc.NoAutoconfigError('opt')
expected = "The opt setting can only be set in config.py!"
assert str(e) == expected
@pytest.mark.parametrize('raw_backends', [
None,
{'QtWebEngine': 'Qt 5.11', 'QtWebKit': False}
])
def test_backend_error(raw_backends):
e = configexc.BackendError('foo', usertypes.Backend.QtWebKit, raw_backends)
expected = "The foo setting is not available with the QtWebKit backend!"
assert str(e) == expected
def test_backend_error_condition():
e = configexc.BackendError('foo', usertypes.Backend.QtWebEngine,
{'QtWebEngine': 'Qt 5.11', 'QtWebKit': True})
expected = "The foo setting needs Qt 5.11 with the QtWebEngine backend!"
assert str(e) == expected
def test_no_pattern_error():
e = configexc.NoPatternError('foo')
expected = "The foo setting does not support URL patterns!"
assert str(e) == expected
def test_desc_with_text():
"""Test ConfigErrorDesc.with_text."""
old = configexc.ConfigErrorDesc("Error text", Exception("Exception text"))
new = old.with_text("additional text")
assert str(new) == 'Error text (additional text): Exception text'
@pytest.fixture
def errors():
"""Get a ConfigFileErrors object."""
err1 = configexc.ConfigErrorDesc("Error text 1", Exception("Exception 1"))
err2 = configexc.ConfigErrorDesc("Error text 2", Exception("Exception 2"),
"Fake traceback")
return configexc.ConfigFileErrors("config.py", [err1, err2])
def test_config_file_errors_str(errors):
assert str(errors).splitlines() == [
'Errors occurred while reading config.py:',
' Error text 1: Exception 1',
' Error text 2 - Exception: Exception 2',
]
def test_config_file_errors_html(errors):
html = errors.to_html()
assert textwrap.dedent(html) == textwrap.dedent("""
Errors occurred while reading config.py:
<ul>
<li>
<b>Error text 1</b>: Exception 1
</li>
<li>
<b>Error text 2</b>: Exception 2
<pre>
Fake traceback
</pre>
</li>
</ul>
""")
# Make sure the traceback is not indented
assert '<pre>\nFake traceback\n' in html
def test_config_file_errors_fatal():
err = configexc.ConfigErrorDesc("Text", Exception("Text"))
errors = configexc.ConfigFileErrors("state", [err], fatal=True)
assert errors.fatal
|
import csv
import typing
import numpy as np
import pandas as pd
import matchzoo as mz
class Embedding(object):
"""
Embedding class.
Examples::
>>> import matchzoo as mz
>>> train_raw = mz.datasets.toy.load_data()
>>> pp = mz.preprocessors.NaivePreprocessor()
>>> train = pp.fit_transform(train_raw, verbose=0)
>>> vocab_unit = mz.build_vocab_unit(train, verbose=0)
>>> term_index = vocab_unit.state['term_index']
>>> embed_path = mz.datasets.embeddings.EMBED_RANK
To load from a file:
>>> embedding = mz.embedding.load_from_file(embed_path)
>>> matrix = embedding.build_matrix(term_index)
>>> matrix.shape[0] == len(term_index)
True
To build your own:
>>> data = pd.DataFrame(data=[[0, 1], [2, 3]], index=['A', 'B'])
>>> embedding = mz.Embedding(data)
>>> matrix = embedding.build_matrix({'A': 2, 'B': 1, '_PAD': 0})
>>> matrix.shape == (3, 2)
True
"""
def __init__(self, data: pd.DataFrame):
"""
Embedding.
:param data: DataFrame to use as term to vector mapping.
"""
self._data = data
@property
def input_dim(self) -> int:
""":return Embedding input dimension."""
return self._data.shape[0]
@property
def output_dim(self) -> int:
""":return Embedding output dimension."""
return self._data.shape[1]
def build_matrix(
self,
term_index: typing.Union[
dict, mz.preprocessors.units.Vocabulary.TermIndex],
initializer=lambda: np.random.uniform(-0.2, 0.2)
) -> np.ndarray:
"""
Build a matrix using `term_index`.
:param term_index: A `dict` or `TermIndex` to build with.
:param initializer: A callable that returns a default value for missing
terms in data. (default: a random uniform distribution in range)
`(-0.2, 0.2)`).
:return: A matrix.
"""
input_dim = len(term_index)
matrix = np.empty((input_dim, self.output_dim))
for index in np.ndindex(*matrix.shape):
matrix[index] = initializer()
valid_keys = set(self._data.index)
for term, index in term_index.items():
if term in valid_keys:
matrix[index] = self._data.loc[term]
return matrix
def load_from_file(file_path: str, mode: str = 'word2vec') -> Embedding:
"""
Load embedding from `file_path`.
:param file_path: Path to file.
:param mode: Embedding file format mode, one of 'word2vec' or 'glove'.
(default: 'word2vec')
:return: An :class:`matchzoo.embedding.Embedding` instance.
"""
if mode == 'word2vec':
data = pd.read_csv(file_path,
sep=" ",
index_col=0,
header=None,
skiprows=1)
elif mode == 'glove':
data = pd.read_csv(file_path,
sep=" ",
index_col=0,
header=None,
quoting=csv.QUOTE_NONE)
else:
raise TypeError(f"{mode} is not a supported embedding type."
f"`word2vec` or `glove` expected.")
return Embedding(data)
|
import diamond.collector
class PingCollector(diamond.collector.ProcessCollector):
def get_default_config_help(self):
config_help = super(PingCollector, self).get_default_config_help()
config_help.update({
'bin': 'The path to the ping binary',
})
return config_help
def get_default_config(self):
"""
Returns the default collector settings
"""
config = super(PingCollector, self).get_default_config()
config.update({
'path': 'ping',
'bin': '/bin/ping',
})
return config
def collect(self):
for key in self.config.keys():
if key[:7] == "target_":
host = self.config[key]
metric_name = host.replace('.', '_')
ping = self.run_command(['-nq', '-c 1', host])
ping = ping[0].strip().split("\n")[-1]
# Linux
if ping.startswith('rtt'):
ping = ping.split()[3].split('/')[0]
metric_value = float(ping)
# OS X
elif ping.startswith('round-trip '):
ping = ping.split()[3].split('/')[0]
metric_value = float(ping)
# Unknown
else:
metric_value = 10000
self.publish(metric_name, metric_value, precision=3)
|
import os
import unittest
from perfkitbenchmarker import sample
from perfkitbenchmarker import test_util
from perfkitbenchmarker.windows_packages import diskspd
class DiskspdBenchmarkTestCase(unittest.TestCase, test_util.SamplesTestMixin):
def getDataContents(self, file_name):
path = os.path.join(os.path.dirname(__file__), '..', 'data', file_name)
with open(path) as fp:
contents = fp.read()
return contents
def setUp(self):
self.result_xml = self.getDataContents('diskspd_result.xml')
def testDiskSpdParsing(self):
single_sample = diskspd.ParseDiskSpdResults(self.result_xml, {},
'ReadSpeed')
expected_metadata = {'DisableAffinity': 'false',
'MaxFileSize': '0',
'BlockSize': '65536',
'IdlePercent': '96.80',
'CompletionRoutines': 'false',
'StrideSize': '65536',
'RandomAccess': 'false',
'Weight': '1',
'UserPercent': '0.25',
'WriteBytes': 0,
'Warmup': '5',
'Pattern': 'sequential',
'IOPriority': '3',
'ThreadsPerFile': '4',
'KernelPercent': '2.95',
'ReadIops': 3030,
'BytesCount': 5961809920,
'InterlockedSequential': 'false',
'MeasureLatency': 'false',
'WriteRatio': '0',
'FileSize': '838860800',
'BaseFileOffset': '0',
'Cooldown': '0',
'IOCount': 90970,
'UseLargePages': 'false',
'UsagePercent': '3.20',
'SequentialScan': 'true',
'TotalIops': 3030,
'WriteSpeed': 0,
'ProcCount': '4',
'WriteCount': 0,
'ReadSpeed': 189,
'TestTimeSeconds': '30.02',
'ThreadCount': '4',
'ReadBytes': 5961809920,
'TemporaryFile': 'false',
'ReadCount': 90970,
'Duration': '30',
'ThreadStride': '0',
'TotalSpeed': 189,
'RandSeed': '0',
'RequestCount': '0',
'Path': 'C:\\scratch\\testfile.dat',
'WriteThrough': 'true',
'CalculateIopsStdDev': 'false',
'IoBucketDuration': '1000',
'ParallelAsyncIO': 'false',
'Throughput': '0',
'DisableOSCache': 'true',
'WriteIops': 0}
sample_list = [
sample.Sample('ReadSpeed', 189, 'MB/s',
expected_metadata)
]
self.assertSampleListsEqualUpToTimestamp([single_sample], sample_list)
if __name__ == '__main__':
unittest.main()
|
import os
from babelfish import Language, language_converters
import pytest
from vcr import VCR
from subliminal.providers.shooter import ShooterSubtitle, ShooterProvider
vcr = VCR(path_transformer=lambda path: path + '.yaml',
record_mode=os.environ.get('VCR_RECORD_MODE', 'once'),
match_on=['method', 'scheme', 'host', 'port', 'path', 'body'],
cassette_library_dir=os.path.realpath(os.path.join('tests', 'cassettes', 'shooter')))
def test_get_matches_movie_hash(movies):
subtitle = ShooterSubtitle(Language('zho'), '314f454ab464775498ae6f1f5ad813a9;fdaa8b702d8936feba2122e93ba5c44f;'
'0a6935e3436aa7db5597ef67a2c494e3;4d269733f36ddd49f71e92732a462fe5', None)
matches = subtitle.get_matches(movies['man_of_steel'])
assert matches == {'hash'}
@pytest.mark.converter
def test_converter_convert_alpha3():
assert language_converters['shooter'].convert('zho') == 'chn'
@pytest.mark.converter
def test_converter_reverse():
assert language_converters['shooter'].reverse('chn') == ('zho',)
@pytest.mark.integration
@vcr.use_cassette
def test_query_movie(movies):
language = Language('zho')
video = movies['man_of_steel']
with ShooterProvider() as provider:
subtitles = provider.query(language, video.name, video.hashes['shooter'])
assert len(subtitles) == 3
@pytest.mark.integration
@vcr.use_cassette
def test_query_movie_no_hash(movies):
language = Language('zho')
video = movies['enders_game']
with ShooterProvider() as provider:
subtitles = provider.query(language, video.name)
assert len(subtitles) == 0
@pytest.mark.integration
@vcr.use_cassette
def test_query_episode(episodes):
video = episodes['bbt_s07e05']
language = Language('zho')
with ShooterProvider() as provider:
subtitles = provider.query(language, video.name, video.hashes['shooter'])
assert len(subtitles) == 3
@pytest.mark.integration
@vcr.use_cassette
def test_query_episode_no_hash(episodes):
video = episodes['dallas_2012_s01e03']
language = Language('zho')
with ShooterProvider() as provider:
subtitles = provider.query(language, video.name)
assert len(subtitles) == 1
@pytest.mark.integration
@vcr.use_cassette
def test_list_subtitles(movies):
video = movies['man_of_steel']
languages = {Language('eng'), Language('zho')}
with ShooterProvider() as provider:
subtitles = provider.list_subtitles(video, languages)
assert len(subtitles) == 6
assert {subtitle.language for subtitle in subtitles} == languages
@pytest.mark.integration
@vcr.use_cassette
def test_download_subtitle(movies):
video = movies['man_of_steel']
languages = {Language('eng'), Language('zho')}
with ShooterProvider() as provider:
subtitles = provider.list_subtitles(video, languages)
provider.download_subtitle(subtitles[0])
assert subtitles[0].content is not None
|
import gc
import sys
import time
import asyncio
from flexx.event import loop
from flexx import app
from flexx.event.both_tester import FakeStream, smart_compare
async def roundtrip(*sessions):
""" Coroutine to await a roundtrip to all given sessions.
"""
ok = []
def up():
ok.append(1)
for session in sessions:
session.call_after_roundtrip(up)
# timeout = time.time() + 5.0
while len(ok) < len(sessions):
await asyncio.sleep(0.02)
loop.iter()
def launch(cls, *args, **kwargs):
""" Shorthand for app.launch() that also returns session.
"""
# from flexx import app
c = app.App(cls, *args, **kwargs).launch('firefox-app')
return c, c.session
def filter_stdout(text):
py_lines = []
js_lines = []
for line in text.strip().splitlines():
if 'JS: ' in line:
js_lines.append(line.split('JS: ', 1)[1])
elif not line.startswith(('[I', '[D')):
py_lines.append(line)
return '\n'.join(py_lines), '\n'.join(js_lines)
def run_live(func):
""" Decorator to run a live test.
"""
def runner():
# Run with a fresh server and loop
loop.reset()
#asyncio_loop = asyncio.get_event_loop()
asyncio_loop = asyncio.new_event_loop()
app.create_server(port=0, loop=asyncio_loop)
print('running', func.__name__, '...', end='')
orig_stdout = sys.stdout
orig_stderr = sys.stderr
fake_stdout = FakeStream()
sys.stdout = sys.stderr = fake_stdout
t0 = time.time()
try:
# Call function - it could be a co-routine
cr = func()
if asyncio.iscoroutine(cr):
asyncio_loop.run_until_complete(cr)
gc.collect()
finally:
sys.stdout = orig_stdout
sys.stderr = orig_stderr
# Clean up / shut down
print('done in %f seconds' % (time.time()-t0))
for appname in app.manager.get_app_names():
if 'default' not in appname:
sessions = app.manager.get_connections(appname)
for session in sessions:
if session.app is not None:
session.app.dispose()
session.close()
loop.reset()
# Get reference text
pyresult, jsresult = filter_stdout(fake_stdout.getvalue())
reference = '\n'.join(line[4:] for line in func.__doc__.splitlines())
parts = reference.split('-'*10)
pyref = parts[0].strip(' \n')
jsref = parts[-1].strip(' \n-')
# Compare
smart_compare(func, ('Python', pyresult, pyref),
('JavaScript', jsresult, jsref))
return runner
|
import bz2
import hashlib
import logging
import struct
import sys
import zlib
from io import BytesIO
logger = logging.getLogger(__name__)
VERSION = 2, 2, 1
__version__ = '.'.join(str(i) for i in VERSION)
# %% The encoder and decoder implementation
# Shorthands
spack = struct.pack
strunpack = struct.unpack
def lencode(x):
""" Encode an unsigned integer into a variable sized blob of bytes.
"""
# We could support 16 bit and 32 bit as well, but the gain is low, since
# 9 bytes for collections with over 250 elements is marginal anyway.
if x <= 250:
return spack('<B', x)
else:
return spack('<BQ', 253, x)
# Include len decoder for completeness; we've inlined it for performance.
def lendecode(f):
""" Decode an unsigned integer from a file.
"""
n = strunpack('<B', f.read(1))[0]
if n == 253: n = strunpack('<Q', f.read(8))[0] # noqa
return n
def encode_type_id(b, ext_id):
""" Encode the type identifier, with or without extension id.
"""
if ext_id is not None:
bb = ext_id.encode('UTF-8')
return b.upper() + lencode(len(bb)) + bb # noqa
else:
return b # noqa
class BsdfLiteSerializer(object):
""" Instances of this class represent a BSDF encoder/decoder.
This is a lite variant of the Python BSDF serializer. It does not support
lazy loading or streaming, but is otherwise fully functional, including
support for custom extensions.
It acts as a placeholder for a set of extensions and encoding/decoding
options. Options for encoding:
* compression (int or str): ``0`` or "no" for no compression (default),
``1`` or "zlib" for Zlib compression (same as zip files and PNG), and
``2`` or "bz2" for Bz2 compression (more compact but slower writing).
Note that some BSDF implementations (e.g. JavaScript) may not support
compression.
* use_checksum (bool): whether to include a checksum with binary blobs.
* float64 (bool): Whether to write floats as 64 bit (default) or 32 bit.
"""
def __init__(self, extensions=None, **options):
self._extensions = {} # name -> extension
self._extensions_by_cls = {} # cls -> (name, extension.encode)
if extensions is None:
extensions = standard_extensions
for extension in extensions:
self.add_extension(extension)
self._parse_options(**options)
def _parse_options(self, compression=0, use_checksum=False, float64=True):
# Validate compression
if isinstance(compression, str):
m = {'no': 0, 'zlib': 1, 'bz2': 2}
compression = m.get(compression.lower(), compression)
if compression not in (0, 1, 2):
raise TypeError('Compression must be 0, 1, 2, '
'"no", "zlib", or "bz2"')
self._compression = compression
# Other encoding args
self._use_checksum = bool(use_checksum)
self._float64 = bool(float64)
def add_extension(self, extension_class):
""" Add an extension to this serializer instance, which must be
a subclass of Extension. Can be used as a decorator.
"""
# Check class
if not (isinstance(extension_class, type) and
issubclass(extension_class, Extension)):
raise TypeError('add_extension() expects a Extension class.')
extension = extension_class()
# Get name
name = extension.name
if not isinstance(name, str):
raise TypeError('Extension name must be str.')
if len(name) == 0 or len(name) > 250:
raise NameError('Extension names must be nonempty and shorter '
'than 251 chars.')
if name in self._extensions:
logger.warning('BSDF warning: overwriting extension "%s", '
'consider removing first' % name)
# Get classes
cls = extension.cls
if not cls:
clss = []
elif isinstance(cls, (tuple, list)):
clss = cls
else:
clss = [cls]
for cls in clss:
if not isinstance(cls, type):
raise TypeError('Extension classes must be types.')
# Store
for cls in clss:
self._extensions_by_cls[cls] = name, extension.encode
self._extensions[name] = extension
return extension_class
def remove_extension(self, name):
""" Remove a converted by its unique name.
"""
if not isinstance(name, str):
raise TypeError('Extension name must be str.')
if name in self._extensions:
self._extensions.pop(name)
for cls in list(self._extensions_by_cls.keys()):
if self._extensions_by_cls[cls][0] == name:
self._extensions_by_cls.pop(cls)
def _encode(self, f, value, ext_id):
""" Main encoder function.
"""
x = encode_type_id
if value is None:
f.write(x(b'v', ext_id)) # V for void
elif value is True:
f.write(x(b'y', ext_id)) # Y for yes
elif value is False:
f.write(x(b'n', ext_id)) # N for no
elif isinstance(value, int):
if -32768 <= value <= 32767:
f.write(x(b'h', ext_id) + spack('h', value)) # H for ...
else:
f.write(x(b'i', ext_id) + spack('<q', value)) # I for int
elif isinstance(value, float):
if self._float64:
f.write(x(b'd', ext_id) + spack('<d', value)) # D for double
else:
f.write(x(b'f', ext_id) + spack('<f', value)) # f for float
elif isinstance(value, str):
bb = value.encode('UTF-8')
f.write(x(b's', ext_id) + lencode(len(bb))) # S for str
f.write(bb)
elif isinstance(value, (list, tuple)):
f.write(x(b'l', ext_id) + lencode(len(value))) # L for list
for v in value:
self._encode(f, v, None)
elif isinstance(value, dict):
f.write(x(b'm', ext_id) + lencode(len(value))) # M for mapping
for key, v in value.items():
assert isinstance(key, str)
name_b = key.encode('UTF-8')
f.write(lencode(len(name_b)))
f.write(name_b)
self._encode(f, v, None)
elif isinstance(value, bytes):
f.write(x(b'b', ext_id)) # B for blob
# Compress
compression = self._compression
if compression == 0:
compressed = value
elif compression == 1:
compressed = zlib.compress(value, 9)
elif compression == 2:
compressed = bz2.compress(value, 9)
else:
assert False, 'Unknown compression identifier'
# Get sizes
data_size = len(value)
used_size = len(compressed)
extra_size = 0
allocated_size = used_size + extra_size
# Write sizes - write at least in a size that allows resizing
if allocated_size <= 250 and compression == 0:
f.write(spack('<B', allocated_size))
f.write(spack('<B', used_size))
f.write(lencode(data_size))
else:
f.write(spack('<BQ', 253, allocated_size))
f.write(spack('<BQ', 253, used_size))
f.write(spack('<BQ', 253, data_size))
# Compression and checksum
f.write(spack('B', compression))
if self._use_checksum:
f.write(b'\xff' + hashlib.md5(compressed).digest())
else:
f.write(b'\x00')
# Byte alignment (only necessary for uncompressed data)
if compression == 0:
alignment = 8 - (f.tell() + 1) % 8 # +1 for the byte to write
f.write(spack('<B', alignment)) # padding for byte alignment
f.write(b'\x00' * alignment)
else:
f.write(spack('<B', 0))
# The actual data and extra space
f.write(compressed)
f.write(b'\x00' * (allocated_size - used_size))
elif getattr(value, "shape", None) == () and str(
getattr(value, "dtype", "")
).startswith(("uint", "int", "float")):
# Implicit conversion of numpy scalars
if 'int' in str(value.dtype):
value = int(value)
if -32768 <= value <= 32767:
f.write(x(b'h', ext_id) + spack('h', value))
else:
f.write(x(b'i', ext_id) + spack('<q', value))
else:
value = float(value)
if self._float64:
f.write(x(b'd', ext_id) + spack('<d', value))
else:
f.write(x(b'f', ext_id) + spack('<f', value))
else:
if ext_id is not None:
raise ValueError(
'Extension %s wronfully encodes object to another '
'extension object (though it may encode to a list/dict '
'that contains other extension objects).' % ext_id)
# Try if the value is of a type we know
ex = self._extensions_by_cls.get(value.__class__, None)
# Maybe its a subclass of a type we know
if ex is None:
for name, c in self._extensions.items():
if c.match(self, value):
ex = name, c.encode
break
else:
ex = None
# Success or fail
if ex is not None:
ext_id2, extension_encode = ex
self._encode(f, extension_encode(self, value), ext_id2)
else:
t = ('Class %r is not a valid base BSDF type, nor is it '
'handled by an extension.')
raise TypeError(t % value.__class__.__name__)
def _decode(self, f):
""" Main decoder function.
"""
# Get value
char = f.read(1)
c = char.lower()
# Conversion (uppercase value identifiers signify converted values)
if not char:
raise EOFError()
elif char != c:
n = strunpack('<B', f.read(1))[0]
# if n == 253: n = strunpack('<Q', f.read(8))[0] # noqa - noneed
ext_id = f.read(n).decode('UTF-8')
else:
ext_id = None
if c == b'v':
value = None
elif c == b'y':
value = True
elif c == b'n':
value = False
elif c == b'h':
value = strunpack('<h', f.read(2))[0]
elif c == b'i':
value = strunpack('<q', f.read(8))[0]
elif c == b'f':
value = strunpack('<f', f.read(4))[0]
elif c == b'd':
value = strunpack('<d', f.read(8))[0]
elif c == b's':
n_s = strunpack('<B', f.read(1))[0]
if n_s == 253: n_s = strunpack('<Q', f.read(8))[0] # noqa
value = f.read(n_s).decode('UTF-8')
elif c == b'l':
n = strunpack('<B', f.read(1))[0]
if n >= 254:
# Streaming
closed = n == 254
n = strunpack('<Q', f.read(8))[0]
if closed:
value = [self._decode(f) for i in range(n)]
else:
value = []
try:
while True:
value.append(self._decode(f))
except EOFError:
pass
else:
# Normal
if n == 253: n = strunpack('<Q', f.read(8))[0] # noqa
value = [self._decode(f) for i in range(n)]
elif c == b'm':
value = dict()
n = strunpack('<B', f.read(1))[0]
if n == 253: n = strunpack('<Q', f.read(8))[0] # noqa
for i in range(n):
n_name = strunpack('<B', f.read(1))[0]
if n_name == 253: n_name = strunpack('<Q', f.read(8))[0] # noqa
assert n_name > 0
name = f.read(n_name).decode('UTF-8')
value[name] = self._decode(f)
elif c == b'b':
# Read blob header data (5 to 42 bytes)
# Size
allocated_size = strunpack('<B', f.read(1))[0]
if allocated_size == 253: allocated_size = strunpack('<Q', f.read(8))[0] # noqa
used_size = strunpack('<B', f.read(1))[0]
if used_size == 253: used_size = strunpack('<Q', f.read(8))[0] # noqa
data_size = strunpack('<B', f.read(1))[0]
if data_size == 253: data_size = strunpack('<Q', f.read(8))[0] # noqa
# Compression and checksum
compression = strunpack('<B', f.read(1))[0]
has_checksum = strunpack('<B', f.read(1))[0]
if has_checksum:
checksum = f.read(16) # noqa - not used yet
# Skip alignment
alignment = strunpack('<B', f.read(1))[0]
f.read(alignment)
# Get data
compressed = f.read(used_size)
# Skip remaining space
f.read(allocated_size - used_size)
# Decompress
if compression == 0:
value = compressed
elif compression == 1:
value = zlib.decompress(compressed)
elif compression == 2:
value = bz2.decompress(compressed)
else:
raise RuntimeError('Invalid compression %i' % compression)
else:
raise RuntimeError('Parse error %r' % char)
# Convert value if we have a nextension for it
if ext_id is not None:
extension = self._extensions.get(ext_id, None)
if extension is not None:
value = extension.decode(self, value)
else:
logger.warning('BSDF warning: no extension found for %r' % ext_id)
return value
def encode(self, ob):
""" Save the given object to bytes.
"""
f = BytesIO()
self.save(f, ob)
return f.getvalue()
def save(self, f, ob):
""" Write the given object to the given file object.
"""
f.write(b'BSDF')
f.write(struct.pack('<B', VERSION[0]))
f.write(struct.pack('<B', VERSION[1]))
self._encode(f, ob, None)
def decode(self, bb):
""" Load the data structure that is BSDF-encoded in the given bytes.
"""
f = BytesIO(bb)
return self.load(f)
def load(self, f):
""" Load a BSDF-encoded object from the given file object.
"""
# Check magic string
if f.read(4) != b'BSDF':
raise RuntimeError('This does not look a BSDF file.')
# Check version
major_version = strunpack('<B', f.read(1))[0]
minor_version = strunpack('<B', f.read(1))[0]
file_version = '%i.%i' % (major_version, minor_version)
if major_version != VERSION[0]: # major version should be 2
t = ('Reading file with different major version (%s) '
'from the implementation (%s).')
raise RuntimeError(t % (file_version, __version__))
if minor_version > VERSION[1]: # minor should be < ours
t = ('BSDF warning: reading file with higher minor version (%s) '
'than the implementation (%s).')
logger.warning(t % (file_version, __version__))
return self._decode(f)
# %% Standard extensions
# Defining extensions as a dict would be more compact and feel lighter, but
# that would only allow lambdas, which is too limiting, e.g. for ndarray
# extension.
class Extension(object):
""" Base class to implement BSDF extensions for special data types.
Extension classes are provided to the BSDF serializer, which
instantiates the class. That way, the extension can be somewhat dynamic:
e.g. the NDArrayExtension exposes the ndarray class only when numpy
is imported.
A extension instance must have two attributes. These can be attribiutes of
the class, or of the instance set in ``__init__()``:
* name (str): the name by which encoded values will be identified.
* cls (type): the type (or list of types) to match values with.
This is optional, but it makes the encoder select extensions faster.
Further, it needs 3 methods:
* `match(serializer, value) -> bool`: return whether the extension can
convert the given value. The default is ``isinstance(value, self.cls)``.
* `encode(serializer, value) -> encoded_value`: the function to encode a
value to more basic data types.
* `decode(serializer, encoded_value) -> value`: the function to decode an
encoded value back to its intended representation.
"""
name = ''
cls = ()
def __repr__(self):
return '<BSDF extension %r at 0x%s>' % (self.name, hex(id(self)))
def match(self, s, v):
return isinstance(v, self.cls)
def encode(self, s, v):
raise NotImplementedError()
def decode(self, s, v):
raise NotImplementedError()
class ComplexExtension(Extension):
name = 'c'
cls = complex
def encode(self, s, v):
return (v.real, v.imag)
def decode(self, s, v):
return complex(v[0], v[1])
class NDArrayExtension(Extension):
name = 'ndarray'
def __init__(self):
if 'numpy' in sys.modules:
import numpy as np
self.cls = np.ndarray
def match(self, s, v): # e.g. for nd arrays in JS
return (hasattr(v, 'shape') and
hasattr(v, 'dtype') and
hasattr(v, 'tobytes'))
def encode(self, s, v):
return dict(shape=v.shape,
dtype=str(v.dtype),
data=v.tobytes())
def decode(self, s, v):
try:
import numpy as np
except ImportError:
return v
a = np.frombuffer(v['data'], dtype=v['dtype'])
a.shape = v['shape']
return a
standard_extensions = [ComplexExtension, NDArrayExtension]
|
import re
try: # pragma: no cover
from collections import OrderedDict as _dict
except ImportError:
_dict = dict
def isidentifier(s):
# http://stackoverflow.com/questions/2544972/
if not isinstance(s, str):
return False
return re.match(r'^\w+$', s, re.UNICODE) and re.match(r'^[0-9]', s) is None
class Dict(_dict):
""" A dict in which the items can be get/set as attributes.
This provides a lean way to represent structured data, and works
well in combination with autocompletion. Keys can be anything that
are otherwise valid keys, but keys that are not valid identifiers
or that are methods of the dict class (e.g. 'items' or 'copy')
can only be get/set in the classic way.
Example:
.. code-block:: python
>> d = Dict(foo=3)
>> d.foo
3
>> d['foo'] = 4
>> d.foo
4
>> d.bar = 5
>> d.bar
5
"""
__reserved_names__ = dir(_dict()) # Also from OrderedDict
__pure_names__ = dir(dict())
__slots__ = []
def __repr__(self):
identifier_items = []
nonidentifier_items = []
for key, val in self.items():
if isidentifier(key):
identifier_items.append('%s=%r' % (key, val))
else:
nonidentifier_items.append('(%r, %r)' % (key, val))
if nonidentifier_items:
return 'Dict([%s], %s)' % (', '.join(nonidentifier_items),
', '.join(identifier_items))
else:
return 'Dict(%s)' % (', '.join(identifier_items))
def __getattribute__(self, key):
try:
return object.__getattribute__(self, key)
except AttributeError:
if key in self:
return self[key]
else:
raise
def __setattr__(self, key, val):
if key in Dict.__reserved_names__:
# Either let OrderedDict do its work, or disallow
if key not in Dict.__pure_names__: # pragma: no cover
return _dict.__setattr__(self, key, val)
else:
raise AttributeError('Reserved name, this key can only ' +
'be set via ``d[%r] = X``' % key)
else:
# if isinstance(val, dict): val = Dict(val) -> no, makes a copy!
self[key] = val
def __dir__(self):
names = [k for k in self.keys() if isidentifier(k)]
return Dict.__reserved_names__ + names
|
from datetime import datetime
import json
import os
import coverage
from tests.coveragetest import UsingModulesMixin, CoverageTest
class JsonReportTest(UsingModulesMixin, CoverageTest):
"""Tests of the JSON reports from coverage.py."""
def _assert_expected_json_report(self, cov, expected_result):
"""
Helper for tests that handles the common ceremony so the tests can be clearly show the
consequences of setting various arguments.
"""
self.make_file("a.py", """\
a = {'b': 1}
if a.get('a'):
b = 1
""")
a = self.start_import_stop(cov, "a")
output_path = os.path.join(self.temp_dir, "a.json")
cov.json_report(a, outfile=output_path)
with open(output_path) as result_file:
parsed_result = json.load(result_file)
self.assert_recent_datetime(
datetime.strptime(parsed_result['meta']['timestamp'], "%Y-%m-%dT%H:%M:%S.%f")
)
del (parsed_result['meta']['timestamp'])
assert parsed_result == expected_result
def test_branch_coverage(self):
cov = coverage.Coverage(branch=True)
expected_result = {
'meta': {
"version": coverage.__version__,
"branch_coverage": True,
"show_contexts": False,
},
'files': {
'a.py': {
'executed_lines': [1, 2],
'missing_lines': [3],
'excluded_lines': [],
'summary': {
'missing_lines': 1,
'covered_lines': 2,
'num_statements': 3,
'num_branches': 2,
'excluded_lines': 0,
'num_partial_branches': 1,
'covered_branches': 1,
'missing_branches': 1,
'percent_covered': 60.0,
}
}
},
'totals': {
'missing_lines': 1,
'covered_lines': 2,
'num_statements': 3,
'num_branches': 2,
'excluded_lines': 0,
'num_partial_branches': 1,
'percent_covered': 60.0,
'covered_branches': 1,
'missing_branches': 1,
}
}
self._assert_expected_json_report(cov, expected_result)
def test_simple_line_coverage(self):
cov = coverage.Coverage()
expected_result = {
'meta': {
"version": coverage.__version__,
"branch_coverage": False,
"show_contexts": False,
},
'files': {
'a.py': {
'executed_lines': [1, 2],
'missing_lines': [3],
'excluded_lines': [],
'summary': {
'excluded_lines': 0,
'missing_lines': 1,
'covered_lines': 2,
'num_statements': 3,
'percent_covered': 66.66666666666667
}
}
},
'totals': {
'excluded_lines': 0,
'missing_lines': 1,
'covered_lines': 2,
'num_statements': 3,
'percent_covered': 66.66666666666667
}
}
self._assert_expected_json_report(cov, expected_result)
def run_context_test(self, relative_files):
"""A helper for two tests below."""
self.make_file("config", """\
[run]
relative_files = {}
[json]
show_contexts = True
""".format(relative_files))
cov = coverage.Coverage(context="cool_test", config_file="config")
expected_result = {
'meta': {
"version": coverage.__version__,
"branch_coverage": False,
"show_contexts": True,
},
'files': {
'a.py': {
'executed_lines': [1, 2],
'missing_lines': [3],
'excluded_lines': [],
"contexts": {
"1": [
"cool_test"
],
"2": [
"cool_test"
]
},
'summary': {
'excluded_lines': 0,
'missing_lines': 1,
'covered_lines': 2,
'num_statements': 3,
'percent_covered': 66.66666666666667
}
}
},
'totals': {
'excluded_lines': 0,
'missing_lines': 1,
'covered_lines': 2,
'num_statements': 3,
'percent_covered': 66.66666666666667
}
}
self._assert_expected_json_report(cov, expected_result)
def test_context_non_relative(self):
self.run_context_test(relative_files=False)
def test_context_relative(self):
self.run_context_test(relative_files=True)
|
import asyncio
from datetime import timedelta
import logging
from pyControl4.error_handling import C4Exception
from pyControl4.light import C4Light
from homeassistant.components.light import (
ATTR_BRIGHTNESS,
ATTR_TRANSITION,
SUPPORT_BRIGHTNESS,
SUPPORT_TRANSITION,
LightEntity,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.const import CONF_SCAN_INTERVAL
from homeassistant.core import HomeAssistant
from homeassistant.helpers.update_coordinator import DataUpdateCoordinator, UpdateFailed
from . import Control4Entity, get_items_of_category
from .const import CONF_DIRECTOR, CONTROL4_ENTITY_TYPE, DOMAIN
from .director_utils import director_update_data
_LOGGER = logging.getLogger(__name__)
CONTROL4_CATEGORY = "lights"
CONTROL4_NON_DIMMER_VAR = "LIGHT_STATE"
CONTROL4_DIMMER_VAR = "LIGHT_LEVEL"
async def async_setup_entry(
hass: HomeAssistant, entry: ConfigEntry, async_add_entities
):
"""Set up Control4 lights from a config entry."""
entry_data = hass.data[DOMAIN][entry.entry_id]
scan_interval = entry_data[CONF_SCAN_INTERVAL]
_LOGGER.debug(
"Scan interval = %s",
scan_interval,
)
async def async_update_data_non_dimmer():
"""Fetch data from Control4 director for non-dimmer lights."""
try:
return await director_update_data(hass, entry, CONTROL4_NON_DIMMER_VAR)
except C4Exception as err:
raise UpdateFailed(f"Error communicating with API: {err}") from err
async def async_update_data_dimmer():
"""Fetch data from Control4 director for dimmer lights."""
try:
return await director_update_data(hass, entry, CONTROL4_DIMMER_VAR)
except C4Exception as err:
raise UpdateFailed(f"Error communicating with API: {err}") from err
non_dimmer_coordinator = DataUpdateCoordinator(
hass,
_LOGGER,
name="light",
update_method=async_update_data_non_dimmer,
update_interval=timedelta(seconds=scan_interval),
)
dimmer_coordinator = DataUpdateCoordinator(
hass,
_LOGGER,
name="light",
update_method=async_update_data_dimmer,
update_interval=timedelta(seconds=scan_interval),
)
# Fetch initial data so we have data when entities subscribe
await non_dimmer_coordinator.async_refresh()
await dimmer_coordinator.async_refresh()
items_of_category = await get_items_of_category(hass, entry, CONTROL4_CATEGORY)
entity_list = []
for item in items_of_category:
try:
if item["type"] == CONTROL4_ENTITY_TYPE:
item_name = item["name"]
item_id = item["id"]
item_parent_id = item["parentId"]
item_manufacturer = None
item_device_name = None
item_model = None
for parent_item in items_of_category:
if parent_item["id"] == item_parent_id:
item_manufacturer = parent_item["manufacturer"]
item_device_name = parent_item["name"]
item_model = parent_item["model"]
else:
continue
except KeyError:
_LOGGER.exception(
"Unknown device properties received from Control4: %s",
item,
)
continue
if item_id in dimmer_coordinator.data:
item_is_dimmer = True
item_coordinator = dimmer_coordinator
elif item_id in non_dimmer_coordinator.data:
item_is_dimmer = False
item_coordinator = non_dimmer_coordinator
else:
director = entry_data[CONF_DIRECTOR]
item_variables = await director.getItemVariables(item_id)
_LOGGER.warning(
"Couldn't get light state data for %s, skipping setup. Available variables from Control4: %s",
item_name,
item_variables,
)
continue
entity_list.append(
Control4Light(
entry_data,
entry,
item_coordinator,
item_name,
item_id,
item_device_name,
item_manufacturer,
item_model,
item_parent_id,
item_is_dimmer,
)
)
async_add_entities(entity_list, True)
class Control4Light(Control4Entity, LightEntity):
"""Control4 light entity."""
def __init__(
self,
entry_data: dict,
entry: ConfigEntry,
coordinator: DataUpdateCoordinator,
name: str,
idx: int,
device_name: str,
device_manufacturer: str,
device_model: str,
device_id: int,
is_dimmer: bool,
):
"""Initialize Control4 light entity."""
super().__init__(
entry_data,
entry,
coordinator,
name,
idx,
device_name,
device_manufacturer,
device_model,
device_id,
)
self._is_dimmer = is_dimmer
def create_api_object(self):
"""Create a pyControl4 device object.
This exists so the director token used is always the latest one, without needing to re-init the entire entity.
"""
return C4Light(self.entry_data[CONF_DIRECTOR], self._idx)
@property
def is_on(self):
"""Return whether this light is on or off."""
return self.coordinator.data[self._idx]["value"] > 0
@property
def brightness(self):
"""Return the brightness of this light between 0..255."""
if self._is_dimmer:
return round(self.coordinator.data[self._idx]["value"] * 2.55)
return None
@property
def supported_features(self) -> int:
"""Flag supported features."""
flags = 0
if self._is_dimmer:
flags |= SUPPORT_BRIGHTNESS | SUPPORT_TRANSITION
return flags
async def async_turn_on(self, **kwargs) -> None:
"""Turn the entity on."""
c4_light = self.create_api_object()
if self._is_dimmer:
if ATTR_TRANSITION in kwargs:
transition_length = kwargs[ATTR_TRANSITION] * 1000
else:
transition_length = 0
if ATTR_BRIGHTNESS in kwargs:
brightness = (kwargs[ATTR_BRIGHTNESS] / 255) * 100
else:
brightness = 100
await c4_light.rampToLevel(brightness, transition_length)
else:
transition_length = 0
await c4_light.setLevel(100)
if transition_length == 0:
transition_length = 1000
delay_time = (transition_length / 1000) + 0.7
_LOGGER.debug("Delaying light update by %s seconds", delay_time)
await asyncio.sleep(delay_time)
await self.coordinator.async_request_refresh()
async def async_turn_off(self, **kwargs) -> None:
"""Turn the entity off."""
c4_light = self.create_api_object()
if self._is_dimmer:
if ATTR_TRANSITION in kwargs:
transition_length = kwargs[ATTR_TRANSITION] * 1000
else:
transition_length = 0
await c4_light.rampToLevel(0, transition_length)
else:
transition_length = 0
await c4_light.setLevel(0)
if transition_length == 0:
transition_length = 1500
delay_time = (transition_length / 1000) + 0.7
_LOGGER.debug("Delaying light update by %s seconds", delay_time)
await asyncio.sleep(delay_time)
await self.coordinator.async_request_refresh()
|
import asyncio
from itertools import product
import logging
from homeassistant.const import ATTR_ENTITY_ID, __version__
from homeassistant.util.decorator import Registry
from .const import (
ERR_DEVICE_OFFLINE,
ERR_PROTOCOL_ERROR,
ERR_UNKNOWN_ERROR,
EVENT_COMMAND_RECEIVED,
EVENT_QUERY_RECEIVED,
EVENT_SYNC_RECEIVED,
)
from .error import SmartHomeError
from .helpers import GoogleEntity, RequestData, async_get_entities
HANDLERS = Registry()
_LOGGER = logging.getLogger(__name__)
async def async_handle_message(hass, config, user_id, message, source):
"""Handle incoming API messages."""
data = RequestData(
config, user_id, source, message["requestId"], message.get("devices")
)
response = await _process(hass, data, message)
if response and "errorCode" in response["payload"]:
_LOGGER.error("Error handling message %s: %s", message, response["payload"])
return response
async def _process(hass, data, message):
"""Process a message."""
inputs: list = message.get("inputs")
if len(inputs) != 1:
return {
"requestId": data.request_id,
"payload": {"errorCode": ERR_PROTOCOL_ERROR},
}
handler = HANDLERS.get(inputs[0].get("intent"))
if handler is None:
return {
"requestId": data.request_id,
"payload": {"errorCode": ERR_PROTOCOL_ERROR},
}
try:
result = await handler(hass, data, inputs[0].get("payload"))
except SmartHomeError as err:
return {"requestId": data.request_id, "payload": {"errorCode": err.code}}
except Exception: # pylint: disable=broad-except
_LOGGER.exception("Unexpected error")
return {
"requestId": data.request_id,
"payload": {"errorCode": ERR_UNKNOWN_ERROR},
}
if result is None:
return None
return {"requestId": data.request_id, "payload": result}
@HANDLERS.register("action.devices.SYNC")
async def async_devices_sync(hass, data, payload):
"""Handle action.devices.SYNC request.
https://developers.google.com/assistant/smarthome/develop/process-intents#SYNC
"""
hass.bus.async_fire(
EVENT_SYNC_RECEIVED,
{"request_id": data.request_id, "source": data.source},
context=data.context,
)
agent_user_id = data.config.get_agent_user_id(data.context)
entities = async_get_entities(hass, data.config)
results = await asyncio.gather(
*(
entity.sync_serialize(agent_user_id)
for entity in entities
if entity.should_expose()
),
return_exceptions=True,
)
devices = []
for entity, result in zip(entities, results):
if isinstance(result, Exception):
_LOGGER.error("Error serializing %s", entity.entity_id, exc_info=result)
else:
devices.append(result)
response = {"agentUserId": agent_user_id, "devices": devices}
await data.config.async_connect_agent_user(agent_user_id)
_LOGGER.debug("Syncing entities response: %s", response)
return response
@HANDLERS.register("action.devices.QUERY")
async def async_devices_query(hass, data, payload):
"""Handle action.devices.QUERY request.
https://developers.google.com/assistant/smarthome/develop/process-intents#QUERY
"""
devices = {}
for device in payload.get("devices", []):
devid = device["id"]
state = hass.states.get(devid)
hass.bus.async_fire(
EVENT_QUERY_RECEIVED,
{
"request_id": data.request_id,
ATTR_ENTITY_ID: devid,
"source": data.source,
},
context=data.context,
)
if not state:
# If we can't find a state, the device is offline
devices[devid] = {"online": False}
continue
entity = GoogleEntity(hass, data.config, state)
try:
devices[devid] = entity.query_serialize()
except Exception: # pylint: disable=broad-except
_LOGGER.exception("Unexpected error serializing query for %s", state)
devices[devid] = {"online": False}
return {"devices": devices}
async def _entity_execute(entity, data, executions):
"""Execute all commands for an entity.
Returns a dict if a special result needs to be set.
"""
for execution in executions:
try:
await entity.execute(data, execution)
except SmartHomeError as err:
return {
"ids": [entity.entity_id],
"status": "ERROR",
**err.to_response(),
}
return None
@HANDLERS.register("action.devices.EXECUTE")
async def handle_devices_execute(hass, data, payload):
"""Handle action.devices.EXECUTE request.
https://developers.google.com/assistant/smarthome/develop/process-intents#EXECUTE
"""
entities = {}
executions = {}
results = {}
for command in payload["commands"]:
for device, execution in product(command["devices"], command["execution"]):
entity_id = device["id"]
hass.bus.async_fire(
EVENT_COMMAND_RECEIVED,
{
"request_id": data.request_id,
ATTR_ENTITY_ID: entity_id,
"execution": execution,
"source": data.source,
},
context=data.context,
)
# Happens if error occurred. Skip entity for further processing
if entity_id in results:
continue
if entity_id in entities:
executions[entity_id].append(execution)
continue
state = hass.states.get(entity_id)
if state is None:
results[entity_id] = {
"ids": [entity_id],
"status": "ERROR",
"errorCode": ERR_DEVICE_OFFLINE,
}
continue
entities[entity_id] = GoogleEntity(hass, data.config, state)
executions[entity_id] = [execution]
execute_results = await asyncio.gather(
*[
_entity_execute(entities[entity_id], data, executions[entity_id])
for entity_id in executions
]
)
for entity_id, result in zip(executions, execute_results):
if result is not None:
results[entity_id] = result
final_results = list(results.values())
for entity in entities.values():
if entity.entity_id in results:
continue
entity.async_update()
final_results.append(
{
"ids": [entity.entity_id],
"status": "SUCCESS",
"states": entity.query_serialize(),
}
)
return {"commands": final_results}
@HANDLERS.register("action.devices.DISCONNECT")
async def async_devices_disconnect(hass, data: RequestData, payload):
"""Handle action.devices.DISCONNECT request.
https://developers.google.com/assistant/smarthome/develop/process-intents#DISCONNECT
"""
await data.config.async_disconnect_agent_user(data.context.user_id)
return None
@HANDLERS.register("action.devices.IDENTIFY")
async def async_devices_identify(hass, data: RequestData, payload):
"""Handle action.devices.IDENTIFY request.
https://developers.google.com/assistant/smarthome/develop/local#implement_the_identify_handler
"""
return {
"device": {
"id": data.config.get_agent_user_id(data.context),
"isLocalOnly": True,
"isProxy": True,
"deviceInfo": {
"hwVersion": "UNKNOWN_HW_VERSION",
"manufacturer": "Home Assistant",
"model": "Home Assistant",
"swVersion": __version__,
},
}
}
@HANDLERS.register("action.devices.REACHABLE_DEVICES")
async def async_devices_reachable(hass, data: RequestData, payload):
"""Handle action.devices.REACHABLE_DEVICES request.
https://developers.google.com/actions/smarthome/create#actiondevicesdisconnect
"""
google_ids = {dev["id"] for dev in (data.devices or [])}
return {
"devices": [
entity.reachable_device_serialize()
for entity in async_get_entities(hass, data.config)
if entity.entity_id in google_ids and entity.should_expose_local()
]
}
def turned_off_response(message):
"""Return a device turned off response."""
return {
"requestId": message.get("requestId"),
"payload": {"errorCode": "deviceTurnedOff"},
}
|
import json
import pytest
import homeassistant.components.sensor as sensor
from homeassistant.const import CONF_NAME
from homeassistant.setup import async_setup_component
import homeassistant.util.dt as dt_util
from tests.async_mock import AsyncMock, patch
from tests.common import assert_setup_component, load_fixture
REPLY = json.loads(load_fixture("yandex_transport_reply.json"))
@pytest.fixture
def mock_requester():
"""Create a mock for YandexMapsRequester."""
with patch("aioymaps.YandexMapsRequester") as requester:
instance = requester.return_value
instance.get_stop_info = AsyncMock(return_value=REPLY)
yield instance
STOP_ID = "stop__9639579"
ROUTES = ["194", "т36", "т47", "м10"]
NAME = "test_name"
TEST_CONFIG = {
"sensor": {
"platform": "yandex_transport",
"stop_id": "stop__9639579",
"routes": ROUTES,
"name": NAME,
}
}
FILTERED_ATTRS = {
"т36": ["18:25", "18:42", "18:46"],
"т47": ["18:35", "18:37", "18:40", "18:42"],
"м10": ["18:20", "18:27", "18:29", "18:41", "18:43"],
"stop_name": "7-й автобусный парк",
"attribution": "Data provided by maps.yandex.ru",
}
RESULT_STATE = dt_util.utc_from_timestamp(1583421540).isoformat(timespec="seconds")
async def assert_setup_sensor(hass, config, count=1):
"""Set up the sensor and assert it's been created."""
with assert_setup_component(count):
assert await async_setup_component(hass, sensor.DOMAIN, config)
await hass.async_block_till_done()
async def test_setup_platform_valid_config(hass, mock_requester):
"""Test that sensor is set up properly with valid config."""
await assert_setup_sensor(hass, TEST_CONFIG)
async def test_setup_platform_invalid_config(hass, mock_requester):
"""Check an invalid configuration."""
await assert_setup_sensor(
hass, {"sensor": {"platform": "yandex_transport", "stopid": 1234}}, count=0
)
async def test_name(hass, mock_requester):
"""Return the name if set in the configuration."""
await assert_setup_sensor(hass, TEST_CONFIG)
state = hass.states.get("sensor.test_name")
assert state.name == TEST_CONFIG["sensor"][CONF_NAME]
async def test_state(hass, mock_requester):
"""Return the contents of _state."""
await assert_setup_sensor(hass, TEST_CONFIG)
state = hass.states.get("sensor.test_name")
assert state.state == RESULT_STATE
async def test_filtered_attributes(hass, mock_requester):
"""Return the contents of attributes."""
await assert_setup_sensor(hass, TEST_CONFIG)
state = hass.states.get("sensor.test_name")
state_attrs = {key: state.attributes[key] for key in FILTERED_ATTRS}
assert state_attrs == FILTERED_ATTRS
|
import pytest
import numpy as np
import math
import os
import shutil
from tensorflow.keras import backend as K
from tensorflow.keras.models import Sequential, load_model # type: ignore
import tensorflow as tf
from tensornetwork.tn_keras.layers import DenseDecomp
from tensornetwork.tn_keras.layers import DenseMPO
from tensornetwork.tn_keras.layers import DenseCondenser
from tensornetwork.tn_keras.layers import DenseExpander
from tensornetwork.tn_keras.layers import DenseEntangler
from tensorflow.keras.layers import Dense # type: ignore
@pytest.fixture(params=[512])
def dummy_data(request):
np.random.seed(42)
# Generate dummy data for use in tests
data = np.random.randint(10, size=(1000, request.param))
labels = np.concatenate((np.ones((500, 1)), np.zeros((500, 1))), axis=0)
return data, labels
@pytest.fixture(params=[
'DenseDecomp', 'DenseMPO', 'DenseCondenser', 'DenseExpander',
'DenseEntangler', 'DenseEntanglerAsymmetric'
])
def make_model(dummy_data, request):
# Disable the redefined-outer-name violation in this function
# pylint: disable=redefined-outer-name
data, _ = dummy_data
if request.param == 'DenseMPO':
model = Sequential()
model.add(
DenseMPO(data.shape[1],
num_nodes=int(math.log(int(data.shape[1]), 8)),
bond_dim=8,
use_bias=True,
activation='relu',
input_shape=(data.shape[1],)))
model.add(Dense(1, activation='sigmoid'))
elif request.param == 'DenseDecomp':
model = Sequential()
model.add(
DenseDecomp(512,
decomp_size=128,
use_bias=True,
activation='relu',
input_shape=(data.shape[1],)))
model.add(Dense(1, activation='sigmoid'))
elif request.param == 'DenseCondenser':
model = Sequential()
model.add(
DenseCondenser(exp_base=2,
num_nodes=3,
use_bias=True,
activation='relu',
input_shape=(data.shape[1],)))
model.add(Dense(1, activation='sigmoid'))
elif request.param == 'DenseExpander':
model = Sequential()
model.add(
DenseExpander(exp_base=2,
num_nodes=3,
use_bias=True,
activation='relu',
input_shape=(data.shape[-1],)))
model.add(Dense(1, activation='sigmoid'))
elif request.param == 'DenseEntangler':
num_legs = 3
leg_dim = round(data.shape[-1]**(1. / num_legs))
assert leg_dim**num_legs == data.shape[-1]
model = Sequential()
model.add(
DenseEntangler(leg_dim**num_legs,
num_legs=num_legs,
num_levels=3,
use_bias=True,
activation='relu',
input_shape=(data.shape[1],)))
model.add(Dense(1, activation='sigmoid'))
elif request.param == 'DenseEntanglerAsymmetric':
num_legs = 3
leg_dim = round(data.shape[-1]**(1. / num_legs))
assert leg_dim**num_legs == data.shape[-1]
model = Sequential()
model.add(
DenseEntangler((leg_dim * 2)**num_legs,
num_legs=num_legs,
num_levels=3,
use_bias=True,
activation='relu',
input_shape=(data.shape[1],)))
model.add(Dense(1, activation='sigmoid'))
return model
def test_train(dummy_data, make_model):
# Disable the redefined-outer-name violation in this function
# pylint: disable=redefined-outer-name
tf.random.set_seed(0)
data, labels = dummy_data
model = make_model
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
# Train the model for 10 epochs
history = model.fit(data, labels, epochs=10, batch_size=32)
# Check that loss decreases and accuracy increases
assert history.history['loss'][0] > history.history['loss'][-1]
assert history.history['accuracy'][0] < history.history['accuracy'][-1]
def test_weights_change(dummy_data, make_model):
# Disable the redefined-outer-name violation in this function
# pylint: disable=redefined-outer-name
tf.random.set_seed(0)
data, labels = dummy_data
model = make_model
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
before = model.get_weights()
model.fit(data, labels, epochs=5, batch_size=32)
after = model.get_weights()
# Make sure every layer's weights changed
for i, _ in enumerate(before):
assert (after[i] != before[i]).any()
def test_output_shape(dummy_data, make_model):
# Disable the redefined-outer-name violation in this function
# pylint: disable=redefined-outer-name
data, _ = dummy_data
data = K.constant(data)
input_shape = data.shape
model = make_model
actual_output_shape = model(data).shape
expected_output_shape = model.compute_output_shape(input_shape)
np.testing.assert_equal(expected_output_shape, actual_output_shape)
@pytest.fixture(params=[(100, 10, 10, 512), (100, 512), (20, 10, 512)])
def high_dim_data(request):
np.random.seed(42)
# Generate dummy data for use in tests
data = np.random.randint(10, size=request.param)
return data
@pytest.fixture(params=[
'DenseDecomp', 'DenseMPO', 'DenseCondenser', 'DenseExpander',
'DenseEntangler'
])
def make_high_dim_model(high_dim_data, request):
# Disable the redefined-outer-name violation in this function
# pylint: disable=redefined-outer-name
data = high_dim_data
if request.param == 'DenseMPO':
model = Sequential()
model.add(
DenseMPO(data.shape[-1],
num_nodes=int(math.log(int(data.shape[-1]), 8)),
bond_dim=8,
use_bias=True,
activation='relu',
input_shape=(data.shape[-1],)))
elif request.param == 'DenseDecomp':
model = Sequential()
model.add(
DenseDecomp(512,
decomp_size=128,
use_bias=True,
activation='relu',
input_shape=(data.shape[-1],)))
elif request.param == 'DenseCondenser':
model = Sequential()
model.add(
DenseCondenser(exp_base=2,
num_nodes=3,
use_bias=True,
activation='relu',
input_shape=(data.shape[-1],)))
elif request.param == 'DenseExpander':
model = Sequential()
model.add(
DenseExpander(exp_base=2,
num_nodes=3,
use_bias=True,
activation='relu',
input_shape=(data.shape[-1],)))
elif request.param == 'DenseEntangler':
num_legs = 3
leg_dim = round(data.shape[-1]**(1. / num_legs))
assert leg_dim**num_legs == data.shape[-1]
model = Sequential()
model.add(
DenseEntangler(leg_dim**num_legs,
num_legs=num_legs,
num_levels=3,
use_bias=True,
activation='relu',
input_shape=(data.shape[-1],)))
return data, model
def test_higher_dim_input_output_shape(make_high_dim_model):
# pylint: disable=redefined-outer-name
data, model = make_high_dim_model
actual_output_shape = model(data).shape
expected_output_shape = model.compute_output_shape(data.shape)
np.testing.assert_equal(expected_output_shape, actual_output_shape)
def test_decomp_num_parameters(dummy_data):
# Disable the redefined-outer-name violation in this function
# pylint: disable=redefined-outer-name
data, _ = dummy_data
output_dim = 256
decomp_size = 128
model = Sequential()
model.add(
DenseDecomp(output_dim,
decomp_size=decomp_size,
use_bias=True,
activation='relu',
input_shape=(data.shape[1],)))
# num_params = a_params + b_params + bias_params
expected_num_parameters = (data.shape[1] * decomp_size) + (
decomp_size * output_dim) + output_dim
np.testing.assert_equal(expected_num_parameters, model.count_params())
def test_mpo_num_parameters(dummy_data):
# Disable the redefined-outer-name violation in this function
# pylint: disable=redefined-outer-name
data, _ = dummy_data
output_dim = data.shape[1]
num_nodes = int(math.log(data.shape[1], 8))
bond_dim = 8
model = Sequential()
model.add(
DenseMPO(output_dim,
num_nodes=num_nodes,
bond_dim=bond_dim,
use_bias=True,
activation='relu',
input_shape=(data.shape[1],)))
in_leg_dim = math.ceil(data.shape[1]**(1. / num_nodes))
out_leg_dim = math.ceil(output_dim**(1. / num_nodes))
# num_params = num_edge_node_params + num_middle_node_params + bias_params
expected_num_parameters = (2 * in_leg_dim * bond_dim * out_leg_dim) + (
(num_nodes - 2) * in_leg_dim * bond_dim * bond_dim *
out_leg_dim) + output_dim
np.testing.assert_equal(expected_num_parameters, model.count_params())
def test_condenser_num_parameters(dummy_data):
# Disable the redefined-outer-name violation in this function
# pylint: disable=redefined-outer-name
data, _ = dummy_data
exp_base = 2
num_nodes = 3
model = Sequential()
model.add(
DenseCondenser(exp_base=exp_base,
num_nodes=num_nodes,
use_bias=True,
activation='relu',
input_shape=(data.shape[1],)))
output_dim = data.shape[-1] // (exp_base**num_nodes)
# num_params = (num_nodes * num_node_params) + num_bias_params
expected_num_parameters = (num_nodes * output_dim * output_dim *
exp_base) + output_dim
np.testing.assert_equal(expected_num_parameters, model.count_params())
def test_expander_num_parameters(dummy_data):
# Disable the redefined-outer-name violation in this function
# pylint: disable=redefined-outer-name
data, _ = dummy_data
exp_base = 2
num_nodes = 3
model = Sequential()
model.add(
DenseExpander(exp_base=exp_base,
num_nodes=num_nodes,
use_bias=True,
activation='relu',
input_shape=(data.shape[-1],)))
output_dim = data.shape[-1] * (exp_base**num_nodes)
# num_params = (num_nodes * num_node_params) + num_bias_params
expected_num_parameters = (num_nodes * data.shape[-1] * data.shape[-1] *
exp_base) + output_dim
np.testing.assert_equal(expected_num_parameters, model.count_params())
def test_entangler_num_parameters(dummy_data):
# Disable the redefined-outer-name violation in this function
# pylint: disable=redefined-outer-name
data, _ = dummy_data
num_legs = 3
num_levels = 3
leg_dim = round(data.shape[-1]**(1. / num_legs))
assert leg_dim**num_legs == data.shape[-1]
model = Sequential()
model.add(
DenseEntangler(leg_dim**num_legs,
num_legs=num_legs,
num_levels=num_levels,
use_bias=True,
activation='relu',
input_shape=(data.shape[1],)))
# num_params = entangler_node_params + bias_params
expected_num_parameters = num_levels * (num_legs - 1) * (leg_dim**4) + (
leg_dim**num_legs)
np.testing.assert_equal(expected_num_parameters, model.count_params())
@pytest.mark.parametrize('num_levels', list(range(1, 4)))
@pytest.mark.parametrize('num_legs', list(range(2, 6)))
@pytest.mark.parametrize('leg_dims', [(4, 8), (8, 4)])
def test_entangler_asymmetric_num_parameters_output_shape(num_legs,
num_levels,
leg_dims):
leg_dim, out_leg_dim = leg_dims
data_shape = (leg_dim ** num_legs,)
model = Sequential()
model.add(
DenseEntangler(out_leg_dim**num_legs,
num_legs=num_legs,
num_levels=num_levels,
use_bias=True,
activation='relu',
input_shape=data_shape))
primary = leg_dim
secondary = out_leg_dim
if leg_dim > out_leg_dim:
primary, secondary = secondary, primary
expected_num_parameters = (num_levels - 1) * (num_legs - 1) * (primary**4) + (
num_legs - 2) * primary**3 * secondary + primary**2 * secondary**2 + (
out_leg_dim**num_legs)
np.testing.assert_equal(expected_num_parameters, model.count_params())
data = np.random.randint(10, size=(10, data_shape[0]))
out = model(data)
np.testing.assert_equal(out.shape, (data.shape[0], out_leg_dim**num_legs))
def test_config(make_model):
# Disable the redefined-outer-name violation in this function
# pylint: disable=redefined-outer-name
model = make_model
expected_num_parameters = model.layers[0].count_params()
# Serialize model and use config to create new layer
model_config = model.get_config()
layer_config = model_config['layers'][1]['config']
if 'mpo' in model.layers[0].name:
new_model = DenseMPO.from_config(layer_config)
elif 'decomp' in model.layers[0].name:
new_model = DenseDecomp.from_config(layer_config)
elif 'condenser' in model.layers[0].name:
new_model = DenseCondenser.from_config(layer_config)
elif 'expander' in model.layers[0].name:
new_model = DenseExpander.from_config(layer_config)
elif 'entangler' in model.layers[0].name:
new_model = DenseEntangler.from_config(layer_config)
# Build the layer so we can count params below
new_model.build(layer_config['batch_input_shape'])
# Check that original layer had same num params as layer built from config
np.testing.assert_equal(expected_num_parameters, new_model.count_params())
def test_model_save(dummy_data, make_model, tmp_path):
# Disable the redefined-outer-name violation in this function
# pylint: disable=redefined-outer-name
data, labels = dummy_data
model = make_model
model.compile(optimizer='adam',
loss='binary_crossentropy',
metrics=['accuracy'])
# Train the model for 5 epochs
model.fit(data, labels, epochs=5, batch_size=32)
for save_path in ['test_model', 'test_model.h5']:
# Save model to a SavedModel folder or h5 file, then load model
save_path = tmp_path / save_path
model.save(save_path)
loaded_model = load_model(save_path)
# Clean up SavedModel folder
if os.path.isdir(save_path):
shutil.rmtree(save_path)
# Clean up h5 file
if os.path.exists(save_path):
os.remove(save_path)
# Compare model predictions and loaded_model predictions
np.testing.assert_equal(model.predict(data), loaded_model.predict(data))
|
import unittest
from absl import flags
from absl.testing import flagsaver
import mock
from tests import pkb_common_test_case
from perfkitbenchmarker.traces import tcpdump
FLAGS = flags.FLAGS
_OUTPUT_FILE = '/tmp/x.pcap'
# all vm.RemoteCommands to launch tcpdump look like this
_CMD_FORMAT = ('sudo tcpdump -n -w {output_file} {{command}} '
'> /dev/null 2>&1 & echo $!').format(output_file=_OUTPUT_FILE)
class TcpdumpTestCase(pkb_common_test_case.PkbCommonTestCase):
def setUp(self):
super(TcpdumpTestCase, self).setUp()
self.enter_context(mock.patch('os.path.isdir', return_value=True))
def assertRunLine(self, command):
expected_command = _CMD_FORMAT.format(command=command)
collector = tcpdump._CreateCollector(FLAGS)
actual_command = collector._CollectorRunCommand(None, _OUTPUT_FILE)
self.assertEqual(expected_command, actual_command)
def testDefaults(self):
self.assertRunLine(r'-s 96 not port \(22\)')
@flagsaver.flagsaver(tcpdump_snaplen=10)
def testSnaplen(self):
self.assertRunLine(r'-s 10 not port \(22\)')
@flagsaver.flagsaver(tcpdump_snaplen=0)
def testNoSnaplen(self):
self.assertRunLine(r'not port \(22\)')
@flagsaver.flagsaver(tcpdump_packet_count=12)
def testCount(self):
self.assertRunLine(r'-s 96 -c 12 not port \(22\)')
@flagsaver.flagsaver(tcpdump_ignore_ports=[53, 80])
def testIgnorePorts(self):
self.assertRunLine(r'-s 96 not port \(53 or 80\)')
@flagsaver.flagsaver(tcpdump_include_ports=[22, 443])
def testIncludePorts(self):
self.assertRunLine(r'-s 96 port \(22 or 443\)')
@flagsaver.flagsaver(tcpdump_ignore_ports=[])
def testIncludeAll(self):
self.assertRunLine(r'-s 96')
def testKillCommand(self):
collector = tcpdump._CreateCollector(FLAGS)
vm = mock.Mock()
vm.RemoteCommand.return_value = ('pid1234', '')
collector._StartOnVm(vm)
vm.RemoteCommand.reset_mock()
collector._StopOnVm(vm, 'roleA')
vm.RemoteCommand.assert_called_with(
'sudo kill -s INT pid1234; sleep 3', ignore_failure=True)
if __name__ == '__main__':
unittest.main()
|
import os.path as op
import pytest
from mne.datasets.testing import data_path
from mne.io import read_raw_nirx
from mne.preprocessing.nirs import optical_density, beer_lambert_law,\
_fnirs_check_bads, _fnirs_spread_bads
from mne.datasets import testing
fname_nirx_15_0 = op.join(data_path(download=False),
'NIRx', 'nirscout', 'nirx_15_0_recording')
fname_nirx_15_2 = op.join(data_path(download=False),
'NIRx', 'nirscout', 'nirx_15_2_recording')
fname_nirx_15_2_short = op.join(data_path(download=False),
'NIRx', 'nirscout',
'nirx_15_2_recording_w_short')
@testing.requires_testing_data
@pytest.mark.parametrize('fname', ([fname_nirx_15_2_short, fname_nirx_15_2,
fname_nirx_15_0]))
def test_fnirs_check_bads(fname):
"""Test checking of bad markings."""
# No bad channels, so these should all pass
raw = read_raw_nirx(fname)
_fnirs_check_bads(raw)
raw = optical_density(raw)
_fnirs_check_bads(raw)
raw = beer_lambert_law(raw)
_fnirs_check_bads(raw)
# Mark pairs of bad channels, so these should all pass
raw = read_raw_nirx(fname)
raw.info['bads'] = raw.ch_names[0:2]
_fnirs_check_bads(raw)
raw = optical_density(raw)
_fnirs_check_bads(raw)
raw = beer_lambert_law(raw)
_fnirs_check_bads(raw)
# Mark single channel as bad, so these should all fail
raw = read_raw_nirx(fname)
raw.info['bads'] = raw.ch_names[0:1]
pytest.raises(RuntimeError, _fnirs_check_bads, raw)
raw = optical_density(raw)
pytest.raises(RuntimeError, _fnirs_check_bads, raw)
raw = beer_lambert_law(raw)
pytest.raises(RuntimeError, _fnirs_check_bads, raw)
@testing.requires_testing_data
@pytest.mark.parametrize('fname', ([fname_nirx_15_2_short, fname_nirx_15_2,
fname_nirx_15_0]))
def test_fnirs_spread_bads(fname):
"""Test checking of bad markings."""
# Test spreading upwards in frequency and on raw data
raw = read_raw_nirx(fname)
raw.info['bads'] = ['S1_D1 760']
raw = _fnirs_spread_bads(raw)
assert raw.info['bads'] == ['S1_D1 760', 'S1_D1 850']
# Test spreading downwards in frequency and on od data
raw = optical_density(raw)
raw.info['bads'] = raw.ch_names[5:6]
raw = _fnirs_spread_bads(raw)
assert raw.info['bads'] == raw.ch_names[4:6]
# Test spreading multiple bads and on chroma data
raw = beer_lambert_law(raw)
raw.info['bads'] = [raw.ch_names[x] for x in [1, 8]]
print(raw.info['bads'])
raw = _fnirs_spread_bads(raw)
print(raw.info['bads'])
assert raw.info['bads'] == [raw.ch_names[x] for x in [0, 1, 8, 9]]
|
import asyncio
from datetime import datetime, timedelta
import enum
from functools import wraps
import random
import re
import socket
import string
import threading
from types import MappingProxyType
from typing import (
Any,
Callable,
Coroutine,
Iterable,
KeysView,
Optional,
TypeVar,
Union,
)
import slugify as unicode_slug
from .dt import as_local, utcnow
T = TypeVar("T")
U = TypeVar("U") # pylint: disable=invalid-name
ENUM_T = TypeVar("ENUM_T", bound=enum.Enum) # pylint: disable=invalid-name
RE_SANITIZE_FILENAME = re.compile(r"(~|\.\.|/|\\)")
RE_SANITIZE_PATH = re.compile(r"(~|\.(\.)+)")
def sanitize_filename(filename: str) -> str:
r"""Sanitize a filename by removing .. / and \\."""
return RE_SANITIZE_FILENAME.sub("", filename)
def sanitize_path(path: str) -> str:
"""Sanitize a path by removing ~ and .."""
return RE_SANITIZE_PATH.sub("", path)
def slugify(text: str, *, separator: str = "_") -> str:
"""Slugify a given text."""
return unicode_slug.slugify(text, separator=separator)
def repr_helper(inp: Any) -> str:
"""Help creating a more readable string representation of objects."""
if isinstance(inp, (dict, MappingProxyType)):
return ", ".join(
f"{repr_helper(key)}={repr_helper(item)}" for key, item in inp.items()
)
if isinstance(inp, datetime):
return as_local(inp).isoformat()
return str(inp)
def convert(
value: Optional[T], to_type: Callable[[T], U], default: Optional[U] = None
) -> Optional[U]:
"""Convert value to to_type, returns default if fails."""
try:
return default if value is None else to_type(value)
except (ValueError, TypeError):
# If value could not be converted
return default
def ensure_unique_string(
preferred_string: str, current_strings: Union[Iterable[str], KeysView[str]]
) -> str:
"""Return a string that is not present in current_strings.
If preferred string exists will append _2, _3, ..
"""
test_string = preferred_string
current_strings_set = set(current_strings)
tries = 1
while test_string in current_strings_set:
tries += 1
test_string = f"{preferred_string}_{tries}"
return test_string
# Taken from: http://stackoverflow.com/a/11735897
def get_local_ip() -> str:
"""Try to determine the local IP address of the machine."""
try:
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
# Use Google Public DNS server to determine own IP
sock.connect(("8.8.8.8", 80))
return sock.getsockname()[0] # type: ignore
except OSError:
try:
return socket.gethostbyname(socket.gethostname())
except socket.gaierror:
return "127.0.0.1"
finally:
sock.close()
# Taken from http://stackoverflow.com/a/23728630
def get_random_string(length: int = 10) -> str:
"""Return a random string with letters and digits."""
generator = random.SystemRandom()
source_chars = string.ascii_letters + string.digits
return "".join(generator.choice(source_chars) for _ in range(length))
class OrderedEnum(enum.Enum):
"""Taken from Python 3.4.0 docs."""
# https://github.com/PyCQA/pylint/issues/2306
# pylint: disable=comparison-with-callable
def __ge__(self, other: ENUM_T) -> bool:
"""Return the greater than element."""
if self.__class__ is other.__class__:
return bool(self.value >= other.value)
return NotImplemented
def __gt__(self, other: ENUM_T) -> bool:
"""Return the greater element."""
if self.__class__ is other.__class__:
return bool(self.value > other.value)
return NotImplemented
def __le__(self, other: ENUM_T) -> bool:
"""Return the lower than element."""
if self.__class__ is other.__class__:
return bool(self.value <= other.value)
return NotImplemented
def __lt__(self, other: ENUM_T) -> bool:
"""Return the lower element."""
if self.__class__ is other.__class__:
return bool(self.value < other.value)
return NotImplemented
class Throttle:
"""A class for throttling the execution of tasks.
This method decorator adds a cooldown to a method to prevent it from being
called more then 1 time within the timedelta interval `min_time` after it
returned its result.
Calling a method a second time during the interval will return None.
Pass keyword argument `no_throttle=True` to the wrapped method to make
the call not throttled.
Decorator takes in an optional second timedelta interval to throttle the
'no_throttle' calls.
Adds a datetime attribute `last_call` to the method.
"""
def __init__(
self, min_time: timedelta, limit_no_throttle: Optional[timedelta] = None
) -> None:
"""Initialize the throttle."""
self.min_time = min_time
self.limit_no_throttle = limit_no_throttle
def __call__(self, method: Callable) -> Callable:
"""Caller for the throttle."""
# Make sure we return a coroutine if the method is async.
if asyncio.iscoroutinefunction(method):
async def throttled_value() -> None:
"""Stand-in function for when real func is being throttled."""
return None
else:
def throttled_value() -> None: # type: ignore
"""Stand-in function for when real func is being throttled."""
return None
if self.limit_no_throttle is not None:
method = Throttle(self.limit_no_throttle)(method)
# Different methods that can be passed in:
# - a function
# - an unbound function on a class
# - a method (bound function on a class)
# We want to be able to differentiate between function and unbound
# methods (which are considered functions).
# All methods have the classname in their qualname separated by a '.'
# Functions have a '.' in their qualname if defined inline, but will
# be prefixed by '.<locals>.' so we strip that out.
is_func = (
not hasattr(method, "__self__")
and "." not in method.__qualname__.split(".<locals>.")[-1]
)
@wraps(method)
def wrapper(*args: Any, **kwargs: Any) -> Union[Callable, Coroutine]:
"""Wrap that allows wrapped to be called only once per min_time.
If we cannot acquire the lock, it is running so return None.
"""
if hasattr(method, "__self__"):
host = getattr(method, "__self__")
elif is_func:
host = wrapper
else:
host = args[0] if args else wrapper
# pylint: disable=protected-access # to _throttle
if not hasattr(host, "_throttle"):
host._throttle = {}
if id(self) not in host._throttle:
host._throttle[id(self)] = [threading.Lock(), None]
throttle = host._throttle[id(self)]
# pylint: enable=protected-access
if not throttle[0].acquire(False):
return throttled_value()
# Check if method is never called or no_throttle is given
force = kwargs.pop("no_throttle", False) or not throttle[1]
try:
if force or utcnow() - throttle[1] > self.min_time:
result = method(*args, **kwargs)
throttle[1] = utcnow()
return result # type: ignore
return throttled_value()
finally:
throttle[0].release()
return wrapper
|
import ipaddress
import logging
import re
from pdunehd import DuneHDPlayer
import voluptuous as vol
from homeassistant import config_entries, exceptions
from homeassistant.const import CONF_HOST
from .const import DOMAIN # pylint:disable=unused-import
_LOGGER = logging.getLogger(__name__)
def host_valid(host):
"""Return True if hostname or IP address is valid."""
try:
if ipaddress.ip_address(host).version == (4 or 6):
return True
except ValueError:
if len(host) > 253:
return False
allowed = re.compile(r"(?!-)[A-Z\d\-\_]{1,63}(?<!-)$", re.IGNORECASE)
return all(allowed.match(x) for x in host.split("."))
class DuneHDConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
"""Handle a config flow for Dune HD integration."""
VERSION = 1
CONNECTION_CLASS = config_entries.CONN_CLASS_LOCAL_POLL
def __init__(self):
"""Initialize."""
self.host = None
async def init_device(self, host):
"""Initialize Dune HD player."""
player = DuneHDPlayer(host)
state = await self.hass.async_add_executor_job(player.update_state)
if not state:
raise CannotConnect()
async def async_step_user(self, user_input=None):
"""Handle the initial step."""
errors = {}
if user_input is not None:
if host_valid(user_input[CONF_HOST]):
self.host = user_input[CONF_HOST]
try:
if self.host_already_configured(self.host):
raise AlreadyConfigured()
await self.init_device(self.host)
except CannotConnect:
errors[CONF_HOST] = "cannot_connect"
except AlreadyConfigured:
errors[CONF_HOST] = "already_configured"
else:
return self.async_create_entry(title=self.host, data=user_input)
else:
errors[CONF_HOST] = "invalid_host"
return self.async_show_form(
step_id="user",
data_schema=vol.Schema({vol.Required(CONF_HOST, default=""): str}),
errors=errors,
)
async def async_step_import(self, user_input=None):
"""Handle configuration by yaml file."""
self.host = user_input[CONF_HOST]
if self.host_already_configured(self.host):
return self.async_abort(reason="already_configured")
try:
await self.init_device(self.host)
except CannotConnect:
_LOGGER.error("Import aborted, cannot connect to %s", self.host)
return self.async_abort(reason="cannot_connect")
else:
return self.async_create_entry(title=self.host, data=user_input)
def host_already_configured(self, host):
"""See if we already have a dunehd entry matching user input configured."""
existing_hosts = {
entry.data[CONF_HOST] for entry in self._async_current_entries()
}
return host in existing_hosts
class CannotConnect(exceptions.HomeAssistantError):
"""Error to indicate we cannot connect."""
class AlreadyConfigured(exceptions.HomeAssistantError):
"""Error to indicate device is already configured."""
|
import socket
import time
import mock
from behave import given
from behave import then
from behave import when
from marathon import MarathonHttpError
from paasta_tools import bounce_lib
from paasta_tools import drain_lib
from paasta_tools import marathon_tools
from paasta_tools import mesos_maintenance
from paasta_tools import setup_marathon_job
from paasta_tools.bounce_lib import get_happy_tasks
def which_id(context, which):
if which == "new":
return context.new_id
elif which == "old":
return context.old_app_config["id"]
@given(
'a new {state} app to be deployed, with bounce strategy "{bounce_method}" and drain method "{drain_method}"'
)
def given_a_new_app_to_be_deployed(context, state, bounce_method, drain_method):
given_a_new_app_to_be_deployed_constraints(
context, state, bounce_method, drain_method, constraints=str([])
)
@given(
"a new {state} app to be deployed, "
+ 'with bounce strategy "{bounce_method}" '
+ 'and drain method "{drain_method}" '
+ "and host_port {host_port:d} "
+ "and {net} networking "
+ "and {instances:d} instances"
)
def given_a_new_app_to_be_deployed_host_port_net(
context, state, bounce_method, drain_method, host_port, net, instances
):
given_a_new_app_to_be_deployed_constraints(
context=context,
state=state,
bounce_method=bounce_method,
drain_method=drain_method,
constraints=str([]),
host_port=host_port,
net=net,
instances=instances,
)
@given(
"a new {state} app to be deployed, "
+ 'with bounce strategy "{bounce_method}" '
+ 'and drain method "{drain_method}" '
+ "and constraints {constraints}"
)
def given_a_new_app_to_be_deployed_constraints(
context,
state,
bounce_method,
drain_method,
constraints,
host_port=0,
net="bridge",
instances=2,
):
constraints = eval(constraints)
if state == "healthy":
cmd = "/bin/true"
elif state == "unhealthy":
cmd = "/bin/false"
else:
return ValueError("can't start test app with unknown state %s", state)
context.service = "bounce"
context.instance = "test1"
context.new_id = "bounce.test1.newapp.confighash"
context.new_marathon_service_config = marathon_tools.MarathonServiceConfig(
service=context.service,
cluster=context.cluster,
instance=context.instance,
config_dict={
"cmd": "/bin/sleep 300",
"instances": instances,
"healthcheck_mode": "cmd",
"healthcheck_cmd": cmd,
"bounce_method": str(bounce_method),
"drain_method": str(drain_method),
"cpus": 0.1,
"mem": 100,
"disk": 10,
"constraints": constraints,
"host_port": host_port,
"net": net,
},
branch_dict={
"docker_image": "busybox",
"desired_state": "start",
"force_bounce": None,
},
)
context.current_client = context.marathon_clients.get_current_client_for_service(
context.new_marathon_service_config
)
@given("an old app to be destroyed")
def given_an_old_app_to_be_destroyed(context):
given_an_old_app_to_be_destroyed_constraints(context, str([]))
@given("an old app to be destroyed with constraints {constraints}")
def given_an_old_app_to_be_destroyed_constraints(context, constraints):
constraints = eval(constraints)
old_app_name = "bounce.test1.oldapp.confighash"
context.old_ids = [old_app_name]
context.old_app_config = {
"id": old_app_name,
"cmd": "/bin/sleep 300",
"instances": 2,
"container": {
"type": "DOCKER",
"docker": {"network": "BRIDGE", "image": "busybox"},
},
"backoff_seconds": 1,
"backoff_factor": 1,
"constraints": constraints,
}
bounce_lib.create_marathon_app(
old_app_name, context.old_app_config, context.current_client
)
@when("there are exactly {num:d} {which} {state} tasks")
def when_there_are_exactly_num_which_tasks(context, num, which, state):
there_are_num_which_tasks(context, num, which, state, True)
@when("there are {num:d} {which} {state} tasks")
def when_there_are_num_which_tasks(context, num, which, state):
there_are_num_which_tasks(context, num, which, state, False)
def there_are_num_which_tasks(context, num, which, state, exact):
context.max_tasks = num
app_id = which_id(context, which)
# 180 * 0.5 = 90 seconds
for _ in range(180):
app = context.current_client.get_app(app_id, embed_tasks=True)
happy_tasks = get_happy_tasks(
app, context.service, "fake_nerve_ns", context.system_paasta_config
)
happy_count = len(happy_tasks)
if state == "healthy":
if exact:
if happy_count == context.max_tasks:
return
else:
if happy_count >= context.max_tasks:
return
elif state == "unhealthy":
if exact:
if len(app.tasks) - happy_count == context.max_tasks:
return
else:
if len(app.tasks) - happy_count >= context.max_tasks:
return
time.sleep(0.5)
raise Exception(
"timed out waiting for %d %s tasks on %s; there are %d"
% (context.max_tasks, state, app_id, len(app.tasks))
)
@when("setup_service is initiated")
def when_setup_service_initiated(context):
with mock.patch(
"paasta_tools.bounce_lib.get_happy_tasks",
autospec=True,
# Wrap function call so we can select a subset of tasks or test
# intermediate steps, like when an app is not completely up
side_effect=lambda app, _, __, ___, **kwargs: get_happy_tasks(
app, context.service, "fake_nerve_ns", context.system_paasta_config
)[: context.max_tasks],
), mock.patch(
"paasta_tools.bounce_lib.bounce_lock_zookeeper", autospec=True
), mock.patch(
"paasta_tools.bounce_lib.time.sleep", autospec=True
), mock.patch(
"paasta_tools.setup_marathon_job.load_system_paasta_config", autospec=True
) as mock_load_system_paasta_config, mock.patch(
"paasta_tools.setup_marathon_job._log", autospec=True
), mock.patch(
"paasta_tools.marathon_tools.get_config_hash",
autospec=True,
return_value="confighash",
), mock.patch(
"paasta_tools.marathon_tools.get_code_sha_from_dockerurl",
autospec=True,
return_value="newapp",
), mock.patch(
"paasta_tools.utils.InstanceConfig.get_docker_url",
autospec=True,
return_value="busybox",
), mock.patch(
"paasta_tools.mesos_maintenance.get_principal", autospec=True
) as mock_get_principal, mock.patch(
"paasta_tools.mesos_maintenance.get_secret", autospec=True
) as mock_get_secret, mock.patch(
"paasta_tools.mesos_maintenance.get_mesos_leader",
autospec=True,
return_value="mesosmaster",
):
credentials = mesos_maintenance.load_credentials(
mesos_secrets="/etc/mesos-slave-secret"
)
mock_get_principal.return_value = credentials.principal
mock_get_secret.return_value = credentials.secret
mock_load_system_paasta_config.return_value.get_cluster = mock.Mock(
return_value=context.cluster
)
# 120 * 0.5 = 60 seconds
for _ in range(120):
try:
marathon_apps_with_clients = marathon_tools.get_marathon_apps_with_clients(
clients=context.marathon_clients.get_all_clients(), embed_tasks=True
)
(code, message, bounce_again) = setup_marathon_job.setup_service(
service=context.service,
instance=context.instance,
clients=context.marathon_clients,
marathon_apps_with_clients=marathon_apps_with_clients,
job_config=context.new_marathon_service_config,
soa_dir="/nail/etc/services",
)
assert code == 0, message
return
except MarathonHttpError:
time.sleep(0.5)
raise Exception(
"Unable to acquire app lock for setup_marathon_job.setup_service"
)
@when("the {which} app is down to {num} instances")
def when_the_which_app_is_down_to_num_instances(context, which, num):
app_id = which_id(context, which)
while True:
tasks = context.current_client.list_tasks(app_id)
if len([t for t in tasks if t.started_at]) <= int(num):
return
time.sleep(0.5)
@then("the {which} app should be running")
def then_the_which_app_should_be_running(context, which):
assert (
marathon_tools.is_app_id_running(
which_id(context, which), context.current_client
)
is True
)
@then("the {which} app should be configured to have {num} instances")
def then_the_which_app_should_be_configured_to_have_num_instances(
context, which, num, retries=10
):
app_id = which_id(context, which)
for _ in range(retries):
app = context.current_client.get_app(app_id)
if app.instances == int(num):
return
time.sleep(0.5)
raise ValueError(
"Expected there to be %d instances, but there were %d"
% (int(num), app.instances)
)
@then("the {which} app should be gone")
def then_the_which_app_should_be_gone(context, which):
assert (
marathon_tools.is_app_id_running(
which_id(context, which), context.current_client
)
is False
)
@when("we wait a bit for the {which} app to disappear")
def and_we_wait_a_bit_for_the_app_to_disappear(context, which):
""" Marathon will not make the app disappear until after all the tasks have died
https://github.com/mesosphere/marathon/issues/1431 """
for _ in range(10):
if (
marathon_tools.is_app_id_running(
which_id(context, which), context.current_client
)
is True
):
time.sleep(0.5)
else:
return True
# It better not be running by now!
assert (
marathon_tools.is_app_id_running(
which_id(context, which), context.current_client
)
is False
)
@when("a task has drained")
def when_a_task_has_drained(context):
"""Tell the TestDrainMethod to mark a task as safe to kill.
Normal drain methods, like hacheck, require waiting for something to happen in the background. The bounce code can
cause a task to go from up -> draining, but the draining->drained transition normally happens outside of Paasta.
With TestDrainMethod, we can control the draining->drained transition to emulate that external code, and that's what
this step does.
"""
drain_lib.TestDrainMethod.mark_arbitrary_task_as_safe_to_kill()
@then("it should be discoverable on port {host_port:d}")
def should_be_discoverable_on_port(context, host_port):
all_discovered = {}
for slave_ip in socket.gethostbyname_ex("mesosslave")[2]:
with mock.patch(
"paasta_tools.mesos_tools.socket.getfqdn",
return_value=slave_ip,
autospec=True,
):
discovered = marathon_tools.marathon_services_running_here()
all_discovered[slave_ip] = discovered
if discovered == [("bounce", "test1", host_port)]:
return
raise Exception(
"Did not find bounce.test1 in marathon_services_running_here for any of our slaves: %r",
all_discovered,
)
@then("it should be discoverable on any port")
def should_be_discoverable_on_any_port(context):
return should_be_discoverable_on_port(context, mock.ANY)
|
from unittest.mock import patch
from homeassistant.components.elgato.light import ElgatoError
from homeassistant.components.light import (
ATTR_BRIGHTNESS,
ATTR_COLOR_TEMP,
DOMAIN as LIGHT_DOMAIN,
)
from homeassistant.const import (
ATTR_ENTITY_ID,
SERVICE_TURN_OFF,
SERVICE_TURN_ON,
STATE_ON,
STATE_UNAVAILABLE,
)
from homeassistant.core import HomeAssistant
from tests.common import mock_coro
from tests.components.elgato import init_integration
from tests.test_util.aiohttp import AiohttpClientMocker
async def test_light_state(
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker
) -> None:
"""Test the creation and values of the Elgato Key Lights."""
await init_integration(hass, aioclient_mock)
entity_registry = await hass.helpers.entity_registry.async_get_registry()
# First segment of the strip
state = hass.states.get("light.frenck")
assert state
assert state.attributes.get(ATTR_BRIGHTNESS) == 54
assert state.attributes.get(ATTR_COLOR_TEMP) == 297
assert state.state == STATE_ON
entry = entity_registry.async_get("light.frenck")
assert entry
assert entry.unique_id == "CN11A1A00001"
async def test_light_change_state(
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker
) -> None:
"""Test the change of state of a Elgato Key Light device."""
await init_integration(hass, aioclient_mock)
state = hass.states.get("light.frenck")
assert state.state == STATE_ON
with patch(
"homeassistant.components.elgato.light.Elgato.light",
return_value=mock_coro(),
) as mock_light:
await hass.services.async_call(
LIGHT_DOMAIN,
SERVICE_TURN_ON,
{
ATTR_ENTITY_ID: "light.frenck",
ATTR_BRIGHTNESS: 255,
ATTR_COLOR_TEMP: 100,
},
blocking=True,
)
await hass.async_block_till_done()
assert len(mock_light.mock_calls) == 1
mock_light.assert_called_with(on=True, brightness=100, temperature=100)
with patch(
"homeassistant.components.elgato.light.Elgato.light",
return_value=mock_coro(),
) as mock_light:
await hass.services.async_call(
LIGHT_DOMAIN,
SERVICE_TURN_OFF,
{ATTR_ENTITY_ID: "light.frenck"},
blocking=True,
)
await hass.async_block_till_done()
assert len(mock_light.mock_calls) == 1
mock_light.assert_called_with(on=False)
async def test_light_unavailable(
hass: HomeAssistant, aioclient_mock: AiohttpClientMocker
) -> None:
"""Test error/unavailable handling of an Elgato Key Light."""
await init_integration(hass, aioclient_mock)
with patch(
"homeassistant.components.elgato.light.Elgato.light",
side_effect=ElgatoError,
):
with patch(
"homeassistant.components.elgato.light.Elgato.state",
side_effect=ElgatoError,
):
await hass.services.async_call(
LIGHT_DOMAIN,
SERVICE_TURN_OFF,
{ATTR_ENTITY_ID: "light.frenck"},
blocking=True,
)
await hass.async_block_till_done()
state = hass.states.get("light.frenck")
assert state.state == STATE_UNAVAILABLE
|
from homeassistant.components.cover import (
DEVICE_CLASS_BLIND,
SUPPORT_CLOSE,
SUPPORT_OPEN,
SUPPORT_SET_POSITION,
CoverEntity,
)
from homeassistant.config_entries import ConfigEntry
from homeassistant.helpers.typing import HomeAssistantType
from .const import DOMAIN
from .devolo_multi_level_switch import DevoloMultiLevelSwitchDeviceEntity
async def async_setup_entry(
hass: HomeAssistantType, entry: ConfigEntry, async_add_entities
) -> None:
"""Get all cover devices and setup them via config entry."""
entities = []
for gateway in hass.data[DOMAIN][entry.entry_id]["gateways"]:
for device in gateway.multi_level_switch_devices:
for multi_level_switch in device.multi_level_switch_property:
if multi_level_switch.startswith("devolo.Blinds"):
entities.append(
DevoloCoverDeviceEntity(
homecontrol=gateway,
device_instance=device,
element_uid=multi_level_switch,
)
)
async_add_entities(entities, False)
class DevoloCoverDeviceEntity(DevoloMultiLevelSwitchDeviceEntity, CoverEntity):
"""Representation of a cover device within devolo Home Control."""
@property
def current_cover_position(self):
"""Return the current position. 0 is closed. 100 is open."""
return self._value
@property
def device_class(self):
"""Return the class of the device."""
return DEVICE_CLASS_BLIND
@property
def is_closed(self):
"""Return if the blind is closed or not."""
return not bool(self._value)
@property
def supported_features(self):
"""Flag supported features."""
return SUPPORT_OPEN | SUPPORT_CLOSE | SUPPORT_SET_POSITION
def open_cover(self, **kwargs):
"""Open the blind."""
self._multi_level_switch_property.set(100)
def close_cover(self, **kwargs):
"""Close the blind."""
self._multi_level_switch_property.set(0)
def set_cover_position(self, **kwargs):
"""Set the blind to the given position."""
self._multi_level_switch_property.set(kwargs["position"])
|
import asyncio
from ipaddress import ip_address
from operator import itemgetter
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.config_entries import ConfigEntry
from homeassistant.exceptions import ConfigEntryNotReady
from homeassistant.helpers import config_validation as cv, device_registry as dr
from homeassistant.helpers.typing import ConfigType, HomeAssistantType
from homeassistant.util import get_local_ip
from .const import (
CONF_LOCAL_IP,
CONFIG_ENTRY_ST,
CONFIG_ENTRY_UDN,
DISCOVERY_LOCATION,
DISCOVERY_ST,
DISCOVERY_UDN,
DISCOVERY_USN,
DOMAIN,
DOMAIN_CONFIG,
DOMAIN_COORDINATORS,
DOMAIN_DEVICES,
DOMAIN_LOCAL_IP,
LOGGER as _LOGGER,
)
from .device import Device
NOTIFICATION_ID = "upnp_notification"
NOTIFICATION_TITLE = "UPnP/IGD Setup"
CONFIG_SCHEMA = vol.Schema(
{DOMAIN: vol.Schema({vol.Optional(CONF_LOCAL_IP): vol.All(ip_address, cv.string)})},
extra=vol.ALLOW_EXTRA,
)
async def async_discover_and_construct(
hass: HomeAssistantType, udn: str = None, st: str = None
) -> Device:
"""Discovery devices and construct a Device for one."""
# pylint: disable=invalid-name
discovery_infos = await Device.async_discover(hass)
_LOGGER.debug("Discovered devices: %s", discovery_infos)
if not discovery_infos:
_LOGGER.info("No UPnP/IGD devices discovered")
return None
if udn:
# Get the discovery info with specified UDN/ST.
filtered = [di for di in discovery_infos if di[DISCOVERY_UDN] == udn]
if st:
filtered = [di for di in discovery_infos if di[DISCOVERY_ST] == st]
if not filtered:
_LOGGER.warning(
'Wanted UPnP/IGD device with UDN/ST "%s"/"%s" not found, aborting',
udn,
st,
)
return None
# Ensure we're always taking the latest, if we filtered only on UDN.
filtered = sorted(filtered, key=itemgetter(DISCOVERY_ST), reverse=True)
discovery_info = filtered[0]
else:
# Get the first/any.
discovery_info = discovery_infos[0]
if len(discovery_infos) > 1:
device_name = discovery_info.get(
DISCOVERY_USN, discovery_info.get(DISCOVERY_LOCATION, "")
)
_LOGGER.info("Detected multiple UPnP/IGD devices, using: %s", device_name)
location = discovery_info[DISCOVERY_LOCATION]
return await Device.async_create_device(hass, location)
async def async_setup(hass: HomeAssistantType, config: ConfigType):
"""Set up UPnP component."""
_LOGGER.debug("async_setup, config: %s", config)
conf_default = CONFIG_SCHEMA({DOMAIN: {}})[DOMAIN]
conf = config.get(DOMAIN, conf_default)
local_ip = await hass.async_add_executor_job(get_local_ip)
hass.data[DOMAIN] = {
DOMAIN_CONFIG: conf,
DOMAIN_COORDINATORS: {},
DOMAIN_DEVICES: {},
DOMAIN_LOCAL_IP: conf.get(CONF_LOCAL_IP, local_ip),
}
# Only start if set up via configuration.yaml.
if DOMAIN in config:
hass.async_create_task(
hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_IMPORT}
)
)
return True
async def async_setup_entry(hass: HomeAssistantType, config_entry: ConfigEntry) -> bool:
"""Set up UPnP/IGD device from a config entry."""
_LOGGER.debug("async_setup_entry, config_entry: %s", config_entry.data)
# Discover and construct.
udn = config_entry.data.get(CONFIG_ENTRY_UDN)
st = config_entry.data.get(CONFIG_ENTRY_ST) # pylint: disable=invalid-name
try:
device = await async_discover_and_construct(hass, udn, st)
except asyncio.TimeoutError as err:
raise ConfigEntryNotReady from err
if not device:
_LOGGER.info("Unable to create UPnP/IGD, aborting")
raise ConfigEntryNotReady
# Save device.
hass.data[DOMAIN][DOMAIN_DEVICES][device.udn] = device
# Ensure entry has a unique_id.
if not config_entry.unique_id:
hass.config_entries.async_update_entry(
entry=config_entry,
unique_id=device.unique_id,
)
# Create device registry entry.
device_registry = await dr.async_get_registry(hass)
device_registry.async_get_or_create(
config_entry_id=config_entry.entry_id,
connections={(dr.CONNECTION_UPNP, device.udn)},
identifiers={(DOMAIN, device.udn)},
name=device.name,
manufacturer=device.manufacturer,
model=device.model_name,
)
# Create sensors.
_LOGGER.debug("Enabling sensors")
hass.async_create_task(
hass.config_entries.async_forward_entry_setup(config_entry, "sensor")
)
return True
async def async_unload_entry(
hass: HomeAssistantType, config_entry: ConfigEntry
) -> bool:
"""Unload a UPnP/IGD device from a config entry."""
udn = config_entry.data.get(CONFIG_ENTRY_UDN)
if udn in hass.data[DOMAIN][DOMAIN_DEVICES]:
del hass.data[DOMAIN][DOMAIN_DEVICES][udn]
if udn in hass.data[DOMAIN][DOMAIN_COORDINATORS]:
del hass.data[DOMAIN][DOMAIN_COORDINATORS][udn]
_LOGGER.debug("Deleting sensors")
return await hass.config_entries.async_forward_entry_unload(config_entry, "sensor")
|
import logging
from gsp import GstreamerPlayer
import voluptuous as vol
from homeassistant.components.media_player import PLATFORM_SCHEMA, MediaPlayerEntity
from homeassistant.components.media_player.const import (
MEDIA_TYPE_MUSIC,
SUPPORT_NEXT_TRACK,
SUPPORT_PAUSE,
SUPPORT_PLAY,
SUPPORT_PLAY_MEDIA,
SUPPORT_VOLUME_SET,
)
from homeassistant.const import CONF_NAME, EVENT_HOMEASSISTANT_STOP, STATE_IDLE
import homeassistant.helpers.config_validation as cv
_LOGGER = logging.getLogger(__name__)
CONF_PIPELINE = "pipeline"
DOMAIN = "gstreamer"
SUPPORT_GSTREAMER = (
SUPPORT_VOLUME_SET
| SUPPORT_PLAY
| SUPPORT_PAUSE
| SUPPORT_PLAY_MEDIA
| SUPPORT_NEXT_TRACK
)
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
{vol.Optional(CONF_NAME): cv.string, vol.Optional(CONF_PIPELINE): cv.string}
)
def setup_platform(hass, config, add_entities, discovery_info=None):
"""Set up the Gstreamer platform."""
name = config.get(CONF_NAME)
pipeline = config.get(CONF_PIPELINE)
player = GstreamerPlayer(pipeline)
def _shutdown(call):
"""Quit the player on shutdown."""
player.quit()
hass.bus.listen_once(EVENT_HOMEASSISTANT_STOP, _shutdown)
add_entities([GstreamerDevice(player, name)])
class GstreamerDevice(MediaPlayerEntity):
"""Representation of a Gstreamer device."""
def __init__(self, player, name):
"""Initialize the Gstreamer device."""
self._player = player
self._name = name or DOMAIN
self._state = STATE_IDLE
self._volume = None
self._duration = None
self._uri = None
self._title = None
self._artist = None
self._album = None
def update(self):
"""Update properties."""
self._state = self._player.state
self._volume = self._player.volume
self._duration = self._player.duration
self._uri = self._player.uri
self._title = self._player.title
self._album = self._player.album
self._artist = self._player.artist
def set_volume_level(self, volume):
"""Set the volume level."""
self._player.volume = volume
def play_media(self, media_type, media_id, **kwargs):
"""Play media."""
if media_type != MEDIA_TYPE_MUSIC:
_LOGGER.error("invalid media type")
return
self._player.queue(media_id)
def media_play(self):
"""Play."""
self._player.play()
def media_pause(self):
"""Pause."""
self._player.pause()
def media_next_track(self):
"""Next track."""
self._player.next()
@property
def media_content_id(self):
"""Content ID of currently playing media."""
return self._uri
@property
def content_type(self):
"""Content type of currently playing media."""
return MEDIA_TYPE_MUSIC
@property
def name(self):
"""Return the name of the device."""
return self._name
@property
def volume_level(self):
"""Return the volume level."""
return self._volume
@property
def supported_features(self):
"""Flag media player features that are supported."""
return SUPPORT_GSTREAMER
@property
def state(self):
"""Return the state of the player."""
return self._state
@property
def media_duration(self):
"""Duration of current playing media in seconds."""
return self._duration
@property
def media_title(self):
"""Media title."""
return self._title
@property
def media_artist(self):
"""Media artist."""
return self._artist
@property
def media_album_name(self):
"""Media album."""
return self._album
|
import json
import logging
import re
import requests
import voluptuous as vol
from homeassistant.components.device_tracker import (
DOMAIN,
PLATFORM_SCHEMA,
DeviceScanner,
)
from homeassistant.const import (
CONF_HOST,
CONF_PASSWORD,
CONF_PORT,
CONF_SSL,
CONF_USERNAME,
CONF_VERIFY_SSL,
HTTP_OK,
HTTP_UNAUTHORIZED,
)
import homeassistant.helpers.config_validation as cv
CONF_HTTP_ID = "http_id"
_LOGGER = logging.getLogger(__name__)
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
{
vol.Required(CONF_HOST): cv.string,
vol.Optional(CONF_PORT): cv.port,
vol.Optional(CONF_SSL, default=False): cv.boolean,
vol.Optional(CONF_VERIFY_SSL, default=True): vol.Any(cv.boolean, cv.isfile),
vol.Required(CONF_PASSWORD): cv.string,
vol.Required(CONF_USERNAME): cv.string,
vol.Required(CONF_HTTP_ID): cv.string,
}
)
def get_scanner(hass, config):
"""Validate the configuration and returns a Tomato scanner."""
return TomatoDeviceScanner(config[DOMAIN])
class TomatoDeviceScanner(DeviceScanner):
"""This class queries a wireless router running Tomato firmware."""
def __init__(self, config):
"""Initialize the scanner."""
host, http_id = config[CONF_HOST], config[CONF_HTTP_ID]
port = config.get(CONF_PORT)
username, password = config[CONF_USERNAME], config[CONF_PASSWORD]
self.ssl, self.verify_ssl = config[CONF_SSL], config[CONF_VERIFY_SSL]
if port is None:
port = 443 if self.ssl else 80
self.req = requests.Request(
"POST",
"http{}://{}:{}/update.cgi".format("s" if self.ssl else "", host, port),
data={"_http_id": http_id, "exec": "devlist"},
auth=requests.auth.HTTPBasicAuth(username, password),
).prepare()
self.parse_api_pattern = re.compile(r"(?P<param>\w*) = (?P<value>.*);")
self.last_results = {"wldev": [], "dhcpd_lease": []}
self.success_init = self._update_tomato_info()
def scan_devices(self):
"""Scan for new devices and return a list with found device IDs."""
self._update_tomato_info()
return [item[1] for item in self.last_results["wldev"]]
def get_device_name(self, device):
"""Return the name of the given device or None if we don't know."""
filter_named = [
item[0] for item in self.last_results["dhcpd_lease"] if item[2] == device
]
if not filter_named or not filter_named[0]:
return None
return filter_named[0]
def _update_tomato_info(self):
"""Ensure the information from the Tomato router is up to date.
Return boolean if scanning successful.
"""
_LOGGER.info("Scanning")
try:
if self.ssl:
response = requests.Session().send(
self.req, timeout=3, verify=self.verify_ssl
)
else:
response = requests.Session().send(self.req, timeout=3)
# Calling and parsing the Tomato api here. We only need the
# wldev and dhcpd_lease values.
if response.status_code == HTTP_OK:
for param, value in self.parse_api_pattern.findall(response.text):
if param in ("wldev", "dhcpd_lease"):
self.last_results[param] = json.loads(value.replace("'", '"'))
return True
if response.status_code == HTTP_UNAUTHORIZED:
# Authentication error
_LOGGER.exception(
"Failed to authenticate, please check your username and password"
)
return False
except requests.exceptions.ConnectionError:
# We get this if we could not connect to the router or
# an invalid http_id was supplied.
_LOGGER.exception(
"Failed to connect to the router or invalid http_id supplied"
)
return False
except requests.exceptions.Timeout:
# We get this if we could not connect to the router or
# an invalid http_id was supplied.
_LOGGER.exception("Connection to the router timed out")
return False
except ValueError:
# If JSON decoder could not parse the response.
_LOGGER.exception("Failed to parse response from router")
return False
|
import logging
from typing import Dict, Union
import voluptuous as vol
from withings_api.common import AuthScope
from homeassistant import config_entries
from homeassistant.components.withings import const
from homeassistant.helpers import config_entry_oauth2_flow
from homeassistant.util import slugify
class WithingsFlowHandler(
config_entry_oauth2_flow.AbstractOAuth2FlowHandler, domain=const.DOMAIN
):
"""Handle a config flow."""
DOMAIN = const.DOMAIN
CONNECTION_CLASS = config_entries.CONN_CLASS_CLOUD_POLL
# Temporarily holds authorization data during the profile step.
_current_data: Dict[str, Union[None, str, int]] = {}
@property
def logger(self) -> logging.Logger:
"""Return logger."""
return logging.getLogger(__name__)
@property
def extra_authorize_data(self) -> dict:
"""Extra data that needs to be appended to the authorize url."""
return {
"scope": ",".join(
[
AuthScope.USER_INFO.value,
AuthScope.USER_METRICS.value,
AuthScope.USER_ACTIVITY.value,
AuthScope.USER_SLEEP_EVENTS.value,
]
)
}
async def async_oauth_create_entry(self, data: dict) -> dict:
"""Override the create entry so user can select a profile."""
self._current_data = data
return await self.async_step_profile(data)
async def async_step_profile(self, data: dict) -> dict:
"""Prompt the user to select a user profile."""
errors = {}
# pylint: disable=no-member # https://github.com/PyCQA/pylint/issues/3167
reauth_profile = (
self.context.get(const.PROFILE)
if self.context.get("source") == "reauth"
else None
)
profile = data.get(const.PROFILE) or reauth_profile
if profile:
existing_entries = [
config_entry
for config_entry in self.hass.config_entries.async_entries(const.DOMAIN)
if slugify(config_entry.data.get(const.PROFILE)) == slugify(profile)
]
if reauth_profile or not existing_entries:
new_data = {**self._current_data, **data, const.PROFILE: profile}
self._current_data = {}
return await self.async_step_finish(new_data)
errors["base"] = "already_configured"
return self.async_show_form(
step_id="profile",
data_schema=vol.Schema({vol.Required(const.PROFILE): str}),
errors=errors,
)
async def async_step_reauth(self, data: dict = None) -> dict:
"""Prompt user to re-authenticate."""
if data is not None:
return await self.async_step_user()
# pylint: disable=no-member # https://github.com/PyCQA/pylint/issues/3167
placeholders = {const.PROFILE: self.context["profile"]}
self.context.update({"title_placeholders": placeholders})
return self.async_show_form(
step_id="reauth",
# pylint: disable=no-member # https://github.com/PyCQA/pylint/issues/3167
description_placeholders=placeholders,
)
async def async_step_finish(self, data: dict) -> dict:
"""Finish the flow."""
self._current_data = {}
await self.async_set_unique_id(
str(data["token"]["userid"]), raise_on_progress=False
)
self._abort_if_unique_id_configured(data)
return self.async_create_entry(title=data[const.PROFILE], data=data)
|
import pytest
from homeassistant.components.NEW_DOMAIN import DOMAIN
import homeassistant.components.automation as automation
from homeassistant.const import STATE_OFF, STATE_ON
from homeassistant.helpers import device_registry
from homeassistant.setup import async_setup_component
from tests.common import (
MockConfigEntry,
assert_lists_same,
async_get_device_automations,
async_mock_service,
mock_device_registry,
mock_registry,
)
@pytest.fixture
def device_reg(hass):
"""Return an empty, loaded, registry."""
return mock_device_registry(hass)
@pytest.fixture
def entity_reg(hass):
"""Return an empty, loaded, registry."""
return mock_registry(hass)
@pytest.fixture
def calls(hass):
"""Track calls to a mock service."""
return async_mock_service(hass, "test", "automation")
async def test_get_triggers(hass, device_reg, entity_reg):
"""Test we get the expected triggers from a NEW_DOMAIN."""
config_entry = MockConfigEntry(domain="test", data={})
config_entry.add_to_hass(hass)
device_entry = device_reg.async_get_or_create(
config_entry_id=config_entry.entry_id,
connections={(device_registry.CONNECTION_NETWORK_MAC, "12:34:56:AB:CD:EF")},
)
entity_reg.async_get_or_create(DOMAIN, "test", "5678", device_id=device_entry.id)
expected_triggers = [
{
"platform": "device",
"domain": DOMAIN,
"type": "turned_off",
"device_id": device_entry.id,
"entity_id": f"{DOMAIN}.test_5678",
},
{
"platform": "device",
"domain": DOMAIN,
"type": "turned_on",
"device_id": device_entry.id,
"entity_id": f"{DOMAIN}.test_5678",
},
]
triggers = await async_get_device_automations(hass, "trigger", device_entry.id)
assert_lists_same(triggers, expected_triggers)
async def test_if_fires_on_state_change(hass, calls):
"""Test for turn_on and turn_off triggers firing."""
hass.states.async_set("NEW_DOMAIN.entity", STATE_OFF)
assert await async_setup_component(
hass,
automation.DOMAIN,
{
automation.DOMAIN: [
{
"trigger": {
"platform": "device",
"domain": DOMAIN,
"device_id": "",
"entity_id": "NEW_DOMAIN.entity",
"type": "turned_on",
},
"action": {
"service": "test.automation",
"data_template": {
"some": (
"turn_on - {{ trigger.platform}} - "
"{{ trigger.entity_id}} - {{ trigger.from_state.state}} - "
"{{ trigger.to_state.state}} - {{ trigger.for }}"
)
},
},
},
{
"trigger": {
"platform": "device",
"domain": DOMAIN,
"device_id": "",
"entity_id": "NEW_DOMAIN.entity",
"type": "turned_off",
},
"action": {
"service": "test.automation",
"data_template": {
"some": (
"turn_off - {{ trigger.platform}} - "
"{{ trigger.entity_id}} - {{ trigger.from_state.state}} - "
"{{ trigger.to_state.state}} - {{ trigger.for }}"
)
},
},
},
]
},
)
# Fake that the entity is turning on.
hass.states.async_set("NEW_DOMAIN.entity", STATE_ON)
await hass.async_block_till_done()
assert len(calls) == 1
assert calls[0].data["some"] == "turn_on - device - {} - off - on - None".format(
"NEW_DOMAIN.entity"
)
# Fake that the entity is turning off.
hass.states.async_set("NEW_DOMAIN.entity", STATE_OFF)
await hass.async_block_till_done()
assert len(calls) == 2
assert calls[1].data["some"] == "turn_off - device - {} - on - off - None".format(
"NEW_DOMAIN.entity"
)
|
from __future__ import print_function
import collections
import json
import re
import sys
def main():
if len(sys.argv) != 4:
print('usage: %s samples_file.json metric_name data_label' % sys.argv[0])
sys.exit(1)
latency_histogram_by_label = collections.defaultdict(
lambda: collections.defaultdict(int))
total_samples = collections.defaultdict(int)
with open(sys.argv[1]) as samples_file:
for line in samples_file:
sample = json.loads(line)
if sample['metric'] == sys.argv[2]:
labels = sample['labels']
regex = r'\|%s:(.*?)\|' % sys.argv[3]
label = re.search(regex, labels).group(1)
histogram = json.loads(
re.search(r'\|histogram:(.*?)\|', labels).group(1))
for bucket, count in histogram.iteritems():
latency_histogram_by_label[label][float(bucket)] += int(count)
total_samples[label] += int(count)
for label, histogram in latency_histogram_by_label.iteritems():
running_count = 0
for bucket in sorted(histogram):
running_count += histogram[bucket]
percentile = 100.0 * running_count / total_samples[label]
print(','.join((label, str(bucket), str(percentile))))
if __name__ == '__main__':
main()
|
from __future__ import unicode_literals
import hashlib
def md5_encode(item):
"""md5 message digest algorithm output 32 char"""
try:
return (hashlib.md5(item.encode("utf-8"))).hexdigest()
except:
return ''
|
from qstrader.broker.fee_model.zero_fee_model import ZeroFeeModel
class AssetMock(object):
def __init__(self):
pass
class BrokerMock(object):
def __init__(self):
pass
def test_commission_is_zero_uniformly():
"""
Tests that each method returns zero commission,
irrespective of asset, consideration or broker.
"""
zbc = ZeroFeeModel()
asset = AssetMock()
quantity = 100
consideration = 1000.0
broker = BrokerMock()
assert zbc._calc_commission(asset, quantity, consideration, broker=broker) == 0.0
assert zbc._calc_tax(asset, quantity, consideration, broker=broker) == 0.0
assert zbc.calc_total_cost(asset, quantity, consideration, broker=broker) == 0.0
|
from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import contextlib
import logging
import os
import platform
import posixpath
import random
import re
import string
import subprocess
import tempfile
import threading
import time
from absl import flags
import jinja2
from perfkitbenchmarker import background_tasks
from perfkitbenchmarker import data
from perfkitbenchmarker import errors
from perfkitbenchmarker import temp_dir
from six.moves import range
FLAGS = flags.FLAGS
PRIVATE_KEYFILE = 'perfkitbenchmarker_keyfile'
PUBLIC_KEYFILE = 'perfkitbenchmarker_keyfile.pub'
# The temporary directory on VMs. We cannot reuse GetTempDir()
# because run_uri will not be available at time of module load and we need
# to use this directory as a base for other module level constants.
VM_TMP_DIR = '/tmp/pkb'
# Default timeout for issuing a command.
DEFAULT_TIMEOUT = 300
# Defaults for retrying commands.
POLL_INTERVAL = 30
TIMEOUT = 1200
FUZZ = .5
MAX_RETRIES = -1
WINDOWS = 'nt'
DARWIN = 'Darwin'
PASSWORD_LENGTH = 15
OUTPUT_STDOUT = 0
OUTPUT_STDERR = 1
OUTPUT_EXIT_CODE = 2
_SIMULATE_MAINTENANCE_SEMAPHORE = threading.Semaphore(0)
flags.DEFINE_integer('default_timeout', TIMEOUT, 'The default timeout for '
'retryable commands in seconds.')
flags.DEFINE_integer('burn_cpu_seconds', 0,
'Amount of time in seconds to burn cpu on vm before '
'starting benchmark')
flags.DEFINE_integer('burn_cpu_threads', 1, 'Number of threads to use to '
'burn cpu before starting benchmark.')
flags.DEFINE_integer('background_cpu_threads', None,
'Number of threads of background cpu usage while '
'running a benchmark')
flags.DEFINE_integer('background_network_mbits_per_sec', None,
'Number of megabits per second of background '
'network traffic to generate during the run phase '
'of the benchmark')
flags.DEFINE_boolean('simulate_maintenance', False,
'Whether to simulate VM maintenance during the benchmark. '
'This requires both benchmark and provider support.')
flags.DEFINE_integer('simulate_maintenance_delay', 0,
'The number of seconds to wait to start simulating '
'maintenance.')
flags.DEFINE_boolean('ssh_reuse_connections', True,
'Whether to reuse SSH connections rather than '
'reestablishing a connection for each remote command.')
# We set this to the short value of 5 seconds so that the cluster boot benchmark
# can measure a fast connection when bringing up a VM. This avoids retries that
# may not be as quick as every 5 seconds when specifying a larger value.
flags.DEFINE_integer('ssh_connect_timeout', 5, 'timeout for SSH connection.',
lower_bound=0)
flags.DEFINE_string('ssh_control_path', None,
'Overrides the default ControlPath setting for ssh '
'connections if --ssh_reuse_connections is set. This can '
'be helpful on systems whose default temporary directory '
'path is too long (sockets have a max path length) or a '
'version of ssh that doesn\'t support the %h token. See '
'ssh documentation on the ControlPath setting for more '
'detailed information.')
flags.DEFINE_string('ssh_control_persist', '30m',
'Setting applied to ssh connections if '
'--ssh_reuse_connections is set. Sets how long the '
'connections persist before they are removed. '
'See ssh documentation about the ControlPersist setting '
'for more detailed information.')
flags.DEFINE_integer('ssh_server_alive_interval', 30,
'Value for ssh -o ServerAliveInterval. Use with '
'--ssh_server_alive_count_max to configure how long to '
'wait for unresponsive servers.')
flags.DEFINE_integer('ssh_server_alive_count_max', 10,
'Value for ssh -o ServerAliveCountMax. Use with '
'--ssh_server_alive_interval to configure how long to '
'wait for unresponsive servers.')
class IpAddressSubset(object):
"""Enum of options for --ip_addresses."""
REACHABLE = 'REACHABLE'
BOTH = 'BOTH'
INTERNAL = 'INTERNAL'
EXTERNAL = 'EXTERNAL'
ALL = (REACHABLE, BOTH, INTERNAL, EXTERNAL)
flags.DEFINE_enum('ip_addresses', IpAddressSubset.REACHABLE,
IpAddressSubset.ALL,
'For networking tests: use both internal and external '
'IP addresses (BOTH), internal and external only if '
'the receiving VM is reachable by internal IP (REACHABLE), '
'external IP only (EXTERNAL) or internal IP only (INTERNAL)')
flags.DEFINE_enum('background_network_ip_type', IpAddressSubset.EXTERNAL,
(IpAddressSubset.INTERNAL, IpAddressSubset.EXTERNAL),
'IP address type to use when generating background network '
'traffic')
class IpAddressMetadata(object):
INTERNAL = 'internal'
EXTERNAL = 'external'
def GetTempDir():
"""Returns the tmp dir of the current run."""
return temp_dir.GetRunDirPath()
def PrependTempDir(file_name):
"""Returns the file name prepended with the tmp dir of the current run."""
return os.path.join(GetTempDir(), file_name)
def GenTempDir():
"""Creates the tmp dir for the current run if it does not already exist."""
temp_dir.CreateTemporaryDirectories()
def SSHKeyGen():
"""Create PerfKitBenchmarker SSH keys in the tmp dir of the current run."""
if not os.path.isdir(GetTempDir()):
GenTempDir()
if not os.path.isfile(GetPrivateKeyPath()):
create_cmd = ['ssh-keygen',
'-t', 'rsa',
'-N', '',
'-m', 'PEM',
'-q',
'-f', PrependTempDir(PRIVATE_KEYFILE)]
IssueCommand(create_cmd)
def GetPrivateKeyPath():
return PrependTempDir(PRIVATE_KEYFILE)
def GetPublicKeyPath():
return PrependTempDir(PUBLIC_KEYFILE)
def GetSshOptions(ssh_key_filename, connect_timeout=None):
"""Return common set of SSH and SCP options."""
options = [
'-2',
'-o', 'UserKnownHostsFile=/dev/null',
'-o', 'StrictHostKeyChecking=no',
'-o', 'IdentitiesOnly=yes',
'-o', 'PreferredAuthentications=publickey',
'-o', 'PasswordAuthentication=no',
'-o', 'ConnectTimeout=%d' % (
connect_timeout or FLAGS.ssh_connect_timeout),
'-o', 'GSSAPIAuthentication=no',
'-o', 'ServerAliveInterval=%d' % FLAGS.ssh_server_alive_interval,
'-o', 'ServerAliveCountMax=%d' % FLAGS.ssh_server_alive_count_max,
'-i', ssh_key_filename
]
if FLAGS.use_ipv6:
options.append('-6')
if FLAGS.ssh_reuse_connections:
control_path = (FLAGS.ssh_control_path or
os.path.join(temp_dir.GetSshConnectionsDir(), '%h'))
options.extend([
'-o', 'ControlPath="%s"' % control_path,
'-o', 'ControlMaster=auto',
'-o', 'ControlPersist=%s' % FLAGS.ssh_control_persist
])
options.extend(FLAGS.ssh_options)
return options
# TODO(skschneider): Remove at least RunParallelProcesses and RunParallelThreads
# from this file (update references to call directly into background_tasks).
RunParallelProcesses = background_tasks.RunParallelProcesses
RunParallelThreads = background_tasks.RunParallelThreads
RunThreaded = background_tasks.RunThreaded
def Retry(poll_interval=POLL_INTERVAL, max_retries=MAX_RETRIES,
timeout=None, fuzz=FUZZ, log_errors=True,
retryable_exceptions=None):
"""A function decorator that will retry when exceptions are thrown.
Args:
poll_interval: The time between tries in seconds. This is the maximum poll
interval when fuzz is specified.
max_retries: The maximum number of retries before giving up. If -1, this
means continue until the timeout is reached. The function will stop
retrying when either max_retries is met or timeout is reached.
timeout: The timeout for all tries in seconds. If -1, this means continue
until max_retries is met. The function will stop retrying when either
max_retries is met or timeout is reached.
fuzz: The amount of randomness in the sleep time. This is used to
keep threads from all retrying at the same time. At 0, this
means sleep exactly poll_interval seconds. At 1, this means
sleep anywhere from 0 to poll_interval seconds.
log_errors: A boolean describing whether errors should be logged.
retryable_exceptions: A tuple of exceptions that should be retried. By
default, this is None, which indicates that all exceptions should
be retried.
Returns:
A function that wraps functions in retry logic. It can be
used as a decorator.
"""
if retryable_exceptions is None:
retryable_exceptions = Exception
def Wrap(f):
"""Wraps the supplied function with retry logic."""
def WrappedFunction(*args, **kwargs):
"""Holds the retry logic."""
local_timeout = FLAGS.default_timeout if timeout is None else timeout
if local_timeout >= 0:
deadline = time.time() + local_timeout
else:
deadline = float('inf')
tries = 0
while True:
try:
tries += 1
return f(*args, **kwargs)
except retryable_exceptions as e:
fuzz_multiplier = 1 - fuzz + random.random() * fuzz
sleep_time = poll_interval * fuzz_multiplier
if ((time.time() + sleep_time) >= deadline or
(max_retries >= 0 and tries > max_retries)):
raise
else:
if log_errors:
logging.info('Retrying exception running %s: %s', f.__name__, e)
time.sleep(sleep_time)
return WrappedFunction
return Wrap
class _BoxedObject(object):
"""Box a value in a reference so it is modifiable inside an inner function.
In python3 the nonlocal keyword could be used instead - but for python2
there is no support for modifying an external scoped variable value.
"""
def __init__(self, initial_value):
self.value = initial_value
def _ReadIssueCommandOutput(tf_out, tf_err):
"""Reads IssueCommand Output from stdout and stderr."""
tf_out.seek(0)
stdout = tf_out.read().decode('ascii', 'ignore')
tf_err.seek(0)
stderr = tf_err.read().decode('ascii', 'ignore')
return stdout, stderr
def IssueCommand(cmd, force_info_log=False, suppress_warning=False,
env=None, timeout=DEFAULT_TIMEOUT, cwd=None,
raise_on_failure=True, suppress_failure=None,
raise_on_timeout=True):
"""Tries running the provided command once.
Args:
cmd: A list of strings such as is given to the subprocess.Popen()
constructor.
force_info_log: A boolean indicating whether the command result should
always be logged at the info level. Command results will always be
logged at the debug level if they aren't logged at another level.
suppress_warning: A boolean indicating whether the results should
not be logged at the info level in the event of a non-zero
return code. When force_info_log is True, the output is logged
regardless of suppress_warning's value.
env: A dict of key/value strings, such as is given to the subprocess.Popen()
constructor, that contains environment variables to be injected.
timeout: Timeout for the command in seconds. If the command has not finished
before the timeout is reached, it will be killed. Set timeout to None to
let the command run indefinitely. If the subprocess is killed, the
return code will indicate an error, and stdout and stderr will
contain what had already been written to them before the process was
killed.
cwd: Directory in which to execute the command.
raise_on_failure: A boolean indicating if non-zero return codes should raise
IssueCommandError.
suppress_failure: A function passed (stdout, stderr, ret_code) for non-zero
return codes to determine if the failure should be suppressed e.g. a
delete command which fails because the item to be deleted does not
exist.
raise_on_timeout: A boolean indicating if killing the process due to the
timeout being hit should raise a IssueCommandTimeoutError
Returns:
A tuple of stdout, stderr, and retcode from running the provided command.
Raises:
IssueCommandError: When raise_on_failure=True and retcode is non-zero.
IssueCommandTimeoutError: When raise_on_timeout=True and
command duration exceeds timeout
"""
if env:
logging.debug('Environment variables: %s', env)
# Force conversion to string so you get a nice log statement before hitting a
# type error or NPE. subprocess will still catch it.
full_cmd = ' '.join(str(w) for w in cmd)
logging.info('Running: %s', full_cmd)
time_file_path = '/usr/bin/time'
running_on_windows = RunningOnWindows()
running_on_darwin = RunningOnDarwin()
should_time = (not (running_on_windows or running_on_darwin) and
os.path.isfile(time_file_path) and FLAGS.time_commands)
shell_value = running_on_windows
with tempfile.TemporaryFile() as tf_out, \
tempfile.TemporaryFile() as tf_err, \
tempfile.NamedTemporaryFile(mode='r') as tf_timing:
cmd_to_use = cmd
if should_time:
cmd_to_use = [time_file_path,
'-o', tf_timing.name,
'--quiet',
'-f', ', WallTime:%Es, CPU:%Us, MaxMemory:%Mkb '] + cmd
process = subprocess.Popen(cmd_to_use, env=env, shell=shell_value,
stdin=subprocess.PIPE, stdout=tf_out,
stderr=tf_err, cwd=cwd)
did_timeout = _BoxedObject(False)
was_killed = _BoxedObject(False)
def _KillProcess():
did_timeout.value = True
if not raise_on_timeout:
logging.warning('IssueCommand timed out after %d seconds. '
'Killing command "%s".', timeout, full_cmd)
process.kill()
was_killed.value = True
timer = threading.Timer(timeout, _KillProcess)
timer.start()
try:
process.wait()
finally:
timer.cancel()
stdout, stderr = _ReadIssueCommandOutput(tf_out, tf_err)
timing_output = ''
if should_time:
timing_output = tf_timing.read().rstrip('\n')
debug_text = ('Ran: {%s}\nReturnCode:%s%s\nSTDOUT: %s\nSTDERR: %s' %
(full_cmd, process.returncode, timing_output, stdout, stderr))
if force_info_log or (process.returncode and not suppress_warning):
logging.info(debug_text)
else:
logging.debug(debug_text)
# Raise timeout error regardless of raise_on_failure - as the intended
# semantics is to ignore expected errors caused by invoking the command
# not errors from PKB infrastructure.
if did_timeout.value and raise_on_timeout:
debug_text = (
'{0}\nIssueCommand timed out after {1} seconds. '
'{2} by perfkitbenchmarker.'.format(
debug_text, timeout,
'Process was killed' if was_killed.value else
'Process may have been killed'))
raise errors.VmUtil.IssueCommandTimeoutError(debug_text)
elif process.returncode and (raise_on_failure or suppress_failure):
if (suppress_failure and
suppress_failure(stdout, stderr, process.returncode)):
# failure is suppressible, rewrite the stderr and return code as passing
# since some callers assume either is a failure e.g.
# perfkitbenchmarker.providers.aws.util.IssueRetryableCommand()
return stdout, '', 0
raise errors.VmUtil.IssueCommandError(debug_text)
return stdout, stderr, process.returncode
def IssueBackgroundCommand(cmd, stdout_path, stderr_path, env=None):
"""Run the provided command once in the background.
Args:
cmd: Command to be run, as expected by subprocess.Popen.
stdout_path: Redirect stdout here. Overwritten.
stderr_path: Redirect stderr here. Overwritten.
env: A dict of key/value strings, such as is given to the subprocess.Popen()
constructor, that contains environment variables to be injected.
"""
logging.debug('Environment variables: %s', env)
full_cmd = ' '.join(cmd)
logging.info('Spawning: %s', full_cmd)
outfile = open(stdout_path, 'w')
errfile = open(stderr_path, 'w')
shell_value = RunningOnWindows()
subprocess.Popen(cmd, env=env, shell=shell_value,
stdout=outfile, stderr=errfile, close_fds=True)
@Retry()
def IssueRetryableCommand(cmd, env=None):
"""Tries running the provided command until it succeeds or times out.
Args:
cmd: A list of strings such as is given to the subprocess.Popen()
constructor.
env: An alternate environment to pass to the Popen command.
Returns:
A tuple of stdout and stderr from running the provided command.
"""
stdout, stderr, retcode = IssueCommand(cmd, env=env, raise_on_failure=False)
if retcode:
debug_text = ('Ran: {%s}\nReturnCode:%s\nSTDOUT: %s\nSTDERR: %s' %
(' '.join(cmd), retcode, stdout, stderr))
raise errors.VmUtil.CalledProcessException(
'Command returned a non-zero exit code:\n{}'.format(debug_text))
return stdout, stderr
def ParseTimeCommandResult(command_result):
"""Parse command result and get time elapsed.
Note this parses the output of bash's time builtin, not /usr/bin/time or other
implementations. You may need to run something like bash -c "time ./command"
to produce parseable output.
Args:
command_result: The result after executing a remote time command.
Returns:
Time taken for the command.
"""
time_data = re.findall(r'real\s+(\d+)m(\d+.\d+)', command_result)
time_in_seconds = 60 * float(time_data[0][0]) + float(time_data[0][1])
return time_in_seconds
def ShouldRunOnExternalIpAddress(ip_type=None):
"""Returns whether a test should be run on an instance's external IP."""
ip_type_to_check = ip_type or FLAGS.ip_addresses
return ip_type_to_check in (IpAddressSubset.EXTERNAL, IpAddressSubset.BOTH,
IpAddressSubset.REACHABLE)
def ShouldRunOnInternalIpAddress(sending_vm, receiving_vm, ip_type=None):
"""Returns whether a test should be run on an instance's internal IP.
Based on the command line flag --ip_addresses. Internal IP addresses are used
when:
* --ip_addresses=BOTH or --ip-addresses=INTERNAL
* --ip_addresses=REACHABLE and 'sending_vm' can ping 'receiving_vm' on its
internal IP.
Args:
sending_vm: VirtualMachine. The client.
receiving_vm: VirtualMachine. The server.
ip_type: optional ip_type to use instead of what is set in the FLAGS
Returns:
Whether a test should be run on an instance's internal IP.
"""
ip_type_to_check = ip_type or FLAGS.ip_addresses
return (ip_type_to_check in (IpAddressSubset.BOTH, IpAddressSubset.INTERNAL)
or (ip_type_to_check == IpAddressSubset.REACHABLE and
sending_vm.IsReachable(receiving_vm)))
def GetLastRunUri():
"""Returns the last run_uri used (or None if it can't be determined)."""
runs_dir_path = temp_dir.GetAllRunsDirPath()
try:
dir_names = next(os.walk(runs_dir_path))[1]
except StopIteration:
# The runs directory was not found.
return None
if not dir_names:
# No run subdirectories were found in the runs directory.
return None
# Return the subdirectory with the most recent modification time.
return max(dir_names,
key=lambda d: os.path.getmtime(os.path.join(runs_dir_path, d)))
@contextlib.contextmanager
def NamedTemporaryFile(mode='w+b', prefix='tmp', suffix='', dir=None,
delete=True):
"""Behaves like tempfile.NamedTemporaryFile.
The existing tempfile.NamedTemporaryFile has the annoying property on
Windows that it cannot be opened a second time while it is already open.
This makes it impossible to use it with a "with" statement in a cross platform
compatible way. This serves a similar role, but allows the file to be closed
within a "with" statement without causing the file to be unlinked until the
context exits.
Args:
mode: see mode in tempfile.NamedTemporaryFile.
prefix: see prefix in tempfile.NamedTemporaryFile.
suffix: see suffix in tempfile.NamedTemporaryFile.
dir: see dir in tempfile.NamedTemporaryFile.
delete: see delete in NamedTemporaryFile.
Yields:
A cross platform file-like object which is "with" compatible.
"""
f = tempfile.NamedTemporaryFile(mode=mode, prefix=prefix, suffix=suffix,
dir=dir, delete=False)
try:
yield f
finally:
if not f.closed:
f.close()
if delete:
os.unlink(f.name)
def GenerateSSHConfig(vms, vm_groups):
"""Generates an SSH config file to simplify connecting to the specified VMs.
Writes a file to GetTempDir()/ssh_config with an SSH configuration for each VM
provided in the arguments. Users can then SSH with any of the following:
ssh -F <ssh_config_path> <vm_name>
ssh -F <ssh_config_path> vm<vm_index>
ssh -F <ssh_config_path> <group_name>-<index>
Args:
vms: list of BaseVirtualMachines.
vm_groups: dict mapping VM group name string to list of BaseVirtualMachines.
"""
target_file = os.path.join(GetTempDir(), 'ssh_config')
template_path = data.ResourcePath('ssh_config.j2')
environment = jinja2.Environment(undefined=jinja2.StrictUndefined)
with open(template_path) as fp:
template = environment.from_string(fp.read())
with open(target_file, 'w') as ofp:
ofp.write(template.render({'vms': vms, 'vm_groups': vm_groups}))
ssh_options = [' ssh -F {0} {1}'.format(target_file, pattern)
for pattern in ('<vm_name>', 'vm<index>',
'<group_name>-<index>')]
logging.info('ssh to VMs in this benchmark by name with:\n%s',
'\n'.join(ssh_options))
def RunningOnWindows():
"""Returns True if PKB is running on Windows."""
return os.name == WINDOWS
def RunningOnDarwin():
"""Returns True if PKB is running on a Darwin OS machine."""
return os.name != WINDOWS and platform.system() == DARWIN
def ExecutableOnPath(executable_name):
"""Return True if the given executable can be found on the path."""
cmd = ['where'] if RunningOnWindows() else ['which']
cmd.append(executable_name)
shell_value = RunningOnWindows()
process = subprocess.Popen(cmd,
shell=shell_value,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
process.communicate()
if process.returncode:
return False
return True
def GenerateRandomWindowsPassword(password_length=PASSWORD_LENGTH):
"""Generates a password that meets Windows complexity requirements."""
# The special characters have to be recognized by the Azure CLI as
# special characters. This greatly limits the set of characters
# that we can safely use. See
# https://github.com/Azure/azure-xplat-cli/blob/master/lib/commands/arm/vm/vmOsProfile._js#L145
special_chars = '*!@#$%+='
# Ensure that the password contains at least one of each 4 required
# character types starting with letters to avoid starting with chars which
# are problematic on the command line e.g. @.
prefix = [random.choice(string.ascii_lowercase),
random.choice(string.ascii_uppercase),
random.choice(string.digits),
random.choice(special_chars)]
password = [
random.choice(string.ascii_letters + string.digits + special_chars)
for _ in range(password_length - 4)]
return ''.join(prefix + password)
def StartSimulatedMaintenance():
"""Initiates the simulated maintenance event."""
if FLAGS.simulate_maintenance:
_SIMULATE_MAINTENANCE_SEMAPHORE.release()
def SetupSimulatedMaintenance(vm):
"""Called ready VM for simulated maintenance."""
if FLAGS.simulate_maintenance:
def _SimulateMaintenance():
_SIMULATE_MAINTENANCE_SEMAPHORE.acquire()
time.sleep(FLAGS.simulate_maintenance_delay)
vm.SimulateMaintenanceEvent()
t = threading.Thread(target=_SimulateMaintenance)
t.daemon = True
t.start()
def CopyFileBetweenVms(filename, src_vm, src_path, dest_vm, dest_path):
"""Copies a file from the src_vm to the dest_vm."""
with tempfile.NamedTemporaryFile() as tf:
temp_path = tf.name
src_vm.RemoteCopy(
temp_path, os.path.join(src_path, filename), copy_to=False)
dest_vm.RemoteCopy(
temp_path, os.path.join(dest_path, filename), copy_to=True)
def ReplaceText(vm, current_value, new_value, file_name, regex_char='/'):
"""Replaces text <current_value> with <new_value> in remote <file_name>."""
vm.RemoteCommand('sed -i -r "s{regex_char}{current_value}{regex_char}'
'{new_value}{regex_char}" {file}'.format(
regex_char=regex_char,
current_value=current_value,
new_value=new_value,
file=file_name))
def DictionaryToEnvString(dictionary, joiner=' '):
"""Convert a dictionary to a space sperated 'key=value' string.
Args:
dictionary: the key-value dictionary to be convert
joiner: string to separate the entries in the returned value.
Returns:
a string representing the dictionary
"""
return joiner.join(
f'{key}={value}' for key, value in sorted(dictionary.items()))
def CreateRemoteFile(vm, file_contents, file_path):
"""Creates a file on the remote server."""
with NamedTemporaryFile(mode='w') as tf:
tf.write(file_contents)
tf.close()
parent_dir = posixpath.dirname(file_path)
vm.RemoteCommand(f'[ -d {parent_dir} ] || mkdir -p {parent_dir}')
vm.PushFile(tf.name, file_path)
|
import logging
import re
import pexpect
import voluptuous as vol
from homeassistant.components.device_tracker import (
DOMAIN,
PLATFORM_SCHEMA,
DeviceScanner,
)
from homeassistant.const import CONF_HOST, CONF_PASSWORD, CONF_USERNAME
import homeassistant.helpers.config_validation as cv
_LOGGER = logging.getLogger(__name__)
_DEVICES_REGEX = re.compile(
r"(?P<name>([^\s]+)?)\s+"
+ r"(?P<ip>([0-9]{1,3}[\.]){3}[0-9]{1,3})\s+"
+ r"(?P<mac>([0-9a-f]{2}[:-]){5}([0-9a-f]{2}))\s+"
)
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
{
vol.Required(CONF_HOST): cv.string,
vol.Required(CONF_PASSWORD): cv.string,
vol.Required(CONF_USERNAME): cv.string,
}
)
def get_scanner(hass, config):
"""Validate the configuration and return a Aruba scanner."""
scanner = ArubaDeviceScanner(config[DOMAIN])
return scanner if scanner.success_init else None
class ArubaDeviceScanner(DeviceScanner):
"""This class queries a Aruba Access Point for connected devices."""
def __init__(self, config):
"""Initialize the scanner."""
self.host = config[CONF_HOST]
self.username = config[CONF_USERNAME]
self.password = config[CONF_PASSWORD]
self.last_results = {}
# Test the router is accessible.
data = self.get_aruba_data()
self.success_init = data is not None
def scan_devices(self):
"""Scan for new devices and return a list with found device IDs."""
self._update_info()
return [client["mac"] for client in self.last_results]
def get_device_name(self, device):
"""Return the name of the given device or None if we don't know."""
if not self.last_results:
return None
for client in self.last_results:
if client["mac"] == device:
return client["name"]
return None
def _update_info(self):
"""Ensure the information from the Aruba Access Point is up to date.
Return boolean if scanning successful.
"""
if not self.success_init:
return False
data = self.get_aruba_data()
if not data:
return False
self.last_results = data.values()
return True
def get_aruba_data(self):
"""Retrieve data from Aruba Access Point and return parsed result."""
connect = f"ssh {self.username}@{self.host}"
ssh = pexpect.spawn(connect)
query = ssh.expect(
[
"password:",
pexpect.TIMEOUT,
pexpect.EOF,
"continue connecting (yes/no)?",
"Host key verification failed.",
"Connection refused",
"Connection timed out",
],
timeout=120,
)
if query == 1:
_LOGGER.error("Timeout")
return
if query == 2:
_LOGGER.error("Unexpected response from router")
return
if query == 3:
ssh.sendline("yes")
ssh.expect("password:")
elif query == 4:
_LOGGER.error("Host key changed")
return
elif query == 5:
_LOGGER.error("Connection refused by server")
return
elif query == 6:
_LOGGER.error("Connection timed out")
return
ssh.sendline(self.password)
ssh.expect("#")
ssh.sendline("show clients")
ssh.expect("#")
devices_result = ssh.before.split(b"\r\n")
ssh.sendline("exit")
devices = {}
for device in devices_result:
match = _DEVICES_REGEX.search(device.decode("utf-8"))
if match:
devices[match.group("ip")] = {
"ip": match.group("ip"),
"mac": match.group("mac").upper(),
"name": match.group("name"),
}
return devices
|
from test import unittest
from test import run_only
from mock import Mock
from mock import patch
import configobj
import diamond.handler.riemann as mod
from diamond.metric import Metric
try:
from riemann_client.client import Client
riemann_client = True
except ImportError:
riemann_client = None
def run_only_if_riemann_client_is_available(func):
def pred():
return riemann_client is not None
return run_only(func, pred)
def fake_connect(self):
# used for 'we can connect' tests
self.transport = Mock()
class TestRiemannHandler(unittest.TestCase):
def setUp(self):
self.__connect_method = mod.RiemannHandler
mod.RiemannHandler._connect = fake_connect
def tearDown(self):
# restore the override
mod.RiemannHandler._connect = self.__connect_method
@run_only_if_riemann_client_is_available
@patch('riemann_client.transport.TCPTransport.connect', Mock())
@patch('riemann_client.client.Client.send_event', Mock())
def test_metric_to_riemann_event(self):
config = configobj.ConfigObj()
config['host'] = 'localhost'
config['port'] = 5555
handler = mod.RiemannHandler(config)
metric = Metric('servers.com.example.www.cpu.total.idle',
0,
timestamp=1234567,
host='com.example.www')
handler.process(metric)
for call in handler.client.send_event.mock_calls:
event = Client.create_dict(call[1][0])
self.assertEqual(event, {
'host': u'com.example.www',
'service': u'servers.cpu.total.idle',
'time': 1234567L,
'metric_f': 0.0,
})
##########################################################################
if __name__ == "__main__":
unittest.main()
|
import os
import os.path
import pytest
from coverage import files
from coverage.files import (
TreeMatcher, FnmatchMatcher, ModuleMatcher, PathAliases,
find_python_files, abs_file, actual_path, flat_rootname, fnmatches_to_regex,
)
from coverage.misc import CoverageException
from coverage import env
from tests.coveragetest import CoverageTest
class FilesTest(CoverageTest):
"""Tests of coverage.files."""
def abs_path(self, p):
"""Return the absolute path for `p`."""
return os.path.join(abs_file(os.getcwd()), os.path.normpath(p))
def test_simple(self):
self.make_file("hello.py")
files.set_relative_directory()
self.assertEqual(files.relative_filename(u"hello.py"), u"hello.py")
a = self.abs_path("hello.py")
self.assertNotEqual(a, "hello.py")
self.assertEqual(files.relative_filename(a), "hello.py")
def test_peer_directories(self):
self.make_file("sub/proj1/file1.py")
self.make_file("sub/proj2/file2.py")
a1 = self.abs_path("sub/proj1/file1.py")
a2 = self.abs_path("sub/proj2/file2.py")
d = os.path.normpath("sub/proj1")
self.chdir(d)
files.set_relative_directory()
self.assertEqual(files.relative_filename(a1), "file1.py")
self.assertEqual(files.relative_filename(a2), a2)
def test_filepath_contains_absolute_prefix_twice(self):
# https://github.com/nedbat/coveragepy/issues/194
# Build a path that has two pieces matching the absolute path prefix.
# Technically, this test doesn't do that on Windows, but drive
# letters make that impractical to achieve.
files.set_relative_directory()
d = abs_file(os.curdir)
trick = os.path.splitdrive(d)[1].lstrip(os.path.sep)
rel = os.path.join('sub', trick, 'file1.py')
self.assertEqual(files.relative_filename(abs_file(rel)), rel)
def test_canonical_filename_ensure_cache_hit(self):
self.make_file("sub/proj1/file1.py")
d = actual_path(self.abs_path("sub/proj1"))
self.chdir(d)
files.set_relative_directory()
canonical_path = files.canonical_filename('sub/proj1/file1.py')
self.assertEqual(canonical_path, self.abs_path('file1.py'))
# After the filename has been converted, it should be in the cache.
self.assertIn('sub/proj1/file1.py', files.CANONICAL_FILENAME_CACHE)
self.assertEqual(
files.canonical_filename('sub/proj1/file1.py'),
self.abs_path('file1.py'))
@pytest.mark.parametrize("original, flat", [
(u"a/b/c.py", u"a_b_c_py"),
(u"c:\\foo\\bar.html", u"_foo_bar_html"),
(u"Montréal/☺/conf.py", u"Montréal_☺_conf_py"),
( # original:
u"c:\\lorem\\ipsum\\quia\\dolor\\sit\\amet\\consectetur\\adipisci\\velit\\sed\\quia\\non"
u"\\numquam\\eius\\modi\\tempora\\incidunt\\ut\\labore\\et\\dolore\\magnam\\aliquam"
u"\\quaerat\\voluptatem\\ut\\enim\\ad\\minima\\veniam\\quis\\nostrum\\exercitationem"
u"\\ullam\\corporis\\suscipit\\laboriosam\\Montréal\\☺\\my_program.py",
# flat:
u"re_et_dolore_magnam_aliquam_quaerat_voluptatem_ut_enim_ad_minima_veniam_quis_"
u"nostrum_exercitationem_ullam_corporis_suscipit_laboriosam_Montréal_☺_my_program_py_"
u"97eaca41b860faaa1a21349b1f3009bb061cf0a8"
),
])
def test_flat_rootname(original, flat):
assert flat_rootname(original) == flat
@pytest.mark.parametrize(
"patterns, case_insensitive, partial,"
"matches,"
"nomatches",
[
(
["abc", "xyz"], False, False,
["abc", "xyz"],
["ABC", "xYz", "abcx", "xabc", "axyz", "xyza"],
),
(
["abc", "xyz"], True, False,
["abc", "xyz", "Abc", "XYZ", "AbC"],
["abcx", "xabc", "axyz", "xyza"],
),
(
["abc/hi.py"], True, False,
["abc/hi.py", "ABC/hi.py", r"ABC\hi.py"],
["abc_hi.py", "abc/hi.pyc"],
),
(
[r"abc\hi.py"], True, False,
[r"abc\hi.py", r"ABC\hi.py"],
["abc/hi.py", "ABC/hi.py", "abc_hi.py", "abc/hi.pyc"],
),
(
["abc/*/hi.py"], True, False,
["abc/foo/hi.py", "ABC/foo/bar/hi.py", r"ABC\foo/bar/hi.py"],
["abc/hi.py", "abc/hi.pyc"],
),
(
["abc/[a-f]*/hi.py"], True, False,
["abc/foo/hi.py", "ABC/foo/bar/hi.py", r"ABC\foo/bar/hi.py"],
["abc/zoo/hi.py", "abc/hi.py", "abc/hi.pyc"],
),
(
["abc/"], True, True,
["abc/foo/hi.py", "ABC/foo/bar/hi.py", r"ABC\foo/bar/hi.py"],
["abcd/foo.py", "xabc/hi.py"],
),
])
def test_fnmatches_to_regex(patterns, case_insensitive, partial, matches, nomatches):
regex = fnmatches_to_regex(patterns, case_insensitive=case_insensitive, partial=partial)
for s in matches:
assert regex.match(s)
for s in nomatches:
assert not regex.match(s)
class MatcherTest(CoverageTest):
"""Tests of file matchers."""
def setUp(self):
super(MatcherTest, self).setUp()
files.set_relative_directory()
def assertMatches(self, matcher, filepath, matches):
"""The `matcher` should agree with `matches` about `filepath`."""
canonical = files.canonical_filename(filepath)
self.assertEqual(
matcher.match(canonical), matches,
"File %s should have matched as %s" % (filepath, matches)
)
def test_tree_matcher(self):
matches_to_try = [
(self.make_file("sub/file1.py"), True),
(self.make_file("sub/file2.c"), True),
(self.make_file("sub2/file3.h"), False),
(self.make_file("sub3/file4.py"), True),
(self.make_file("sub3/file5.c"), False),
]
trees = [
files.canonical_filename("sub"),
files.canonical_filename("sub3/file4.py"),
]
tm = TreeMatcher(trees)
self.assertEqual(tm.info(), trees)
for filepath, matches in matches_to_try:
self.assertMatches(tm, filepath, matches)
def test_module_matcher(self):
matches_to_try = [
('test', True),
('trash', False),
('testing', False),
('test.x', True),
('test.x.y.z', True),
('py', False),
('py.t', False),
('py.test', True),
('py.testing', False),
('py.test.buz', True),
('py.test.buz.baz', True),
('__main__', False),
('mymain', True),
('yourmain', False),
]
modules = ['test', 'py.test', 'mymain']
mm = ModuleMatcher(modules)
self.assertEqual(
mm.info(),
modules
)
for modulename, matches in matches_to_try:
self.assertEqual(
mm.match(modulename),
matches,
modulename,
)
def test_fnmatch_matcher(self):
matches_to_try = [
(self.make_file("sub/file1.py"), True),
(self.make_file("sub/file2.c"), False),
(self.make_file("sub2/file3.h"), True),
(self.make_file("sub3/file4.py"), True),
(self.make_file("sub3/file5.c"), False),
]
fnm = FnmatchMatcher(["*.py", "*/sub2/*"])
self.assertEqual(fnm.info(), ["*.py", "*/sub2/*"])
for filepath, matches in matches_to_try:
self.assertMatches(fnm, filepath, matches)
def test_fnmatch_matcher_overload(self):
fnm = FnmatchMatcher(["*x%03d*.txt" % i for i in range(500)])
self.assertMatches(fnm, "x007foo.txt", True)
self.assertMatches(fnm, "x123foo.txt", True)
self.assertMatches(fnm, "x798bar.txt", False)
def test_fnmatch_windows_paths(self):
# We should be able to match Windows paths even if we are running on
# a non-Windows OS.
fnm = FnmatchMatcher(["*/foo.py"])
self.assertMatches(fnm, r"dir\foo.py", True)
fnm = FnmatchMatcher([r"*\foo.py"])
self.assertMatches(fnm, r"dir\foo.py", True)
class PathAliasesTest(CoverageTest):
"""Tests for coverage/files.py:PathAliases"""
run_in_temp_dir = False
def assert_mapped(self, aliases, inp, out):
"""Assert that `inp` mapped through `aliases` produces `out`.
`out` is canonicalized first, since aliases always produce
canonicalized paths.
"""
aliases.pprint()
print(inp)
print(out)
self.assertEqual(aliases.map(inp), files.canonical_filename(out))
def assert_unchanged(self, aliases, inp):
"""Assert that `inp` mapped through `aliases` is unchanged."""
self.assertEqual(aliases.map(inp), inp)
def test_noop(self):
aliases = PathAliases()
self.assert_unchanged(aliases, '/ned/home/a.py')
def test_nomatch(self):
aliases = PathAliases()
aliases.add('/home/*/src', './mysrc')
self.assert_unchanged(aliases, '/home/foo/a.py')
def test_wildcard(self):
aliases = PathAliases()
aliases.add('/ned/home/*/src', './mysrc')
self.assert_mapped(aliases, '/ned/home/foo/src/a.py', './mysrc/a.py')
aliases = PathAliases()
aliases.add('/ned/home/*/src/', './mysrc')
self.assert_mapped(aliases, '/ned/home/foo/src/a.py', './mysrc/a.py')
def test_no_accidental_match(self):
aliases = PathAliases()
aliases.add('/home/*/src', './mysrc')
self.assert_unchanged(aliases, '/home/foo/srcetc')
def test_multiple_patterns(self):
aliases = PathAliases()
aliases.add('/home/*/src', './mysrc')
aliases.add('/lib/*/libsrc', './mylib')
self.assert_mapped(aliases, '/home/foo/src/a.py', './mysrc/a.py')
self.assert_mapped(aliases, '/lib/foo/libsrc/a.py', './mylib/a.py')
def test_cant_have_wildcard_at_end(self):
aliases = PathAliases()
msg = "Pattern must not end with wildcards."
with self.assertRaisesRegex(CoverageException, msg):
aliases.add("/ned/home/*", "fooey")
with self.assertRaisesRegex(CoverageException, msg):
aliases.add("/ned/home/*/", "fooey")
with self.assertRaisesRegex(CoverageException, msg):
aliases.add("/ned/home/*/*/", "fooey")
def test_no_accidental_munging(self):
aliases = PathAliases()
aliases.add(r'c:\Zoo\boo', 'src/')
aliases.add('/home/ned$', 'src/')
self.assert_mapped(aliases, r'c:\Zoo\boo\foo.py', 'src/foo.py')
self.assert_mapped(aliases, r'/home/ned$/foo.py', 'src/foo.py')
def test_paths_are_os_corrected(self):
aliases = PathAliases()
aliases.add('/home/ned/*/src', './mysrc')
aliases.add(r'c:\ned\src', './mysrc')
self.assert_mapped(aliases, r'C:\Ned\src\sub\a.py', './mysrc/sub/a.py')
aliases = PathAliases()
aliases.add('/home/ned/*/src', r'.\mysrc')
aliases.add(r'c:\ned\src', r'.\mysrc')
self.assert_mapped(aliases, r'/home/ned/foo/src/sub/a.py', r'.\mysrc\sub\a.py')
def test_windows_on_linux(self):
# https://github.com/nedbat/coveragepy/issues/618
lin = "*/project/module/"
win = "*\\project\\module\\"
# Try the paths in both orders.
for paths in [[lin, win], [win, lin]]:
aliases = PathAliases()
for path in paths:
aliases.add(path, "project/module")
self.assert_mapped(
aliases,
"C:\\a\\path\\somewhere\\coveragepy_test\\project\\module\\tests\\file.py",
"project/module/tests/file.py"
)
def test_linux_on_windows(self):
# https://github.com/nedbat/coveragepy/issues/618
lin = "*/project/module/"
win = "*\\project\\module\\"
# Try the paths in both orders.
for paths in [[lin, win], [win, lin]]:
aliases = PathAliases()
for path in paths:
aliases.add(path, "project\\module")
self.assert_mapped(
aliases,
"C:/a/path/somewhere/coveragepy_test/project/module/tests/file.py",
"project\\module\\tests\\file.py"
)
def test_multiple_wildcard(self):
aliases = PathAliases()
aliases.add('/home/jenkins/*/a/*/b/*/django', './django')
self.assert_mapped(
aliases,
'/home/jenkins/xx/a/yy/b/zz/django/foo/bar.py',
'./django/foo/bar.py'
)
def test_leading_wildcard(self):
aliases = PathAliases()
aliases.add('*/d1', './mysrc1')
aliases.add('*/d2', './mysrc2')
self.assert_mapped(aliases, '/foo/bar/d1/x.py', './mysrc1/x.py')
self.assert_mapped(aliases, '/foo/bar/d2/y.py', './mysrc2/y.py')
def test_dot(self):
cases = ['.', '..', '../other']
if not env.WINDOWS:
# The root test case was added for the manylinux Docker images,
# and I'm not sure how it should work on Windows, so skip it.
cases += ['/']
for d in cases:
aliases = PathAliases()
aliases.add(d, '/the/source')
the_file = os.path.join(d, 'a.py')
the_file = os.path.expanduser(the_file)
the_file = os.path.abspath(os.path.realpath(the_file))
assert '~' not in the_file # to be sure the test is pure.
self.assert_mapped(aliases, the_file, '/the/source/a.py')
class FindPythonFilesTest(CoverageTest):
"""Tests of `find_python_files`."""
def test_find_python_files(self):
self.make_file("sub/a.py")
self.make_file("sub/b.py")
self.make_file("sub/x.c") # nope: not .py
self.make_file("sub/ssub/__init__.py")
self.make_file("sub/ssub/s.py")
self.make_file("sub/ssub/~s.py") # nope: editor effluvia
self.make_file("sub/lab/exp.py") # nope: no __init__.py
self.make_file("sub/windows.pyw")
py_files = set(find_python_files("sub"))
self.assert_same_files(py_files, [
"sub/a.py", "sub/b.py",
"sub/ssub/__init__.py", "sub/ssub/s.py",
"sub/windows.pyw",
])
class WindowsFileTest(CoverageTest):
"""Windows-specific tests of file name handling."""
run_in_temp_dir = False
def setUp(self):
if not env.WINDOWS:
self.skipTest("Only need to run Windows tests on Windows.")
super(WindowsFileTest, self).setUp()
def test_actual_path(self):
self.assertEqual(actual_path(r'c:\Windows'), actual_path(r'C:\wINDOWS'))
|
from homeassistant.const import HTTP_FORBIDDEN, HTTP_UNAUTHORIZED
def is_invalid_auth_code(http_status_code):
"""HTTP status codes that mean invalid auth."""
if http_status_code in (HTTP_UNAUTHORIZED, HTTP_FORBIDDEN):
return True
return False
def percent_conv(val):
"""Convert an actual percentage (0.0-1.0) to 0-100 scale."""
return round(val * 100.0, 1)
|
from homeassistant import config_entries, setup
from homeassistant.components.coronavirus.const import DOMAIN, OPTION_WORLDWIDE
async def test_form(hass):
"""Test we get the form."""
await setup.async_setup_component(hass, "persistent_notification", {})
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
)
assert result["type"] == "form"
assert result["errors"] == {}
result2 = await hass.config_entries.flow.async_configure(
result["flow_id"],
{"country": OPTION_WORLDWIDE},
)
assert result2["type"] == "create_entry"
assert result2["title"] == "Worldwide"
assert result2["result"].unique_id == OPTION_WORLDWIDE
assert result2["data"] == {
"country": OPTION_WORLDWIDE,
}
await hass.async_block_till_done()
assert len(hass.states.async_all()) == 4
|
import unittest
from unittest import mock
from homeassistant.components import dyson
from .common import load_mock_device
from tests.common import get_test_home_assistant
def _get_dyson_account_device_available():
"""Return a valid device provide by Dyson web services."""
device = mock.Mock()
load_mock_device(device)
device.connect = mock.Mock(return_value=True)
device.auto_connect = mock.Mock(return_value=True)
return device
def _get_dyson_account_device_not_available():
"""Return an invalid device provide by Dyson web services."""
device = mock.Mock()
load_mock_device(device)
device.connect = mock.Mock(return_value=False)
device.auto_connect = mock.Mock(return_value=False)
return device
def _get_dyson_account_device_error():
"""Return an invalid device raising OSError while connecting."""
device = mock.Mock()
load_mock_device(device)
device.connect = mock.Mock(side_effect=OSError("Network error"))
return device
class DysonTest(unittest.TestCase):
"""Dyson parent component test class."""
def setUp(self): # pylint: disable=invalid-name
"""Set up things to be run when tests are started."""
self.hass = get_test_home_assistant()
self.addCleanup(self.tear_down_cleanup)
def tear_down_cleanup(self):
"""Stop everything that was started."""
self.hass.stop()
@mock.patch("libpurecool.dyson.DysonAccount.login", return_value=False)
def test_dyson_login_failed(self, mocked_login):
"""Test if Dyson connection failed."""
dyson.setup(
self.hass,
{
dyson.DOMAIN: {
dyson.CONF_USERNAME: "email",
dyson.CONF_PASSWORD: "password",
dyson.CONF_LANGUAGE: "FR",
}
},
)
assert mocked_login.call_count == 1
@mock.patch("libpurecool.dyson.DysonAccount.devices", return_value=[])
@mock.patch("libpurecool.dyson.DysonAccount.login", return_value=True)
def test_dyson_login(self, mocked_login, mocked_devices):
"""Test valid connection to dyson web service."""
dyson.setup(
self.hass,
{
dyson.DOMAIN: {
dyson.CONF_USERNAME: "email",
dyson.CONF_PASSWORD: "password",
dyson.CONF_LANGUAGE: "FR",
}
},
)
assert mocked_login.call_count == 1
assert mocked_devices.call_count == 1
assert len(self.hass.data[dyson.DYSON_DEVICES]) == 0
@mock.patch("homeassistant.helpers.discovery.load_platform")
@mock.patch(
"libpurecool.dyson.DysonAccount.devices",
return_value=[_get_dyson_account_device_available()],
)
@mock.patch("libpurecool.dyson.DysonAccount.login", return_value=True)
def test_dyson_custom_conf(self, mocked_login, mocked_devices, mocked_discovery):
"""Test device connection using custom configuration."""
dyson.setup(
self.hass,
{
dyson.DOMAIN: {
dyson.CONF_USERNAME: "email",
dyson.CONF_PASSWORD: "password",
dyson.CONF_LANGUAGE: "FR",
dyson.CONF_DEVICES: [
{"device_id": "XX-XXXXX-XX", "device_ip": "192.168.0.1"}
],
}
},
)
assert mocked_login.call_count == 1
assert mocked_devices.call_count == 1
assert len(self.hass.data[dyson.DYSON_DEVICES]) == 1
assert mocked_discovery.call_count == 5
@mock.patch(
"libpurecool.dyson.DysonAccount.devices",
return_value=[_get_dyson_account_device_not_available()],
)
@mock.patch("libpurecool.dyson.DysonAccount.login", return_value=True)
def test_dyson_custom_conf_device_not_available(self, mocked_login, mocked_devices):
"""Test device connection with an invalid device."""
dyson.setup(
self.hass,
{
dyson.DOMAIN: {
dyson.CONF_USERNAME: "email",
dyson.CONF_PASSWORD: "password",
dyson.CONF_LANGUAGE: "FR",
dyson.CONF_DEVICES: [
{"device_id": "XX-XXXXX-XX", "device_ip": "192.168.0.1"}
],
}
},
)
assert mocked_login.call_count == 1
assert mocked_devices.call_count == 1
assert len(self.hass.data[dyson.DYSON_DEVICES]) == 0
@mock.patch(
"libpurecool.dyson.DysonAccount.devices",
return_value=[_get_dyson_account_device_error()],
)
@mock.patch("libpurecool.dyson.DysonAccount.login", return_value=True)
def test_dyson_custom_conf_device_error(self, mocked_login, mocked_devices):
"""Test device connection with device raising an exception."""
dyson.setup(
self.hass,
{
dyson.DOMAIN: {
dyson.CONF_USERNAME: "email",
dyson.CONF_PASSWORD: "password",
dyson.CONF_LANGUAGE: "FR",
dyson.CONF_DEVICES: [
{"device_id": "XX-XXXXX-XX", "device_ip": "192.168.0.1"}
],
}
},
)
assert mocked_login.call_count == 1
assert mocked_devices.call_count == 1
assert len(self.hass.data[dyson.DYSON_DEVICES]) == 0
@mock.patch("homeassistant.helpers.discovery.load_platform")
@mock.patch(
"libpurecool.dyson.DysonAccount.devices",
return_value=[_get_dyson_account_device_available()],
)
@mock.patch("libpurecool.dyson.DysonAccount.login", return_value=True)
def test_dyson_custom_conf_with_unknown_device(
self, mocked_login, mocked_devices, mocked_discovery
):
"""Test device connection with custom conf and unknown device."""
dyson.setup(
self.hass,
{
dyson.DOMAIN: {
dyson.CONF_USERNAME: "email",
dyson.CONF_PASSWORD: "password",
dyson.CONF_LANGUAGE: "FR",
dyson.CONF_DEVICES: [
{"device_id": "XX-XXXXX-XY", "device_ip": "192.168.0.1"}
],
}
},
)
assert mocked_login.call_count == 1
assert mocked_devices.call_count == 1
assert len(self.hass.data[dyson.DYSON_DEVICES]) == 0
assert mocked_discovery.call_count == 0
@mock.patch("homeassistant.helpers.discovery.load_platform")
@mock.patch(
"libpurecool.dyson.DysonAccount.devices",
return_value=[_get_dyson_account_device_available()],
)
@mock.patch("libpurecool.dyson.DysonAccount.login", return_value=True)
def test_dyson_discovery(self, mocked_login, mocked_devices, mocked_discovery):
"""Test device connection using discovery."""
dyson.setup(
self.hass,
{
dyson.DOMAIN: {
dyson.CONF_USERNAME: "email",
dyson.CONF_PASSWORD: "password",
dyson.CONF_LANGUAGE: "FR",
dyson.CONF_TIMEOUT: 5,
dyson.CONF_RETRY: 2,
}
},
)
assert mocked_login.call_count == 1
assert mocked_devices.call_count == 1
assert len(self.hass.data[dyson.DYSON_DEVICES]) == 1
assert mocked_discovery.call_count == 5
@mock.patch(
"libpurecool.dyson.DysonAccount.devices",
return_value=[_get_dyson_account_device_not_available()],
)
@mock.patch("libpurecool.dyson.DysonAccount.login", return_value=True)
def test_dyson_discovery_device_not_available(self, mocked_login, mocked_devices):
"""Test device connection with discovery and invalid device."""
dyson.setup(
self.hass,
{
dyson.DOMAIN: {
dyson.CONF_USERNAME: "email",
dyson.CONF_PASSWORD: "password",
dyson.CONF_LANGUAGE: "FR",
dyson.CONF_TIMEOUT: 5,
dyson.CONF_RETRY: 2,
}
},
)
assert mocked_login.call_count == 1
assert mocked_devices.call_count == 1
assert len(self.hass.data[dyson.DYSON_DEVICES]) == 0
|
from typing import Optional
from aioesphomeapi import BinarySensorInfo, BinarySensorState
from homeassistant.components.binary_sensor import BinarySensorEntity
from . import EsphomeEntity, platform_async_setup_entry
async def async_setup_entry(hass, entry, async_add_entities):
"""Set up ESPHome binary sensors based on a config entry."""
await platform_async_setup_entry(
hass,
entry,
async_add_entities,
component_key="binary_sensor",
info_type=BinarySensorInfo,
entity_type=EsphomeBinarySensor,
state_type=BinarySensorState,
)
class EsphomeBinarySensor(EsphomeEntity, BinarySensorEntity):
"""A binary sensor implementation for ESPHome."""
@property
def _static_info(self) -> BinarySensorInfo:
return super()._static_info
@property
def _state(self) -> Optional[BinarySensorState]:
return super()._state
@property
def is_on(self) -> Optional[bool]:
"""Return true if the binary sensor is on."""
if self._static_info.is_status_binary_sensor:
# Status binary sensors indicated connected state.
# So in their case what's usually _availability_ is now state
return self._entry_data.available
if self._state is None:
return None
if self._state.missing_state:
return None
return self._state.state
@property
def device_class(self) -> str:
"""Return the class of this device, from component DEVICE_CLASSES."""
return self._static_info.device_class
@property
def available(self) -> bool:
"""Return True if entity is available."""
if self._static_info.is_status_binary_sensor:
return True
return super().available
|
import asyncio
from ssl import SSLContext
import sys
from typing import Any, Awaitable, Optional, Union, cast
import aiohttp
from aiohttp import web
from aiohttp.hdrs import CONTENT_TYPE, USER_AGENT
from aiohttp.web_exceptions import HTTPBadGateway, HTTPGatewayTimeout
import async_timeout
from homeassistant.const import EVENT_HOMEASSISTANT_CLOSE, __version__
from homeassistant.core import Event, callback
from homeassistant.helpers.frame import warn_use
from homeassistant.helpers.typing import HomeAssistantType
from homeassistant.loader import bind_hass
from homeassistant.util import ssl as ssl_util
DATA_CONNECTOR = "aiohttp_connector"
DATA_CONNECTOR_NOTVERIFY = "aiohttp_connector_notverify"
DATA_CLIENTSESSION = "aiohttp_clientsession"
DATA_CLIENTSESSION_NOTVERIFY = "aiohttp_clientsession_notverify"
SERVER_SOFTWARE = "HomeAssistant/{0} aiohttp/{1} Python/{2[0]}.{2[1]}".format(
__version__, aiohttp.__version__, sys.version_info
)
@callback
@bind_hass
def async_get_clientsession(
hass: HomeAssistantType, verify_ssl: bool = True
) -> aiohttp.ClientSession:
"""Return default aiohttp ClientSession.
This method must be run in the event loop.
"""
if verify_ssl:
key = DATA_CLIENTSESSION
else:
key = DATA_CLIENTSESSION_NOTVERIFY
if key not in hass.data:
hass.data[key] = async_create_clientsession(hass, verify_ssl)
return cast(aiohttp.ClientSession, hass.data[key])
@callback
@bind_hass
def async_create_clientsession(
hass: HomeAssistantType,
verify_ssl: bool = True,
auto_cleanup: bool = True,
**kwargs: Any,
) -> aiohttp.ClientSession:
"""Create a new ClientSession with kwargs, i.e. for cookies.
If auto_cleanup is False, you need to call detach() after the session
returned is no longer used. Default is True, the session will be
automatically detached on homeassistant_stop.
This method must be run in the event loop.
"""
connector = _async_get_connector(hass, verify_ssl)
clientsession = aiohttp.ClientSession(
connector=connector,
headers={USER_AGENT: SERVER_SOFTWARE},
**kwargs,
)
clientsession.close = warn_use( # type: ignore
clientsession.close, "closes the Home Assistant aiohttp session"
)
if auto_cleanup:
_async_register_clientsession_shutdown(hass, clientsession)
return clientsession
@bind_hass
async def async_aiohttp_proxy_web(
hass: HomeAssistantType,
request: web.BaseRequest,
web_coro: Awaitable[aiohttp.ClientResponse],
buffer_size: int = 102400,
timeout: int = 10,
) -> Optional[web.StreamResponse]:
"""Stream websession request to aiohttp web response."""
try:
with async_timeout.timeout(timeout):
req = await web_coro
except asyncio.CancelledError:
# The user cancelled the request
return None
except asyncio.TimeoutError as err:
# Timeout trying to start the web request
raise HTTPGatewayTimeout() from err
except aiohttp.ClientError as err:
# Something went wrong with the connection
raise HTTPBadGateway() from err
try:
return await async_aiohttp_proxy_stream(
hass, request, req.content, req.headers.get(CONTENT_TYPE)
)
finally:
req.close()
@bind_hass
async def async_aiohttp_proxy_stream(
hass: HomeAssistantType,
request: web.BaseRequest,
stream: aiohttp.StreamReader,
content_type: Optional[str],
buffer_size: int = 102400,
timeout: int = 10,
) -> web.StreamResponse:
"""Stream a stream to aiohttp web response."""
response = web.StreamResponse()
if content_type is not None:
response.content_type = content_type
await response.prepare(request)
try:
while True:
with async_timeout.timeout(timeout):
data = await stream.read(buffer_size)
if not data:
break
await response.write(data)
except (asyncio.TimeoutError, aiohttp.ClientError):
# Something went wrong fetching data, closed connection
pass
return response
@callback
def _async_register_clientsession_shutdown(
hass: HomeAssistantType, clientsession: aiohttp.ClientSession
) -> None:
"""Register ClientSession close on Home Assistant shutdown.
This method must be run in the event loop.
"""
@callback
def _async_close_websession(event: Event) -> None:
"""Close websession."""
clientsession.detach()
hass.bus.async_listen_once(EVENT_HOMEASSISTANT_CLOSE, _async_close_websession)
@callback
def _async_get_connector(
hass: HomeAssistantType, verify_ssl: bool = True
) -> aiohttp.BaseConnector:
"""Return the connector pool for aiohttp.
This method must be run in the event loop.
"""
key = DATA_CONNECTOR if verify_ssl else DATA_CONNECTOR_NOTVERIFY
if key in hass.data:
return cast(aiohttp.BaseConnector, hass.data[key])
if verify_ssl:
ssl_context: Union[bool, SSLContext] = ssl_util.client_context()
else:
ssl_context = False
connector = aiohttp.TCPConnector(enable_cleanup_closed=True, ssl=ssl_context)
hass.data[key] = connector
async def _async_close_connector(event: Event) -> None:
"""Close connector pool."""
await connector.close()
hass.bus.async_listen_once(EVENT_HOMEASSISTANT_CLOSE, _async_close_connector)
return connector
|
import io
import os
import lxml.html
from nikola import shortcodes as sc
from nikola.plugin_categories import PageCompiler
from nikola.utils import LocaleBorg, makedirs, map_metadata, write_metadata
class CompileHtml(PageCompiler):
"""Compile HTML into HTML."""
name = "html"
friendly_name = "HTML"
supports_metadata = True
def compile_string(self, data, source_path=None, is_two_file=True, post=None, lang=None):
"""Compile HTML into HTML strings, with shortcode support."""
if not is_two_file:
_, data = self.split_metadata(data, post, lang)
new_data, shortcodes = sc.extract_shortcodes(data)
return self.site.apply_shortcodes_uuid(new_data, shortcodes, filename=source_path, extra_context={'post': post})
def compile(self, source, dest, is_two_file=True, post=None, lang=None):
"""Compile the source file into HTML and save as dest."""
makedirs(os.path.dirname(dest))
with io.open(dest, "w+", encoding="utf-8") as out_file:
with io.open(source, "r", encoding="utf-8-sig") as in_file:
data = in_file.read()
data, shortcode_deps = self.compile_string(data, source, is_two_file, post, lang)
out_file.write(data)
if post is None:
if shortcode_deps:
self.logger.error(
"Cannot save dependencies for post {0} (post unknown)",
source)
else:
post._depfile[dest] += shortcode_deps
return True
def create_post(self, path, **kw):
"""Create a new post."""
content = kw.pop('content', None)
onefile = kw.pop('onefile', False)
# is_page is not used by create_post as of now.
kw.pop('is_page', False)
metadata = {}
metadata.update(self.default_metadata)
metadata.update(kw)
makedirs(os.path.dirname(path))
if not content.endswith('\n'):
content += '\n'
with io.open(path, "w+", encoding="utf-8") as fd:
if onefile:
fd.write(write_metadata(metadata, comment_wrap=True, site=self.site, compiler=self))
fd.write(content)
def read_metadata(self, post, file_metadata_regexp=None, unslugify_titles=False, lang=None):
"""Read the metadata from a post's meta tags, and return a metadata dict."""
if lang is None:
lang = LocaleBorg().current_lang
source_path = post.translated_source_path(lang)
with io.open(source_path, 'r', encoding='utf-8-sig') as inf:
data = inf.read()
metadata = {}
try:
doc = lxml.html.document_fromstring(data)
except lxml.etree.ParserError as e:
# Issue #374 -> #2851
if str(e) == "Document is empty":
return {}
# let other errors raise
raise
title_tag = doc.find('*//title')
if title_tag is not None and title_tag.text:
metadata['title'] = title_tag.text
meta_tags = doc.findall('*//meta')
for tag in meta_tags:
k = tag.get('name', '').lower()
if not k:
continue
elif k == 'keywords':
k = 'tags'
content = tag.get('content')
if content:
metadata[k] = content
map_metadata(metadata, 'html_metadata', self.site.config)
return metadata
|
import numpy as np
import pytest
# pylint: disable=line-too-long
from tensornetwork.contractors.custom_path_solvers.nconinterface import ncon_solver, ncon_to_adj, ord_to_ncon, ncon_cost_check
@pytest.mark.parametrize('chi', range(2, 6))
def test_ncon_solver(chi):
# test against network with known cost
chi = np.random.randint(2, 10)
u = np.random.rand(chi, chi, chi, chi)
w = np.random.rand(chi, chi, chi)
ham = np.random.rand(chi, chi, chi, chi, chi, chi)
tensors = [u, u, w, w, w, ham, u, u, w, w, w]
connects = [[1, 3, 10, 11], [4, 7, 12, 13], [8, 10, -4], [11, 12, -5],
[13, 14, -6], [2, 5, 6, 3, 4, 7], [1, 2, 9, 17], [5, 6, 16, 15],
[8, 9, -1], [17, 16, -2], [15, 14, -3]]
con_order, costs, is_optimal = ncon_solver(tensors, connects, max_branch=None)
flat_connects = np.concatenate(connects)
inds = np.sort(np.unique(flat_connects[flat_connects > 0]))
ex_cost = np.log10(2 * chi**9 + 4 * chi**8 + 2 * chi**6 + 2 * chi**5)
assert np.allclose(costs, ex_cost)
assert is_optimal
assert np.array_equal(inds, np.sort(con_order))
@pytest.mark.parametrize('num_closed', range(1, 20))
def test_ncon_solver2(num_closed):
chi = 4
N = 10
A = np.zeros([chi, chi, chi, chi, chi, chi])
tensors = [A] * N
num_open = 4 * N - 2 * num_closed
cl_inds = 1 + np.arange(num_closed)
op_inds = -1 - np.arange(num_open)
connects = [0] * N
perm = np.argsort(np.sin(range(4 * N)))
comb_inds = np.concatenate((op_inds, cl_inds, cl_inds))[perm]
for k in range(N):
if k < (N - 1):
connect_temp = np.concatenate((comb_inds[4 * k:4 * (k + 1)],
[num_closed + k + 1, num_closed + k + 2]))
else:
connect_temp = np.concatenate(
(comb_inds[4 * k:4 * (k + 1)], [num_closed + k + 1, num_closed + 1]))
connects[k] = list(connect_temp[np.argsort(np.random.rand(6))])
max_branch = 1000
con_order, costs, _ = ncon_solver(tensors, connects, max_branch=max_branch)
ex_cost = ncon_cost_check(tensors, connects, con_order)
assert np.allclose(costs, ex_cost)
assert np.array_equal(np.arange(num_closed + N) + 1, np.sort(con_order))
@pytest.mark.parametrize('chi', range(2, 6))
@pytest.mark.parametrize('N', range(2, 7))
def test_ncon_to_adj(chi, N):
A = np.zeros([chi, chi])
tensors = [A] * N
connects = [0] * N
for k in range(N):
if k == 0:
connects[k] = [-1, 1]
elif k == (N - 1):
connects[k] = [k, -2]
else:
connects[k] = [k, k + 1]
log_adj = ncon_to_adj(tensors, connects)
ex_log_adj = np.zeros([N, N])
ex_log_adj[:(N - 1), 1:] = np.diag(np.log10(chi) * np.ones([N - 1]))
ex_log_adj += ex_log_adj.T
ex_log_adj[0, 0] = np.log10(chi)
ex_log_adj[-1, -1] = np.log10(chi)
assert np.allclose(log_adj, ex_log_adj)
@pytest.mark.parametrize('num_closed', range(1, 16))
def test_ord_to_ncon(num_closed):
N = 8
num_open = 4 * N - 2 * num_closed
cl_inds = 1 + np.arange(num_closed)
op_inds = -1 - np.arange(num_open)
connects = [0] * N
perm = np.argsort(np.random.rand(4 * N))
comb_inds = np.concatenate((op_inds, cl_inds, cl_inds))[perm]
for k in range(N):
if k < (N - 1):
connect_temp = np.concatenate((comb_inds[4 * k:4 * (k + 1)],
[num_closed + k + 1, num_closed + k + 2]))
else:
connect_temp = np.concatenate(
(comb_inds[4 * k:4 * (k + 1)], [num_closed + k + 1, num_closed + 1]))
connects[k] = list(connect_temp[np.argsort(np.random.rand(6))])
order = np.zeros([2, N - 1], dtype=int)
for k in range(N - 1):
temp_loc = np.random.randint(0, N - k - 1)
order[0, k] = temp_loc
order[1, k] = np.random.randint(temp_loc + 1, N - k)
con_order = ord_to_ncon(connects, order)
assert np.array_equal(np.sort(con_order), np.arange(num_closed + N) + 1)
@pytest.mark.parametrize('chi', range(2, 6))
def test_ncon_cost_check(chi):
# test against network with known cost
u = np.random.rand(chi, chi, chi, chi)
w = np.random.rand(chi, chi, chi)
ham = np.random.rand(chi, chi, chi, chi, chi, chi)
tensors = [u, u, w, w, w, ham, u, u, w, w, w]
connects = [[1, 3, 10, 11], [4, 7, 12, 13], [8, 10, -4], [11, 12, -5],
[13, 14, -6], [2, 5, 6, 3, 4, 7], [1, 2, 9, 17], [5, 6, 16, 15],
[8, 9, -1], [17, 16, -2], [15, 14, -3]]
con_order = [4, 7, 17, 5, 6, 11, 3, 12, 14, 1, 2, 16, 8, 9, 10, 13, 15]
cost = ncon_cost_check(tensors, connects, con_order)
ex_cost = np.log10(2 * chi**9 + 4 * chi**8 + 2 * chi**6 + 2 * chi**5)
assert np.allclose(cost, ex_cost)
@pytest.mark.parametrize('chi', range(2, 6))
def test_ncon_cost_check2(chi):
# test against network with known (includes traces and inner products
A = np.zeros([chi, chi, chi, chi])
B = np.zeros([chi, chi, chi, chi, chi, chi])
C = np.zeros([chi, chi, chi])
D = np.zeros([chi, chi])
tensors = [A, B, C, D]
connects = [[1, 2, 3, 1], [2, 4, 4, 5, 6, 6], [3, 5, -1], [-2, -3]]
con_order = [1, 2, 3, 4, 5, 6]
cost = ncon_cost_check(tensors, connects, con_order)
ex_cost = np.log10(3 * chi**3)
assert np.allclose(cost, ex_cost)
|
import os
import cherrypy
from cherrypy.test import helper
curdir = os.path.join(os.getcwd(), os.path.dirname(__file__))
class VirtualHostTest(helper.CPWebCase):
@staticmethod
def setup_server():
class Root:
@cherrypy.expose
def index(self):
return 'Hello, world'
@cherrypy.expose
def dom4(self):
return 'Under construction'
@cherrypy.expose
def method(self, value):
return 'You sent %s' % value
class VHost:
def __init__(self, sitename):
self.sitename = sitename
@cherrypy.expose
def index(self):
return 'Welcome to %s' % self.sitename
@cherrypy.expose
def vmethod(self, value):
return 'You sent %s' % value
@cherrypy.expose
def url(self):
return cherrypy.url('nextpage')
# Test static as a handler (section must NOT include vhost prefix)
static = cherrypy.tools.staticdir.handler(
section='/static', dir=curdir)
root = Root()
root.mydom2 = VHost('Domain 2')
root.mydom3 = VHost('Domain 3')
hostmap = {'www.mydom2.com': '/mydom2',
'www.mydom3.com': '/mydom3',
'www.mydom4.com': '/dom4',
}
cherrypy.tree.mount(root, config={
'/': {
'request.dispatch': cherrypy.dispatch.VirtualHost(**hostmap)
},
# Test static in config (section must include vhost prefix)
'/mydom2/static2': {
'tools.staticdir.on': True,
'tools.staticdir.root': curdir,
'tools.staticdir.dir': 'static',
'tools.staticdir.index': 'index.html',
},
})
def testVirtualHost(self):
self.getPage('/', [('Host', 'www.mydom1.com')])
self.assertBody('Hello, world')
self.getPage('/mydom2/', [('Host', 'www.mydom1.com')])
self.assertBody('Welcome to Domain 2')
self.getPage('/', [('Host', 'www.mydom2.com')])
self.assertBody('Welcome to Domain 2')
self.getPage('/', [('Host', 'www.mydom3.com')])
self.assertBody('Welcome to Domain 3')
self.getPage('/', [('Host', 'www.mydom4.com')])
self.assertBody('Under construction')
# Test GET, POST, and positional params
self.getPage('/method?value=root')
self.assertBody('You sent root')
self.getPage('/vmethod?value=dom2+GET', [('Host', 'www.mydom2.com')])
self.assertBody('You sent dom2 GET')
self.getPage('/vmethod', [('Host', 'www.mydom3.com')], method='POST',
body='value=dom3+POST')
self.assertBody('You sent dom3 POST')
self.getPage('/vmethod/pos', [('Host', 'www.mydom3.com')])
self.assertBody('You sent pos')
# Test that cherrypy.url uses the browser url, not the virtual url
self.getPage('/url', [('Host', 'www.mydom2.com')])
self.assertBody('%s://www.mydom2.com/nextpage' % self.scheme)
def test_VHost_plus_Static(self):
# Test static as a handler
self.getPage('/static/style.css', [('Host', 'www.mydom2.com')])
self.assertStatus('200 OK')
self.assertHeader('Content-Type', 'text/css;charset=utf-8')
# Test static in config
self.getPage('/static2/dirback.jpg', [('Host', 'www.mydom2.com')])
self.assertStatus('200 OK')
self.assertHeaderIn('Content-Type', ['image/jpeg', 'image/pjpeg'])
# Test static config with "index" arg
self.getPage('/static2/', [('Host', 'www.mydom2.com')])
self.assertStatus('200 OK')
self.assertBody('Hello, world\r\n')
# Since tools.trailing_slash is on by default, this should redirect
self.getPage('/static2', [('Host', 'www.mydom2.com')])
self.assertStatus(301)
|
from homeassistant import config_entries, data_entry_flow
from homeassistant.components import ps4
from homeassistant.components.media_player.const import (
ATTR_MEDIA_CONTENT_TYPE,
ATTR_MEDIA_TITLE,
MEDIA_TYPE_GAME,
)
from homeassistant.components.ps4.const import (
ATTR_MEDIA_IMAGE_URL,
COMMANDS,
CONFIG_ENTRY_VERSION as VERSION,
DEFAULT_REGION,
DOMAIN,
PS4_DATA,
)
from homeassistant.const import (
ATTR_COMMAND,
ATTR_ENTITY_ID,
ATTR_LOCKED,
CONF_HOST,
CONF_NAME,
CONF_REGION,
CONF_TOKEN,
)
from homeassistant.exceptions import HomeAssistantError
from homeassistant.setup import async_setup_component
from homeassistant.util import location
from tests.async_mock import MagicMock, patch
from tests.common import MockConfigEntry, mock_registry
MOCK_HOST = "192.168.0.1"
MOCK_NAME = "test_ps4"
MOCK_REGION = "Some Region"
MOCK_CREDS = "1234567890A"
MOCK_DEVICE = {CONF_HOST: MOCK_HOST, CONF_NAME: MOCK_NAME, CONF_REGION: MOCK_REGION}
MOCK_DATA = {CONF_TOKEN: MOCK_CREDS, "devices": [MOCK_DEVICE]}
MOCK_FLOW_RESULT = {
"version": VERSION,
"handler": DOMAIN,
"type": data_entry_flow.RESULT_TYPE_CREATE_ENTRY,
"title": "test_ps4",
"data": MOCK_DATA,
}
MOCK_ENTRY_ID = "SomeID"
MOCK_CONFIG = MockConfigEntry(domain=DOMAIN, data=MOCK_DATA, entry_id=MOCK_ENTRY_ID)
MOCK_LOCATION = location.LocationInfo(
"0.0.0.0",
"US",
"United States",
"CA",
"California",
"San Diego",
"92122",
"America/Los_Angeles",
32.8594,
-117.2073,
True,
)
MOCK_DEVICE_VERSION_1 = {
CONF_HOST: MOCK_HOST,
CONF_NAME: MOCK_NAME,
CONF_REGION: "Some Region",
}
MOCK_DATA_VERSION_1 = {CONF_TOKEN: MOCK_CREDS, "devices": [MOCK_DEVICE_VERSION_1]}
MOCK_DEVICE_ID = "somedeviceid"
MOCK_ENTRY_VERSION_1 = MockConfigEntry(
domain=DOMAIN, data=MOCK_DATA_VERSION_1, entry_id=MOCK_ENTRY_ID, version=1
)
MOCK_UNIQUE_ID = "someuniqueid"
MOCK_ID = "CUSA00123"
MOCK_URL = "http://someurl.jpeg"
MOCK_TITLE = "Some Title"
MOCK_TYPE = MEDIA_TYPE_GAME
MOCK_GAMES_DATA_OLD_STR_FORMAT = {"mock_id": "mock_title", "mock_id2": "mock_title2"}
MOCK_GAMES_DATA = {
ATTR_LOCKED: False,
ATTR_MEDIA_CONTENT_TYPE: MEDIA_TYPE_GAME,
ATTR_MEDIA_IMAGE_URL: MOCK_URL,
ATTR_MEDIA_TITLE: MOCK_TITLE,
}
MOCK_GAMES_DATA_LOCKED = {
ATTR_LOCKED: True,
ATTR_MEDIA_CONTENT_TYPE: MEDIA_TYPE_GAME,
ATTR_MEDIA_IMAGE_URL: MOCK_URL,
ATTR_MEDIA_TITLE: MOCK_TITLE,
}
MOCK_GAMES = {MOCK_ID: MOCK_GAMES_DATA}
MOCK_GAMES_LOCKED = {MOCK_ID: MOCK_GAMES_DATA_LOCKED}
async def test_ps4_integration_setup(hass):
"""Test PS4 integration is setup."""
await ps4.async_setup(hass, {})
await hass.async_block_till_done()
assert hass.data[PS4_DATA].protocol is not None
async def test_creating_entry_sets_up_media_player(hass):
"""Test setting up PS4 loads the media player."""
mock_flow = "homeassistant.components.ps4.PlayStation4FlowHandler.async_step_user"
with patch(
"homeassistant.components.ps4.media_player.async_setup_entry",
return_value=True,
) as mock_setup, patch(mock_flow, return_value=MOCK_FLOW_RESULT):
result = await hass.config_entries.flow.async_init(
DOMAIN, context={"source": config_entries.SOURCE_USER}
)
assert result["type"] == data_entry_flow.RESULT_TYPE_CREATE_ENTRY
await hass.async_block_till_done()
assert len(mock_setup.mock_calls) == 1
async def test_config_flow_entry_migrate(hass):
"""Test that config flow entry is migrated correctly."""
# Start with the config entry at Version 1.
manager = hass.config_entries
mock_entry = MOCK_ENTRY_VERSION_1
mock_entry.add_to_manager(manager)
mock_e_registry = mock_registry(hass)
mock_entity_id = f"media_player.ps4_{MOCK_UNIQUE_ID}"
mock_e_entry = mock_e_registry.async_get_or_create(
"media_player",
"ps4",
MOCK_UNIQUE_ID,
config_entry=mock_entry,
device_id=MOCK_DEVICE_ID,
)
assert len(mock_e_registry.entities) == 1
assert mock_e_entry.entity_id == mock_entity_id
assert mock_e_entry.unique_id == MOCK_UNIQUE_ID
with patch(
"homeassistant.util.location.async_detect_location_info",
return_value=MOCK_LOCATION,
), patch(
"homeassistant.helpers.entity_registry.async_get_registry",
return_value=mock_e_registry,
):
await ps4.async_migrate_entry(hass, mock_entry)
await hass.async_block_till_done()
assert len(mock_e_registry.entities) == 1
for entity in mock_e_registry.entities.values():
mock_entity = entity
# Test that entity_id remains the same.
assert mock_entity.entity_id == mock_entity_id
assert mock_entity.device_id == MOCK_DEVICE_ID
# Test that last four of credentials is appended to the unique_id.
assert mock_entity.unique_id == "{}_{}".format(MOCK_UNIQUE_ID, MOCK_CREDS[-4:])
# Test that config entry is at the current version.
assert mock_entry.version == VERSION
assert mock_entry.data[CONF_TOKEN] == MOCK_CREDS
assert mock_entry.data["devices"][0][CONF_HOST] == MOCK_HOST
assert mock_entry.data["devices"][0][CONF_NAME] == MOCK_NAME
assert mock_entry.data["devices"][0][CONF_REGION] == DEFAULT_REGION
async def test_media_player_is_setup(hass):
"""Test media_player is setup correctly."""
await setup_mock_component(hass)
assert len(hass.data[PS4_DATA].devices) == 1
async def setup_mock_component(hass):
"""Set up Mock Media Player."""
entry = MockConfigEntry(domain=ps4.DOMAIN, data=MOCK_DATA, version=VERSION)
entry.add_to_manager(hass.config_entries)
await async_setup_component(hass, DOMAIN, {DOMAIN: {}})
await hass.async_block_till_done()
def test_games_reformat_to_dict(hass):
"""Test old data format is converted to new format."""
with patch(
"homeassistant.components.ps4.load_json",
return_value=MOCK_GAMES_DATA_OLD_STR_FORMAT,
), patch("homeassistant.components.ps4.save_json", side_effect=MagicMock()), patch(
"os.path.isfile", return_value=True
):
mock_games = ps4.load_games(hass, MOCK_ENTRY_ID)
# New format is a nested dict.
assert isinstance(mock_games, dict)
assert mock_games["mock_id"][ATTR_MEDIA_TITLE] == "mock_title"
assert mock_games["mock_id2"][ATTR_MEDIA_TITLE] == "mock_title2"
for mock_game in mock_games:
mock_data = mock_games[mock_game]
assert isinstance(mock_data, dict)
assert mock_data
assert mock_data[ATTR_MEDIA_IMAGE_URL] is None
assert mock_data[ATTR_LOCKED] is False
assert mock_data[ATTR_MEDIA_CONTENT_TYPE] == MEDIA_TYPE_GAME
def test_load_games(hass):
"""Test that games are loaded correctly."""
with patch(
"homeassistant.components.ps4.load_json", return_value=MOCK_GAMES
), patch("homeassistant.components.ps4.save_json", side_effect=MagicMock()), patch(
"os.path.isfile", return_value=True
):
mock_games = ps4.load_games(hass, MOCK_ENTRY_ID)
assert isinstance(mock_games, dict)
mock_data = mock_games[MOCK_ID]
assert isinstance(mock_data, dict)
assert mock_data[ATTR_MEDIA_TITLE] == MOCK_TITLE
assert mock_data[ATTR_MEDIA_IMAGE_URL] == MOCK_URL
assert mock_data[ATTR_LOCKED] is False
assert mock_data[ATTR_MEDIA_CONTENT_TYPE] == MEDIA_TYPE_GAME
def test_loading_games_returns_dict(hass):
"""Test that loading games always returns a dict."""
with patch(
"homeassistant.components.ps4.load_json", side_effect=HomeAssistantError
), patch("homeassistant.components.ps4.save_json", side_effect=MagicMock()), patch(
"os.path.isfile", return_value=True
):
mock_games = ps4.load_games(hass, MOCK_ENTRY_ID)
assert isinstance(mock_games, dict)
assert not mock_games
with patch(
"homeassistant.components.ps4.load_json", return_value="Some String"
), patch("homeassistant.components.ps4.save_json", side_effect=MagicMock()), patch(
"os.path.isfile", return_value=True
):
mock_games = ps4.load_games(hass, MOCK_ENTRY_ID)
assert isinstance(mock_games, dict)
assert not mock_games
with patch("homeassistant.components.ps4.load_json", return_value=[]), patch(
"homeassistant.components.ps4.save_json", side_effect=MagicMock()
), patch("os.path.isfile", return_value=True):
mock_games = ps4.load_games(hass, MOCK_ENTRY_ID)
assert isinstance(mock_games, dict)
assert not mock_games
async def test_send_command(hass):
"""Test send_command service."""
await setup_mock_component(hass)
mock_func = "{}{}".format(
"homeassistant.components.ps4", ".media_player.PS4Device.async_send_command"
)
mock_devices = hass.data[PS4_DATA].devices
assert len(mock_devices) == 1
mock_entity = mock_devices[0]
assert mock_entity.entity_id == f"media_player.{MOCK_NAME}"
# Test that all commands call service function.
with patch(mock_func, return_value=True) as mock_service:
for mock_command in COMMANDS:
await hass.services.async_call(
DOMAIN,
"send_command",
{ATTR_ENTITY_ID: mock_entity.entity_id, ATTR_COMMAND: mock_command},
)
await hass.async_block_till_done()
assert len(mock_service.mock_calls) == len(COMMANDS)
|
import argparse
import getpass
import os
from homeassistant.util.yaml import _SECRET_NAMESPACE
# mypy: allow-untyped-defs
REQUIREMENTS = ["keyring==21.2.0", "keyrings.alt==3.4.0"]
def run(args):
"""Handle keyring script."""
parser = argparse.ArgumentParser(
description=(
"Modify Home Assistant secrets in the default keyring. "
"Use the secrets in configuration files with: "
"!secret <name>"
)
)
parser.add_argument("--script", choices=["keyring"])
parser.add_argument(
"action",
choices=["get", "set", "del", "info"],
help="Get, set or delete a secret",
)
parser.add_argument("name", help="Name of the secret", nargs="?", default=None)
import keyring # pylint: disable=import-outside-toplevel
# pylint: disable=import-outside-toplevel
from keyring.util import platform_ as platform
args = parser.parse_args(args)
if args.action == "info":
keyr = keyring.get_keyring()
print("Keyring version {}\n".format(REQUIREMENTS[0].split("==")[1]))
print(f"Active keyring : {keyr.__module__}")
config_name = os.path.join(platform.config_root(), "keyringrc.cfg")
print(f"Config location : {config_name}")
print(f"Data location : {platform.data_root()}\n")
elif args.name is None:
parser.print_help()
return 1
if args.action == "set":
entered_secret = getpass.getpass(f"Please enter the secret for {args.name}: ")
keyring.set_password(_SECRET_NAMESPACE, args.name, entered_secret)
print(f"Secret {args.name} set successfully")
elif args.action == "get":
the_secret = keyring.get_password(_SECRET_NAMESPACE, args.name)
if the_secret is None:
print(f"Secret {args.name} not found")
else:
print(f"Secret {args.name}={the_secret}")
elif args.action == "del":
try:
keyring.delete_password(_SECRET_NAMESPACE, args.name)
print(f"Deleted secret {args.name}")
except keyring.errors.PasswordDeleteError:
print(f"Secret {args.name} not found")
|
__docformat__ = "restructuredtext en"
import os
import sys
import logging
from six import string_types
from logilab.common.textutils import colorize_ansi
def set_log_methods(cls, logger):
"""bind standard logger's methods as methods on the class"""
cls.__logger = logger
for attr in ('debug', 'info', 'warning', 'error', 'critical', 'exception'):
setattr(cls, attr, getattr(logger, attr))
def xxx_cyan(record):
if 'XXX' in record.message:
return 'cyan'
class ColorFormatter(logging.Formatter):
"""
A color Formatter for the logging standard module.
By default, colorize CRITICAL and ERROR in red, WARNING in orange, INFO in
green and DEBUG in yellow.
self.colors is customizable via the 'color' constructor argument (dictionary).
self.colorfilters is a list of functions that get the LogRecord
and return a color name or None.
"""
def __init__(self, fmt=None, datefmt=None, colors=None):
logging.Formatter.__init__(self, fmt, datefmt)
self.colorfilters = []
self.colors = {'CRITICAL': 'red',
'ERROR': 'red',
'WARNING': 'magenta',
'INFO': 'green',
'DEBUG': 'yellow',
}
if colors is not None:
assert isinstance(colors, dict)
self.colors.update(colors)
def format(self, record):
msg = logging.Formatter.format(self, record)
if record.levelname in self.colors:
color = self.colors[record.levelname]
return colorize_ansi(msg, color)
else:
for cf in self.colorfilters:
color = cf(record)
if color:
return colorize_ansi(msg, color)
return msg
def set_color_formatter(logger=None, **kw):
"""
Install a color formatter on the 'logger'. If not given, it will
defaults to the default logger.
Any additional keyword will be passed as-is to the ColorFormatter
constructor.
"""
if logger is None:
logger = logging.getLogger()
if not logger.handlers:
logging.basicConfig()
format_msg = logger.handlers[0].formatter._fmt
fmt = ColorFormatter(format_msg, **kw)
fmt.colorfilters.append(xxx_cyan)
logger.handlers[0].setFormatter(fmt)
LOG_FORMAT = '%(asctime)s - (%(name)s) %(levelname)s: %(message)s'
LOG_DATE_FORMAT = '%Y-%m-%d %H:%M:%S'
def get_handler(debug=False, syslog=False, logfile=None, rotation_parameters=None):
"""get an apropriate handler according to given parameters"""
if os.environ.get('APYCOT_ROOT'):
handler = logging.StreamHandler(sys.stdout)
if debug:
handler = logging.StreamHandler()
elif logfile is None:
if syslog:
from logging import handlers
handler = handlers.SysLogHandler()
else:
handler = logging.StreamHandler()
else:
try:
if rotation_parameters is None:
if os.name == 'posix' and sys.version_info >= (2, 6):
from logging.handlers import WatchedFileHandler
handler = WatchedFileHandler(logfile)
else:
handler = logging.FileHandler(logfile)
else:
from logging.handlers import TimedRotatingFileHandler
handler = TimedRotatingFileHandler(
logfile, **rotation_parameters)
except IOError:
handler = logging.StreamHandler()
return handler
def get_threshold(debug=False, logthreshold=None):
if logthreshold is None:
if debug:
logthreshold = logging.DEBUG
else:
logthreshold = logging.ERROR
elif isinstance(logthreshold, string_types):
logthreshold = getattr(logging, THRESHOLD_MAP.get(logthreshold,
logthreshold))
return logthreshold
def _colorable_terminal():
isatty = hasattr(sys.__stdout__, 'isatty') and sys.__stdout__.isatty()
if not isatty:
return False
if os.name == 'nt':
try:
from colorama import init as init_win32_colors
except ImportError:
return False
init_win32_colors()
return True
def get_formatter(logformat=LOG_FORMAT, logdateformat=LOG_DATE_FORMAT):
if _colorable_terminal():
fmt = ColorFormatter(logformat, logdateformat)
def col_fact(record):
if 'XXX' in record.message:
return 'cyan'
if 'kick' in record.message:
return 'red'
fmt.colorfilters.append(col_fact)
else:
fmt = logging.Formatter(logformat, logdateformat)
return fmt
def init_log(debug=False, syslog=False, logthreshold=None, logfile=None,
logformat=LOG_FORMAT, logdateformat=LOG_DATE_FORMAT, fmt=None,
rotation_parameters=None, handler=None):
"""init the log service"""
logger = logging.getLogger()
if handler is None:
handler = get_handler(debug, syslog, logfile, rotation_parameters)
# only addHandler and removeHandler method while I would like a setHandler
# method, so do it this way :$
logger.handlers = [handler]
logthreshold = get_threshold(debug, logthreshold)
logger.setLevel(logthreshold)
if fmt is None:
if debug:
fmt = get_formatter(logformat=logformat, logdateformat=logdateformat)
else:
fmt = logging.Formatter(logformat, logdateformat)
handler.setFormatter(fmt)
return handler
# map logilab.common.logger thresholds to logging thresholds
THRESHOLD_MAP = {'LOG_DEBUG': 'DEBUG',
'LOG_INFO': 'INFO',
'LOG_NOTICE': 'INFO',
'LOG_WARN': 'WARNING',
'LOG_WARNING': 'WARNING',
'LOG_ERR': 'ERROR',
'LOG_ERROR': 'ERROR',
'LOG_CRIT': 'CRITICAL',
}
|
import copy
import datetime
import tempfile
from absl import flags
from perfkitbenchmarker import beam_benchmark_helper
from perfkitbenchmarker import beam_pipeline_options
from perfkitbenchmarker import configs
from perfkitbenchmarker import dpb_service
from perfkitbenchmarker import errors
from perfkitbenchmarker import kubernetes_helper
from perfkitbenchmarker import sample
from perfkitbenchmarker.dpb_service import BaseDpbService
BENCHMARK_NAME = 'beam_integration_benchmark'
BENCHMARK_CONFIG = """
beam_integration_benchmark:
description: Run word count on dataflow and dataproc
dpb_service:
service_type: dataflow
worker_group:
vm_spec:
GCP:
machine_type: n1-standard-1
boot_disk_size: 500
AWS:
machine_type: m3.medium
disk_spec:
GCP:
disk_type: nodisk
AWS:
disk_size: 500
disk_type: gp2
worker_count: 2
"""
DEFAULT_JAVA_IT_CLASS = 'org.apache.beam.examples.WordCountIT'
DEFAULT_PYTHON_IT_MODULE = ('apache_beam.examples.wordcount_it_test:'
'WordCountIT.test_wordcount_it')
flags.DEFINE_string('beam_it_class', None, 'Path to IT class')
flags.DEFINE_string('beam_it_args', None, 'Args to provide to the IT.'
' Deprecated & replaced by beam_it_options')
flags.DEFINE_string('beam_it_options', None, 'Pipeline Options sent to the'
' integration test.')
flags.DEFINE_string('beam_kubernetes_scripts', None, 'A local path to the'
' Kubernetes scripts to run which will instantiate a'
' datastore.')
flags.DEFINE_string('beam_options_config_file', None, 'A local path to the'
' yaml file defining static and dynamic pipeline options to'
' use for this benchmark run.')
FLAGS = flags.FLAGS
def GetConfig(user_config):
return configs.LoadConfig(BENCHMARK_CONFIG, user_config, BENCHMARK_NAME)
def CheckPrerequisites(benchmark_config_spec):
"""Verifies that the required resources are present.
Raises:
perfkitbenchmarker.errors.Config.InvalidValue: If no Beam args are provided.
NotImplementedError: If an invalid runner is specified.
"""
if FLAGS.beam_it_options is None and FLAGS.beam_it_args is None:
raise errors.Config.InvalidValue(
'No options provided. To run with default class (WordCountIT), must'
' provide --beam_it_options=--tempRoot=<temp dir,'
' e.g. gs://my-dir/temp>.')
if FLAGS.beam_sdk is None:
raise errors.Config.InvalidValue(
'No sdk provided. To run Beam integration benchmark, the test must'
'specify which sdk is used in the pipeline. For example, java/python.')
if benchmark_config_spec.dpb_service.service_type != dpb_service.DATAFLOW:
raise NotImplementedError('Currently only works against Dataflow.')
if (FLAGS.beam_it_options and
(not FLAGS.beam_it_options.endswith(']') or
not FLAGS.beam_it_options.startswith('['))):
raise Exception("beam_it_options must be of form"
" [\"--option=value\",\"--option2=val2\"]")
def Prepare(benchmark_spec):
beam_benchmark_helper.InitializeBeamRepo(benchmark_spec)
benchmark_spec.always_call_cleanup = True
kubernetes_helper.CreateAllFiles(getKubernetesScripts())
pass
def getKubernetesScripts():
if FLAGS.beam_kubernetes_scripts:
scripts = FLAGS.beam_kubernetes_scripts.split(',')
return scripts
else:
return []
def Run(benchmark_spec):
# Get handle to the dpb service
dpb_service_instance = benchmark_spec.dpb_service
# Create a file handle to contain the response from running the job on
# the dpb service
stdout_file = tempfile.NamedTemporaryFile(suffix='.stdout',
prefix='beam_integration_benchmark',
delete=False)
stdout_file.close()
if FLAGS.beam_it_class is None:
if FLAGS.beam_sdk == beam_benchmark_helper.BEAM_JAVA_SDK:
classname = DEFAULT_JAVA_IT_CLASS
elif FLAGS.beam_sdk == beam_benchmark_helper.BEAM_PYTHON_SDK:
classname = DEFAULT_PYTHON_IT_MODULE
else:
raise NotImplementedError('Unsupported Beam SDK: %s.' % FLAGS.beam_sdk)
else:
classname = FLAGS.beam_it_class
static_pipeline_options, dynamic_pipeline_options = \
beam_pipeline_options.ReadPipelineOptionConfigFile()
job_arguments = beam_pipeline_options.GenerateAllPipelineOptions(
FLAGS.beam_it_args, FLAGS.beam_it_options,
static_pipeline_options,
dynamic_pipeline_options)
job_type = BaseDpbService.BEAM_JOB_TYPE
results = []
metadata = copy.copy(dpb_service_instance.GetMetadata())
start = datetime.datetime.now()
dpb_service_instance.SubmitJob(
classname=classname,
job_arguments=job_arguments,
job_stdout_file=stdout_file,
job_type=job_type)
end_time = datetime.datetime.now()
run_time = (end_time - start).total_seconds()
results.append(sample.Sample('run_time', run_time, 'seconds', metadata))
return results
def Cleanup(benchmark_spec):
kubernetes_helper.DeleteAllFiles(getKubernetesScripts())
pass
|
import asyncio
from ssl import SSLContext
from typing import List, Optional, Union
from aiohttp import web
from yarl import URL
class HomeAssistantTCPSite(web.BaseSite):
"""HomeAssistant specific aiohttp Site.
Vanilla TCPSite accepts only str as host. However, the underlying asyncio's
create_server() implementation does take a list of strings to bind to multiple
host IP's. To support multiple server_host entries (e.g. to enable dual-stack
explicitly), we would like to pass an array of strings. Bring our own
implementation inspired by TCPSite.
Custom TCPSite can be dropped when https://github.com/aio-libs/aiohttp/pull/4894
is merged.
"""
__slots__ = ("_host", "_port", "_reuse_address", "_reuse_port", "_hosturl")
def __init__(
self,
runner: "web.BaseRunner",
host: Union[None, str, List[str]],
port: int,
*,
shutdown_timeout: float = 60.0,
ssl_context: Optional[SSLContext] = None,
backlog: int = 128,
reuse_address: Optional[bool] = None,
reuse_port: Optional[bool] = None,
) -> None: # noqa: D107
super().__init__(
runner,
shutdown_timeout=shutdown_timeout,
ssl_context=ssl_context,
backlog=backlog,
)
self._host = host
self._port = port
self._reuse_address = reuse_address
self._reuse_port = reuse_port
@property
def name(self) -> str: # noqa: D102
scheme = "https" if self._ssl_context else "http"
host = self._host[0] if isinstance(self._host, list) else "0.0.0.0"
return str(URL.build(scheme=scheme, host=host, port=self._port))
async def start(self) -> None: # noqa: D102
await super().start()
loop = asyncio.get_running_loop()
server = self._runner.server
assert server is not None
self._server = await loop.create_server(
server,
self._host,
self._port,
ssl=self._ssl_context,
backlog=self._backlog,
reuse_address=self._reuse_address,
reuse_port=self._reuse_port,
)
|
import pytest
from PyQt5.QtCore import QUrl
from qutebrowser.misc import autoupdate, httpclient
INVALID_JSON = ['{"invalid": { "json"}', '{"wrong": "keys"}']
class HTTPGetStub(httpclient.HTTPClient):
"""A stub class for HTTPClient.
Attributes:
url: the last url used by get()
_success: Whether get() will emit a success signal.
"""
def __init__(self, success=True, json=None):
super().__init__()
self.url = None
self._success = success
if json:
self._json = json
else:
self._json = '{"info": {"version": "test"}}'
def get(self, url):
self.url = url
if self._success:
self.success.emit(self._json)
else:
self.error.emit("error")
def test_constructor(qapp):
client = autoupdate.PyPIVersionClient()
assert isinstance(client._client, httpclient.HTTPClient)
def test_get_version_success(qtbot):
"""Test get_version() when success is emitted."""
http_stub = HTTPGetStub(success=True)
client = autoupdate.PyPIVersionClient(client=http_stub)
with qtbot.assertNotEmitted(client.error):
with qtbot.waitSignal(client.success):
client.get_version('test')
assert http_stub.url == QUrl(client.API_URL.format('test'))
def test_get_version_error(qtbot):
"""Test get_version() when error is emitted."""
http_stub = HTTPGetStub(success=False)
client = autoupdate.PyPIVersionClient(client=http_stub)
with qtbot.assertNotEmitted(client.success):
with qtbot.waitSignal(client.error):
client.get_version('test')
@pytest.mark.parametrize('json', INVALID_JSON)
def test_invalid_json(qtbot, json):
"""Test on_client_success() with invalid JSON."""
http_stub = HTTPGetStub(json=json)
client = autoupdate.PyPIVersionClient(client=http_stub)
client.get_version('test')
with qtbot.assertNotEmitted(client.success):
with qtbot.waitSignal(client.error):
client.get_version('test')
|
import logging
import blebox_uniapi
import pytest
from homeassistant.components.light import (
ATTR_BRIGHTNESS,
ATTR_HS_COLOR,
ATTR_WHITE_VALUE,
SUPPORT_BRIGHTNESS,
SUPPORT_COLOR,
SUPPORT_WHITE_VALUE,
)
from homeassistant.const import (
ATTR_SUPPORTED_FEATURES,
SERVICE_TURN_OFF,
SERVICE_TURN_ON,
STATE_OFF,
STATE_ON,
)
from homeassistant.util import color
from .conftest import async_setup_entity, mock_feature
from tests.async_mock import AsyncMock, PropertyMock
ALL_LIGHT_FIXTURES = ["dimmer", "wlightbox_s", "wlightbox"]
@pytest.fixture(name="dimmer")
def dimmer_fixture():
"""Return a default light entity mock."""
feature = mock_feature(
"lights",
blebox_uniapi.light.Light,
unique_id="BleBox-dimmerBox-1afe34e750b8-brightness",
full_name="dimmerBox-brightness",
device_class=None,
brightness=65,
is_on=True,
supports_color=False,
supports_white=False,
)
product = feature.product
type(product).name = PropertyMock(return_value="My dimmer")
type(product).model = PropertyMock(return_value="dimmerBox")
return (feature, "light.dimmerbox_brightness")
async def test_dimmer_init(dimmer, hass, config):
"""Test cover default state."""
_, entity_id = dimmer
entry = await async_setup_entity(hass, config, entity_id)
assert entry.unique_id == "BleBox-dimmerBox-1afe34e750b8-brightness"
state = hass.states.get(entity_id)
assert state.name == "dimmerBox-brightness"
supported_features = state.attributes[ATTR_SUPPORTED_FEATURES]
assert supported_features & SUPPORT_BRIGHTNESS
assert state.attributes[ATTR_BRIGHTNESS] == 65
assert state.state == STATE_ON
device_registry = await hass.helpers.device_registry.async_get_registry()
device = device_registry.async_get(entry.device_id)
assert device.name == "My dimmer"
assert device.identifiers == {("blebox", "abcd0123ef5678")}
assert device.manufacturer == "BleBox"
assert device.model == "dimmerBox"
assert device.sw_version == "1.23"
async def test_dimmer_update(dimmer, hass, config):
"""Test light updating."""
feature_mock, entity_id = dimmer
def initial_update():
feature_mock.brightness = 53
feature_mock.async_update = AsyncMock(side_effect=initial_update)
await async_setup_entity(hass, config, entity_id)
state = hass.states.get(entity_id)
assert state.attributes[ATTR_BRIGHTNESS] == 53
assert state.state == STATE_ON
async def test_dimmer_on(dimmer, hass, config):
"""Test light on."""
feature_mock, entity_id = dimmer
def initial_update():
feature_mock.is_on = False
feature_mock.brightness = 0 # off
feature_mock.sensible_on_value = 254
feature_mock.async_update = AsyncMock(side_effect=initial_update)
await async_setup_entity(hass, config, entity_id)
feature_mock.async_update = AsyncMock()
state = hass.states.get(entity_id)
assert state.state == STATE_OFF
def turn_on(brightness):
assert brightness == 254
feature_mock.brightness = 254 # on
feature_mock.is_on = True # on
feature_mock.async_on = AsyncMock(side_effect=turn_on)
await hass.services.async_call(
"light",
SERVICE_TURN_ON,
{"entity_id": entity_id},
blocking=True,
)
state = hass.states.get(entity_id)
assert state.state == STATE_ON
assert state.attributes[ATTR_BRIGHTNESS] == 254
async def test_dimmer_on_with_brightness(dimmer, hass, config):
"""Test light on with a brightness value."""
feature_mock, entity_id = dimmer
def initial_update():
feature_mock.is_on = False
feature_mock.brightness = 0 # off
feature_mock.sensible_on_value = 254
feature_mock.async_update = AsyncMock(side_effect=initial_update)
await async_setup_entity(hass, config, entity_id)
feature_mock.async_update = AsyncMock()
state = hass.states.get(entity_id)
assert state.state == STATE_OFF
def turn_on(brightness):
assert brightness == 202
feature_mock.brightness = 202 # on
feature_mock.is_on = True # on
feature_mock.async_on = AsyncMock(side_effect=turn_on)
def apply(value, brightness):
assert value == 254
return brightness
feature_mock.apply_brightness = apply
await hass.services.async_call(
"light",
SERVICE_TURN_ON,
{"entity_id": entity_id, ATTR_BRIGHTNESS: 202},
blocking=True,
)
state = hass.states.get(entity_id)
assert state.attributes[ATTR_BRIGHTNESS] == 202
assert state.state == STATE_ON
async def test_dimmer_off(dimmer, hass, config):
"""Test light off."""
feature_mock, entity_id = dimmer
def initial_update():
feature_mock.is_on = True
feature_mock.async_update = AsyncMock(side_effect=initial_update)
await async_setup_entity(hass, config, entity_id)
feature_mock.async_update = AsyncMock()
state = hass.states.get(entity_id)
assert state.state == STATE_ON
def turn_off():
feature_mock.is_on = False
feature_mock.brightness = 0 # off
feature_mock.async_off = AsyncMock(side_effect=turn_off)
await hass.services.async_call(
"light",
SERVICE_TURN_OFF,
{"entity_id": entity_id},
blocking=True,
)
state = hass.states.get(entity_id)
assert state.state == STATE_OFF
assert ATTR_BRIGHTNESS not in state.attributes
@pytest.fixture(name="wlightbox_s")
def wlightboxs_fixture():
"""Return a default light entity mock."""
feature = mock_feature(
"lights",
blebox_uniapi.light.Light,
unique_id="BleBox-wLightBoxS-1afe34e750b8-color",
full_name="wLightBoxS-color",
device_class=None,
brightness=None,
is_on=None,
supports_color=False,
supports_white=False,
)
product = feature.product
type(product).name = PropertyMock(return_value="My wLightBoxS")
type(product).model = PropertyMock(return_value="wLightBoxS")
return (feature, "light.wlightboxs_color")
async def test_wlightbox_s_init(wlightbox_s, hass, config):
"""Test cover default state."""
_, entity_id = wlightbox_s
entry = await async_setup_entity(hass, config, entity_id)
assert entry.unique_id == "BleBox-wLightBoxS-1afe34e750b8-color"
state = hass.states.get(entity_id)
assert state.name == "wLightBoxS-color"
supported_features = state.attributes[ATTR_SUPPORTED_FEATURES]
assert supported_features & SUPPORT_BRIGHTNESS
assert ATTR_BRIGHTNESS not in state.attributes
assert state.state == STATE_OFF
device_registry = await hass.helpers.device_registry.async_get_registry()
device = device_registry.async_get(entry.device_id)
assert device.name == "My wLightBoxS"
assert device.identifiers == {("blebox", "abcd0123ef5678")}
assert device.manufacturer == "BleBox"
assert device.model == "wLightBoxS"
assert device.sw_version == "1.23"
async def test_wlightbox_s_update(wlightbox_s, hass, config):
"""Test light updating."""
feature_mock, entity_id = wlightbox_s
def initial_update():
feature_mock.brightness = 0xAB
feature_mock.is_on = True
feature_mock.async_update = AsyncMock(side_effect=initial_update)
await async_setup_entity(hass, config, entity_id)
state = hass.states.get(entity_id)
assert state.state == STATE_ON
assert state.attributes[ATTR_BRIGHTNESS] == 0xAB
async def test_wlightbox_s_on(wlightbox_s, hass, config):
"""Test light on."""
feature_mock, entity_id = wlightbox_s
def initial_update():
feature_mock.is_on = False
feature_mock.sensible_on_value = 254
feature_mock.async_update = AsyncMock(side_effect=initial_update)
await async_setup_entity(hass, config, entity_id)
feature_mock.async_update = AsyncMock()
state = hass.states.get(entity_id)
assert state.state == STATE_OFF
def turn_on(brightness):
assert brightness == 254
feature_mock.brightness = 254 # on
feature_mock.is_on = True # on
feature_mock.async_on = AsyncMock(side_effect=turn_on)
await hass.services.async_call(
"light",
SERVICE_TURN_ON,
{"entity_id": entity_id},
blocking=True,
)
state = hass.states.get(entity_id)
assert state.attributes[ATTR_BRIGHTNESS] == 254
assert state.state == STATE_ON
@pytest.fixture(name="wlightbox")
def wlightbox_fixture():
"""Return a default light entity mock."""
feature = mock_feature(
"lights",
blebox_uniapi.light.Light,
unique_id="BleBox-wLightBox-1afe34e750b8-color",
full_name="wLightBox-color",
device_class=None,
is_on=None,
supports_color=True,
supports_white=True,
white_value=None,
rgbw_hex=None,
)
product = feature.product
type(product).name = PropertyMock(return_value="My wLightBox")
type(product).model = PropertyMock(return_value="wLightBox")
return (feature, "light.wlightbox_color")
async def test_wlightbox_init(wlightbox, hass, config):
"""Test cover default state."""
_, entity_id = wlightbox
entry = await async_setup_entity(hass, config, entity_id)
assert entry.unique_id == "BleBox-wLightBox-1afe34e750b8-color"
state = hass.states.get(entity_id)
assert state.name == "wLightBox-color"
supported_features = state.attributes[ATTR_SUPPORTED_FEATURES]
assert supported_features & SUPPORT_WHITE_VALUE
assert supported_features & SUPPORT_COLOR
assert ATTR_WHITE_VALUE not in state.attributes
assert ATTR_HS_COLOR not in state.attributes
assert ATTR_BRIGHTNESS not in state.attributes
assert state.state == STATE_OFF
device_registry = await hass.helpers.device_registry.async_get_registry()
device = device_registry.async_get(entry.device_id)
assert device.name == "My wLightBox"
assert device.identifiers == {("blebox", "abcd0123ef5678")}
assert device.manufacturer == "BleBox"
assert device.model == "wLightBox"
assert device.sw_version == "1.23"
async def test_wlightbox_update(wlightbox, hass, config):
"""Test light updating."""
feature_mock, entity_id = wlightbox
def initial_update():
feature_mock.is_on = True
feature_mock.rgbw_hex = "fa00203A"
feature_mock.white_value = 0x3A
feature_mock.async_update = AsyncMock(side_effect=initial_update)
await async_setup_entity(hass, config, entity_id)
state = hass.states.get(entity_id)
assert state.attributes[ATTR_HS_COLOR] == (352.32, 100.0)
assert state.attributes[ATTR_WHITE_VALUE] == 0x3A
assert state.state == STATE_ON
async def test_wlightbox_on_via_just_whiteness(wlightbox, hass, config):
"""Test light on."""
feature_mock, entity_id = wlightbox
def initial_update():
feature_mock.is_on = False
feature_mock.async_update = AsyncMock(side_effect=initial_update)
await async_setup_entity(hass, config, entity_id)
feature_mock.async_update = AsyncMock()
state = hass.states.get(entity_id)
assert state.state == STATE_OFF
def turn_on(value):
feature_mock.is_on = True
assert value == "f1e2d3c7"
feature_mock.white_value = 0xC7 # on
feature_mock.rgbw_hex = "f1e2d3c7"
feature_mock.async_on = AsyncMock(side_effect=turn_on)
def apply_white(value, white):
assert value == "f1e2d305"
assert white == 0xC7
return "f1e2d3c7"
feature_mock.apply_white = apply_white
feature_mock.sensible_on_value = "f1e2d305"
await hass.services.async_call(
"light",
SERVICE_TURN_ON,
{"entity_id": entity_id, ATTR_WHITE_VALUE: 0xC7},
blocking=True,
)
state = hass.states.get(entity_id)
assert state.state == STATE_ON
assert state.attributes[ATTR_WHITE_VALUE] == 0xC7
assert state.attributes[ATTR_HS_COLOR] == color.color_RGB_to_hs(0xF1, 0xE2, 0xD3)
async def test_wlightbox_on_via_reset_whiteness(wlightbox, hass, config):
"""Test light on."""
feature_mock, entity_id = wlightbox
def initial_update():
feature_mock.is_on = False
feature_mock.async_update = AsyncMock(side_effect=initial_update)
await async_setup_entity(hass, config, entity_id)
feature_mock.async_update = AsyncMock()
state = hass.states.get(entity_id)
assert state.state == STATE_OFF
def turn_on(value):
feature_mock.is_on = True
feature_mock.white_value = 0x0
assert value == "f1e2d300"
feature_mock.rgbw_hex = "f1e2d300"
feature_mock.async_on = AsyncMock(side_effect=turn_on)
def apply_white(value, white):
assert value == "f1e2d305"
assert white == 0x0
return "f1e2d300"
feature_mock.apply_white = apply_white
feature_mock.sensible_on_value = "f1e2d305"
await hass.services.async_call(
"light",
SERVICE_TURN_ON,
{"entity_id": entity_id, ATTR_WHITE_VALUE: 0x0},
blocking=True,
)
state = hass.states.get(entity_id)
assert state.state == STATE_ON
assert state.attributes[ATTR_WHITE_VALUE] == 0x0
assert state.attributes[ATTR_HS_COLOR] == color.color_RGB_to_hs(0xF1, 0xE2, 0xD3)
async def test_wlightbox_on_via_just_hsl_color(wlightbox, hass, config):
"""Test light on."""
feature_mock, entity_id = wlightbox
def initial_update():
feature_mock.is_on = False
feature_mock.rgbw_hex = "00000000"
feature_mock.async_update = AsyncMock(side_effect=initial_update)
await async_setup_entity(hass, config, entity_id)
feature_mock.async_update = AsyncMock()
state = hass.states.get(entity_id)
assert state.state == STATE_OFF
hs_color = color.color_RGB_to_hs(0xFF, 0xA1, 0xB2)
def turn_on(value):
feature_mock.is_on = True
assert value == "ffa1b2e4"
feature_mock.white_value = 0xE4
feature_mock.rgbw_hex = value
feature_mock.async_on = AsyncMock(side_effect=turn_on)
def apply_color(value, color_value):
assert value == "c1a2e3e4"
assert color_value == "ffa0b1"
return "ffa1b2e4"
feature_mock.apply_color = apply_color
feature_mock.sensible_on_value = "c1a2e3e4"
await hass.services.async_call(
"light",
SERVICE_TURN_ON,
{"entity_id": entity_id, ATTR_HS_COLOR: hs_color},
blocking=True,
)
state = hass.states.get(entity_id)
assert state.attributes[ATTR_HS_COLOR] == hs_color
assert state.attributes[ATTR_WHITE_VALUE] == 0xE4
assert state.state == STATE_ON
async def test_wlightbox_on_to_last_color(wlightbox, hass, config):
"""Test light on."""
feature_mock, entity_id = wlightbox
def initial_update():
feature_mock.is_on = False
feature_mock.async_update = AsyncMock(side_effect=initial_update)
await async_setup_entity(hass, config, entity_id)
feature_mock.async_update = AsyncMock()
state = hass.states.get(entity_id)
assert state.state == STATE_OFF
def turn_on(value):
feature_mock.is_on = True
assert value == "f1e2d3e4"
feature_mock.white_value = 0xE4
feature_mock.rgbw_hex = value
feature_mock.async_on = AsyncMock(side_effect=turn_on)
feature_mock.sensible_on_value = "f1e2d3e4"
await hass.services.async_call(
"light",
SERVICE_TURN_ON,
{"entity_id": entity_id},
blocking=True,
)
state = hass.states.get(entity_id)
assert state.attributes[ATTR_WHITE_VALUE] == 0xE4
assert state.attributes[ATTR_HS_COLOR] == color.color_RGB_to_hs(0xF1, 0xE2, 0xD3)
assert state.state == STATE_ON
async def test_wlightbox_off(wlightbox, hass, config):
"""Test light off."""
feature_mock, entity_id = wlightbox
def initial_update():
feature_mock.is_on = True
feature_mock.async_update = AsyncMock(side_effect=initial_update)
await async_setup_entity(hass, config, entity_id)
feature_mock.async_update = AsyncMock()
state = hass.states.get(entity_id)
assert state.state == STATE_ON
def turn_off():
feature_mock.is_on = False
feature_mock.white_value = 0x0
feature_mock.rgbw_hex = "00000000"
feature_mock.async_off = AsyncMock(side_effect=turn_off)
await hass.services.async_call(
"light",
SERVICE_TURN_OFF,
{"entity_id": entity_id},
blocking=True,
)
state = hass.states.get(entity_id)
assert ATTR_WHITE_VALUE not in state.attributes
assert ATTR_HS_COLOR not in state.attributes
assert state.state == STATE_OFF
@pytest.mark.parametrize("feature", ALL_LIGHT_FIXTURES, indirect=["feature"])
async def test_update_failure(feature, hass, config, caplog):
"""Test that update failures are logged."""
caplog.set_level(logging.ERROR)
feature_mock, entity_id = feature
feature_mock.async_update = AsyncMock(side_effect=blebox_uniapi.error.ClientError)
await async_setup_entity(hass, config, entity_id)
assert f"Updating '{feature_mock.full_name}' failed: " in caplog.text
@pytest.mark.parametrize("feature", ALL_LIGHT_FIXTURES, indirect=["feature"])
async def test_turn_on_failure(feature, hass, config, caplog):
"""Test that turn_on failures are logged."""
caplog.set_level(logging.ERROR)
feature_mock, entity_id = feature
feature_mock.async_on = AsyncMock(side_effect=blebox_uniapi.error.BadOnValueError)
await async_setup_entity(hass, config, entity_id)
feature_mock.sensible_on_value = 123
await hass.services.async_call(
"light",
SERVICE_TURN_ON,
{"entity_id": entity_id},
blocking=True,
)
assert (
f"Turning on '{feature_mock.full_name}' failed: Bad value 123 ()" in caplog.text
)
|
from test import CollectorTestCase
from test import get_collector_config
from snmpinterface import SNMPInterfaceCollector
class TestSNMPInterfaceCollector(CollectorTestCase):
def setUp(self, allowed_names=None):
if not allowed_names:
allowed_names = []
config = get_collector_config('SNMPInterfaceCollector', {
})
self.collector = SNMPInterfaceCollector(config, None)
def test_import(self):
self.assertTrue(SNMPInterfaceCollector)
|
import numpy as np
from ..utils import read_str
def _unpack_matrix(fid, rows, cols, dtype, out_dtype):
"""Unpack matrix."""
dtype = np.dtype(dtype)
string = fid.read(int(dtype.itemsize * rows * cols))
out = np.frombuffer(string, dtype=dtype).reshape(
rows, cols).astype(out_dtype)
return out
def _unpack_simple(fid, dtype, out_dtype):
"""Unpack a NumPy type."""
dtype = np.dtype(dtype)
string = fid.read(dtype.itemsize)
out = np.frombuffer(string, dtype=dtype).astype(out_dtype)
if len(out) > 0:
out = out[0]
return out
def read_char(fid, count=1):
"""Read character from bti file."""
return _unpack_simple(fid, '>S%s' % count, 'S')
def read_bool(fid):
"""Read bool value from bti file."""
return _unpack_simple(fid, '>?', bool)
def read_uint8(fid):
"""Read unsigned 8bit integer from bti file."""
return _unpack_simple(fid, '>u1', np.uint8)
def read_int8(fid):
"""Read 8bit integer from bti file."""
return _unpack_simple(fid, '>i1', np.int8)
def read_uint16(fid):
"""Read unsigned 16bit integer from bti file."""
return _unpack_simple(fid, '>u2', np.uint16)
def read_int16(fid):
"""Read 16bit integer from bti file."""
return _unpack_simple(fid, '>i2', np.int16)
def read_uint32(fid):
"""Read unsigned 32bit integer from bti file."""
return _unpack_simple(fid, '>u4', np.uint32)
def read_int32(fid):
"""Read 32bit integer from bti file."""
return _unpack_simple(fid, '>i4', np.int32)
def read_uint64(fid):
"""Read unsigned 64bit integer from bti file."""
return _unpack_simple(fid, '>u8', np.uint64)
def read_int64(fid):
"""Read 64bit integer from bti file."""
return _unpack_simple(fid, '>u8', np.int64)
def read_float(fid):
"""Read 32bit float from bti file."""
return _unpack_simple(fid, '>f4', np.float32)
def read_double(fid):
"""Read 64bit float from bti file."""
return _unpack_simple(fid, '>f8', np.float64)
def read_int16_matrix(fid, rows, cols):
"""Read 16bit integer matrix from bti file."""
return _unpack_matrix(fid, rows, cols, dtype='>i2',
out_dtype=np.int16)
def read_float_matrix(fid, rows, cols):
"""Read 32bit float matrix from bti file."""
return _unpack_matrix(fid, rows, cols, dtype='>f4',
out_dtype=np.float32)
def read_double_matrix(fid, rows, cols):
"""Read 64bit float matrix from bti file."""
return _unpack_matrix(fid, rows, cols, dtype='>f8',
out_dtype=np.float64)
def read_transform(fid):
"""Read 64bit float matrix transform from bti file."""
return read_double_matrix(fid, rows=4, cols=4)
def read_dev_header(x):
"""Create a dev header."""
return dict(size=read_int32(x), checksum=read_int32(x),
reserved=read_str(x, 32))
|
import asyncio
from datetime import timedelta
import functools
import logging
from typing import Optional
import aiohttp
from async_upnp_client import UpnpFactory
from async_upnp_client.aiohttp import AiohttpNotifyServer, AiohttpSessionRequester
from async_upnp_client.profiles.dlna import DeviceState, DmrDevice
import voluptuous as vol
from homeassistant.components.media_player import PLATFORM_SCHEMA, MediaPlayerEntity
from homeassistant.components.media_player.const import (
MEDIA_TYPE_CHANNEL,
MEDIA_TYPE_EPISODE,
MEDIA_TYPE_IMAGE,
MEDIA_TYPE_MOVIE,
MEDIA_TYPE_MUSIC,
MEDIA_TYPE_PLAYLIST,
MEDIA_TYPE_TVSHOW,
MEDIA_TYPE_VIDEO,
SUPPORT_NEXT_TRACK,
SUPPORT_PAUSE,
SUPPORT_PLAY,
SUPPORT_PLAY_MEDIA,
SUPPORT_PREVIOUS_TRACK,
SUPPORT_SEEK,
SUPPORT_STOP,
SUPPORT_VOLUME_MUTE,
SUPPORT_VOLUME_SET,
)
from homeassistant.const import (
CONF_NAME,
CONF_URL,
EVENT_HOMEASSISTANT_STOP,
STATE_IDLE,
STATE_OFF,
STATE_ON,
STATE_PAUSED,
STATE_PLAYING,
)
from homeassistant.exceptions import PlatformNotReady
from homeassistant.helpers.aiohttp_client import async_get_clientsession
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.typing import HomeAssistantType
from homeassistant.util import get_local_ip
import homeassistant.util.dt as dt_util
_LOGGER = logging.getLogger(__name__)
DLNA_DMR_DATA = "dlna_dmr"
DEFAULT_NAME = "DLNA Digital Media Renderer"
DEFAULT_LISTEN_PORT = 8301
CONF_LISTEN_IP = "listen_ip"
CONF_LISTEN_PORT = "listen_port"
CONF_CALLBACK_URL_OVERRIDE = "callback_url_override"
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
{
vol.Required(CONF_URL): cv.string,
vol.Optional(CONF_LISTEN_IP): cv.string,
vol.Optional(CONF_LISTEN_PORT, default=DEFAULT_LISTEN_PORT): cv.port,
vol.Optional(CONF_NAME, default=DEFAULT_NAME): cv.string,
vol.Optional(CONF_CALLBACK_URL_OVERRIDE): cv.url,
}
)
HOME_ASSISTANT_UPNP_CLASS_MAPPING = {
MEDIA_TYPE_MUSIC: "object.item.audioItem",
MEDIA_TYPE_TVSHOW: "object.item.videoItem",
MEDIA_TYPE_MOVIE: "object.item.videoItem",
MEDIA_TYPE_VIDEO: "object.item.videoItem",
MEDIA_TYPE_EPISODE: "object.item.videoItem",
MEDIA_TYPE_CHANNEL: "object.item.videoItem",
MEDIA_TYPE_IMAGE: "object.item.imageItem",
MEDIA_TYPE_PLAYLIST: "object.item.playlistItem",
}
UPNP_CLASS_DEFAULT = "object.item"
HOME_ASSISTANT_UPNP_MIME_TYPE_MAPPING = {
MEDIA_TYPE_MUSIC: "audio/*",
MEDIA_TYPE_TVSHOW: "video/*",
MEDIA_TYPE_MOVIE: "video/*",
MEDIA_TYPE_VIDEO: "video/*",
MEDIA_TYPE_EPISODE: "video/*",
MEDIA_TYPE_CHANNEL: "video/*",
MEDIA_TYPE_IMAGE: "image/*",
MEDIA_TYPE_PLAYLIST: "playlist/*",
}
def catch_request_errors():
"""Catch asyncio.TimeoutError, aiohttp.ClientError errors."""
def call_wrapper(func):
"""Call wrapper for decorator."""
@functools.wraps(func)
async def wrapper(self, *args, **kwargs):
"""Catch asyncio.TimeoutError, aiohttp.ClientError errors."""
try:
return await func(self, *args, **kwargs)
except (asyncio.TimeoutError, aiohttp.ClientError):
_LOGGER.error("Error during call %s", func.__name__)
return wrapper
return call_wrapper
async def async_start_event_handler(
hass: HomeAssistantType,
server_host: str,
server_port: int,
requester,
callback_url_override: Optional[str] = None,
):
"""Register notify view."""
hass_data = hass.data[DLNA_DMR_DATA]
if "event_handler" in hass_data:
return hass_data["event_handler"]
# start event handler
server = AiohttpNotifyServer(
requester,
listen_port=server_port,
listen_host=server_host,
callback_url=callback_url_override,
)
await server.start_server()
_LOGGER.info("UPNP/DLNA event handler listening, url: %s", server.callback_url)
hass_data["notify_server"] = server
hass_data["event_handler"] = server.event_handler
# register for graceful shutdown
async def async_stop_server(event):
"""Stop server."""
_LOGGER.debug("Stopping UPNP/DLNA event handler")
await server.stop_server()
hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, async_stop_server)
return hass_data["event_handler"]
async def async_setup_platform(
hass: HomeAssistantType, config, async_add_entities, discovery_info=None
):
"""Set up DLNA DMR platform."""
if config.get(CONF_URL) is not None:
url = config[CONF_URL]
name = config.get(CONF_NAME)
elif discovery_info is not None:
url = discovery_info["ssdp_description"]
name = discovery_info.get("name")
if DLNA_DMR_DATA not in hass.data:
hass.data[DLNA_DMR_DATA] = {}
if "lock" not in hass.data[DLNA_DMR_DATA]:
hass.data[DLNA_DMR_DATA]["lock"] = asyncio.Lock()
# build upnp/aiohttp requester
session = async_get_clientsession(hass)
requester = AiohttpSessionRequester(session, True)
# ensure event handler has been started
async with hass.data[DLNA_DMR_DATA]["lock"]:
server_host = config.get(CONF_LISTEN_IP)
if server_host is None:
server_host = get_local_ip()
server_port = config.get(CONF_LISTEN_PORT, DEFAULT_LISTEN_PORT)
callback_url_override = config.get(CONF_CALLBACK_URL_OVERRIDE)
event_handler = await async_start_event_handler(
hass, server_host, server_port, requester, callback_url_override
)
# create upnp device
factory = UpnpFactory(requester, disable_state_variable_validation=True)
try:
upnp_device = await factory.async_create_device(url)
except (asyncio.TimeoutError, aiohttp.ClientError) as err:
raise PlatformNotReady() from err
# wrap with DmrDevice
dlna_device = DmrDevice(upnp_device, event_handler)
# create our own device
device = DlnaDmrDevice(dlna_device, name)
_LOGGER.debug("Adding device: %s", device)
async_add_entities([device], True)
class DlnaDmrDevice(MediaPlayerEntity):
"""Representation of a DLNA DMR device."""
def __init__(self, dmr_device, name=None):
"""Initialize DLNA DMR device."""
self._device = dmr_device
self._name = name
self._available = False
self._subscription_renew_time = None
async def async_added_to_hass(self):
"""Handle addition."""
self._device.on_event = self._on_event
# Register unsubscribe on stop
bus = self.hass.bus
bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, self._async_on_hass_stop)
@property
def available(self):
"""Device is available."""
return self._available
async def _async_on_hass_stop(self, event):
"""Event handler on Home Assistant stop."""
async with self.hass.data[DLNA_DMR_DATA]["lock"]:
await self._device.async_unsubscribe_services()
async def async_update(self):
"""Retrieve the latest data."""
was_available = self._available
try:
await self._device.async_update()
self._available = True
except (asyncio.TimeoutError, aiohttp.ClientError):
self._available = False
_LOGGER.debug("Device unavailable")
return
# do we need to (re-)subscribe?
now = dt_util.utcnow()
should_renew = (
self._subscription_renew_time and now >= self._subscription_renew_time
)
if should_renew or not was_available and self._available:
try:
timeout = await self._device.async_subscribe_services()
self._subscription_renew_time = dt_util.utcnow() + timeout / 2
except (asyncio.TimeoutError, aiohttp.ClientError):
self._available = False
_LOGGER.debug("Could not (re)subscribe")
def _on_event(self, service, state_variables):
"""State variable(s) changed, let home-assistant know."""
self.schedule_update_ha_state()
@property
def supported_features(self):
"""Flag media player features that are supported."""
supported_features = 0
if self._device.has_volume_level:
supported_features |= SUPPORT_VOLUME_SET
if self._device.has_volume_mute:
supported_features |= SUPPORT_VOLUME_MUTE
if self._device.has_play:
supported_features |= SUPPORT_PLAY
if self._device.has_pause:
supported_features |= SUPPORT_PAUSE
if self._device.has_stop:
supported_features |= SUPPORT_STOP
if self._device.has_previous:
supported_features |= SUPPORT_PREVIOUS_TRACK
if self._device.has_next:
supported_features |= SUPPORT_NEXT_TRACK
if self._device.has_play_media:
supported_features |= SUPPORT_PLAY_MEDIA
if self._device.has_seek_rel_time:
supported_features |= SUPPORT_SEEK
return supported_features
@property
def volume_level(self):
"""Volume level of the media player (0..1)."""
return self._device.volume_level
@catch_request_errors()
async def async_set_volume_level(self, volume):
"""Set volume level, range 0..1."""
await self._device.async_set_volume_level(volume)
@property
def is_volume_muted(self):
"""Boolean if volume is currently muted."""
return self._device.is_volume_muted
@catch_request_errors()
async def async_mute_volume(self, mute):
"""Mute the volume."""
desired_mute = bool(mute)
await self._device.async_mute_volume(desired_mute)
@catch_request_errors()
async def async_media_pause(self):
"""Send pause command."""
if not self._device.can_pause:
_LOGGER.debug("Cannot do Pause")
return
await self._device.async_pause()
@catch_request_errors()
async def async_media_play(self):
"""Send play command."""
if not self._device.can_play:
_LOGGER.debug("Cannot do Play")
return
await self._device.async_play()
@catch_request_errors()
async def async_media_stop(self):
"""Send stop command."""
if not self._device.can_stop:
_LOGGER.debug("Cannot do Stop")
return
await self._device.async_stop()
@catch_request_errors()
async def async_media_seek(self, position):
"""Send seek command."""
if not self._device.can_seek_rel_time:
_LOGGER.debug("Cannot do Seek/rel_time")
return
time = timedelta(seconds=position)
await self._device.async_seek_rel_time(time)
@catch_request_errors()
async def async_play_media(self, media_type, media_id, **kwargs):
"""Play a piece of media."""
title = "Home Assistant"
mime_type = HOME_ASSISTANT_UPNP_MIME_TYPE_MAPPING.get(media_type, media_type)
upnp_class = HOME_ASSISTANT_UPNP_CLASS_MAPPING.get(
media_type, UPNP_CLASS_DEFAULT
)
# Stop current playing media
if self._device.can_stop:
await self.async_media_stop()
# Queue media
await self._device.async_set_transport_uri(
media_id, title, mime_type, upnp_class
)
await self._device.async_wait_for_can_play()
# If already playing, no need to call Play
if self._device.state == DeviceState.PLAYING:
return
# Play it
await self.async_media_play()
@catch_request_errors()
async def async_media_previous_track(self):
"""Send previous track command."""
if not self._device.can_previous:
_LOGGER.debug("Cannot do Previous")
return
await self._device.async_previous()
@catch_request_errors()
async def async_media_next_track(self):
"""Send next track command."""
if not self._device.can_next:
_LOGGER.debug("Cannot do Next")
return
await self._device.async_next()
@property
def media_title(self):
"""Title of current playing media."""
return self._device.media_title
@property
def media_image_url(self):
"""Image url of current playing media."""
return self._device.media_image_url
@property
def state(self):
"""State of the player."""
if not self._available:
return STATE_OFF
if self._device.state is None:
return STATE_ON
if self._device.state == DeviceState.PLAYING:
return STATE_PLAYING
if self._device.state == DeviceState.PAUSED:
return STATE_PAUSED
return STATE_IDLE
@property
def media_duration(self):
"""Duration of current playing media in seconds."""
return self._device.media_duration
@property
def media_position(self):
"""Position of current playing media in seconds."""
return self._device.media_position
@property
def media_position_updated_at(self):
"""When was the position of the current playing media valid.
Returns value from homeassistant.util.dt.utcnow().
"""
return self._device.media_position_updated_at
@property
def name(self) -> str:
"""Return the name of the device."""
if self._name:
return self._name
return self._device.name
@property
def unique_id(self) -> str:
"""Return an unique ID."""
return self._device.udn
|
import logging
from devolo_home_control_api.mydevolo import Mydevolo
import voluptuous as vol
from homeassistant import config_entries
from homeassistant.const import CONF_PASSWORD, CONF_USERNAME
from homeassistant.core import callback
from .const import ( # pylint:disable=unused-import
CONF_HOMECONTROL,
CONF_MYDEVOLO,
DEFAULT_MPRM,
DEFAULT_MYDEVOLO,
DOMAIN,
)
_LOGGER = logging.getLogger(__name__)
class DevoloHomeControlFlowHandler(config_entries.ConfigFlow, domain=DOMAIN):
"""Handle a devolo HomeControl config flow."""
VERSION = 1
CONNECTION_CLASS = config_entries.CONN_CLASS_CLOUD_PUSH
def __init__(self):
"""Initialize devolo Home Control flow."""
self.data_schema = {
vol.Required(CONF_USERNAME): str,
vol.Required(CONF_PASSWORD): str,
}
async def async_step_user(self, user_input=None):
"""Handle a flow initiated by the user."""
if self.show_advanced_options:
self.data_schema = {
vol.Required(CONF_USERNAME): str,
vol.Required(CONF_PASSWORD): str,
vol.Required(CONF_MYDEVOLO, default=DEFAULT_MYDEVOLO): str,
vol.Required(CONF_HOMECONTROL, default=DEFAULT_MPRM): str,
}
if user_input is None:
return self._show_form(user_input)
user = user_input[CONF_USERNAME]
password = user_input[CONF_PASSWORD]
try:
mydevolo = Mydevolo.get_instance()
except SyntaxError:
mydevolo = Mydevolo()
mydevolo.user = user
mydevolo.password = password
if self.show_advanced_options:
mydevolo.url = user_input[CONF_MYDEVOLO]
mprm = user_input[CONF_HOMECONTROL]
else:
mydevolo.url = DEFAULT_MYDEVOLO
mprm = DEFAULT_MPRM
credentials_valid = await self.hass.async_add_executor_job(
mydevolo.credentials_valid
)
if not credentials_valid:
return self._show_form({"base": "invalid_auth"})
_LOGGER.debug("Credentials valid")
gateway_ids = await self.hass.async_add_executor_job(mydevolo.get_gateway_ids)
await self.async_set_unique_id(gateway_ids[0])
self._abort_if_unique_id_configured()
return self.async_create_entry(
title="devolo Home Control",
data={
CONF_PASSWORD: password,
CONF_USERNAME: user,
CONF_MYDEVOLO: mydevolo.url,
CONF_HOMECONTROL: mprm,
},
)
@callback
def _show_form(self, errors=None):
"""Show the form to the user."""
return self.async_show_form(
step_id="user",
data_schema=vol.Schema(self.data_schema),
errors=errors if errors else {},
)
|
import os
import os.path as op
from shutil import copyfile
import numpy as np
from scipy import sparse
import pytest
from numpy.testing import assert_array_equal, assert_allclose, assert_equal
from mne.datasets import testing
from mne import (read_surface, write_surface, decimate_surface, pick_types,
dig_mri_distances)
from mne.surface import (read_morph_map, _compute_nearest, _tessellate_sphere,
fast_cross_3d, get_head_surf, read_curvature,
get_meg_helmet_surf, _normal_orth, _read_patch)
from mne.utils import (_TempDir, requires_vtk, catch_logging,
run_tests_if_main, object_diff, requires_freesurfer)
from mne.io import read_info
from mne.io.constants import FIFF
from mne.transforms import _get_trans
data_path = testing.data_path(download=False)
subjects_dir = op.join(data_path, 'subjects')
fname = op.join(subjects_dir, 'sample', 'bem',
'sample-1280-1280-1280-bem-sol.fif')
fname_trans = op.join(data_path, 'MEG', 'sample',
'sample_audvis_trunc-trans.fif')
fname_raw = op.join(data_path, 'MEG', 'sample', 'sample_audvis_trunc_raw.fif')
rng = np.random.RandomState(0)
def test_helmet():
"""Test loading helmet surfaces."""
base_dir = op.join(op.dirname(__file__), '..', 'io')
fname_raw = op.join(base_dir, 'tests', 'data', 'test_raw.fif')
fname_kit_raw = op.join(base_dir, 'kit', 'tests', 'data',
'test_bin_raw.fif')
fname_bti_raw = op.join(base_dir, 'bti', 'tests', 'data',
'exported4D_linux_raw.fif')
fname_ctf_raw = op.join(base_dir, 'tests', 'data', 'test_ctf_raw.fif')
fname_trans = op.join(base_dir, 'tests', 'data',
'sample-audvis-raw-trans.txt')
trans = _get_trans(fname_trans)[0]
new_info = read_info(fname_raw)
artemis_info = new_info.copy()
for pick in pick_types(new_info, meg=True):
new_info['chs'][pick]['coil_type'] = 9999
artemis_info['chs'][pick]['coil_type'] = \
FIFF.FIFFV_COIL_ARTEMIS123_GRAD
for info, n, name in [(read_info(fname_raw), 304, '306m'),
(read_info(fname_kit_raw), 150, 'KIT'), # Delaunay
(read_info(fname_bti_raw), 304, 'Magnes'),
(read_info(fname_ctf_raw), 342, 'CTF'),
(new_info, 102, 'unknown'), # Delaunay
(artemis_info, 102, 'ARTEMIS123'), # Delaunay
]:
with catch_logging() as log:
helmet = get_meg_helmet_surf(info, trans, verbose=True)
log = log.getvalue()
assert name in log
assert_equal(len(helmet['rr']), n)
assert_equal(len(helmet['rr']), len(helmet['nn']))
@testing.requires_testing_data
def test_head():
"""Test loading the head surface."""
surf_1 = get_head_surf('sample', subjects_dir=subjects_dir)
surf_2 = get_head_surf('sample', 'head', subjects_dir=subjects_dir)
assert len(surf_1['rr']) < len(surf_2['rr']) # BEM vs dense head
pytest.raises(TypeError, get_head_surf, subject=None,
subjects_dir=subjects_dir)
def test_fast_cross_3d():
"""Test cross product with lots of elements."""
x = rng.rand(100000, 3)
y = rng.rand(1, 3)
z = np.cross(x, y)
zz = fast_cross_3d(x, y)
assert_array_equal(z, zz)
# broadcasting and non-2D
zz = fast_cross_3d(x[:, np.newaxis], y[0])
assert_array_equal(z, zz[:, 0])
def test_compute_nearest():
"""Test nearest neighbor searches."""
x = rng.randn(500, 3)
x /= np.sqrt(np.sum(x ** 2, axis=1))[:, None]
nn_true = rng.permutation(np.arange(500, dtype=np.int64))[:20]
y = x[nn_true]
nn1 = _compute_nearest(x, y, method='BallTree')
nn2 = _compute_nearest(x, y, method='cKDTree')
nn3 = _compute_nearest(x, y, method='cdist')
assert_array_equal(nn_true, nn1)
assert_array_equal(nn_true, nn2)
assert_array_equal(nn_true, nn3)
# test distance support
nnn1 = _compute_nearest(x, y, method='BallTree', return_dists=True)
nnn2 = _compute_nearest(x, y, method='cKDTree', return_dists=True)
nnn3 = _compute_nearest(x, y, method='cdist', return_dists=True)
assert_array_equal(nnn1[0], nn_true)
assert_array_equal(nnn1[1], np.zeros_like(nn1)) # all dists should be 0
assert_equal(len(nnn1), len(nnn2))
for nn1, nn2, nn3 in zip(nnn1, nnn2, nnn3):
assert_array_equal(nn1, nn2)
assert_array_equal(nn1, nn3)
@pytest.mark.slowtest
@testing.requires_testing_data
def test_make_morph_maps():
"""Test reading and creating morph maps."""
# make a new fake subjects_dir
tempdir = _TempDir()
for subject in ('sample', 'sample_ds', 'fsaverage_ds'):
os.mkdir(op.join(tempdir, subject))
os.mkdir(op.join(tempdir, subject, 'surf'))
regs = ('reg', 'left_right') if subject == 'fsaverage_ds' else ('reg',)
for hemi in ['lh', 'rh']:
for reg in regs:
args = [subject, 'surf', hemi + '.sphere.' + reg]
copyfile(op.join(subjects_dir, *args),
op.join(tempdir, *args))
for subject_from, subject_to, xhemi in (
('fsaverage_ds', 'sample_ds', False),
('fsaverage_ds', 'fsaverage_ds', True)):
# trigger the creation of morph-maps dir and create the map
with catch_logging() as log:
mmap = read_morph_map(subject_from, subject_to, tempdir,
xhemi=xhemi, verbose=True)
log = log.getvalue()
assert 'does not exist' in log
assert 'Creating' in log
mmap2 = read_morph_map(subject_from, subject_to, subjects_dir,
xhemi=xhemi)
assert_equal(len(mmap), len(mmap2))
for m1, m2 in zip(mmap, mmap2):
# deal with sparse matrix stuff
diff = (m1 - m2).data
assert_allclose(diff, np.zeros_like(diff), atol=1e-3, rtol=0)
# This will also trigger creation, but it's trivial
with pytest.warns(None):
mmap = read_morph_map('sample', 'sample', subjects_dir=tempdir)
for mm in mmap:
assert (mm - sparse.eye(mm.shape[0], mm.shape[0])).sum() == 0
@testing.requires_testing_data
def test_io_surface():
"""Test reading and writing of Freesurfer surface mesh files."""
tempdir = _TempDir()
fname_quad = op.join(data_path, 'subjects', 'bert', 'surf',
'lh.inflated.nofix')
fname_tri = op.join(data_path, 'subjects', 'sample', 'bem',
'inner_skull.surf')
for fname in (fname_quad, fname_tri):
with pytest.warns(None): # no volume info
pts, tri, vol_info = read_surface(fname, read_metadata=True)
write_surface(op.join(tempdir, 'tmp'), pts, tri, volume_info=vol_info,
overwrite=True)
with pytest.warns(None): # no volume info
c_pts, c_tri, c_vol_info = read_surface(op.join(tempdir, 'tmp'),
read_metadata=True)
assert_array_equal(pts, c_pts)
assert_array_equal(tri, c_tri)
assert_equal(object_diff(vol_info, c_vol_info), '')
if fname != fname_tri: # don't bother testing wavefront for the bigger
continue
# Test writing/reading a Wavefront .obj file
write_surface(op.join(tempdir, 'tmp.obj'), pts, tri, volume_info=None,
overwrite=True)
c_pts, c_tri = read_surface(op.join(tempdir, 'tmp.obj'),
read_metadata=False)
assert_array_equal(pts, c_pts)
assert_array_equal(tri, c_tri)
# reading patches (just a smoke test, let the flatmap viz tests be more
# complete)
fname_patch = op.join(
data_path, 'subjects', 'fsaverage', 'surf', 'rh.cortex.patch.flat')
_read_patch(fname_patch)
@testing.requires_testing_data
def test_read_curv():
"""Test reading curvature data."""
fname_curv = op.join(data_path, 'subjects', 'fsaverage', 'surf', 'lh.curv')
fname_surf = op.join(data_path, 'subjects', 'fsaverage', 'surf',
'lh.inflated')
bin_curv = read_curvature(fname_curv)
rr = read_surface(fname_surf)[0]
assert len(bin_curv) == len(rr)
assert np.logical_or(bin_curv == 0, bin_curv == 1).all()
@requires_vtk
def test_decimate_surface_vtk():
"""Test triangular surface decimation."""
points = np.array([[-0.00686118, -0.10369860, 0.02615170],
[-0.00713948, -0.10370162, 0.02614874],
[-0.00686208, -0.10368247, 0.02588313],
[-0.00713987, -0.10368724, 0.02587745]])
tris = np.array([[0, 1, 2], [1, 2, 3], [0, 3, 1], [1, 2, 0]])
for n_tri in [4, 3, 2]: # quadric decimation creates even numbered output.
_, this_tris = decimate_surface(points, tris, n_tri)
assert len(this_tris) == n_tri if not n_tri % 2 else 2
with pytest.raises(ValueError, match='exceeds number of original'):
decimate_surface(points, tris, len(tris) + 1)
nirvana = 5
tris = np.array([[0, 1, 2], [1, 2, 3], [0, 3, 1], [1, 2, nirvana]])
pytest.raises(ValueError, decimate_surface, points, tris, n_tri)
@requires_freesurfer('mris_sphere')
def test_decimate_surface_sphere():
"""Test sphere mode of decimation."""
rr, tris = _tessellate_sphere(3)
assert len(rr) == 66
assert len(tris) == 128
for kind, n_tri in [('ico', 20), ('oct', 32)]:
with catch_logging() as log:
_, tris_new = decimate_surface(
rr, tris, n_tri, method='sphere', verbose=True)
log = log.getvalue()
assert 'Freesurfer' in log
assert kind in log
assert len(tris_new) == n_tri
@pytest.mark.parametrize('dig_kinds, exclude, count, bounds, outliers', [
('auto', False, 72, (0.001, 0.002), 0),
(('eeg', 'extra', 'cardinal', 'hpi'), False, 146, (0.002, 0.003), 1),
(('eeg', 'extra', 'cardinal', 'hpi'), True, 139, (0.001, 0.002), 0),
])
@testing.requires_testing_data
def test_dig_mri_distances(dig_kinds, exclude, count, bounds, outliers):
"""Test the trans obtained by coregistration."""
info = read_info(fname_raw)
dists = dig_mri_distances(info, fname_trans, 'sample', subjects_dir,
dig_kinds=dig_kinds, exclude_frontal=exclude)
assert dists.shape == (count,)
assert bounds[0] < np.mean(dists) < bounds[1]
assert np.sum(dists > 0.03) == outliers
def test_normal_orth():
"""Test _normal_orth."""
nns = np.eye(3)
for nn in nns:
ori = _normal_orth(nn)
assert_allclose(ori[2], nn, atol=1e-12)
run_tests_if_main()
|
import io
from setuptools import setup, find_packages # pylint: disable=no-name-in-module,import-error
def dependencies(file):
with open(file) as f:
return f.read().splitlines()
with io.open("README.md", encoding='utf-8') as infile:
long_description = infile.read()
setup(
name='halo',
packages=find_packages(exclude=('tests', 'examples')),
version='0.0.29',
license='MIT',
description='Beautiful terminal spinners in Python',
long_description=long_description,
long_description_content_type="text/markdown",
author='Manraj Singh',
author_email='manrajsinghgrover@gmail.com',
url='https://github.com/manrajgrover/halo',
keywords=[
"console",
"loading",
"indicator",
"progress",
"cli",
"spinner",
"spinners",
"terminal",
"term",
"busy",
"wait",
"idle"
],
install_requires=dependencies('requirements.txt'),
tests_require=dependencies('requirements-dev.txt'),
include_package_data=True,
extras_require={
'ipython': [
'IPython==5.7.0',
'ipywidgets==7.1.0',
]
}
)
|
from unittest import TestCase
import numpy as np
import pandas as pd
from scattertext import whitespace_nlp_with_sentences
from scattertext.features.FeatsFromScoredLexicon import FeatsFromScoredLexicon
class TestFeatsFromScoredLexicon(TestCase):
def test_main(self):
lexicon_df = pd.DataFrame({'activation': {'a': 1.3846,
'abandon': 2.375,
'abandoned': 2.1,
'abandonment': 2.0,
'abated': 1.3333},
'imagery': {'a': 1.0,
'abandon': 2.4,
'abandoned': 3.0,
'abandonment': 1.4,
'abated': 1.2},
'pleasantness': {'a': 2.0,
'abandon': 1.0,
'abandoned': 1.1429,
'abandonment': 1.0,
'abated': 1.6667}})
with self.assertRaises(AssertionError):
FeatsFromScoredLexicon(3)
feats_from_scored_lexicon = FeatsFromScoredLexicon(lexicon_df)
self.assertEqual(set(feats_from_scored_lexicon.get_top_model_term_lists().keys()),
set(['activation', 'imagery', 'pleasantness']))
features = feats_from_scored_lexicon.get_doc_metadata(whitespace_nlp_with_sentences('I abandoned a wallet.'))
np.testing.assert_almost_equal(features[['activation', 'imagery', 'pleasantness']],
np.array([1.74230, 2.00000, 1.57145]))
|
import asyncio
from datetime import timedelta
import logging
from aiohttp import ClientConnectionError
from async_timeout import timeout
from pydaikin.daikin_base import Appliance
import voluptuous as vol
from homeassistant.config_entries import SOURCE_IMPORT, ConfigEntry
from homeassistant.const import CONF_API_KEY, CONF_HOST, CONF_HOSTS, CONF_PASSWORD
from homeassistant.exceptions import ConfigEntryNotReady
import homeassistant.helpers.config_validation as cv
from homeassistant.helpers.device_registry import CONNECTION_NETWORK_MAC
from homeassistant.helpers.typing import HomeAssistantType
from homeassistant.util import Throttle
from . import config_flow # noqa: F401
from .const import CONF_UUID, KEY_MAC, TIMEOUT
_LOGGER = logging.getLogger(__name__)
DOMAIN = "daikin"
PARALLEL_UPDATES = 0
MIN_TIME_BETWEEN_UPDATES = timedelta(seconds=60)
COMPONENT_TYPES = ["climate", "sensor", "switch"]
CONFIG_SCHEMA = vol.Schema(
vol.All(
cv.deprecated(DOMAIN, invalidation_version="0.113.0"),
{
DOMAIN: vol.Schema(
{
vol.Optional(CONF_HOSTS, default=[]): vol.All(
cv.ensure_list, [cv.string]
)
}
)
},
),
extra=vol.ALLOW_EXTRA,
)
async def async_setup(hass, config):
"""Establish connection with Daikin."""
if DOMAIN not in config:
return True
hosts = config[DOMAIN][CONF_HOSTS]
if not hosts:
hass.async_create_task(
hass.config_entries.flow.async_init(
DOMAIN, context={"source": SOURCE_IMPORT}
)
)
for host in hosts:
hass.async_create_task(
hass.config_entries.flow.async_init(
DOMAIN, context={"source": SOURCE_IMPORT}, data={CONF_HOST: host}
)
)
return True
async def async_setup_entry(hass: HomeAssistantType, entry: ConfigEntry):
"""Establish connection with Daikin."""
conf = entry.data
# For backwards compat, set unique ID
if entry.unique_id is None:
hass.config_entries.async_update_entry(entry, unique_id=conf[KEY_MAC])
elif ".local" in entry.unique_id:
hass.config_entries.async_update_entry(entry, unique_id=conf[KEY_MAC])
daikin_api = await daikin_api_setup(
hass,
conf[CONF_HOST],
conf.get(CONF_API_KEY),
conf.get(CONF_UUID),
conf.get(CONF_PASSWORD),
)
if not daikin_api:
return False
hass.data.setdefault(DOMAIN, {}).update({entry.entry_id: daikin_api})
for component in COMPONENT_TYPES:
hass.async_create_task(
hass.config_entries.async_forward_entry_setup(entry, component)
)
return True
async def async_unload_entry(hass, config_entry):
"""Unload a config entry."""
await asyncio.wait(
[
hass.config_entries.async_forward_entry_unload(config_entry, component)
for component in COMPONENT_TYPES
]
)
hass.data[DOMAIN].pop(config_entry.entry_id)
if not hass.data[DOMAIN]:
hass.data.pop(DOMAIN)
return True
async def daikin_api_setup(hass, host, key, uuid, password):
"""Create a Daikin instance only once."""
session = hass.helpers.aiohttp_client.async_get_clientsession()
try:
with timeout(TIMEOUT):
device = await Appliance.factory(
host, session, key=key, uuid=uuid, password=password
)
except asyncio.TimeoutError as err:
_LOGGER.debug("Connection to %s timed out", host)
raise ConfigEntryNotReady from err
except ClientConnectionError as err:
_LOGGER.debug("ClientConnectionError to %s", host)
raise ConfigEntryNotReady from err
except Exception: # pylint: disable=broad-except
_LOGGER.error("Unexpected error creating device %s", host)
return None
api = DaikinApi(device)
return api
class DaikinApi:
"""Keep the Daikin instance in one place and centralize the update."""
def __init__(self, device: Appliance):
"""Initialize the Daikin Handle."""
self.device = device
self.name = device.values.get("name", "Daikin AC")
self.ip_address = device.device_ip
self._available = True
@Throttle(MIN_TIME_BETWEEN_UPDATES)
async def async_update(self, **kwargs):
"""Pull the latest data from Daikin."""
try:
await self.device.update_status()
self._available = True
except ClientConnectionError:
_LOGGER.warning("Connection failed for %s", self.ip_address)
self._available = False
@property
def available(self) -> bool:
"""Return True if entity is available."""
return self._available
@property
def device_info(self):
"""Return a device description for device registry."""
info = self.device.values
return {
"connections": {(CONNECTION_NETWORK_MAC, self.device.mac)},
"manufacturer": "Daikin",
"model": info.get("model"),
"name": info.get("name"),
"sw_version": info.get("ver", "").replace("_", "."),
}
|
from openzwavemqtt.const import ATTR_POSITION, ATTR_VALUE
from openzwavemqtt.exceptions import InvalidValueError, NotFoundError, WrongTypeError
import pytest
from .common import setup_ozw
async def test_services(hass, light_data, sent_messages):
"""Test services on lock."""
await setup_ozw(hass, fixture=light_data)
# Test set_config_parameter list by label
await hass.services.async_call(
"ozw",
"set_config_parameter",
{"node_id": 39, "parameter": 1, "value": "Disable"},
blocking=True,
)
assert len(sent_messages) == 1
msg = sent_messages[0]
assert msg["topic"] == "OpenZWave/1/command/setvalue/"
assert msg["payload"] == {"Value": 0, "ValueIDKey": 281475641245716}
# Test set_config_parameter list by index int
await hass.services.async_call(
"ozw",
"set_config_parameter",
{"node_id": 39, "parameter": 1, "value": 1},
blocking=True,
)
assert len(sent_messages) == 2
msg = sent_messages[1]
assert msg["topic"] == "OpenZWave/1/command/setvalue/"
assert msg["payload"] == {"Value": 1, "ValueIDKey": 281475641245716}
# Test set_config_parameter int
await hass.services.async_call(
"ozw",
"set_config_parameter",
{"node_id": 39, "parameter": 3, "value": 55},
blocking=True,
)
assert len(sent_messages) == 3
msg = sent_messages[2]
assert msg["topic"] == "OpenZWave/1/command/setvalue/"
assert msg["payload"] == {"Value": 55, "ValueIDKey": 844425594667027}
# Test set_config_parameter invalid list int
with pytest.raises(NotFoundError):
assert await hass.services.async_call(
"ozw",
"set_config_parameter",
{"node_id": 39, "parameter": 1, "value": 12},
blocking=True,
)
assert len(sent_messages) == 3
# Test set_config_parameter invalid list value
with pytest.raises(NotFoundError):
assert await hass.services.async_call(
"ozw",
"set_config_parameter",
{"node_id": 39, "parameter": 1, "value": "Blah"},
blocking=True,
)
assert len(sent_messages) == 3
# Test set_config_parameter invalid list value type
with pytest.raises(WrongTypeError):
assert await hass.services.async_call(
"ozw",
"set_config_parameter",
{
"node_id": 39,
"parameter": 1,
"value": {ATTR_VALUE: True, ATTR_POSITION: 1},
},
blocking=True,
)
assert len(sent_messages) == 3
# Test set_config_parameter int out of range
with pytest.raises(InvalidValueError):
assert await hass.services.async_call(
"ozw",
"set_config_parameter",
{"node_id": 39, "parameter": 3, "value": 2147483657},
blocking=True,
)
assert len(sent_messages) == 3
# Test set_config_parameter short
await hass.services.async_call(
"ozw",
"set_config_parameter",
{"node_id": 39, "parameter": 81, "value": 3000},
blocking=True,
)
assert len(sent_messages) == 4
msg = sent_messages[3]
assert msg["topic"] == "OpenZWave/1/command/setvalue/"
assert msg["payload"] == {"Value": 3000, "ValueIDKey": 22799473778098198}
# Test set_config_parameter byte
await hass.services.async_call(
"ozw",
"set_config_parameter",
{"node_id": 39, "parameter": 16, "value": 20},
blocking=True,
)
assert len(sent_messages) == 5
msg = sent_messages[4]
assert msg["topic"] == "OpenZWave/1/command/setvalue/"
assert msg["payload"] == {"Value": 20, "ValueIDKey": 4503600291905553}
|
from __future__ import print_function
import configobj
import optparse
import os
import shutil
import sys
import tempfile
import traceback
sys.path.append(os.path.abspath(
os.path.join(os.path.dirname(__file__), 'src')))
def getIncludePaths(path):
for f in os.listdir(path):
cPath = os.path.abspath(os.path.join(path, f))
if os.path.isfile(cPath) and len(f) > 3 and f.endswith('.py'):
sys.path.append(os.path.dirname(cPath))
elif os.path.isdir(cPath):
getIncludePaths(cPath)
collectors = {}
def getCollectors(path):
for f in os.listdir(path):
cPath = os.path.abspath(os.path.join(path, f))
if os.path.isfile(cPath) and len(f) > 3 and f.endswith('.py'):
modname = f[:-3]
if modname.startswith('Test'):
continue
if modname.startswith('test'):
continue
try:
# Import the module
module = __import__(modname, globals(), locals(), ['*'])
# Find the name
for attr in dir(module):
if not attr.endswith('Collector'):
continue
cls = getattr(module, attr)
if cls.__module__ != modname:
continue
if cls.__name__ not in collectors:
collectors[cls.__name__] = module
except Exception:
print("Failed to import module: %s. %s" % (
modname, traceback.format_exc()))
collectors[modname] = False
elif os.path.isdir(cPath):
getCollectors(cPath)
handlers = {}
def getHandlers(path, name=None):
for f in os.listdir(path):
cPath = os.path.abspath(os.path.join(path, f))
if os.path.isfile(cPath) and len(f) > 3 and f.endswith('.py'):
modname = f[:-3]
if name and f is not "%s.py" % name:
break
try:
# Import the module
module = __import__(modname, globals(), locals(), ['*'])
# Find the name
for attr in dir(module):
if ((not attr.endswith('Handler') or
attr.startswith('Handler'))):
continue
cls = getattr(module, attr)
if cls.__name__ not in handlers:
handlers[cls.__name__] = module
except Exception:
print("Failed to import module: %s. %s" % (
modname, traceback.format_exc()))
handlers[modname] = False
elif os.path.isdir(cPath):
getHandlers(cPath)
def writeDocHeader(docFile):
docFile.write("<!--")
docFile.write("This file was generated from the python source\n")
docFile.write("Please edit the source to make changes\n")
docFile.write("-->\n")
def writeDocString(docFile, name, doc):
docFile.write("%s\n" % (name))
docFile.write("=====\n")
if doc is None:
print("No __doc__ string for %s!" % name)
docFile.write("%s\n" % doc)
def writeDocOptionsHeader(docFile):
docFile.write("#### Options\n")
docFile.write("\n")
docFile.write("Setting | Default | Description | Type\n")
docFile.write("--------|---------|-------------|-----\n")
def writeDocOptions(docFile, options, default_options):
for option in sorted(options.keys()):
defaultOption = ''
defaultOptionType = ''
if option in default_options:
defaultOptionType = default_options[option].__class__.__name__
if isinstance(default_options[option], list):
defaultOption = ', '.join(map(str, default_options[option]))
defaultOption += ','
else:
defaultOption = str(default_options[option])
docFile.write("%s | %s | %s | %s\n"
% (option,
defaultOption,
options[option].replace("\n", '<br>\n'),
defaultOptionType))
def writeDoc(items, type_name, doc_path):
for item in sorted(items.iterkeys()):
# Skip configuring the basic item object
if item == type_name:
continue
if item.startswith('Test'):
continue
print("Processing %s..." % (item))
if not hasattr(items[item], item):
continue
cls = getattr(items[item], item)
item_options = None
default_options = None
try:
tmpfile = None
if type_name is "Collector":
obj = cls(config=config, handlers={})
elif type_name is "Handler":
tmpfile = tempfile.mkstemp()
obj = cls({'log_file': tmpfile[1]})
item_options = obj.get_default_config_help()
default_options = obj.get_default_config()
if type_name is "Handler":
os.remove(tmpfile[1])
except Exception as e:
print("Caught Exception {}".format(e))
docFile = open(os.path.join(doc_path, item + ".md"), 'w')
writeDocHeader(docFile)
writeDocString(docFile, item, items[item].__doc__)
writeDocOptionsHeader(docFile)
if item_options:
writeDocOptions(docFile, item_options, default_options)
if type_name is "Collector":
docFile.write("\n")
docFile.write("#### Example Output\n")
docFile.write("\n")
docFile.write("```\n")
docFile.write("__EXAMPLESHERE__\n")
docFile.write("```\n")
docFile.write("\n")
docFile.close()
##########################################################################
if __name__ == "__main__":
# Initialize Options
parser = optparse.OptionParser()
parser.add_option("-c", "--configfile",
dest="configfile",
default="/etc/diamond/diamond.conf",
help="Path to the config file")
parser.add_option("-C", "--collector",
dest="collector",
default=None,
help="Configure a single collector")
parser.add_option("-H", "--handler",
dest="handler",
default=None,
help="Configure a single handler")
parser.add_option("-p", "--print",
action="store_true",
dest="dump",
default=False,
help="Just print the defaults")
# Parse Command Line Args
(options, args) = parser.parse_args()
# Initialize Config
if os.path.exists(options.configfile):
config = configobj.ConfigObj(os.path.abspath(options.configfile))
else:
print("ERROR: Config file: %s does not exist." % (
options.configfile), file=sys.stderr)
print(("Please run python config.py -c /path/to/diamond.conf"),
file=sys.stderr)
parser.print_help(sys.stderr)
sys.exit(1)
docs_path = os.path.abspath(os.path.join(
os.path.dirname(__file__), 'docs'))
if options.collector or (not options.collector and not options.handler):
collector_path = config['server']['collectors_path']
collectors_doc_path = os.path.join(docs_path, "collectors")
getIncludePaths(collector_path)
if options.collector:
single_collector_path = os.path.join(collector_path,
options.collector)
getCollectors(single_collector_path)
else:
# Ugly hack for snmp collector overrides
getCollectors(os.path.join(collector_path, 'snmp'))
getCollectors(collector_path)
shutil.rmtree(collectors_doc_path)
os.mkdir(collectors_doc_path)
writeDoc(collectors, "Collector", collectors_doc_path)
if options.handler or (not options.collector and not options.handler):
handler_path = os.path.abspath(os.path.join(os.path.dirname(__file__),
'src',
'diamond',
'handler'))
handlers_doc_path = os.path.join(docs_path, "handlers")
getIncludePaths(handler_path)
if options.handler:
getHandlers(handler_path, name=options.handler)
else:
getHandlers(handler_path)
shutil.rmtree(handlers_doc_path)
os.mkdir(handlers_doc_path)
writeDoc(handlers, "Handler", handlers_doc_path)
|