wizata-dsapi 2.2.0.dev15__tar.gz → 2.2.0.dev17__tar.gz

{wizata_dsapi-2.2.0.dev15 → wizata_dsapi-2.2.0.dev17}/PKG-INFO

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

{wizata_dsapi-2.2.0.dev15 → wizata_dsapi-2.2.0.dev17}/wizata_dsapi/__init__.py

@@ -60,7 +60,7 @@ from .notification import NotificationScope, DeviceToken, AlertRule, AlertActive
     MonitoredPipeline, NotificationPreference, RecipientList, Recipient, RecipientType
 from .edge_device import EdgeDevice, EdgeDeviceStatus, EdgeDeviceType, EdgeDeviceProvisioning
 from .edge_module import EdgeModule, EdgeModuleType, WIZATA_MODULES
-from .edge_config import EdgeConsumer, EdgeWriter, EdgeTrigger
+from .edge_config import EdgeConsumer, EdgeWriter, EdgeTrigger, EdgeFile, EdgeConfig, EdgeCommand
 from .connection import Connection, ConnectionMapping, ConnectionDirection, TransformKind, \
     EdgeDeviceKey, EdgeDeviceKeyStatus
 from .connection_types import ConnectionType, CONNECTION_TYPES, TRANSFORM_SCHEMAS, get_connection_type, \

wizata_dsapi-2.2.0.dev17/wizata_dsapi/edge_config.py

