wizata-dsapi 2.2.0.dev8__tar.gz → 2.2.0.dev10__tar.gz

{wizata_dsapi-2.2.0.dev8 → wizata_dsapi-2.2.0.dev10}/PKG-INFO

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

{wizata_dsapi-2.2.0.dev8 → wizata_dsapi-2.2.0.dev10}/wizata_dsapi/__init__.py

@@ -66,7 +66,7 @@ from .connection import Connection, ConnectionMapping, ConnectionDirection, Tran
 from .connection_types import ConnectionType, CONNECTION_TYPES, TRANSFORM_SCHEMAS, get_connection_type, \
     list_connection_types
 from .product import ProductKind, Product, ProductComponent, BUILTIN_PRODUCT_KINDS, is_valid_product_key
-from .inventory import (InventoryBalance, inventory_mode, INVENTORY_OPTION, INVENTORY_MODES,
+from .inventory import (InventoryBalance, InventoryStorage, InventoryStorageDatapoint, inventory_mode, INVENTORY_OPTION, INVENTORY_MODES,
                         INVENTORY_MOVEMENTS, INVENTORY_BALANCES, INVENTORY_STOCK,
                         PRODUCT_TAG, PRODUCT_MESSAGE_KEY)
 from .dashboard import Dashboard, DashboardType

{wizata_dsapi-2.2.0.dev8 → wizata_dsapi-2.2.0.dev10}/wizata_dsapi/inventory.py

@@ -83,8 +83,9 @@ class InventoryBalance:
     DataPoint ``datapoint`` (a hardware id), true at ``timestamp`` (when it was
     counted, not when it was recorded: that is ``created_at``).
 
-    PostgreSQL ``"InventoryBalance"``, PK (``datapoint``, ``product``, ``timestamp``).
-    Writing the same key again replaces the quantity.
+    PostgreSQL ``"InventoryBalance"``, PK ``id`` (DEV-6085); (``datapoint``, ``product``,
+    ``timestamp``) is unique, and writing the same key again replaces the quantity.
+    ``count`` is the key shared by every balance written in one call (one count).
 
     On write only:
 
@@ -99,7 +100,9 @@ class InventoryBalance:
         return "planner/inventory/balances"
 
     def __init__(self, datapoint: str = None, product: str = None, timestamp=None,
-                 quantity: float = None, unit=None, twin: str = None):
+                 quantity: float = None, unit=None, twin: str = None, balance_id=None, count=None):
+        self.id: Optional[str] = _uuid_str(balance_id)
+        self.count: Optional[str] = _uuid_str(count)
         self.datapoint: Optional[str] = datapoint
         self.product: Optional[str] = product
         self.timestamp: Optional[datetime] = _ts_in(timestamp)
@@ -113,7 +116,8 @@ class InventoryBalance:
 
     def to_dict(self) -> dict:
         obj = {}
