wizata-dsapi 2.2.0.dev1__tar.gz → 2.2.0.dev3__tar.gz

{wizata_dsapi-2.2.0.dev1 → wizata_dsapi-2.2.0.dev3}/PKG-INFO

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

{wizata_dsapi-2.2.0.dev1 → wizata_dsapi-2.2.0.dev3}/wizata_dsapi/__init__.py

@@ -61,6 +61,11 @@ from .notification import NotificationScope, DeviceToken, AlertRule, AlertActive
 from .edge_device import EdgeDevice, EdgeDeviceStatus, EdgeDeviceType
 from .edge_module import EdgeModule, EdgeModuleType, WIZATA_MODULES
 from .edge_config import EdgeConsumer, EdgeWriter, EdgeTrigger
+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 .product import ProductKind, Product, ProductComponent, BUILTIN_PRODUCT_KINDS, is_valid_product_key
 from .dashboard import Dashboard, DashboardType
 from .mobile_asset import MobileAssetTile, MobileAssetTileType, MobileAssetConfig
 from .graylog_log import GraylogLog

wizata_dsapi-2.2.0.dev3/wizata_dsapi/connection.py

@@ -0,0 +1,299 @@
+"""
+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:
+
+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.
+
+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.
+
+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.
+"""
+
+from datetime import datetime, timezone
+from enum import Enum
+from typing import Optional
+
+
+class ConnectionDirection(str, Enum):
+    READ = "read"
+    WRITE = "write"
+
+
+class TransformKind(str, Enum):
+    # value -> value, a python expression on ``x`` (e.g. ``"x / 100"``)
+    EXPRESSION = "expression"
+    # payload -> list of messages, ``{"filepath": ..., "function_name": ...}``
+    FUNCTION = "function"
+
+
+class EdgeDeviceKeyStatus(str, Enum):
+    ACTIVE = "active"
+    RETIRED = "retired"
+
+
+def _ts_out(value: Optional[datetime]) -> Optional[int]:
+    return int(value.timestamp() * 1000) if value is not None else None
+
+
+def _ts_in(value) -> Optional[datetime]:
+    if value is None:
+        return None
+    if isinstance(value, datetime):
+        return value
+    return datetime.fromtimestamp(value / 1000, tz=timezone.utc)
+
+
+class Connection:
+    """
+    Connection entity stored in PostgreSQL ``"Connection"`` table. PK ``id`` (UUID).
+
+    - ``key``: unique user-facing identifier, also the consumer id on the edge.
+    - ``connection_type``: a name from ``connection_types.CONNECTION_TYPES``.
+    - ``edge_device_id``: the edge that owns it and alone can read its secrets.
+    - ``config``: clear parameters, validated against the type's config schema.
+    - ``secrets``: ``{field: envelope}`` once stored. On the write path it carries
+      plaintext instead — ``{field: "value"}`` to set, ``{field: None}`` to clear;
+      fields left out keep their current value.
+    """
+
+    def __init__(self):
+        self.id: Optional[str] = None
+        self.key: Optional[str] = None
+        self.name: Optional[str] = None
+        self.connection_type: Optional[str] = None
+        self.edge_device_id: Optional[str] = None
+        self.config: dict = {}
+        self.secrets: dict = {}
+        self.created_at: Optional[datetime] = None
+        self.updated_at: Optional[datetime] = None
+
+    def secrets_set(self) -> list:
+        """Names of the secret fields holding a value."""
+        return sorted(k for k, v in (self.secrets or {}).items() if v is not None)
+
+    def to_dict(self, include_secrets: bool = False, active_key_id: str = None) -> dict:
+        """
+        :param include_secrets: emit the sealed envelopes (persistence and edge
+            rendering only). Never set it on a response to a user: the default
+            shows which fields are set, not what they hold.
+        :param active_key_id: fingerprint of the edge's active key. When given, the
+            public form also lists the secrets sealed for another key — the edge
+            can no longer open those and they must be entered again.
+        """
+        obj = {}
+        if self.id is not None:
+            obj["id"] = str(self.id)
+        if self.key is not None:
+            obj["key"] = self.key
+        if self.name is not None:
+            obj["name"] = self.name
+        if self.connection_type is not None:
+            obj["connectionType"] = self.connection_type
+        if self.edge_device_id is not None:
+            obj["edgeDeviceId"] = self.edge_device_id
+        obj["config"] = dict(self.config or {})
+        if include_secrets:
+            obj["secrets"] = dict(self.secrets or {})
+        else:
+            obj["secretsSet"] = self.secrets_set()
+            if active_key_id is not None:
+                obj["secretsStale"] = sorted(
+                    k for k, v in (self.secrets or {}).items()
+                    if isinstance(v, dict) and v.get("kid") != active_key_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) -> "Connection":
+        obj = cls()
+        obj.id = data.get("id")
+        obj.key = data.get("key")
+        obj.name = data.get("name")
+        obj.connection_type = data.get("connectionType") or data.get("connection_type")
+        obj.edge_device_id = data.get("edgeDeviceId") or data.get("edge_device_id")
+        obj.config = data.get("config") or {}
+        obj.secrets = data.get("secrets") or {}
+        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 api_key(self) -> str:
+        return self.key
+
+    def set_id(self, value):
+        self.id = str(value)
+
+    def __repr__(self) -> str:
+        # secrets deliberately left out, even sealed
+        return (f"Connection(id={self.id!r}, key={self.key!r}, "
+                f"type={self.connection_type!r}, edge={self.edge_device_id!r})")
+
+
+class ConnectionMapping:
+    """
+    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``...).
+    """
+
+    def __init__(self):
+        self.id: Optional[str] = None
+        self.connection_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.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.connection_id is not None:
+            obj["connectionId"] = str(self.connection_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.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) -> "ConnectionMapping":
+        obj = cls()
+        obj.id = data.get("id")
+        obj.connection_id = data.get("connectionId") or data.get("connection_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.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 api_key(self) -> str:
+        return self.api_id()
+
+    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})")
+
+
+class EdgeDeviceKey:
+    """
+    EdgeDeviceKey entity stored in PostgreSQL ``"EdgeDeviceKey"`` table. PK ``id``.
+
+    The edge generates the pair and registers only the public half; the private half
+    never leaves the device, and the platform holds no key that could open a secret.
+    At most one ACTIVE row per ``edge_device_id``.
+
+    - ``public_key``: PEM (SubjectPublicKeyInfo).
+    - ``algorithm``: e.g. ``"x25519"``.
+    - ``fingerprint``: sha256 of the raw public key, hex — the ``kid`` envelopes carry.
+    """
+
+    def __init__(self):
+        self.id: Optional[str] = None
+        self.edge_device_id: Optional[str] = None
+        self.public_key: Optional[str] = None
+        self.algorithm: Optional[str] = None
+        self.fingerprint: Optional[str] = None
+        self.status: EdgeDeviceKeyStatus = EdgeDeviceKeyStatus.ACTIVE
+        self.created_at: Optional[datetime] = None
+        self.retired_at: Optional[datetime] = None
+
+    def to_dict(self) -> dict:
+        obj = {}
+        if self.id is not None:
+            obj["id"] = str(self.id)
+        if self.edge_device_id is not None:
+            obj["edgeDeviceId"] = self.edge_device_id
+        if self.public_key is not None:
+            obj["publicKey"] = self.public_key
+        if self.algorithm is not None:
+            obj["algorithm"] = self.algorithm
+        if self.fingerprint is not None:
+            obj["fingerprint"] = self.fingerprint
+        obj["status"] = (self.status.value
+                         if isinstance(self.status, EdgeDeviceKeyStatus)
+                         else self.status)
+        if self.created_at is not None:
+            obj["createdAt"] = _ts_out(self.created_at)
+        if self.retired_at is not None:
+            obj["retiredAt"] = _ts_out(self.retired_at)
+        return obj
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "EdgeDeviceKey":
+        obj = cls()
+        obj.id = data.get("id")
+        obj.edge_device_id = data.get("edgeDeviceId") or data.get("edge_device_id")
+        obj.public_key = data.get("publicKey") or data.get("public_key")
+        obj.algorithm = data.get("algorithm")
+        obj.fingerprint = data.get("fingerprint")
+        raw_status = data.get("status")
+        if raw_status is not None:
+            obj.status = EdgeDeviceKeyStatus(str(raw_status).lower())
+        obj.created_at = _ts_in(data.get("createdAt") or data.get("created_at"))
+        obj.retired_at = _ts_in(data.get("retiredAt") or data.get("retired_at"))
+        return obj
+
+    def api_id(self) -> str:
+        return str(self.id) if self.id else None
+
+    def api_key(self) -> str:
+        return self.api_id()
+
+    def set_id(self, value):
+        self.id = str(value)
+
+    def __repr__(self) -> str:
+        return (f"EdgeDeviceKey(edge={self.edge_device_id!r}, "
+                f"fingerprint={self.fingerprint!r}, status={self.status!r})")