@@ -0,0 +1,240 @@
+from .api_dto import Dto
+
+
+class EdgeConsumer(Dto):
+    """
+    A data source connector configured on an edge device.
+
+    Known fields are extracted as attributes; everything else lands in ``extras``.
+    Consumer types vary (opc-ua, mqtt, modbus, …) so type-specific fields are
+    intentionally left unstructured.
+
+    :ivar str id: connector identifier.
+    :ivar str type: connector type (e.g. ``"opc-ua"``, ``"mqtt"``).
+    :ivar str prefix: datapoint prefix applied by this consumer.
+    :ivar dict extras: all other fields from the JSON config.
+    """
+
+    _KNOWN_KEYS = {"id", "type", "prefix"}
+
+    def __init__(self, id=None, type=None, prefix=None, extras=None):
+        self.id = id
+        self.type = type
+        self.prefix = prefix
+        self.extras = extras or {}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "EdgeConsumer":
+        extras = {k: v for k, v in data.items() if k not in cls._KNOWN_KEYS}
+        return cls(
+            id=data.get("id"),
+            type=data.get("type"),
+            prefix=data.get("prefix"),
+            extras=extras,
+        )
+
+    def to_dict(self, include_extras=True) -> dict:
+        obj = {}
+        if self.id is not None:
+            obj["id"] = self.id
+        if self.type is not None:
+            obj["type"] = self.type
+        if self.prefix is not None:
+            obj["prefix"] = self.prefix
+        if include_extras and self.extras:
+            obj.update(self.extras)
+        return obj
+
+
+class EdgeWriter(Dto):
+    """
+    A data output destination configured on an edge device.
+
+    Also the stored entity for an edge's ``cloud`` (hub) and ``edge`` (tsdb) writers
+    (DEV-6014, ``"EdgeWriter"`` table): which datapoints each one passes. Their connection
+    settings stay in the edge's environment, so a stored writer has no ``extras``.
+
+    :ivar str id: writer identifier.
+    :ivar str type: writer type (e.g. ``"tsdb"``, ``"hub"``, ``"opc-ua"``).
+    :ivar datapoints: ``"*"`` for all, a list of datapoint names, or a dict mapping names to addresses.
+    :ivar dict extras: all other fields from the JSON config.
+    :ivar str edge_device_id: the device it belongs to, when stored (not part of writers.json).
+    """
+
+    _KNOWN_KEYS = {"id", "type", "datapoints"}
+
+    def __init__(self, id=None, type=None, datapoints=None, extras=None, edge_device_id=None):
+        self.id = id
+        self.type = type
+        self.datapoints = datapoints
+        self.extras = extras or {}
+        self.edge_device_id = edge_device_id
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "EdgeWriter":
+        extras = {k: v for k, v in data.items() if k not in cls._KNOWN_KEYS}
+        return cls(
+            id=data.get("id"),
+            type=data.get("type"),
+            datapoints=data.get("datapoints"),
+            extras=extras,
+        )
+
+    def to_dict(self, include_extras=True) -> dict:
+        obj = {}
+        if self.id is not None:
+            obj["id"] = self.id
+        if self.type is not None:
+            obj["type"] = self.type
+        if self.datapoints is not None:
+            obj["datapoints"] = self.datapoints
+        if include_extras and self.extras:
+            obj.update(self.extras)
+        return obj
+
+
+class EdgeTrigger(Dto):
+    """
+    A pipeline trigger configured on an edge device.
+
+    Also the stored entity for an edge's hand-made triggers (DEV-6095, ``"EdgeTrigger"``
+    table): a standalone trigger, or an overlay naming a ``deploymentId`` whose extra
+    keys (``exceptions``...) are merged into that deployment's rendered entry.
+
+    :ivar str id: trigger identifier (the stored key).
+    :ivar int interval: execution interval in milliseconds.
+    :ivar str pipeline_image_id: pipeline image reference (build tag + pipeline key).
+    :ivar str twin: twin key this trigger targets.
+    :ivar str template: template key this trigger targets.
+    :ivar dict extras: all other fields from the JSON config.
+    :ivar str edge_device_id: the device it belongs to, when stored (not part of triggers.json).
+    """
+
+    _KNOWN_KEYS = {"id", "interval", "pipelineImageId", "twin", "template"}
+
+    def __init__(self, id=None, interval=None, pipeline_image_id=None,
+                 twin=None, template=None, extras=None, edge_device_id=None):
+        self.id = id
+        self.interval = interval
+        self.pipeline_image_id = pipeline_image_id
+        self.twin = twin
+        self.template = template
+        self.extras = extras or {}
+        self.edge_device_id = edge_device_id
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "EdgeTrigger":
+        extras = {k: v for k, v in data.items() if k not in cls._KNOWN_KEYS}
+        return cls(
+            id=data.get("id"),
+            interval=data.get("interval"),
+            pipeline_image_id=data.get("pipelineImageId"),
+            twin=data.get("twin"),
+            template=data.get("template"),
+            extras=extras,
+        )
+
+    def to_dict(self, include_extras=True) -> dict:
+        obj = {}
+        if self.id is not None:
+            obj["id"] = self.id
+        if self.interval is not None:
+            obj["interval"] = self.interval
+        if self.pipeline_image_id is not None:
+            obj["pipelineImageId"] = self.pipeline_image_id
+        if self.twin is not None:
+            obj["twin"] = self.twin
+        if self.template is not None:
+            obj["template"] = self.template
+        if include_extras and self.extras:
+            obj.update(self.extras)
+        return obj
+
+
+class EdgeFile(Dto):
+    """
+    A file an edge needs besides its rendered configuration, stored in PostgreSQL
+    (DEV-6014): today the code of the transform functions MQTT and RabbitMQ mappings
+    name by ``filepath``. Served to the edge at the same path under its conf directory.
+
+    :ivar str edge_device_id: the device id it belongs to.
+    :ivar str path: relative path on the edge, e.g. ``functions/parse.py``.
+    :ivar str content: the file's text.
+    :ivar str sha256: hex digest of the content.
+    """
+
+    def __init__(self, edge_device_id=None, path=None, content=None, sha256=None,
+                 created_at=None, updated_at=None):
+        self.edge_device_id = edge_device_id
+        self.path = path
+        self.content = content
+        self.sha256 = sha256
+        self.created_at = created_at
+        self.updated_at = updated_at
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "EdgeFile":
+        return cls(edge_device_id=data.get("edgeDeviceId"), path=data.get("path"),
+                   content=data.get("content"), sha256=data.get("sha256"),
+                   created_at=data.get("createdAt"), updated_at=data.get("updatedAt"))
+
+    def to_dict(self, include_content=True) -> dict:
+        obj = {"edgeDeviceId": self.edge_device_id, "path": self.path, "sha256": self.sha256}
+        if include_content:
+            obj["content"] = self.content
+        if self.created_at is not None:
+            obj["createdAt"] = self.created_at
+        if self.updated_at is not None:
+            obj["updatedAt"] = self.updated_at
+        return obj
+
+
+class EdgeConfig(Dto):
+    """
+    Everything an edge syncs into its conf directory, rendered from PostgreSQL by the
+    platform (DEV-6014): ``consumers.json``, ``writers.json`` and the stored files, by
+    path, plus the pipeline images it should hold. ``etag`` changes whenever any of it
+    does, so an edge asks again with it and gets nothing back when nothing changed.
+
+    :ivar dict files: relative path -> text content.
+    :ivar list images: pipeline image ids the edge should have under ``images/``.
+    :ivar str etag: digest of files and images.
+    """
+
+    def __init__(self, files=None, images=None, etag=None):
+        self.files = files or {}
+        self.images = images or []
+        self.etag = etag
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "EdgeConfig":
+        return cls(files=data.get("files"), images=data.get("images"), etag=data.get("etag"))
+
+    def to_dict(self) -> dict:
+        return {"files": dict(self.files), "images": list(self.images), "etag": self.etag}
+
+
+class EdgeCommand(Dto):
+    """
+    A one-shot operator command for an edge (DEV-6095), served as ``command.json`` until
+    it expires. The edge's command handler runs it once and refuses it when older than
+    15 minutes, so the platform only stores what was asked, and when.
+
+    :ivar str id: command id (UUID); the edge remembers which ids it ran.
+    :ivar str edge_device_id: the device it is for.
+    :ivar str action: e.g. ``purge_queue``.
+    :ivar str queue: e.g. ``pipeline``.
+    :ivar str issued_at: ISO-8601 UTC, ``Z`` suffix.
+    """
+
+    def __init__(self, id=None, edge_device_id=None, action=None, queue=None, issued_at=None):
+        self.id = id
+        self.edge_device_id = edge_device_id
+        self.action = action
+        self.queue = queue
+        self.issued_at = issued_at
+
+    def to_dict(self) -> dict:
+        """The ``command.json`` shape the edge's command handler reads."""
+        return {"id": self.id, "action": self.action, "queue": self.queue,
+                "issuedAt": self.issued_at}

