@uns-kit/cli 0.0.34 → 0.0.36

package/templates/python/examples/README.md

@@ -1,84 +1,134 @@
-# Python Examples for the UNS gRPC Gateway
-
-These examples demonstrate how to use the Node-based UNS Gateway (MQTT + UNS infra) from Python via gRPC. They mirror the TypeScript examples for data, table, cron-like publishing, and API endpoints.
-
-The gateway centralizes all UNS rules (packet format, sequenceId, interval, produced topics, handover). Python focuses on business logic and ML/ETL while calling the gateway.
-
-## Prerequisites
-
-- Build the Node project once: `npm run build`
-- Generate Python stubs and venv: `cd python && ./scripts/setup.sh && source venv/bin/activate`
-- Ensure `config.json` is present at repo root (Node gateway reads brokers and UNS options from it)
-
-## Gateway Address
-
-- If `--addr` is omitted, each script auto‑generates a unique address:
-  - Unix/macOS: `unix:/tmp/uns-gateway-<script>-<pid>.sock`
-  - Windows: `127.0.0.1:<ephemeral_port>`
-- You can still pass an explicit `--addr` if you want a fixed address.
-
-All examples accept `--addr` and `--auto`. With `--auto`, the example will spawn the gateway via `npm run gateway` and wait until it's ready.
-
-Imports note: Examples add the generated stubs folder (`python/gen`) to `sys.path` so you can run them from the repo root or from the `python/` folder. Ensure you’ve run `./scripts/setup.sh` so `gen` exists.
-
-Readiness: Examples call the gateway’s `Ready()` RPC to wait for the requested components (publisher/subscriber/API) to be active before publishing or subscribing. No manual sleeps are required.
-
-## Common Flags
-
-- `--addr`: Gateway address (`unix:/path.sock` or `host:port`)
-- `--auto`: Auto-start the gateway if not running
-
-## Scripts
-
-- `data_transformer.py`
-  - Subscribes to input topics (default `raw/#`) and publishes UNS data packets (`example/` + `data-number`).
-  - Examples:
-    - Unix/macOS: `python python/examples/data_transformer.py --addr unix:/tmp/uns-gateway.sock --auto --in raw/# --out-topic example/ --attribute data-number --uom mV --group electricity`
-    - Windows: `python python/examples/data_transformer.py --addr 127.0.0.1:50051 --auto --in raw/# --out-topic example/ --attribute data-number --uom mV --group electricity`
-
-- `table_transformer.py`
-  - Subscribes to `integration/raw-table` JSON and publishes a UNS table packet (`example/factory-a/line-1/` + `table-sample`).
-  - Examples:
-    - Unix/macOS: `python python/examples/table_transformer.py --addr unix:/tmp/uns-gateway.sock --auto --in-topic integration/raw-table --out-topic example/factory-a/line-1/ --attribute table-sample`
-    - Windows: `python python/examples/table_transformer.py --addr 127.0.0.1:50051 --auto --in-topic integration/raw-table --out-topic example/factory-a/line-1/ --attribute table-sample`
-
-- `data_publisher_loop.py`
-  - Cron-like loop that publishes a data value periodically (default 1000 ms).
-  - Examples:
-    - Unix/macOS: `python python/examples/data_publisher_loop.py --addr unix:/tmp/uns-gateway.sock --auto --out-topic example/ --attribute data-number --uom mV --period-ms 1000`
-    - Windows: `python python/examples/data_publisher_loop.py --addr 127.0.0.1:50051 --auto --out-topic example/ --attribute data-number --uom mV --period-ms 1000`
-
-- `data_publish_once.py`
-  - Sends a single UNS data packet.
-  - Examples:
-    - Unix/macOS: `python python/examples/data_publish_once.py --addr unix:/tmp/uns-gateway.sock --auto --out-topic example/ --attribute data-number --value 42 --uom mV --group electricity`
-    - Windows: `python python/examples/data_publish_once.py --addr 127.0.0.1:50051 --auto --out-topic example/ --attribute data-number --value 42 --uom mV --group electricity`
-
-- `data_subscribe.py`
-  - Subscribes to topics via the gateway and prints messages.
-  - Examples:
-    - Unix/macOS: `python python/examples/data_subscribe.py --addr unix:/tmp/uns-gateway.sock --auto raw/# some/other/topic`
-    - Windows: `python python/examples/data_subscribe.py --addr 127.0.0.1:50051 --auto raw/# some/other/topic`
-
-- `api_register_and_serve.py`
-  - Registers `/api/example/summary-1` and `/api/example/summary-2` endpoints and serves requests over a bidirectional stream.
-  - Examples:
-    - Unix/macOS: `python python/examples/api_register_and_serve.py --addr unix:/tmp/uns-gateway.sock --auto`
-    - Windows: `python python/examples/api_register_and_serve.py --addr 127.0.0.1:50051 --auto`
-    - Then call: `http://<gateway-host>:<gateway-port>/api/example/summary-1?filter=foo&limit=10`
-
-- `api_handler.py`
-  - Another API handler demo that returns structured JSON responses. Similar to `api_register_and_serve.py`.
-
-## Auth
-
-- If `config.json` sets `uns.jwksWellKnownUrl`, the gateway enforces JWT via JWKS (and path rules), matching UnsApiProxy behavior.
-- Otherwise, it uses a dev `jwtSecret` ("CHANGEME"). For local testing, you can:
-  - Remove JWKS settings in `config.json` and rely on the dev secret, or
-  - Provide a valid Bearer token as required by your environment.
-
-## Notes
-
-- The gateway binds to `--addr` or the `UNS_GATEWAY_ADDR` env var. Examples pass `--addr` explicitly.
-- On Unix/macOS, a stable UDS path (e.g., `/tmp/uns-gateway.sock`) is recommended for simplicity.
-- All examples will auto-start the gateway when `--auto` is used.
+# Python Examples for the UNS gRPC Gateway
+
+These examples demonstrate how to use the Node-based UNS Gateway (MQTT + UNS infra) from Python via gRPC. They mirror the TypeScript examples for data, table, cron-like publishing, and API endpoints.
+
+The gateway centralizes all UNS rules (packet format, sequenceId, interval, produced topics, handover). Python focuses on business logic and ML/ETL while calling the gateway.
+
+## Prerequisites
+
+- Build the Node project once: `npm run build`
+- Generate Python stubs and venv: `cd python && ./scripts/setup.sh && source venv/bin/activate`
+- Ensure `config.json` is present at repo root (Node gateway reads brokers and UNS options from it)
+
+## Gateway Address
+
+- If `--addr` is omitted, each script auto‑generates a unique address:
+  - Unix/macOS: `unix:/tmp/uns-gateway-<script>-<pid>.sock`
+  - Windows: `127.0.0.1:<ephemeral_port>`
+- You can still pass an explicit `--addr` if you want a fixed address.
+
+All examples accept `--addr` and `--auto`. With `--auto`, the example will spawn the gateway via `npm run gateway` and wait until it's ready.
+
+Imports note: Examples add the generated stubs folder (`python/gen`) to `sys.path` so you can run them from the repo root or from the `python/` folder. Ensure you’ve run `./scripts/setup.sh` so `gen` exists.
+
+Readiness: Examples call the gateway’s `Ready()` RPC to wait for the requested components (publisher/subscriber/API) to be active before publishing or subscribing. No manual sleeps are required.
+
+## Common Flags
+
+- `--addr`: Gateway address (`unix:/path.sock` or `host:port`)
+- `--auto`: Auto-start the gateway if not running
+
+## Scripts
+### `data_transformer.py`
+
+Transforms incoming sensor data and republishes it to a target topic.
+
+-   **Description:**  
+    Subscribes to `sensors/temperature`, applies a transformation (e.g., scales the value), and republishes it as processed data.
+    
+-   **Example:**
+    
+    ```bash
+    python python/examples/data_transformer.py
+    ```
+    
+    Transforms data from `sensors/temperature` and republishes to `sensors/temperature/room1` it with a modified value.
+    
+
+---
+
+### `data_subscribe.py`
+
+Subscribes to topics via the gateway and prints received messages.
+
+-   **Description:**  
+    Useful for monitoring live data updates.
+    
+-   **Example:**
+    
+    ```bash
+    python python/examples/data_subscribe.py
+    ```
+    
+    Prints all messages received from `sensors/temperature`.
+    
+
+---
+
+### `data_publish.py`
+
+Publishes a single data point to a UNS topic.
+
+-   **Description:**  
+    Sends a single temperature measurement (e.g., 22.5 °C) to the gateway, waits 10 seconds, then exits.
+    
+-   **Example:**
+    
+    ```bash
+    python python/examples/data_publish.py
+    ```
+    
+    Publishes one temperature value to `sensors/temperature/room1`.
+    
+
+---
+
+### `table_transformer.py`
+
+Publishes a structured table-like JSON object as UNS table data.
+
+-   **Description:**  
+    Sends summarized or grouped sensor data (e.g., temperature, humidity, status) to a topic.
+    
+-   **Example:**
+    
+    ```bash
+    python python/examples/dtable_transformer.py
+    ```
+    
+    Publishes a table with room statistics (temperature, humidity, etc.) to `sensors/summary/room1`.
+    
+
+---
+
+### `api_handler.py`
+
+Registers and handles an example API endpoint for querying data.
+
+-   **Description:**  
+    Demonstrates registering an API endpoint (`example/summary-1`) with query parameters and returning JSON responses.
+    
+-   **Example:**
+    
+    ```bash
+    python python/examples/api_handler.py
+    ```
+    
+    Then test it with:
+    
+    ```bash
+    http://<gateway-host>:<gateway-port>/api/example/summary-1?filter=test&limit=10
+    ```
+
+## Auth
+
+- If `config.json` sets `uns.jwksWellKnownUrl`, the gateway enforces JWT via JWKS (and path rules), matching UnsApiProxy behavior.
+- Otherwise, it uses a dev `jwtSecret` ("CHANGEME"). For local testing, you can:
+  - Remove JWKS settings in `config.json` and rely on the dev secret, or
+  - Provide a valid Bearer token as required by your environment.
+
+## Notes
+
+- The gateway binds to `--addr` or the `UNS_GATEWAY_ADDR` env var. Examples pass `--addr` explicitly.
+- On Unix/macOS, a stable UDS path (e.g., `/tmp/uns-gateway.sock`) is recommended for simplicity.
+- All examples will auto-start the gateway when `--auto` is used.

