добавлена возможность восстановления состояний выходов после перезагрузки меги

UA translation update

.experiment.py

@@ -1,56 +1,30 @@
 import asyncio
-from urllib.parse import urlparse, parse_qsl
 from asyncio import Event, FIRST_COMPLETED
 import signal
-import typing
-from logging import getLogger, DEBUG
 
 
 stop = Event()
 loop = asyncio.get_event_loop()
-lg = getLogger(__name__)
-lg.setLevel(DEBUG)
 
 
-def make_handler(get_ans: typing.Callable[[dict], str]):
-
-    async def handler(
-            reader: asyncio.StreamReader,
-            writer: asyncio.StreamWriter,
-    ):
-        data = await reader.read(200)
-        print(data)
-        message = data.decode()
-        addr = writer.get_extra_info('peername')
-        lg.debug('process msg "%s" from %s', message, addr)
-        try:
-            (_, p, *_) = message.split(' ')
-            p = dict(parse_qsl(urlparse(p).query))
-            lg.debug('query %s', p)
-            ans = get_ans(p)
-            ans = f'''HTTP/1.1 200 OK\nContent-Length: {len(ans)}\n\n{ans}'''.encode()  # \nContent-Length: 6
-            ans = b'HTTP/1.1 200 OK\r\n\r\n7:2'
-            print(ans)
-        except Exception as exc:
-            print(exc)
-            lg.exception('process msg "%s" from %s', message, addr)
-            ans = '''HTTP/1.1 500\n\n'''.encode()
-        writer.write(ans)
-        await writer.drain()
-        # writer.transport.close()
-        writer.close()
-        await writer.wait_closed()
-    return handler
+async def handler(
+        reader: asyncio.StreamReader,
+        writer: asyncio.StreamWriter,
+):
+    await reader.read(100)
+    ans = b'HTTP/1.1 200 OK\r\nContent-Length:1\r\n\r\nd'
+    writer.write(ans)
+    await writer.drain()
+    writer.close()
+    await writer.wait_closed()
 
 
 async def serve():
     server = await asyncio.start_server(
-        make_handler(lambda x: '7:2'),
+        handler,
         host='0.0.0.0',
-        port=1111,
+        port=8888,
     )
-    addr = server.sockets[0].getsockname()
-    print(f'Serving on {addr}')
     async with server:
         await asyncio.wait((server.serve_forever(), stop.wait()), return_when=FIRST_COMPLETED)
 
@@ -58,4 +32,4 @@ if __name__ == '__main__':
     loop.add_signal_handler(
         signal.SIGINT, stop.set
     )
-    loop.run_until_complete(serve())
+    loop.run_until_complete(serve())

.github/ISSUE_TEMPLATE/bug-report.md

@@ -24,10 +24,4 @@ megad firmware version:
 If applicable, add screenshots to help explain your problem.
 
 **LOG**
