enapter 0.6.3__py3-none-any.whl → 0.12.1__py3-none-any.whl

enapter/standalone/config.py

@@ -0,0 +1,218 @@
+import base64
+import dataclasses
+import enum
+import json
+import logging
+import os
+from typing import Any, MutableMapping, Self
+
+from enapter import mqtt
+
+LOGGER = logging.getLogger(__name__)
+
+
+@dataclasses.dataclass
+class Config:
+
+    communication_config: "CommunicationConfig"
+
+    @property
+    def communication(self) -> "CommunicationConfig":
+        return self.communication_config
+
+    @classmethod
+    def from_env(
+        cls, env: MutableMapping[str, str] = os.environ, namespace: str = "ENAPTER_"
+    ) -> Self:
+        communication_config = CommunicationConfig.from_env(env, namespace=namespace)
+        return cls(communication_config=communication_config)
+
+
+@dataclasses.dataclass
+class CommunicationConfig:
+
+    mqtt_api_config: mqtt.api.Config
+    hardware_id: str
+    channel_id: str
+    ucm_needed: bool
+
+    @property
+    def mqtt_api(self) -> mqtt.api.Config:
+        return self.mqtt_api_config
+
+    @classmethod
+    def from_env(
+        cls, env: MutableMapping[str, str] = os.environ, namespace: str = "ENAPTER_"
+    ) -> Self:
+        prefix = namespace + "STANDALONE_COMMUNICATION_"
+        try:
+            blob = env[namespace + "VUCM_BLOB"]
+            LOGGER.warn(
+                "`%s` is deprecated and will be removed soon. Please use `%s`.",
+                namespace + "VUCM_BLOB",
+                prefix + "CONFIG",
+            )
+        except KeyError:
+            blob = env[prefix + "CONFIG"]
+        config = cls.from_blob(blob)
+        override_mqtt_api_host = env.get(prefix + "OVERRIDE_MQTT_API_HOST")
+        if override_mqtt_api_host is not None:
+            config.mqtt_api.host = override_mqtt_api_host
+        return config
+
+    @classmethod
+    def from_blob(cls, blob: str) -> Self:
+        dto = json.loads(base64.b64decode(blob))
+        if "ucm_id" in dto:
+            config_v1 = CommunicationConfigV1.from_dto(dto)
+            return cls.from_config_v1(config_v1)
+        else:
+            config_v3 = CommunicationConfigV3.from_dto(dto)
+            return cls.from_config_v3(config_v3)
+
+    @classmethod
+    def from_config_v1(cls, config: "CommunicationConfigV1") -> Self:
+        mqtt_api_config = mqtt.api.Config(
+            host=config.mqtt_host,
+            port=config.mqtt_port,
+            tls_config=mqtt.api.TLSConfig(
+                secret_key=config.mqtt_private_key,
+                cert=config.mqtt_cert,
+                ca_cert=config.mqtt_ca,
+            ),
+        )
+        return cls(
+            mqtt_api_config=mqtt_api_config,
+            hardware_id=config.ucm_id,
+            channel_id=config.channel_id,
+            ucm_needed=True,
+        )
+
+    @classmethod
+    def from_config_v3(cls, config: "CommunicationConfigV3") -> Self:
+        mqtt_api_config: mqtt.api.Config | None = None
+        match config.mqtt_protocol:
+            case CommunicationConfigV3.MQTTProtocol.MQTT:
+                assert isinstance(
+                    config.mqtt_credentials, CommunicationConfigV3.MQTTCredentials
+                )
+                mqtt_api_config = mqtt.api.Config(
+                    host=config.mqtt_host,
+                    port=config.mqtt_port,
+                    user=config.mqtt_credentials.username,
+                    password=config.mqtt_credentials.password,
+                )
+            case CommunicationConfigV3.MQTTProtocol.MQTTS:
+                assert isinstance(
+                    config.mqtt_credentials, CommunicationConfigV3.MQTTSCredentials
+                )
+                mqtt_api_config = mqtt.api.Config(
+                    host=config.mqtt_host,
+                    port=config.mqtt_port,
+                    tls_config=mqtt.api.TLSConfig(
+                        secret_key=config.mqtt_credentials.private_key,
+                        cert=config.mqtt_credentials.certificate,
+                        ca_cert=config.mqtt_credentials.ca_chain,
+                    ),
+                )
+            case _:
+                raise NotImplementedError(config.mqtt_protocol)
+        assert mqtt_api_config is not None
+        return cls(
+            mqtt_api_config=mqtt_api_config,
+            hardware_id=config.hardware_id,
+            channel_id=config.channel_id,
+            ucm_needed=False,
+        )
+
+
+@dataclasses.dataclass
+class CommunicationConfigV1:
+
+    mqtt_host: str
+    mqtt_port: int
+    mqtt_ca: str
+    mqtt_cert: str
+    mqtt_private_key: str
+    ucm_id: str
+    channel_id: str
+
+    @classmethod
+    def from_dto(cls, dto: dict[str, Any]) -> Self:
+        return cls(
+            mqtt_host=dto["mqtt_host"],
+            mqtt_port=int(dto["mqtt_port"]),
+            mqtt_ca=dto["mqtt_ca"],
+            mqtt_cert=dto["mqtt_cert"],
+            mqtt_private_key=dto["mqtt_private_key"],
+            ucm_id=dto["ucm_id"],
+            channel_id=dto["channel_id"],
+        )
+
+
+@dataclasses.dataclass
+class CommunicationConfigV3:
+
+    class MQTTProtocol(enum.Enum):
+
+        MQTT = "MQTT"
+        MQTTS = "MQTTS"
+
+    @dataclasses.dataclass
+    class MQTTCredentials:
+
+        username: str
+        password: str
+
+        @classmethod
+        def from_dto(cls, dto: dict[str, Any]) -> Self:
+            return cls(username=dto["username"], password=dto["password"])
+
+    @dataclasses.dataclass
+    class MQTTSCredentials:
+
+        private_key: str
+        certificate: str
+        ca_chain: str
+
+        @classmethod
+        def from_dto(cls, dto: dict[str, Any]) -> Self:
+            return cls(
+                private_key=dto["private_key"],
+                certificate=dto["certificate"],
+                ca_chain=dto["ca_chain"],
+            )
+
+    mqtt_host: str
+    mqtt_port: int
+    mqtt_protocol: MQTTProtocol
+    mqtt_credentials: MQTTCredentials | MQTTSCredentials
+    hardware_id: str
+    channel_id: str
+
+    @classmethod
+    def from_dto(cls, dto: dict[str, Any]) -> Self:
+        mqtt_protocol = cls.MQTTProtocol(dto["mqtt_protocol"])
+        mqtt_credentials: (
+            CommunicationConfigV3.MQTTCredentials
+            | CommunicationConfigV3.MQTTSCredentials
+            | None
+        ) = None
+        match mqtt_protocol:
+            case cls.MQTTProtocol.MQTT:
+                mqtt_credentials = cls.MQTTCredentials.from_dto(dto["mqtt_credentials"])
+            case cls.MQTTProtocol.MQTTS:
+                mqtt_credentials = cls.MQTTSCredentials.from_dto(
+                    dto["mqtt_credentials"]
+                )
+            case _:
+                raise NotImplementedError(mqtt_protocol)
+        assert mqtt_credentials is not None
+        return cls(
+            mqtt_host=dto["mqtt_host"],
+            mqtt_port=int(dto["mqtt_port"]),
+            mqtt_credentials=mqtt_credentials,
+            mqtt_protocol=mqtt_protocol,
+            hardware_id=dto["hardware_id"],
+            channel_id=dto["channel_id"],
+        )