wizata_dsapi-2.2.0.dev17/wizata_dsapi/version.py

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

{wizata_dsapi-2.2.0.dev15 → wizata_dsapi-2.2.0.dev17}/wizata_dsapi/wizata_dsapi_client.py

@@ -57,6 +57,7 @@ from .deployment import Deployment, DeploymentStatus
 from .product import ProductKind, Product, ProductComponent
 from .inventory import InventoryBalance, InventoryStorage, InventoryStock
 from .connection import EdgeDeviceKey
+from .edge_config import EdgeConfig
 from .api_config import _registry
 
 from .streamlit_utils import get_streamlit_token, get_streamlit_domain
@@ -2990,13 +2991,28 @@ class WizataDSAPIClient(ApiInterface, ApiDtoInterface):
         self._planner_request("DELETE", f"planner/inventory/balances/{self._balance_id(balance)}/",
                               expected=(204,))
 
-    # ------------------------------------------------------------ edge device keys
+    # ------------------------------------------------------------ edge (DEV-6013/6014)
 
     @staticmethod
-    def _edge_device_keys_route(edge_device_id) -> str:
+    def _edge_route(edge_device_id, *parts) -> str:
+        """``edge/<device id>/...``: the routes an edge itself calls."""
         if not edge_device_id:
             raise ValueError("please provide the edge device id")
-        return f"edgedevices/{urllib.parse.quote(str(edge_device_id), safe='')}/keys"
+        quoted = [urllib.parse.quote(str(p), safe='') for p in (edge_device_id,) + parts]
+        return "edge/" + "/".join(quoted)
+
+    def _edge_request(self, method: str, route: str, body=None, headers=None,
+                      expected=(200,), stream=False):
+        response = requests.request(
+            method,
+            self.__url() + route,
+            headers={**self.__header(), **(headers or {})},
+            data=json.dumps(body) if body is not None else None,
+            stream=stream,
+        )
+        if response.status_code not in expected:
+            raise self.__raise_error(response)
+        return response
 
     def register_edge_device_key(self, edge_device_id: str, public_key: str) -> EdgeDeviceKey:
         """
@@ -3012,9 +3028,8 @@ class WizataDSAPIClient(ApiInterface, ApiDtoInterface):
         :param public_key: PEM of the edge's X25519 public key.
         :return: the edge's active key.
         """
