wizata-dsapi 2.2.0.dev29__tar.gz → 2.2.0.dev30__tar.gz

{wizata_dsapi-2.2.0.dev29 → wizata_dsapi-2.2.0.dev30}/PKG-INFO

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

{wizata_dsapi-2.2.0.dev29 → wizata_dsapi-2.2.0.dev30}/wizata_dsapi/__init__.py

@@ -84,6 +84,7 @@ from .inventory import (InventoryBalance, InventoryStorage, InventoryStorageData
 from .planned_movement import (PlannedMovement, PlannedMovementSet, PLANNED_MOVEMENT_TYPES,
                                PLANNED_MOVEMENT_SNAPSHOT_TYPES, PLANNED_MOVEMENT_DATED_TYPES,
                                planned_movement_direction, is_dated_planned_movement)
+from .inventory_availability import InventoryAvailability, InventoryAvailabilityProduct, InventoryProjectionDay
 from .dashboard import Dashboard, DashboardType
 from .mobile_asset import MobileAssetTile, MobileAssetTileType, MobileAssetConfig
 from .graylog_log import GraylogLog

wizata_dsapi-2.2.0.dev30/wizata_dsapi/inventory_availability.py

@@ -0,0 +1,138 @@
+"""
+Production Planner availability (DEV-6137, epic DEV-6044, release 12.2).
+
+What a facility can still promise, per product, and how its stock is projected over the
+next days. Computed on read from the stock (balances + movements) and the planned
+movements (DEV-6136); nothing here is stored.
+
+- ``total``: stock under the facility, read at the moment of the last availability
+  snapshot written (``snapshot_as_of``), so the figures below hold at one moment and ATP
+  matches the source's.
+- ``allocated``, ``hold``, ``open_demand``: the snapshot's figures (``allocated``,
+  ``hold``, ``openDemand`` planned movements). Without a snapshot they come from the open
+  customer order lines (picked not shipped, ordered not picked) and ``from_snapshot`` is
+  False.
+- ``available`` = total - allocated - hold; ``atp`` = available - open demand.
+- ``dated``: the unpicked part of the open customer order lines, capped at the open
+  demand (lines are read more often than the snapshot); ``undated`` = open demand - dated,
+  due at once.
+- ``projection``: one entry per day of the horizon, the level at the end of the day =
+  available - undated - dated due by then + supply (open work and purchase orders) due by
+  then. ``net_requirement`` is the lowest level when it is below zero.
+"""
+
+from datetime import date, datetime
+from typing import Optional
+
+from .inventory import _ts_in, _ts_out, _uuid_str
+
+
+def _date_in(value):
+    if value is None or isinstance(value, date):
+        return value
+    return date.fromisoformat(str(value)[:10])
+
+
+class InventoryProjectionDay:
+    """The projected level at the end of ``day``, with what comes in and goes out that day."""
+
+    def __init__(self, day=None, incoming: float = None, outgoing: float = None, level: float = None):
+        self.day: Optional[date] = _date_in(day)
+        self.incoming = incoming
+        self.outgoing = outgoing
+        self.level = level
+
+    def to_dict(self) -> dict:
+        return {"date": self.day.isoformat() if self.day else None, "incoming": self.incoming,
+                "outgoing": self.outgoing, "level": self.level}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "InventoryProjectionDay":
+        return cls(day=data.get("date"), incoming=data.get("incoming"), outgoing=data.get("outgoing"),
+                   level=data.get("level"))
+
+
+class InventoryAvailabilityProduct:
+    """One product's availability at a facility, in ``unit`` (its stock total's unit)."""
+
+    def __init__(self, key: str = None, name: str = None, unit=None, unit_symbol: str = None):
+        self.key = key
+        self.name = name
+        self.unit: Optional[str] = _uuid_str(unit)
+        self.unit_symbol = unit_symbol
+        self.total: Optional[float] = None
+        self.allocated: Optional[float] = None
+        self.hold: Optional[float] = None
+        self.open_demand: Optional[float] = None
+        self.available: Optional[float] = None
+        self.atp: Optional[float] = None
+        self.dated: Optional[float] = None
+        self.undated: Optional[float] = None
+        self.demand_explained: Optional[float] = None
+        self.allocation_explained: Optional[float] = None
+        self.supply: Optional[float] = None
+        self.net_requirement: Optional[float] = None
+        self.lowest: Optional[InventoryProjectionDay] = None
+        self.projection: list = []
+        self.from_snapshot: bool = False
+
+    _NUMBERS = (("total", "total"), ("allocated", "allocated"), ("hold", "hold"), ("openDemand", "open_demand"),
+                ("available", "available"), ("atp", "atp"), ("dated", "dated"), ("undated", "undated"),
+                ("demandExplained", "demand_explained"), ("allocationExplained", "allocation_explained"),
+                ("supply", "supply"), ("netRequirement", "net_requirement"))
+
+    def to_dict(self) -> dict:
+        obj = {"product": self.key, "name": self.name, "unit": self.unit, "unitSymbol": self.unit_symbol}
+        for json_name, attr in self._NUMBERS:
+            obj[json_name] = getattr(self, attr)
+        obj["fromSnapshot"] = self.from_snapshot
+        obj["lowest"] = self.lowest.to_dict() if self.lowest is not None else None
+        obj["projection"] = [day.to_dict() for day in self.projection]
+        return obj
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "InventoryAvailabilityProduct":
+        obj = cls(key=data.get("product"), name=data.get("name"), unit=data.get("unit"),
+                  unit_symbol=data.get("unitSymbol"))
+        for json_name, attr in cls._NUMBERS:
+            setattr(obj, attr, data.get(json_name))
+        obj.from_snapshot = bool(data.get("fromSnapshot"))
+        obj.lowest = InventoryProjectionDay.from_dict(data["lowest"]) if data.get("lowest") else None
+        obj.projection = [InventoryProjectionDay.from_dict(d) for d in data.get("projection") or []]
+        return obj
+
+    def __repr__(self) -> str:
+        return (f"InventoryAvailabilityProduct({self.key!r}, total={self.total}, atp={self.atp}, "
+                f"net_requirement={self.net_requirement})")
+
+
+class InventoryAvailability:
+    """
+    Availability of a facility's products at ``as_of`` (DEV-6137). ``snapshot_as_of`` is the
+    moment of the last availability snapshot written at or before it (None without one):
+    the stock and the snapshot's figures are read there.
+    """
+
+    def __init__(self, facility: str = None, as_of=None, snapshot_as_of=None, horizon_days: int = None):
+        self.facility = facility
+        self.as_of: Optional[datetime] = _ts_in(as_of)
+        self.snapshot_as_of: Optional[datetime] = _ts_in(snapshot_as_of)
+        self.horizon_days = horizon_days
+        self.products: list = []
+
+    def product(self, key: str) -> Optional[InventoryAvailabilityProduct]:
+        return next((p for p in self.products if p.key == key), None)
+
+    def to_dict(self) -> dict:
+        return {"facility": self.facility,
+                "asOf": _ts_out(self.as_of) if isinstance(self.as_of, datetime) else self.as_of,
+                "snapshotAsOf": _ts_out(self.snapshot_as_of) if isinstance(self.snapshot_as_of, datetime)
+                else self.snapshot_as_of,
+                "horizonDays": self.horizon_days, "products": [p.to_dict() for p in self.products]}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "InventoryAvailability":
+        obj = cls(facility=data.get("facility"), as_of=data.get("asOf"), snapshot_as_of=data.get("snapshotAsOf"),
+                  horizon_days=data.get("horizonDays"))
+        obj.products = [InventoryAvailabilityProduct.from_dict(p) for p in data.get("products") or []]
+        return obj

wizata_dsapi-2.2.0.dev30/wizata_dsapi/version.py

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

{wizata_dsapi-2.2.0.dev29 → wizata_dsapi-2.2.0.dev30}/wizata_dsapi/wizata_dsapi_client.py

@@ -58,6 +58,7 @@ import ast
 from .deployment import Deployment, DeploymentStatus
 from .product import ProductKind, Product, ProductComponent
 from .inventory import InventoryBalance, InventoryStorage, InventoryStock, InventoryCount, InventoryHistory
+from .inventory_availability import InventoryAvailability
 from .planned_movement import PlannedMovement, PlannedMovementSet
 from .connection import EdgeDeviceKey
 from .edge_config import EdgeConfig
@@ -3233,6 +3234,38 @@ class WizataDSAPIClient(ApiInterface, ApiDtoInterface):
                                          expected=(200, 404))
         return response.json().get("deleted", 0) if response.status_code == 200 else 0
 
