@uns-kit/cli 0.0.32 → 0.0.35

package/templates/python/examples/table_transformer.py

@@ -1,163 +1,16 @@
-#!/usr/bin/env python3
-from __future__ import annotations
-
-import argparse
-import json
-import os
+from gateway.client import Client, iso_now
 import time
-from datetime import datetime, timezone
-from typing import Iterable, Dict
-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_from_epoch_ms(ms: int) -> str:
-    dt = datetime.fromtimestamp(ms / 1000.0, tz=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-table-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_topic: str, out_topic: str, out_attribute: 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=[in_topic]))
-        for msg in stream:
-            if msg.topic != in_topic:
-                continue
-            try:
-                obj = json.loads(msg.payload)
-            except Exception:
-                continue
-            ts = obj.pop("Timestamp", None)
-            if ts is None:
-                continue
-            try:
-                ts_ms = int(ts)
-            except Exception:
-                continue
-            time_iso = iso_from_epoch_ms(ts_ms if ts_ms > 10_000_000_000 else ts_ms * 1000)
-
-            values: Dict[str, pb2.TableValue] = {}
-            tv_list = []
-            for k, v in obj.items():
-                if isinstance(v, (int, float)):
-                    tv_list.append(pb2.TableValue(key=k, value_number=float(v)))
-                elif v is None:
-                    tv_list.append(pb2.TableValue(key=k))
-                else:
-                    tv_list.append(pb2.TableValue(key=k, value_string=str(v)))
-
-            req = pb2.PublishRequest(
-                topic=out_topic,
-                attribute=out_attribute,
-                table=pb2.Table(time=time_iso, values=tv_list, data_group="demo_table"),
-            )
-            res = stub.Publish(req)
-            if not res.ok:
-                print("publish error:", res.error)
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Subscribe to an upstream topic and publish UNS table 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-topic", default="integration/raw-table")
-    parser.add_argument("--out-topic", default="example/factory-a/line-1/")
-    parser.add_argument("--attribute", default="table-sample")
-    args = parser.parse_args()
-
-    transform(args.addr, args.in_topic, args.out_topic, args.attribute, args.auto)
-
 
-if __name__ == "__main__":
-    main()
+client = Client()
+client.publish_table(
+    topic="sensors/summary/",
+    attribute="room1",
+    obj={
+        "temperature": 22.5,
+        "humidity": 55.2,
+        "status": "ok",
+        "error": None
+    },
+    data_group="room_stats"
+)
+time.sleep(10)

package/templates/python/gateway/cli.py

@@ -0,0 +1,75 @@
+import argparse
+from .manager import GatewayManager
+from . import client
+import uns_gateway_pb2_grpc as gw
+from .client import make_channel
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--addr", default=None)
+    sub = parser.add_subparsers(dest="cmd", required=True)
+
+    # --- Publish ---
+    p_pub = sub.add_parser("pub")
+    p_pub.add_argument("topic")
+    p_pub.add_argument("attribute")
+    p_pub.add_argument("time_iso")
+    p_pub.add_argument("value", type=float)
+    p_pub.add_argument("--uom", default="")
+    p_pub.add_argument("--group", default="")
+    p_pub.add_argument("--cumulative", action="store_true")
+    p_pub.add_argument("--auto", action="store_true")
+
+    # --- Subscribe ---
+    p_sub = sub.add_parser("sub")
+    p_sub.add_argument("topics", nargs="+")
+    p_sub.add_argument("--auto", action="store_true")
+
+    # --- Register API ---
+    p_reg = sub.add_parser("regapi")
+    p_reg.add_argument("topic")
+    p_reg.add_argument("attribute")
+    p_reg.add_argument("--desc", default="")
+    p_reg.add_argument("--tag", action="append", default=[])
+    p_reg.add_argument("--param", action="append", default=[])
+    p_reg.add_argument("--auto", action="store_true")
+
+    # --- Unregister API ---
+    p_unreg = sub.add_parser("unregapi")
+    p_unreg.add_argument("topic")
+    p_unreg.add_argument("attribute")
+    p_unreg.add_argument("--auto", action="store_true")
+
+    # --- API Stream ---
+    p_stream = sub.add_parser("apistream")
+    p_stream.add_argument("--echo", action="store_true")
+    p_stream.add_argument("--auto", action="store_true")
+
+    args = parser.parse_args()
+    mgr = GatewayManager(args.addr, auto=getattr(args, "auto", False))
+    addr = mgr.ensure_running()
+
+    if args.cmd == "pub":
+        client.publish_data(
+            addr, topic=args.topic, attribute=args.attribute,
+            time_iso=args.time_iso, value_number=args.value,
+            uom=args.uom, data_group=args.group,
+            value_is_cumulative=args.cumulative
+        )
+    elif args.cmd == "sub":
+        client.subscribe(addr, args.topics)
+    elif args.cmd == "regapi":
+        with make_channel(addr) as ch:
+            stub = gw.UnsGatewayStub(ch)
+            client.register_api(stub, args.topic, args.attribute, args.desc, args.tag, args.param)
+            print("registered")
+    elif args.cmd == "unregapi":
+        with make_channel(addr) as ch:
+            stub = gw.UnsGatewayStub(ch)
+            client.unregister_api(stub, args.topic, args.attribute)
+            print("unregistered")
+    elif args.cmd == "apistream":
+        client.api_stream(addr, echo=args.echo)
+
+if __name__ == "__main__":
+    main()