-        response = self._process_request(method="POST",
-                                         route=self._edge_device_keys_route(edge_device_id),
-                                         data=json.dumps({"publicKey": public_key}))
+        response = self._edge_request("POST", self._edge_route(edge_device_id, "keys"),
+                                      body={"publicKey": public_key}, expected=(200, 201))
         return EdgeDeviceKey.from_dict(response.json())
 
     def get_edge_device_keys(self, edge_device_id: str) -> list:
@@ -3023,9 +3038,45 @@ class WizataDSAPIClient(ApiInterface, ApiDtoInterface):
         :return: every EdgeDeviceKey the edge registered, newest first. With no active
             one, the edge has not registered yet and no secret can be entered for it.
         """
-        return self._process_request(method="GET",
-                                     route=self._edge_device_keys_route(edge_device_id),
-                                     dto_class=EdgeDeviceKey, result_type="list")
+        response = self._edge_request("GET", self._edge_route(edge_device_id, "keys"))
+        return [EdgeDeviceKey.from_dict(k) for k in response.json()]
+
+    def get_edge_config(self, edge_device_id: str, etag: str = None):
+        """
+        What the edge syncs into its conf directory, rendered from PostgreSQL (DEV-6014).
+
+        :param edge_device_id: the device id the edge runs as.
+        :param etag: the etag of the configuration the edge already holds.
+        :return: EdgeConfig, or None when it has not changed since ``etag``.
+        """
+        headers = {"If-None-Match": f'"{etag}"'} if etag else None
+        response = self._edge_request("GET", self._edge_route(edge_device_id, "config"),
+                                      headers=headers, expected=(200, 304))
+        if response.status_code == 304:
+            return None
+        return EdgeConfig.from_dict(response.json())
+
+    def download_edge_image(self, edge_device_id: str, image_id: str, path: str) -> str:
+        """
+        Stream a pipeline image to ``path``, written whole or not at all: it lands in a
+        temporary file next to ``path`` and is renamed once complete, so a runner never
+        loads half an image.
+
+        :return: ``path``.
+        """
+        response = self._edge_request("GET", self._edge_route(edge_device_id, "images", image_id),
+                                      stream=True)
+        temporary = path + ".part"
+        try:
+            with open(temporary, "wb") as f:
+                for chunk in response.iter_content(chunk_size=1024 * 1024):
+                    f.write(chunk)
+            os.replace(temporary, path)
+        finally:
+            response.close()
+            if os.path.exists(temporary):
+                os.remove(temporary)
+        return path
 
 
 def api() -> WizataDSAPIClient:

{wizata_dsapi-2.2.0.dev15 → wizata_dsapi-2.2.0.dev17}/wizata_dsapi.egg-info/PKG-INFO

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

wizata_dsapi-2.2.0.dev15/wizata_dsapi/edge_config.py

@@ -1,139 +0,0 @@
-from .api_dto import Dto
-
-
-class EdgeConsumer(Dto):
-    """
-    A data source connector configured on an edge device.
-
-    Known fields are extracted as attributes; everything else lands in ``extras``.
-    Consumer types vary (opc-ua, mqtt, modbus, …) so type-specific fields are
-    intentionally left unstructured.
-
-    :ivar str id: connector identifier.
-    :ivar str type: connector type (e.g. ``"opc-ua"``, ``"mqtt"``).
-    :ivar str prefix: datapoint prefix applied by this consumer.
-    :ivar dict extras: all other fields from the JSON config.
-    """
-
-    _KNOWN_KEYS = {"id", "type", "prefix"}
-
-    def __init__(self, id=None, type=None, prefix=None, extras=None):
-        self.id = id
-        self.type = type
-        self.prefix = prefix
-        self.extras = extras or {}
-
-    @classmethod
-    def from_dict(cls, data: dict) -> "EdgeConsumer":
-        extras = {k: v for k, v in data.items() if k not in cls._KNOWN_KEYS}
-        return cls(
-            id=data.get("id"),
-            type=data.get("type"),
-            prefix=data.get("prefix"),
-            extras=extras,
-        )
-
-    def to_dict(self, include_extras=True) -> dict:
-        obj = {}
-        if self.id is not None:
-            obj["id"] = self.id
-        if self.type is not None:
-            obj["type"] = self.type
-        if self.prefix is not None:
-            obj["prefix"] = self.prefix
-        if include_extras and self.extras:
-            obj.update(self.extras)
-        return obj
-
-
-class EdgeWriter(Dto):
-    """
-    A data output destination configured on an edge device.
-
-    :ivar str id: writer identifier.
-    :ivar str type: writer type (e.g. ``"tsdb"``, ``"hub"``, ``"opc-ua"``).
-    :ivar datapoints: ``"*"`` for all, a list of datapoint names, or a dict mapping names to addresses.
-    :ivar dict extras: all other fields from the JSON config.
-    """
-
-    _KNOWN_KEYS = {"id", "type", "datapoints"}
-
-    def __init__(self, id=None, type=None, datapoints=None, extras=None):
-        self.id = id
-        self.type = type
-        self.datapoints = datapoints
-        self.extras = extras or {}
-
-    @classmethod
-    def from_dict(cls, data: dict) -> "EdgeWriter":
-        extras = {k: v for k, v in data.items() if k not in cls._KNOWN_KEYS}
-        return cls(
-            id=data.get("id"),
-            type=data.get("type"),
-            datapoints=data.get("datapoints"),
-            extras=extras,
-        )
-
-    def to_dict(self, include_extras=True) -> dict:
-        obj = {}
-        if self.id is not None:
-            obj["id"] = self.id
-        if self.type is not None:
-            obj["type"] = self.type
-        if self.datapoints is not None:
-            obj["datapoints"] = self.datapoints
-        if include_extras and self.extras:
-            obj.update(self.extras)
-        return obj
-
-
-class EdgeTrigger(Dto):
-    """
-    A pipeline trigger configured on an edge device.
-
-    :ivar str id: trigger identifier.
-    :ivar int interval: execution interval in milliseconds.
-    :ivar str pipeline_image_id: pipeline image reference (build tag + pipeline key).
-    :ivar str twin: twin key this trigger targets.
-    :ivar str template: template key this trigger targets.
-    :ivar dict extras: all other fields from the JSON config.
-    """
-
-    _KNOWN_KEYS = {"id", "interval", "pipelineImageId", "twin", "template"}
-
-    def __init__(self, id=None, interval=None, pipeline_image_id=None,
-                 twin=None, template=None, extras=None):
-        self.id = id
-        self.interval = interval
-        self.pipeline_image_id = pipeline_image_id
-        self.twin = twin
-        self.template = template
-        self.extras = extras or {}
-
-    @classmethod
-    def from_dict(cls, data: dict) -> "EdgeTrigger":
-        extras = {k: v for k, v in data.items() if k not in cls._KNOWN_KEYS}
-        return cls(
-            id=data.get("id"),
-            interval=data.get("interval"),
-            pipeline_image_id=data.get("pipelineImageId"),
-            twin=data.get("twin"),
-            template=data.get("template"),
-            extras=extras,
-        )
-
-    def to_dict(self, include_extras=True) -> dict:
-        obj = {}
-        if self.id is not None:
-            obj["id"] = self.id
-        if self.interval is not None:
-            obj["interval"] = self.interval
-        if self.pipeline_image_id is not None:
-            obj["pipelineImageId"] = self.pipeline_image_id
-        if self.twin is not None:
-            obj["twin"] = self.twin
-        if self.template is not None:
-            obj["template"] = self.template
-        if include_extras and self.extras:
-            obj.update(self.extras)
-        return obj

wizata_dsapi-2.2.0.dev15/wizata_dsapi/version.py

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