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

uns_kit/templates/default/src/load_test.py

@@ -0,0 +1,103 @@
+import asyncio
+import math
+from datetime import datetime
+from pathlib import Path
+
+from uns_kit import UnsConfig, UnsMqttClient, TopicBuilder
+
+
+def load_config() -> UnsConfig:
+    cfg_path = Path("config.json")
+    if cfg_path.exists():
+        return UnsConfig.load(cfg_path)
+    return UnsConfig(host="localhost")
+
+
+def simulate_sensor_value(step: int) -> float:
+    base_value = 42.0
+    fast_cycle = math.sin(step / 5.0) * 3.0
+    slow_cycle = math.sin(step / 25.0) * 6.0
+    ripple = math.sin(step / 2.0 + math.pi / 4.0) * 0.5
+    value = base_value + fast_cycle + slow_cycle + ripple
+    return round(value, 2)
+
+
+def prompt_bool(prompt: str, default_yes: bool = True) -> bool:
+    suffix = " (Y/n) " if default_yes else " (y/N) "
+    answer = input(prompt + suffix).strip().lower()
+    if not answer:
+        return default_yes
+    return answer in ("y", "yes")
+
+
+def prompt_int(prompt: str, default: int, suffix: str = "") -> int:
+    answer = input(f"{prompt} (default {default}{suffix}) ").strip()
+    try:
+        return int(answer) if answer else default
+    except ValueError:
+        return default
+
+
+def prompt_topic(prompt: str, default: str) -> str:
+    answer = input(f"{prompt} (default {default}) ").strip()
+    return answer or default
+
+
+def log_info(message: str) -> None:
+    timestamp = datetime.now().isoformat(timespec="seconds")
+    print(f"{timestamp} [INFO] {message}")
+
+
+async def main() -> None:
+    cfg = load_config()
+    host = f"{cfg.host}:{cfg.port}" if cfg.port else cfg.host
+
+    if not prompt_bool(f"Would you like to continue with load-test on {host}?"):
+        print("Load test aborted.")
+        return
+
+    count = prompt_int("How many iterations should be run?", 100, "")
+    delay_ms = prompt_int("What should be the delay between intervals in milliseconds?", 0, " ms")
+    topic = prompt_topic("Topic to publish to", "raw/data")
+    retain = prompt_bool("Retain each published message so late subscribers see the last value?", True)
+    delay_s = delay_ms / 1000.0
+
+    log_info(f"Starting load test with {count} messages and {delay_ms} ms delay...")
+
+    # Use a dedicated identity for load testing to avoid clashing with app processes.
+    tb = TopicBuilder(package_name="uns-loadtest", package_version="0.0.0", process_name="load-tester")
+    client = UnsMqttClient(
+        cfg.host,
+        port=cfg.port,
+        username=cfg.username or None,
+        password=cfg.password or None,
+        tls=cfg.tls,
+        client_id="uns-loadtest-client",
+        topic_builder=tb,
+        instance_name="py-load-test",
+        reconnect_interval=1,
+    )
+    await client.connect()
+
+    start = asyncio.get_event_loop().time()
+    for i in range(count):
+        now = asyncio.get_event_loop().time()
+        sensor_value = simulate_sensor_value(i)
+        raw_payload = f"{i},{int(now * 1000)},{sensor_value}"
+        await client.publish_raw(topic, raw_payload, retain=retain)
+        if delay_s:
+            await asyncio.sleep(delay_s)
+
+    log_info("Sleeping for 50ms.")
+    await asyncio.sleep(0.05)
+    end = asyncio.get_event_loop().time()
+    duration = end - start
+    rate = count / duration if duration > 0 else 0
+    log_info(f"Load test completed in {duration:.2f} seconds.")
+    log_info(f"Message rate: {rate:.2f} msg/s.")
+
+    await client.close()
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

uns_kit/topic_builder.py

@@ -33,6 +33,16 @@ class TopicBuilder:
     def handover_topic(self) -> str:
         return f"{self._base}handover"
 
+    def wildcard_active_topic(self) -> str:
+        parts = self._base.strip("/").split("/")
+        if len(parts) < 2:
+            raise ValueError("processStatusTopic must follow 'uns-infra/<package>/<version>/<process>/'")
+        return "/".join(parts[:2]) + "/+/+/active"
+
+    def instance_status_topic(self, instance_name: str) -> str:
+        sanitized = self.sanitize_topic_part(instance_name)
+        return f"{self._base}{sanitized}/"
+
     @staticmethod
     def extract_base_topic(full_topic: str) -> str:
         parts = full_topic.split("/")

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.3.dist-info → uns_kit-0.0.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: uns-kit
-Version: 0.0.3
+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,9 +71,32 @@ 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
+uns-kit-py create my-uns-py-app
+cd my-uns-py-app
+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-0.0.3.dist-info/RECORD

@@ -1,10 +0,0 @@
-uns_kit/__init__.py,sha256=-4R72u-uzg2ib2Z1SFQiSX5KSNYY6oMqVvGoVPI3eQs,290
-uns_kit/cli.py,sha256=BVqLPNegmbEasBr_k2Qt4S_A3fQuP8tn5d5Z_bO5t5w,4800
-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/topic_builder.py,sha256=JGYdYynRWWSwzXaCaRLjap0-du13eSc6qe1V0GrD_ak,1492
-uns_kit-0.0.3.dist-info/METADATA,sha256=w6WCkwhbS7KmMuqskMiFKgblVFJsgKu4-G_Rbw6WPBk,2604
-uns_kit-0.0.3.dist-info/WHEEL,sha256=3ny-bZhpXrU6vSQ1UPG34FoxZBp3lVcvK0LkgUz6VLk,88
-uns_kit-0.0.3.dist-info/entry_points.txt,sha256=sLvTioiJQfGczUD-ODVx2xwwtHcGKjlIOn8t_Lt87Pg,47
-uns_kit-0.0.3.dist-info/RECORD,,