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

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

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

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

@@ -66,7 +66,8 @@ 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, InventoryStorage, InventoryStorageDatapoint, inventory_mode, INVENTORY_OPTION, INVENTORY_MODES,
+from .inventory import (InventoryBalance, InventoryStorage, InventoryStorageDatapoint, inventory_mode,
+                        InventoryStock, InventoryStockProduct, InventoryStockLine, InventoryStockCount, 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.dev10 → wizata_dsapi-2.2.0.dev12}/wizata_dsapi/inventory.py

@@ -204,3 +204,110 @@ class InventoryStorage:
 
     def __repr__(self) -> str:
         return f"InventoryStorage({self.twin_hardware_id!r}, {[d.hardware_id for d in self.datapoints]})"
+
+
+class InventoryStockCount:
+    """The last count behind a stock line: the balance it starts from (DEV-6088)."""
+
+    def __init__(self, balance_id=None, count=None, timestamp=None, quantity: float = None, by: str = None):
+        self.id: Optional[str] = _uuid_str(balance_id)
+        self.count: Optional[str] = _uuid_str(count)
+        self.timestamp: Optional[datetime] = _ts_in(timestamp)
+        self.quantity: Optional[float] = quantity
+        self.by: Optional[str] = by
+
+    def to_dict(self) -> dict:
+        return {"id": self.id, "count": self.count,
+                "timestamp": _ts_out(self.timestamp) if isinstance(self.timestamp, datetime) else self.timestamp,
+                "quantity": self.quantity, "by": self.by}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "InventoryStockCount":
+        return cls(balance_id=data.get("id"), count=data.get("count"), timestamp=data.get("timestamp"),
+                   quantity=data.get("quantity"), by=data.get("by"))
+
+
+class InventoryStockLine:
+    """
+    One product on one storage datapoint at a moment: ``quantity`` in the datapoint's unit,
+    ``last_count`` (None when never counted) and ``moved_since`` it (DEV-6088).
+    """
+
+    def __init__(self, twin_id=None, twin_hardware_id: str = None, twin_name: str = None, datapoint: str = None,
+                 unit=None, unit_symbol: str = None, quantity: float = None, moved_since: float = None,
+                 last_count: InventoryStockCount = 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.datapoint: Optional[str] = datapoint
+        self.unit: Optional[str] = _uuid_str(unit)
+        self.unit_symbol: Optional[str] = unit_symbol
+        self.quantity: Optional[float] = quantity
+        self.moved_since: Optional[float] = moved_since
+        self.last_count: Optional[InventoryStockCount] = last_count
+
+    def to_dict(self) -> dict:
+        return {"twin": {"id": self.twin_id, "hardwareId": self.twin_hardware_id, "name": self.twin_name},
+                "datapoint": self.datapoint, "unit": self.unit, "unitSymbol": self.unit_symbol,
+                "quantity": self.quantity, "movedSince": self.moved_since,
+                "lastCount": self.last_count.to_dict() if self.last_count is not None else None}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "InventoryStockLine":
+        twin = data.get("twin") or {}
+        last = data.get("lastCount")
+        return cls(twin_id=twin.get("id"), twin_hardware_id=twin.get("hardwareId"), twin_name=twin.get("name"),
+                   datapoint=data.get("datapoint"), unit=data.get("unit"), unit_symbol=data.get("unitSymbol"),
+                   quantity=data.get("quantity"), moved_since=data.get("movedSince"),
+                   last_count=InventoryStockCount.from_dict(last) if last else None)
+
+
+class InventoryStockProduct:
+    """
+    A product's stock at a moment: one line per storage holding it, and a ``total`` in
+    ``total_unit``: the product's default unit, else the unit most of its storages use
+    (DEV-6088). ``total`` is None when a line's unit cannot be converted.
+    """
+
+    def __init__(self, key: str = None, name: str = None, kind: str = None, category=None, unit=None,
+                 unit_symbol: str = None, total: float = None, total_unit=None, total_unit_symbol: str = None,
+                 storages: list = None):
+        self.key: Optional[str] = key
+        self.name: Optional[str] = name
+        self.kind: Optional[str] = kind
+        self.category: Optional[str] = _uuid_str(category)
+        self.unit: Optional[str] = _uuid_str(unit)
+        self.unit_symbol: Optional[str] = unit_symbol
+        self.total: Optional[float] = total
+        self.total_unit: Optional[str] = _uuid_str(total_unit)
+        self.total_unit_symbol: Optional[str] = total_unit_symbol
+        self.storages: list = list(storages or [])
+
+    def to_dict(self) -> dict:
+        return {"key": self.key, "name": self.name, "kind": self.kind, "category": self.category,
+                "unit": self.unit, "unitSymbol": self.unit_symbol, "total": self.total,
+                "totalUnit": self.total_unit, "totalUnitSymbol": self.total_unit_symbol,
+                "storages": [s.to_dict() for s in self.storages]}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "InventoryStockProduct":
+        return cls(key=data.get("key"), name=data.get("name"), kind=data.get("kind"), category=data.get("category"),
+                   unit=data.get("unit"), unit_symbol=data.get("unitSymbol"), total=data.get("total"),
+                   total_unit=data.get("totalUnit"), total_unit_symbol=data.get("totalUnitSymbol"),
+                   storages=[InventoryStockLine.from_dict(s) for s in data.get("storages") or []])
+
+
+class InventoryStock:
+    """Stock of every product × storage at ``as_of`` (``POST /dsapi/planner/inventory/stock``, DEV-6088)."""
+
+    def __init__(self, as_of=None, products: list = None):
+        self.as_of: Optional[datetime] = _ts_in(as_of)
+        self.products: list = list(products or [])
+
+    def to_dict(self) -> dict:
+        return {"asOf": _ts_out(self.as_of) if isinstance(self.as_of, datetime) else self.as_of,
+                "products": [p.to_dict() for p in self.products]}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "InventoryStock":
+        return cls(as_of=data.get("asOf"), products=[InventoryStockProduct.from_dict(p) for p in data.get("products") or []])

{wizata_dsapi-2.2.0.dev10 → wizata_dsapi-2.2.0.dev12}/wizata_dsapi/request.py

@@ -165,7 +165,9 @@ class Request(ApiDto):
     :ivar dict filters: filters to apply to the query pre-aggregation. nested dictionary using as first key=datapoint then value=another dictionary with key=operator (gt,lt,gte,lte,eq,neq) and value is the float value to compare too).
     :ivar dict options: dict representing query options.
     :ivar list scopes: scope filters for SCOPED datapoints.
