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

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

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

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

@@ -81,6 +81,9 @@ from .inventory import (InventoryBalance, InventoryStorage, InventoryStorageData
                         InventoryHistoryEvent, HISTORY_MOVEMENT, HISTORY_COUNT, round_quantity,
                         INVENTORY_MOVEMENTS, INVENTORY_BALANCES, INVENTORY_STOCK,
                         PRODUCT_TAG, PRODUCT_MESSAGE_KEY)
+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 .dashboard import Dashboard, DashboardType
 from .mobile_asset import MobileAssetTile, MobileAssetTileType, MobileAssetConfig
 from .graylog_log import GraylogLog

wizata_dsapi-2.2.0.dev29/wizata_dsapi/planned_movement.py

@@ -0,0 +1,195 @@
+"""
+Production Planner planned movements (epic DEV-6044, DEV-6136, release 12.2).
+
+A planned movement is a quantity of a product the planner must not count as free stock:
+
+- stock the system of record has reserved or blocked, reported by its availability
+  snapshot (``allocated``, ``hold``, ``openDemand``: one row per product, no date);
+- or a movement expected to happen (``customerOrder``, ``workOrder``,
+  ``workOrderComponent``, ``purchaseOrder``, ``forecast``: one row per document line,
+  due at a date).
+
+When an expected movement happens it becomes a real one (a shipped or production
+movement on an inventoryMovement DataPoint) and the planned one closes. Stock itself is
+unchanged: movements and balances stay what they are.
+
+A sync writes the **full set** of one source, type and facility at a moment (``asOf``):
+a changed row gets a new version, a row missing from the set is closed. Every version is
+kept (``validFrom`` / ``validTo``), so what was planned at any past moment can be read
+again.
+"""
+
+from datetime import datetime
+from typing import Optional
+
+from .inventory import _ts_in, _ts_out, _uuid_str
+
+#: type -> (direction, dated). Snapshot types carry one row per product and no date.
+PLANNED_MOVEMENT_TYPES = {
+    "allocated": ("out", False),
+    "hold": ("out", False),
+    "openDemand": ("out", False),
+    "customerOrder": ("out", True),
+    "workOrder": ("in", True),
+    "workOrderComponent": ("out", True),
+    "purchaseOrder": ("in", True),
+    "forecast": ("out", True),
+}
+PLANNED_MOVEMENT_SNAPSHOT_TYPES = tuple(t for t, (_, dated) in PLANNED_MOVEMENT_TYPES.items() if not dated)
+PLANNED_MOVEMENT_DATED_TYPES = tuple(t for t, (_, dated) in PLANNED_MOVEMENT_TYPES.items() if dated)
+PLANNED_MOVEMENT_DIRECTIONS = ("in", "out")
+
+
+def planned_movement_direction(movement_type: str) -> str:
+    """``in`` or ``out`` for a type; a ValueError for an unknown one."""
+    if movement_type not in PLANNED_MOVEMENT_TYPES:
+        raise ValueError(f"type must be one of {', '.join(PLANNED_MOVEMENT_TYPES)}, not {movement_type!r}"[:300])
+    return PLANNED_MOVEMENT_TYPES[movement_type][0]
+
+
+def is_dated_planned_movement(movement_type: str) -> bool:
+    """True for a type with one row per document line and a due date."""
+    planned_movement_direction(movement_type)
+    return PLANNED_MOVEMENT_TYPES[movement_type][1]
+
+
+class PlannedMovement:
+    """
+    One version of one planned movement. PostgreSQL ``"PlannedMovement"`` (alembic 0032).
+
+    - ``source`` names the system it comes from (e.g. ``asc``), ``type`` one of
+      :data:`PLANNED_MOVEMENT_TYPES`, ``facility`` the Twin (hardware id) it applies to.
+    - A snapshot type is one row per ``product``. A dated type is one row per
+      ``document`` (as the source writes it) and ``line`` (its position), due at ``due``.
+    - Quantities: ``planned`` in total, ``in_progress`` already started (picked),
+      ``done`` already happened (shipped). What remains open is ``planned - done``; it
+      is never stored.
+    - ``unit``: on write, the backend unit id the quantities are sent in (of the
+      product's category); they are converted to the product's default unit. On read,
+      the unit they are stored in: the product's default unit when the row was written,
+      None when it had none.
+    - ``valid_from`` / ``valid_to``: when this version was true. ``valid_to`` is None
+      while it still is.
+    """
+
+    @classmethod
+    def route(cls):
+        return "planner/plannedmovements"
+
+    def __init__(self, product: str = None, planned: float = None, document: str = None, line: int = None,
+                 due=None, in_progress: float = None, done: float = None, partner: str = None,
+                 movement_type: str = None, source: str = None, facility: str = None,
+                 direction: str = None, unit=None, movement_id=None):
+        self.id: Optional[str] = _uuid_str(movement_id)
+        self.source: Optional[str] = source
+        self.type: Optional[str] = movement_type
+        self.facility: Optional[str] = facility
+        self.document: Optional[str] = document
+        self.line: Optional[int] = line
+        self.direction: Optional[str] = direction
+        self.product: Optional[str] = product
+        self.partner: Optional[str] = partner
+        self.due: Optional[datetime] = _ts_in(due)
+        self.planned: Optional[float] = planned
+        self.in_progress: Optional[float] = in_progress
+        self.done: Optional[float] = done
+        self.unit: Optional[str] = _uuid_str(unit)
+        self.valid_from: Optional[datetime] = None
+        self.valid_to: Optional[datetime] = None
+        self.created_at: Optional[datetime] = None
+        self.created_by: Optional[str] = None
+
+    @property
+    def is_open(self) -> bool:
+        """This version is still true."""
+        return self.valid_to is None
+
+    def key(self) -> tuple:
+        """What identifies the row within its set: the product for a snapshot type, the
+        document and line for a dated one."""
+        if self.type in PLANNED_MOVEMENT_TYPES and not PLANNED_MOVEMENT_TYPES[self.type][1]:
+            return (self.product,)
+        return self.document, self.line
+
+    def to_dict(self) -> dict:
+        obj = {}
+        for name, value in (("id", self.id), ("source", self.source), ("type", self.type),
+                            ("facility", self.facility), ("document", self.document), ("line", self.line),
+                            ("direction", self.direction), ("product", self.product),
+                            ("partner", self.partner), ("planned", self.planned),
+                            ("inProgress", self.in_progress), ("done", self.done), ("unit", self.unit),
+                            ("createdBy", self.created_by)):
+            if value is not None:
+                obj[name] = value
+        for name, value in (("due", self.due), ("validFrom", self.valid_from), ("validTo", self.valid_to),
+                            ("createdAt", self.created_at)):
+            if value is not None:
+                obj[name] = _ts_out(value) if isinstance(value, datetime) else value
+        return obj
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "PlannedMovement":
+        obj = cls()
+        obj.id = _uuid_str(data.get("id"))
+        obj.source = data.get("source")
+        obj.type = data.get("type")
+        obj.facility = data.get("facility")
+        obj.document = data.get("document")
+        obj.line = data.get("line")
+        obj.direction = data.get("direction")
+        obj.product = data.get("product")
+        obj.partner = data.get("partner")
+        obj.due = _ts_in(data.get("due"))
+        obj.planned = data.get("planned")
+        obj.in_progress = data.get("inProgress", data.get("in_progress"))
+        obj.done = data.get("done")
+        obj.unit = _uuid_str(data.get("unit"))
+        obj.valid_from = _ts_in(data.get("validFrom") or data.get("valid_from"))
+        obj.valid_to = _ts_in(data.get("validTo") or data.get("valid_to"))
+        obj.created_at = _ts_in(data.get("createdAt") or data.get("created_at"))
+        obj.created_by = data.get("createdBy") or data.get("created_by")
+        return obj
+
+    def api_id(self) -> str:
+        return self.id
+
+    def __repr__(self) -> str:
+        return (f"PlannedMovement(type={self.type!r}, product={self.product!r}, document={self.document!r}, "
+                f"line={self.line!r}, planned={self.planned!r}, done={self.done!r})")
+
+
+class PlannedMovementSet:
+    """
+    The outcome of writing one full set (source, type, facility) at ``as_of``: how many
+    rows were ``created``, ``changed`` (a new version), ``unchanged`` and ``closed``
+    (missing from the set). ``open`` is how many rows the set holds afterwards.
+    """
+
+    def __init__(self, source: str = None, movement_type: str = None, facility: str = None, as_of=None,
+                 created: int = 0, changed: int = 0, unchanged: int = 0, closed: int = 0, open_rows: int = 0):
+        self.source = source
+        self.type = movement_type
+        self.facility = facility
+        self.as_of: Optional[datetime] = _ts_in(as_of)
+        self.created = created
+        self.changed = changed
+        self.unchanged = unchanged
+        self.closed = closed
+        self.open = open_rows
+
+    def to_dict(self) -> dict:
+        return {"source": self.source, "type": self.type, "facility": self.facility,
+                "asOf": _ts_out(self.as_of) if isinstance(self.as_of, datetime) else self.as_of,
+                "created": self.created, "changed": self.changed, "unchanged": self.unchanged,
+                "closed": self.closed, "open": self.open}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "PlannedMovementSet":
+        return cls(source=data.get("source"), movement_type=data.get("type"), facility=data.get("facility"),
+                   as_of=data.get("asOf"), created=data.get("created", 0), changed=data.get("changed", 0),
+                   unchanged=data.get("unchanged", 0), closed=data.get("closed", 0),
+                   open_rows=data.get("open", 0))
+
+    def __repr__(self) -> str:
+        return (f"PlannedMovementSet(type={self.type!r}, facility={self.facility!r}, created={self.created}, "
+                f"changed={self.changed}, unchanged={self.unchanged}, closed={self.closed}, open={self.open})")

