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

enapter/mqtt/command.py

@@ -1,45 +0,0 @@
-import enum
-import json
-
-
-class CommandState(enum.Enum):
-    COMPLETED = "completed"
-    ERROR = "error"
-
-
-class CommandRequest:
-    @classmethod
-    def unmarshal_json(cls, data):
-        req = json.loads(data)
-        return cls(id_=req["id"], name=req["name"], args=req.get("arguments"))
-
-    def __init__(self, id_, name, args=None):
-        self.id = id_
-        self.name = name
-
-        if args is None:
-            args = {}
-        self.args = args
-
-    def new_response(self, *args, **kwargs):
-        return CommandResponse(self.id, *args, **kwargs)
-
-
-class CommandResponse:
-    def __init__(self, id_, state, payload=None):
-        self.id = id_
-
-        if not isinstance(state, CommandState):
-            state = CommandState(state)
-        self.state = state
-
-        if not isinstance(payload, dict):
-            payload = {"message": payload}
-        self.payload = payload
-
-    def json(self):
-        json_object = {"id": self.id, "state": self.state.value}
-        if self.payload is not None:
-            json_object["payload"] = self.payload
-
-        return json_object

enapter/mqtt/config.py

@@ -1,48 +0,0 @@
-import os
-
-
-class Config:
-    @classmethod
-    def from_env(cls, prefix="ENAPTER_", env=os.environ):
-        def pem(value):
-            if value is None:
-                return value
-            return value.replace("\\n", "\n")
-
-        return cls(
-            host=env[prefix + "MQTT_HOST"],
-            port=int(env[prefix + "MQTT_PORT"]),
-            user=env.get(prefix + "MQTT_USER", default=None),
-            password=env.get(prefix + "MQTT_PASSWORD", default=None),
-            tls_secret_key=pem(env.get(prefix + "MQTT_TLS_SECRET_KEY", default=None)),
-            tls_cert=pem(env.get(prefix + "MQTT_TLS_CERT", default=None)),
-            tls_ca_cert=pem(env.get(prefix + "MQTT_TLS_CA_CERT", default=None)),
-        )
-
-    def __init__(
-        self,
-        host,
-        port,
-        user=None,
-        password=None,
-        tls_secret_key=None,
-        tls_cert=None,
-        tls_ca_cert=None,
-    ):
-        self.host = host
-        self.port = port
-        self.user = user
-        self.password = password
-
-        self.tls_secret_key = tls_secret_key
-        self.tls_cert = tls_cert
-        self.tls_ca_cert = tls_ca_cert
-
-        self.tls_enabled = {tls_secret_key, tls_cert, tls_ca_cert} != {None}
-
-    def __repr__(self):
-        return "mqtt.Config(host=%r, port=%r, tls_enabled=%r)" % (
-            self.host,
-            self.port,
-            self.tls_enabled,
-        )

enapter/mqtt/device_channel.py

@@ -1,83 +0,0 @@
-import enum
-import json
-import logging
-import time
-
-from .. import async_
-from .command import CommandRequest
-
-LOGGER = logging.getLogger(__name__)
-
-
-class DeviceChannel:
-    def __init__(self, client, hardware_id, channel_id):
-        self._client = client
-        self._logger = self._new_logger(hardware_id, channel_id)
-        self._hardware_id = hardware_id
-        self._channel_id = channel_id
-
-    @property
-    def hardware_id(self):
-        return self._hardware_id
-
-    @property
-    def channel_id(self):
-        return self._channel_id
-
-    @staticmethod
-    def _new_logger(hardware_id, channel_id):
-        extra = {"hardware_id": hardware_id, "channel_id": channel_id}
-        return logging.LoggerAdapter(LOGGER, extra=extra)
-
-    @async_.generator
-    async def subscribe_to_command_requests(self):
-        async with self._subscribe("v1/command/requests") as messages:
-            async for msg in messages:
-                yield CommandRequest.unmarshal_json(msg.payload)
-
-    async def publish_command_response(self, resp):
-        await self._publish_json("v1/command/responses", resp.json())
-
-    async def publish_telemetry(self, telemetry, **kwargs):
-        await self._publish_json("v1/telemetry", telemetry, **kwargs)
-
-    async def publish_properties(self, properties, **kwargs):
-        await self._publish_json("v1/register", properties, **kwargs)
-
-    async def publish_logs(self, msg, severity, persist=False, **kwargs):
-        logs = {
-            "message": msg,
-            "severity": severity.value,
-        }
-        if persist:
-            logs["persist"] = True
-
-        await self._publish_json("v3/logs", logs, **kwargs)
-
-    def _subscribe(self, path):
-        topic = f"v1/to/{self._hardware_id}/{self._channel_id}/{path}"
-        return self._client.subscribe(topic)
-
-    async def _publish_json(self, path, json_object, **kwargs):
-        if "timestamp" in json_object:
-            raise ValueError("`timestamp` field is reserved")
-
-        json_object["timestamp"] = int(time.time())
-        payload = json.dumps(json_object)
-
-        await self._publish(path, payload, **kwargs)
-
-    async def _publish(self, path, payload, **kwargs):
-        topic = f"v1/from/{self._hardware_id}/{self._channel_id}/{path}"
-        try:
-            await self._client.publish(topic, payload, **kwargs)
-        except Exception as e:
-            self._logger.error("failed to publish %s: %r", path, e)
-
-
-class DeviceLogSeverity(enum.Enum):
-
-    DEBUG = "debug"
-    INFO = "info"
-    WARNING = "warning"
-    ERROR = "error"

