wizata-dsapi 2.0.0.dev7__tar.gz → 2.0.0.dev9__tar.gz

{wizata_dsapi-2.0.0.dev7/wizata_dsapi.egg-info → wizata_dsapi-2.0.0.dev9}/PKG-INFO

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

{wizata_dsapi-2.0.0.dev7 → wizata_dsapi-2.0.0.dev9}/wizata_dsapi/__init__.py

@@ -52,5 +52,7 @@ from .streamlit_utils import (get_streamlit_token, get_streamlit_domain, get_str
 from .search import FilterOperator, SearchQuery, SortOption, GroupSearchQuery
 from .notification import NotificationScope, DeviceToken, AlertRule, AlertActive, MonitoredDatapoint
 from .edge_device import EdgeDevice, EdgeDeviceStatus, EdgeDeviceType
+from .edge_module import EdgeModule, EdgeModuleType, WIZATA_MODULES
 from .dashboard import Dashboard, DashboardType
-from .mobile_asset import MobileAssetTile, MobileAssetTileType, MobileAssetConfig
+from .mobile_asset import MobileAssetTile, MobileAssetTileType, MobileAssetConfig
+from .graylog_log import GraylogLog

{wizata_dsapi-2.0.0.dev7 → wizata_dsapi-2.0.0.dev9}/wizata_dsapi/edge_device.py

@@ -35,6 +35,8 @@ class EdgeDevice(ApiDto):
     :ivar EdgeDeviceStatus status: current status of the device.
     :ivar int status_code: numeric status code.
     :ivar EdgeDeviceType device_type: type of the edge device.
+    :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.
     """
 
     @classmethod
@@ -55,7 +57,9 @@ class EdgeDevice(ApiDto):
                  twin_id: uuid.UUID = None,
                  status: EdgeDeviceStatus = None,
                  status_code: int = None,
-                 device_type: EdgeDeviceType = None):
+                 device_type: EdgeDeviceType = None,
+                 connection_state: str = None,
+                 last_activity_time: str = None):
         if edge_device_id is None:
             self.edge_device_id = uuid.uuid4()
         else:
@@ -67,6 +71,8 @@ class EdgeDevice(ApiDto):
         self.status = status
         self.status_code = status_code
         self.device_type = device_type
+        self.connection_state = connection_state
+        self.last_activity_time = last_activity_time
 
     def api_id(self) -> str:
         return str(self.edge_device_id).upper()
@@ -97,6 +103,10 @@ class EdgeDevice(ApiDto):
             self.status_code = int(obj["statusCode"])
         if "deviceType" in obj and obj["deviceType"] is not None:
             self.device_type = EdgeDeviceType(obj["deviceType"])
+        if "connectionState" in obj and obj["connectionState"] is not None:
+            self.connection_state = obj["connectionState"]
+        if "lastActivityTime" in obj and obj["lastActivityTime"] is not None:
+            self.last_activity_time = obj["lastActivityTime"]
 
     def to_json(self, target: str = None):
         obj = {
@@ -116,4 +126,8 @@ class EdgeDevice(ApiDto):
             obj["statusCode"] = self.status_code
         if self.device_type is not None:
             obj["deviceType"] = self.device_type.value
+        if self.connection_state is not None:
+            obj["connectionState"] = self.connection_state
+        if self.last_activity_time is not None:
+            obj["lastActivityTime"] = self.last_activity_time
         return obj

wizata_dsapi-2.0.0.dev9/wizata_dsapi/edge_module.py

@@ -0,0 +1,115 @@
+from enum import Enum
+from .api_dto import Dto
+
+
+class EdgeModuleType(Enum):
+    """
+    Classification of an edge module.
+
+    WIZATA: modules developed and maintained by Wizata (configsync, message_client, pipeline_runner).
+    SYSTEM: IoT Edge runtime and third-party infrastructure (edgeAgent, edgeHub, influxdb, rabbitmq, loki, ...).
+    """
+    WIZATA = "wizata"
+    SYSTEM = "system"
+
+
+# Hardcoded registry of known Wizata modules.
+# Maps module_id to a human-readable description.
+WIZATA_MODULES = {
+    "configsync": "Configuration synchronization between cloud and edge",
+    "message_client": "Message client for edge-to-cloud telemetry",
+    "pipeline_runner": "Pipeline execution engine on edge",
+}
+
+
+def _extract_image_version(image: str) -> str:
+    """Extract the tag portion after ':' from a container image reference."""
+    if image and ":" in image:
+        return image.rsplit(":", 1)[1]
+    return None
+
+
+class EdgeModule(Dto):
+    """
+    Represents a module deployed on an IoT Edge device.
+
+    :ivar str module_id: module identifier (e.g. 'configsync', '$edgeAgent').
+    :ivar str runtime_status: runtime status from $edgeAgent reported twin (e.g. 'running', 'stopped').
+    :ivar int exit_code: last exit code of the module container.
+    :ivar str last_start_time: last container start time (UTC).
+    :ivar str last_exit_time: last container exit time (UTC).
+    :ivar str image: container image reference.
+    :ivar str image_version: tag extracted from image (e.g. 'p12-20260313.3'), only set for wizata modules.
+    :ivar str last_updated: when this module's status was last reported to IoT Hub (from $edgeAgent twin $metadata).
+    :ivar EdgeModuleType module_type: wizata or system classification.
+    """
+
+    def __init__(self,
+                 module_id: str = None,
+                 runtime_status: str = None,
+                 exit_code: int = None,
+                 last_start_time: str = None,
+                 last_exit_time: str = None,
+                 image: str = None,
+                 image_version: str = None,
+                 last_updated: str = None,
+                 module_type: EdgeModuleType = None):
+        self.module_id = module_id
+        self.runtime_status = runtime_status
+        self.exit_code = exit_code
+        self.last_start_time = last_start_time
+        self.last_exit_time = last_exit_time
+        self.image = image
+        self.last_updated = last_updated
+        if module_type is not None:
+            self.module_type = module_type
+        elif module_id is not None:
+            self.module_type = EdgeModuleType.WIZATA if module_id in WIZATA_MODULES else EdgeModuleType.SYSTEM
+        else:
+            self.module_type = None
+        # image_version: explicit value wins, otherwise extract for wizata modules only
+        if image_version is not None:
+            self.image_version = image_version
+        elif self.module_type == EdgeModuleType.WIZATA and image:
+            self.image_version = _extract_image_version(image)
+        else:
+            self.image_version = None
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "EdgeModule":
+        module_type = None
+        if "moduleType" in data and data["moduleType"] is not None:
+            module_type = EdgeModuleType(data["moduleType"])
+        return cls(
+            module_id=data.get("moduleId"),
+            runtime_status=data.get("runtimeStatus"),
+            exit_code=data.get("exitCode"),
+            last_start_time=data.get("lastStartTime"),
+            last_exit_time=data.get("lastExitTime"),
+            image=data.get("image"),
+            image_version=data.get("imageVersion"),
+            last_updated=data.get("lastUpdated"),
+            module_type=module_type,
+        )
+
+    def to_dict(self) -> dict:
+        obj = {}
+        if self.module_id is not None:
+            obj["moduleId"] = self.module_id
+        if self.runtime_status is not None:
+            obj["runtimeStatus"] = self.runtime_status
+        if self.exit_code is not None:
+            obj["exitCode"] = self.exit_code
+        if self.last_start_time is not None:
+            obj["lastStartTime"] = self.last_start_time
+        if self.last_exit_time is not None:
+            obj["lastExitTime"] = self.last_exit_time
+        if self.image is not None:
+            obj["image"] = self.image
+        if self.image_version is not None:
+            obj["imageVersion"] = self.image_version
+        if self.last_updated is not None:
+            obj["lastUpdated"] = self.last_updated
+        if self.module_type is not None:
+            obj["moduleType"] = self.module_type.value
+        return obj

wizata_dsapi-2.0.0.dev9/wizata_dsapi/graylog_log.py

@@ -0,0 +1,132 @@
+from typing import Optional
+from datetime import datetime, timezone
+
+
+class GraylogLog:
+    """
+    DTO for a single Graylog log entry.
+
+    Represents a log message from Graylog with standard GELF fields
+    plus Wizata custom fields (appId, edgeDeviceId, etc.).
+
+    Timestamps are always milliseconds (int) in serialized form.
+
+    :ivar int timestamp: event timestamp in milliseconds
+    :ivar str message: log message text
+    :ivar int level: syslog severity level (0=Emergency .. 7=Debug)
+    :ivar str source: source hostname
+    :ivar str app_id: application identifier
+    :ivar str edge_device_id: IoT Edge device identifier
+    :ivar str env: environment name
+    :ivar str tenant_id: tenant identifier
+    :ivar dict extra: any additional fields from the Graylog message
+    """
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "GraylogLog":
+        """
+        Deserialize a Graylog message dict into a GraylogLog.
+
+        Graylog returns timestamps as ISO 8601 strings — these are
+        converted to millisecond timestamps.
+
+        :param data: Graylog message dict (from API response message field).
+        """
+        timestamp = data.get("timestamp")
+        timestamp_ms = None
+        if timestamp is not None:
+            if isinstance(timestamp, (int, float)):
+                timestamp_ms = int(timestamp)
+            elif isinstance(timestamp, str):
+                timestamp_ms = cls._parse_graylog_timestamp(timestamp)
+
+        known_fields = {
+            "timestamp", "message", "level", "source",
+            "appId", "app_id",
+            "edgeDeviceId", "edge_device_id",
+            "env", "tenantId", "tenant_id",
+            "gl2_message_id", "gl2_remote_ip", "gl2_remote_port",
+            "gl2_source_input", "gl2_source_node",
+            "streams", "_id", "facility",
+        }
+        extra = {k: v for k, v in data.items() if k not in known_fields}
+
+        return cls(
+            timestamp=timestamp_ms,
+            message=data.get("message"),
+            level=int(data["level"]) if "level" in data and data["level"] is not None else None,
+            source=data.get("source"),
+            app_id=data.get("appId") or data.get("app_id"),
+            edge_device_id=data.get("edgeDeviceId") or data.get("edge_device_id"),
+            env=data.get("env"),
+            tenant_id=data.get("tenantId") or data.get("tenant_id"),
+            extra=extra if extra else None,
+        )
+
+    def __init__(self,
+                 timestamp: Optional[int] = None,
+                 message: Optional[str] = None,
+                 level: Optional[int] = None,
+                 source: Optional[str] = None,
+                 app_id: Optional[str] = None,
+                 edge_device_id: Optional[str] = None,
+                 env: Optional[str] = None,
+                 tenant_id: Optional[str] = None,
+                 extra: Optional[dict] = None):
+        self.timestamp = timestamp
+        self.message = message
+        self.level = level
+        self.source = source
+        self.app_id = app_id
+        self.edge_device_id = edge_device_id
+        self.env = env
+        self.tenant_id = tenant_id
+        self.extra = extra or {}
+
+    def to_dict(self) -> dict:
+        """
+        Serialize to a camelCase dict.
+        Timestamps are millisecond integers.
+        """
+        data = {}
+        if self.timestamp is not None:
+            data["timestamp"] = self.timestamp
+        if self.message is not None:
+            data["message"] = self.message
+        if self.level is not None:
+            data["level"] = self.level
+        if self.source is not None:
+            data["source"] = self.source
+        if self.app_id is not None:
+            data["appId"] = self.app_id
+        if self.edge_device_id is not None:
+            data["edgeDeviceId"] = self.edge_device_id
+        if self.env is not None:
+            data["env"] = self.env
+        if self.tenant_id is not None:
+            data["tenantId"] = self.tenant_id
+        if self.extra:
+            data.update(self.extra)
+        return data
+
+    @staticmethod
+    def _parse_graylog_timestamp(ts_str: str) -> Optional[int]:
+        """
+        Parse a Graylog ISO 8601 timestamp string to milliseconds.
+        Graylog format: '2024-01-15T10:30:00.123Z' or '2024-01-15 10:30:00.123'
+        """
+        formats = [
+            "%Y-%m-%dT%H:%M:%S.%fZ",
+            "%Y-%m-%dT%H:%M:%SZ",
+            "%Y-%m-%dT%H:%M:%S.%f",
+            "%Y-%m-%dT%H:%M:%S",
+            "%Y-%m-%d %H:%M:%S.%f",
+            "%Y-%m-%d %H:%M:%S",
+        ]
+        for fmt in formats:
+            try:
+                dt = datetime.strptime(ts_str, fmt).replace(tzinfo=timezone.utc)
+                return int(dt.timestamp() * 1000)
+            except ValueError:
+                continue
+        return None

wizata_dsapi-2.0.0.dev9/wizata_dsapi/version.py

@@ -0,0 +1 @@
+__version__ = "2.0.0.dev9"

{wizata_dsapi-2.0.0.dev7 → wizata_dsapi-2.0.0.dev9/wizata_dsapi.egg-info}/PKG-INFO

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

{wizata_dsapi-2.0.0.dev7 → wizata_dsapi-2.0.0.dev9}/wizata_dsapi.egg-info/SOURCES.txt

@@ -15,10 +15,12 @@ wizata_dsapi/datastore.py
 wizata_dsapi/ds_dataframe.py
 wizata_dsapi/dsapi_json_encoder.py
 wizata_dsapi/edge_device.py
+wizata_dsapi/edge_module.py
 wizata_dsapi/evaluation.py
 wizata_dsapi/execution.py
 wizata_dsapi/execution_log.py
 wizata_dsapi/experiment.py
+wizata_dsapi/graylog_log.py
 wizata_dsapi/group_system.py
 wizata_dsapi/ilogger.py
 wizata_dsapi/insight.py

wizata_dsapi-2.0.0.dev7/wizata_dsapi/version.py

@@ -1 +0,0 @@
-__version__ = "2.0.0.dev7"