+    def get_inventory_availability(self, facility: str, as_of=None, products: list = None,
+                                   horizon_days: int = None, sources: list = None) -> InventoryAvailability:
+        """
+        What a facility can still promise per product, and its stock projected per day
+        (DEV-6137). The stock under the facility twin and its children and the figures of the
+        last availability snapshot (``allocated``, ``hold``, ``openDemand`` planned movements)
+        are read at that snapshot's moment (``snapshot_as_of``): available = total - allocated
+        - hold, ATP = available - open demand. The open customer order lines date the demand
+        (capped at the open demand; the rest is due at once) and the open work and purchase
+        orders come in when due. Without a snapshot, the lines give allocated and open demand.
+
+        :param facility: hardware id of the facility Twin.
+        :param as_of: datetime, ISO 8601, epoch ms or a relative ``now-1d``; default now.
+        :param products: product keys to keep.
+        :param horizon_days: days projected (UTC days, today first); default 14, at most 120.
+        :param sources: keep the planned movements of those sources.
+        """
+        body = {"facility": facility}
+        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 (("products", products), ("sources", sources)):
+            if value is not None:
+                body[name] = list(value)
+        if horizon_days is not None:
+            body["horizonDays"] = horizon_days
+        response = self._planner_request("POST", "planner/inventory/availability", body=body)
+        return InventoryAvailability.from_dict(response.json())
+
     # ------------------------------------------------------------ edge (DEV-6013/6014)
 
     @staticmethod

{wizata_dsapi-2.2.0.dev29 → wizata_dsapi-2.2.0.dev30}/wizata_dsapi.egg-info/PKG-INFO

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

{wizata_dsapi-2.2.0.dev29 → wizata_dsapi-2.2.0.dev30}/wizata_dsapi.egg-info/SOURCES.txt

@@ -33,6 +33,7 @@ wizata_dsapi/group_system.py
 wizata_dsapi/ilogger.py
 wizata_dsapi/insight.py
 wizata_dsapi/inventory.py
+wizata_dsapi/inventory_availability.py
 wizata_dsapi/mlmodel.py
 wizata_dsapi/mobile_asset.py
 wizata_dsapi/model_toolkit.py

wizata_dsapi-2.2.0.dev29/wizata_dsapi/version.py

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