package/templates/python/examples/api_handler.py

@@ -1,101 +1,28 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-import argparse
-import json
-import os
-import queue
-from typing import Dict, Iterable, Optional
-
-import grpc
-
-import sys, os
-# Ensure generated stubs (python/gen) are importable as top-level modules
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'gen')))
-import uns_gateway_pb2 as pb2
-import uns_gateway_pb2_grpc as gw
-
-
-def make_channel(addr: str) -> grpc.Channel:
-    # Supports unix:/path.sock or host:port
-    return grpc.insecure_channel(addr)
-
-
-def register_endpoints(stub: gw.UnsGatewayStub) -> None:
-    # Mirror TS api-example.ts for two GET endpoints under /api/example/summary-1 and -2
-    qp = [
-        pb2.ApiQueryParam(name="filter", type="string", required=True, description="Filter za podatke"),
-        pb2.ApiQueryParam(name="limit", type="number", required=False, description="Koliko podatkov želiš"),
-    ]
-
-    for idx, tag in [(1, "Tag1"), (2, "Tag2")]:
-        req = pb2.RegisterApiGetRequest(
-            topic="example/",
-            attribute=f"summary-{idx}",
-            api_description=f"Test API endpoint {idx}",
-            tags=[tag],
-            query_params=qp,
-        )
-        res = stub.RegisterApiGet(req)
-        if not res.ok:
-            raise RuntimeError(f"Failed to register summary-{idx}: {res.error}")
-
-
-def serve_requests(stub: gw.UnsGatewayStub, echo: bool = False) -> None:
-    q: "queue.Queue[pb2.ApiEventResponse|None]" = queue.Queue()
-
-    def req_iter():
-        while True:
-            item = q.get()
-            if item is None:
-                break
-            yield item
-
-    stream = stub.ApiEventStream(req_iter())
-    try:
-        for ev in stream:
-            # ev.path e.g. /example/summary-1; ev.query is a map<string,string>
-            path = ev.path
-            query: Dict[str, str] = dict(ev.query)
-            filt = query.get("filter", "")
-            limit = query.get("limit")
-            endpoint = "summary-1" if path.endswith("summary-1") else ("summary-2" if path.endswith("summary-2") else "unknown")
-
-            # Your business logic here. This example returns JSON reflecting the request.
-            body = {
-                "status": "OK",
-                "endpoint": endpoint,
-                "filter": filt,
-                "limit": int(limit) if (limit is not None and limit.isdigit()) else None,
-                "data": [
-                    {"id": 1, "value": 42},
-                    {"id": 2, "value": 43},
-                ],
-            }
-
-            q.put(
-                pb2.ApiEventResponse(
-                    id=ev.id,
-                    status=200,
-                    headers={"Content-Type": "application/json"},
-                    body=json.dumps(body),
-                )
-            )
-    except KeyboardInterrupt:
-        q.put(None)
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Python API handler for UNS gRPC Gateway")
-    parser.add_argument("--addr", default=os.environ.get("GATEWAY_ADDR", "unix:/tmp/template-uns-rtt-1.6.14-uns-gateway.sock"), help="Gateway address (unix:/path.sock or host:port)")
-    parser.add_argument("--echo", action="store_true", help="Echo simple OK response instead of JSON body")
-    args = parser.parse_args()
-
-    with make_channel(args.addr) as ch:
-        stub = gw.UnsGatewayStub(ch)
-        register_endpoints(stub)
-        serve_requests(stub, echo=args.echo)
-
-
-if __name__ == "__main__":
-    main()
+from gateway.client import Client
+from uns_gateway_pb2 import ApiQueryParam, ApiEventResponse
+import json
+
+client = Client()
+
+# Register API with structured query params
+qp = [
+    ApiQueryParam(name="filter", type="string", required=True, description="Filter za podatke"),
+    ApiQueryParam(name="limit", type="number", required=False, description="Koliko podatkov želiš"),
+]
+
+client.register_api(
+    topic="example/",
+    attribute="summary-1",
+    desc="Example API endpoint",
+    tags=["example", "demo"],
+    query_params=qp
+)
+
+# Handle API events
+def handle_api(ev):
+    print(f"API request: {ev.path}, query={dict(ev.query)}")
+    body = {"status": "OK", "path": ev.path, "query": dict(ev.query)}
+    return ApiEventResponse(id=ev.id, status=200, headers={"Content-Type": "application/json"},
+                            body=json.dumps(body))
+
+client.api_stream(handle_event=handle_api)

