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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wizata_dsapi
-Version: 2.2.0.dev29
+Version: 2.2.0.dev31
 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.dev31}/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.dev29 → wizata_dsapi-2.2.0.dev31}/wizata_dsapi/connection.py

@@ -79,6 +79,9 @@ class Connection:
         # read-only summaries a search adds: [ConnectionChannel], without their rows
         self.readers: Optional[list] = None
         self.writers: Optional[list] = None
+        # read-only, set by ConnectionClient.mark_in_use (DEV-6165): whether its device runs
+        # it. False for an Edge store kept on a device that left Connectivity + Pipelines.
+        self.in_use: Optional[bool] = None
 
     @property
     def system(self) -> bool:
@@ -113,6 +116,8 @@ class Connection:
         if self.edge_device_id is not None:
             obj["edgeDeviceId"] = self.edge_device_id
         obj["system"] = self.system
+        if self.in_use is not None:
+            obj["inUse"] = self.in_use
         obj["config"] = dict(self.config or {})
         if include_secrets:
             obj["secrets"] = dict(self.secrets or {})
@@ -180,6 +185,10 @@ class ConnectionChannel:
     - ``signals``: on create only, the policy rows to write with it (read back from search).
     - ``signal_count`` / ``mapped_count``: read-only, how many rows and how many name a
       datapoint.
+    - ``received`` / ``dropped`` / ``last_seen`` / ``in_sync``: read-only, a reader's summary
+      of its seen names (DEV-6163): names received, dropped under the stored policy, the
+      newest time any was seen, and whether the edge runs the stored policy (None until it
+      has reported).
     """
 
     def __init__(self):
@@ -196,6 +205,10 @@ class ConnectionChannel:
         self.signals: Optional[list] = None
         self.signal_count: Optional[int] = None
         self.mapped_count: Optional[int] = None
+        self.received: Optional[int] = None
+        self.dropped: Optional[int] = None
+        self.last_seen: Optional[datetime] = None
+        self.in_sync: Optional[bool] = None
         self.created_at: Optional[datetime] = None
         self.updated_at: Optional[datetime] = None
 
@@ -226,6 +239,14 @@ class ConnectionChannel:
             obj["signalCount"] = self.signal_count
         if self.mapped_count is not None:
             obj["mappedCount"] = self.mapped_count
+        if self.received is not None:
+            obj["received"] = self.received
+        if self.dropped is not None:
+            obj["dropped"] = self.dropped
+        if self.last_seen is not None:
+            obj["lastSeen"] = _ts_out(self.last_seen)
+        if self.in_sync is not None:
+            obj["inSync"] = self.in_sync
         if self.created_at is not None:
             obj["createdAt"] = _ts_out(self.created_at)
         if self.updated_at is not None:
@@ -291,6 +312,9 @@ class ConnectionSignal:
       node, the name written). In a ``list`` policy a row with no ``tag`` lets the
       datapoint through.
     - A row with both always renames, whatever the mode.
+    - ``datapoint`` / ``status`` / ``last_received``: read-only, what a search with
+      ``include`` adds (DEV-6164): the datapoint the row produces, what becomes of it under
+      the device's cloud and edge writers, and when a reader last received its name.
     """
 
     def __init__(self, tag: str = None, hardware_id: str = None):
@@ -300,6 +324,9 @@ class ConnectionSignal:
         self.hardware_id: Optional[str] = hardware_id
         self.created_at: Optional[datetime] = None
         self.updated_at: Optional[datetime] = None
+        self.datapoint: Optional[str] = None
+        self.status: Optional[str] = None
+        self.last_received: Optional[datetime] = None
 
     def to_dict(self) -> dict:
         obj = {}
@@ -309,6 +336,12 @@ class ConnectionSignal:
             obj["channelId"] = str(self.channel_id)
         obj["tag"] = self.tag
         obj["hardwareId"] = self.hardware_id
+        if self.datapoint is not None:
+            obj["datapoint"] = self.datapoint
+        if self.status is not None:
+            obj["status"] = self.status
+        if self.last_received is not None:
+            obj["lastReceived"] = _ts_out(self.last_received)
         if self.created_at is not None:
             obj["createdAt"] = _ts_out(self.created_at)
         if self.updated_at is not None:

{wizata_dsapi-2.2.0.dev29 → wizata_dsapi-2.2.0.dev31}/wizata_dsapi/connection_types.py

@@ -126,6 +126,19 @@ class ConnectionType:
     def directions(self) -> list:
         return ([_READ] if self.reader else []) + ([_WRITE] if self.writer else [])
 
+    def exists_on(self, device_type) -> bool:
+        """
+        Whether a device of ``device_type`` runs a connection of this type (DEV-6165). A type
+        that lists ``device_types`` exists on those only: the Edge store is kept on a device
+        that leaves Connectivity + Pipelines, but not rendered. The render and the payload's
+        ``inUse`` both read this.
+
+        :param device_type: an ``EdgeDeviceType`` or its value; None (unknown) counts as every type.
+        """
+        if not self.device_types or device_type is None:
+            return True
+        return getattr(device_type, "value", device_type) in self.device_types
+
     def channel(self, direction) -> Optional[ChannelType]:
         direction = getattr(direction, "value", direction)
         return self.reader if direction == _READ else self.writer if direction == _WRITE else None

wizata_dsapi-2.2.0.dev31/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.dev31/wizata_dsapi/version.py

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

{wizata_dsapi-2.2.0.dev29 → wizata_dsapi-2.2.0.dev31}/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.dev31}/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.dev31
 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.dev31}/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"