enapter/types.py

@@ -1,3 +0,0 @@
-from typing import Any, Dict
-
-JSON = Dict[str, Any]

enapter/vucm/__init__.py

@@ -1,12 +0,0 @@
-from .app import App, run
-from .config import Config
-from .device import Device
-from .ucm import UCM
-
-__all__ = [
-    "App",
-    "Config",
-    "Device",
-    "UCM",
-    "run",
-]

enapter/vucm/app.py

@@ -1,48 +0,0 @@
-import asyncio
-
-from .. import async_, log, mqtt
-from .config import Config
-from .ucm import UCM
-
-
-async def run(device_factory):
-    log.configure(level=log.LEVEL or "info")
-
-    config = Config.from_env()
-
-    async with App(config=config, device_factory=device_factory) as app:
-        await app.join()
-
-
-class App(async_.Routine):
-    def __init__(self, config, device_factory):
-        self._config = config
-        self._device_factory = device_factory
-
-    async def _run(self):
-        tasks = set()
-
-        mqtt_client = await self._stack.enter_async_context(
-            mqtt.Client(config=self._config.mqtt)
-        )
-        tasks.add(mqtt_client.task())
-
-        if self._config.start_ucm:
-            ucm = await self._stack.enter_async_context(
-                UCM(mqtt_client=mqtt_client, hardware_id=self._config.hardware_id)
-            )
-            tasks.add(ucm.task())
-
-        device = await self._stack.enter_async_context(
-            self._device_factory(
-                channel=mqtt_client.device_channel(
-                    hardware_id=self._config.hardware_id,
-                    channel_id=self._config.channel_id,
-                )
-            )
-        )
-        tasks.add(device.task())
-
-        self._started.set()
-
-        await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)

enapter/vucm/config.py

@@ -1,59 +0,0 @@
-import base64
-import json
-import os
-
-from .. import mqtt
-
-
-class Config:
-    @classmethod
-    def from_env(cls, prefix="ENAPTER_VUCM_", env=os.environ):
-        try:
-            blob = os.environ[prefix + "BLOB"]
-        except KeyError:
-            pass
-        else:
-            config = cls.from_blob(blob)
-            try:
-                config.channel_id = os.environ[prefix + "CHANNEL_ID"]
-            except KeyError:
-                pass
-            return config
-
-        hardware_id = os.environ[prefix + "HARDWARE_ID"]
-        channel_id = os.environ[prefix + "CHANNEL_ID"]
-
-        mqtt_config = mqtt.Config.from_env(prefix=prefix, env=env)
-
-        start_ucm = os.environ.get(prefix + "START_UCM", "1") != "0"
-
-        return cls(
-            hardware_id=hardware_id,
-            channel_id=channel_id,
-            mqtt_config=mqtt_config,
-            start_ucm=start_ucm,
-        )
-
-    @classmethod
-    def from_blob(cls, blob):
-        payload = json.loads(base64.b64decode(blob))
-
-        mqtt_config = mqtt.Config(
-            host=payload["mqtt_host"],
-            port=int(payload["mqtt_port"]),
-            tls_ca_cert=payload["mqtt_ca"],
-            tls_cert=payload["mqtt_cert"],
-            tls_secret_key=payload["mqtt_private_key"],
-        )
-
-        return cls(
-            hardware_id=payload["ucm_id"],
-            channel_id=payload["channel_id"],
-            mqtt_config=mqtt_config,
-        )
-
-    def __init__(self, hardware_id, channel_id, mqtt_config, start_ucm=True):
-        self.hardware_id = hardware_id
-        self.channel_id = channel_id
-        self.mqtt = mqtt_config
-        self.start_ucm = start_ucm