-        for name, value in (("datapoint", self.datapoint), ("product", self.product),
+        for name, value in (("id", self.id), ("count", self.count),
+                            ("datapoint", self.datapoint), ("product", self.product),
                             ("quantity", self.quantity), ("unit", self.unit),
                             ("twin", self.twin), ("createdBy", self.created_by),
                             ("updatedBy", self.updated_by)):
@@ -128,6 +132,8 @@ class InventoryBalance:
     @classmethod
     def from_dict(cls, data: dict) -> "InventoryBalance":
         obj = cls()
+        obj.id = _uuid_str(data.get("id"))
+        obj.count = _uuid_str(data.get("count"))
         obj.datapoint = data.get("datapoint")
         obj.product = data.get("product")
         obj.timestamp = _ts_in(data.get("timestamp"))
@@ -140,9 +146,61 @@ class InventoryBalance:
         obj.updated_by = data.get("updatedBy") or data.get("updated_by")
         return obj
 
+    def api_id(self) -> str:
+        return self.id
+
     def key(self) -> tuple:
         return self.datapoint, self.product, self.timestamp
 
     def __repr__(self) -> str:
         return (f"InventoryBalance(datapoint={self.datapoint!r}, product={self.product!r}, "
                 f"timestamp={self.timestamp!r}, quantity={self.quantity!r})")
+
+
+class InventoryStorageDatapoint:
+    """One inventoryMovement DataPoint of a storage: its category and unit (DEV-6086)."""
+
+    def __init__(self, hardware_id: str = None, name: str = None, category=None, unit=None,
+                 unit_symbol: str = None):
+        self.hardware_id: Optional[str] = hardware_id
+        self.name: Optional[str] = name
+        self.category: Optional[str] = _uuid_str(category)
+        self.unit: Optional[str] = _uuid_str(unit)
+        self.unit_symbol: Optional[str] = unit_symbol
+
+    def to_dict(self) -> dict:
+        return {"hardwareId": self.hardware_id, "name": self.name, "category": self.category,
+                "unit": self.unit, "unitSymbol": self.unit_symbol}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "InventoryStorageDatapoint":
+        return cls(hardware_id=data.get("hardwareId") or data.get("hardware_id"), name=data.get("name"),
+                   category=data.get("category"), unit=data.get("unit"),
+                   unit_symbol=data.get("unitSymbol") or data.get("unit_symbol"))
+
+
+class InventoryStorage:
+    """
+    A storage place: a Twin holding at least one inventoryMovement DataPoint (DEV-6086).
+    Read only, from ``POST /dsapi/planner/inventory/storages/search``.
+    """
+
+    def __init__(self, twin_id=None, twin_hardware_id: str = None, twin_name: str = None,
+                 datapoints: list = None):
+        self.twin_id: Optional[str] = _uuid_str(twin_id)
+        self.twin_hardware_id: Optional[str] = twin_hardware_id
+        self.twin_name: Optional[str] = twin_name
+        self.datapoints: list = list(datapoints or [])
+
+    def to_dict(self) -> dict:
+        return {"twin": {"id": self.twin_id, "hardwareId": self.twin_hardware_id, "name": self.twin_name},
+                "datapoints": [d.to_dict() for d in self.datapoints]}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "InventoryStorage":
+        twin = data.get("twin") or {}
+        return cls(twin_id=twin.get("id"), twin_hardware_id=twin.get("hardwareId"), twin_name=twin.get("name"),
+                   datapoints=[InventoryStorageDatapoint.from_dict(d) for d in data.get("datapoints") or []])
+
+    def __repr__(self) -> str:
+        return f"InventoryStorage({self.twin_hardware_id!r}, {[d.hardware_id for d in self.datapoints]})"

wizata_dsapi-2.2.0.dev10/wizata_dsapi/version.py

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

{wizata_dsapi-2.2.0.dev8 → wizata_dsapi-2.2.0.dev10}/wizata_dsapi/wizata_dsapi_client.py

@@ -55,7 +55,7 @@ from .version import __version__
 import ast
 from .deployment import Deployment, DeploymentStatus
 from .product import ProductKind, Product, ProductComponent
-from .inventory import InventoryBalance
+from .inventory import InventoryBalance, InventoryStorage
 from .api_config import _registry
 
 from .streamlit_utils import get_streamlit_token, get_streamlit_domain
@@ -2886,7 +2886,8 @@ class WizataDSAPIClient(ApiInterface, ApiDtoInterface):
             inventoryMovement DataPoint by ``datapoint``, or by ``twin`` (the DataPoint
             of the product's category on that Twin). ``unit`` converts the quantity to
             the DataPoint's unit.
-        :return: the stored balances, quantities in the DataPoint's unit.
+        :return: the stored balances, quantities in the DataPoint's unit, each with its
+            ``id`` and the ``count`` key the call created.
         """
         body = [b.to_dict() if isinstance(b, InventoryBalance) else b for b in balances]
         response = self._planner_request("POST", "planner/inventory/balances/", body=body)
@@ -2896,8 +2897,8 @@ class WizataDSAPIClient(ApiInterface, ApiDtoInterface):
         """
         List recorded balances, newest first by default.
 
-        :param search_query: SearchQuery or dict; filters on ``datapoint`` and
-            ``product`` (eq / in) and ``timestamp`` (gte / gt / lt / lte).
+        :param search_query: SearchQuery or dict; filters on ``datapoint``, ``product``,
+            ``twin``, ``count``, ``id`` (eq / in) and ``timestamp`` (eq / gte / gt / lt / lte).
         :return: PagedQueryResult with InventoryBalance results.
         """
         if search_query is None:
@@ -2908,19 +2909,57 @@ class WizataDSAPIClient(ApiInterface, ApiDtoInterface):
                                          body=search_query.to_dict())
         return PagedQueryResult.from_dict(response.json(), dto_class=InventoryBalance)
 
-    def delete_inventory_balance(self, datapoint: str, product: str, timestamp):
+    def search_inventory_storages(self, search_query=None) -> PagedQueryResult:
+        """
+        The storage places: Twins holding an inventoryMovement DataPoint, each with those
+        datapoints' category, unit and unit symbol (DEV-6086).
+
+        :param search_query: SearchQuery or dict; filters ``twin`` (hardware id or id) and
+            ``category`` (eq / in), ``_search`` (``{"query": text}`` on names and hardware ids).
+        :return: PagedQueryResult with InventoryStorage results, sorted by twin name.
+        """
+        if search_query is None:
+            search_query = SearchQuery()
+        elif isinstance(search_query, dict):
+            search_query = SearchQuery.from_dict(search_query)
+        response = self._planner_request("POST", "planner/inventory/storages/search",
+                                         body=search_query.to_dict())
+        return PagedQueryResult.from_dict(response.json(), dto_class=InventoryStorage)
+
+    @staticmethod
+    def _balance_id(value) -> str:
+        balance_id = value.id if isinstance(value, InventoryBalance) else value
+        if not balance_id:
+            raise ValueError("please provide a balance or its id")
+        return urllib.parse.quote(str(balance_id), safe="")
+
+    def get_inventory_balance(self, balance_id):
+        """
+        :param balance_id: the balance's id.
+        :return: InventoryBalance, or None when it does not exist.
+        """
+        response = self._planner_request("GET", f"planner/inventory/balances/{self._balance_id(balance_id)}/",
+                                         expected=(200, 404))
+        return InventoryBalance.from_dict(response.json()) if response.status_code == 200 else None
+
+    def update_inventory_balance(self, balance: InventoryBalance) -> InventoryBalance:
+        """
+        Change one balance's quantity and/or time (its datapoint and product never change).
+        ``unit`` converts the quantity to the datapoint's unit. 409 when another balance
+        already holds the new time.
+        """
+        body = {k: v for k, v in balance.to_dict().items() if k in ("quantity", "timestamp", "unit")}
+        response = self._planner_request("PUT", f"planner/inventory/balances/{self._balance_id(balance)}/",
+                                         body=body)
+        return InventoryBalance.from_dict(response.json())
+
+    def delete_inventory_balance(self, balance):
         """
         Delete one recorded balance (a count entered by mistake).
 
-        :param timestamp: datetime or ISO string, exactly as stored.
+        :param balance: InventoryBalance or its id.
         """
-        if isinstance(timestamp, datetime.datetime):
-            if timestamp.tzinfo is None:
-                timestamp = timestamp.replace(tzinfo=datetime.timezone.utc)
-            timestamp = timestamp.isoformat()
-        self._planner_request("DELETE", "planner/inventory/balances/",
-                              params={"datapoint": datapoint, "product": product,
-                                      "timestamp": timestamp},
+        self._planner_request("DELETE", f"planner/inventory/balances/{self._balance_id(balance)}/",
                               expected=(204,))
 
 

{wizata_dsapi-2.2.0.dev8 → wizata_dsapi-2.2.0.dev10}/wizata_dsapi.egg-info/PKG-INFO

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

wizata_dsapi-2.2.0.dev8/wizata_dsapi/version.py

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