enapter/standalone/device.py

@@ -0,0 +1,59 @@
+import abc
+import asyncio
+from typing import AsyncGenerator
+
+from .device_protocol import CommandArgs, CommandResult, Log, Properties, Telemetry
+from .logger import Logger
+
+
+class Device(abc.ABC):
+
+    def __init__(
+        self,
+        properties_queue_size: int = 1,
+        telemetry_queue_size: int = 1,
+        log_queue_size: int = 1,
+        command_prefix: str = "cmd_",
+    ) -> None:
+        self._properties_queue: asyncio.Queue[Properties] = asyncio.Queue(
+            properties_queue_size
+        )
+        self._telemetry_queue: asyncio.Queue[Telemetry] = asyncio.Queue(
+            telemetry_queue_size
+        )
+        self._log_queue: asyncio.Queue[Log] = asyncio.Queue(log_queue_size)
+        self._logger = Logger(self._log_queue)
+        self._command_prefix = command_prefix
+
+    @abc.abstractmethod
+    async def run(self) -> None:
+        pass
+
+    @property
+    def logger(self) -> Logger:
+        return self._logger
+
+    async def send_properties(self, properties: Properties) -> None:
+        await self._properties_queue.put(properties.copy())
+
+    async def send_telemetry(self, telemetry: Telemetry) -> None:
+        await self._telemetry_queue.put(telemetry.copy())
+
+    async def stream_properties(self) -> AsyncGenerator[Properties, None]:
+        while True:
+            yield await self._properties_queue.get()
+
+    async def stream_telemetry(self) -> AsyncGenerator[Telemetry, None]:
+        while True:
+            yield await self._telemetry_queue.get()
+
+    async def stream_logs(self) -> AsyncGenerator[Log, None]:
+        while True:
+            yield await self._log_queue.get()
+
+    async def execute_command(self, name: str, args: CommandArgs) -> CommandResult:
+        try:
+            command = getattr(self, self._command_prefix + name)
+        except AttributeError:
+            raise NotImplementedError() from None
+        return {"result": await command(**args)}

