wizata-dsapi 2.2.0.dev20__py3-none-any.whl → 2.2.0.dev21__py3-none-any.whl

wizata_dsapi/__init__.py

@@ -65,10 +65,13 @@ from .edge_device import EdgeDevice, EdgeDeviceStatus, EdgeDeviceType, EdgeDevic
 from .edge_module import EdgeModule, EdgeModuleType, WIZATA_MODULES
 from .edge_config import EdgeConsumer, EdgeWriter, EdgeTrigger, EdgeFile, EdgeConfig, EdgeCommand
 from .edge_package import EdgePackage, EdgePackageOperation, EdgeRelease
-from .connection import Connection, ConnectionMapping, ConnectionDirection, TransformKind, \
-    EdgeDeviceKey, EdgeDeviceKeyStatus
-from .connection_types import ConnectionType, CONNECTION_TYPES, TRANSFORM_SCHEMAS, get_connection_type, \
-    list_connection_types
+from .connection import Connection, ConnectionChannel, ConnectionSignal, ConnectionDirection, \
+    TransformKind, EdgeDeviceKey, EdgeDeviceKeyStatus
+from .connection_types import ConnectionType, ChannelType, CONNECTION_TYPES, SYSTEM_TYPES, \
+    TRANSFORM_SCHEMAS, get_connection_type, list_connection_types
+from .connection_policy import DatapointPolicy, PolicyError, canonical_node_id
+from .connection_discovery import ConnectionSeenName, ConnectionSeenReport, ConnectionBrowse, \
+    SEEN_OUTCOMES, BROWSE_REQUESTED, BROWSE_STATUSES, BROWSE_EXPIRES_SECONDS
 from .product import ProductKind, Product, ProductComponent, BUILTIN_PRODUCT_KINDS, is_valid_product_key
 from .inventory import (InventoryBalance, InventoryStorage, InventoryStorageDatapoint, inventory_mode,
                         InventoryStock, InventoryStockProduct, InventoryStockLine, InventoryStockCount, INVENTORY_OPTION, INVENTORY_MODES,

wizata_dsapi/connection.py

@@ -2,16 +2,18 @@
 Edge connection DTOs (DEV-6013).
 
 An edge connector used to be one untyped dict in the device's ``consumers.json``,
-credentials inline. It is now split in two entities, the same for every type:
+credentials inline. It is now (12.2 redesign) three entities, the same for every type:
 
 Connection — how to reach a source or a target (endpoint, credentials, certificates),
-  bound to one edge device. ``config`` is clear; ``secrets`` holds one sealed envelope
-  per secret field, readable by the owning edge only.
+  bound to one edge device and entered once. ``config`` is clear; ``secrets`` holds one
+  sealed envelope per secret field, readable by the owning edge only. ``cloud`` (hub) and
+  ``edge`` (tsdb) are the device's built-in connections.
 
-ConnectionMapping — one thing to read or write through a connection (an OPC node, an
-  MQTT topic, a Modbus register, an S7 block entry, a queue). ``address`` and
-  ``options`` are shaped by the connection type (see ``connection_types``); the other
-  fields are common to every type.
+ConnectionChannel — a reader or a writer of a connection: what it reads or writes
+  (``spec``, shaped by the type) and its datapoint policy (all / list / mapping).
+
+ConnectionSignal — one row of a policy: a reader's name and the datapoint it goes on as,
+  or a datapoint and where a writer sends it.
 
 EdgeDeviceKey — the public half of the key pair an edge generated for itself. Secrets
   are sealed for the edge's active key; rotating adds a row and retires the previous.
@@ -74,6 +76,17 @@ class Connection:
         self.secrets: dict = {}
         self.created_at: Optional[datetime] = None
         self.updated_at: Optional[datetime] = None
+        # read-only summaries a search adds: [ConnectionChannel], without their rows
+        self.readers: Optional[list] = None
+        self.writers: Optional[list] = None
+
+    @property
+    def system(self) -> bool:
+        """A device's built-in ``cloud`` / ``edge`` connection (DEV-6013): created by the
+        platform, never deleted, only its writer's policy edited."""
+        from .connection_types import get_connection_type
+        connection_type = get_connection_type(self.connection_type)
+        return bool(connection_type and connection_type.system)
 
     def secrets_set(self) -> list:
         """Names of the secret fields holding a value."""
@@ -99,6 +112,7 @@ class Connection:
             obj["connectionType"] = self.connection_type
         if self.edge_device_id is not None:
             obj["edgeDeviceId"] = self.edge_device_id
+        obj["system"] = self.system
         obj["config"] = dict(self.config or {})
         if include_secrets:
             obj["secrets"] = dict(self.secrets or {})
@@ -113,6 +127,10 @@ class Connection:
             obj["createdAt"] = _ts_out(self.created_at)
         if self.updated_at is not None:
             obj["updatedAt"] = _ts_out(self.updated_at)
+        if self.readers is not None:
+            obj["readers"] = [c.to_dict() for c in self.readers]
+        if self.writers is not None:
+            obj["writers"] = [c.to_dict() for c in self.writers]
         return obj
 
     @classmethod
@@ -144,50 +162,70 @@ class Connection:
                 f"type={self.connection_type!r}, edge={self.edge_device_id!r})")
 
 
-class ConnectionMapping:
+class ConnectionChannel:
     """
-    ConnectionMapping entity stored in PostgreSQL ``"ConnectionMapping"`` table.
-    PK ``id`` (UUID). FK ``connection_id`` → ``Connection.id``, cascade on delete.
-
-    - ``direction``: READ (source → platform) or WRITE (platform → target).
-    - ``address``: where, shaped by the type (``{"node_id": ...}``, ``{"topic": ...}``).
-    - ``hardware_id``: the datapoint. Optional where the source names it (OPC browse
-      with ``children``, a topic function fanning out to many datapoints).
-    - ``poll_interval_ms``: polling cadence for polled types; ignored when pushed.
-    - ``transform``: ``{"kind": "expression", "expression": "x / 10"}`` or
-      ``{"kind": "function", "filepath": ..., "function_name": ...}``.
-    - ``options``: type-specific tuning (``qos``, ``batch_size``, ``pack``...).
+    A reader or a writer of a connection (DEV-6013, 12.2 redesign), stored in PostgreSQL
+    ``"ConnectionChannel"``. PK ``id`` (UUID); FK ``connection_id`` → ``Connection.id``,
+    cascade on delete.
+
+    - ``direction``: READ (a reader, a consumers.json entry) or WRITE (a writer, a
+      writers.json entry).
+    - ``key``: unique per device and direction; it is the consumer or writer ``id`` on the
+      edge, so it is what the edge's logs and seen names call it.
+    - ``spec``: what it reads or writes, shaped by the connection type
+      (``connection_types``): OPC nodes and cadence, MQTT topics and function, a queue...
+    - ``policy_mode`` / ``prefix``: its datapoint policy (``connection_policy``); the rows
+      of the policy are its ``ConnectionSignal`` s.
+    - ``enabled``: a disabled reader or writer is not rendered.
+    - ``signals``: on create only, the policy rows to write with it (read back from search).
+    - ``signal_count`` / ``mapped_count``: read-only, how many rows and how many name a
+      datapoint.
     """
 
     def __init__(self):
         self.id: Optional[str] = None
         self.connection_id: Optional[str] = None
+        self.edge_device_id: Optional[str] = None
         self.direction: ConnectionDirection = ConnectionDirection.READ
-        self.address: dict = {}
-        self.hardware_id: Optional[str] = None
-        self.poll_interval_ms: Optional[int] = None
-        self.transform: Optional[dict] = None
-        self.options: dict = {}
+        self.key: Optional[str] = None
+        self.name: Optional[str] = None
+        self.enabled: bool = True
+        self.spec: dict = {}
+        self.policy_mode: Optional[str] = None
+        self.prefix: Optional[str] = None
+        self.signals: Optional[list] = None
+        self.signal_count: Optional[int] = None
+        self.mapped_count: Optional[int] = None
         self.created_at: Optional[datetime] = None
         self.updated_at: Optional[datetime] = None
 
