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

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

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

{wizata_dsapi-2.2.0.dev9 → wizata_dsapi-2.2.0.dev11}/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, 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.dev11/wizata_dsapi/inventory.py

@@ -0,0 +1,313 @@
+"""
+Production Planner inventory (epic DEV-6044, release 12.2).
+
+Two facts, and stock is derived from both:
+
+- **Movements** are points on a DataPoint of business type ``inventoryMovement``, one
+  per storage Twin and category. Each point is a signed quantity (+ in, - out) in the
+  DataPoint's unit, and its ``productKey`` tag names the product.
+- **Balances** (:class:`InventoryBalance`) are absolute levels counted at a moment
+  ("460 L of coke in the tank at 16:00"), stored in PostgreSQL on the same DataPoint.
+
+A query chooses what it reads with ``options={"inventory": ...}``:
+
+- ``movements`` (the default): the DataPoint's own points, one series per product.
+- ``balances``: the recorded balances, one series per product.
+- ``stock``: the level. Take the last balance before each moment, then add the
+  movements after it. A balance at T already counts every movement at or before T.
+  A product never counted starts from 0.
+
+``Request.products`` keeps only some products. Columns are named
+``<hardwareId>|<productKey>``.
+"""
+
+from datetime import datetime, timezone
+from typing import Optional
+
+#: Request option that chooses what an inventoryMovement DataPoint returns.
+INVENTORY_OPTION = "inventory"
+INVENTORY_MOVEMENTS = "movements"
+INVENTORY_BALANCES = "balances"
+INVENTORY_STOCK = "stock"
+INVENTORY_MODES = (INVENTORY_MOVEMENTS, INVENTORY_BALANCES, INVENTORY_STOCK)
+
+#: Time-series tag that carries the product key on a movement point.
+PRODUCT_TAG = "productKey"
+#: Message key that carries it to the writers (``Scope``, ``EventType`` style).
+PRODUCT_MESSAGE_KEY = "ProductKey"
+
+
+def inventory_mode(options) -> str:
+    """The inventory mode a request's options ask for; ``movements`` when unset."""
+    mode = None
+    if isinstance(options, dict):
+        mode = options.get(INVENTORY_OPTION)
+    if mode is None:
+        return INVENTORY_MOVEMENTS
+    if mode not in INVENTORY_MODES:
+        raise ValueError(f"options.{INVENTORY_OPTION} must be one of {', '.join(INVENTORY_MODES)} "
+                         f"but received {mode!r}"[:300])
+    return mode
+
+
+def _ts_out(value):
+    if value is None:
+        return None
+    if value.tzinfo is None:
+        value = value.replace(tzinfo=timezone.utc)
+    return value.isoformat()
+
+
+def _ts_in(value):
+    """A datetime from ISO 8601 or epoch milliseconds; anything else is kept as sent,
+    for the server to refuse with a message that names it."""
+    if value is None or isinstance(value, datetime):
+        return value
+    if isinstance(value, (int, float)) and not isinstance(value, bool):
+        return datetime.fromtimestamp(value / 1000, tz=timezone.utc)
+    try:
+        return datetime.fromisoformat(str(value).replace("Z", "+00:00"))
+    except ValueError:
+        return value
+
+
+def _uuid_str(value):
+    if value is None or value == "":
+        return None
+    return str(value).lower()
+
+
+class InventoryBalance:
+    """
+    An absolute stock level: ``quantity`` of ``product`` on the inventoryMovement
+    DataPoint ``datapoint`` (a hardware id), true at ``timestamp`` (when it was
+    counted, not when it was recorded: that is ``created_at``).
+
+    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:
+
+    - ``twin`` (a Twin hardware id) may replace ``datapoint``. The DataPoint is then
+      the Twin's inventoryMovement DataPoint of the product's category.
+    - ``unit`` (a backend unit id of the product's category) converts ``quantity`` to
+      the DataPoint's unit. It is stored in that unit, so a read never carries ``unit``.
+    """
+
+    @classmethod
+    def route(cls):
+        return "planner/inventory/balances"
+
+    def __init__(self, datapoint: str = None, product: str = None, timestamp=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)
+        self.quantity: Optional[float] = quantity
+        self.unit: Optional[str] = _uuid_str(unit)
+        self.twin: Optional[str] = twin
+        self.created_at: Optional[datetime] = None
+        self.created_by: Optional[str] = None
+        self.updated_at: Optional[datetime] = None
+        self.updated_by: Optional[str] = None
+
+    def to_dict(self) -> dict:
+        obj = {}
+        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)):
+            if value is not None:
+                obj[name] = value
+        for name, value in (("timestamp", self.timestamp), ("createdAt", self.created_at),
+                            ("updatedAt", self.updated_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) -> "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"))
+        obj.quantity = data.get("quantity")
+        obj.unit = _uuid_str(data.get("unit"))
+        obj.twin = data.get("twin")
+        obj.created_at = _ts_in(data.get("createdAt") or data.get("created_at"))
+        obj.created_by = data.get("createdBy") or data.get("created_by")
+        obj.updated_at = _ts_in(data.get("updatedAt") or data.get("updated_at"))
+        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
+
+    def __repr__(self) -> str:
+        return (f"InventoryBalance(datapoint={self.datapoint!r}, product={self.product!r}, "
+                f"timestamp={self.timestamp!r}, quantity={self.quantity!r})")
+
+
+class InventoryStorageDatapoint:
+    """One inventoryMovement DataPoint of a storage: its category and unit (DEV-6086)."""
+
+    def __init__(self, hardware_id: str = None, name: str = None, category=None, unit=None,
+                 unit_symbol: str = None):
+        self.hardware_id: Optional[str] = hardware_id
+        self.name: Optional[str] = name
+        self.category: Optional[str] = _uuid_str(category)
+        self.unit: Optional[str] = _uuid_str(unit)
+        self.unit_symbol: Optional[str] = unit_symbol
+
+    def to_dict(self) -> dict:
+        return {"hardwareId": self.hardware_id, "name": self.name, "category": self.category,
+                "unit": self.unit, "unitSymbol": self.unit_symbol}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "InventoryStorageDatapoint":
+        return cls(hardware_id=data.get("hardwareId") or data.get("hardware_id"), name=data.get("name"),
+                   category=data.get("category"), unit=data.get("unit"),
+                   unit_symbol=data.get("unitSymbol") or data.get("unit_symbol"))
+
+
+class InventoryStorage:
+    """
+    A storage place: a Twin holding at least one inventoryMovement DataPoint (DEV-6086).
+    Read only, from ``POST /dsapi/planner/inventory/storages/search``.
+    """
+
+    def __init__(self, twin_id=None, twin_hardware_id: str = None, twin_name: str = None,
+                 datapoints: list = 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.datapoints: list = list(datapoints or [])
+
+    def to_dict(self) -> dict:
+        return {"twin": {"id": self.twin_id, "hardwareId": self.twin_hardware_id, "name": self.twin_name},
+                "datapoints": [d.to_dict() for d in self.datapoints]}
+
+    @classmethod
+    def from_dict(cls, data: dict) -> "InventoryStorage":
+        twin = data.get("twin") or {}
+        return cls(twin_id=twin.get("id"), twin_hardware_id=twin.get("hardwareId"), twin_name=twin.get("name"),
+                   datapoints=[InventoryStorageDatapoint.from_dict(d) for d in data.get("datapoints") or []])
+
+    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.dev11/wizata_dsapi/version.py

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

{wizata_dsapi-2.2.0.dev9 → wizata_dsapi-2.2.0.dev11}/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
+from .inventory import InventoryBalance, InventoryStorage, InventoryStock
 from .api_config import _registry
 
 from .streamlit_utils import get_streamlit_token, get_streamlit_domain
@@ -2909,6 +2909,48 @@ 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
+        datapoints' category, unit and unit symbol (DEV-6086).
+
+        :param search_query: SearchQuery or dict; filters ``twin`` (hardware id or id) and
+            ``category`` (eq / in), ``_search`` (``{"query": text}`` on names and hardware ids).
+        :return: PagedQueryResult with InventoryStorage results, sorted by twin name.
+        """
+        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/inventory/storages/search",
+                                         body=search_query.to_dict())
+        return PagedQueryResult.from_dict(response.json(), dto_class=InventoryStorage)
+
     @staticmethod
     def _balance_id(value) -> str:
         balance_id = value.id if isinstance(value, InventoryBalance) else value

{wizata_dsapi-2.2.0.dev9 → wizata_dsapi-2.2.0.dev11}/wizata_dsapi.egg-info/PKG-INFO

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

wizata_dsapi-2.2.0.dev9/wizata_dsapi/inventory.py

@@ -1,157 +0,0 @@
-"""
-Production Planner inventory (epic DEV-6044, release 12.2).
-
-Two facts, and stock is derived from both:
-
-- **Movements** are points on a DataPoint of business type ``inventoryMovement``, one
-  per storage Twin and category. Each point is a signed quantity (+ in, - out) in the
-  DataPoint's unit, and its ``productKey`` tag names the product.
-- **Balances** (:class:`InventoryBalance`) are absolute levels counted at a moment
-  ("460 L of coke in the tank at 16:00"), stored in PostgreSQL on the same DataPoint.
-
-A query chooses what it reads with ``options={"inventory": ...}``:
-
-- ``movements`` (the default): the DataPoint's own points, one series per product.
-- ``balances``: the recorded balances, one series per product.
-- ``stock``: the level. Take the last balance before each moment, then add the
-  movements after it. A balance at T already counts every movement at or before T.
-  A product never counted starts from 0.
-
-``Request.products`` keeps only some products. Columns are named
-``<hardwareId>|<productKey>``.
-"""
-
-from datetime import datetime, timezone
-from typing import Optional
-
-#: Request option that chooses what an inventoryMovement DataPoint returns.
-INVENTORY_OPTION = "inventory"
-INVENTORY_MOVEMENTS = "movements"
-INVENTORY_BALANCES = "balances"
-INVENTORY_STOCK = "stock"
-INVENTORY_MODES = (INVENTORY_MOVEMENTS, INVENTORY_BALANCES, INVENTORY_STOCK)
-
-#: Time-series tag that carries the product key on a movement point.
-PRODUCT_TAG = "productKey"
-#: Message key that carries it to the writers (``Scope``, ``EventType`` style).
-PRODUCT_MESSAGE_KEY = "ProductKey"
-
-
-def inventory_mode(options) -> str:
-    """The inventory mode a request's options ask for; ``movements`` when unset."""
-    mode = None
-    if isinstance(options, dict):
-        mode = options.get(INVENTORY_OPTION)
-    if mode is None:
-        return INVENTORY_MOVEMENTS
-    if mode not in INVENTORY_MODES:
-        raise ValueError(f"options.{INVENTORY_OPTION} must be one of {', '.join(INVENTORY_MODES)} "
-                         f"but received {mode!r}"[:300])
-    return mode
-
-
-def _ts_out(value):
-    if value is None:
-        return None
-    if value.tzinfo is None:
-        value = value.replace(tzinfo=timezone.utc)
-    return value.isoformat()
-
-
-def _ts_in(value):
-    """A datetime from ISO 8601 or epoch milliseconds; anything else is kept as sent,
-    for the server to refuse with a message that names it."""
-    if value is None or isinstance(value, datetime):
-        return value
-    if isinstance(value, (int, float)) and not isinstance(value, bool):
-        return datetime.fromtimestamp(value / 1000, tz=timezone.utc)
-    try:
-        return datetime.fromisoformat(str(value).replace("Z", "+00:00"))
-    except ValueError:
-        return value
-
-
-def _uuid_str(value):
-    if value is None or value == "":
-        return None
-    return str(value).lower()
-
-
-class InventoryBalance:
-    """
-    An absolute stock level: ``quantity`` of ``product`` on the inventoryMovement
-    DataPoint ``datapoint`` (a hardware id), true at ``timestamp`` (when it was
-    counted, not when it was recorded: that is ``created_at``).
-
-    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:
-
-    - ``twin`` (a Twin hardware id) may replace ``datapoint``. The DataPoint is then
-      the Twin's inventoryMovement DataPoint of the product's category.
-    - ``unit`` (a backend unit id of the product's category) converts ``quantity`` to
-      the DataPoint's unit. It is stored in that unit, so a read never carries ``unit``.
-    """
-
-    @classmethod
-    def route(cls):
-        return "planner/inventory/balances"
-
-    def __init__(self, datapoint: str = None, product: str = None, timestamp=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)
-        self.quantity: Optional[float] = quantity
-        self.unit: Optional[str] = _uuid_str(unit)
-        self.twin: Optional[str] = twin
-        self.created_at: Optional[datetime] = None
-        self.created_by: Optional[str] = None
-        self.updated_at: Optional[datetime] = None
-        self.updated_by: Optional[str] = None
-
-    def to_dict(self) -> dict:
-        obj = {}
-        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)):
-            if value is not None:
-                obj[name] = value
-        for name, value in (("timestamp", self.timestamp), ("createdAt", self.created_at),
-                            ("updatedAt", self.updated_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) -> "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"))
-        obj.quantity = data.get("quantity")
-        obj.unit = _uuid_str(data.get("unit"))
-        obj.twin = data.get("twin")
-        obj.created_at = _ts_in(data.get("createdAt") or data.get("created_at"))
-        obj.created_by = data.get("createdBy") or data.get("created_by")
-        obj.updated_at = _ts_in(data.get("updatedAt") or data.get("updated_at"))
-        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
-
-    def __repr__(self) -> str:
-        return (f"InventoryBalance(datapoint={self.datapoint!r}, product={self.product!r}, "
-                f"timestamp={self.timestamp!r}, quantity={self.quantity!r})")

wizata_dsapi-2.2.0.dev9/wizata_dsapi/version.py

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