b1sl-python 0.1.0__py3-none-any.whl

b1sl/b1sl/models/_overrides/inventory.py

@@ -0,0 +1,24 @@
+from .._generated.entities.inventory import Item as _Item
+
+
+class Item(_Item):
+    """
+    Manual override for Item entity to add business logic.
+    """
+
+    @property
+    def available_stock(self) -> float:
+        """
+        Calculated available stock based on standard SAP logic:
+        Available = OnHand - IsCommited + OnOrder
+
+        Mapping:
+        - OnHand: quantity_on_stock
+        - IsCommited: quantity_ordered_by_customers
+        - OnOrder: quantity_ordered_from_vendors
+        """
+        on_hand = self.quantity_on_stock or 0.0
+        committed = self.quantity_ordered_by_customers or 0.0
+        ordered = self.quantity_ordered_from_vendors or 0.0
+
+        return on_hand - committed + ordered

b1sl/b1sl/models/base.py

@@ -0,0 +1,209 @@
+"""
+b1sl.b1sl.models.base
+~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Single source of truth for the shared B1Model base class.
+
+All SAP B1 Pydantic models in this SDK must inherit from B1Model, never
+directly from pydantic.BaseModel.  This guarantees a consistent config
+across the whole model hierarchy:
+
+  - ``extra='allow'``  — unknown UDFs (U_*) returned by SAP are preserved
+    instead of causing a ValidationError.
+  - ``populate_by_name=True`` — fields can be set by their Python name
+    OR by their SAP alias (whichever is more convenient at the call site).
+
+Inbound normalisation contract
+-------------------------------
+``B1Model`` handles SAP-specific encodings transparently via a
+``model_validator(mode='before')`` so every subclass automatically
+receives clean Python values:
+
+    * ``"tYES"`` / ``"tNO"``       → ``bool``
+    * ``"/Date(1735689600000)/"``   → ISO date string ``"2025-01-01"``
+
+    >>> from b1sl.b1sl.models.base import B1Model
+    >>> from pydantic import Field
+    >>> class MyModel(B1Model):
+    ...     active: bool | None = Field(None, alias="Active")
+    ...     created: str | None = Field(None, alias="CreateDate")
+    >>> MyModel.model_validate({"Active": "tYES", "CreateDate": "/Date(1735689600000)/"})
+    MyModel(active=True, created='2025-01-01')
+
+Outbound serialisation contract
+---------------------------------
+``to_api_payload()`` reverses the normalisation so SAP receives its native
+format, and enforces ``exclude_unset=True`` to prevent accidental null-
+overwrites on PATCH requests:
+
+    * ``bool``             → ``"tYES"`` / ``"tNO"``
+    * ``datetime.date``    → ISO string ``"YYYY-MM-DD"``
+    * ``Valid=True``       → also sets ``Frozen="tNO"`` (SAP invariant)
+"""
+
+from __future__ import annotations
+
+import re
+from datetime import date, datetime, timezone
+from enum import Enum
+from typing import Annotated, Any
+
+from pydantic import BaseModel, BeforeValidator, ConfigDict, model_validator
+
+# SAP boolean sentinel values — exact set used by the Service Layer.
+_SAP_YES: str = "tYES"
+_SAP_NO: str = "tNO"
+
+_SAP_BOOL_TRUE = {"boyes", "tyes", "y", "yes", "true", "1"}
+_SAP_BOOL_FALSE = {"bono", "tno", "n", "no", "false", "0"}
+
+
+def _coerce_sap_boolean(v: Any) -> Any:
+    if isinstance(v, str):
+        vl = v.lower()
+        if vl in _SAP_BOOL_TRUE:
+            return True
+        elif vl in _SAP_BOOL_FALSE:
+            return False
+    return v
+
+
+SapBool = Annotated[bool, BeforeValidator(_coerce_sap_boolean)]
+
+# /Date(milliseconds_since_epoch)/ — the OData v2 date format SAP uses.
+_SAP_DATE_RE = re.compile(r"^/Date\((\d+)\)/$")
+
+
+class B1Model(BaseModel):
+    """
+    Base for every SAP B1 Pydantic model in the SDK.
+
+    Subclass this instead of ``pydantic.BaseModel`` to inherit:
+
+    * Automatic ``/Date(ms)/`` → ISO date string coercion on ingest.
+    * ``extra='allow'`` — unknown UDFs (U_* fields) round-trip cleanly.
+    * ``populate_by_name=True`` — both Python name and SAP alias accepted.
+    * ``to_api_payload()`` — safe outbound serialisation:
+        - ``exclude_unset=True`` to prevent over-posting on PATCH.
+        - ``bool`` → ``"tYES"``/``"tNO"``
+        - ``date`` → ISO string
+        - ``Valid`` presence → auto-sets ``Frozen`` to the inverse.
+
+    UDF Example::
+
+        class MyItem(B1Model):
+            item_code: str           = Field(alias="ItemCode")
+            custom_field: str | None = Field(None, alias="U_MyCustomField")
+
+    Because ``extra='allow'`` is set, any *additional* UDFs returned by SAP
+    that are not explicitly declared on the subclass are stored in
+    ``model.__pydantic_extra__`` and round-trip cleanly through
+    ``to_api_payload()``.
+    """
+
+    model_config = ConfigDict(
+        populate_by_name=True,  # accept both field name and alias
+        extra="allow",  # preserve unknown SAP UDFs (U_* fields)
+        arbitrary_types_allowed=True,
+    )
+
+    # ── Inbound coercion (SAP → Python) ─────────────────────────────────── #
+
+    @model_validator(mode="before")
+    @classmethod
+    def _coerce_sap_primitives(cls, data: Any) -> Any:
+        """
+        Coerce SAP string sentinels to native Python types before
+        field-level validation runs.
+
+        Conversions applied:
+        * "/Date(1735689600000)/"     → "2025-01-01" (ISO date string)
+        * "tYES" / "tNO" etc          → bool
+        """
+        if not isinstance(data, dict):
+            return data
+
+        coerced: dict[str, Any] = {}
+        for key, val in data.items():
+            if isinstance(val, str):
+                # 1. Check for Dates
+                m = _SAP_DATE_RE.match(val)
+                if m:
+                    epoch_ms = int(m.group(1))
+                    coerced[key] = (
+                        datetime.fromtimestamp(epoch_ms / 1000, tz=timezone.utc)
+                        .date()
+                        .isoformat()
+                    )
+                else:
+                    # 2. Check for Booleans
+                    coerced[key] = _coerce_sap_boolean(val)
+            else:
+                coerced[key] = val
+        return coerced
+
+    # ── Outbound serialisation (Python → SAP) ───────────────────────────── #
+
+    def get(self, field_alias: str, default: Any = None) -> Any:
+        """
+        Access a field's value by its SAP alias (e.g. 'CardCode') or Python name.
+
+        This is particularly useful when using the ``F`` (fields) constants to
+        read data from a model instance dynamically.
+
+        Args:
+            field_alias (str): The SAP alias or Python attribute name.
+            default (Any, optional): Value to return if the field is not found.
+                Defaults to None.
+
+        Returns:
+            Any: The field value if found, else the default.
+        """
+        # 1. Search in defined Pydantic fields
+        for name, field in self.model_fields.items():
+            if field.alias == field_alias or name == field_alias:
+                return getattr(self, name, default)
+
+        # 2. Search in 'extra' fields (UDFs) if allowed
+        if self.model_extra and field_alias in self.model_extra:
+            return self.model_extra[field_alias]
+
+        return default
+
+    def to_api_payload(self) -> dict:
+        """
+        Serialise this model to an API-ready dict safe for SAP Service Layer.
+
+        Behaviour:
+        * ``exclude_unset=True`` — only fields the developer *explicitly* set
+          are included, preventing accidental null-overwrites on PATCH.
+        * ``bool``          → ``"tYES"`` / ``"tNO"``
+        * ``datetime.date`` → ISO string ``"YYYY-MM-DD"``
+        * If ``Valid`` is in the payload, ``Frozen`` is automatically set to
+          the inverse value (SAP requires both fields to be kept in sync).
+
+        Fields explicitly set to ``None`` **are** included (the developer
+        intended to clear that SAP field).
+
+        Outputs SAP field aliases (not Python attribute names) and includes
+        any extra UDF fields stored in ``__pydantic_extra__``.
+        """
+        raw: dict[str, Any] = self.model_dump(by_alias=True, exclude_unset=True)
+
+        encoded: dict[str, Any] = {}
+        for key, val in raw.items():
+            if isinstance(val, bool):
+                encoded[key] = _SAP_YES if val else _SAP_NO
+            elif isinstance(val, date):
+                encoded[key] = val.isoformat()
+            elif isinstance(val, Enum):
+                # For BoYesNoEnum and others, we might need special handling if they are IntEnums but represent booleans
+                if val.name in ("tYES", "boYES"):
+                    encoded[key] = _SAP_YES
+                elif val.name in ("tNO", "boNO"):
+                    encoded[key] = _SAP_NO
+                else:
+                    encoded[key] = val.value
+            else:
+                encoded[key] = val
+
+        return encoded