+    @property
+    def is_reader(self) -> bool:
+        return ConnectionDirection(self.direction) == ConnectionDirection.READ
+
     def to_dict(self) -> dict:
         obj = {}
         if self.id is not None:
             obj["id"] = str(self.id)
         if self.connection_id is not None:
             obj["connectionId"] = str(self.connection_id)
-        obj["direction"] = (self.direction.value
-                            if isinstance(self.direction, ConnectionDirection)
+        if self.edge_device_id is not None:
+            obj["edgeDeviceId"] = self.edge_device_id
+        obj["direction"] = (self.direction.value if isinstance(self.direction, ConnectionDirection)
                             else self.direction)
-        obj["address"] = dict(self.address or {})
-        if self.hardware_id is not None:
-            obj["hardwareId"] = self.hardware_id
-        if self.poll_interval_ms is not None:
-            obj["pollIntervalMs"] = self.poll_interval_ms
-        if self.transform is not None:
-            obj["transform"] = dict(self.transform)
-        obj["options"] = dict(self.options or {})
+        if self.key is not None:
+            obj["key"] = self.key
+        if self.name is not None:
+            obj["name"] = self.name
+        obj["enabled"] = bool(self.enabled)
+        obj["spec"] = dict(self.spec or {})
+        obj["policy"] = {"mode": self.policy_mode, "prefix": self.prefix or ""}
+        if self.signals is not None:
+            obj["signals"] = [s.to_dict() if hasattr(s, "to_dict") else dict(s) for s in self.signals]
+        if self.signal_count is not None:
+            obj["signalCount"] = self.signal_count
+        if self.mapped_count is not None:
+            obj["mappedCount"] = self.mapped_count
         if self.created_at is not None:
             obj["createdAt"] = _ts_out(self.created_at)
         if self.updated_at is not None:
@@ -195,19 +233,32 @@ class ConnectionMapping:
         return obj
 
     @classmethod
-    def from_dict(cls, data: dict) -> "ConnectionMapping":
+    def from_dict(cls, data: dict) -> "ConnectionChannel":
         obj = cls()
         obj.id = data.get("id")
         obj.connection_id = data.get("connectionId") or data.get("connection_id")
+        obj.edge_device_id = data.get("edgeDeviceId") or data.get("edge_device_id")
         raw_direction = data.get("direction")
         if raw_direction is not None:
             obj.direction = ConnectionDirection(str(raw_direction).lower())
-        obj.address = data.get("address") or {}
-        obj.hardware_id = data.get("hardwareId") or data.get("hardware_id")
-        poll = data.get("pollIntervalMs", data.get("poll_interval_ms"))
-        obj.poll_interval_ms = int(poll) if poll is not None else None
-        obj.transform = data.get("transform")
-        obj.options = data.get("options") or {}
+        obj.key = data.get("key")
+        obj.name = data.get("name")
+        enabled = data.get("enabled")
+        obj.enabled = True if enabled is None else bool(enabled)
+        obj.spec = data.get("spec") or {}
+        policy = data.get("policy")
+        if isinstance(policy, dict):
+            obj.policy_mode = policy.get("mode")
+            obj.prefix = policy.get("prefix")
+        else:
+            obj.policy_mode = data.get("policyMode") or data.get("policy_mode")
+            obj.prefix = data.get("prefix")
+        signals = data.get("signals")
+        if signals is not None:
+            obj.signals = [s if isinstance(s, ConnectionSignal) else ConnectionSignal.from_dict(s)
+                           for s in signals]
+        obj.signal_count = data.get("signalCount")
+        obj.mapped_count = data.get("mappedCount")
         obj.created_at = _ts_in(data.get("createdAt") or data.get("created_at"))
         obj.updated_at = _ts_in(data.get("updatedAt") or data.get("updated_at"))
         return obj
@@ -216,14 +267,73 @@ class ConnectionMapping:
         return str(self.id) if self.id else None
 
     def api_key(self) -> str:
-        return self.api_id()
+        return self.key
+
+    def set_id(self, value):
+        self.id = str(value)
+
+    def __repr__(self) -> str:
+        return (f"ConnectionChannel(id={self.id!r}, key={self.key!r}, direction={self.direction!r}, "
+                f"connection={self.connection_id!r}, policy={self.policy_mode!r})")
+
+
+class ConnectionSignal:
+    """
+    One row of a reader's or writer's datapoint policy (DEV-6013, 12.2 redesign), stored in
+    PostgreSQL ``"ConnectionSignal"``. PK ``id`` (UUID); FK ``channel_id`` →
+    ``ConnectionChannel.id``, cascade on delete. Unique per channel: ``tag``, and
+    ``hardware_id`` when set.
+
+    - For a **reader**, ``tag`` is the reader's own name for what it read (an OPC node id,
+      a point name, a function's output) and ``hardware_id`` the datapoint it goes on as.
+      In a ``list`` policy a row with no ``hardware_id`` lets the tag through (prefixed).
+    - For a **writer**, ``hardware_id`` is the datapoint and ``tag`` where it goes (the OPC
+      node, the name written). In a ``list`` policy a row with no ``tag`` lets the
+      datapoint through.
+    - A row with both always renames, whatever the mode.
+    """
+
+    def __init__(self, tag: str = None, hardware_id: str = None):
+        self.id: Optional[str] = None
+        self.channel_id: Optional[str] = None
+        self.tag: Optional[str] = tag
+        self.hardware_id: Optional[str] = hardware_id
+        self.created_at: Optional[datetime] = None
+        self.updated_at: Optional[datetime] = None
+
+    def to_dict(self) -> dict:
+        obj = {}
+        if self.id is not None:
+            obj["id"] = str(self.id)
+        if self.channel_id is not None:
+            obj["channelId"] = str(self.channel_id)
+        obj["tag"] = self.tag
+        obj["hardwareId"] = self.hardware_id
+        if self.created_at is not None:
+            obj["createdAt"] = _ts_out(self.created_at)
+        if self.updated_at is not None:
+            obj["updatedAt"] = _ts_out(self.updated_at)
+        return obj
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "ConnectionSignal":
+        obj = cls()
+        obj.id = data.get("id")
+        obj.channel_id = data.get("channelId") or data.get("channel_id")
+        obj.tag = data.get("tag")
+        obj.hardware_id = data.get("hardwareId") or data.get("hardware_id")
+        obj.created_at = _ts_in(data.get("createdAt") or data.get("created_at"))
+        obj.updated_at = _ts_in(data.get("updatedAt") or data.get("updated_at"))
+        return obj
+
+    def api_id(self) -> str:
+        return str(self.id) if self.id else None
 
     def set_id(self, value):
         self.id = str(value)
 
     def __repr__(self) -> str:
-        return (f"ConnectionMapping(id={self.id!r}, connection={self.connection_id!r}, "
-                f"direction={self.direction!r}, hardware_id={self.hardware_id!r})")
+        return f"ConnectionSignal(tag={self.tag!r}, hardware_id={self.hardware_id!r})"
 
 
 class EdgeDeviceKey:

wizata_dsapi/connection_discovery.py

@@ -0,0 +1,196 @@
+"""
+What an edge tells the platform about its connections (DEV-6013, release 12.2):
+
+- **seen names**: every name a reader produced, and what its policy did with it. A new
+  reader lets nothing through (an empty list), so this is how a user sees what to allow.
+  **Names, counts and times, never values**: what a policy dropped must not leave the edge
+  through the report.
+- **browse results**: the nodes of an OPC-UA server, browsed by the edge on a platform
+  request (``browse_opc`` command) or by hand on a manual edge (``browse.py``).
+
+Stored in PostgreSQL (alembic 0029): ``"ConnectionSeenName"``, ``"ConnectionSeenReport"``,
+``"ConnectionBrowse"``.
+"""
+import uuid
+from datetime import datetime
+from typing import Optional
+
+from .connection import _ts_in, _ts_out
+
+SEEN_OUTCOMES = ("passed", "renamed", "dropped")
+
+BROWSE_REQUESTED = "requested"
+BROWSE_STATUSES = (BROWSE_REQUESTED, "ok", "partial", "failed", "refused")
+#: A request the edge never answered reads as expired after this (the command is served
+#: 15 minutes, a browse runs up to 5, and its upload is retried up to 15).
+BROWSE_EXPIRES_SECONDS = 3600
+
+
+class ConnectionSeenName:
+    """
+    One name a reader produced (PK ``channel_id`` + ``name``), as the edge last reported it.
+
+    - ``name``: the reader's native name (OPC node id or display name, a point name, what a
+      function emitted), before its policy.
+    - ``hardware_id`` / ``outcome``: what the policy the edge ran made of it (``passed``,
+      ``renamed``, ``dropped``); ``hardware_id`` is None when dropped.
+    - ``count``: messages since the edge's reader started; ``first_seen`` / ``last_seen``.
+    - ``value_type``: ``number``, ``text``, ``bool``... never the value.
+    - ``current_hardware_id`` / ``current_outcome``: read-only, what the policy stored now
+      makes of the name (the edge applies it on its next sync).
+    """
+
+    def __init__(self, channel_id: str = None, name: str = None):
+        self.channel_id: Optional[str] = channel_id
+        self.name: Optional[str] = name
+        self.hardware_id: Optional[str] = None
+        self.outcome: Optional[str] = None
+        self.count: int = 0
+        self.first_seen: Optional[datetime] = None
+        self.last_seen: Optional[datetime] = None
+        self.value_type: Optional[str] = None
+        self.reported_at: Optional[datetime] = None
+        self.current_hardware_id: Optional[str] = None
+        self.current_outcome: Optional[str] = None
+
+    def to_dict(self) -> dict:
+        obj = {"channelId": str(self.channel_id) if self.channel_id else None, "name": self.name,
+               "hardwareId": self.hardware_id, "outcome": self.outcome, "count": self.count,
+               "firstSeen": _ts_out(self.first_seen), "lastSeen": _ts_out(self.last_seen),
+               "valueType": self.value_type, "reportedAt": _ts_out(self.reported_at)}
+        if self.current_outcome is not None:
+            obj["current"] = {"hardwareId": self.current_hardware_id, "outcome": self.current_outcome}
+        return obj
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "ConnectionSeenName":
+        obj = cls(channel_id=data.get("channelId"), name=data.get("name"))
+        obj.hardware_id = data.get("hardwareId")
+        obj.outcome = data.get("outcome")
+        obj.count = int(data.get("count") or 0)
+        obj.first_seen = _ts_in(data.get("firstSeen"))
+        obj.last_seen = _ts_in(data.get("lastSeen"))
+        obj.value_type = data.get("valueType")
+        obj.reported_at = _ts_in(data.get("reportedAt"))
+        return obj
+
+    def __repr__(self) -> str:
+        return f"ConnectionSeenName(name={self.name!r}, outcome={self.outcome!r})"
+
+
+class ConnectionSeenReport:
+    """
+    The last report of one reader (PK ``channel_id``): the digest of the policy the edge
+    ran, so a user sees whether the edge applies the stored one yet; names beyond the
+    edge's cap (``overflow``) and messages it could not name (``invalid``).
+    """
+
+    def __init__(self, channel_id: str = None):
+        self.channel_id: Optional[str] = channel_id
+        self.policy_digest: Optional[str] = None
+        self.overflow: int = 0
+        self.invalid: int = 0
+        self.reported_at: Optional[datetime] = None
+
+    def to_dict(self) -> dict:
+        return {"channelId": str(self.channel_id) if self.channel_id else None,
+                "policyDigest": self.policy_digest, "overflow": self.overflow,
+                "invalid": self.invalid, "reportedAt": _ts_out(self.reported_at)}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "ConnectionSeenReport":
+        obj = cls(channel_id=data.get("channelId"))
+        obj.policy_digest = data.get("policyDigest")
+        obj.overflow = int(data.get("overflow") or 0)
+        obj.invalid = int(data.get("invalid") or 0)
+        obj.reported_at = _ts_in(data.get("reportedAt"))
+        return obj
+
+
+class ConnectionBrowse:
+    """
+    One OPC-UA browse of a connection (PK ``id``, the command id the edge answers with).
+
+    - ``source``: ``platform`` (requested here, sent as a ``browse_opc`` command) or
+      ``edge`` (run by hand on a manual edge and uploaded).
+    - ``status``: ``requested`` until the edge answers, then the edge's ``ok``,
+      ``partial`` (deadline or node cap reached), ``failed`` or ``refused``. Read as
+      ``expired`` when a request got no answer within ``BROWSE_EXPIRES_SECONDS``.
+    - ``roots``, ``depth``, ``max_nodes``, ``timeout_seconds``: what was asked (the edge
+      clamps them).
+    - ``server``: ``{url, namespaces}``; ``nodes``: what the browser returned (node id,
+      names, class, data type, access, ``readable``, ``hasChildren``, parent, depth).
+    - ``pages`` / ``complete``: the edge uploads at most 1000 nodes per page; ``complete``
+      once its last page arrived.
+    """
+
+    def __init__(self, id: str = None, connection_id: str = None, edge_device_id: str = None):
+        self.id: Optional[str] = id
+        self.connection_id: Optional[str] = connection_id
+        self.edge_device_id: Optional[str] = edge_device_id
+        self.source: str = "platform"
+        self.status: str = BROWSE_REQUESTED
+        self.roots: Optional[list] = None
+        self.depth: Optional[int] = None
+        self.max_nodes: Optional[int] = None
+        self.timeout_seconds: Optional[int] = None
+        self.requested_by: Optional[str] = None
+        self.requested_at: Optional[datetime] = None
+        self.started_at: Optional[str] = None
+        self.finished_at: Optional[str] = None
+        self.error: Optional[str] = None
+        self.truncated: bool = False
+        self.server: Optional[dict] = None
+        self.nodes: list = []
+        self.node_count: int = 0
+        self.pages: int = 0
+        self.complete: bool = False
+
+    def api_id(self) -> str:
+        return str(self.id) if self.id else None
+
+    def set_id(self, value):
+        self.id = str(value)
+
+    def get_id_type(self) -> type:
+        return uuid.UUID
+
+    def to_dict(self, include_nodes: bool = True) -> dict:
+        obj = {"id": str(self.id) if self.id else None,
+               "connectionId": str(self.connection_id) if self.connection_id else None,
+               "edgeDeviceId": self.edge_device_id, "source": self.source, "status": self.status,
+               "roots": self.roots, "depth": self.depth, "maxNodes": self.max_nodes,
+               "timeoutSeconds": self.timeout_seconds, "requestedBy": self.requested_by,
+               "requestedAt": _ts_out(self.requested_at), "startedAt": self.started_at,
+               "finishedAt": self.finished_at, "error": self.error, "truncated": bool(self.truncated),
+               "server": self.server, "nodeCount": self.node_count, "pages": self.pages,
+               "complete": bool(self.complete)}
+        if include_nodes:
+            obj["nodes"] = list(self.nodes or [])
+        return obj
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "ConnectionBrowse":
+        obj = cls(id=data.get("id"), connection_id=data.get("connectionId"),
+                  edge_device_id=data.get("edgeDeviceId"))
+        obj.source = data.get("source") or "platform"
+        obj.status = data.get("status") or BROWSE_REQUESTED
+        obj.roots = data.get("roots")
+        obj.depth = data.get("depth")
+        obj.max_nodes = data.get("maxNodes")
+        obj.timeout_seconds = data.get("timeoutSeconds")
+        obj.requested_by = data.get("requestedBy")
+        obj.requested_at = _ts_in(data.get("requestedAt"))
+        obj.started_at = data.get("startedAt")
+        obj.finished_at = data.get("finishedAt")
+        obj.error = data.get("error")
+        obj.truncated = bool(data.get("truncated"))
+        obj.server = data.get("server")
+        obj.nodes = list(data.get("nodes") or [])
+        obj.node_count = int(data.get("nodeCount") or len(obj.nodes))
+        obj.pages = int(data.get("pages") or 0)
+        obj.complete = bool(data.get("complete"))
+        return obj
+
+    def __repr__(self) -> str:
+        return f"ConnectionBrowse(id={self.id!r}, status={self.status!r}, nodes={self.node_count})"

wizata_dsapi/connection_policy.py

@@ -0,0 +1,194 @@
+"""
+DEV-6013 (12.2 redesign): the datapoint policy of an edge reader or writer, and the one
+resolution of it that both the platform and the edge run.
+
+A reader names what it reads with its own **tag**: an OPC node id or name (per its
+``name_source``), a modbus or S7 point name, or the ``HardwareId`` an MQTT or RabbitMQ
+function emits. A writer receives datapoints (``HardwareId``). The policy decides what
+goes on, and under which name:
+
+| Name ``n`` | Result |
+|---|---|
+| in ``mapping`` | ``mapping[n]``, verbatim, whatever the mode |
+| mode ``all`` | ``prefix + n`` |
+| mode ``list`` and ``n`` in ``names`` | ``prefix + n`` |
+| otherwise | dropped (``None``) |
+
+So ``mapping`` mode is strict: a name with no mapping is dropped. ``list`` matches the
+native name, so changing the prefix never empties a list. ``all`` with mapping entries is
+how a 12.1 OPC consumer named its nodes (its ``mapping``, else ``prefix + name``). For a
+writer, the mapping is ``{datapoint: target}``: the OPC node id, or the name written to
+the cloud or to the store.
+
+The platform renders a policy into every ``consumers.json`` / ``writers.json`` entry as
+``{"mode", "prefix", "names", "mapping"}``. message_client reads it back with
+``DatapointPolicy.from_dict`` and applies ``resolve``. A policy that cannot be read is a
+``PolicyError``; the edge then drops everything for that reader or writer (fail closed),
+because a policy is what keeps data from leaving.
+"""
+import hashlib
+import json
+
+MODE_ALL = "all"
+MODE_LIST = "list"
+MODE_MAPPING = "mapping"
+MODES = (MODE_ALL, MODE_LIST, MODE_MAPPING)
+
+OUTCOME_PASSED = "passed"
+OUTCOME_RENAMED = "renamed"
+OUTCOME_DROPPED = "dropped"
+
+
+class PolicyError(ValueError):
+    """The policy cannot be read: a mode it does not know, or names that are not text."""
+
+
+class DatapointPolicy:
+    """
+    An immutable datapoint policy. Build it with ``from_dict`` (the rendered form),
+    ``from_datapoints`` (a writers.json entry without one), ``deny`` or ``allow_all``.
+    """
+
+    __slots__ = ("mode", "prefix", "names", "mapping", "_digest")
+
+    def __init__(self, mode: str = MODE_LIST, prefix: str = None, names=None, mapping: dict = None):
+        if mode not in MODES:
+            raise PolicyError(f"unknown policy mode {mode!r}: use one of {', '.join(MODES)}")
+        if prefix is None:
+            prefix = ""
+        if not isinstance(prefix, str):
+            raise PolicyError("the policy prefix must be text")
+        listed = set()
+        for name in names or ():
+            if not isinstance(name, str) or not name:
+                raise PolicyError(f"a listed name must be non-empty text, not {name!r}")
+            listed.add(name)
+        renames = {}
+        if mapping is not None and not isinstance(mapping, dict):
+            raise PolicyError("the policy mapping must be an object {name: name}")
+        for source, target in (mapping or {}).items():
+            if not isinstance(source, str) or not source:
+                raise PolicyError(f"a mapped name must be non-empty text, not {source!r}")
+            if not isinstance(target, str) or not target:
+                raise PolicyError(f"{source!r} must map to a non-empty name, not {target!r}")
+            renames[source] = target
+        object.__setattr__(self, "mode", mode)
+        object.__setattr__(self, "prefix", prefix)
+        object.__setattr__(self, "names", frozenset(listed))
+        object.__setattr__(self, "mapping", renames)
+        object.__setattr__(self, "_digest", None)
+
+    def __setattr__(self, key, value):
+        raise AttributeError("a DatapointPolicy is immutable")
+
+    def __eq__(self, other):
+        return isinstance(other, DatapointPolicy) and self.to_dict() == other.to_dict()
+
+    def __hash__(self):
+        return hash(self.digest())
+
+    def __repr__(self):
+        return (f"DatapointPolicy(mode={self.mode!r}, prefix={self.prefix!r}, "
+                f"names={len(self.names)}, mapping={len(self.mapping)})")
+
+    # ------------------------------------------------------------------ builders
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "DatapointPolicy":
+        """The rendered form ``{"mode", "prefix", "names", "mapping"}``. A missing mode is
+        ``list``, so a policy that says nothing lets nothing through. Unknown keys are
+        ignored, so a newer platform can add some."""
+        if not isinstance(data, dict):
+            raise PolicyError(f"a policy must be an object, not {type(data).__name__}")
+        names = data.get("names")
+        if names is not None and not isinstance(names, (list, tuple, set, frozenset)):
+            raise PolicyError("the policy names must be a list")
+        return cls(mode=data.get("mode", MODE_LIST), prefix=data.get("prefix"),
+                   names=names, mapping=data.get("mapping"))
+
+    @classmethod
+    def from_datapoints(cls, datapoints) -> "DatapointPolicy":
+        """
+        The policy a writers.json entry without one has always meant: ``"*"`` is all, a
+        list keeps those datapoints, and a dict (an OPC writer's ``{datapoint: node id}``)
+        keeps its keys and does not rename them (the writer maps them itself). Anything
+        else, including no ``datapoints`` at all, keeps nothing.
+        """
+        if datapoints == "*":
+            return cls.allow_all()
+        if isinstance(datapoints, dict):
+            return cls(mode=MODE_LIST, names=[k for k in datapoints if isinstance(k, str) and k])
+        if isinstance(datapoints, (list, tuple, set, frozenset)):
+            return cls(mode=MODE_LIST, names=[k for k in datapoints if isinstance(k, str) and k])
+        return cls.deny()
+
+    @classmethod
+    def deny(cls) -> "DatapointPolicy":
+        """An empty list: nothing goes on. What a new reader or cloud/edge writer starts with."""
+        return cls(mode=MODE_LIST)
+
+    @classmethod
+    def allow_all(cls, prefix: str = None) -> "DatapointPolicy":
+        return cls(mode=MODE_ALL, prefix=prefix)
+
+    # ------------------------------------------------------------------ resolution
+
+    def resolve(self, name):
+        """The name ``name`` goes on as, or ``None`` when the policy drops it."""
+        if not isinstance(name, str):
+            return None
+        mapped = self.mapping.get(name)
+        if mapped is not None:
+            return mapped
+        if self.mode == MODE_ALL or (self.mode == MODE_LIST and name in self.names):
+            return self.prefix + name
+        return None
+
+    def allows(self, name) -> bool:
+        return self.resolve(name) is not None
+
+    def outcome(self, name) -> str:
+        """``passed`` (same name), ``renamed`` or ``dropped``: what the edge reports for a
+        name it saw."""
+        resolved = self.resolve(name)
+        if resolved is None:
+            return OUTCOME_DROPPED
+        return OUTCOME_PASSED if resolved == name else OUTCOME_RENAMED
+
+    @property
+    def is_identity(self) -> bool:
+        """Every name goes on unchanged: nothing to filter, nothing to copy."""
+        return self.mode == MODE_ALL and not self.prefix and not self.mapping
+
+    # ------------------------------------------------------------------ rendering
+
+    def to_dict(self) -> dict:
+        """The rendered form, sorted, so the same policy always renders the same bytes."""
+        return {
+            "mode": self.mode,
+            "prefix": self.prefix,
+            "names": sorted(self.names),
+            "mapping": {k: self.mapping[k] for k in sorted(self.mapping)},
+        }
+
+    def digest(self) -> str:
+        """``sha256:<hex>`` of the rendered form. The edge reports the digest it applies, so
+        the platform can tell an edit the edge already runs from one still on its way."""
+        if self._digest is None:
+            text = json.dumps(self.to_dict(), sort_keys=True, separators=(",", ":"))
+            object.__setattr__(self, "_digest", "sha256:" + hashlib.sha256(text.encode()).hexdigest())
+        return self._digest
+
+
+def canonical_node_id(text: str) -> str:
+    """
+    A light canonical form of an OPC node id, for the platform, which has no OPC stack:
+    surrounding spaces trimmed and the default namespace dropped (``ns=0;i=85`` and
+    ``i=85`` are one node). The edge normalises with asyncua, which agrees on these forms.
+    """
+    if not isinstance(text, str):
+        return text
+    text = text.strip()
+    if text.startswith("ns=0;"):
+        text = text[len("ns=0;"):]
+    return text

wizata_dsapi/connection_types.py

@@ -1,27 +1,37 @@
 """
-Connection type registry (DEV-6013).
+Connection type registry (DEV-6013; readers and writers since the 12.2 redesign).
 
-One definition per connector type, used for three things:
+A **connection** says how an edge reaches something: its endpoint and credentials, entered
+once. A connection holds **readers** and **writers**, and each one has:
+- a **spec**: what it reads or writes, and how (OPC nodes and cadence, MQTT topics and the
+  function parsing them, a queue, Modbus points, S7 blocks);
+- a **datapoint policy** (``connection_policy``): ``all``, ``list`` or ``mapping``, over
+  the reader's own names (its *tag*) or the writer's datapoints.
+
+One definition per type serves three things:
 - the front-end lists the types and builds each form from its JSON Schemas;
-- the platform validates every connection and mapping against them on write — the
+- the platform validates every connection, reader and writer against them on write — the
   single place a secret-bearing key is refused outside ``secrets``;
 - the platform renders the edge configuration from the entities.
 
-Schemas are plain JSON Schema (draft 2020-12) dicts, so serving them needs nothing.
-Secret fields are ``writeOnly``: accepted on write, never returned.
+Schemas are plain JSON Schema (draft 2020-12) dicts. Secret fields are ``writeOnly``:
+accepted on write, never returned. Key names are the entity's, not the legacy
+``consumers.json`` spelling; rendering maps them back.
 
-Key names are the entity's, not the legacy ``consumers.json`` spelling, which drifted
-per type (``opc_session_timeout_ms`` vs ``opc_session_timeout``, snap7 ``port`` vs
-``tcp_port``, RabbitMQ ``RQ_USER`` vs ``user``). Rendering maps them back.
+``hub`` (key ``cloud``) and ``tsdb`` (key ``edge``) are **system** types: every device gets
+them from the platform, with one writer each, and only their policy is edited. Their
+endpoint is the edge's own environment.
 """
 
 from typing import Optional
 
 from .connection import ConnectionDirection, TransformKind
+from .connection_policy import MODE_ALL, MODE_LIST, MODE_MAPPING
 
 
 _READ = ConnectionDirection.READ.value
 _WRITE = ConnectionDirection.WRITE.value
+_ALL_MODES = [MODE_ALL, MODE_LIST, MODE_MAPPING]
 
 
 def _obj(properties: dict, required: list = None) -> dict:
@@ -31,6 +41,13 @@ def _obj(properties: dict, required: list = None) -> dict:
     return schema
 
 
+def _array(items: dict, min_items: int = None) -> dict:
+    schema = {"type": "array", "items": items}
+    if min_items is not None:
+        schema["minItems"] = min_items
+    return schema
+
+
 def _secret(title: str, pem: bool = False) -> dict:
     field = {"type": "string", "title": title, "writeOnly": True}
     if pem:
@@ -44,38 +61,74 @@ def _pem(title: str) -> dict:
 
 _EMPTY = _obj({})
 
+_FUNCTION = _obj({
+    "filepath": {"type": "string", "title": "Function file", "minLength": 1},
+    "function_name": {"type": "string", "title": "Function name", "minLength": 1},
+}, required=["filepath", "function_name"])
+
+_POLL = {"type": "integer", "title": "Poll interval (ms)", "minimum": 10, "default": 1000}
+
+
+class ChannelType:
+    """
+    What a reader or writer of a type is.
+
+    :param spec: JSON Schema of its ``spec``.
+    :param policy_modes: the policy modes it accepts.
+    :param tag: what its native names are, for the form ("the OPC node id").
+    :param default_mode: the mode a new one starts with. Readers and the cloud/edge
+        writers start as an empty list: a wrong configuration must not flood the platform.
+    """
+
+    def __init__(self, spec: dict, policy_modes: list, tag: str, default_mode: str = MODE_LIST):
+        self.spec = spec
+        self.policy_modes = policy_modes
+        self.tag = tag
+        self.default_mode = default_mode
+
+    def describe(self) -> dict:
+        return {"spec": self.spec, "policyModes": list(self.policy_modes), "tag": self.tag,
+                "defaultMode": self.default_mode}
+
 
 class ConnectionType:
     """
-    One supported connector type.
+    One supported connection type.
 
     :param name: identifier stored on ``Connection.connection_type``.
-    :param directions: what mappings may do — read, write, or both.
-    :param transforms: transform kinds a read mapping may carry.
-    :param polled: mappings take a ``poll_interval_ms`` (else the source pushes).
-    :param hardware_id_required: per direction, whether a mapping must name its
-        datapoint (False where the source names it).
     :param config: schema for ``Connection.config``.
     :param secrets: schema for ``Connection.secrets`` (plaintext write form).
-    :param mapping: per direction, ``{"address": schema, "options": schema}``.
+    :param reader: what its readers are, or None when it cannot read.
+    :param writer: what its writers are, or None when it cannot write.
+    :param system: created by the platform with the device (``cloud`` / ``edge``).
+    :param device_types: the device types it exists on (None: every type).
+    :param system_key: the key of the system connection, and of its writer.
     """
 
     def __init__(self, name: str, label: str, description: str,
-                 directions: list, transforms: list, polled: bool,
-                 hardware_id_required: dict,
-                 config: dict, secrets: dict, mapping: dict,
-                 supports_browse: bool = False):
+                 config: dict, secrets: dict,
+                 reader: ChannelType = None, writer: ChannelType = None,
+                 supports_browse: bool = False, system: bool = False,
+                 device_types: list = None, system_key: str = None):
         self.name = name
         self.label = label
         self.description = description
