wizata-dsapi 2.2.0.dev18__tar.gz → 2.2.0.dev19__tar.gz

{wizata_dsapi-2.2.0.dev18 → wizata_dsapi-2.2.0.dev19}/PKG-INFO

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

{wizata_dsapi-2.2.0.dev18 → wizata_dsapi-2.2.0.dev19}/wizata_dsapi/__init__.py

@@ -61,6 +61,7 @@ from .notification import NotificationScope, DeviceToken, AlertRule, AlertActive
 from .edge_device import EdgeDevice, EdgeDeviceStatus, EdgeDeviceType, EdgeDeviceProvisioning
 from .edge_module import EdgeModule, EdgeModuleType, WIZATA_MODULES
 from .edge_config import EdgeConsumer, EdgeWriter, EdgeTrigger, EdgeFile, EdgeConfig, EdgeCommand
+from .edge_package import EdgePackage, EdgePackageOperation, EdgeRelease
 from .connection import Connection, ConnectionMapping, ConnectionDirection, TransformKind, \
     EdgeDeviceKey, EdgeDeviceKeyStatus
 from .connection_types import ConnectionType, CONNECTION_TYPES, TRANSFORM_SCHEMAS, get_connection_type, \

{wizata_dsapi-2.2.0.dev18 → wizata_dsapi-2.2.0.dev19}/wizata_dsapi/edge_device.py

@@ -59,6 +59,7 @@ class EdgeDevice(ApiDto):
     :ivar bool managed: the platform keeps this device's manifest ("deploy modules").
     :ivar dict applied_modules: what was last applied: module -> {image, env names}.
     :ivar str reconcile_error: why the last apply failed, until one succeeds.