b1sl/b1sl/models/odata_query_model.py

@@ -0,0 +1,50 @@
+"""
+b1sl.b1sl.models.odata_query_model
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Typed container for OData v4 query parameters.
+
+``ODataQueryModel`` is used internally by ``BaseResource._build_odata_params``
+to construct validated, serialisable query-parameter dicts.  Using a Pydantic
+model here gives us:
+
+* ``extra='forbid'`` — typos in keyword arguments raise a ``ValidationError``
+  immediately instead of silently being ignored by the HTTP client.
+* A single ``build_query_params()`` method that strips ``None`` values and
+  coerces all parameter values to strings as required by ``requests``.
+"""
+
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ODataQueryModel(BaseModel):
+    """Typed representation of OData v4 system query options.
+
+    All fields are optional; only non-``None`` fields are included in the
+    generated query-parameter dict.
+    """
+
+    select: str | None = Field(None, alias="$select")
+    filter_: str | None = Field(None, alias="$filter")
+    order_by: str | None = Field(None, alias="$orderby")
+    top: int | None = Field(None, alias="$top")
+    skip: int | None = Field(None, alias="$skip")
+    expand: str | None = Field(None, alias="$expand")
+    format: str | None = Field(None, alias="$format")
+    count: bool | None = Field(None, alias="$count")
+    search: str | None = Field(None, alias="$search")
+
+    model_config = ConfigDict(
+        extra="forbid",  # reject unknown keys — catches query-param typos
+        populate_by_name=True,  # allow both Python name and OData alias
+    )
+
+    def build_query_params(self) -> dict[str, str]:
+        """Return a ``{str: str}`` dict suitable for ``requests`` ``params=``.
+
+        Only set (non-``None``) fields are included.  OData alias names
+        (e.g. ``"$select"``) are used as keys.
+        """
+        raw = self.model_dump(by_alias=True, exclude_none=True)
+        return {k: str(v) for k, v in raw.items()}