-        self.directions = directions
-        self.transforms = transforms
-        self.polled = polled
-        self.hardware_id_required = hardware_id_required
         self.config = config
         self.secrets = secrets
-        self.mapping = mapping
+        self.reader = reader
+        self.writer = writer
         self.supports_browse = supports_browse
+        self.system = system
+        self.device_types = device_types
+        self.system_key = system_key
+
+    @property
+    def directions(self) -> list:
+        return ([_READ] if self.reader else []) + ([_WRITE] if self.writer else [])
+
+    def channel(self, direction) -> Optional[ChannelType]:
+        direction = getattr(direction, "value", direction)
+        return self.reader if direction == _READ else self.writer if direction == _WRITE else None
 
     @property
     def secret_fields(self) -> list:
@@ -87,37 +140,66 @@ class ConnectionType:
             "type": self.name,
             "label": self.label,
             "description": self.description,
-            "directions": list(self.directions),
-            "transforms": list(self.transforms),
-            "polled": self.polled,
+            "system": self.system,
+            "deviceTypes": list(self.device_types) if self.device_types else None,
+            "directions": self.directions,
             "supportsBrowse": self.supports_browse,
             "secretFields": self.secret_fields,
         }
 
     def schema(self) -> dict:
-        """Everything a form needs: the summary plus every JSON Schema."""
+        """Everything a form needs: the summary, the connection's schemas, and per direction
+        the reader's or writer's spec schema and policy modes."""
         out = self.describe()
