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

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

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

{wizata_dsapi-2.2.0.dev17 → 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.dev17 → wizata_dsapi-2.2.0.dev19}/wizata_dsapi/edge_device.py

@@ -9,6 +9,7 @@ class EdgeDeviceStatus(Enum):
     """
     WAITING_FOR_REGISTRATION = "WaitingForRegistration"
     REGISTERED = "Registered"
+    DEPLOYING = "Deploying"
     DEPLOYED = "Deployed"
     FAILED = "Failed"
     OFFLINE = "Offline"
@@ -35,25 +36,41 @@ class EdgeDevice(ApiDto):
     """
     Edge device registered on the platform.
 
-    :ivar uuid.UUID edge_device_id: technical id of the edge device.
-    :ivar str device_id: logical device identifier string.
+    The device id is its only identifier (DEV-6101): the name it runs as (its IoT Hub
+    device id), and what connections, keys and deployment targets refer to.
+
+    :ivar str device_id: the device identifier.
     :ivar str name: display name of the edge device.
     :ivar str twin_name: name of the associated twin.
     :ivar uuid.UUID twin_id: technical id of the associated twin.
     :ivar EdgeDeviceStatus status: current status of the device.
-    :ivar int status_code: numeric status code.
+    :ivar int status_code: last ``$edgeAgent`` ``lastDesiredStatus.code`` read (417, 200, 406...).
     :ivar EdgeDeviceType device_type: type of the edge device.
     :ivar EdgeDeviceProvisioning provisioning: how the device is installed.
     :ivar int created_at: creation time, epoch ms (the PostgreSQL registry, DEV-6015).
     :ivar int updated_at: last update time, epoch ms.
     :ivar str connection_state: IoT Hub connection state ('Connected' or 'Disconnected'), enriched from IoT Hub.
     :ivar str last_activity_time: last device activity timestamp from IoT Hub.
+    :ivar str applied_hash: digest of the manifest the platform last applied (DEV-6101).
+    :ivar int applied_version: ``$edgeAgent`` desired ``$version`` that apply produced.
+    :ivar int applied_at: when it was applied, epoch ms.
+    :ivar dict image_overrides: module -> image, winning over the release's images.
+    :ivar str runner_python_version: Python version of the edge's pipeline runner.
+    :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
     def route(cls):
         return "edgedevices"
 
+    @classmethod
+    def get_id_type(cls) -> type:
+        """The device id (a string) is the edge's only identifier (DEV-6101)."""
+        return str
+
     @classmethod
     def from_dict(cls, data):
         obj = EdgeDevice()
@@ -61,7 +78,6 @@ class EdgeDevice(ApiDto):
         return obj
 
     def __init__(self,
-                 edge_device_id: uuid.UUID = None,
                  device_id: str = None,
                  name: str = None,
                  twin_name: str = None,
@@ -73,11 +89,16 @@ class EdgeDevice(ApiDto):
                  last_activity_time: str = None,
                  provisioning: EdgeDeviceProvisioning = None,
                  created_at: int = None,
-                 updated_at: int = None):
-        if edge_device_id is None:
-            self.edge_device_id = uuid.uuid4()
-        else:
-            self.edge_device_id = edge_device_id
+                 updated_at: int = None,
+                 applied_hash: str = None,
+                 applied_version: int = None,
+                 applied_at: int = None,
+                 image_overrides: dict = None,
+                 runner_python_version: str = None,
+                 managed: bool = None,
+                 applied_modules: dict = None,
+                 reconcile_error: str = None,
+                 last_seen_at: int = None):
         self.device_id = device_id
         self.name = name
         self.twin_name = twin_name
@@ -90,22 +111,29 @@ class EdgeDevice(ApiDto):
         self.provisioning = provisioning
         self.created_at = created_at
         self.updated_at = updated_at
+        self.applied_hash = applied_hash
+        self.applied_version = applied_version
+        self.applied_at = applied_at
+        self.image_overrides = image_overrides
+        self.runner_python_version = runner_python_version
+        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 str(self.edge_device_id).upper()
+        return self.device_id
 
     def api_key(self) -> str:
         return self.device_id
 
     def set_id(self, id_value):