package/templates/python/examples/data_publish.py

@@ -0,0 +1,11 @@
+from gateway.client import Client
+import time
+# Publish a single data point
+client = Client()
+client.publish_data(
+    topic="sensors/temperature",
+    attribute="room1",
+    value=22.5,
+    uom="°C"
+)
+time.sleep(10)

package/templates/python/examples/data_subscribe.py

@@ -1,124 +1,8 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-import argparse
-import os
-import time
-import socket
-
-import grpc
-
-import sys, os
-# Ensure generated stubs (python/gen) are importable as top-level modules
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'gen')))
-import uns_gateway_pb2 as pb2
-import uns_gateway_pb2_grpc as gw
-
-
-def make_channel(addr: str) -> grpc.Channel:
-    return grpc.insecure_channel(addr)
-
-
-import atexit, signal, subprocess
-_AUTO_GATEWAY_PROC = None
-def _cleanup_gateway():
-    global _AUTO_GATEWAY_PROC
-    if _AUTO_GATEWAY_PROC and _AUTO_GATEWAY_PROC.poll() is None:
-        try:
-            if os.name == 'nt':
-                _AUTO_GATEWAY_PROC.terminate()
-            else:
-                os.killpg(os.getpgid(_AUTO_GATEWAY_PROC.pid), signal.SIGTERM)
-            try:
-                _AUTO_GATEWAY_PROC.wait(timeout=3)
-            except Exception:
-                if os.name == 'nt':
-                    _AUTO_GATEWAY_PROC.kill()
-                else:
-                    os.killpg(os.getpgid(_AUTO_GATEWAY_PROC.pid), signal.SIGKILL)
-        except Exception:
-            pass
-    _AUTO_GATEWAY_PROC = None
-
-def _default_addr() -> str:
-    if os.name == 'nt':
-        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-            s.bind(('127.0.0.1', 0))
-            port = s.getsockname()[1]
-        return f"127.0.0.1:{port}"
-    else:
-        return f"unix:/tmp/uns-gateway-data-subscribe-{os.getpid()}.sock"
-
-
-def ensure_gateway_running(addr: str | None, *, auto: bool, timeout_s: int = 20) -> str:
-    if not addr:
-        addr = _default_addr()
-    ch = make_channel(addr)
-    try:
-        grpc.channel_ready_future(ch).result(timeout=2)
-        ch.close(); return addr
-    except Exception:
-        ch.close()
-        if not auto:
-            return addr
-    repo_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
-    cli_path = os.path.join(repo_root, "dist", "uns-grpc", "uns-gateway-cli")
-    popen_kwargs = {}
-    creationflags = 0
-    if os.name != 'nt':
-        popen_kwargs['preexec_fn'] = os.setsid
-    else:
-        creationflags = getattr(subprocess, 'CREATE_NEW_PROCESS_GROUP', 0)
-    suffix = f"py-{os.path.basename(__file__).replace('.py','')}-{os.getpid()}"
-    proc = subprocess.Popen(["node", cli_path, "--addr", addr, "--instanceSuffix", suffix, "--instanceMode", "force"], cwd=repo_root, creationflags=creationflags, **popen_kwargs)
-    global _AUTO_GATEWAY_PROC
-    _AUTO_GATEWAY_PROC = proc
-    atexit.register(_cleanup_gateway)
-    start = time.time()
-    while time.time() - start < timeout_s:
-        ch2 = make_channel(addr)
-        try:
-            grpc.channel_ready_future(ch2).result(timeout=2)
-            ch2.close();
-            try:
-                wait_s = int(os.environ.get("UNS_GATEWAY_HANDOVER_WAIT", "11"))
-            except Exception:
-                wait_s = 11
-            if wait_s > 0:
-                time.sleep(wait_s)
-            return addr
-        except Exception:
-            ch2.close(); time.sleep(0.5)
-    raise RuntimeError("Gateway did not become ready in time")
-
-
-def subscribe(addr: str | None, topics: list[str], auto: bool) -> None:
-    addr = ensure_gateway_running(addr, auto=auto)
-    # Ensure subscriber readiness
-    try:
-        with make_channel(addr) as ch:
-            gw.UnsGatewayStub(ch).Ready(pb2.ReadyRequest(timeout_ms=15000, wait_input=True))
-    except Exception:
-        pass
-    with make_channel(addr) as ch:
-        stub = gw.UnsGatewayStub(ch)
-        stream = stub.Subscribe(pb2.SubscribeRequest(topics=topics))
-        try:
-            for msg in stream:
-                print(f"{msg.topic}: {msg.payload}")
-        except KeyboardInterrupt:
-            pass
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Subscribe to MQTT topics via gateway")
-    parser.add_argument("--addr", default=None)
-    parser.add_argument("--auto", action="store_true")
-    parser.add_argument("topics", nargs="+")
-    args = parser.parse_args()
-
-    subscribe(args.addr, args.topics, args.auto)
-
-
-if __name__ == "__main__":
-    main()
+from gateway.client import Client
+
+def handle_message(msg):
+    print(f"Callback got {msg.topic}: {msg.payload}")
+    # You could also transform, save, or push to another service
+
+client = Client()
+client.subscribe(["sensors/temperature"], callback=handle_message)