wizata_dsapi-2.2.0.dev3/wizata_dsapi/connection_types.py

@@ -0,0 +1,325 @@
+"""
+Connection type registry (DEV-6013).
+
+One definition per connector type, used for 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
+  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.
+
+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.
+"""
+
+from typing import Optional
+
+from .connection import ConnectionDirection, TransformKind
+
+
+_READ = ConnectionDirection.READ.value
+_WRITE = ConnectionDirection.WRITE.value
+
+
+def _obj(properties: dict, required: list = None) -> dict:
+    schema = {"type": "object", "properties": properties, "additionalProperties": False}
+    if required:
+        schema["required"] = required
+    return schema
+
+
+def _secret(title: str, pem: bool = False) -> dict:
+    field = {"type": "string", "title": title, "writeOnly": True}
+    if pem:
+        field["contentMediaType"] = "application/x-pem-file"
+    return field
+
+
+def _pem(title: str) -> dict:
+    return {"type": "string", "title": title, "contentMediaType": "application/x-pem-file"}
+
+
+_EMPTY = _obj({})
+
+
+class ConnectionType:
+    """
+    One supported connector 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}``.
+    """
+
+    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):
+        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.supports_browse = supports_browse
+
+    @property
+    def secret_fields(self) -> list:
+        return list(self.secrets.get("properties", {}).keys())
+
+    def describe(self) -> dict:
+        """Summary for the type list: enough to offer the type, not to build a form."""
+        return {
+            "type": self.name,
+            "label": self.label,
+            "description": self.description,
+            "directions": list(self.directions),
+            "transforms": list(self.transforms),
+            "polled": self.polled,
+            "supportsBrowse": self.supports_browse,
+            "secretFields": self.secret_fields,
+        }
+
+    def schema(self) -> dict:
+        """Everything a form needs: the summary plus every JSON Schema."""
+        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()}
+        return out
+
+
+# ── OPC-UA ─────────────────────────────────────────────────────────────────────
+
+_OPC_SECURITY_POLICIES = ["None", "Basic128Rsa15", "Basic256", "Basic256Sha256",
+                          "Aes128Sha256RsaOaep", "Aes256Sha256RsaPss"]
+
+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,
+    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"},
+        "application_uri": {"type": "string", "title": "Application URI"},
+        "security_policy": {"type": "string", "title": "Security policy",
+                            "enum": _OPC_SECURITY_POLICIES, "default": "None"},
+        "security_mode": {"type": "string", "title": "Security mode",
+                          "enum": ["None", "Sign", "SignAndEncrypt"], "default": "None"},
+        "client_certificate": _pem("Client certificate"),
+        "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,
+        },
+    },
+)
+
+# ── MQTT ───────────────────────────────────────────────────────────────────────
+
+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},
+    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},
+        "reconnect_max": {"type": "number", "minimum": 0, "default": 120.0},
+        "connect_timeout": {"type": "number", "minimum": 0, "default": 30.0},
+        "watchdog_timeout": {"type": "number", "minimum": 0, "default": 0},
+    }, required=["host"]),
+    secrets=_obj({
+        "password": _secret("Password"),
+    }),
+    mapping={
+        _READ: {
+            "address": _obj({
+                "topic": {"type": "string", "title": "Topic", "examples": ["plant/line1/#"]},
+            }, required=["topic"]),
+            "options": _obj({
+                "qos": {"type": "integer", "enum": [0, 1, 2], "default": 1},
+            }),
+        },
+    },
+)
+
+# ── Modbus TCP ─────────────────────────────────────────────────────────────────
+
+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},
+    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({
+                "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({
+                "pack": {"type": "string", "title": "struct pack format", "examples": [">HH"]},
+                "unpack": {"type": "string", "title": "struct unpack format", "examples": [">f"]},
+            }, required=["pack", "unpack"]),
+        },
+    },
+)
+
+# ── Siemens S7 (snap7) ─────────────────────────────────────────────────────────
+
+SNAP7 = ConnectionType(
+    name="snap7",
+    label="Siemens S7",
+    description="Siemens S7 PLC — poll data blocks.",
+    directions=[_READ],
+    transforms=[],
+    polled=True,
+    hardware_id_required={_READ: True},
+    config=_obj({
+        "address": {"type": "string", "title": "PLC address"},
+        "rack": {"type": "integer", "minimum": 0, "default": 0},
+        "slot": {"type": "integer", "minimum": 0, "default": 1},
+        "tcp_port": {"type": "integer", "title": "Port", "default": 102},
+    }, required=["address"]),
+    secrets=_EMPTY,
+    mapping={
+        _READ: {
+            "address": _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,
+        },
+    },
+)
+
+# ── RabbitMQ (external queue) ──────────────────────────────────────────────────
+
+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},
+    config=_obj({
+        "host": {"type": "string", "title": "Host"},
+        "port": {"type": "integer", "title": "Port", "default": 5671},
+        "vhost": {"type": "string", "title": "Virtual host", "default": "/"},
+        "tls": {"type": "boolean", "title": "TLS", "default": True},
+        "username": {"type": "string", "title": "Username"},
+    }, required=["host", "username"]),
+    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"},
+            }),
+        },
+    },
+)
+
+
+CONNECTION_TYPES = {t.name: t for t in (OPC_UA, MQTT, MODBUS, SNAP7, RABBITMQ)}
+
+# Transform payloads, whatever the type (the type decides which kinds it accepts).
+TRANSFORM_SCHEMAS = {
+    TransformKind.EXPRESSION.value: _obj({
+        "kind": {"const": TransformKind.EXPRESSION.value},
+        "expression": {"type": "string", "title": "Expression on x", "examples": ["x / 100"]},
+    }, required=["kind", "expression"]),
+    TransformKind.FUNCTION.value: _obj({
+        "kind": {"const": TransformKind.FUNCTION.value},
+        "filepath": {"type": "string", "title": "Function file"},
+        "function_name": {"type": "string", "title": "Function name"},
+    }, required=["kind", "filepath", "function_name"]),
+}
+
+
+def get_connection_type(name: str) -> Optional[ConnectionType]:
+    return CONNECTION_TYPES.get((name or "").lower())
+
+
+def list_connection_types() -> list:
+    return [t.describe() for t in CONNECTION_TYPES.values()]