-        out["hardwareIdRequired"] = dict(self.hardware_id_required)
         out["config"] = self.config
         out["secrets"] = self.secrets
-        out["mapping"] = {d: dict(s) for d, s in self.mapping.items()}
+        out["reader"] = self.reader.describe() if self.reader else None
+        out["writer"] = self.writer.describe() if self.writer else None
         return out
 
 
+# ── Built-in: the cloud hub and the edge's own store ───────────────────────────
+
+HUB = ConnectionType(
+    name="hub",
+    label="Cloud",
+    description="The platform's hub (Event Hub by default), reached with the edge's own "
+                "settings. Its writer chooses which datapoints leave the edge, and under which name.",
+    config=_EMPTY, secrets=_EMPTY,
+    writer=ChannelType(spec=_EMPTY, policy_modes=_ALL_MODES,
+                       tag="the datapoint; in a mapping, the name it is sent to the cloud as"),
+    system=True, system_key="cloud",
+)
+
+TSDB = ConnectionType(
+    name="tsdb",
+    label="Edge store",
+    description="The edge's own time-series database, which its pipelines read. Its writer "
+                "chooses which datapoints the edge keeps.",
+    config=_EMPTY, secrets=_EMPTY,
+    writer=ChannelType(spec=_EMPTY, policy_modes=_ALL_MODES,
+                       tag="the datapoint; in a mapping, the name it is stored as"),
+    system=True, system_key="edge", device_types=["ConnectivityAndPipelines"],
+)
+
 # ── OPC-UA ─────────────────────────────────────────────────────────────────────
 
 _OPC_SECURITY_POLICIES = ["None", "Basic128Rsa15", "Basic256", "Basic256Sha256",
                           "Aes128Sha256RsaOaep", "Aes256Sha256RsaPss"]
 
