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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wizata_dsapi
-Version: 2.2.0.dev18
+Version: 2.2.0.dev20
 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.dev20}/wizata_dsapi/__init__.py

@@ -5,6 +5,8 @@ from .paged_query_result import PagedQueryResult
 from .plot import Plot
 from .mlmodel import ModelInfo, ModelList, MLModelConfig, ModelFile, ModelIdentifierInfo
 from .request import Request, filter_map, RequestGroup, RequestGroupMap, DynamicSelector
+from .formula import (FormulaError, apply_formulas, evaluate_formula, normalize_formulas, check_result_name,
+                      formula_catalog, FORMULA_OPERATORS, FORMULA_FUNCTIONS, FORMULA_CONSTANTS)
 from .execution import Execution, ExecutionStatus, ExecutionStepLog, AbortedException
 from .execution_log import ExecutionLog
 from .experiment import Experiment
@@ -45,7 +47,8 @@ from .wizard_function import WizardStep, WizardFunction
 from .wizard_request import WizardRequest
 
 # Pipeline Entities (Dto)
-from .pipeline import Pipeline, PipelineStep, StepType, WriteConfig, AlertConfig, PipelineIO, RunnerStatus, AlertType
+from .pipeline import Pipeline, PipelineStep, StepType, WriteConfig, AlertConfig, FormulaConfig, PipelineIO, RunnerStatus, \
+    AlertType
 from .context import Context
 from .ilogger import ILogger
 from .pipeline_image import PipelineImage
@@ -61,6 +64,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.dev20}/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.dev20/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}