package/templates/python/examples/data_transformer.py

@@ -1,147 +1,17 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-import argparse
-import json
-import os
-import time
-from datetime import datetime, timezone
-from typing import Iterable
-import socket
-
-import grpc
-
-import sys, os
-# Ensure generated stubs (python/gen) are importable as top-level modules
-sys.path.insert(0, os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'gen')))
-import uns_gateway_pb2 as pb2
-import uns_gateway_pb2_grpc as gw
-
-
-def iso_now() -> str:
-    dt = datetime.now(timezone.utc)
-    return dt.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
-
-
-def make_channel(addr: str) -> grpc.Channel:
-    return grpc.insecure_channel(addr)
-
-
-import atexit, signal, subprocess
-_AUTO_GATEWAY_PROC = None
-def _cleanup_gateway():
-    global _AUTO_GATEWAY_PROC
-    if _AUTO_GATEWAY_PROC and _AUTO_GATEWAY_PROC.poll() is None:
-        try:
-            if os.name == 'nt':
-                _AUTO_GATEWAY_PROC.terminate()
-            else:
-                os.killpg(os.getpgid(_AUTO_GATEWAY_PROC.pid), signal.SIGTERM)
-            try:
-                _AUTO_GATEWAY_PROC.wait(timeout=3)
-            except Exception:
-                if os.name == 'nt':
-                    _AUTO_GATEWAY_PROC.kill()
-                else:
-                    os.killpg(os.getpgid(_AUTO_GATEWAY_PROC.pid), signal.SIGKILL)
-        except Exception:
-            pass
-    _AUTO_GATEWAY_PROC = None
-
-def _default_addr() -> str:
-    if os.name == 'nt':
-        with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
-            s.bind(('127.0.0.1', 0))
-            port = s.getsockname()[1]
-        return f"127.0.0.1:{port}"
-    else:
-        return f"unix:/tmp/uns-gateway-data-transformer-{os.getpid()}.sock"
-
-
-def ensure_gateway_running(addr: str | None, *, auto: bool, timeout_s: int = 20) -> str:
-    if not addr:
-        addr = _default_addr()
-    ch = make_channel(addr)
-    try:
-        grpc.channel_ready_future(ch).result(timeout=2)
-        ch.close(); return addr
-    except Exception:
-        ch.close()
-        if not auto:
-            return addr
-    repo_root = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
-    cli_path = os.path.join(repo_root, "dist", "uns-grpc", "uns-gateway-cli")
-    popen_kwargs = {}
-    creationflags = 0
-    if os.name != 'nt':
-        popen_kwargs['preexec_fn'] = os.setsid
-    else:
-        creationflags = getattr(subprocess, 'CREATE_NEW_PROCESS_GROUP', 0)
-    suffix = f"py-{os.path.basename(__file__).replace('.py','')}-{os.getpid()}"
-    proc = subprocess.Popen(["node", cli_path, "--addr", addr, "--instanceSuffix", suffix, "--instanceMode", "force"], cwd=repo_root, creationflags=creationflags, **popen_kwargs)
-    global _AUTO_GATEWAY_PROC
-    _AUTO_GATEWAY_PROC = proc
-    atexit.register(_cleanup_gateway)
-    start = time.time()
-    while time.time() - start < timeout_s:
-        ch2 = make_channel(addr)
-        try:
-            grpc.channel_ready_future(ch2).result(timeout=2)
-            ch2.close();
-            try:
-                wait_s = int(os.environ.get("UNS_GATEWAY_HANDOVER_WAIT", "11"))
-            except Exception:
-                wait_s = 11
-            if wait_s > 0:
-                time.sleep(wait_s)
-            return addr
-        except Exception:
-            ch2.close(); time.sleep(0.5)
-    raise RuntimeError("Gateway did not become ready in time")
-
-
-def transform(addr: str | None, in_topics: Iterable[str], out_topic: str, out_attribute: str, uom: str, data_group: str, auto: bool) -> None:
-    addr = ensure_gateway_running(addr, auto=auto)
-    # Ensure both subscriber and publisher are ready
-    try:
-        with make_channel(addr) as ch:
-            gw.UnsGatewayStub(ch).Ready(pb2.ReadyRequest(timeout_ms=15000, wait_input=True, wait_output=True))
-    except Exception:
-        pass
-    with make_channel(addr) as ch:
-        stub = gw.UnsGatewayStub(ch)
-        stream = stub.Subscribe(pb2.SubscribeRequest(topics=list(in_topics)))
-        for msg in stream:
-            # Expecting raw/data with payload "<number>,<timestamp>"
-            if msg.topic == "raw/data":
-                parts = msg.payload.split(",")
-                try:
-                    value = float(parts[0])
-                except Exception:
-                    continue
-                req = pb2.PublishRequest(
-                    topic=out_topic,
-                    attribute=out_attribute,
-                    data=pb2.Data(time=iso_now(), value_number=value, uom=uom, data_group=data_group),
-                )
-                res = stub.Publish(req)
-                if not res.ok:
-                    print("publish error:", res.error)
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Subscribe to raw/# and publish UNS data packets")
-    parser.add_argument("--addr", default=None, help="Gateway address (unix:/path.sock or host:port); defaults to unique per-script")
-    parser.add_argument("--auto", action="store_true", help="auto-start gateway if not running")
-    parser.add_argument("--in", dest="in_topics", nargs="+", default=["raw/#"], help="input topics to subscribe")
-    parser.add_argument("--out-topic", default="example/", help="output UNS base topic")
-    parser.add_argument("--attribute", default="data-number", help="output attribute")
-    parser.add_argument("--uom", default="mV", help="unit of measure")
-    parser.add_argument("--group", default="electricity", help="dataGroup")
-    args = parser.parse_args()
-
-    transform(args.addr, args.in_topics, args.out_topic, args.attribute, args.uom, args.group, args.auto)
-
-
-if __name__ == "__main__":
-    main()
+from gateway.client import Client, iso_now
+import json
+
+client = Client()
+    
+def transform_data(value):
+    
+    return value * 1.1
+
+def handle_message(msg):
+    payload = json.loads(msg.payload)
+    value = float(payload["value"])
+    
+    transformed_value = transform_data(value)
+    client.publish_data("sensors/temperature", "room1", value=transformed_value, uom="°C")
+
+client.subscribe(["sensors/temperature"], callback=handle_message)