b1sl/b1sl/models/paginated_result.py

@@ -0,0 +1,85 @@
+"""
+b1sl.b1sl.models.paginated_result
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+Generic container for a single SAP B1 OData page.
+"""
+
+from __future__ import annotations
+
+from typing import (
+    Any,
+    Generic,
+    Iterator,
+)
+
+from b1sl.b1sl._types import T
+
+
+class PaginatedResult(Generic[T]):
+    """
+    Wraps one page of SAP B1 OData results together with pagination metadata.
+
+    Attributes:
+        data:        An **iterator** yielding validated model instances for
+                     this page.  See the warning below.
+        metadata:    The ``odata.metadata`` URL string returned by SAP, if any.
+        next_params: Query-param dict for the next page (from ``odata.nextLink``),
+                     or ``None`` if this is the last page.
+
+    .. warning:: ``data`` is a **one-shot generator**.
+
+        Iterating over ``data`` a second time returns nothing::
+
+            result = client.items.list()
+            first  = list(result.data)   # ✅ correct
+            second = list(result.data)   # ❌ empty — generator exhausted!
+
+        To consume the page multiple times, call :meth:`to_list` **once** and
+        keep a reference to the returned list::
+
+            items = result.to_list()
+            print(items[0])   # ✅ safe — list is cached internally
+            print(items[-1])  # ✅ still fine
+    """
+
+    def __init__(
+        self,
+        data: Iterator[T],
+        metadata: str | None = None,
+        next_params: dict[str, Any] | None = None,
+    ) -> None:
+        self._data_iter: Iterator[T] = data
+        self._data_cache: list[T] | None = None
+        self.metadata = metadata
+        self.next_params = next_params
+
+    @property
+    def data(self) -> Iterator[T]:
+        """
+        One-shot iterator over this page's records.
+
+        If you have already called :meth:`to_list`, subsequent accesses to
+        ``data`` will replay the cached list so it is not empty.
+        """
+        if self._data_cache is not None:
+            return iter(self._data_cache)
+        return self._data_iter
+
+    def to_list(self) -> list[T]:
+        """
+        Materialise the page into a list and cache it.
+
+        Safe to call multiple times — the generator is consumed only once and
+        the result is stored in ``_data_cache`` for all future accesses via
+        either ``to_list()`` or the ``data`` property.
+
+        Returns:
+            A list of validated model instances for this page.
+        """
+        if self._data_cache is None:
+            self._data_cache = list(self._data_iter)
+        return self._data_cache
+
+    def __iter__(self) -> Iterator[T]:
+        """Allow ``for item in paginated_result`` to work transparently."""
+        return self.data