wizata_dsapi-2.2.0.dev29/wizata_dsapi/version.py

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

{wizata_dsapi-2.2.0.dev28 → wizata_dsapi-2.2.0.dev29}/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 .planned_movement import PlannedMovement, PlannedMovementSet
 from .connection import EdgeDeviceKey
 from .edge_config import EdgeConfig
 from .api_config import _registry
@@ -3169,6 +3170,69 @@ class WizataDSAPIClient(ApiInterface, ApiDtoInterface):
         response = self._planner_request("POST", "planner/inventory/history", body=body)
         return InventoryHistory.from_dict(response.json())
 
+    # Production Planner - planned movements (DEV-6136)
+
+    def set_planned_movements(self, source: str, movement_type: str, facility: str, as_of,
+                              movements: list) -> PlannedMovementSet:
+        """
+        Write the full set of planned movements of one source, type and facility as it is
+        at ``as_of``, all or none: afterwards the set holds exactly ``movements``. A row
+        whose values changed gets a new version, a row left out is closed at ``as_of``, an
+        empty list closes them all. Every version is kept.
+
+        Sets are written in time order: an ``as_of`` before the set's last write is a 409.
+        Writing the same ``as_of`` again corrects that write.
+
+        :param source: the system the rows come from, e.g. ``asc``.
+        :param movement_type: ``allocated``, ``hold``, ``openDemand`` (one row per product,
+            from the source's availability snapshot), or ``customerOrder``, ``workOrder``,
+            ``workOrderComponent``, ``purchaseOrder``, ``forecast`` (one row per
+            ``document`` and ``line``, with a ``due`` date).
+        :param facility: hardware id of the Twin the rows apply to.
+        :param as_of: datetime or ISO 8601: when the source held this set.
+        :param movements: PlannedMovement list (or dicts). Quantities: ``planned``, and
+            ``in_progress`` / ``done`` for dated types, in the product's default unit unless
+            ``unit`` names another unit of its category.
+        :return: PlannedMovementSet: how many rows were created, changed, unchanged, closed.
+        """
+        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 = {"source": source, "type": movement_type, "facility": facility, "asOf": as_of,
+                "movements": [m.to_dict() if isinstance(m, PlannedMovement) else m for m in movements or []]}
+        response = self._planner_request("POST", "planner/plannedmovements/", body=body)
+        return PlannedMovementSet.from_dict(response.json())
+
+    def search_planned_movements(self, search_query=None) -> PagedQueryResult:
+        """
+        List planned movements: the open rows by default, sorted by due date.
+
+        :param search_query: SearchQuery or dict; filters on ``source``, ``type``,
+            ``facility``, ``product``, ``document``, ``partner`` (eq / in), ``due`` (eq / gte /
+            gt / lt / lte), ``asOf`` (the rows as they were at that moment) or ``history``
+            (true: every version).
+        :return: PagedQueryResult with PlannedMovement results.
+        """
+        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/plannedmovements/search", body=search_query.to_dict())
+        return PagedQueryResult.from_dict(response.json(), dto_class=PlannedMovement)
+
+    def delete_planned_movements(self, source: str, movement_type: str, facility: str) -> int:
+        """
+        Delete every version of every row of one set (e.g. a sync pointed at the wrong
+        facility). To close the rows and keep their history, write an empty set instead.
+
+        :return: how many rows were deleted; 0 when the set held nothing.
+        """
+        response = self._planner_request("DELETE", "planner/plannedmovements/",
+                                         params={"source": source, "type": movement_type, "facility": facility},
+                                         expected=(200, 404))
+        return response.json().get("deleted", 0) if response.status_code == 200 else 0
+
     # ------------------------------------------------------------ edge (DEV-6013/6014)
 
     @staticmethod

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

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

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

@@ -40,6 +40,7 @@ wizata_dsapi/notification.py
 wizata_dsapi/paged_query_result.py
 wizata_dsapi/pipeline.py
 wizata_dsapi/pipeline_image.py
+wizata_dsapi/planned_movement.py
 wizata_dsapi/plot.py
 wizata_dsapi/product.py
 wizata_dsapi/python_package.py

wizata_dsapi-2.2.0.dev28/wizata_dsapi/version.py

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