enapter/vucm/device.py

@@ -1,92 +0,0 @@
-import asyncio
-import traceback
-from typing import Optional, Set
-
-from .. import async_, mqtt, types
-from .logger import Logger
-
-
-class Device(async_.Routine):
-    def __init__(self, channel, cmd_prefix="cmd_", task_prefix="task_") -> None:
-        self.__channel = channel
-
-        self.__cmd_prefix = cmd_prefix
-        self.__task_prefix = task_prefix
-
-        self.log = Logger(channel=channel)
-        self.alerts: Set[str] = set()
-
-    async def send_telemetry(self, telemetry: Optional[types.JSON] = None) -> None:
-        if telemetry is None:
-            telemetry = {}
-        else:
-            telemetry = telemetry.copy()
-
-        telemetry.setdefault("alerts", list(self.alerts))
-
-        await self.__channel.publish_telemetry(telemetry)
-
-    async def send_properties(self, properties: Optional[types.JSON] = None) -> None:
-        if properties is None:
-            properties = {}
-        else:
-            properties = properties.copy()
-
-        await self.__channel.publish_properties(properties)
-
-    async def _run(self):
-        tasks = set()
-
-        for name in dir(self):
-            if name.startswith(self.__task_prefix):
-                task_func = getattr(self, name)
-                name_without_prefix = name[len(self.__task_prefix) :]
-                tasks.add(asyncio.create_task(task_func(), name=name_without_prefix))
-
-        tasks.add(
-            asyncio.create_task(
-                self.__process_command_requests(), name="command_requests_processor"
-            )
-        )
-
-        self._started.set()
-
-        try:
-            await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
-        except asyncio.CancelledError:
-            pass
-
-        finally:
-            for task in tasks:
-                task.cancel()
-                self._stack.push_async_callback(self.__wait_task, task)
-
-    async def __wait_task(self, task):
-        try:
-            await task
-        except asyncio.CancelledError:
-            pass
-        except Exception as e:
-            try:
-                await self.log.error(f"device task {task.get_name()!r} failed: {e!r}")
-            except:
-                pass
-            raise
-
-    async def __process_command_requests(self):
-        async with self.__channel.subscribe_to_command_requests() as reqs:
-            async for req in reqs:
-                state, payload = await self.__execute_command(req)
-                resp = req.new_response(state, payload)
-                await self.__channel.publish_command_response(resp)
-
-    async def __execute_command(self, req):
-        try:
-            cmd = getattr(self, self.__cmd_prefix + req.name)
-        except AttributeError:
-            return mqtt.CommandState.ERROR, {"reason": "unknown command"}
-
-        try:
-            return mqtt.CommandState.COMPLETED, await cmd(**req.args)
-        except:
-            return mqtt.CommandState.ERROR, {"traceback": traceback.format_exc()}

enapter/vucm/logger.py

@@ -1,39 +0,0 @@
-import logging
-
-from .. import mqtt
-
-LOGGER = logging.getLogger(__name__)
-
-
-class Logger:
-    def __init__(self, channel):
-        self._channel = channel
-        self._logger = self._new_logger(channel.hardware_id, channel.channel_id)
-
-    @staticmethod
-    def _new_logger(hardware_id, channel_id):
-        extra = {"hardware_id": hardware_id, "channel_id": channel_id}
-        return logging.LoggerAdapter(LOGGER, extra=extra)
-
-    async def debug(self, msg: str, persist: bool = False):
-        self._logger.debug(msg)
-        await self.log(msg, severity=mqtt.DeviceLogSeverity.DEBUG, persist=persist)
-
-    async def info(self, msg: str, persist: bool = False):
-        self._logger.info(msg)
-        await self.log(msg, severity=mqtt.DeviceLogSeverity.INFO, persist=persist)
-
-    async def warning(self, msg: str, persist: bool = False):
-        self._logger.warning(msg)
-        await self.log(msg, severity=mqtt.DeviceLogSeverity.WARNING, persist=persist)
-
-    async def error(self, msg: str, persist: bool = False):
-        self._logger.error(msg)
-        await self.log(msg, severity=mqtt.DeviceLogSeverity.ERROR, persist=persist)
-
-    async def log(
-        self, msg: str, severity: mqtt.DeviceLogSeverity, persist: bool = False
-    ):
-        await self._channel.publish_logs(msg=msg, severity=severity, persist=persist)
-
-    __call__ = log