b1sl/b1sl/models/result.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+from pydantic import BaseModel, ConfigDict
+
+
+class Result(BaseModel):
+    status_code: int
+    message: str = ""
+    data: dict | None = None
+    next_link: str | None = None
+    next_params: dict | None = None
+    metadata: str | None = None
+
+    # Update configuration for Pydantic V2
+    model_config = ConfigDict(
+        extra="allow"  # Allows extra fields not explicitly defined
+    )

b1sl/b1sl/resources/__init__.py

@@ -0,0 +1,11 @@
+"""
+b1sl.b1sl.resources — public resource re-exports.
+"""
+
+from b1sl.b1sl.resources.base import GenericResource
+from b1sl.b1sl.resources.udo import UDOResource
+
+__all__ = [
+    "GenericResource",
+    "UDOResource",
+]

b1sl/b1sl/resources/_generated/account_category.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any
+from b1sl.b1sl.resources.base import GenericResource
+
+if TYPE_CHECKING:
+    from ...models._generated._types import *
+
+class AccountCategoryService(GenericResource["AccountCategory"]):
+    """This entity enables you to manipulate 'AccountCategory'."""
+    endpoint = "AccountCategory"
+    
+    def __init__(self, adapter):
+        from ...models._generated._types import AccountCategory
+        self.model = AccountCategory
+        super().__init__(adapter)

b1sl/b1sl/resources/_generated/account_category_service.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any
+from b1sl.b1sl.resources.base import GenericResource
+
+if TYPE_CHECKING:
+    from ...models._generated._types import *
+
+class AccountCategoryService(GenericResource[Any]):
+    endpoint = "AccountCategoryService"
+    
+    def __init__(self, adapter):
+        self.model = None
+        super().__init__(adapter)
+
+    # --- Actions ---
+
+    def get_category_list(self, payload: dict | None = None) -> Any:
+        """POST AccountCategoryService_GetCategoryList
+        Invoke the method 'GetCategoryList' on this service.
+        """
+        return self._adapter.post(f"AccountCategoryService_GetCategoryList", data=payload)