wizata_dsapi-2.2.0.dev3/wizata_dsapi/product.py

@@ -0,0 +1,210 @@
+"""
+Production Planner product definitions (DEV-6070, epic DEV-6044).
+
+ProductKind — what role a product plays: raw material, container, finished product,
+  or a kind the customer adds. The three built-in kinds (``BUILTIN_PRODUCT_KINDS``)
+  are seeded on every tenant and cannot be deleted.
+
+Product — something the plant consumes or makes, identified by a Wizata key
+  (e.g. ``can_33_coke``). ``category`` is a backend category id (Volume, Count, ...):
+  it says how a quantity of that product is expressed.
+
+ProductComponent — one line of a product's bill of materials: ``product`` is made of
+  ``quantity`` ``unit`` of ``composed_of``. The unit is a backend unit id and must
+  belong to the category of ``composed_of`` (33 ml of coke, 1 pcs of can).
+  ``unit_symbol`` is filled on read only.
+
+All of it is served under ``/dsapi/planner`` and gated by the Production Planner
+add-on license (DEV-6069).
+"""
+
+import re
+from datetime import datetime, timezone
+from typing import Optional
+
+#: key -> (name, description). Seeded by alembic 0019; editable, never deletable.
+BUILTIN_PRODUCT_KINDS = {
+    "raw": ("Raw Material",
+            "A material bought or produced upstream and consumed to make other "
+            "products (e.g. syrup, water, aluminium)."),
+    "container": ("Containers",
+                  "Packaging that holds or carries a product (e.g. can, bottle, box, pallet)."),
+    "finished": ("Finished Product",
+                 "A product ready to ship or sell, made from raw materials and containers."),
+}
+
+#: A Wizata key: starts with a letter or digit, then letters, digits, ``_ - .``.
+PRODUCT_KEY_PATTERN = re.compile(r"^[A-Za-z0-9][A-Za-z0-9_\-.]{0,63}$")
+
+
+def is_valid_product_key(key) -> bool:
+    return isinstance(key, str) and PRODUCT_KEY_PATTERN.match(key) is not None
+
+
+def _ts_out(value):
+    if value is None:
+        return None
+    if value.tzinfo is None:
+        value = value.replace(tzinfo=timezone.utc)
+    return value.isoformat()
+
+
+def _ts_in(value):
+    if value is None or isinstance(value, datetime):
+        return value
+    return datetime.fromisoformat(str(value).replace("Z", "+00:00"))
+
+
+def _uuid_str(value):
+    """Backend ids travel as strings, lower-cased so equal ids compare equal."""
+    if value is None or value == "":
+        return None
+    return str(value).lower()
+
+
+class ProductKind:
+    """ProductKind entity stored in PostgreSQL ``"ProductKind"``. PK ``key``."""
+
+    @classmethod
+    def route(cls):
+        return "planner/productkinds"
+
+    def __init__(self, key: str = None, name: str = None, description: str = None):
+        self.key: Optional[str] = key
+        self.name: Optional[str] = name
+        self.description: Optional[str] = description
+        self.created_at: Optional[datetime] = None
+        self.updated_at: Optional[datetime] = None
+
+    @property
+    def builtin(self) -> bool:
+        return self.key in BUILTIN_PRODUCT_KINDS
+
+    def to_dict(self) -> dict:
+        obj = {}
+        if self.key is not None:
+            obj["key"] = self.key
+        if self.name is not None:
+            obj["name"] = self.name
+        if self.description is not None:
+            obj["description"] = self.description
+        obj["builtin"] = self.builtin
+        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) -> "ProductKind":
+        obj = cls()
+        obj.key = data.get("key")
+        obj.name = data.get("name")
+        obj.description = data.get("description")
+        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 self.key
+
+    def __repr__(self) -> str:
+        return f"ProductKind(key={self.key!r}, name={self.name!r})"
+
+
+class Product:
+    """Product entity stored in PostgreSQL ``"Product"``. PK ``key``."""
+
+    @classmethod
+    def route(cls):
+        return "planner/products"
+
+    def __init__(self, key: str = None, name: str = None, category=None,
+                 kind: str = None, description: str = None):
+        self.key: Optional[str] = key
+        self.name: Optional[str] = name
+        self.category: Optional[str] = _uuid_str(category)
+        self.kind: Optional[str] = kind
+        self.description: Optional[str] = description
+        self.created_at: Optional[datetime] = None
+        self.updated_at: Optional[datetime] = None
+
+    def to_dict(self) -> dict:
+        obj = {}
+        if self.key is not None:
+            obj["key"] = self.key
+        if self.name is not None:
+            obj["name"] = self.name
+        if self.category is not None:
+            obj["category"] = self.category
+        if self.kind is not None:
+            obj["kind"] = self.kind
+        if self.description is not None:
+            obj["description"] = self.description
+        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) -> "Product":
+        obj = cls()
+        obj.key = data.get("key")
+        obj.name = data.get("name")
+        obj.category = _uuid_str(data.get("category"))
+        obj.kind = data.get("kind")
+        obj.description = data.get("description")
+        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 self.key
+
+    def __repr__(self) -> str:
+        return f"Product(key={self.key!r}, kind={self.kind!r}, category={self.category!r})"
+
+
+class ProductComponent:
+    """
+    One bill-of-materials line, stored in PostgreSQL ``"ProductComponent"``.
+    PK (``product``, ``composed_of``).
+    """
+
+    def __init__(self, product: str = None, composed_of: str = None,
+                 quantity: float = None, unit=None):
+        self.product: Optional[str] = product
+        self.composed_of: Optional[str] = composed_of
+        self.quantity: Optional[float] = quantity
+        self.unit: Optional[str] = _uuid_str(unit)
+        #: read-only, filled from the backend unit on read
+        self.unit_symbol: Optional[str] = None
+
+    def to_dict(self) -> dict:
+        obj = {}
+        if self.product is not None:
+            obj["product"] = self.product
+        if self.composed_of is not None:
+            obj["composedOf"] = self.composed_of
+        if self.quantity is not None:
+            obj["quantity"] = self.quantity
+        if self.unit is not None:
+            obj["unit"] = self.unit
+        if self.unit_symbol is not None:
+            obj["unitSymbol"] = self.unit_symbol
+        return obj
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "ProductComponent":
+        obj = cls()
+        obj.product = data.get("product")
+        obj.composed_of = data.get("composedOf") or data.get("composed_of")
+        obj.quantity = data.get("quantity")
+        obj.unit = _uuid_str(data.get("unit"))
+        obj.unit_symbol = data.get("unitSymbol") or data.get("unit_symbol")
+        return obj
+
+    def __repr__(self) -> str:
+        return (f"ProductComponent({self.product!r} <- {self.quantity!r} {self.unit_symbol or self.unit!r} "
+                f"of {self.composed_of!r})")