-Просьба прикладывать детальный лог, который можно включить в конфиге так:
-```yaml
-logger:
-  default: info
-  logs:
-    custom_components.mega: debug
-```
+Просьба прикладывать детальный лог, подробная инструкция как включать отладку по [ссылке](https://github.com/andvikt/mega_hacs/wiki/Отладка)

custom_components/mega/__init__.py

@@ -7,24 +7,23 @@ import voluptuous as vol
 
 from homeassistant.const import (
     CONF_SCAN_INTERVAL, CONF_ID, CONF_NAME, CONF_DOMAIN,
-    CONF_UNIT_OF_MEASUREMENT, CONF_HOST
+    CONF_UNIT_OF_MEASUREMENT, CONF_HOST, CONF_VALUE_TEMPLATE
 )
 from homeassistant.core import HomeAssistant, ServiceCall
 from homeassistant.helpers.service import bind_hass
-from homeassistant.helpers.template import Template
 from homeassistant.helpers import config_validation as cv
 from homeassistant.components import mqtt
 from homeassistant.config_entries import ConfigEntry
 from .const import DOMAIN, CONF_INVERT, CONF_RELOAD, PLATFORMS, CONF_PORTS, CONF_CUSTOM, CONF_SKIP, CONF_PORT_TO_SCAN, \
     CONF_MQTT_INPUTS, CONF_HTTP, CONF_RESPONSE_TEMPLATE, CONF_ACTION, CONF_GET_VALUE, CONF_ALLOW_HOSTS, \
-    CONF_CONV_TEMPLATE, CONF_ALL, CONF_FORCE_D
+    CONF_CONV_TEMPLATE, CONF_ALL, CONF_FORCE_D, CONF_DEF_RESPONSE
 from .hub import MegaD
 from .config_flow import ConfigFlow
 from .http import MegaView
 
 _LOGGER = logging.getLogger(__name__)
 
-CUSTOMIZE_PORT = vol.Schema({
+CUSTOMIZE_PORT = {
     vol.Optional(CONF_SKIP, description='исключить порт из сканирования', default=False): bool,
     vol.Optional(CONF_INVERT, default=False): bool,
     vol.Optional(CONF_NAME): vol.Any(str, {
@@ -41,19 +40,24 @@ CUSTOMIZE_PORT = vol.Schema({
                     'сообщение из меги '): cv.template,
     vol.Optional(CONF_ACTION): cv.script_action, # пока не реализовано
     vol.Optional(CONF_GET_VALUE, default=True): bool,
-    vol.Optional(CONF_CONV_TEMPLATE): cv.template
-})
-CUSTOMIZE_DS2413 = vol.Schema({
+    vol.Optional(CONF_CONV_TEMPLATE): cv.template,
+    vol.Optional(CONF_VALUE_TEMPLATE): cv.template,
+}
+CUSTOMIZE_DS2413 = {
     vol.Optional(str.lower, description='адрес и индекс устройства'): CUSTOMIZE_PORT
-})
+}
 
 CONFIG_SCHEMA = vol.Schema(
     {
         DOMAIN: {
             vol.Optional(CONF_ALLOW_HOSTS): [str],
-            # vol.Optional(CONF_FORCE_D, description='Принудительно слать d после срабатывания входа', default=False): bool,
             vol.Required(str, description='id меги из веб-интерфейса'): {
                 vol.Optional(CONF_FORCE_D, description='Принудительно слать d после срабатывания входа', default=False): bool,
+                vol.Optional(
+                    CONF_DEF_RESPONSE,
+                    description='Ответ по умолчанию',
+                    default=None
+                ): vol.Any(cv.template, None),
                 vol.Optional(int, description='номер порта'): vol.Any(
                     CUSTOMIZE_PORT,
                     CUSTOMIZE_DS2413,
@@ -124,8 +128,7 @@ async def get_hub(hass, entry):
 async def _add_mega(hass: HomeAssistant, entry: ConfigEntry):
     id = entry.data.get('id', entry.entry_id)
     hub = await get_hub(hass, entry)
-    hass.data[DOMAIN][id] = hass.data[DOMAIN]['__def'] = hub
-    hass.data[DOMAIN][entry.data.get(CONF_HOST)] = hub
+    hass.data[DOMAIN][id] = hub
     hass.data[DOMAIN][CONF_ALL][id] = hub
     if not await hub.authenticate():
         raise Exception("not authentificated")

custom_components/mega/config_flow.py

@@ -10,7 +10,8 @@ from homeassistant.config_entries import ConfigEntry
 from homeassistant.const import CONF_HOST, CONF_ID, CONF_PASSWORD, CONF_SCAN_INTERVAL
 from homeassistant.core import callback, HomeAssistant
 from .const import DOMAIN, CONF_PORT_TO_SCAN, CONF_RELOAD, PLATFORMS, CONF_MQTT_INPUTS, \
-    CONF_NPORTS, CONF_UPDATE_ALL, CONF_POLL_OUTS  # pylint:disable=unused-import
+    CONF_NPORTS, CONF_UPDATE_ALL, CONF_POLL_OUTS, CONF_FAKE_RESPONSE, CONF_FORCE_D, \
+    CONF_ALLOW_HOSTS, CONF_PROTECTED, CONF_RESTORE_ON_RESTART  # pylint:disable=unused-import
 from .hub import MegaD
 from . import exceptions
 
@@ -24,9 +25,14 @@ STEP_USER_DATA_SCHEMA = vol.Schema(
         vol.Optional(CONF_SCAN_INTERVAL, default=0): int,
         vol.Optional(CONF_POLL_OUTS, default=False): bool,
         vol.Optional(CONF_PORT_TO_SCAN, default=0): int,
-        vol.Optional(CONF_MQTT_INPUTS, default=True): bool,
+        vol.Optional(CONF_MQTT_INPUTS, default=False): bool,
         vol.Optional(CONF_NPORTS, default=37): int,
         vol.Optional(CONF_UPDATE_ALL, default=True): bool,
+        vol.Optional(CONF_FAKE_RESPONSE, default=True): bool,
+        vol.Optional(CONF_FORCE_D, default=True): bool,
+        vol.Optional(CONF_RESTORE_ON_RESTART, default=True): bool,
+        vol.Optional(CONF_PROTECTED, default=True): bool,
+        vol.Optional(CONF_ALLOW_HOSTS, default='::1;127.0.0.1'): str,
     },
 )
 
@@ -57,7 +63,7 @@ async def validate_input(hass: core.HomeAssistant, data):
 class ConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
     """Handle a config flow for mega."""
 
-    VERSION = 5
+    VERSION = 11
     CONNECTION_CLASS = config_entries.CONN_CLASS_ASSUMED
 
     async def async_step_user(self, user_input=None):
@@ -107,7 +113,7 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
 
     async def async_step_init(self, user_input=None):
         """Manage the options."""
-
+        hub = await get_hub(self.hass, self.config_entry.data)
         if user_input is not None:
             reload = user_input.pop(CONF_RELOAD)
             cfg = dict(self.config_entry.data)
@@ -138,6 +144,11 @@ class OptionsFlowHandler(config_entries.OptionsFlow):
                 vol.Optional(CONF_NPORTS, default=e.get(CONF_NPORTS, 37)): int,
                 vol.Optional(CONF_RELOAD, default=False): bool,
                 vol.Optional(CONF_UPDATE_ALL, default=e.get(CONF_UPDATE_ALL, True)): bool,
+                vol.Optional(CONF_FAKE_RESPONSE, default=e.get(CONF_FAKE_RESPONSE, True)): bool,
+                vol.Optional(CONF_FORCE_D, default=e.get(CONF_FORCE_D, False)): bool,
+                vol.Optional(CONF_RESTORE_ON_RESTART, default=e.get(CONF_RESTORE_ON_RESTART, False)): bool,
+                vol.Optional(CONF_PROTECTED, default=e.get(CONF_PROTECTED, True)): bool,
+                vol.Optional(CONF_ALLOW_HOSTS, default='::1;127.0.0.1'): str,
                 # vol.Optional(CONF_INVERT, default=''): str,
             }),
         )

custom_components/mega/const.py

@@ -23,11 +23,15 @@ CONF_NPORTS = 'nports'
 CONF_RESPONSE_TEMPLATE = 'response_template'
 CONF_ACTION = 'action'
 CONF_UPDATE_ALL = 'update_all'
+CONF_FAKE_RESPONSE = 'fake_response'
 CONF_GET_VALUE = 'get_value'
 CONF_ALLOW_HOSTS = 'allow_hosts'
+CONF_PROTECTED = 'protected'
 CONF_CONV_TEMPLATE = 'conv_template'
 CONF_POLL_OUTS = 'poll_outs'
 CONF_FORCE_D = 'force_d'
+CONF_DEF_RESPONSE = 'def_response'
+CONF_RESTORE_ON_RESTART = 'restore_on_restart'
 PLATFORMS = [
     "light",
     "switch",

custom_components/mega/entities.py

@@ -48,6 +48,9 @@ class BaseMegaEntity(CoordinatorEntity, RestoreEntity):
             index=None,
     ):
         super().__init__(mega.updater)
+
+        self.http_cmd = http_cmd
+
         self._state: State = None
         self.port = port
         self.config_entry = config_entry
@@ -60,9 +63,10 @@ class BaseMegaEntity(CoordinatorEntity, RestoreEntity):
         self._name = name or f"{mega.id}_{port}" + \
                             (f"_{id_suffix}" if id_suffix else "")
         self._customize: dict = None
-        self.http_cmd = http_cmd
         self.index = index
         self.addr = addr
+        if self.http_cmd == 'ds2413':
+            self.mega.ds2413_ports |= {self.port}
 
     @property
     def customize(self):
@@ -125,7 +129,8 @@ class BaseMegaEntity(CoordinatorEntity, RestoreEntity):
             _task_set_ev_on = asyncio.create_task(_set_events_on())
 
     async def get_state(self):
-        if self.mega.mqtt is None:
+        self.lg.debug(f'state is %s', self.state)
+        if not self.mega.mqtt_inputs:
             self.async_write_ha_state()
 
 
@@ -218,9 +223,9 @@ class MegaOutPort(MegaPushEntity):
         self._is_on = None
         self.dimmer = dimmer
 
-    @property
-    def assumed_state(self) -> bool:
-        return True if self.index is not None or self.mega.mqtt is None else False
+    # @property
+    # def assumed_state(self) -> bool:
+    #     return True if self.index is not None or self.mega.mqtt is None else False
 
     @property
     def invert(self):
@@ -248,21 +253,25 @@ class MegaOutPort(MegaPushEntity):
             return self._state == 'ON'
         elif val is not None:
             val = val.get("value")
-            if self.index and self.addr:
-                _val = val.get(self.addr)
-                if not isinstance(val, str):
-                    self.mega.lg.warning(f'{self} has wrong state: {val}')
+            if not isinstance(val, str) and self.index is not None and self.addr is not None:
+                if not isinstance(val, dict):
+                    self.mega.lg.warning(f'{self.entity_id}: {val} is not a dict')
+                    return
+                _val = val.get(self.addr, val.get(self.addr.lower(), val.get(self.addr.upper())))
+                if not isinstance(_val, str):
+                    self.mega.lg.warning(f'{self.entity_id}: can not get {self.addr} from {val}, recieved {_val}')
                     return
                 _val = _val.split('/')
                 if len(_val) >= 2:
-                    val = val[self.index]
+                    self.mega.lg.debug('%s parsed values: %s[%s]="%s"', self.entity_id, _val, self.index, _val)
+                    val = _val[self.index]
                 else:
-                    self.mega.lg.warning(f'{self} has wrong state: {val}')
+                    self.mega.lg.warning(f'{self.entity_id}: {_val} has wrong length')
                     return
-            elif self.index and self.addr is None:
-                self.mega.lg.warning(f'{self} does not has addr')
+            elif self.index is not None and self.addr is None:
+                self.mega.lg.warning(f'{self.entity_id} does not has addr')
                 return
-
+            self.mega.lg.debug('%s.state = %s', self.entity_id, val)
             if not self.invert:
                 return val == 'ON' or str(val) == '1' or (safe_int(val) is not None and safe_int(val) > 0)
             else:
@@ -284,18 +293,18 @@ class MegaOutPort(MegaPushEntity):
             cmd = brightness
         else:
             cmd = 1 if not self.invert else 0
-        cmd = {"cmd": f"{self.cmd_port}:{cmd}"}
+        _cmd = {"cmd": f"{self.cmd_port}:{cmd}"}
         if self.addr:
-            cmd['addr'] = self.addr
-        await self.mega.request(**cmd)
+            _cmd['addr'] = self.addr
+        await self.mega.request(**_cmd)
         if self.index is not None:
             # обновление текущего стейта для ds2413
-            self.hass.async_create_task(self.mega.get_port(
+            await self.mega.get_port(
                 port=self.port,
                 force_http=True,
                 conv=False,
                 http_cmd='list',
-            ))
+            )
         else:
             self.mega.values[self.port] = {'value': cmd}
         await self.get_state()
@@ -303,18 +312,18 @@ class MegaOutPort(MegaPushEntity):
     async def async_turn_off(self, **kwargs) -> None:
 
         cmd = "0" if not self.invert else "1"
-        cmd = {"cmd": f"{self.cmd_port}:{cmd}"}
+        _cmd = {"cmd": f"{self.cmd_port}:{cmd}"}
         if self.addr:
-            cmd['addr'] = self.addr
-        await self.mega.request(**cmd)
+            _cmd['addr'] = self.addr
+        await self.mega.request(**_cmd)
         if self.index is not None:
             # обновление текущего стейта для ds2413
-            self.hass.async_create_task(self.mega.get_port(
+            await self.mega.get_port(
                 port=self.port,
                 force_http=True,
                 conv=False,
                 http_cmd='list',
-            ))
+            )
         else:
             self.mega.values[self.port] = {'value': cmd}
         await self.get_state()

custom_components/mega/http.py

@@ -24,7 +24,9 @@ class MegaView(HomeAssistantView):
 
     def __init__(self, cfg: dict):
         self._try = 0
-        self.allowed_hosts = {'::1'}
+        self.protected = True
+        self.allowed_hosts = {'::1', '127.0.0.1'}
+        self.notified_attempts = defaultdict(lambda : False)
         self.callbacks = defaultdict(lambda: defaultdict(list))
         self.templates: typing.Dict[str, typing.Dict[str, Template]] = {
             mid: {
@@ -34,23 +36,43 @@ class MegaView(HomeAssistantView):
             } for mid in cfg if isinstance(cfg[mid], dict)
         }
         _LOGGER.debug('templates: %s', self.templates)
+        self.hubs = {}
 
     async def get(self, request: Request) -> Response:
-
-        auth = False
-        for x in self.allowed_hosts:
-            if request.remote.startswith(x):
-                auth = True
-                break
-        if not auth:
-            _LOGGER.warning(f'unauthorised attempt to connect from {request.remote}')
-            return Response(status=401)
-
+        _LOGGER.debug('request from %s %s', request.remote, request.headers)
         hass: HomeAssistant = request.app['hass']
-        hub: 'h.MegaD' = hass.data.get(DOMAIN).get(request.remote)  # TODO: проверить какой remote
-        if hub is None and request.remote == '::1':
-            hub = hass.data.get(DOMAIN).get('__def')
-        if hub is None:
+        if self.protected:
+            auth = False
+            for x in self.allowed_hosts:
+                if request.remote.startswith(x):
+                    auth = True
+                    break
+            if not auth:
+                msg = f"Non-authorised request from {request.remote} to `/mega`. "\
+                      f"If you want to accept requests from this host "\
+                      f"please add it to allowed hosts in `mega` UI-configuration"
+                if not self.notified_attempts[request.remote]:
+                    await hass.services.async_call(
+                        'persistent_notification',
+                        'create',
+                        {
+                            "notification_id": request.remote,
+                            "title": "Non-authorised request",
+                            "message": msg
+                        }
+                    )
+                _LOGGER.warning(msg)
+                return Response(status=401)
+
+        remote = request.headers.get('X-Real-IP', request.remote)
+        hub: 'h.MegaD' = self.hubs.get(remote)
+        if hub is None and 'mdid' in request.query:
+            hub = self.hubs.get(request.query['mdid'])
+            if hub is None:
+                _LOGGER.warning(f'can not find mdid={request.query["mdid"]} in {list(self.hubs)}')
+        if hub is None and request.remote in ['::1', '127.0.0.1']:
+            hub = self.hubs.get('__def')
+        elif hub is None:
             return Response(status=400)
         data = dict(request.query)
         hass.bus.async_fire(
@@ -59,6 +81,9 @@ class MegaView(HomeAssistantView):
         )
         _LOGGER.debug(f"Request: %s from '%s'", data, request.remote)
         make_ints(data)
+        if data.get('st') == '1' and hub.restore_on_restart:
+            asyncio.create_task(self.later_restore(hub))
+            return Response(status=200)
         port = data.get('pt')
         data = data.copy()
         update_all = True
@@ -66,23 +91,39 @@ class MegaView(HomeAssistantView):
             update_all = False
             data['value'] = data.pop('v')
         data['mega_id'] = hub.id
-        ret = 'd'
+        ret = 'd' if hub.force_d else ''
         if port is not None:
             hub.values[port] = data
             for cb in self.callbacks[hub.id][port]:
                 cb(data)
-            template: Template = self.templates.get(hub.id, {}).get(port)
+            template: Template = self.templates.get(hub.id, {}).get(port, hub.def_response)
             if hub.update_all and update_all:
                 asyncio.create_task(self.later_update(hub))
             if template is not None:
                 template.hass = hass
                 ret = template.async_render(data)
         _LOGGER.debug('response %s', ret)
-        ret = Response(body=ret or 'd', content_type='text/plain', headers={'Server': 's', 'Date': 'n'})
+        Response(body='' if hub.fake_response else ret, content_type='text/plain')
+
+        if hub.fake_response and 'value' not in data and 'pt' in data:
+            if 'd' in ret:
+                await hub.request(pt=port, cmd=ret)
+            else:
+                await hub.request(cmd=ret)
         return ret
 
+    async def later_restore(self, hub):
+        """
+        Восстановление всех выходов с небольшой задержкой. Задержка нужна чтобы ответ прошел успешно
+
+        :param hub:
+        :return:
+        """
+        await asyncio.sleep(0.2)
+        await hub.restore_states()
+
     async def later_update(self, hub):
-        _LOGGER.debug('force update')
         await asyncio.sleep(1)
+        _LOGGER.debug('force update')
         await hub.updater.async_refresh()
 

custom_components/mega/hub.py

@@ -19,9 +19,9 @@ from homeassistant.helpers.update_coordinator import DataUpdateCoordinator
 from .const import (
     TEMP, HUM, PRESS,
     LUX, PATT_SPLIT, DOMAIN,
-    CONF_HTTP, EVENT_BINARY_SENSOR, CONF_CUSTOM, CONF_FORCE_D
+    CONF_HTTP, EVENT_BINARY_SENSOR, CONF_CUSTOM, CONF_FORCE_D, CONF_DEF_RESPONSE
 )
-from .entities import set_events_off, BaseMegaEntity
+from .entities import set_events_off, BaseMegaEntity, MegaOutPort
 from .exceptions import CannotConnect, NoPort
 from .tools import make_ints
 
@@ -72,9 +72,13 @@ class MegaD:
             scan_interval=60,
             port_to_scan=0,
             nports=38,
-            inverted: typing.List[int] = None,
-            update_all=True,
-            poll_outs=False,
+            update_all: bool=True,
+            poll_outs: bool=False,
+            fake_response: bool=True,
+            force_d: bool=None,
+            allow_hosts: str=None,
+            protected=True,
+            restore_on_restart=False,
             **kwargs,
     ):
         """Initialize."""
@@ -82,11 +86,17 @@ class MegaD:
             self.http = hass.data.get(DOMAIN, {}).get(CONF_HTTP)
             if not self.http is None:
                 self.http.allowed_hosts |= {host}
+                self.http.hubs[host] = self
+                if len(self.http.hubs) == 1:
+                    self.http.hubs['__def'] = self
+                if mqtt_id:
+                    self.http.hubs[mqtt_id] = self
         else:
             self.http = None
         self.poll_outs = poll_outs
         self.update_all = update_all if update_all is not None else True
         self.nports = nports
+        self.fake_response = fake_response
         self.mqtt_inputs = mqtt_inputs
         self.loop: asyncio.AbstractEventLoop = None
         self.hass = hass
@@ -101,6 +111,7 @@ class MegaD:
         self.cnd = asyncio.Condition()
         self.online = True
         self.entities: typing.List[BaseMegaEntity] = []
+        self.ds2413_ports = set()
         self.poll_interval = scan_interval
         self.subs = None
         self.lg: logging.Logger = lg.getChild(self.id)
@@ -126,6 +137,17 @@ class MegaD:
             self.mqtt_id = f"megad/{_id}"
         else:
             self.mqtt_id = mqtt_id
+        self.restore_on_restart = restore_on_restart
+        if force_d is not None:
+            self.customize[CONF_FORCE_D] = force_d
+        try:
+            if allow_hosts is not None:
+                allow_hosts = set(allow_hosts.split(';'))
+                hass.data[DOMAIN][CONF_HTTP].allowed_hosts |= allow_hosts
+            hass.data[DOMAIN][CONF_HTTP].protected = protected
+
+        except Exception:
+            self.lg.exception('while setting allowed hosts')
 
     async def start(self):
         self.loop = asyncio.get_event_loop()
@@ -170,6 +192,10 @@ class MegaD:
     def force_d(self):
         return self.customize.get(CONF_FORCE_D, False)
 
+    @property
+    def def_response(self):
+        return self.customize.get(CONF_DEF_RESPONSE, None)
+
     @property
     def is_online(self):
         return (datetime.now() - self.last_update).total_seconds() < (self.poll_interval + 10)
@@ -191,20 +217,25 @@ class MegaD:
             )
             self.online = True
 
+    async def _get_ds2413(self):
+        """
+        обновление ds2413 устройств
+        :return:
+        """
+        for x in self.ds2413_ports:
+            self.lg.debug(f'poll ds2413 for %s', x)
+            await self.get_port(
+                port=x,
+                force_http=True,
+                http_cmd='list',
+                conv=False
+            )
+
     async def poll(self):
         """
         Polling ports
         """
         self.lg.debug('poll')
-        for x in self.entities:
-            # обновление ds2413 устройств
-            if x.http_cmd == 'ds2413':
-                await self.get_port(
-                    port=x.port,
-                    force_http=True,
-                    http_cmd='list',
-                    conv=False
-                )
         if self.mqtt is None:
             await self.get_all_ports()
             await self.get_sensors(only_list=True)
@@ -214,6 +245,7 @@ class MegaD:
             await self.get_sensors()
         else:
             await self.get_port(self.port_to_scan)
+        await self._get_ds2413()
         return self.values
 
     async def get_mqtt_id(self):
@@ -247,13 +279,18 @@ class MegaD:
     async def save(self):
         await self.send_command(cmd='s')
 
-    def parse_response(self, ret):
+    def parse_response(self, ret, cmd='get'):
         if ret is None:
             raise NoPort()
         if 'busy' in ret:
             return None
         if ':' in ret:
-            ret = PATT_SPLIT.split(ret)
+            if ';' in ret:
+                ret = ret.split(';')
+            elif '/' in ret and not cmd == 'list':
+                ret = ret.split('/')
+            else:
+                ret = [ret]
             ret = {'value': dict([
                 x.split(':') for x in ret if x.count(':') == 1
             ])}
@@ -275,7 +312,7 @@ class MegaD:
             if http_cmd == 'list' and conv:
                 await self.request(pt=port, cmd='conv')
                 await asyncio.sleep(1)
-            ret = self.parse_response(await self.request(pt=port, cmd=http_cmd))
+            ret = self.parse_response(await self.request(pt=port, cmd=http_cmd), cmd=http_cmd)
             ntry = 0
             while http_cmd == 'list' and ret is None and ntry < 3:
                 await asyncio.sleep(1)
@@ -308,6 +345,8 @@ class MegaD:
         if not self.mqtt_inputs:
             ret = await self.request(cmd='all')
             for port, x in enumerate(ret.split(';')):
+                if port in self.ds2413_ports:
+                    continue
                 if check_skip and not port in self.ports:
                     continue
                 ret = self.parse_response(x)
@@ -442,6 +481,7 @@ class MegaD:
 
     async def get_config(self, nports=37):
         ret = defaultdict(lambda: defaultdict(list))
+        ret['mqtt_id'] = await self.get_mqtt_id()
         async for port, pty, m in self.scan_ports(nports):
             if pty == "0":
                 ret['binary_sensor'][port].append({})
@@ -455,17 +495,22 @@ class MegaD:
                     self.lg.warning(f'can not add ds2413 on port {port}, it has wrong data: {_data}')
                     continue
                 for addr, state in data.items():
-                    ret['light'][port].append([
+                    ret['light'][port].extend([
                         {"index": 0, "addr": addr, "id_suffix": f'{addr}_a', "http_cmd": 'ds2413'},
                         {"index": 1, "addr": addr, "id_suffix": f'{addr}_b', "http_cmd": 'ds2413'},
                     ])
             elif pty in ('3', '2', '4'):
                 try:
                     http_cmd = 'get'
-                    values = await self.get_port(port, force_http=True)
-                    if values is None or (isinstance(values, dict) and str(values.get('value')) in ('', 'None')):
+                    if m == '5' and pty == '3':
+                        # 1-wire bus
                         values = await self.get_port(port, force_http=True, http_cmd='list')
                         http_cmd = 'list'
+                    else:
+                        values = await self.get_port(port, force_http=True)
+                        if values is None or (isinstance(values, dict) and str(values.get('value')) in ('', 'None')):
+                            values = await self.get_port(port, force_http=True, http_cmd='list')
+                            http_cmd = 'list'
                 except asyncio.TimeoutError:
                     self.lg.warning(f'timout on port {port}')
                     continue
@@ -493,4 +538,12 @@ class MegaD:
                     ))
         return ret
 
+    async def restore_states(self):
+        for x in self.entities:
+            if isinstance(x, MegaOutPort):
+                if x.is_on:
+                    await x.async_turn_on(brightness=x.brightness)
+                else:
+                    await x.async_turn_off()
+
 

custom_components/mega/manifest.json

@@ -15,5 +15,5 @@
     "@andvikt"
   ],
   "issue_tracker": "https://github.com/andvikt/mega_hacs/issues",
-  "version": "v0.4.1b"
+  "version": "v0.4.2b1"
 }

custom_components/mega/sensor.py

@@ -13,7 +13,7 @@ from homeassistant.const import (
     CONF_PORT,
     CONF_UNIQUE_ID,
     CONF_ID,
-    CONF_TYPE, CONF_UNIT_OF_MEASUREMENT,
+    CONF_TYPE, CONF_UNIT_OF_MEASUREMENT, CONF_VALUE_TEMPLATE,
 )
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers.template import Template
@@ -163,7 +163,7 @@ class Mega1WSensor(MegaPushEntity):
             ret = str(ret)
         except:
             ret = None
-        tmpl: Template = self.customize.get(CONF_CONV_TEMPLATE)
+        tmpl: Template = self.customize.get(CONF_CONV_TEMPLATE, self.customize.get(CONF_VALUE_TEMPLATE))
         if tmpl is not None and self.hass is not None:
             tmpl.hass = self.hass
             ret = tmpl.async_render({'value': ret})

custom_components/mega/strings.json

@@ -15,6 +15,11 @@
           "mqtt_inputs": "[%key:common::config_flow::data::mqtt_inputs%]",
           "nports": "[%key:common::config_flow::data::nports%]",
           "update_all": "[%key:common::config_flow::data::update_all%]",
+          "fake_response": "[%key:common::config_flow::data::fake_response%]",
+          "force_d": "[%key:common::config_flow::data::force_d%]",
+          "protected": "[%key:common::config_flow::data::protected%]",
+          "allow_hosts": "[%key:common::config_flow::data::allow_hosts%]",
+          "restore_on_restart": "[%key:common::config_flow::data::restore_on_restart%]",
           "poll_outs": "[%key:common::config_flow::data::poll_outs%]"
         }
       }