b1sl/b1sl/resources/_generated/account_segmentation_categories.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any
+from b1sl.b1sl.resources.base import GenericResource
+
+if TYPE_CHECKING:
+    from ...models._generated._types import *
+
+class AccountSegmentationCategoriesService(GenericResource["AccountSegmentationCategory"]):
+    """This entity enables you to manipulate 'AccountSegmentationCategories'. It represents the categories under each of the account segments."""
+    endpoint = "AccountSegmentationCategories"
+    
+    def __init__(self, adapter):
+        from ...models._generated._types import AccountSegmentationCategory
+        self.model = AccountSegmentationCategory
+        super().__init__(adapter)

b1sl/b1sl/resources/_generated/account_segmentations.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any
+from b1sl.b1sl.resources.base import GenericResource
+
+if TYPE_CHECKING:
+    from ...models._generated._types import *
+
+class AccountSegmentationsService(GenericResource["AccountSegmentation"]):
+    """This entity enables you to manipulate 'AccountSegmentations'."""
+    endpoint = "AccountSegmentations"
+    
+    def __init__(self, adapter):
+        from ...models._generated._types import AccountSegmentation
+        self.model = AccountSegmentation
+        super().__init__(adapter)

b1sl/b1sl/resources/_generated/accounts_service.py

@@ -0,0 +1,33 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any
+from b1sl.b1sl.resources.base import GenericResource
+
+if TYPE_CHECKING:
+    from ...models._generated._types import *
+
+class AccountsService(GenericResource[Any]):
+    endpoint = "AccountsService"
+    
+    def __init__(self, adapter):
+        self.model = None
+        super().__init__(adapter)
+
+    # --- Actions ---
+
+    def create_open_balance(self, payload: dict | None = None) -> Any:
+        """POST AccountsService_CreateOpenBalance
+        Invoke the method 'CreateOpenBalance' on this service by specifying the payload 'OpenningBalanceAccount,GLAccounts' in the JSON format.
+
+        Example:
+        ```json
+        {
+            "GLAccounts": {
+                "Code": "test"
+            },
+            "OpenningBalanceAccount": {
+                "Date": "2016-08-29"
+            }
+        }
+        ```
+        """
+        return self._adapter.post(f"AccountsService_CreateOpenBalance", data=payload)

b1sl/b1sl/resources/_generated/accrual_types.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any
+from b1sl.b1sl.resources.base import GenericResource
+
+if TYPE_CHECKING:
+    from ...models._generated._types import *
+
+class AccrualTypesService(GenericResource["AccrualType"]):
+    """This entity enables you to manipulate 'AccrualTypes'."""
+    endpoint = "AccrualTypes"
+    
+    def __init__(self, adapter):
+        from ...models._generated._types import AccrualType
+        self.model = AccrualType
+        super().__init__(adapter)

b1sl/b1sl/resources/_generated/accrual_types_service.py

@@ -0,0 +1,21 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any
+from b1sl.b1sl.resources.base import GenericResource
+
+if TYPE_CHECKING:
+    from ...models._generated._types import *
+
+class AccrualTypesService(GenericResource[Any]):
+    endpoint = "AccrualTypesService"
+    
+    def __init__(self, adapter):
+        self.model = None
+        super().__init__(adapter)
+
+    # --- Actions ---
+
+    def get_accrual_type_list(self, payload: dict | None = None) -> Any:
+        """POST AccrualTypesService_GetAccrualTypeList
+        Invoke the method 'GetAccrualTypeList' on this service.
+        """
+        return self._adapter.post(f"AccrualTypesService_GetAccrualTypeList", data=payload)

b1sl/b1sl/resources/_generated/activities.py

@@ -0,0 +1,15 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any
+from b1sl.b1sl.resources.base import GenericResource
+
+if TYPE_CHECKING:
+    from ...models._generated._types import *
+
+class ActivitiesService(GenericResource["Activity"]):
+    """This entity enables you to manipulate 'Activities'."""
+    endpoint = "Activities"
+    
+    def __init__(self, adapter):
+        from ...models._generated._types import Activity
+        self.model = Activity
+        super().__init__(adapter)

b1sl/b1sl/resources/_generated/activities_service.py