enapter/vucm/ucm.py

@@ -1,30 +0,0 @@
-import asyncio
-
-from .device import Device
-
-
-class UCM(Device):
-    def __init__(self, mqtt_client, hardware_id):
-        super().__init__(
-            channel=mqtt_client.device_channel(
-                hardware_id=hardware_id, channel_id="ucm"
-            )
-        )
-
-    async def cmd_reboot(self):
-        await asyncio.sleep(0)
-        raise NotImplementedError
-
-    async def cmd_upload_lua_script(self, url, sha1, payload=None):
-        await asyncio.sleep(0)
-        raise NotImplementedError
-
-    async def task_telemetry_publisher(self):
-        while True:
-            await self.send_telemetry()
-            await asyncio.sleep(1)
-
-    async def task_properties_publisher(self):
-        while True:
-            await self.send_properties({"virtual": True, "lua_api_ver": 1})
-            await asyncio.sleep(10)

enapter-0.6.3.dist-info/METADATA

@@ -1,111 +0,0 @@
-Metadata-Version: 2.1
-Name: enapter
-Version: 0.6.3
-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: aiohttp (==3.8.*)
-Requires-Dist: asyncio-mqtt (==0.12.*)
-Requires-Dist: dnspython (==2.2.*)
-Requires-Dist: json-log-formatter (==0.5.*)
-
-# 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)
-
-Enapter software development kit for Python.
-
-:warning: **This project is work in progress. The API is not stable and may change at any time.** :warning:
-
-## Installation
-
-Stable from PyPI:
-
-```bash
-pip install enapter
-```
-
-Latest for GitHub:
-
-```bash
-pip install git+https://github.com/Enapter/python-sdk#egg=enapter
-```
-
-## Usage
-
-Checkout [examples](examples).
-
-## Implementing your own VUCM
-
-### Device Telemetry and Properties
-
-Every method of `enapter.vucm.Device` subclass with a name that starts with
-`task_` prefix is considered a _device task_. When such a device is started,
-all of its tasks are started as well. Device tasks are started in random order
-and are being executed concurrently in the background. If a device task returns
-or raises an exception, device routine is terminated. A typical use of the task
-is to run a periodic job to send device telemetry and properties.
-
-In order to send telemetry and properties define two corresponding device
-tasks. It is advised (but is not obligatory) to send telemetry every **1
-second** and to send properties every **10 seconds**.
-
-Examples:
-
-- [wttr-in](examples/vucm/wttr-in)
-
-### Device Commands
-
-Every method of `enapter.vucm.Device` subclass with a name that starts with
-`cmd_` prefix is considered a _device command handler_. Device command handlers
-receive the same arguments as described in device Blueprint manifest and can
-optionally return a payload as `dict`.
-
-In order to handle device commands define corresponding device command
-handlers.
-
-Examples:
-
-- [zhimi-fan-za5](examples/vucm/zhimi-fan-za5)
-
-### Device Alerts
-
-Device alerts are stored in `self.alerts`. It is a usual Python `set`, so you
-can add an alert using `alerts.add`, remove an alert `alerts.remove` and clear
-alerts using `alerts.clear`.
-
-Alerts are sent only as part of telemetry, so in order to report device alert,
-use `send_telemetry` with any payload.
-
-## Running your own VUCM via Docker
-
-A simple Dockerfile can be:
-
-```
-FROM python:3.10-alpine3.16
-
-WORKDIR /app
-
-RUN python -m venv .venv
-COPY requirements.txt requirements.txt
-RUN .venv/bin/pip install -r requirements.txt
-
-COPY script.py script.py
-
-CMD [".venv/bin/python", "script.py"]
-```
-
-:information_source: If you are using [Enapter
-Gateway](https://handbook.enapter.com/software/gateway_software/), you should
-connect your containers to `host` network :information_source::
-
-```bash
-docker run --network host ...
-```
-
-:warning: Host networking is not supported on Mac and Windows, so Docker VUCMs
-are at the moment only available on Linux.

enapter-0.6.3.dist-info/RECORD

@@ -1,27 +0,0 @@
-enapter/__init__.py,sha256=N95xA1SYof-WTNf_q5WfZIHXHHW4Tjx7Ezd_bNzlmk8,182
-enapter/types.py,sha256=2366bx_VI7bIBNnIaG5sol7G4k0PqaQ6oS74dzM4l1M,52
-enapter/async_/__init__.py,sha256=JuiRI2bN2AgB-HLfAUoSsZpEziwFRftNNEp59Evnd0M,109
-enapter/async_/generator.py,sha256=qBhnt36Gl2166sJFnZHsREbZu8l43M4DfxybUMIv6W4,300
-enapter/async_/routine.py,sha256=A5fG4XnCEQT0Qa_JNh1N43Fv5lnLaCoGF4xt6pOAdNs,1770
-enapter/log/__init__.py,sha256=n1sWMDKJSs_ebZzjbTrVdfg-oi0V1tvliTxgIV-msJ0,600
-enapter/log/json_formatter.py,sha256=P46zEdU5-dr3mDMkUjBy7z_FSMPi61RUgEYyBEfqVNQ,705
-enapter/mdns/__init__.py,sha256=uwsg8wJ0Lcsr9oOEW1PkEV3jVgWzgA7RG2ur_MRLtM0,55
-enapter/mdns/resolver.py,sha256=31zQz8LsUXKorh39QGqzknZBWpu2krBySm2xcCNYVPo,1159
-enapter/mqtt/__init__.py,sha256=D_RK-cScavukvDvwahEwvlvGLHSPsVLjG_JpdvpC2ok,336
-enapter/mqtt/client.py,sha256=qqAm8G5Lo8HUHOJPkyMmndijXWKIP8gN1hY_rMPrbzY,4975
-enapter/mqtt/command.py,sha256=ozhDTjRrdCWv_bzPTjVFpL8tx7nhirm3JtQaD45wTdo,1092
-enapter/mqtt/config.py,sha256=Bng9A271vXMg1cNZ1A0lWXVKQUzun8fQHLqqt8AMXNw,1399
-enapter/mqtt/device_channel.py,sha256=BrAuzrNITd3t6XRchOcO7gLY05m9C1Wv8Obrn6uCtsc,2556
-enapter/vucm/__init__.py,sha256=OhUYlVNO1RereHiZEyeJPdpEcy2QEqDBg4xBk_-A7-c,177
-enapter/vucm/app.py,sha256=UmwFrercm2MWs7ZUBRAAjNQ-74gQfklA5puEROe2ba8,1325
-enapter/vucm/config.py,sha256=ir5EQwniN2vNuMbLS1YpXh9mSyHXALk3j8kOwxdoGHo,1649
-enapter/vucm/device.py,sha256=JMer-q19nuBCyXbvvYAoQuRGrETUA7p7Hwk3mWIzOCk,2923
-enapter/vucm/logger.py,sha256=nzcb8y5jEsykGxrLLgwkkx_cU4-hOhsyVxA5Mqv3zqo,1354
-enapter/vucm/ucm.py,sha256=tcHy-Lkv5XhwwcgOiG6hsNNT1CzEKISNqWOJiZxjeIk,824
-tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-tests/test_async.py,sha256=KwhwKBSeSb7Qyaf50Ca2LGB7gm3m5j5wgGgWnvYY98k,4208
-tests/test_log.py,sha256=DQD1OCVkYYzy-Kq-jH_xsaRDtiwIqULuTgMitjSeiuo,1876
-enapter-0.6.3.dist-info/METADATA,sha256=nKgQF-xwZfiHTBHpR8SVZkDsWvsBVVxXfzuD6tiom1w,3303
-enapter-0.6.3.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-enapter-0.6.3.dist-info/top_level.txt,sha256=DsMzVradd7z3A0fm7zmn9oh08ijO41RtzglrnPlx54w,14
-enapter-0.6.3.dist-info/RECORD,,