custom_components/mega/tools.py

@@ -1,5 +1,6 @@
 _params = ['m', 'click', 'cnt', 'pt']
 
+
 def make_ints(d: dict):
     for x in _params:
         try:

custom_components/mega/translations/en.json

@@ -22,7 +22,12 @@
                     "port_to_scan": "Port to poll aliveness (needed only if no sensors used)",
                     "nports": "Number of ports",
                     "update_all": "Update all outs when input",
-                    "mqtt_inputs": "Use MQTT",
+                    "mqtt_inputs": "Use MQTT (Deprecated)",
+                    "fake_response": "Fake response",
+                    "force_d": "Force 'd' response",
+                    "protected": "Protected",
+                    "allow_hosts": "Allowed hosts",
+                    "restore_on_restart": "Restore outs on restart",
                     "poll_outs": "Poll outs"
                 }
             }
@@ -35,8 +40,13 @@
                   "scan_interval": "Scan interval (sec), 0 - don't update",
                   "port_to_scan": "Port to poll aliveness (needed only if no sensors used)",
                   "reload": "Reload objects",
-                  "mqtt_inputs": "Use MQTT",
+                  "mqtt_inputs": "Use MQTT (Deprecated)",
                   "update_all": "Update all outs when input",
+                  "fake_response": "Fake response",
+                  "force_d": "Force 'd' response",
+                  "protected": "Protected",
+                  "allow_hosts": "Allowed hosts",
+                  "restore_on_restart": "Restore outs on restart",
                   "poll_outs": "Poll outs"
                 }
             }

