uns-kit 0.0.4__py3-none-any.whl → 0.0.5__py3-none-any.whl

uns_kit/uns_mqtt_proxy.py

@@ -0,0 +1,237 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Any, Dict, Optional
+
+from .client import UnsMqttClient
+from .packet import UnsPacket, isoformat
+from .proxy import UnsProxy
+from .topic_builder import TopicBuilder
+
+
+class MessageMode(str, Enum):
+    RAW = "raw"
+    DELTA = "delta"
+    BOTH = "both"
+
+
+@dataclass
+class LastValueEntry:
+    value: Any
+    uom: Optional[str]
+    timestamp: datetime
+
+
+class UnsMqttProxy(UnsProxy):
+    def __init__(
+        self,
+        host: str,
+        *,
+        process_name: str,
+        instance_name: str,
+        package_name: str = "uns-kit",
+        package_version: str = "0.0.1",
+        port: Optional[int] = None,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        tls: bool = False,
+        client_id: Optional[str] = None,
+        keepalive: int = 60,
+        clean_session: bool = True,
+    ) -> None:
+        self.topic_builder = TopicBuilder(package_name, package_version, process_name)
+        self.instance_status_topic = self.topic_builder.instance_status_topic(instance_name)
+        self.client = UnsMqttClient(
+            host,
+            port=port,
+            username=username,
+            password=password,
+            tls=tls,
+            client_id=client_id,
+            keepalive=keepalive,
+            clean_session=clean_session,
+            topic_builder=self.topic_builder,
+            instance_name=instance_name,
+            publisher_active=True,
+            subscriber_active=True,
+        )
+        super().__init__(self.client, self.instance_status_topic, instance_name)
+        self._last_values: Dict[str, LastValueEntry] = {}
+        self._sequence_ids: Dict[str, int] = {}
+
+    async def connect(self) -> None:
+        await self.client.connect()
+        await self.start()
+
+    async def close(self) -> None:
+        await self.stop()
+        await self.client.close()
+
+    async def publish_message(self, topic: str, payload: str | bytes) -> None:
+        await self.client.publish_raw(topic, payload)
+
+    async def publish_packet(self, topic: str, packet: Dict[str, Any]) -> None:
+        await self.client.publish_packet(topic, packet)
+
+    async def publish_mqtt_message(self, mqtt_message: Dict[str, Any], mode: MessageMode = MessageMode.RAW) -> None:
+        attrs = mqtt_message.get("attributes")
+        if attrs is None:
+            raise ValueError("mqtt_message must include attributes")
+        if not isinstance(attrs, list):
+            attrs = [attrs]
+
+        base_topic = mqtt_message.get("topic", "")
+        asset = mqtt_message.get("asset")
+        asset_description = mqtt_message.get("assetDescription")
+        object_type = mqtt_message.get("objectType")
+        object_type_description = mqtt_message.get("objectTypeDescription")
+        object_id = mqtt_message.get("objectId")
+
+        for attr in attrs:
+            attribute = attr.get("attribute")
+            if attribute is None:
+                raise ValueError("attribute is required")
+            description = attr.get("description")
+            tags = attr.get("tags")
+            attribute_needs_persistence = attr.get("attributeNeedsPersistence")
+
+            message = attr.get("message")
+            if message is None:
+                if "data" in attr:
+                    message = {
+                        "data": attr["data"],
+                        **({"createdAt": attr["createdAt"]} if attr.get("createdAt") else {}),
+                        **({"expiresAt": attr["expiresAt"]} if attr.get("expiresAt") else {}),
+                    }
+                elif "table" in attr:
+                    message = {
+                        "table": attr["table"],
+                        **({"createdAt": attr["createdAt"]} if attr.get("createdAt") else {}),
+                        **({"expiresAt": attr["expiresAt"]} if attr.get("expiresAt") else {}),
+                    }
+                else:
+                    raise ValueError("Attribute entry must include exactly one of data/table/message")
+
+            packet = UnsPacket.from_message(message)
+
+            msg = {
+                "topic": base_topic,
+                "asset": asset,
+                "assetDescription": asset_description,
+                "objectType": object_type,
+                "objectTypeDescription": object_type_description,
+                "objectId": object_id,
+                "attribute": attribute,
+                "description": description or attribute,
+                "tags": tags,
+                "attributeNeedsPersistence": attribute_needs_persistence,
+                "packet": packet,
+            }
+
+            if mode == MessageMode.RAW:
+                await self._process_and_publish(msg, value_is_cumulative=False)
+            elif mode == MessageMode.DELTA:
+                delta_msg = dict(msg)
+                delta_msg["attribute"] = f"{attribute}-delta"
+                delta_msg["description"] = f"{msg['description']} (delta)"
+                await self._process_and_publish(delta_msg, value_is_cumulative=True)
+            elif mode == MessageMode.BOTH:
+                await self._process_and_publish(msg, value_is_cumulative=False)
+                delta_msg = dict(msg)
+                delta_msg["attribute"] = f"{attribute}-delta"
+                delta_msg["description"] = f"{msg['description']} (delta)"
+                await self._process_and_publish(delta_msg, value_is_cumulative=True)
+
+    def _resolve_object_identity(self, msg: Dict[str, Any]) -> None:
+        topic = msg.get("topic", "")
+        provided_type = msg.get("objectType")
+        provided_id = msg.get("objectId")
+        provided_asset = msg.get("asset")
+
+        parts = [p for p in topic.split("/") if p]
+        parsed_type = parts[-2] if len(parts) >= 2 else None
+        parsed_id = parts[-1] if len(parts) >= 1 else None
+        parsed_asset = parts[-3] if len(parts) >= 3 else None
+
+        msg["objectType"] = provided_type or parsed_type
+        msg["objectId"] = provided_id or parsed_id or "main"
+        msg["asset"] = provided_asset or parsed_asset
+
+    def _normalize_topic(self, topic: str) -> str:
+        return topic if topic.endswith("/") else f"{topic}/"
+
+    async def _process_and_publish(self, msg: Dict[str, Any], *, value_is_cumulative: bool) -> None:
+        self._resolve_object_identity(msg)
+        base_topic = self._normalize_topic(msg.get("topic", ""))
+
+        packet = msg["packet"]
+        message = packet.get("message", {})
+        data = message.get("data")
+        table = message.get("table")
+
+        attribute_type = "Data" if data is not None else "Table" if table is not None else None
+        data_group = ""
+        if isinstance(data, dict):
+            data_group = data.get("dataGroup") or ""
+        if isinstance(table, dict):
+            data_group = table.get("dataGroup") or ""
+
+        await self.register_unique_topic(
+            {
+                "timestamp": isoformat(datetime.now(timezone.utc)),
+                "topic": base_topic,
+                "asset": msg.get("asset"),
+                "assetDescription": msg.get("assetDescription"),
+                "objectType": msg.get("objectType"),
+                "objectTypeDescription": msg.get("objectTypeDescription"),
+                "objectId": msg.get("objectId"),
+                "attribute": msg.get("attribute"),
+                "attributeType": attribute_type,
+                "description": msg.get("description"),
+                "tags": msg.get("tags"),
+                "attributeNeedsPersistence": msg.get("attributeNeedsPersistence"),
+                "dataGroup": data_group,
+            }
+        )
+
+        publish_topic = (
+            f"{base_topic}"
+            f"{msg.get('asset') + '/' if msg.get('asset') else ''}"
+            f"{msg.get('objectType') + '/' if msg.get('objectType') else ''}"
+            f"{msg.get('objectId') + '/' if msg.get('objectId') else ''}"
+            f"{msg.get('attribute')}"
+        )
+
+        seq_id = self._sequence_ids.get(base_topic, 0)
+        self._sequence_ids[base_topic] = seq_id + 1
+        packet["sequenceId"] = seq_id
+
+        if isinstance(data, dict):
+            time_value = data.get("time")
+            if not time_value:
+                time_value = UnsPacket.data(value=0)["message"]["data"]["time"]
+                data["time"] = time_value
+            current_time = datetime.fromisoformat(time_value.replace("Z", "+00:00"))
+            new_value = data.get("value")
+            new_uom = data.get("uom")
+            last = self._last_values.get(publish_topic)
+            if last:
+                interval_ms = int((current_time - last.timestamp).total_seconds() * 1000)
+                packet["interval"] = interval_ms
+                if value_is_cumulative and isinstance(new_value, (int, float)) and isinstance(last.value, (int, float)):
+                    delta = new_value - last.value
+                    data["value"] = delta
+                    data["time"] = isoformat(current_time)
+                self._last_values[publish_topic] = LastValueEntry(new_value, new_uom, current_time)
+                await self.client.publish_raw(publish_topic, UnsPacket.to_json(packet))
+            else:
+                self._last_values[publish_topic] = LastValueEntry(new_value, new_uom, current_time)
+                # For delta mode with no previous value, skip to avoid bogus delta; otherwise publish.
+                if not value_is_cumulative:
+                    await self.client.publish_raw(publish_topic, UnsPacket.to_json(packet))
+        elif isinstance(table, dict):
+            await self.client.publish_raw(publish_topic, UnsPacket.to_json(packet))
+        else:
+            raise ValueError("packet.message must include data or table")