+_OPC_GROUP_TUNING = {
+    "batch_size": {"type": "integer", "minimum": 1, "title": "Nodes per read"},
+    "max_concurrent_batches": {"type": "integer", "minimum": 1},
+    "publishing_interval": {"type": "integer", "minimum": 0, "default": 1000},
+    "sampling_interval": {"type": "integer", "minimum": 0, "default": 0},
+    "queue_size": {"type": "integer", "minimum": 1, "default": 1},
+}
+
 OPC_UA = ConnectionType(
     name="opc-ua",
     label="OPC-UA",
-    description="OPC-UA server — read by polling or subscription, write to nodes.",
-    directions=[_READ, _WRITE],
-    transforms=[],
-    polled=True,
+    description="OPC-UA server — readers poll or subscribe to nodes, writers write to nodes.",
     supports_browse=True,
-    hardware_id_required={_READ: False, _WRITE: True},
     config=_obj({
         "server_url": {"type": "string", "title": "Server URL", "pattern": "^opc\\.tcp://"},
         "username": {"type": "string", "title": "Username"},
@@ -130,39 +212,36 @@ OPC_UA = ConnectionType(
         "server_certificate": _pem("Server certificate"),
         "session_timeout_ms": {"type": "integer", "title": "Session timeout (ms)",
                                "minimum": 1000, "default": 60000},
-        "reconnect_interval_ms": {"type": "integer", "title": "Reconnect interval (ms)",
-                                  "minimum": 1000, "default": 5000},
-        "mode": {"type": "string", "title": "Read mode",
-                 "enum": ["polling", "subscription"], "default": "polling"},
-        "name_source": {"type": "string", "title": "Name unmapped nodes by",
-                        "enum": ["name", "identifier"], "default": "name"},
-        "prefix": {"type": "string", "title": "Prefix for unmapped nodes"},
     }, required=["server_url"]),
     secrets=_obj({
         "password": _secret("Password"),
         "client_private_key": _secret("Client private key", pem=True),
     }),
-    mapping={
-        _READ: {
-            "address": _obj({
-                "node_id": {"type": "string", "title": "Node id", "examples": ["ns=2;s=Temperature"]},
-                "children": {"type": "boolean", "title": "Browse children", "default": False},
-            }, required=["node_id"]),
-            "options": _obj({
-                "batch_size": {"type": "integer", "minimum": 1},
-                "max_concurrent_batches": {"type": "integer", "minimum": 1},
-                "publishing_interval": {"type": "integer", "minimum": 0, "default": 1000},
-                "sampling_interval": {"type": "integer", "minimum": 0, "default": 0},
-                "queue_size": {"type": "integer", "minimum": 1, "default": 1},
-            }),
-        },
-        _WRITE: {
-            "address": _obj({
-                "node_id": {"type": "string", "title": "Node id"},
-            }, required=["node_id"]),
-            "options": _EMPTY,
-        },
-    },
+    reader=ChannelType(
+        spec=_obj({
+            "mode": {"type": "string", "title": "Read mode",
+                     "enum": ["polling", "subscription"], "default": "polling"},
+            "name_source": {"type": "string", "title": "Name nodes by",
+                            "enum": ["nodeid", "name", "identifier"], "default": "nodeid"},
+            "reconnect_interval_ms": {"type": "integer", "title": "Reconnect interval (ms)",
+                                      "minimum": 1000, "default": 5000},
+            "poll_interval_ms": _POLL,
+            "nodes_from_policy": {"type": "boolean", "title": "Read the nodes listed in the policy",
+                                  "default": False},
+            "nodes": _array(_obj({
+                "node_ids": _array({"type": "string", "minLength": 1}, min_items=1),
+                "children": {"type": "boolean", "title": "And everything under them", "default": False},
+                "children_depth": {"type": "integer", "minimum": 1},
+                "poll_interval_ms": _POLL,
+                **_OPC_GROUP_TUNING,
+            }, required=["node_ids"])),
+            **{k: v for k, v in _OPC_GROUP_TUNING.items()},
+        }),
+        policy_modes=_ALL_MODES,
+        tag="the OPC node id (name_source nodeid), or its display name / identifier",
+    ),
+    writer=ChannelType(spec=_EMPTY, policy_modes=[MODE_MAPPING],
+                       tag="the node id each datapoint is written to", default_mode=MODE_MAPPING),
 )
 
 # ── MQTT ───────────────────────────────────────────────────────────────────────
@@ -170,17 +249,12 @@ OPC_UA = ConnectionType(
 MQTT = ConnectionType(
     name="mqtt",
     label="MQTT",
-    description="MQTT broker — subscribe to topics, optional function to parse payloads.",
-    directions=[_READ],
-    transforms=[TransformKind.FUNCTION.value],
-    polled=False,
-    hardware_id_required={_READ: False},
+    description="MQTT broker — readers subscribe to topics, a function parses the payloads.",
     config=_obj({
         "host": {"type": "string", "title": "Broker host"},
         "port": {"type": "integer", "title": "Port", "default": 1883},
         "tls": {"type": "boolean", "title": "TLS", "default": False},
         "username": {"type": "string", "title": "Username"},
-        "client_id": {"type": "string", "title": "Client id"},
         "keepalive": {"type": "integer", "title": "Keepalive (s)", "minimum": 1, "default": 60},
         "payload_format": {"type": "string", "enum": ["json", "raw"], "default": "json"},
         "reconnect_min": {"type": "number", "minimum": 0, "default": 1.0},
@@ -191,16 +265,18 @@ MQTT = ConnectionType(
     secrets=_obj({
         "password": _secret("Password"),
     }),
-    mapping={
-        _READ: {
-            "address": _obj({
+    reader=ChannelType(
+        spec=_obj({
+            "topics": _array(_obj({
                 "topic": {"type": "string", "title": "Topic", "examples": ["plant/line1/#"]},
-            }, required=["topic"]),
-            "options": _obj({
                 "qos": {"type": "integer", "enum": [0, 1, 2], "default": 1},
-            }),
-        },
-    },
+            }, required=["topic"]), min_items=1),
+            "client_id": {"type": "string", "title": "Client id"},
+            "function": _FUNCTION,
+        }, required=["topics"]),
+        policy_modes=_ALL_MODES,
+        tag="the HardwareId the function (or the payload) gives each value",
+    ),
 )
 
 # ── Modbus TCP ─────────────────────────────────────────────────────────────────
@@ -208,31 +284,29 @@ MQTT = ConnectionType(
 MODBUS = ConnectionType(
     name="modbus",
     label="Modbus TCP",
-    description="Modbus TCP device — poll holding or input registers.",
-    directions=[_READ],
-    transforms=[TransformKind.EXPRESSION.value],
-    polled=True,
-    hardware_id_required={_READ: True},
+    description="Modbus TCP device — readers poll holding or input registers.",
     config=_obj({
         "ip_address": {"type": "string", "title": "IP address"},
         "port": {"type": "integer", "title": "Port", "default": 502},
         "unit_id": {"type": "integer", "title": "Unit id", "minimum": 0, "default": 1},
     }, required=["ip_address"]),
     secrets=_EMPTY,
-    mapping={
-        _READ: {
-            "address": _obj({
+    reader=ChannelType(
+        spec=_obj({
+            "poll_interval_ms": _POLL,
+            "points": _array(_obj({
+                "name": {"type": "string", "title": "Point name", "minLength": 1},
                 "address": {"type": "integer", "title": "Register address", "minimum": 0},
                 "quantity": {"type": "integer", "title": "Register count", "minimum": 1},
-                "register_type": {"type": "string", "enum": ["holding", "input"],
-                                  "default": "holding"},
-            }, required=["address", "quantity"]),
-            "options": _obj({
+                "register_type": {"type": "string", "enum": ["holding", "input"], "default": "holding"},
                 "pack": {"type": "string", "title": "struct pack format", "examples": [">HH"]},
                 "unpack": {"type": "string", "title": "struct unpack format", "examples": [">f"]},
-            }, required=["pack", "unpack"]),
-        },
-    },
+                "transform": {"type": "string", "title": "Expression on x", "examples": ["x / 100"]},
+            }, required=["name", "address", "quantity", "pack", "unpack"]), min_items=1),
+        }, required=["points"]),
+        policy_modes=_ALL_MODES,
+        tag="the point name",
+    ),
 )
 
 # ── Siemens S7 (snap7) ─────────────────────────────────────────────────────────
@@ -240,11 +314,7 @@ MODBUS = ConnectionType(
 SNAP7 = ConnectionType(
     name="snap7",
     label="Siemens S7",
-    description="Siemens S7 PLC — poll data blocks.",
-    directions=[_READ],
-    transforms=[],
-    polled=True,
-    hardware_id_required={_READ: True},
+    description="Siemens S7 PLC — readers poll data blocks.",
     config=_obj({
         "address": {"type": "string", "title": "PLC address"},
         "rack": {"type": "integer", "minimum": 0, "default": 0},
@@ -252,19 +322,24 @@ SNAP7 = ConnectionType(
         "tcp_port": {"type": "integer", "title": "Port", "default": 102},
     }, required=["address"]),
     secrets=_EMPTY,
-    mapping={
-        _READ: {
-            "address": _obj({
+    reader=ChannelType(
+        spec=_obj({
+            "poll_interval_ms": _POLL,
+            "blocks": _array(_obj({
                 "db_number": {"type": "integer", "minimum": 0},
                 "start_offset": {"type": "integer", "minimum": 0},
                 "size": {"type": "integer", "minimum": 1},
-                "index": {"type": "integer", "title": "Byte index in the block", "minimum": 0},
-                "type": {"type": "string", "enum": ["dword", "word", "bool", "real", "int"]},
-                "bit_position": {"type": "integer", "minimum": 0, "maximum": 7},
-            }, required=["db_number", "start_offset", "size", "index", "type"]),
-            "options": _EMPTY,
-        },
-    },
+                "points": _array(_obj({
+                    "name": {"type": "string", "title": "Point name", "minLength": 1},
+                    "type": {"type": "string", "enum": ["dword", "word", "bool", "real", "int"]},
+                    "index": {"type": "integer", "title": "Byte index in the block", "minimum": 0},
+                    "bit_position": {"type": "integer", "minimum": 0, "maximum": 7},
+                }, required=["name", "type", "index"]), min_items=1),
+            }, required=["db_number", "start_offset", "size", "points"]), min_items=1),
+        }, required=["blocks"]),
+        policy_modes=_ALL_MODES,
+        tag="the point name",
+    ),
 )
 
 # ── RabbitMQ (external queue) ──────────────────────────────────────────────────
@@ -272,11 +347,7 @@ SNAP7 = ConnectionType(
 RABBITMQ = ConnectionType(
     name="rabbitmq",
     label="RabbitMQ",
-    description="External RabbitMQ broker — consume a queue, function to parse payloads.",
-    directions=[_READ],
-    transforms=[TransformKind.FUNCTION.value],
-    polled=False,
-    hardware_id_required={_READ: False},
+    description="External RabbitMQ broker — each reader consumes a queue, a function parses it.",
     config=_obj({
         "host": {"type": "string", "title": "Host"},
         "port": {"type": "integer", "title": "Port", "default": 5671},
@@ -287,23 +358,26 @@ RABBITMQ = ConnectionType(
     secrets=_obj({
         "password": _secret("Password"),
     }),
-    mapping={
-        _READ: {
-            "address": _obj({
-                "queue": {"type": "string", "title": "Queue", "default": "messages"},
-            }, required=["queue"]),
-            "options": _obj({
-                "prefetch": {"type": "integer", "minimum": 1},
-                "error_queue": {"type": "string"},
-            }),
-        },
-    },
+    reader=ChannelType(
+        spec=_obj({
+            "queue": {"type": "string", "title": "Queue", "default": "messages"},
+            "prefetch": {"type": "integer", "minimum": 1},
+            "error_queue": {"type": "string"},
+            "function": _FUNCTION,
+        }, required=["queue"]),
+        policy_modes=_ALL_MODES,
+        tag="the HardwareId the function gives each value",
+    ),
 )
 
 
-CONNECTION_TYPES = {t.name: t for t in (OPC_UA, MQTT, MODBUS, SNAP7, RABBITMQ)}
+CONNECTION_TYPES = {t.name: t for t in (HUB, TSDB, OPC_UA, MQTT, MODBUS, SNAP7, RABBITMQ)}
+
+#: The types a device gets from the platform, by the key of their connection.
+SYSTEM_TYPES = {t.system_key: t for t in CONNECTION_TYPES.values() if t.system}
 
-# Transform payloads, whatever the type (the type decides which kinds it accepts).
+# Kept for the forms that still name the two transform kinds; a Modbus point carries its
+# expression, an MQTT or RabbitMQ reader its function.
 TRANSFORM_SCHEMAS = {
     TransformKind.EXPRESSION.value: _obj({
         "kind": {"const": TransformKind.EXPRESSION.value},

wizata_dsapi/version.py

@@ -1 +1 @@
-__version__ = "2.2.0.dev20"
+__version__ = "2.2.0.dev21"

wizata_dsapi/wizata_dsapi_client.py

@@ -3104,6 +3104,37 @@ class WizataDSAPIClient(ApiInterface, ApiDtoInterface):
                                       body={"packages": list(packages or [])}, timeout=timeout)
         return response.json()
 
+    def send_edge_browse_result(self, edge_device_id: str, page: dict, timeout=(5, 60)) -> dict:
+        """
+        One page of an OPC browse the edge ran (DEV-6013): on a platform request
+        (``requestId``), or run by hand on a manual edge (``requestId`` null). Pages hold
+        at most 1000 nodes; the last one says ``final: true``.
+
+        :param page: ``{requestId, connectionId, page, final, status, error, truncated,
+            startedAt, finishedAt, server, roots, depth, nodes: [...]}``.
+        :param timeout: (connect, read) seconds.
+        :return: the platform's answer.
+        """
+        response = self._edge_request("POST", self._edge_route(edge_device_id, "browse"),
+                                      body=page, expected=(200, 201), timeout=timeout)
+        return response.json()
+
+    def send_edge_seen_names(self, edge_device_id: str, report: dict, timeout=(5, 30)) -> dict:
+        """
+        The names each reader of the edge produced, and what its policy did with them
+        (DEV-6013): names, counts and times, never values. A policy keeps data from
+        leaving, and the report must not carry what it dropped.
+
+        :param report: ``{writtenAt, full, readers: [{readerId, connectionId, type,
+            policyMode, policyDigest, overflow, invalid, names: [{name, hardwareId,
+            outcome, count, firstSeen, lastSeen, valueType}]}]}``.
+        :param timeout: (connect, read) seconds.
+        :return: the platform's answer.
+        """
+        response = self._edge_request("POST", self._edge_route(edge_device_id, "seen"),
+                                      body=report, expected=(200, 201), timeout=timeout)
+        return response.json()
+
 
 def api() -> WizataDSAPIClient:
     """

{wizata_dsapi-2.2.0.dev20.dist-info → wizata_dsapi-2.2.0.dev21.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wizata_dsapi
-Version: 2.2.0.dev20
+Version: 2.2.0.dev21
 Summary: Wizata Data Science Toolkit
 Author: Wizata S.A.
 Author-email: info@wizata.com

{wizata_dsapi-2.2.0.dev20.dist-info → wizata_dsapi-2.2.0.dev21.dist-info}/RECORD

@@ -1,11 +1,13 @@
-wizata_dsapi/__init__.py,sha256=ASXZxRPiRNt0-QspmCMZKBpqLdVaSKgggmVlbPH2NoU,4219
+wizata_dsapi/__init__.py,sha256=I6R8Q2VGjMTZvV5ZiM1hkpQi1DyP4I04e95ljSjZ9SE,4516
 wizata_dsapi/api_config.py,sha256=zOgvpkB3FE2ny_2vAui7B1hcAMFCLvfb2ep3m-b7dIw,8270
 wizata_dsapi/api_dto.py,sha256=F9HjNa_vqYhdEMZwwk8E3SmCxuMBcxFnMp1eE9dxLvg,2910
 wizata_dsapi/api_interface.py,sha256=mCq0-rlwWL4GKB2QnxSPuyTecYOXXknmPOlQe_SEf2I,14670
 wizata_dsapi/bucket.py,sha256=Zz9olv-pymikAutGitSuGWrAPiawOTW86JDDHG4ugTc,1150
 wizata_dsapi/business_label.py,sha256=u0TVfUNfoR9qSv8lzpf6rNjlg3G9xTiz6itefcKfeak,4151
-wizata_dsapi/connection.py,sha256=C1VcA1oFqRLtiJN8jHkwlJobH5Lh2OCohEN_2mLP41c,12200
-wizata_dsapi/connection_types.py,sha256=nEQRp5-hGKGmOfZfKqocM-THuw3nQYJIqrX2BMK-mUs,13986
+wizata_dsapi/connection.py,sha256=sngpF2rfcR1N5IT9wqccv07IwIDUM85k_6vnNjzThGE,17027
+wizata_dsapi/connection_discovery.py,sha256=1CHEFQNE_IGtbbnyAfToZuXmP77PIjJJq_ASRW2mcpg,9055
+wizata_dsapi/connection_policy.py,sha256=oU1yukVMdCZGy4tvj0Ei3u00xBDJ_0ZEMQ7WVsocroE,8434
+wizata_dsapi/connection_types.py,sha256=ffpauxzzRBg0k4j5Amy-I3zeBZ-Q6EnmyZ-6Jo-FQlI,18358
 wizata_dsapi/context.py,sha256=1t0wCzRnBEzch7fx7jG4Oj3Ezrjv9getJtCrqEpn-pc,13188
 wizata_dsapi/dashboard.py,sha256=NY4m-1EpMRoKDHem0EwsRF0QQzal3bvrm9gQv3BNizk,3841
 wizata_dsapi/dataframe_toolkit.py,sha256=7D8JrhsFSGXeO3mRAd2e2cLmdjbXRjk04IuaMG8F974,9078
@@ -48,10 +50,10 @@ wizata_dsapi/trigger.py,sha256=waOX2AhrLvFzNFRQ535j6iemgg_QJP2QsWGL2ipljFg,8848
 wizata_dsapi/twin.py,sha256=8AnrxSaL7dMrILXJ3-GGmmUz078j3qqwzDTe6i86xqA,12672
 wizata_dsapi/twinregistration.py,sha256=iXt55AVGAQNl0jmxa3ZVynPqlSsIunFf4sLfp-MWTw0,13244
 wizata_dsapi/user.py,sha256=-hchKAMZULu9P00RUHDqu_5AT4NI5BYOJd8XCBrt3eQ,1950
-wizata_dsapi/version.py,sha256=Ej92cnhM5g3Pwri9IPc8X2C0NhC-UawJM0AUXdnAxLM,28
+wizata_dsapi/version.py,sha256=YrgaspNwsrXytFOHsMVGn4pLI4bQSL62FdMaB7nvDBs,28
 wizata_dsapi/wizard_function.py,sha256=RbM7W7Gf-6Rhp_1dU9DBYkHaciknGAGvuAndhAS_vyo,942
 wizata_dsapi/wizard_request.py,sha256=v6BaqKLKvTWmUSo0_gda9FabAQz5x_-GOH1Av50GzFo,3762
-wizata_dsapi/wizata_dsapi_client.py,sha256=uoeUsaob9CsR1VojBuyM5Yq0wqUVDkCKorrb8kE4uTg,130806
+wizata_dsapi/wizata_dsapi_client.py,sha256=0dEdcHB0sUcIRktvvYe36DI8kEtqrvFnmikrIR4gWes,132510
 wizata_dsapi/words.py,sha256=tV8CqzCqODZCV7PgBxBF5exBxeF_ya9t5DiUy-cg6Sg,1535
 wizata_dsapi/models/__init__.py,sha256=O3Tusyhl8hFb-5QaEBY7DJISRB8Gf_Xbxxr-aFDR1_U,380
 wizata_dsapi/models/common.py,sha256=5BC3Dc6kMvqPGxHgoCuGVOynu_F1MWh7EJSzXIICSSg,27196
@@ -60,8 +62,8 @@ wizata_dsapi/plots/common.py,sha256=7F4WMBaddubnCpdSafgaI9U9Sz0Sngg0VREP_vnIMno,
 wizata_dsapi/plots/theme.py,sha256=D4sSgEwabXVxF3z1GV8DivXJbbY61KgxXAWfjUbNDAc,3594
 wizata_dsapi/scripts/__init__.py,sha256=9fRdTMuuXcqMkIsUPf5dwFsTWwBzKteQdAMVkyy2acQ,212
 wizata_dsapi/scripts/common.py,sha256=8LJK23Za0Yy4Dda1feKpKELav8806MH-hxFJYrklVOY,14758
-wizata_dsapi-2.2.0.dev20.dist-info/licenses/LICENSE.txt,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-wizata_dsapi-2.2.0.dev20.dist-info/METADATA,sha256=xKiGgGaanscGQRqW-QYSjLGfGcqI-jq52HHKBJcFTpw,14038
-wizata_dsapi-2.2.0.dev20.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-wizata_dsapi-2.2.0.dev20.dist-info/top_level.txt,sha256=-OeTJbEnh5DuWyTOHtvw0Dw3LRg3G27TNS6W4ZtfwPs,13
-wizata_dsapi-2.2.0.dev20.dist-info/RECORD,,
+wizata_dsapi-2.2.0.dev21.dist-info/licenses/LICENSE.txt,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+wizata_dsapi-2.2.0.dev21.dist-info/METADATA,sha256=rv_Ua4W6BNoghD_NujFiFQ39BEu0CnIfN6AA6b1vWEI,14038
+wizata_dsapi-2.2.0.dev21.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+wizata_dsapi-2.2.0.dev21.dist-info/top_level.txt,sha256=-OeTJbEnh5DuWyTOHtvw0Dw3LRg3G27TNS6W4ZtfwPs,13
+wizata_dsapi-2.2.0.dev21.dist-info/RECORD,,