custom_components/mega/translations/ru.json

@@ -19,9 +19,14 @@
                     "mqtt_id": "MQTT id",
                     "scan_interval": "Периодичность обновлений (сек.), 0 - не обновлять",
                     "port_to_scan": "Порт, который сканируется когда нет датчиков",
-                    "mqtt_inputs": "Использовать MQTT",
+                    "mqtt_inputs": "Использовать MQTT (Не рекомендуется)",
                     "nports": "Кол-во портов",
                     "update_all": "Обновить все выходы когда срабатывает вход",
+                    "fake_response": "Имитация http-ответа",
+                    "force_d": "Ответ 'd' по умолчанию",
+                    "protected": "Блокировать неразрешенные соединения",
+                    "restore_on_restart": "Восстанавливать выходы при перезагрузке",
+                    "allow_hosts": "Разрешенные ip (через ;)",
                     "poll_outs": "Обновлять выходы (регулярно)"
                 }
             }
@@ -35,10 +40,15 @@
                   "port_to_scan": "Порт, который сканируется когда нет датчиков",
                   "reload": "Обновить объекты",
                   "invert": "Список портов (через ,) с инвертированной логикой",
-                  "mqtt_inputs": "Использовать MQTT",
-                    "nports": "Кол-во портов",
-                    "update_all": "Обновить все выходы когда срабатывает вход",
-                    "poll_outs": "Обновлять выходы (регулярно)"
+                  "mqtt_inputs": "Использовать MQTT (Не рекомендуется)",
+                  "fake_response": "Имитация http-ответа",
+                  "force_d": "Ответ 'd' по умолчанию",
+                  "nports": "Кол-во портов",
+                  "update_all": "Обновить все выходы когда срабатывает вход",
+                  "protected": "Блокировать неразрешенные соединения",
+                  "allow_hosts": "Разрешенные ip (через ;)",
+                  "restore_on_restart": "Восстанавливать выходы при перезагрузке",
+                  "poll_outs": "Обновлять выходы (регулярно)"
                 }
             }
         }

