wizata-dsapi 2.2.0.dev1__py3-none-any.whl → 2.2.0.dev2__py3-none-any.whl

wizata_dsapi/__init__.py

@@ -61,6 +61,10 @@ 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 .dashboard import Dashboard, DashboardType
 from .mobile_asset import MobileAssetTile, MobileAssetTileType, MobileAssetConfig
 from .graylog_log import GraylogLog

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/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/version.py

@@ -1 +1 @@
-__version__ = "2.2.0.dev1"
+__version__ = "2.2.0.dev2"

{wizata_dsapi-2.2.0.dev1.dist-info → wizata_dsapi-2.2.0.dev2.dist-info}/METADATA

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

{wizata_dsapi-2.2.0.dev1.dist-info → wizata_dsapi-2.2.0.dev2.dist-info}/RECORD

@@ -1,9 +1,11 @@
-wizata_dsapi/__init__.py,sha256=CkfJI_C4rnJBILMv-Kzv3TTvlH_CfRoftMoMwfrHPg4,3110
+wizata_dsapi/__init__.py,sha256=8zazLs_NYKRhveJt3vhy1SxwXHvBv5fEl6yfX-UilrI,3374
 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/context.py,sha256=1t0wCzRnBEzch7fx7jG4Oj3Ezrjv9getJtCrqEpn-pc,13188
 wizata_dsapi/dashboard.py,sha256=NY4m-1EpMRoKDHem0EwsRF0QQzal3bvrm9gQv3BNizk,3841
 wizata_dsapi/dataframe_toolkit.py,sha256=7D8JrhsFSGXeO3mRAd2e2cLmdjbXRjk04IuaMG8F974,9078
@@ -42,7 +44,7 @@ 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=TGgs6acPJU8FXwMUa7mMJng74NdaxQxlSQH5GY1maYE,27
+wizata_dsapi/version.py,sha256=bKxMxf4FLo3j7fCZ_ayiGhLIAkPquwpEeY8g9TOU0P8,27
 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=DX8WXKT5gi_nfHHX2-jz4dvUe-Bo_HszQmr94R3JvV0,112418
@@ -54,8 +56,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=T2cP8aGPg8OgIvBWuQBNonVtph_dHlNFubByuYrLb0o,15675
-wizata_dsapi-2.2.0.dev1.dist-info/licenses/LICENSE.txt,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
-wizata_dsapi-2.2.0.dev1.dist-info/METADATA,sha256=ijnULPMqLgYPq2KJsSCI7bhyPCu8aEuJbwr2H2bGcGw,14037
-wizata_dsapi-2.2.0.dev1.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
-wizata_dsapi-2.2.0.dev1.dist-info/top_level.txt,sha256=-OeTJbEnh5DuWyTOHtvw0Dw3LRg3G27TNS6W4ZtfwPs,13
-wizata_dsapi-2.2.0.dev1.dist-info/RECORD,,
+wizata_dsapi-2.2.0.dev2.dist-info/licenses/LICENSE.txt,sha256=QwcOLU5TJoTeUhuIXzhdCEEDDvorGiC6-3YTOl4TecE,11356
+wizata_dsapi-2.2.0.dev2.dist-info/METADATA,sha256=dVvL2OBGr42dKhKzMnfULhMExHhmUkJkAW1X8oR7_uU,14037
+wizata_dsapi-2.2.0.dev2.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+wizata_dsapi-2.2.0.dev2.dist-info/top_level.txt,sha256=-OeTJbEnh5DuWyTOHtvw0Dw3LRg3G27TNS6W4ZtfwPs,13
+wizata_dsapi-2.2.0.dev2.dist-info/RECORD,,