+    :ivar int last_seen_at: last heartbeat of a manual edge, epoch ms (DEV-6109).
     """
 
     @classmethod
@@ -96,7 +97,8 @@ class EdgeDevice(ApiDto):
                  runner_python_version: str = None,
                  managed: bool = None,
                  applied_modules: dict = None,
-                 reconcile_error: str = None):
+                 reconcile_error: str = None,
+                 last_seen_at: int = None):
         self.device_id = device_id
         self.name = name
         self.twin_name = twin_name
@@ -117,6 +119,7 @@ class EdgeDevice(ApiDto):
         self.managed = managed
         self.applied_modules = applied_modules
         self.reconcile_error = reconcile_error
+        self.last_seen_at = last_seen_at
 
     def api_id(self) -> str:
         return self.device_id
@@ -173,6 +176,8 @@ class EdgeDevice(ApiDto):
             self.applied_modules = obj["appliedModules"]
         if "reconcileError" in obj and obj["reconcileError"] is not None:
             self.reconcile_error = obj["reconcileError"]
+        if "lastSeenAt" in obj and obj["lastSeenAt"] is not None:
+            self.last_seen_at = int(obj["lastSeenAt"])
 
     def to_json(self, target: str = None):
         obj = {}
@@ -215,4 +220,6 @@ class EdgeDevice(ApiDto):
             obj["appliedModules"] = self.applied_modules
         if self.reconcile_error is not None:
             obj["reconcileError"] = self.reconcile_error
+        if self.last_seen_at is not None:
+            obj["lastSeenAt"] = self.last_seen_at
         return obj

wizata_dsapi-2.2.0.dev19/wizata_dsapi/edge_package.py

@@ -0,0 +1,128 @@
+from enum import Enum
+
+from .api_dto import Dto
+
+
+class EdgePackageOperation(Enum):
+    """
+    What a package for a manual edge does (DEV-6109). A manual edge serves a validated
+    (21 CFR Part 11) site: the platform never changes it, the site's operator runs each
+    package as a procedure.
+
+    - ``pipeline``: the pipelines it runs — triggers.json and the pipeline images;
+    - ``platform``: the platform version — docker-compose.yml, the module settings and
+      the profile files of a release;
+    - ``full``: everything, for the first install or any other change (connections,
+      writers, functions).
+    """
+    PIPELINE = "pipeline"
+    PLATFORM = "platform"
+    FULL = "full"
+
+
+class EdgeRelease(Dto):
+    """
+    The edge images of a release, as Wizata.Jobs publishes them (DEV-6109).
+
+    ``edge_images.json`` in Wizata.Jobs stays where they are pinned. The Jobs consumer
+    writes them here at its start, so the DS API can compose a manual edge's platform
+    package with the images the environment runs.
+
+    :ivar str id: digest of the images: the same images are the same release.
+    :ivar str version: what published them, e.g. ``wizata-packages 2.2.0``.
+    :ivar dict images: module -> image; ``pipeline_runner`` maps a Python version to one.
+    :ivar int published_at: when last published, epoch ms.
+    """
+
+    def __init__(self, id=None, version=None, images=None, published_at=None):
+        self.id = id
+        self.version = version
+        self.images = images
+        self.published_at = published_at
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "EdgeRelease":
+        return cls(id=data.get("id"), version=data.get("version"), images=data.get("images"),
+                   published_at=data.get("publishedAt"))
+
+    def to_dict(self) -> dict:
+        return {"id": self.id, "version": self.version, "images": self.images,
+                "publishedAt": self.published_at}
+
+
+class EdgePackage(Dto):
+    """
+    A procedure composed for a manual edge, and its record (DEV-6109): what it contains,
+    who generated and downloaded it, and when the edge reported it applied.
+
+    The package itself holds secrets (the module settings) and is never stored: it is
+    rendered again at each download, and refused if its contents changed since it was
+    generated. The record holds names and digests only.
+
+    :ivar str id: package id (UUID). The edge reports it once installed.
+    :ivar str edge_device_id: the device it is for.
+    :ivar EdgePackageOperation operation: pipeline, platform or full.
+    :ivar int sequence: 1, 2, 3... per device.
+    :ivar str release_id: the ``EdgeRelease`` its module images come from (platform, full).
+    :ivar str contents_hash: digest of the contents, secrets excluded.
+    :ivar dict contents: ``files`` (path -> sha256), ``settings`` (module -> variable
+        names), ``modules`` (module -> image), ``images`` (pipeline image ids),
+        ``warnings``.
+    :ivar dict diff: against what the edge runs (its applied packages): added, changed
+        and removed files, pipeline images, module images.
+    :ivar list procedure: the steps, each ``{"title", "command"}``.
+    :ivar str generated_by: who generated it.
+    :ivar int generated_at: epoch ms.
+    :ivar list downloads: each ``{"by", "at"}``.
+    :ivar int applied_at: when it was first reported installed, epoch ms.
+    :ivar str applied_by: ``edge`` (its heartbeat), or the admin who confirmed it for an
+        edge that cannot reach the platform.
+    """
+
+    def __init__(self, id=None, edge_device_id=None, operation=None, sequence=None,
+                 release_id=None, contents_hash=None, contents=None, diff=None, procedure=None,
+                 generated_by=None, generated_at=None, downloads=None, applied_at=None,
+                 applied_by=None):
+        self.id = id
+        self.edge_device_id = edge_device_id
+        self.operation = operation
+        self.sequence = sequence
+        self.release_id = release_id
+        self.contents_hash = contents_hash
+        self.contents = contents
+        self.diff = diff
+        self.procedure = procedure
+        self.generated_by = generated_by
+        self.generated_at = generated_at
+        self.downloads = downloads
+        self.applied_at = applied_at
+        self.applied_by = applied_by
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "EdgePackage":
+        operation = data.get("operation")
+        return cls(id=data.get("id"), edge_device_id=data.get("edgeDeviceId"),
+                   operation=EdgePackageOperation(operation) if operation else None,
+                   sequence=data.get("sequence"), release_id=data.get("releaseId"),
+                   contents_hash=data.get("contentsHash"), contents=data.get("contents"),
+                   diff=data.get("diff"), procedure=data.get("procedure"),
+                   generated_by=data.get("generatedBy"), generated_at=data.get("generatedAt"),
+                   downloads=data.get("downloads"), applied_at=data.get("appliedAt"),
+                   applied_by=data.get("appliedBy"))
+
+    def to_dict(self) -> dict:
+        return {"id": self.id, "edgeDeviceId": self.edge_device_id,
+                "operation": self.operation.value if self.operation else None,
+                "sequence": self.sequence, "releaseId": self.release_id,
+                "contentsHash": self.contents_hash, "contents": self.contents,
+                "diff": self.diff, "procedure": self.procedure,
+                "generatedBy": self.generated_by, "generatedAt": self.generated_at,
+                "downloads": self.downloads or [], "appliedAt": self.applied_at,
+                "appliedBy": self.applied_by}
+
+    def marker(self) -> dict:
+        """What the package installs as ``conf/_packages/<id>.json`` and the edge reports."""
+        return {"id": self.id, "edgeDeviceId": self.edge_device_id,
+                "operation": self.operation.value if self.operation else None,
+                "sequence": self.sequence, "releaseId": self.release_id,
+                "contentsHash": self.contents_hash}

wizata_dsapi-2.2.0.dev19/wizata_dsapi/version.py

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

{wizata_dsapi-2.2.0.dev18 → wizata_dsapi-2.2.0.dev19}/wizata_dsapi/wizata_dsapi_client.py

@@ -3004,13 +3004,14 @@ class WizataDSAPIClient(ApiInterface, ApiDtoInterface):
         return "edge/" + "/".join(quoted)
 
     def _edge_request(self, method: str, route: str, body=None, headers=None,
-                      expected=(200,), stream=False):
+                      expected=(200,), stream=False, timeout=None):
         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,
+            timeout=timeout,
         )
         if response.status_code not in expected:
             raise self.__raise_error(response)
@@ -3080,6 +3081,21 @@ class WizataDSAPIClient(ApiInterface, ApiDtoInterface):
                 os.remove(temporary)
         return path
 
+    def send_edge_heartbeat(self, edge_device_id: str, packages: list = None,
+                            timeout=(5, 15)) -> dict:
+        """
+        A manual edge's heartbeat (DEV-6109): it is alive, and these packages (the ids in
+        its ``conf/_packages``) are installed. The platform records when it was seen, and
+        each package as installed the first time it is listed.
+
+        :param timeout: (connect, read) seconds — a site that blocks outbound traffic must
+            not hold the caller.
+        :return: ``{"lastSeenAt", "applied": [ids newly recorded], "unknown": [ids]}``.
+        """
+        response = self._edge_request("POST", self._edge_route(edge_device_id, "heartbeat"),
+                                      body={"packages": list(packages or [])}, timeout=timeout)
+        return response.json()
+
 
 def api() -> WizataDSAPIClient:
     """

{wizata_dsapi-2.2.0.dev18 → wizata_dsapi-2.2.0.dev19}/wizata_dsapi.egg-info/PKG-INFO

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

{wizata_dsapi-2.2.0.dev18 → wizata_dsapi-2.2.0.dev19}/wizata_dsapi.egg-info/SOURCES.txt

@@ -20,6 +20,7 @@ wizata_dsapi/dsapi_json_encoder.py
 wizata_dsapi/edge_config.py
 wizata_dsapi/edge_device.py
 wizata_dsapi/edge_module.py
+wizata_dsapi/edge_package.py
 wizata_dsapi/evaluation.py
 wizata_dsapi/execution.py
 wizata_dsapi/execution_log.py

wizata_dsapi-2.2.0.dev18/wizata_dsapi/version.py

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