@@ -0,0 +1,109 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Any
+from b1sl.b1sl.resources.base import GenericResource
+
+if TYPE_CHECKING:
+    from ...models._generated._types import *
+
+class ActivitiesService(GenericResource[Any]):
+    endpoint = "ActivitiesService"
+    
+    def __init__(self, adapter):
+        self.model = None
+        super().__init__(adapter)
+
+    # --- Actions ---
+
+    def delete_single_instance_from_series(self, payload: dict | None = None) -> Any:
+        """POST ActivitiesService_DeleteSingleInstanceFromSeries
+        Invoke the method 'DeleteSingleInstanceFromSeries' on this service by specifying the payload 'ActivityInstanceParams' in the JSON format.
+
+        Example:
+        ```json
+        {
+            "ActivityInstanceParams": {
+                "ActivityCode": "3",
+                "InstanceDate": "2016-08-30"
+            }
+        }
+        ```
+        """
+        return self._adapter.post(f"ActivitiesService_DeleteSingleInstanceFromSeries", data=payload)
+
+    def get_activity_list(self, payload: dict | None = None) -> Any:
+        """POST ActivitiesService_GetActivityList
+        Invoke the method 'GetActivityList' on this service.
+        """
+        return self._adapter.post(f"ActivitiesService_GetActivityList", data=payload)
+
+    def get_list_by_attend_user(self, payload: dict | None = None) -> Any:
+        """POST ActivitiesService_GetListByAttendUser
+        """
+        return self._adapter.post(f"ActivitiesService_GetListByAttendUser", data=payload)
+
+    def get_single_instance_from_series(self, payload: dict | None = None) -> Any:
+        """POST ActivitiesService_GetSingleInstanceFromSeries
+        Invoke the method 'GetSingleInstanceFromSeries' on this service by specifying the payload 'ActivityInstanceParams' in the JSON format.
+
+        Example:
+        ```json
+        {
+            "ActivityInstanceParams": {
+                "ActivityCode": "3",
+                "InstanceDate": "2016-08-30"
+            }
+        }
+        ```
+        """
+        return self._adapter.post(f"ActivitiesService_GetSingleInstanceFromSeries", data=payload)
+
+    def get_top_n_activity_instances(self, payload: dict | None = None) -> Any:
+        """POST ActivitiesService_GetTopNActivityInstances
+        Invoke the method 'GetTopNActivityInstances' on this service by specifying the payload 'ActivityInstancesListParams' in the JSON format.
+
+        Example:
+        ```json
+        {
+            "ActivityInstancesListParams": {
+                "ActivityInstancesListParams": {
+                    "StartDate": "2016-08-30"
+                }
+            }
+        }
+        ```
+        """
+        return self._adapter.post(f"ActivitiesService_GetTopNActivityInstances", data=payload)
+
+    def init_data(self, payload: dict | None = None) -> Any:
+        """POST ActivitiesService_InitData
+        """
+        return self._adapter.post(f"ActivitiesService_InitData", data=payload)
+
+    def update_single_instance_in_series(self, payload: dict | None = None) -> Any:
+        """POST ActivitiesService_UpdateSingleInstanceInSeries
+        Invoke the method 'UpdateSingleInstanceInSeries' on this service by specifying the payload 'Activity' in the JSON format.
+
+        Example:
+        ```json
+        {
+            "Activity": {
+                "ActivityDate": "2016-08-30",
+                "ActivityTime": "08:13:00",
+                "CardCode": "C01",
+                "DocEntry": "3",
+                "DocNum": "1",
+                "DocType": "17",
+                "Duration": 15,
+                "DurationType": "du_Minuts",
+                "EndDueDate": "2016-08-30",
+                "EndTime": "08:28:00",
+                "Reminder": "tYES",
+                "ReminderPeriod": 15,
+                "ReminderType": "du_Minuts",
+                "StartDate": "2016-08-30",
+                "StartTime": "08:13:00"
+            }
+        }
+        ```
+        """
+        return self._adapter.post(f"ActivitiesService_UpdateSingleInstanceInSeries", data=payload)