package/templates/python/gateway/client.py

@@ -0,0 +1,155 @@
+from typing import Iterable, Dict, Callable, List
+import queue
+import json
+import threading
+from datetime import datetime, timezone
+import grpc
+from .manager import GatewayManager
+
+from gen import uns_gateway_pb2 as pb2
+from gen import uns_gateway_pb2_grpc as gw
+
+
+def iso_now() -> str:
+    """Return current UTC time in ISO format with milliseconds."""
+    dt = datetime.now(timezone.utc)
+    return dt.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3] + "Z"
+
+
+def make_channel(addr: str) -> grpc.Channel:
+    """Create a gRPC insecure channel."""
+    return grpc.insecure_channel(addr)
+
+
+class Client:
+    """
+    High-level client for UNS gateway.
+    Automatically manages gateway lifecycle and keeps a persistent stub.
+    """
+
+    def __init__(self, addr: str | None = None, auto: bool = True, timeout_s: int = 20):
+        self.manager = GatewayManager(addr=addr, auto=auto, timeout_s=timeout_s)
+        self.addr = self.manager.ensure_running()
+        self._ch = make_channel(self.addr)
+        self._stub = gw.UnsGatewayStub(self._ch)
+
+    # --- Publish ---
+    def publish_data(self, topic: str, attribute: str, value: float,
+                     time_iso: str | None = None, uom: str = "",
+                     data_group: str = "", cumulative: bool = False):
+        time_iso = time_iso or iso_now()
+        req = pb2.PublishRequest(
+            topic=topic,
+            attribute=attribute,
+            data=pb2.Data(
+                time=time_iso,
+                value_number=value,
+                uom=uom,
+                data_group=data_group
+            ),
+            value_is_cumulative=cumulative
+        )
+        res = self._stub.Publish(req)
+        if not res.ok:
+            raise RuntimeError(res.error)
+        
+    def publish_table(self, topic: str, attribute: str, obj: Dict[str, any],
+                      time_iso: str | None = None, data_group: str = "default"):
+        """
+        Publish a dictionary as a Table.
+        Numeric values -> value_number
+        None -> empty
+        Other -> value_string
+        """
+        time_iso = time_iso or iso_now()
+        tv_list = []
+        for k, v in obj.items():
+            if isinstance(v, (int, float)):
+                tv_list.append(pb2.TableValue(key=k, value_number=float(v)))
+            elif v is None:
+                tv_list.append(pb2.TableValue(key=k))
+            else:
+                tv_list.append(pb2.TableValue(key=k, value_string=str(v)))
+
+        req = pb2.PublishRequest(
+            topic=topic,
+            attribute=attribute,
+            table=pb2.Table(time=time_iso, values=tv_list, data_group=data_group)
+        )
+        res = self._stub.Publish(req)
+        if not res.ok:
+            raise RuntimeError(res.error)
+    # --- Subscribe ---
+    def subscribe(self, topics: Iterable[str], callback: Callable[[any], None] | None = None):
+        """
+        Subscribe to topics and call the provided callback on each message.
+        """
+        stub = self._stub
+        try:
+            stub.Ready(pb2.ReadyRequest(timeout_ms=15000, wait_input=True))
+        except Exception:
+            pass
+
+        stream = stub.Subscribe(pb2.SubscribeRequest(topics=list(topics)))
+        try:
+            for msg in stream:
+                if callback:
+                    callback(msg)
+                else:
+                    print(f"{msg.topic}: {msg.payload}")
+        except KeyboardInterrupt:
+            pass
+
+    # --- API Register ---
+    def register_api(self, topic: str, attribute: str, desc: str = "",
+                     tags: list[str] | None = None,
+                     query_params: List[pb2.ApiQueryParam] | None = None):
+        tags = tags or []
+        query_params = query_params or []
+
+        res = self._stub.RegisterApiGet(
+            pb2.RegisterApiGetRequest(
+                topic=topic,
+                attribute=attribute,
+                api_description=desc,
+                tags=tags,
+                query_params=query_params
+            )
+        )
+        if not res.ok:
+            raise RuntimeError(f"Register failed: {res.error}")
+
+    def unregister_api(self, topic: str, attribute: str):
+        res = self._stub.UnregisterApiGet(
+            pb2.UnregisterApiGetRequest(topic=topic, attribute=attribute)
+        )
+        if not res.ok:
+            raise RuntimeError(f"Unregister failed: {res.error}")
+
+    # --- API Stream ---
+    def api_stream(self, echo: bool = False, handle_event: Callable | None = 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 = self._stub.ApiEventStream(req_iter())
+        try:
+            for ev in stream:
+                if handle_event:
+                    resp = handle_event(ev)
+                    if resp:
+                        q.put(resp)
+                    continue
+                if echo:
+                    q.put(pb2.ApiEventResponse(id=ev.id, status=200, body="OK"))
+                    continue
+                body = {"status": "OK", "endpoint": ev.path, "query": dict(ev.query)}
+                q.put(pb2.ApiEventResponse(id=ev.id, status=200, headers={"Content-Type": "application/json"},
+                                           body=json.dumps(body)))
+        except KeyboardInterrupt:
+            q.put(None)

package/templates/python/gateway/manager.py

@@ -0,0 +1,97 @@
+import os
+import sys
+import time
+import socket
+import subprocess
+import atexit
+import signal
+import grpc
+
+class GatewayManager:
+    """
+    Ensures a Node.js UNS gateway is running.
+    Can start it automatically if needed.
+    """
+    def __init__(self, addr: str | None = None, auto: bool = True, timeout_s: int = 20):
+        self.addr = addr
+        self.auto = auto
+        self.timeout_s = timeout_s
+        self._proc: subprocess.Popen | None = None
+
+    def _default_addr(self) -> 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:
+            script = os.path.basename(sys.argv[0]).replace(".py", "")
+            return f"unix:/tmp/uns-gateway-{script}-{os.getpid()}.sock"
+
+    def _cleanup(self):
+        if not self._proc:
+            return
+        try:
+            if self._proc.poll() is None:
+                if os.name == "nt":
+                    self._proc.terminate()
+                else:
+                    os.killpg(os.getpgid(self._proc.pid), signal.SIGTERM)
+                try:
+                    self._proc.wait(timeout=3)
+                except Exception:
+                    if os.name == "nt":
+                        self._proc.kill()
+                    else:
+                        os.killpg(os.getpgid(self._proc.pid), signal.SIGKILL)
+        except Exception:
+            pass
+        self._proc = None
+
+    def ensure_running(self) -> str:
+        addr = self.addr or self._default_addr()
+        ch = grpc.insecure_channel(addr)
+        try:
+            grpc.channel_ready_future(ch).result(timeout=2)
+            ch.close()
+            return addr
+        except Exception:
+            ch.close()
+            if not self.auto:
+                return addr
+
+        # Spawn Node.js gateway
+        repo_root = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
+        cli_path = os.path.join(repo_root, "node_modules", "@uns-kit", "core", "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(sys.argv[0]).replace('.py','')}-{os.getpid()}"
+        self._proc = subprocess.Popen(
+            ["node", cli_path, "--addr", addr, "--instanceSuffix", suffix, "--instanceMode", "force"],
+            cwd=repo_root,
+            creationflags=creationflags,
+            **popen_kwargs,
+        )
+        atexit.register(self._cleanup)
+
+        # Wait for channel ready
+        start = time.time()
+        while time.time() - start < self.timeout_s:
+            ch2 = grpc.insecure_channel(addr)
+            try:
+                grpc.channel_ready_future(ch2).result(timeout=2)
+                ch2.close()
+                wait_s = int(os.environ.get("UNS_GATEWAY_HANDOVER_WAIT", "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")

package/templates/python/main.py

@@ -0,0 +1 @@
+"Main Logic"

package/templates/python/pyproject.toml

@@ -0,0 +1,5 @@
+[project]
+name = "uns-example"
+version = "0.1.0"
+description = "A new gRPC project"
+dependencies = ["grpcio", "grpcio-tools", "httpx>=0.27.2"]

package/templates/python/scripts/setup.sh

@@ -5,7 +5,7 @@ set -euo pipefail
 # Navigate to the project root
 cd "$(dirname "$0")/.."
 
-# Detect OS and set python & venv paths
+# Detect OS and set paths
 PLATFORM="$(uname)"
 if [[ "$PLATFORM" == "Linux" || "$PLATFORM" == "Darwin" ]]; then
   PYTHON_EXEC="python3"
@@ -20,16 +20,23 @@ else
   exit 1
 fi
 
-# Check if Python is available
-if ! command -v "$PYTHON_EXEC" &> /dev/null; then
-  echo "[setup] Error: $PYTHON_EXEC not found in PATH."
-  exit 1
+if [[ "$PLATFORM" =~ MINGW.*|MSYS.*|CYGWIN.*|Windows_NT ]]; then
+    UV_CMD="$HOME/.local/bin/uv.exe"
+else
+    UV_CMD="$HOME/.cargo/bin/uv"
+fi
+
+if [ ! -f "$UV_CMD" ]; then
+    echo "[setup] uv not found. Installing it..."
+    curl -LsSf https://astral.sh/uv/install.sh | sh
+else
+    echo "[setup] uv already installed at $UV_CMD"
 fi
 
-# Create virtual environment if it doesn't exist
+# Create virtual environment using uv
 if [ ! -d "$VENV_DIR" ]; then
-  echo "[setup] Creating virtual environment in $VENV_DIR..."
-  "$PYTHON_EXEC" -m venv "$VENV_DIR"
+  echo "[setup] Creating virtual environment in $VENV_DIR using uv..."
+  "$UV_CMD" venv "$VENV_DIR"
 fi
 
 # Create gen directory if it doesn't exist
@@ -46,14 +53,19 @@ fi
 
 # Activate the virtual environment
 echo "[setup] Activating virtual environment..."
-source "$VENV_ACTIVATE"
+if [[ "$PLATFORM" =~ MINGW.*|MSYS.*|CYGWIN.* ]]; then
+    # Windows Git Bash / MSYS
+    . "$VENV_ACTIVATE"
+else
+    # Linux / macOS
+    source "$VENV_ACTIVATE"
+fi
 
-# Install Python dependencies using pip from venv
-echo "[setup] Installing requirements using pip from venv..."
-"$PYTHON_EXEC" -m pip install --upgrade pip
-"$PYTHON_EXEC" -m pip install -r requirements.txt
+# Install dependencies using uv (much faster than pip)
+echo "[setup] Installing requirements using uv..."
+"$UV_CMD" sync --active
 
-# Generate Python gRPC code from the proto file
+# Generate Python gRPC code from proto
 echo "[setup] Generating gRPC Python code..."
 "$PYTHON_EXEC" -m grpc_tools.protoc \
   -I=proto \
@@ -61,4 +73,15 @@ echo "[setup] Generating gRPC Python code..."
   --grpc_python_out=gen \
   proto/uns-gateway.proto
 
+  # Patch the generated _pb2_grpc.py to use relative imports
+GRPC_FILE="gen/uns_gateway_pb2_grpc.py"
+if [[ -f "$GRPC_FILE" ]]; then
+    echo "[setup] Patching $GRPC_FILE to use relative imports..."
+    if [[ "$PLATFORM" == "Linux" || "$PLATFORM" == "Darwin" ]]; then
+        sed -i 's/^import \(.*_pb2\) as/from . import \1 as/' "$GRPC_FILE"
+    elif [[ "$PLATFORM" =~ MINGW.*|MSYS.*|CYGWIN.* ]]; then
+        sed -i'' 's/^import \(.*_pb2\) as/from . import \1 as/' "$GRPC_FILE"
+    fi
+fi
+
 echo "[setup] Setup complete!"

package/templates/temporal/src/examples/temporal-example.ts

@@ -3,6 +3,7 @@
  */
 import { UnsProxyProcess, ConfigFile, logger } from "@uns-kit/core";
 import { ITemporalTopic } from "@uns-kit/temporal";
+import "@uns-kit/temporal";
 import { type UnsProxyProcessWithTemporal } from "@uns-kit/temporal";
 import { UnsAttributeType } from "@uns-kit/core/graphql/schema.js";