wizata-dsapi 1.2.7__tar.gz → 1.2.10__tar.gz

{wizata_dsapi-1.2.7 → wizata_dsapi-1.2.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wizata_dsapi
-Version: 1.2.7
+Version: 1.2.10
 Summary: Wizata Data Science Toolkit
 Author: Wizata S.A.
 Author-email: info@wizata.com

{wizata_dsapi-1.2.7 → wizata_dsapi-1.2.10}/wizata_dsapi/__init__.py

@@ -4,7 +4,7 @@ from .api_dto import ApiDto, VarType
 from .paged_query_result import PagedQueryResult
 from .plot import Plot
 from .mlmodel import MLModel, MLModelConfig
-from .request import Request, filter_map, RequestGroup, RequestGroupMap
+from .request import Request, filter_map, RequestGroup, RequestGroupMap, DynamicSelector
 from .execution import Execution, ExecutionStatus, ExecutionStepLog, AbortedException
 from .experiment import Experiment
 from .ds_dataframe import DSDataFrame

{wizata_dsapi-1.2.7 → wizata_dsapi-1.2.10}/wizata_dsapi/request.py

@@ -15,6 +15,35 @@ filter_map = {
     '!=': 'neq'
 }
 
+class DynamicSelector:
+    """
+    A dynamic selector defines how datapoint(s) are fetched within a query.
+        - it corresponds to a request to fetch datapoints
+        - it must be used on a twin base query
+    :ivar category: filter datapoints on uuid of a category or str name.
+    """
+
+    def __init__(self, category = None):
+        self.category = category
+
+    @classmethod
+    def from_dict(cls, obj):
+        dynamic_selector = cls()
+        dynamic_selector.from_json(obj)
+        return dynamic_selector
+
+    def from_json(self, obj):
+        if not isinstance(obj, dict):
+            raise TypeError('dynamic selector to parse is not a dict.')
+        if "category" in obj:
+            self.category = obj["category"]
+
+    def to_json(self) -> dict:
+        obj = {}
+        if self.category:
+            obj["category"] = self.category
+        return obj
+
 class RequestGroup:
     """
     Define a group statement within a structured query.
@@ -140,10 +169,9 @@ class Request(ApiDto):
         self.request_id = request_id
         self.function = None
 
-        # Equipments & Data Points
-        self.equipments = []
-        if datapoints is not None:
-            self.add_datapoints(datapoints)
+        # Datapoints
+        self._datapoints = []
+        self.datapoints = datapoints
 
         # Template & Registration
         self.template = None
@@ -293,63 +321,6 @@ class Request(ApiDto):
         else:
             return
 
-    def prepare(self):
-        """
-        prepare analyse the query and produce a dict with query information.
-        :return: dict
-        """
-        query = {}
-        if self.request_id is not None:
-            query["id"] = str(self.request_id)
-        if self.equipments is not None:
-            query["equipments_list"] = self.equipments
-        else:
-            raise KeyError("Missing data points inside the query - add_datapoints")
-        if self.start is not None and self.end is not None:
-
-            if isinstance(self.start, str):
-                start = self.start
-            else:
-                start = self.__format_date(self.start)
-
-            if isinstance(self.end, str):
-                end = self.end
-            else:
-                end = self.__format_date(self.end)
-
-            query["timeframe"] = {
-                "start": start,
-                "end": end
-            }
-        else:
-            if self.group is None:
-                raise KeyError("missing in query start and end date, "
-                               "please use datatime format or try with a group system")
-        query["aggregations"] = {
-            "agg_method": self.aggregation
-        }
-        if self.interval:
-            query["aggregations"]["interval"] = self.interval * 1000
-        if self.null is not None and self.null != 'drop':
-            query['null'] = self.null
-        if self.template is not None:
-            query['template'] = self.template
-            if isinstance(self.template, dict) and 'template_id' in query['template']:
-                query['template']['template_id'] = str(query['template']['template_id'])
-        if self.filters is not None:
-            query['filters'] = self.filters
-        if self.group is not None:
-            query['group'] = self.group
-        if self.options is not None:
-            query['options'] = self.options
-        if self.field is not None:
-            query['field'] = self.field
-        if self.bucket is not None:
-            query['bucket'] = self.bucket
-        if self.tags is not None:
-            query['tags'] = self.tags
-        return query
-
     def __format_date(self, dt_to_format):
         if isinstance(dt_to_format, datetime):
             millisec = dt_to_format.timestamp() * 1000
@@ -387,79 +358,42 @@ class Request(ApiDto):
         else:
             raise TypeError(f'unsupported end datetime type {self.end.__class__.__name__}')
 
-    def add_datapoints(self, datapoints, shift: int = 0):
-        """
-        add datapoints to existing list of datapoints in the query.
-        :param datapoints:  datapoints to fetch identified by hardware id or template property name.
-        :param shift: shift to apply in seconds on timestamp, by default 0.
-        """
-        self.equipments.append({
-            "id": None,
-            "datapoints": list(datapoints),
-            "shift": str(shift) + "s"
-        })
+    @property
+    def datapoints(self):
+        return self._datapoints
+
+    @datapoints.setter
+    def datapoints(self, values):
+        self._datapoints = []
+        if values:
+            if not isinstance(values, list):
+                raise ValueError(f'datapoints on a query must be a list of str, dict or DynamicSelector')
+            for value in values:
+                if isinstance(value, str):
+                    self._datapoints.append(value)
+                elif isinstance(value, dict):
+                    self._datapoints.append(DynamicSelector.from_dict(value))
+                elif isinstance(value, DynamicSelector):
+                    self._datapoints.append(value)
+                else:
+                    raise TypeError(f'datapoints on a query must be a list of str, dict or DynamicSelector '
+                                    f'but encountered {type(value)} as {value}')
 
-    def get_datapoints(self) -> list:
-        """
-        get datapoints
-        :return: list of declared datapoints.
-        """
+    @property
+    def datapoints_without_selectors(self):
         datapoints = []
-
-        if self.equipments is not None:
-            for equipment in self.equipments:
-                if "datapoints" not in equipment.keys():
-                    raise KeyError("No 'data points' have been provided for equipment with id '" +
-                                   str(equipment["id"]) + "'")
-                for datapoint in equipment["datapoints"]:
-                    if isinstance(datapoint, str):
-                        datapoints.append(datapoint)
-                    elif "id" in datapoint.keys():
-                        datapoints.append(datapoint["id"])
-                    else:
-                        raise KeyError("Incorrect datapoint declaration : '" + str(datapoint) + "'")
-
+        for datapoint in self._datapoints:
+            if not isinstance(datapoint, DynamicSelector):
+                datapoints.append(datapoint)
         return datapoints
 
-    def set_datapoints(self, datapoints: list):
-        """
-        replace current datapoints by provided list
-        """
-        self.equipments = []
-        if datapoints is not None:
-            self.add_datapoints(datapoints)
-
-    def add_equipment(self, equipment_id: uuid.UUID, datapoints, shift=0):
-        """
-        add datapoints to fetch with a digital twin id identification.
-        :param equipment_id: UUID of the Digital Twin ID to which the datapoints are linked.
-        :param datapoints: List(str) of datapoints to fetch identified by Hardware ID.
-        :param shift: Shift to apply in seconds on timestamp, by default 0.
-        """
-        if not isinstance(equipment_id, uuid.UUID):
-            raise TypeError("equipment_id must be of type uuid.UUID")
-        for equipment in self.equipments:
-            if "id" in equipment.keys() and equipment["id"] == str(equipment_id):
-                raise ValueError("equipment_id is already in the request please remove it before adding datapoints.")
-        self.equipments.append({
-            "id": str(equipment_id),
-            "datapoints": list(datapoints),
-            "shift": str(shift) + "s"
-        })
-
-    def remove_equipment(self, equipment_id: uuid.UUID):
-        """
-        remove equipment from the list including all its listed datapoints.
-        :param equipment_id: UUID of the Digital Twin item.
-        """
-        if equipment_id is not None and not isinstance(equipment_id, uuid.UUID):
-            raise TypeError("equipment_id must be None or of type uuid.UUID")
-        found = None
-        for equipment in self.equipments:
-            if "id" in equipment.keys() and equipment["id"] == str(equipment_id):
-                found = equipment
-        if found is not None:
-            self.equipments.remove(equipment)
+    @property
+    def datapoints_only_selectors(self):
+        datapoints = []
+        for datapoint in self._datapoints:
+            if isinstance(datapoint, DynamicSelector):
+                datapoints.append(datapoint)
+        return datapoints
 
     def set_aggregation(self, method, interval=None):
         """
@@ -555,9 +489,87 @@ class Request(ApiDto):
             raise KeyError(f'parameter {name} not found in request.')
 
     def to_json(self, target: str = None):
-        obj = self.prepare()
-        self.set_extra_data(obj)
-        return obj
+        query = {}
+
+        if self.request_id is not None:
+            query["id"] = str(self.request_id)
+
+        datapoints = []
+        for datapoint in self.datapoints:
+            if isinstance(datapoint, str):
+                datapoints.append(datapoint)
+            elif isinstance(datapoint, dict):
+                datapoints.append(datapoint)
+            elif isinstance(datapoint, DynamicSelector):
+                datapoints.append(datapoint.to_json())
+            else:
+                raise TypeError(f'datapoints on a query must be a list of str, dict or DynamicSelector '
+                                f'but encountered {type(datapoint)} as {datapoint}')
+        query["datapoints"] = datapoints
+
+        if self.start is not None and self.end is not None:
+
+            if isinstance(self.start, str):
+                start = self.start
+            else:
+                start = self.__format_date(self.start)
+
+            if isinstance(self.end, str):
+                end = self.end
+            else:
+                end = self.__format_date(self.end)
+
+            query["timeframe"] = {
+                "start": start,
+                "end": end
+            }
+        else:
+            if self.group is None:
+                raise KeyError("missing in query start and end date, "
+                               "please use datatime format or try with a group system")
+        query["aggregations"] = {
+            "agg_method": self.aggregation
+        }
+        if self.interval:
+            query["aggregations"]["interval"] = self.interval * 1000
+        if self.null is not None and self.null != 'drop':
+            query['null'] = self.null
+        if self.template is not None:
+            query['template'] = self.template
+            if isinstance(self.template, dict) and 'template_id' in query['template']:
+                query['template']['template_id'] = str(query['template']['template_id'])
+        if self.filters is not None:
+            query['filters'] = self.filters
+        if self.group is not None:
+            query['group'] = self.group
+        if self.options is not None:
+            query['options'] = self.options
+        if self.field is not None:
+            query['field'] = self.field
+        if self.bucket is not None:
+            query['bucket'] = self.bucket
+        if self.tags is not None:
+            query['tags'] = self.tags
+
+        if self.target_feat is not None:
+            query["target_feat"] = {
+                "sensor": self.target_feat["sensor"],
+                "operator": self.target_feat["operator"],
+                "threshold": self.target_feat["threshold"]
+            }
+        if self.on_off_sensor is not None and self.restart_time is not None:
+            query["restart_filter"] = {
+                "on_off_sensor": self.on_off_sensor,
+                "stop_restart_time": self.restart_time
+            }
+
+        if self.sensitivity is not None:
+            query["sensitivity"] = self.sensitivity
+
+        if self.extra_data is not None:
+            query["extra_data"] = self.extra_data
+
+        return query
 
     def from_json(self, json_data):
         if "id" in json_data.keys():
@@ -566,28 +578,27 @@ class Request(ApiDto):
         if "name" in json_data.keys():
             self.name = json_data["name"]
 
-        found_dps = False
+        datapoints = []
         if "equipments_list" in json_data.keys():
-            self.equipments = json_data["equipments_list"]
-            for equipment in self.equipments:
+            for equipment in json_data["equipments_list"]:
                 if "datapoints" not in equipment.keys():
-                    raise KeyError("No 'data points' have been provided for equipment with id '" +
+                    raise KeyError("no 'datapoints' have been provided for equipment with id '" +
                                    str(equipment["id"]) + "'")
-                else:
-                    found_dps = True
-        elif "datapoints" in json_data.keys():
-            equipment = {"datapoints": []}
-            for datapoint in json_data["datapoints"]:
-                equipment["datapoints"].append(datapoint)
-            self.equipments.append(equipment)
-            found_dps = True
+                datapoints.extend(equipment["datapoints"])
+
+        if "datapoints" in json_data.keys():
+            datapoints.extend(["datapoints"])
 
         if "template" in json_data.keys():
             self.template = json_data["template"]
-            found_dps = True
 
-        if not found_dps:
-            raise KeyError('no equipments_list datapoints, nor template specified inside the request.')
+        if len(datapoints) == 0 and self.template is None:
+            raise KeyError('at least one datapoint or template is required within a request')
+
+        if len(datapoints) >= 0:
+            self.datapoints = datapoints
+        else:
+            self._datapoints = []
 
         if "timeframe" in json_data.keys():
             if "start" not in json_data["timeframe"].keys():
@@ -682,28 +693,4 @@ class Request(ApiDto):
         if "extra_data" in json_data.keys():
             self.extra_data = json_data["extra_data"]
 
-    def set_extra_data(self, obj) -> dict:
-        """
-        deprecated - set additional data to query used as post-processing
-        """
-        if obj is None:
-            obj = {}
-        if self.target_feat is not None:
-            obj["target_feat"] = {
-                "sensor": self.target_feat["sensor"],
-                "operator": self.target_feat["operator"],
-                "threshold": self.target_feat["threshold"]
-            }
-        if self.on_off_sensor is not None and self.restart_time is not None:
-            obj["restart_filter"] = {
-                "on_off_sensor": self.on_off_sensor,
-                "stop_restart_time": self.restart_time
-            }
-
-        if self.sensitivity is not None:
-            obj["sensitivity"] = self.sensitivity
-
-        if self.extra_data is not None:
-            obj["extra_data"] = self.extra_data
-        return obj
 

{wizata_dsapi-1.2.7 → wizata_dsapi-1.2.10}/wizata_dsapi/twin.py

@@ -2,6 +2,7 @@ import uuid
 from .api_dto import ApiDto
 from enum import Enum
 import re
+import json
 
 
 def is_valid_hex_color(color):
@@ -149,7 +150,9 @@ class Twin(ApiDto):
     def __init__(self, twin_id=None, hardware_id=None, name=None, parent_id=None, ttype=TwinBlockType.MACHINE,
                  type_id:uuid.UUID = None,
                  latitude_id: uuid.UUID = None, longitude_id: uuid.UUID = None, color: str = None, icon: str = None,
-                 latitude: float = None, longitude: float = None, description: str = None):
+                 latitude: float = None, longitude: float = None,
+                 extra_properties: dict = None,
+                 description: str = None):
         if twin_id is None:
             self.twin_id = uuid.uuid4()
         else:
@@ -168,6 +171,7 @@ class Twin(ApiDto):
             is_valid_hex_color(color)
         self.color = color
         self.icon = icon
+        self.extra_properties = extra_properties
         self.createdById = None
         self.createdDate = None
         self.updatedById = None
@@ -207,6 +211,11 @@ class Twin(ApiDto):
             self.description = str(obj["description"])
         if "type" in obj.keys():
             self.type = TwinBlockType(str(obj["type"]))
+        if "extraProperties" in obj.keys():
+            if isinstance(obj["extraProperties"], str):
+                self.extra_properties = json.loads(obj["extraProperties"])
+            else:
+                self.extra_properties = obj["extraProperties"]
         if "createdById" in obj.keys() and obj["createdById"] is not None:
             self.createdById = obj["createdById"]
         if "createdDate" in obj.keys() and obj["createdDate"] is not None:
@@ -244,6 +253,10 @@ class Twin(ApiDto):
             obj["longitudeSensorId"] = str(self.longitude_id)
         if self.icon is not None:
             obj["icon"] = str(self.icon)
+        if self.extra_properties is not None:
+            if not isinstance(self.extra_properties, dict):
+                raise ValueError('on twin extra properties must be None or a JSON serializable dict')
+            obj["extraProperties"] = json.dumps(self.extra_properties)
         if self.createdById is not None:
             obj["createdById"] = str(self.createdById)
         if self.createdDate is not None:

wizata_dsapi-1.2.10/wizata_dsapi/version.py

@@ -0,0 +1 @@
+__version__ = "1.2.10"

{wizata_dsapi-1.2.7 → wizata_dsapi-1.2.10}/wizata_dsapi.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: wizata-dsapi
-Version: 1.2.7
+Version: 1.2.10
 Summary: Wizata Data Science Toolkit
 Author: Wizata S.A.
 Author-email: info@wizata.com

wizata_dsapi-1.2.7/wizata_dsapi/version.py

@@ -1 +0,0 @@
-__version__ = "1.2.7"