redblack-python-sdk 0.1.0__py3-none-any.whl

redblack/resources/cash_actions.py

@@ -0,0 +1,260 @@
+"""Cash-action reads, writes, and deliberately separated bulk deletion."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator, Mapping, Sequence
+from typing import Final, Literal, overload
+
+from ..models import (
+    CashAction,
+    CashActionCreate,
+    CashActionCreateResult,
+    CashActionDeleteResult,
+    CashActionDetails,
+    CashActionUpdate,
+    CashActionUpdateResult,
+)
+from ..odata import DEFAULT_PAGE_SIZE
+from ..pagination import Page
+from ._base import (
+    ApiResponseProtocol,
+    HttpInfoMode,
+    body_value,
+    require_positive_identifier,
+)
+from ._collections import CollectionResource
+
+
+class _DeleteAllCashActionsConfirmation:
+    __slots__ = ()
+
+    def __repr__(self) -> str:
+        return "CONFIRM_DELETE_ALL_CASH_ACTIONS"
+
+
+CONFIRM_DELETE_ALL_CASH_ACTIONS: Final = _DeleteAllCashActionsConfirmation()
+"""Identity-checked token required by :meth:`CashActionsResource.delete_all`."""
+
+
+class CashActionsResource(CollectionResource[HttpInfoMode]):
+    LIST_OPERATION_ID = "CashActions_Query"
+    OPERATION_IDS = frozenset(
+        {
+            "CashActions_Add",
+            LIST_OPERATION_ID,
+            "CashActions_Get",
+            "CashActions_Update",
+            "CashActions_DeleteCashActions",
+        }
+    )
+
+    @overload
+    def list(
+        self: CashActionsResource[Literal[False]],
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[CashAction]: ...
+
+    @overload
+    def list(
+        self: CashActionsResource[Literal[True]],
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> ApiResponseProtocol[Page[CashAction]]: ...
+
+    def list(
+        self,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[CashAction] | ApiResponseProtocol[Page[CashAction]]:
+        return self._list(filter=filter, order_by=order_by, top=top, skip=skip, count=count)
+
+    def iter_pages(
+        self,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        count: bool | None = None,
+        start_skip: int = 0,
+        page_size: int = DEFAULT_PAGE_SIZE,
+        max_items: int | None = None,
+    ) -> Iterator[Page[CashAction]]:
+        return self._iter_pages(
+            filter=filter,
+            order_by=order_by,
+            count=count,
+            start_skip=start_skip,
+            page_size=page_size,
+            max_items=max_items,
+        )
+
+    def iter_all(
+        self,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        count: bool | None = None,
+        start_skip: int = 0,
+        page_size: int = DEFAULT_PAGE_SIZE,
+        max_items: int | None = None,
+    ) -> Iterator[CashAction]:
+        return self._iter_all(
+            filter=filter,
+            order_by=order_by,
+            count=count,
+            start_skip=start_skip,
+            page_size=page_size,
+            max_items=max_items,
+        )
+
+    @overload
+    def create(
+        self: CashActionsResource[Literal[False]],
+        cash_action: CashActionCreate | Mapping[str, object],
+    ) -> CashActionCreateResult: ...
+
+    @overload
+    def create(
+        self: CashActionsResource[Literal[True]],
+        cash_action: CashActionCreate | Mapping[str, object],
+    ) -> ApiResponseProtocol[CashActionCreateResult]: ...
+
+    def create(
+        self, cash_action: CashActionCreate | Mapping[str, object]
+    ) -> CashActionCreateResult | ApiResponseProtocol[CashActionCreateResult]:
+        response = self._request("CashActions_Add", json=body_value(cash_action))
+        return self._finish(response, response.data)
+
+    @overload
+    def get(
+        self: CashActionsResource[Literal[False]], cash_action_id: int
+    ) -> CashActionDetails: ...
+
+    @overload
+    def get(
+        self: CashActionsResource[Literal[True]], cash_action_id: int
+    ) -> ApiResponseProtocol[CashActionDetails]: ...
+
+    def get(
+        self, cash_action_id: int
+    ) -> CashActionDetails | ApiResponseProtocol[CashActionDetails]:
+        require_positive_identifier("cash_action_id", cash_action_id)
+        response = self._request("CashActions_Get", path_params={"id": cash_action_id})
+        return self._finish(response, response.data)
+
+    @overload
+    def update(
+        self: CashActionsResource[Literal[False]],
+        cash_action_id: int,
+        patch: CashActionUpdate | Mapping[str, object],
+    ) -> CashActionUpdateResult: ...
+
+    @overload
+    def update(
+        self: CashActionsResource[Literal[True]],
+        cash_action_id: int,
+        patch: CashActionUpdate | Mapping[str, object],
+    ) -> ApiResponseProtocol[CashActionUpdateResult]: ...
+
+    def update(
+        self,
+        cash_action_id: int,
+        patch: CashActionUpdate | Mapping[str, object],
+    ) -> CashActionUpdateResult | ApiResponseProtocol[CashActionUpdateResult]:
+        require_positive_identifier("cash_action_id", cash_action_id)
+        response = self._request(
+            "CashActions_Update",
+            path_params={"id": cash_action_id},
+            json=body_value(patch),
+        )
+        return self._finish(response, response.data)
+
+    @overload
+    def delete_specific(
+        self: CashActionsResource[Literal[False]], cash_action_ids: Sequence[int]
+    ) -> CashActionDeleteResult | None: ...
+
+    @overload
+    def delete_specific(
+        self: CashActionsResource[Literal[True]], cash_action_ids: Sequence[int]
+    ) -> ApiResponseProtocol[CashActionDeleteResult | None]: ...
+
+    def delete_specific(
+        self, cash_action_ids: Sequence[int]
+    ) -> CashActionDeleteResult | None | ApiResponseProtocol[CashActionDeleteResult | None]:
+        """Delete only the explicit IDs; an empty sequence is rejected."""
+
+        ids = list(cash_action_ids)
+        if not ids:
+            raise ValueError("cash_action_ids must contain at least one id")
+        for cash_action_id in ids:
+            require_positive_identifier("cash_action_id", cash_action_id)
+        response = self._request(
+            "CashActions_DeleteCashActions",
+            json={"criteria": {"mode": 1, "ids": ids, "filter": None}},
+        )
+        return self._finish(response, response.data)
+
+    @overload
+    def delete_filtered(
+        self: CashActionsResource[Literal[False]], filter: str
+    ) -> CashActionDeleteResult | None: ...
+
+    @overload
+    def delete_filtered(
+        self: CashActionsResource[Literal[True]], filter: str
+    ) -> ApiResponseProtocol[CashActionDeleteResult | None]: ...
+
+    def delete_filtered(
+        self, filter: str
+    ) -> CashActionDeleteResult | None | ApiResponseProtocol[CashActionDeleteResult | None]:
+        """Delete only cash actions selected by an explicit OData filter."""
+
+        if not isinstance(filter, str):
+            raise TypeError("filter must be a string")
+        if not filter.strip():
+            raise ValueError("filter must not be empty")
+        response = self._request(
+            "CashActions_DeleteCashActions",
+            json={"criteria": {"mode": 0, "ids": None, "filter": filter}},
+        )
+        return self._finish(response, response.data)
+
+    @overload
+    def delete_all(
+        self: CashActionsResource[Literal[False]],
+        *,
+        confirmation: _DeleteAllCashActionsConfirmation,
+    ) -> CashActionDeleteResult | None: ...
+
+    @overload
+    def delete_all(
+        self: CashActionsResource[Literal[True]],
+        *,
+        confirmation: _DeleteAllCashActionsConfirmation,
+    ) -> ApiResponseProtocol[CashActionDeleteResult | None]: ...
+
+    def delete_all(
+        self, *, confirmation: _DeleteAllCashActionsConfirmation
+    ) -> CashActionDeleteResult | None | ApiResponseProtocol[CashActionDeleteResult | None]:
+        """Delete every visible cash action after identity-checked confirmation."""
+
+        if confirmation is not CONFIRM_DELETE_ALL_CASH_ACTIONS:
+            raise ValueError("delete_all requires confirmation=CONFIRM_DELETE_ALL_CASH_ACTIONS")
+        response = self._request(
+            "CashActions_DeleteCashActions",
+            json={"criteria": {"mode": 2, "ids": None, "filter": None}},
+        )
+        return self._finish(response, response.data)

redblack/resources/equivalents.py

@@ -0,0 +1,144 @@
+"""Equivalents resource operations."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import Literal, overload
+
+from ..models import Equivalent, EquivalentExportJob
+from ..odata import DEFAULT_PAGE_SIZE
+from ..pagination import Page
+from ._base import ApiResponseProtocol, HttpInfoMode
+from ._collections import CollectionResource
+from ._exports import ExportJobHandle, ExportOperations, ExportResource
+
+
+class EquivalentsResource(CollectionResource[HttpInfoMode], ExportResource[HttpInfoMode]):
+    """Equivalents, including exports present in the operation contract.
+
+    The narrative export guide is narrower than the normalized operation
+    contract.  Live support for this export family still needs UAT evidence.
+    """
+
+    LIST_OPERATION_ID = "Equivalent_QueryEquivalents"
+    EXPORT_OPERATIONS = ExportOperations(
+        create="Equivalents_ExportJob",
+        status="Equivalents_GetExportJobStatus",
+        file="Equivalents_GetExportFile",
+        body_required=True,
+    )
+    OPERATION_IDS = frozenset(
+        {
+            LIST_OPERATION_ID,
+            EXPORT_OPERATIONS.create,
+            EXPORT_OPERATIONS.status,
+            EXPORT_OPERATIONS.file,
+        }
+    )
+
+    @overload
+    def list(
+        self: EquivalentsResource[Literal[False]],
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[Equivalent]: ...
+
+    @overload
+    def list(
+        self: EquivalentsResource[Literal[True]],
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> ApiResponseProtocol[Page[Equivalent]]: ...
+
+    def list(
+        self,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[Equivalent] | ApiResponseProtocol[Page[Equivalent]]:
+        return self._list(filter=filter, order_by=order_by, top=top, skip=skip, count=count)
+
+    def iter_pages(
+        self,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        count: bool | None = None,
+        start_skip: int = 0,
+        page_size: int = DEFAULT_PAGE_SIZE,
+        max_items: int | None = None,
+    ) -> Iterator[Page[Equivalent]]:
+        return self._iter_pages(
+            filter=filter,
+            order_by=order_by,
+            count=count,
+            start_skip=start_skip,
+            page_size=page_size,
+            max_items=max_items,
+        )
+
+    def iter_all(
+        self,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        count: bool | None = None,
+        start_skip: int = 0,
+        page_size: int = DEFAULT_PAGE_SIZE,
+        max_items: int | None = None,
+    ) -> Iterator[Equivalent]:
+        return self._iter_all(
+            filter=filter,
+            order_by=order_by,
+            count=count,
+            start_skip=start_skip,
+            page_size=page_size,
+            max_items=max_items,
+        )
+
+    @overload
+    def create_export(
+        self: EquivalentsResource[Literal[False]], *, filter: str | None = None
+    ) -> ExportJobHandle[EquivalentExportJob]: ...
+
+    @overload
+    def create_export(
+        self: EquivalentsResource[Literal[True]], *, filter: str | None = None
+    ) -> ApiResponseProtocol[ExportJobHandle[EquivalentExportJob]]: ...
+
+    def create_export(
+        self, *, filter: str | None = None
+    ) -> (
+        ExportJobHandle[EquivalentExportJob]
+        | ApiResponseProtocol[ExportJobHandle[EquivalentExportJob]]
+    ):
+        return self._create_export(filter=filter)
+
+    @overload
+    def get_export(
+        self: EquivalentsResource[Literal[False]], job_id: int
+    ) -> ExportJobHandle[EquivalentExportJob]: ...
+
+    @overload
+    def get_export(
+        self: EquivalentsResource[Literal[True]], job_id: int
+    ) -> ApiResponseProtocol[ExportJobHandle[EquivalentExportJob]]: ...
+
+    def get_export(
+        self, job_id: int
+    ) -> (
+        ExportJobHandle[EquivalentExportJob]
+        | ApiResponseProtocol[ExportJobHandle[EquivalentExportJob]]
+    ):
+        return self._get_export(job_id)

redblack/resources/households.py

@@ -0,0 +1,138 @@
+"""Households resource operations."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import Literal, overload
+
+from ..models import Household, HouseholdExportJob
+from ..odata import DEFAULT_PAGE_SIZE
+from ..pagination import Page
+from ._base import ApiResponseProtocol, HttpInfoMode
+from ._collections import CollectionResource
+from ._exports import ExportJobHandle, ExportOperations, ExportResource
+
+
+class HouseholdsResource(CollectionResource[HttpInfoMode], ExportResource[HttpInfoMode]):
+    LIST_OPERATION_ID = "Households_QueryHouseholds"
+    EXPORT_OPERATIONS = ExportOperations(
+        create="Households_BulkExport",
+        status="Households_GetBulkExportSessionStatus",
+        file="Households_GetBulkExportFile",
+        body_required=False,
+    )
+    OPERATION_IDS = frozenset(
+        {
+            LIST_OPERATION_ID,
+            EXPORT_OPERATIONS.create,
+            EXPORT_OPERATIONS.status,
+            EXPORT_OPERATIONS.file,
+        }
+    )
+
+    @overload
+    def list(
+        self: HouseholdsResource[Literal[False]],
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[Household]: ...
+
+    @overload
+    def list(
+        self: HouseholdsResource[Literal[True]],
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> ApiResponseProtocol[Page[Household]]: ...
+
+    def list(
+        self,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[Household] | ApiResponseProtocol[Page[Household]]:
+        return self._list(filter=filter, order_by=order_by, top=top, skip=skip, count=count)
+
+    def iter_pages(
+        self,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        count: bool | None = None,
+        start_skip: int = 0,
+        page_size: int = DEFAULT_PAGE_SIZE,
+        max_items: int | None = None,
+    ) -> Iterator[Page[Household]]:
+        return self._iter_pages(
+            filter=filter,
+            order_by=order_by,
+            count=count,
+            start_skip=start_skip,
+            page_size=page_size,
+            max_items=max_items,
+        )
+
+    def iter_all(
+        self,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        count: bool | None = None,
+        start_skip: int = 0,
+        page_size: int = DEFAULT_PAGE_SIZE,
+        max_items: int | None = None,
+    ) -> Iterator[Household]:
+        return self._iter_all(
+            filter=filter,
+            order_by=order_by,
+            count=count,
+            start_skip=start_skip,
+            page_size=page_size,
+            max_items=max_items,
+        )
+
+    @overload
+    def create_export(
+        self: HouseholdsResource[Literal[False]], *, filter: str | None = None
+    ) -> ExportJobHandle[HouseholdExportJob]: ...
+
+    @overload
+    def create_export(
+        self: HouseholdsResource[Literal[True]], *, filter: str | None = None
+    ) -> ApiResponseProtocol[ExportJobHandle[HouseholdExportJob]]: ...
+
+    def create_export(
+        self, *, filter: str | None = None
+    ) -> (
+        ExportJobHandle[HouseholdExportJob]
+        | ApiResponseProtocol[ExportJobHandle[HouseholdExportJob]]
+    ):
+        return self._create_export(filter=filter)
+
+    @overload
+    def get_export(
+        self: HouseholdsResource[Literal[False]], job_id: int
+    ) -> ExportJobHandle[HouseholdExportJob]: ...
+
+    @overload
+    def get_export(
+        self: HouseholdsResource[Literal[True]], job_id: int
+    ) -> ApiResponseProtocol[ExportJobHandle[HouseholdExportJob]]: ...
+
+    def get_export(
+        self, job_id: int
+    ) -> (
+        ExportJobHandle[HouseholdExportJob]
+        | ApiResponseProtocol[ExportJobHandle[HouseholdExportJob]]
+    ):
+        return self._get_export(job_id)

redblack/resources/orders.py

@@ -0,0 +1,118 @@
+"""Trade Blotter and Trade Reconciliation order queries (API 2026.3.0)."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import Literal, overload
+
+from ..models import Order, OrderFilterType
+from ..odata import DEFAULT_PAGE_SIZE
+from ..pagination import Page
+from ._base import ApiResponseProtocol, HttpInfoMode
+from ._collections import CollectionResource
+
+
+class OrdersResource(CollectionResource[HttpInfoMode]):
+    """List active/deleted blotter orders or orders in reconciliation.
+
+    Orders still in review sets use ``review_sets.list_pending_orders()``.
+    Omitting ``filter_type`` leaves the server default (active orders) intact.
+    """
+
+    LIST_OPERATION_ID = "Orders_QueryOrders"
+    OPERATION_IDS = frozenset({LIST_OPERATION_ID})
+
+    @overload
+    def list(
+        self: OrdersResource[Literal[False]],
+        *,
+        filter_type: OrderFilterType | Literal[0, 1, 2] | None = None,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[Order]: ...
+
+    @overload
+    def list(
+        self: OrdersResource[Literal[True]],
+        *,
+        filter_type: OrderFilterType | Literal[0, 1, 2] | None = None,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> ApiResponseProtocol[Page[Order]]: ...
+
+    def list(
+        self,
+        *,
+        filter_type: OrderFilterType | Literal[0, 1, 2] | None = None,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[Order] | ApiResponseProtocol[Page[Order]]:
+        return self._list(
+            filter=filter,
+            order_by=order_by,
+            top=top,
+            skip=skip,
+            count=count,
+            extra_query=_filter_query(filter_type),
+        )
+
+    def iter_pages(
+        self,
+        *,
+        filter_type: OrderFilterType | Literal[0, 1, 2] | None = None,
+        filter: str | None = None,
+        order_by: str | None = None,
+        count: bool | None = None,
+        start_skip: int = 0,
+        page_size: int = DEFAULT_PAGE_SIZE,
+        max_items: int | None = None,
+    ) -> Iterator[Page[Order]]:
+        return self._iter_pages(
+            filter=filter,
+            order_by=order_by,
+            count=count,
+            start_skip=start_skip,
+            page_size=page_size,
+            max_items=max_items,
+            extra_query=_filter_query(filter_type),
+        )
+
+    def iter_all(
+        self,
+        *,
+        filter_type: OrderFilterType | Literal[0, 1, 2] | None = None,
+        filter: str | None = None,
+        order_by: str | None = None,
+        count: bool | None = None,
+        start_skip: int = 0,
+        page_size: int = DEFAULT_PAGE_SIZE,
+        max_items: int | None = None,
+    ) -> Iterator[Order]:
+        return self._iter_all(
+            filter=filter,
+            order_by=order_by,
+            count=count,
+            start_skip=start_skip,
+            page_size=page_size,
+            max_items=max_items,
+            extra_query=_filter_query(filter_type),
+        )
+
+
+def _filter_query(
+    filter_type: OrderFilterType | Literal[0, 1, 2] | None,
+) -> dict[str, object]:
+    if filter_type is None:
+        return {}
+    if isinstance(filter_type, bool) or not isinstance(filter_type, int):
+        raise TypeError("filter_type must be an OrderFilterType or integer 0, 1, or 2")
+    return {"filter-type": OrderFilterType(filter_type)}