enapter/standalone/device_protocol.py

@@ -0,0 +1,33 @@
+import dataclasses
+from typing import Any, AsyncGenerator, Literal, Protocol, TypeAlias
+
+Properties: TypeAlias = dict[str, Any]
+Telemetry: TypeAlias = dict[str, Any]
+CommandArgs: TypeAlias = dict[str, Any]
+CommandResult: TypeAlias = dict[str, Any]
+
+
+@dataclasses.dataclass
+class Log:
+
+    severity: Literal["debug", "info", "warning", "error"]
+    message: str
+    persist: bool
+
+
+class DeviceProtocol(Protocol):
+
+    async def run(self) -> None:
+        pass
+
+    async def stream_properties(self) -> AsyncGenerator[Properties, None]:
+        yield {}
+
+    async def stream_telemetry(self) -> AsyncGenerator[Telemetry, None]:
+        yield {}
+
+    async def stream_logs(self) -> AsyncGenerator[Log, None]:
+        yield Log("debug", "", False)
+
+    async def execute_command(self, name: str, args: CommandArgs) -> CommandResult:
+        pass

enapter/standalone/logger.py

@@ -0,0 +1,21 @@
+import asyncio
+
+from .device_protocol import Log
+
+
+class Logger:
+
+    def __init__(self, queue: asyncio.Queue[Log]) -> None:
+        self._queue = queue
+
+    async def debug(self, msg: str, persist: bool = False) -> None:
+        await self._queue.put(Log("debug", msg, persist))
+
+    async def info(self, msg: str, persist: bool = False) -> None:
+        await self._queue.put(Log("info", msg, persist))
+
+    async def warning(self, msg: str, persist: bool = False) -> None:
+        await self._queue.put(Log("warning", msg, persist))
+
+    async def error(self, msg: str, persist: bool = False) -> None:
+        await self._queue.put(Log("error", msg, persist))

enapter/standalone/mqtt_adapter.py

