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

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,
-    async def handler(
+        writer: asyncio.StreamWriter,
-            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'
-        data = await reader.read(200)
+    writer.write(ans)
-        print(data)
+    await writer.drain()
-        message = data.decode()
+    writer.close()
-        addr = writer.get_extra_info('peername')
+    await writer.wait_closed()
-        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 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())

custom_components/mega/__init__.py

@@ -128,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][id] = hub
-    hass.data[DOMAIN][entry.data.get(CONF_HOST)] = 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 = 10
+    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,12 +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/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:
-
+        _LOGGER.debug('request from %s %s', request.remote, request.headers)
-        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)
-
         hass: HomeAssistant = request.app['hass']
-        hub: 'h.MegaD' = hass.data.get(DOMAIN).get(request.remote)  # TODO: проверить какой remote
+        if self.protected:
-        if hub is None and request.remote == '::1':
+            auth = False
-            hub = hass.data.get(DOMAIN).get('__def')
+            for x in self.allowed_hosts:
-        if hub is None:
+                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
@@ -78,13 +103,25 @@ class MegaView(HomeAssistantView):
                 template.hass = hass
                 ret = template.async_render(data)
         _LOGGER.debug('response %s', ret)
-        Response(body='', content_type='text/plain', headers={'Server': 's', 'Date': 'n'})
+        Response(body='' if hub.fake_response else ret, content_type='text/plain')
-        if 'd' in ret:
+
-            await hub.request(pt=port, cmd=ret)
+        if hub.fake_response and 'value' not in data and 'pt' in data:
-        else:
+            if 'd' in ret:
-            await hub.request(cmd=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):
         await asyncio.sleep(1)
         _LOGGER.debug('force update')

custom_components/mega/hub.py

@@ -21,7 +21,7 @@ from .const import (
     LUX, PATT_SPLIT, DOMAIN,
     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: bool=True,
-            update_all=True,
+            poll_outs: bool=False,
-            poll_outs=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
@@ -127,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()
@@ -460,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({})
@@ -516,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.1"
+  "version": "v0.4.2b1"
 }

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",
+                  "mqtt_inputs": "Использовать MQTT (Не рекомендуется)",
-                    "nports": "Кол-во портов",
+                  "fake_response": "Имитация http-ответа",
-                    "update_all": "Обновить все выходы когда срабатывает вход",
+                  "force_d": "Ответ 'd' по умолчанию",
-                    "poll_outs": "Обновлять выходы (регулярно)"
+                  "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": "Період оновлення (сек.)",
+                    "scan_interval": "Період оновлення (сек.)",
-                  "port_to_scan": "Порт для сканування при відсутності датчиків",
+                    "port_to_scan": "Порт для сканування при відсутності датчиків",
-                  "reload": "Оновити об'єкти",
+                    "reload": "Оновити об'єкти",
-                  "invert": "Список портів з інвертованою логікою (через ,)",
+                    "invert": "Список портів з інвертованою логікою (через ,)",
-                  "mqtt_inputs": "Використовувати MQTT",
+                    "mqtt_inputs": "Використовувати MQTT (Deprecated)",
-                  "nports": "Кількість портів",
+                    "nports": "Кількість портів",
-                  "update_all": "Оновити всі виходи коли спрацьовує вхід",
+                    "fake_response": "Імітація http-відповіді",
+                    "force_d": "Неявно відповідати 'd'",
+                    "update_all": "Оновити всі виходи коли спрацьовує вхід",
+                    "protected": "Блокувати недозволені з'єднання",
+                    "allow_hosts": "Дозволені ip (через ;)",
+                    "restore_on_restart": "Відновлювати виходи при перезавантаженні",
                     "poll_outs": "Оновити виходи"
                 }
             }

readme.md

@@ -16,17 +16,18 @@
 Предложения по доработкам просьба писать в [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):
@@ -52,7 +53,23 @@ wget -q -O - https://raw.githubusercontent.com/andvikt/mega_hacs/master/install.
 
 Все имеющиеся у вас порты будут настроены автоматически. Вы можете менять названия, иконки и entity_id так же из интерфейса.
 
+В самой меге необходимо прописать настройки:
+```yaml
+srv: "192.168.1.4:8123" # ip:port вашего HA
+script: "mega" # это api интеграции, к которому будет обращаться контроллер
+```
+Так же необходимо настроить Mega-ID в настройках контроллера, для каждой меги id должен быть разным.
+
+При любых изменениях настроек контроллера (типы входов, id и тд) необходимо в настройках интеграции нажать `Обновить 
+объекты`
+
 ## Зависимости
-Для совместимости c mqtt необходимо настроить интеграцию [mqtt](https://www.home-assistant.io/integrations/mqtt/) 
+Для максимальной скорости реакции на команды сервера, рекомендуется выключить `имитацию http-ответа` в 
-в HomeAssistant, а так же обновить ваш контроллер до последней версии, обновление прошивки MegaD можно делать прямо 
+настройках интеграции и настроить proxy_pass к HA, самый простой способ сделать это - воспользоваться 
+[специальным аддоном](https://github.com/andvikt/mega_addon/tree/master/mega-proxy)
+
+Обновить ваш контроллер до последней версии, обновление прошивки MegaD можно делать 
 из HA с помощью [аддона](https://github.com/andvikt/mega_addon.git)
+
+
+Подробная документация по [ссылке](https://github.com/andvikt/mega_hacs/wiki)