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

{wizata_dsapi-2.2.0.dev7 → wizata_dsapi-2.2.0.dev9}/PKG-INFO

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

{wizata_dsapi-2.2.0.dev7 → wizata_dsapi-2.2.0.dev9}/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,6 +146,9 @@ 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
 

{wizata_dsapi-2.2.0.dev7 → wizata_dsapi-2.2.0.dev9}/wizata_dsapi/product.py

@@ -7,7 +7,9 @@ ProductKind — what role a product plays: raw material, container, finished pro
 
 Product — something the plant consumes or makes, identified by a Wizata key
   (e.g. ``can_33_coke``). ``category`` is a backend category id (Volume, Count, ...):
-  it says how a quantity of that product is expressed.
+  it says how a quantity of that product is expressed. ``unit`` (optional, DEV-6087) is
+  its default unit, a backend unit id of that category, used for stock totals across
+  storages; ``unit_symbol`` is filled on read only.
 
 ProductComponent — one line of a product's bill of materials: ``product`` is made of
   ``quantity`` ``unit`` of ``composed_of``. The unit is a backend unit id and must
@@ -120,12 +122,14 @@ class Product:
         return "planner/products"
 
     def __init__(self, key: str = None, name: str = None, category=None,
-                 kind: str = None, description: str = None):
+                 kind: str = None, description: str = None, unit=None):
         self.key: Optional[str] = key
         self.name: Optional[str] = name
         self.category: Optional[str] = _uuid_str(category)
         self.kind: Optional[str] = kind
         self.description: Optional[str] = description
+        self.unit: Optional[str] = _uuid_str(unit)
+        self.unit_symbol: Optional[str] = None
         self.created_at: Optional[datetime] = None
         self.updated_at: Optional[datetime] = None
 
@@ -141,6 +145,10 @@ class Product:
             obj["kind"] = self.kind
         if self.description is not None:
             obj["description"] = self.description
+        if self.unit is not None:
+            obj["unit"] = self.unit
+        if self.unit_symbol is not None:
+            obj["unitSymbol"] = self.unit_symbol
         if self.created_at is not None:
             obj["createdAt"] = _ts_out(self.created_at)
         if self.updated_at is not None:
@@ -155,6 +163,8 @@ class Product:
         obj.category = _uuid_str(data.get("category"))
         obj.kind = data.get("kind")
         obj.description = data.get("description")
+        obj.unit = _uuid_str(data.get("unit"))
+        obj.unit_symbol = data.get("unitSymbol") or data.get("unit_symbol")
         obj.created_at = _ts_in(data.get("createdAt") or data.get("created_at"))
         obj.updated_at = _ts_in(data.get("updatedAt") or data.get("updated_at"))
         return obj

wizata_dsapi-2.2.0.dev9/wizata_dsapi/version.py

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

{wizata_dsapi-2.2.0.dev7 → wizata_dsapi-2.2.0.dev9}/wizata_dsapi/wizata_dsapi_client.py

@@ -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,40 @@ 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):
+    @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.dev7 → wizata_dsapi-2.2.0.dev9}/wizata_dsapi.egg-info/PKG-INFO

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

wizata_dsapi-2.2.0.dev7/wizata_dsapi/version.py

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