@@ -0,0 +1,134 @@
+import asyncio
+import contextlib
+import logging
+import time
+import traceback
+
+from enapter import async_, mqtt
+
+from .device_protocol import DeviceProtocol
+
+LOGGER = logging.getLogger(__name__)
+
+
+class MQTTAdapter(async_.Routine):
+
+    def __init__(
+        self,
+        hardware_id: str,
+        channel_id: str,
+        mqtt_api_client: mqtt.api.Client,
+        device: DeviceProtocol,
+        task_group: asyncio.TaskGroup | None,
+    ) -> None:
+        super().__init__(task_group=task_group)
+        self._logger = logging.LoggerAdapter(
+            LOGGER, extra={"hardware_id": hardware_id, "channel_id": channel_id}
+        )
+        self._device_channel = mqtt_api_client.device_channel(hardware_id, channel_id)
+        self._device = device
+
+    async def _run(self) -> None:
+        async with asyncio.TaskGroup() as tg:
+            tg.create_task(self._device.run())
+            tg.create_task(self._stream_properties())
+            tg.create_task(self._stream_telemetry())
+            tg.create_task(self._stream_logs())
+            tg.create_task(self._execute_commands())
+
+    async def _stream_properties(self) -> None:
+        async with contextlib.aclosing(self._device.stream_properties()) as stream:
+            async for properties in stream:
+                properties = properties.copy()
+                timestamp = properties.pop("timestamp", int(time.time()))
+                await self._publish_properties(
+                    mqtt.api.device.Properties(timestamp=timestamp, values=properties)
+                )
+
+    async def _publish_properties(self, properties: mqtt.api.device.Properties) -> None:
+        try:
+            await self._device_channel.publish_properties(properties=properties)
+        except Exception as e:
+            self._logger.error("failed to publish properties: %s", e)
+
+    async def _stream_telemetry(self) -> None:
+        async with contextlib.aclosing(self._device.stream_telemetry()) as stream:
+            async for telemetry in stream:
+                telemetry = telemetry.copy()
+                timestamp = telemetry.pop("timestamp", int(time.time()))
+                alerts = telemetry.pop("alerts", None)
+                await self._publish_telemetry(
+                    mqtt.api.device.Telemetry(
+                        timestamp=timestamp, alerts=alerts, values=telemetry
+                    )
+                )
+
+    async def _publish_telemetry(self, telemetry: mqtt.api.device.Telemetry) -> None:
+        try:
+            await self._device_channel.publish_telemetry(telemetry=telemetry)
+        except Exception as e:
+            self._logger.error("failed to publish telemetry: %s", e)
+
+    async def _stream_logs(self) -> None:
+        async with contextlib.aclosing(self._device.stream_logs()) as stream:
+            async for log in stream:
+                match log.severity:
+                    case "debug":
+                        self._logger.debug(log.message)
+                    case "info":
+                        self._logger.info(log.message)
+                    case "warning":
+                        self._logger.warning(log.message)
+                    case "error":
+                        self._logger.error(log.message)
+                    case _:
+                        raise NotImplementedError(log.severity)
+                await self._publish_log(
+                    mqtt.api.device.Log(
+                        timestamp=int(time.time()),
+                        severity=mqtt.api.device.LogSeverity(log.severity),
+                        message=log.message,
+                        persist=log.persist,
+                    )
+                )
+
+    async def _publish_log(self, log: mqtt.api.device.Log) -> None:
+        try:
+            await self._device_channel.publish_log(log=log)
+        except Exception as e:
+            self._logger.error("failed to publish log: %s", e)
+
+    async def _execute_commands(self) -> None:
+        async with asyncio.TaskGroup() as tg:
+            async with self._device_channel.subscribe_to_command_requests() as requests:
+                async for request in requests:
+                    tg.create_task(self._execute_command(request))
+
+    async def _execute_command(self, request: mqtt.api.device.CommandRequest) -> None:
+        await self._device_channel.publish_command_response(
+            request.new_response(
+                mqtt.api.device.CommandState.LOG, {"message": "Executing command..."}
+            )
+        )
+        try:
+            payload = await self._device.execute_command(
+                request.name, request.arguments
+            )
+        except NotImplementedError:
+            await self._device_channel.publish_command_response(
+                request.new_response(
+                    mqtt.api.device.CommandState.ERROR,
+                    {"message": "Command handler not implemented."},
+                )
+            )
+        except Exception:
+            await self._device_channel.publish_command_response(
+                request.new_response(
+                    mqtt.api.device.CommandState.ERROR,
+                    {"message": traceback.format_exc()},
+                )
+            )
+        else:
+            await self._device_channel.publish_command_response(
+                request.new_response(mqtt.api.device.CommandState.COMPLETED, payload)
+            )

enapter/standalone/run.py