wizata_dsapi-2.2.0.dev3/wizata_dsapi/version.py

@@ -0,0 +1 @@
+__version__ = "2.2.0.dev3"

{wizata_dsapi-2.2.0.dev1 → wizata_dsapi-2.2.0.dev3}/wizata_dsapi/wizata_dsapi_client.py

@@ -54,6 +54,7 @@ from .mobile_asset import MobileAssetTile, MobileAssetConfig
 from .version import __version__
 import ast
 from .deployment import Deployment, DeploymentStatus
+from .product import ProductKind, Product, ProductComponent
 from .api_config import _registry
 
 from .streamlit_utils import get_streamlit_token, get_streamlit_domain
@@ -2731,6 +2732,142 @@ class WizataDSAPIClient(ApiInterface, ApiDtoInterface):
             raise self.__raise_error(response)
 
 
+    # ------------------------------------------------------------------
+    # Production Planner - product definitions (DEV-6070)
+    #
+    # Everything below answers 403 PLANNER_LICENSE_DISABLED while the
+    # Production Planner add-on is not active on the environment (DEV-6069).
+    # ------------------------------------------------------------------
+
+    def _planner_request(self, method: str, route: str, body=None, params: dict = None,
+                         expected=(200,)):
+        response = requests.request(
+            method,
+            self.__url() + route,
+            headers=self.__header(),
+            data=json.dumps(body) if body is not None else None,
+            params=params,
+        )
+        if response.status_code not in expected:
+            raise self.__raise_error(response)
+        return response
+
+    @staticmethod
+    def _planner_key(value) -> str:
+        key = value.key if hasattr(value, "key") else value
+        if not key:
+            raise ValueError("please provide a key")
+        return urllib.parse.quote(str(key), safe="")
+
+    def search_product_kinds(self, search_query=None) -> PagedQueryResult:
+        """
+        The only way to list product kinds: the built-in raw / container / finished and
+        the tenant's own.
+
+        :param search_query: SearchQuery or dict; filters on ``name``, ``_search`` over
+            key and name.
+        :return: PagedQueryResult with ProductKind results.
+        """
+        if search_query is None:
+            search_query = SearchQuery()
+        elif isinstance(search_query, dict):
+            search_query = SearchQuery.from_dict(search_query)
+        response = self._planner_request("POST", "planner/productkinds/search",
+                                         body=search_query.to_dict())
+        return PagedQueryResult.from_dict(response.json(), dto_class=ProductKind)
+
+    def get_product_kind(self, key: str):
+        """
+        :param key: product kind key (e.g. ``raw``).
+        :return: ProductKind, or None when it does not exist.
+        """
+        response = self._planner_request("GET", f"planner/productkinds/{self._planner_key(key)}/",
+                                         expected=(200, 404))
+        return ProductKind.from_dict(response.json()) if response.status_code == 200 else None
+
+    def create_product_kind(self, kind: ProductKind) -> ProductKind:
+        response = self._planner_request("POST", "planner/productkinds/", body=kind.to_dict(),
+                                         expected=(201,))
+        return ProductKind.from_dict(response.json())
+
+    def update_product_kind(self, kind: ProductKind) -> ProductKind:
+        response = self._planner_request("PUT", f"planner/productkinds/{self._planner_key(kind)}/",
+                                         body=kind.to_dict())
+        return ProductKind.from_dict(response.json())
+
+    def delete_product_kind(self, kind):
+        """
+        :param kind: ProductKind or its key. A built-in kind, or a kind still used by a
+            product, is refused (409).
+        """
+        self._planner_request("DELETE", f"planner/productkinds/{self._planner_key(kind)}/",
+                              expected=(204,))
+
+    def search_products(self, search_query=None) -> PagedQueryResult:
+        """
+        The only way to list products.
+
+        :param search_query: SearchQuery or dict; filters on ``kind``, ``category``
+            (backend category id), ``name``, and ``_search`` over key and name.
+        :return: PagedQueryResult with Product results.
+        """
+        if search_query is None:
+            search_query = SearchQuery()
+        elif isinstance(search_query, dict):
+            search_query = SearchQuery.from_dict(search_query)
+        response = self._planner_request("POST", "planner/products/search",
+                                         body=search_query.to_dict())
+        return PagedQueryResult.from_dict(response.json(), dto_class=Product)
+
+    def get_product(self, key: str):
+        """
+        :return: Product, or None when it does not exist.
+        """
+        response = self._planner_request("GET", f"planner/products/{self._planner_key(key)}/",
+                                         expected=(200, 404))
+        return Product.from_dict(response.json()) if response.status_code == 200 else None
+
+    def create_product(self, product: Product) -> Product:
+        response = self._planner_request("POST", "planner/products/", body=product.to_dict(),
+                                         expected=(201,))
+        return Product.from_dict(response.json())
+
+    def update_product(self, product: Product) -> Product:
+        response = self._planner_request("PUT", f"planner/products/{self._planner_key(product)}/",
+                                         body=product.to_dict())
+        return Product.from_dict(response.json())
+
+    def delete_product(self, product):
+        """
+        :param product: Product or its key. Refused (409) while another product is made
+            of it; its own bill of materials is deleted with it.
+        """
+        self._planner_request("DELETE", f"planner/products/{self._planner_key(product)}/",
+                              expected=(204,))
+
+    def get_product_components(self, product) -> list:
+        """
+        :param product: Product or its key.
+        :return: its bill of materials, a list of ProductComponent with unit_symbol set.
+        """
+        response = self._planner_request(
+            "GET", f"planner/products/{self._planner_key(product)}/components/")
+        return [ProductComponent.from_dict(c) for c in response.json()]
+
+    def set_product_components(self, product, components: list) -> list:
+        """
+        Replace a product's bill of materials (an empty list clears it).
+
+        :param product: Product or its key.
+        :param components: list of ProductComponent (``product`` may be left unset).
+        :return: the stored components, unit_symbol set.
+        """
+        body = [c.to_dict() if isinstance(c, ProductComponent) else c for c in components]
+        response = self._planner_request(
+            "PUT", f"planner/products/{self._planner_key(product)}/components/", body=body)
+        return [ProductComponent.from_dict(c) for c in response.json()]
+
+
 def api() -> WizataDSAPIClient:
     """
     Create a WizataDSAPIClient from environment variables.

{wizata_dsapi-2.2.0.dev1 → wizata_dsapi-2.2.0.dev3}/wizata_dsapi.egg-info/PKG-INFO

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

{wizata_dsapi-2.2.0.dev1 → wizata_dsapi-2.2.0.dev3}/wizata_dsapi.egg-info/SOURCES.txt

@@ -7,6 +7,8 @@ wizata_dsapi/api_dto.py
 wizata_dsapi/api_interface.py
 wizata_dsapi/bucket.py
 wizata_dsapi/business_label.py
+wizata_dsapi/connection.py
+wizata_dsapi/connection_types.py
 wizata_dsapi/context.py
 wizata_dsapi/dashboard.py
 wizata_dsapi/dataframe_toolkit.py
@@ -34,6 +36,7 @@ wizata_dsapi/paged_query_result.py
 wizata_dsapi/pipeline.py
 wizata_dsapi/pipeline_image.py
 wizata_dsapi/plot.py
+wizata_dsapi/product.py
 wizata_dsapi/request.py
 wizata_dsapi/script.py
 wizata_dsapi/search.py

wizata_dsapi-2.2.0.dev1/wizata_dsapi/version.py

@@ -1 +0,0 @@
-__version__ = "2.2.0.dev1"