custom_components/mega/translations/uk.json

@@ -19,9 +19,14 @@
                     "mqtt_id": "MQTT id",
                     "scan_interval": "Період оновлення (сек.), 0 - не оновлювати",
                     "port_to_scan": "Порт для сканування при відсутності датчиків",
-                    "mqtt_inputs": "Використовувати MQTT",
+                    "mqtt_inputs": "Використовувати MQTT (Deprecated)",
                     "nports": "Кількість портів",
                     "update_all": "Оновити всі виходи коли спрацьовує вхід",
+                    "fake_response": "Імітація http-відповіді",
+                    "force_d": "Неявно відповідати 'd'",
+                    "protected": "Блокувати недозволені з'єднання",
+                    "allow_hosts": "Дозволені ip (через ;)",
+                    "restore_on_restart": "Відновлювати виходи при перезавантаженні",
                     "poll_outs": "Оновити виходи"
                 }
             }
@@ -31,13 +36,18 @@
         "step": {
             "init": {
                 "data": {
-                  "scan_interval": "Період оновлення (сек.)",
-                  "port_to_scan": "Порт для сканування при відсутності датчиків",
-                  "reload": "Оновити об'єкти",
-                  "invert": "Список портів з інвертованою логікою (через ,)",
-                  "mqtt_inputs": "Використовувати MQTT",
-                  "nports": "Кількість портів",
-                  "update_all": "Оновити всі виходи коли спрацьовує вхід",
+                    "scan_interval": "Період оновлення (сек.)",
+                    "port_to_scan": "Порт для сканування при відсутності датчиків",
+                    "reload": "Оновити об'єкти",
+                    "invert": "Список портів з інвертованою логікою (через ,)",
+                    "mqtt_inputs": "Використовувати MQTT (Deprecated)",
+                    "nports": "Кількість портів",
+                    "fake_response": "Імітація http-відповіді",
+                    "force_d": "Неявно відповідати 'd'",
+                    "update_all": "Оновити всі виходи коли спрацьовує вхід",
+                    "protected": "Блокувати недозволені з'єднання",
+                    "allow_hosts": "Дозволені ip (через ;)",
+                    "restore_on_restart": "Відновлювати виходи при перезавантаженні",
                     "poll_outs": "Оновити виходи"
                 }
             }

readme.md

@@ -10,24 +10,37 @@
 интеграция очень понравилась - еще приятнее, если вы воспользуетесь кнопкой доната )
 
 Обновление прошивки MegaD можно делать прямо из HA с помощью [аддона](https://github.com/andvikt/mega_addon.git)
+
+Подробная документация по [ссылке](https://github.com/andvikt/mega_hacs/wiki)
+
+Предложения по доработкам просьба писать в [discussions](https://github.com/andvikt/mega_hacs/discussions), о проблемах
+создавать [issue](https://github.com/andvikt/mega_hacs/issues/new/choose)
 ## Основные особенности:
-- Настройка в веб-интерфейсе + yaml
+- Настройка в веб-интерфейсе + [yaml](https://github.com/andvikt/mega_hacs/wiki/Кастомизация)
 - Все порты автоматически добавляются как устройства (для обычных релейных выходов создается 
   `light`, для шим - `light` с поддержкой яркости, для цифровых входов `binary_sensor`, для датчиков
   `sensor`)
 - Возможность работы с несколькими megad
-- Обратная связь по mqtt или http (на выбор)
-- События на двойные/долгие нажатия
+- Обратная связь по [http](https://github.com/andvikt/mega_hacs/wiki/http) или mqtt (`deprecated`, поддержка mqtt 
+  будет выключена в версиях >= 1.0.0, тк в нем нет необходимости)
+- [События](https://github.com/andvikt/mega_hacs/wiki/События) на двойные/долгие нажатия
 - Команды выполняются друг за другом без конкурентного доступа к ресурсам megad, это дает гарантии надежного исполнения
   большого кол-ва команд (например в сценах). Каждая следующая команда отправляется только после получения ответа о
   выполнении предыдущей.
-- поддержка ds2413 (начиная с версии 0.4.1)
+- поддержка [ds2413](https://www.ab-log.ru/smart-house/ethernet/megad-2w) (начиная с версии 0.4.1)
 
 ## Установка
 Рекомендованный способ с поддержкой обновлений - [HACS](https://hacs.xyz/docs/installation/installation):
 
 HACS - Integrations - Explore, в поиске ищем MegaD. 
 
+Чтобы включить возможность использования бета-версий, зайдите в HACS, найдите интеграцию MegaD, нажмите три точки, 
+там кнопка "переустановить" или reinstall, дальше нужно нажать галку "показывать бета-версии"
+
+Обновления выполняются так же в меню HACS. 
+Информация об обновлениях приходит с некоторым интервалом, чтобы вручную проверить наличие обновлений
+нажмите три точки возле интеграции в меню HACS и нажмите `обновить информацию`
+
 Альтернативный способ установки:
 ```shell
 # из папки с конфигом
@@ -40,226 +53,23 @@ wget -q -O - https://raw.githubusercontent.com/andvikt/mega_hacs/master/install.
 
 Все имеющиеся у вас порты будут настроены автоматически. Вы можете менять названия, иконки и entity_id так же из интерфейса.
 
-#### Кастомизация устройств с помощью yaml:
-```yaml
-# configuration.yaml
-
-mega:
-  hello: # ID меги, как в UI 
-    7: # номер порта
-      domain: switch # тип устройства (switch или light, по умолчанию для цифровых выходов используется light)
-      invert: true # инвертировать или нет (по умолчанию false)
-      name: Насос # имя устройства
-    8:
-      # исключить из сканирования
-      skip: true
-    10:
-      skip: false # если нужен skip, то он работает только целиком для всего порта
-      # в случае если порт настроен как ds2413  
-      address_a:  #address - это адрес ds2413
-        # здесь внутри работают все стандартные поля конфигурирования порта
-        invert: true
-        domain: switch
-      c6c439000000_b:
-        name: какое-то имя
-    33:
-      # для датчиков можно кастомизировать только имя и unit_of_measurement
-      # для температуры и влажность unit определяется автоматически, для остальных юнита нет 
-      name:
-        hum: "влажность"
-        temp: "температура"
-      unit_of_measurement:
-        hum: "%" # если датчиков несколько, то можно указывать юниты по их ключам
-        temp: "°C"
-      # можно так же указать шаблон для конвертации значения, может быть полезно для ацп-входа
-      # текущее значение порта передается в шаблон в переменной "value"
-      conv_template: "{{(value|float)/100}}"
-    14:
-      name: какой-то датчик
-      unit_of_measurement: "°C" # если датчик один, то просто строчкой
-```
-
-## Зависимости
-Для совместимости c mqtt необходимо настроить интеграцию [mqtt](https://www.home-assistant.io/integrations/mqtt/) 
-в HomeAssistant, а так же обновить ваш контроллер до последней версии, тк были важные обновления в части mqtt
-
-## HTTP in
-Начиная с версии `0.3.1` интеграция стала поддерживать обратную связь без mqtt, используя http-сервер. Для этого в настройках
-интеграции необходимо снять галку с `использовать mqtt`
-
-**Внимание!** Не используйте srv loop на контроллере, это может приводить к ложным срабатываниям входов. Вместо srv loop 
-интеграция будет сама обновлять все состояния портов с заданным интервалом
-
 В самой меге необходимо прописать настройки:
 ```yaml
 srv: "192.168.1.4:8123" # ip:port вашего HA
 script: "mega" # это api интеграции, к которому будет обращаться контроллер
 ```
+Так же необходимо настроить Mega-ID в настройках контроллера, для каждой меги id должен быть разным.
 
-#### Ответ на входящие события от контроллера
-Контроллер ожидает ответ от сервера, который может быть сценарием (по умолчанию интеграция отвечает `d`, что означает 
-запустить то что прописано в поле act в настройках порта).
+При любых изменениях настроек контроллера (типы входов, id и тд) необходимо в настройках интеграции нажать `Обновить 
+объекты`
 
-Поддерживаются шаблоны HA. Это может быть использовано, например, для запоминания яркости (тк сам контроллер этого не 
-умеет). В шаблоне можно использовать параметры, которые передает контроллер (m, click, pt, mdid, mega_id)
+## Зависимости
+Для максимальной скорости реакции на команды сервера, рекомендуется выключить `имитацию http-ответа` в 
+настройках интеграции и настроить proxy_pass к HA, самый простой способ сделать это - воспользоваться 
+[специальным аддоном](https://github.com/andvikt/mega_addon/tree/master/mega-proxy)
 
-Примеры:
-```yaml
-mega:
-  mega1: # id меги, который вы сами придумываете в конфиге в UI
-    4: # номер порта, с которого ожидаются события
-      response_template: "5:2" # простейший пример без шаблона. Каждый раз когда будет приходить сообщение на этот порт, 
-                             # будем менять состояние на противоположное
-    5:
-      # пример с использованием шаблона, порт 1 будет выключен если он сейчас включен и включен с последней сохраненной 
-      # яркостью если он сейчас выключен     
-      response_template: >-
-        {% if is_state('light.some_port_1', 'on') %}
-        1:0
-        {% else %}
-        1:{{state_attr('light.some_port_1', 'brightness')}}
-        {% endif %}
-    6:
-      # в шаблон так же передаются все параметры, которые передает контроллер (pt, cnt, m, click)
-      # эти параметры можно использовать в условиях или непосредственно в шаблоне в виде {{pt}}
-      response_template: >-
-        {% if m==2 %}1:0{% else %}d{% endif %}
-```
+Обновить ваш контроллер до последней версии, обновление прошивки MegaD можно делать 
+из HA с помощью [аддона](https://github.com/andvikt/mega_addon.git)
 
-Начиная с версии v0.3.17 ответ можно слать так же и в режиме MQTT. Аналогично, темплейт должен возвращать готовую команду
-такую же как требует команда cmd, так же можно использовать d, но d не отправляется по умолчанию, это сделано чтобы не 
-сломать текущую логику у пользователей предыдущих версий. Чтобы включить для всех входов в режиме mqtt отправку команды 
-d необходимо в конфиге прописать следующее:
-```yaml
-mega:
-  mega1:
-    force_d: true
-```
-**Внимание!** Нельзя использовать чекбокс напротив поля act если планируется использовать ответ сервера - у вас и 
-сработает act и команда от сервера, а вслучае ответа d сработает act два раза.
 
-Так же следует понимать, что это не "ответ" в нормальном понимании - это вызов следом за полученным mqtt-сообщением
-http команды такого вида `http://megaurl/?pt=port&cmd=rendered_template`, где `port` - это номер порта сработавшего входа,
-а `cmd` - текст команды, который получен из темплейта. Те это имитация ответа. У этого подхода есть минус - задержка в 
-исполнении будет значительно выше чем при ответе в режиме http, но тем не менее эта задержка скорее всего не будет 
-сильно заметна.
-
-## binary_sensor и события
-
-Входы будут доступны как binary_sensor, а так же в виде событий `mega.sensor` и `mega.binary`.
-Для корректной работы binary_sensor имеет смысл использовать режим P&R, для остальных режимов - лучше пользоваться 
-событиями.
-
-События можно использовать в автоматизациях, например так:
-```yaml
-# Пример события с полями как есть прямо из меги
-- alias: some double click
-  trigger:
-    - platform: event
-      event_type: mega.sensor
-      event_data:
-        pt: 1
-        click: 2
-  action:
-    - service: light.toggle
-      entity_id: light.some_light
-```
-События могут содержать следующие поля: 
-- `mega_id`: id как в конфиге HA
-- `pt`: номер порта
-- `cnt`: счетчик срабатываний
-- `mdid`: if как в конфиге контроллера
-- `click`: клик (подробнее в документации меги)
-- `value`: текущее значение (только для mqtt)
-- `port`: номер порта
-
-Начиная с версии 0.3.7 появилось так же событие типа `mega.binary`:
-```yaml
-# Пример события с полями как есть прямо из меги
-- alias: some long click
-  trigger:
-    - platform: event
-      event_type: mega.binary
-      event_data:
-        entity_id: binary_sensor.some_id
-        type: long
-  action:
-    - service: light.toggle
-      entity_id: light.some_light
-```
-Возможные варианты поля `type`:
-- `long`: долгое нажатие
-- `release`: размыкание (с гарантией** что не было долгого нажатия)
-- `long_release`: размыкание после долгого нажатия
-- `press`: замыкание
-- `single`: одинарный клик (в режиме кликов)
-- `double`: двойной клик
-
-**гарантия есть только при использовании http-метода синхронизации, mqtt не гарантирует порядок доставки сообщений, хотя 
-маловероятно, что порядок будет нарушен, но все же сам протокол не дает таких гарантий.
-
-Чтобы понять, какие события происходят, лучше всего воспользоваться панелью разработчика и подписаться
-на вкладке события на событие `mega.sensor`, понажимать кнопки.
-
-## Сервисы
-Все сервисы доступны в меню разработчика с описанием и примерами использования
-```yaml
-mega.save:
-  description: Сохраняет текущее состояние портов (?cmd=s)
-  fields:
-    mega_id:
-      description: ID меги, можно оставить пустым, тогда будут сохранены все зарегистрированные меги
-      example: "mega"
-
-mega.get_port:
-  description: Запросить текущий статус порта (или всех)
-  fields:
-    mega_id:
-      description: ID меги, можно оставить пустым, тогда будут порты всех зарегистрированных мег
-      example: "mega"
-    port:
-      description: Номер порта (если не заполнять, будут запрошены все порты сразу)
-      example: 1
-
-mega.run_cmd:
-  description: Выполнить любую произвольную команду
-  fields:
-    mega_id:
-      description: ID меги
-      example: "mega"
-    port:
-      description: Номер порта (это не порт, которым мы управляем, а порт с которого шлем команду)
-      example: 1
-    cmd:
-      description: Любая поддерживаемая мегой команда
-      example: "1:0"
-```
-
-## Отладка
-Интеграция находится в активной разработке, при возникновении проблем [заводите issue](https://github.com/andvikt/mega_hacs/issues/new/choose)
-
-Просьба прикладывать детальный лог, который можно включить в конфиге так:
-```yaml
-logger:
-  default: info
-  logs:
-    custom_components.mega: debug
-```
-
-#### Отладка ответов http-сервера
-Для отладки ответов сервера можно самим имитировать запросы контроллера, если у вас есть доступ к консоли
-HA:
-```shell
-curl -v -X GET 'http://localhost:8123/mega?pt=5&m=1'
-```
-Если доступа нет, нужно в файл конфигурации добавить ip, с которого вы хотите делать запросы, например:
-```yaml
-mega:
-  allow_hosts:
-    - 192.168.1.1
-```
-И тогда можно с локальной машины делать запросы на ваш сервер HA:
-```shell
-curl -v -X GET 'http://192.168.88.1.4:8123/mega?pt=5&m=1'
-```
-В ответ будет приходить либо `d`, либо скрипт, который вы настроили
+Подробная документация по [ссылке](https://github.com/andvikt/mega_hacs/wiki)