@@ -0,0 +1,39 @@
+import asyncio
+import contextlib
+
+from enapter import log, mqtt
+
+from .config import Config
+from .device_protocol import DeviceProtocol
+from .mqtt_adapter import MQTTAdapter
+from .ucm import UCM
+
+
+async def run(device: DeviceProtocol) -> None:
+    log.configure(level=log.LEVEL or "info")
+    config = Config.from_env()
+    async with contextlib.AsyncExitStack() as stack:
+        task_group = await stack.enter_async_context(asyncio.TaskGroup())
+        mqtt_api_client = await stack.enter_async_context(
+            mqtt.api.Client(config=config.communication.mqtt_api, task_group=task_group)
+        )
+        _ = await stack.enter_async_context(
+            MQTTAdapter(
+                hardware_id=config.communication.hardware_id,
+                channel_id=config.communication.channel_id,
+                mqtt_api_client=mqtt_api_client,
+                device=device,
+                task_group=task_group,
+            )
+        )
+        if config.communication.ucm_needed:
+            _ = await stack.enter_async_context(
+                MQTTAdapter(
+                    hardware_id=config.communication.hardware_id,
+                    channel_id="ucm",
+                    mqtt_api_client=mqtt_api_client,
+                    device=UCM(),
+                    task_group=task_group,
+                )
+            )
+        await asyncio.Event().wait()

enapter/standalone/ucm.py

@@ -0,0 +1,28 @@
+import asyncio
+
+from .device import Device
+from .device_protocol import CommandResult
+
+
+class UCM(Device):
+
+    async def run(self) -> None:
+        async with asyncio.TaskGroup() as tg:
+            tg.create_task(self.properties_sender())
+            tg.create_task(self.telemetry_sender())
+
+    async def properties_sender(self) -> None:
+        while True:
+            await self.send_properties({"virtual": True, "lua_api_ver": 1})
+            await asyncio.sleep(30)
+
+    async def telemetry_sender(self) -> None:
+        while True:
+            await self.send_telemetry({})
+            await asyncio.sleep(1)
+
+    async def cmd_reboot(self, *args, **kwargs) -> CommandResult:
+        raise NotImplementedError
+
+    async def cmd_upload_lua_script(self, *args, **kwargs) -> CommandResult:
+        raise NotImplementedError

enapter-0.12.1.dist-info/METADATA