-    :ivar list products: product keys to keep on inventoryMovement datapoints (all when None).
+    :ivar list products: product keys to keep on inventoryMovement datapoints (all when None). With
+        no datapoints, it selects the inventoryMovement datapoints holding them (under the twin
+        when the request names one).
     """
 
     @classmethod

wizata_dsapi-2.2.0.dev12/wizata_dsapi/version.py

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

{wizata_dsapi-2.2.0.dev10 → wizata_dsapi-2.2.0.dev12}/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, InventoryStorage
+from .inventory import InventoryBalance, InventoryStorage, InventoryStock
 from .api_config import _registry
 
 from .streamlit_utils import get_streamlit_token, get_streamlit_domain
@@ -872,6 +872,8 @@ class WizataDSAPIClient(ApiInterface, ApiDtoInterface):
         :param scopes: list of scope filters for SCOPED datapoints (e.g. ["normal", {"vibration": {"gte": 0.6}}]).
         :param products: product keys to keep on inventoryMovement datapoints (all when None).
             ``options={"inventory": "movements" | "balances" | "stock"}`` chooses what they return.
+            With no ``datapoints``, the inventoryMovement datapoints holding those products are
+            selected for you: every storage, or those under ``twin`` and its children (DEV-6089).
         :return: dataframe
         """
         return self._query(request=self._build_request(
@@ -2909,6 +2911,31 @@ class WizataDSAPIClient(ApiInterface, ApiDtoInterface):
                                          body=search_query.to_dict())
         return PagedQueryResult.from_dict(response.json(), dto_class=InventoryBalance)
 
+    def get_inventory_stock(self, as_of=None, twins: list = None, products: list = None,
+                            kinds: list = None) -> InventoryStock:
+        """
+        Stock of every product × storage at a moment (DEV-6088): per storage datapoint the
+        quantity in its unit, the last count and what moved since; per product a total in
+        its default unit (else the unit most of its storages use).
+
+        :param as_of: datetime or ISO string; default now. Events at that moment count.
+        :param twins: storage twins (hardware ids or ids) to keep.
+        :param products: product keys to keep.
+        :param kinds: product kind keys to keep.
+        """
+        body = {}
+        if as_of is not None:
+            if isinstance(as_of, datetime.datetime):
+                if as_of.tzinfo is None:
+                    as_of = as_of.replace(tzinfo=datetime.timezone.utc)
+                as_of = as_of.isoformat()
+            body["asOf"] = as_of
+        for name, value in (("twins", twins), ("products", products), ("kinds", kinds)):
+            if value is not None:
+                body[name] = list(value)
+        response = self._planner_request("POST", "planner/inventory/stock", body=body)
+        return InventoryStock.from_dict(response.json())
+
     def search_inventory_storages(self, search_query=None) -> PagedQueryResult:
         """
         The storage places: Twins holding an inventoryMovement DataPoint, each with those

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

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

wizata_dsapi-2.2.0.dev10/wizata_dsapi/version.py

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