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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wizata_dsapi
-Version: 2.2.0.dev15
+Version: 2.2.0.dev16
 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.dev16}/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
 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.dev15 → wizata_dsapi-2.2.0.dev16}/wizata_dsapi/edge_config.py

@@ -50,19 +50,25 @@ 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):
+    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":
@@ -137,3 +143,66 @@ class EdgeTrigger(Dto):
         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}

wizata_dsapi-2.2.0.dev16/wizata_dsapi/version.py

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

{wizata_dsapi-2.2.0.dev15 → wizata_dsapi-2.2.0.dev16}/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.dev16}/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.dev16
 Summary: Wizata Data Science Toolkit
 Author: Wizata S.A.
 Author-email: info@wizata.com

wizata_dsapi-2.2.0.dev15/wizata_dsapi/version.py

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