-        self.edge_device_id = uuid.UUID(str(id_value))
+        self.device_id = str(id_value)
 
     def endpoint(self) -> str:
         return "EdgeDevices"
 
     def from_json(self, obj):
-        if "id" in obj and obj["id"] is not None:
-            self.edge_device_id = uuid.UUID(obj["id"])
         if "deviceId" in obj and obj["deviceId"] is not None:
             self.device_id = obj["deviceId"]
         if "name" in obj and obj["name"] is not None:
@@ -130,11 +158,29 @@ class EdgeDevice(ApiDto):
             self.created_at = int(obj["createdAt"])
         if "updatedAt" in obj and obj["updatedAt"] is not None:
             self.updated_at = int(obj["updatedAt"])
+        if "appliedHash" in obj and obj["appliedHash"] is not None:
+            self.applied_hash = obj["appliedHash"]
+        if "appliedVersion" in obj and obj["appliedVersion"] is not None:
+            self.applied_version = int(obj["appliedVersion"])
+        if "appliedAt" in obj and obj["appliedAt"] is not None:
+            self.applied_at = int(obj["appliedAt"])
+        if "imageOverrides" in obj and obj["imageOverrides"] is not None:
+            if not isinstance(obj["imageOverrides"], dict):
+                raise ValueError("imageOverrides must be an object: module -> image")
+            self.image_overrides = dict(obj["imageOverrides"])
+        if "runnerPythonVersion" in obj and obj["runnerPythonVersion"] is not None:
+            self.runner_python_version = str(obj["runnerPythonVersion"])
+        if "managed" in obj and obj["managed"] is not None:
+            self.managed = bool(obj["managed"])
+        if "appliedModules" in obj and obj["appliedModules"] is not None:
+            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 = {
-            "id": str(self.edge_device_id)
-        }
+        obj = {}
         if self.device_id is not None:
             obj["deviceId"] = self.device_id
         if self.name is not None:
@@ -159,4 +205,21 @@ class EdgeDevice(ApiDto):
             obj["createdAt"] = self.created_at
         if self.updated_at is not None:
             obj["updatedAt"] = self.updated_at
-        return obj
+        if self.applied_hash is not None:
+            obj["appliedHash"] = self.applied_hash
+        if self.applied_version is not None:
+            obj["appliedVersion"] = self.applied_version
+        if self.applied_at is not None:
+            obj["appliedAt"] = self.applied_at
+        if self.image_overrides is not None:
+            obj["imageOverrides"] = self.image_overrides
+        if self.runner_python_version is not None:
+            obj["runnerPythonVersion"] = self.runner_python_version
+        obj["managed"] = bool(self.managed)
+        if self.applied_modules is not None:
+            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.dev17 → wizata_dsapi-2.2.0.dev19}/wizata_dsapi/wizata_dsapi_client.py

@@ -446,7 +446,7 @@ class WizataDSAPIClient(ApiInterface, ApiDtoInterface):
                 return self._query(request=obj)
             else:
                 dto_class = self._get_class(entity=type(obj), operation=operation)
-                if dto_class == PipelineImage:
+                if dto_class == PipelineImage or dto_class.get_id_type() == str:
                     id = obj.api_id()
                 else:
                     id = uuid.UUID(obj.api_id())
@@ -582,6 +582,8 @@ class WizataDSAPIClient(ApiInterface, ApiDtoInterface):
             if dto_class.get_id_type() == int:
                 obj.set_id(response.json()["id"])
                 return response.json()["id"]
+            elif dto_class.get_id_type() == str:
+                return obj.api_id()
             else:
                 return uuid.UUID(obj.api_id())
 
@@ -3002,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)
@@ -3078,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.dev17 → 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.dev17
+Version: 2.2.0.dev19
 Summary: Wizata Data Science Toolkit
 Author: Wizata S.A.
 Author-email: info@wizata.com

{wizata_dsapi-2.2.0.dev17 → 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.dev17/wizata_dsapi/version.py

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