uns_kit/version.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+try:  # pragma: no cover - best-effort metadata fetch
+    from importlib.metadata import version
+
+    __version__ = version("uns-kit")
+except Exception:  # fallback for editable/local
+    __version__ = "0.0.0"
+

{uns_kit-0.0.4.dist-info → uns_kit-0.0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uns-kit
-Version: 0.0.4
+Version: 0.0.5
 Summary: Lightweight Python UNS MQTT client (pub/sub + infra topics)
 License: MIT
 Author: Aljoša Vister
@@ -15,6 +15,7 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
 Requires-Dist: asyncio-mqtt (>=0.16.1,<0.17.0)
 Requires-Dist: click (>=8.1.7,<9.0.0)
+Requires-Dist: paho-mqtt (<2)
 Description-Content-Type: text/markdown
 
 # uns-kit (Python)
@@ -22,8 +23,8 @@ Description-Content-Type: text/markdown
 Lightweight UNS MQTT client for Python. Provides:
 - Topic builder compatible with UNS infra topics (`uns-infra/<package>/<version>/<process>/`).
 - Async publish/subscribe via MQTT v5 (using `asyncio-mqtt`).
-- Infra status topics (`alive`, `uptime`) with MQTT will.
-- Minimal UNS packet builder/parser (data/table).
+- Process + instance status topics (active/heap/uptime/alive + stats).
+- Minimal UNS packet builder/parser (data/table) aligned with TS core.
 
 ## Install (editable)
 ```bash
@@ -42,20 +43,21 @@ poetry run uns-kit-py write-config --path config.json
 ## Quick start
 ```python
 import asyncio
-from uns_kit import UnsMqttClient, TopicBuilder, UnsPacket
+from uns_kit import UnsConfig, UnsPacket, UnsProxyProcess
 
 async def main():
-    tb = TopicBuilder(package_name="uns-kit", package_version="0.0.1", process_name="py-demo")
-    client = UnsMqttClient(host="mqtt-broker", topic_builder=tb, reconnect_interval=1)
-    await client.connect()
+    process = UnsProxyProcess("mqtt-broker", config=UnsConfig(host="mqtt-broker"))
+    await process.start()
+    mqtt = await process.create_mqtt_proxy("py")
 
     # Subscribe
-    async with client.messages("uns-infra/#") as messages:
-        await client.publish_packet("raw/data/", UnsPacket.data(value=1, uom="count"))
+    async with mqtt.client.messages("uns-infra/#") as messages:
+        await mqtt.publish_packet("raw/data/", UnsPacket.data(value=1, uom="count"))
         msg = await messages.__anext__()
         print(msg.topic, msg.payload.decode())
 
-    await client.close()
+    await mqtt.close()
+    await process.stop()
 
 asyncio.run(main())
 ```
@@ -69,6 +71,7 @@ async for msg in client.resilient_messages("uns-infra/#"):
 ### Examples
 - `examples/publish.py` — publish 5 data packets.
 - `examples/subscribe.py` — resilient subscription with auto-reconnect.
+- `examples/load_test.py` — interactive publish burst.
 
 ### Create a new project
 ```bash
@@ -78,8 +81,22 @@ poetry install
 poetry run python src/main.py
 ```
 
+### Create a sandbox app in this repo
+From the monorepo root:
+```bash
+pnpm run py:sandbox
+```
+This creates `sandbox-app-py/` using the default Python template.
+
 ## Notes
-- Default QoS is 0; will message is retained on `<statusTopic>alive`.
-- Uptime is published every 10 seconds on `<statusTopic>uptime`.
-- Packet shape mirrors the TypeScript core: `{"version":1,"message":{"data":{...}},"sequenceId":0}`.
+- Default QoS is 0.
+- Instance status topics are published every 10 seconds; stats every 60 seconds.
+- Packet shape mirrors the TypeScript core: `{"version":"1.3.0","message":{"data":{...}},"sequenceId":0}`.
+
+## TODO (parity with TS core)
+- Handover manager (cross-version active detection + handover_* messages).
+- Publish throttling/queue.
+- Status parity (publisher/subscriber active flags everywhere, richer metrics).
+- API endpoints registry (to mirror @uns-kit/api produced endpoints).
+- Optional: dictionary/measurement helpers + CLI wrapper.
 

uns_kit-0.0.5.dist-info/RECORD

@@ -0,0 +1,19 @@
+uns_kit/__init__.py,sha256=oLhYBOJkoYXBJGN7VDtJpMXAb1v5qFVphun5QgFwthw,564
+uns_kit/cli.py,sha256=USq7bHl6sL75s--Y_nV2j7v1JScZWehZp92GyqYgjyw,5552
+uns_kit/client.py,sha256=GjlGOTPuaxeLlgkfcJWpxMId6nLeZNsZTNBfOYAe8YY,14892
+uns_kit/config.py,sha256=K9FIvFB_zk59I_9XW5PA7sDRJOMl-5-3VCHbpyLgxyM,2899
+uns_kit/packet.py,sha256=M-JJ0--FVe-iFPGnBUFynx_0iKB9F3NFwvETJ7yKibc,5874
+uns_kit/proxy.py,sha256=H1Afs71rdb7DTHYp_8qeoM8uN5vOvAzYK50u9JszXQQ,2338
+uns_kit/proxy_process.py,sha256=If8HXd_YAf1xYjzy8BA73Jo0DRh0-3WpHHIoVcIbS-Q,3906
+uns_kit/status_monitor.py,sha256=8XXBaUHh8SW7gX4d3EtChnEkgQ7rnQ14tEHb0jDB25I,3022
+uns_kit/templates/default/README.md,sha256=V8HXk3MxL9Aq21lm-zt8WOK7n3pDBI4CMrvtRYOPPK4,1213
+uns_kit/templates/default/pyproject.toml,sha256=JT2gYvmofwBuS7FI7U0i_5U3TzyiXrwU6w-bz-cTvKU,540
+uns_kit/templates/default/src/data_example.py,sha256=8D1CyGVsbeKzZV79l8zaX-hqz_gxrA_ps2TA-GwzLQI,4381
+uns_kit/templates/default/src/load_test.py,sha256=cmQ3FzakBisLJU5TTNVpHpfdnIoA32c2pN7dnEwlfgo,3359
+uns_kit/topic_builder.py,sha256=UYC2SS9ptHopeyQ3ud1HEg1IHr5RJ7X2DEkfZC1CM5Y,1938
+uns_kit/uns_mqtt_proxy.py,sha256=QzG0E42r7n33Z4Ri70-DxTlVoM-wj0_wAtnbMyaet08,9831
+uns_kit/version.py,sha256=vmk-z_o25XOVgX5lSUrECllqau8NL7B_pkKsSmwhmX0,247
+uns_kit-0.0.5.dist-info/METADATA,sha256=VZ2JjJ_7twYxRtrSEURUXfPKsdSiqhGKuVIH08Zrg-M,3306
+uns_kit-0.0.5.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
+uns_kit-0.0.5.dist-info/entry_points.txt,sha256=sLvTioiJQfGczUD-ODVx2xwwtHcGKjlIOn8t_Lt87Pg,47
+uns_kit-0.0.5.dist-info/RECORD,,

uns_kit/templates/default/src/main.py

@@ -1,27 +0,0 @@
-import asyncio
-import json
-from pathlib import Path
-from uns_kit import UnsMqttClient, TopicBuilder, UnsPacket
-
-
-async def main():
-    cfg = json.loads(Path("config.json").read_text())
-    tb = TopicBuilder(cfg["packageName"], cfg["packageVersion"], cfg["processName"])
-    client = UnsMqttClient(
-        cfg["host"],
-        port=cfg.get("port"),
-        username=cfg.get("username") or None,
-        password=cfg.get("password") or None,
-        tls=cfg.get("tls", False),
-        client_id=cfg.get("clientId"),
-        topic_builder=tb,
-        reconnect_interval=1,
-    )
-    await client.connect()
-    await client.publish_packet("raw/data/", UnsPacket.data(value=1, uom="count"))
-    async for msg in client.resilient_messages("uns-infra/#"):
-        print(msg.topic, msg.payload.decode())
-
-
-if __name__ == "__main__":
-    asyncio.run(main())

uns_kit-0.0.4.dist-info/RECORD

@@ -1,13 +0,0 @@
-uns_kit/__init__.py,sha256=-4R72u-uzg2ib2Z1SFQiSX5KSNYY6oMqVvGoVPI3eQs,290
-uns_kit/cli.py,sha256=USq7bHl6sL75s--Y_nV2j7v1JScZWehZp92GyqYgjyw,5552
-uns_kit/client.py,sha256=bFXAKmuR06mSlO8tsAoeB7jv9RQgw1a_AIbXQNpNFTw,5815
-uns_kit/config.py,sha256=mRMiuxGV6CEIBDVZUJQqYIeGxKzfBhlXCcGNXnVtBj4,869
-uns_kit/packet.py,sha256=qd6BrCv_JE8fxh-iaJBAVhUZvY28lhiDr9F1At8CXjw,1675
-uns_kit/templates/default/README.md,sha256=IQ1zvCSzigE3foKBLkDv9UZnZEScuS6V19oCSCJPvXw,149
-uns_kit/templates/default/pyproject.toml,sha256=dxSghe6RiljsXfz4Gt_YXB1g-P_W2jiYUJk6ug4TytE,362
-uns_kit/templates/default/src/main.py,sha256=0mxq9Oa00UwqlEiJIBnlDiulBPECJ4YSojqjv6tonTk,850
-uns_kit/topic_builder.py,sha256=JGYdYynRWWSwzXaCaRLjap0-du13eSc6qe1V0GrD_ak,1492
-uns_kit-0.0.4.dist-info/METADATA,sha256=CjegZQzS1ZMvRyMEXB7p21RaejS7cidggXYvKgZ_QMs,2736
-uns_kit-0.0.4.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
-uns_kit-0.0.4.dist-info/entry_points.txt,sha256=sLvTioiJQfGczUD-ODVx2xwwtHcGKjlIOn8t_Lt87Pg,47
-uns_kit-0.0.4.dist-info/RECORD,,