@@ -0,0 +1,74 @@
+Metadata-Version: 2.4
+Name: enapter
+Version: 0.12.1
+Summary: Enapter Python SDK
+Home-page: https://github.com/Enapter/python-sdk
+Author: Roman Novatorov
+Author-email: rnovatorov@enapter.com
+Description-Content-Type: text/markdown
+Requires-Dist: aiomqtt==2.4.*
+Requires-Dist: dnspython==2.8.*
+Requires-Dist: json-log-formatter==1.1.*
+Requires-Dist: httpx==0.28.*
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: requires-dist
+Dynamic: summary
+
+# Enapter Python SDK
+
+[![CI](https://github.com/Enapter/python-sdk/actions/workflows/ci.yml/badge.svg)](https://github.com/Enapter/python-sdk/actions/workflows/ci.yml)
+[![PyPI version](https://img.shields.io/pypi/v/enapter.svg)](https://pypi.org/project/enapter)
+[![Code Style](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/python/black)
+
+A software development kit (SDK) for building applications and integrations
+with Enapter using Python.
+
+## Features
+
+- [Standalone
+  Devices](https://v3.developers.enapter.com/docs/standalone/introduction)
+  framework
+- [MQTT
+  API](https://v3.developers.enapter.com/reference/device_integration/mqtt_api/)
+  client
+- [HTTP API](https://v3.developers.enapter.com/reference/http/intro) client
+
+## Installation
+
+> [!IMPORTANT]
+> Requires **Python 3.11+**.
+
+> [!WARNING]
+> The API is still under development and may change at any time. It is
+> recommended to pin the package version when installing.
+
+Install from PyPI:
+
+```bash
+pip install enapter==0.12.0
+```
+
+## Usage
+
+Explore the examples:
+
+- [Standalone Devices](examples/standalone)
+- [MQTT API](examples/mqtt)
+- [HTTP API](examples/http)
+
+These provide a good overview of the available features and should give you
+enough to get started.
+
+> [!TIP]
+> Don't hesitate to peek into the source code - it's meant to be easy to
+> follow.
+
+## Help
+
+If you feel lost or confused, reach us on
+[Discord](https://discord.com/invite/TCaEZs3qpe) or just [file a
+bug](https://github.com/Enapter/python-sdk/issues/new). We'd be glad to help.

enapter-0.12.1.dist-info/RECORD

@@ -0,0 +1,52 @@
+enapter/__init__.py,sha256=Tl2rL_JwFFrogMeXuJ61iIqUMC9tD2PXPAi4Zs2RRNc,208
+enapter/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+enapter/async_/__init__.py,sha256=9bi9f3OEu71WRUHQei-FiIbz_LEy8lY44n5y_I4WEfo,98
+enapter/async_/generator.py,sha256=BQPPtPCYdsZIjgVy0UlC81DqId3yIDrpEyrmJ2cHdc8,497
+enapter/async_/routine.py,sha256=oNgq2rgMSOEK1cr7gCVeLLc_hlrbKpY8-tzE3uAQObA,1035
+enapter/http/__init__.py,sha256=dvicm4uAqVhr7d9QdhLRuTq3qUcs03JikShjsBSzgdE,37
+enapter/http/api/__init__.py,sha256=tKDag5EZBTcNc9pkVltA_MHFTvJNfZgbNmaIKQFxJFI,119
+enapter/http/api/client.py,sha256=nvnlMZUzmR4QJlW9evqlKXyO5nbQkPz43ZnyWWaKYsQ,741
+enapter/http/api/config.py,sha256=L0yZzgfbuK9YzKe-EVfcgu2W2mCVY9CcUwSauG_YUbs,648
+enapter/http/api/devices/__init__.py,sha256=aBetjJCQEZ8YgxmyN551gx3hQ0X5xtjbpEpjWLJGO7c,572
+enapter/http/api/devices/authorized_role.py,sha256=KWiwiXmZ7lICqaXxKy0Bwb5nlgMcF0M1arl3pCZaTx8,184
+enapter/http/api/devices/client.py,sha256=dhB7KGn5vY6bHlGstmLhG5CFPu4LlYuB9IdeVzvsb5g,859
+enapter/http/api/devices/communication_config.py,sha256=OuexZYjR4K3wVZMdhqUWSmakxL1gOyuYfKHpcqtoFio,1618
+enapter/http/api/devices/device.py,sha256=07R20IxAFO5xRYkXqK7l5nfd6nrn7h4eKBiBl0qFJmU,808
+enapter/http/api/devices/device_type.py,sha256=64pl62rzblNKdstcBX5nUw8NisYx4v0VAbM6VLnpUn4,180
+enapter/http/api/devices/mqtt_credentials.py,sha256=8q1zjJEE4WDo2tjp0rB0gf-eQ4qHACdRzFqtSl7JpCc,274
+enapter/http/api/devices/mqtt_protocol.py,sha256=tJuxuiTpMj__-OeVraTEeCWyOwikcAoDAx_0h2thCI0,84
+enapter/http/api/devices/mqtts_credentials.py,sha256=92Qfp0ynGbLmhpzybM_3gUVED1stsAezUPnbnejNhiA,384
+enapter/http/api/devices/time_sync_protocol.py,sha256=627RxrmxX95LOse3QD7Ub_kNvqRndGKRMnKhE9StlNA,66
+enapter/log/__init__.py,sha256=n1sWMDKJSs_ebZzjbTrVdfg-oi0V1tvliTxgIV-msJ0,600
+enapter/log/json_formatter.py,sha256=TlKjdnYQvVAbSpMwjJbkzLrpelPcBiRbyeBQOHBX30k,974
+enapter/mdns/__init__.py,sha256=uwsg8wJ0Lcsr9oOEW1PkEV3jVgWzgA7RG2ur_MRLtM0,55
+enapter/mdns/resolver.py,sha256=lr1Z1Fa6gC-v1BK9SszynNpQrX1tEIib5AH2QEQo8kg,1434
+enapter/mqtt/__init__.py,sha256=0cZIMl62Racl30n3mR31sFEqDRrkVH7VzTf657k3-y4,165
+enapter/mqtt/client.py,sha256=F589ZfL8QWdCGQerJ1G-dokw4uyZpOxHUFODgnIDtNc,4221
+enapter/mqtt/errors.py,sha256=KGDPc7FwYmKV1Rknl8Ngm7219TQ2G1mIqTQyokNwLP8,42
+enapter/mqtt/message.py,sha256=KO6XndORPDHC3YYJyXXXNlDa3hJRZq153WRmjQ8tNPQ,42
+enapter/mqtt/api/__init__.py,sha256=XiDOzEL1H-1NBWsfPs90cs_7huycvTzt23vcmvZ6s6E,157
+enapter/mqtt/api/client.py,sha256=-D32m8cd9aqR01LL_Cwy90-gEprWch9hmvy3u4gwJ9g,1919
+enapter/mqtt/api/config.py,sha256=UMRX9CBtJDnYDd3zaL3i3aFBzwefk6bJUBjNXZG-bnM,2189
+enapter/mqtt/api/device/__init__.py,sha256=F2RyxMJKrfR1uj-lOlY1meVHN1F2hOJmDD2CmZQrLcY,490
+enapter/mqtt/api/device/channel.py,sha256=Czgol_EPOcR0LYn83r-_iAYLYFPDtgruUe51w-sx8XU,2058
+enapter/mqtt/api/device/command_request.py,sha256=tonIhOVFyiT0fAmCmL0xGcdrV-0zcFBW_5fyMCM5uUk,876
+enapter/mqtt/api/device/command_response.py,sha256=7yBiFy365b4p4G8qC1oEbYiYouQuk9vOxAsc9V0OQKo,627
+enapter/mqtt/api/device/command_state.py,sha256=rsAUyb3YZ1SiRWZc1oKa9Ik3968LJvHnUCIr85w8V9Q,110
+enapter/mqtt/api/device/log.py,sha256=1LbAztBIcmj7tJXh-2fmnaIu0HebKmBUilSe1Dn9Fkk,733
+enapter/mqtt/api/device/log_severity.py,sha256=5icvVG3XfIxmOqqwfcvHB1foewAPq13bXjda7xmVCn0,127
+enapter/mqtt/api/device/message.py,sha256=xoIL4B_im15tmRAv1nctt4KsSk9hOf_yrUM-f0_ww2Y,486
+enapter/mqtt/api/device/properties.py,sha256=0vvYIpIivNcSR8jbh1-bUlZH9wCAFVPs8Z7HaDOV0Ic,683
+enapter/mqtt/api/device/telemetry.py,sha256=pssdpreLZ02JnD-4ovOD5YUlocsBBk4mlnQj2W7H6PM,844
+enapter/standalone/__init__.py,sha256=gLWomm_p8GrIZ07Pvea9HoHJpOVEFgDfhCrlfICvZkQ,407
+enapter/standalone/config.py,sha256=83kAmexJNgpGBzuWnjCLLWERq-Islo4XSpJ5QjlGr9o,6789
+enapter/standalone/device.py,sha256=fX0coeOxl1hFnNmqsUjz7uoXxdbffxwlUI8o-665z1Y,1917
+enapter/standalone/device_protocol.py,sha256=oL5oQJfFmA4r4DKMCldA9qHyL0-UFpgoKMTqhUR6eao,843
+enapter/standalone/logger.py,sha256=DF5KUbOYmb3bh0OSpBUwfJA9jSLspiRs5bdqwVonf6I,663
+enapter/standalone/mqtt_adapter.py,sha256=W5rlFfDAodK53EbvilgOCWF9agO3tFmTduJ_aqWLqpo,5356
+enapter/standalone/run.py,sha256=pjdLLfU2CmQHToWDX_jhuEVqhGGGWfGQjsV-EtV7HBc,1365
+enapter/standalone/ucm.py,sha256=2dPYLKlC1Alu2aL3O3-xVqKIp-bQb-ZlfUEiMklPe-E,829
+enapter-0.12.1.dist-info/METADATA,sha256=AuUqAAOatB0p1IHqXNQmVOD_e7Vcr1jQzWANHVg8OyQ,2068
+enapter-0.12.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+enapter-0.12.1.dist-info/top_level.txt,sha256=IeuS2-kf8S5mBht3xxULzMkYhXe08xGuailHeEaaD1A,8
+enapter-0.12.1.dist-info/RECORD,,

{enapter-0.6.3.dist-info → enapter-0.12.1.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.37.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

{enapter-0.6.3.dist-info → enapter-0.12.1.dist-info}/top_level.txt

@@ -1,2 +1 @@
 enapter
-tests