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

redblack/resources/securities.py

@@ -0,0 +1,175 @@
+"""Securities and sweep-securities collection operations."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import Any, Literal, overload
+
+from ..models import Security, SweepSecurity
+from ..odata import DEFAULT_PAGE_SIZE, ODataQuery
+from ..pagination import Page, Paginator
+from ._base import ApiResponseProtocol, HttpInfoMode, Resource
+
+
+class SecuritiesResource(Resource[HttpInfoMode]):
+    OPERATION_IDS = frozenset({"Securities_Query", "Securities_QuerySweep"})
+
+    def _list_operation(
+        self,
+        operation_id: str,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[Any] | ApiResponseProtocol[Page[Any]]:
+        return self._page(
+            operation_id,
+            odata=ODataQuery(
+                filter=filter,
+                order_by=order_by,
+                top=top,
+                skip=skip,
+                count=count,
+            ),
+        )
+
+    @overload
+    def list(
+        self: SecuritiesResource[Literal[False]],
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[Security]: ...
+
+    @overload
+    def list(
+        self: SecuritiesResource[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[Security]]: ...
+
+    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[Security] | ApiResponseProtocol[Page[Security]]:
+        return self._list_operation(
+            "Securities_Query",
+            filter=filter,
+            order_by=order_by,
+            top=top,
+            skip=skip,
+            count=count,
+        )
+
+    @overload
+    def list_sweeps(
+        self: SecuritiesResource[Literal[False]],
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[SweepSecurity]: ...
+
+    @overload
+    def list_sweeps(
+        self: SecuritiesResource[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[SweepSecurity]]: ...
+
+    def list_sweeps(
+        self,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[SweepSecurity] | ApiResponseProtocol[Page[SweepSecurity]]:
+        return self._list_operation(
+            "Securities_QuerySweep",
+            filter=filter,
+            order_by=order_by,
+            top=top,
+            skip=skip,
+            count=count,
+        )
+
+    def _iterator(
+        self,
+        operation_id: str,
+        *,
+        filter: str | None,
+        order_by: str | None,
+        count: bool | None,
+        start_skip: int,
+        page_size: int,
+        max_items: int | None,
+    ) -> Paginator[Any]:
+        base = ODataQuery(filter=filter, order_by=order_by, count=count, skip=start_skip)
+        return Paginator(
+            fetch_page=lambda query: self._page_value(operation_id, odata=query),
+            query=base,
+            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[Security]:
+        return self._iterator(
+            "Securities_Query",
+            filter=filter,
+            order_by=order_by,
+            count=count,
+            start_skip=start_skip,
+            page_size=page_size,
+            max_items=max_items,
+        ).iter_items()
+
+    def iter_all_sweeps(
+        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[SweepSecurity]:
+        return self._iterator(
+            "Securities_QuerySweep",
+            filter=filter,
+            order_by=order_by,
+            count=count,
+            start_skip=start_skip,
+            page_size=page_size,
+            max_items=max_items,
+        ).iter_items()

redblack/resources/tasks.py

@@ -0,0 +1,291 @@
+"""Task resources, settings lookups, and ETag-protected mutations."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator, Mapping
+from typing import Any, Literal, overload
+
+from ..models import (
+    Task,
+    TaskCreate,
+    TaskCreateResult,
+    TaskListItem,
+    TaskStatus,
+    TaskType,
+    TaskUpdate,
+    TaskUpdateResult,
+)
+from ..odata import DEFAULT_PAGE_SIZE, ODataQuery
+from ..pagination import Page, Paginator
+from ._base import (
+    ApiResponseProtocol,
+    HttpInfoMode,
+    Resource,
+    VersionedResource,
+    body_value,
+    require_etag,
+    require_positive_identifier,
+    response_header,
+)
+
+
+class TasksResource(Resource[HttpInfoMode]):
+    OPERATION_IDS = frozenset(
+        {
+            "TaskSettings_ListTypes",
+            "TaskSettings_ListStatuses",
+            "Tasks_ListTasks",
+            "Tasks_Add",
+            "Tasks_Get",
+            "Tasks_Delete",
+            "Tasks_Update",
+        }
+    )
+
+    def _collection(
+        self,
+        operation_id: str,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[Any] | ApiResponseProtocol[Page[Any]]:
+        return self._page(
+            operation_id,
+            odata=ODataQuery(
+                filter=filter,
+                order_by=order_by,
+                top=top,
+                skip=skip,
+                count=count,
+            ),
+        )
+
+    @overload
+    def list(
+        self: TasksResource[Literal[False]],
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[TaskListItem]: ...
+
+    @overload
+    def list(
+        self: TasksResource[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[TaskListItem]]: ...
+
+    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[TaskListItem] | ApiResponseProtocol[Page[TaskListItem]]:
+        return self._collection(
+            "Tasks_ListTasks",
+            filter=filter,
+            order_by=order_by,
+            top=top,
+            skip=skip,
+            count=count,
+        )
+
+    @overload
+    def list_types(
+        self: TasksResource[Literal[False]],
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[TaskType]: ...
+
+    @overload
+    def list_types(
+        self: TasksResource[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[TaskType]]: ...
+
+    def list_types(
+        self,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[TaskType] | ApiResponseProtocol[Page[TaskType]]:
+        return self._collection(
+            "TaskSettings_ListTypes",
+            filter=filter,
+            order_by=order_by,
+            top=top,
+            skip=skip,
+            count=count,
+        )
+
+    @overload
+    def list_statuses(
+        self: TasksResource[Literal[False]],
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[TaskStatus]: ...
+
+    @overload
+    def list_statuses(
+        self: TasksResource[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[TaskStatus]]: ...
+
+    def list_statuses(
+        self,
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[TaskStatus] | ApiResponseProtocol[Page[TaskStatus]]:
+        return self._collection(
+            "TaskSettings_ListStatuses",
+            filter=filter,
+            order_by=order_by,
+            top=top,
+            skip=skip,
+            count=count,
+        )
+
+    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[TaskListItem]:
+        base = ODataQuery(filter=filter, order_by=order_by, count=count, skip=start_skip)
+        return Paginator(
+            fetch_page=lambda query: self._page_value("Tasks_ListTasks", odata=query),
+            query=base,
+            page_size=page_size,
+            max_items=max_items,
+        ).iter_items()
+
+    @overload
+    def create(
+        self: TasksResource[Literal[False]], task: TaskCreate | Mapping[str, object]
+    ) -> TaskCreateResult: ...
+
+    @overload
+    def create(
+        self: TasksResource[Literal[True]], task: TaskCreate | Mapping[str, object]
+    ) -> ApiResponseProtocol[TaskCreateResult]: ...
+
+    def create(
+        self, task: TaskCreate | Mapping[str, object]
+    ) -> TaskCreateResult | ApiResponseProtocol[TaskCreateResult]:
+        response = self._request("Tasks_Add", json=body_value(task))
+        return self._finish(response, response.data)
+
+    @overload
+    def get(self: TasksResource[Literal[False]], task_id: int) -> VersionedResource[Task]: ...
+
+    @overload
+    def get(
+        self: TasksResource[Literal[True]], task_id: int
+    ) -> ApiResponseProtocol[VersionedResource[Task]]: ...
+
+    def get(
+        self, task_id: int
+    ) -> VersionedResource[Task] | ApiResponseProtocol[VersionedResource[Task]]:
+        require_positive_identifier("task_id", task_id)
+        response = self._request("Tasks_Get", path_params={"id": task_id})
+        versioned = VersionedResource(
+            data=response.data,
+            etag=response_header(response, "ETag"),
+            http=response.http,
+        )
+        return self._finish(response, versioned)
+
+    @overload
+    def update(
+        self: TasksResource[Literal[False]],
+        task_id: int,
+        patch: TaskUpdate | Mapping[str, object],
+        *,
+        if_match: str,
+    ) -> TaskUpdateResult: ...
+
+    @overload
+    def update(
+        self: TasksResource[Literal[True]],
+        task_id: int,
+        patch: TaskUpdate | Mapping[str, object],
+        *,
+        if_match: str,
+    ) -> ApiResponseProtocol[TaskUpdateResult]: ...
+
+    def update(
+        self,
+        task_id: int,
+        patch: TaskUpdate | Mapping[str, object],
+        *,
+        if_match: str,
+    ) -> TaskUpdateResult | ApiResponseProtocol[TaskUpdateResult]:
+        require_positive_identifier("task_id", task_id)
+        require_etag(if_match)
+        response = self._request(
+            "Tasks_Update",
+            path_params={"id": task_id},
+            headers={"If-Match": if_match},
+            json=body_value(patch),
+        )
+        return self._finish(response, response.data)
+
+    @overload
+    def delete(self: TasksResource[Literal[False]], task_id: int, *, if_match: str) -> None: ...
+
+    @overload
+    def delete(
+        self: TasksResource[Literal[True]], task_id: int, *, if_match: str
+    ) -> ApiResponseProtocol[None]: ...
+
+    def delete(self, task_id: int, *, if_match: str) -> None | ApiResponseProtocol[None]:
+        require_positive_identifier("task_id", task_id)
+        require_etag(if_match)
+        response = self._request(
+            "Tasks_Delete",
+            path_params={"id": task_id},
+            headers={"If-Match": if_match},
+        )
+        return self._finish(response, response.data)

redblack/resources/users.py

@@ -0,0 +1,88 @@
+"""API users collection operations."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from typing import Literal, overload
+
+from ..models import User
+from ..odata import DEFAULT_PAGE_SIZE
+from ..pagination import Page
+from ._base import ApiResponseProtocol, HttpInfoMode
+from ._collections import CollectionResource
+
+
+class UsersResource(CollectionResource[HttpInfoMode]):
+    LIST_OPERATION_ID = "Users_ListUsers"
+    OPERATION_IDS = frozenset({LIST_OPERATION_ID})
+
+    @overload
+    def list(
+        self: UsersResource[Literal[False]],
+        *,
+        filter: str | None = None,
+        order_by: str | None = None,
+        top: int | None = None,
+        skip: int | None = None,
+        count: bool | None = None,
+    ) -> Page[User]: ...
+
+    @overload
+    def list(
+        self: UsersResource[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[User]]: ...
+
+    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[User] | ApiResponseProtocol[Page[User]]:
+        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[User]]:
+        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[User]:
+        return self._iter_all(
+            filter=filter,
+            order_by=order_by,
+            count=count,
+            start_skip=start_skip,
+            page_size=page_size,
+            max_items=max_items,
+        )

redblack/response.py

@@ -0,0 +1,118 @@
+"""HTTP metadata containers shared by typed and raw SDK responses."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator, Mapping
+from dataclasses import dataclass, field
+from typing import Generic, TypeVar
+
+from .errors import sanitize_url
+
+T = TypeVar("T")
+U = TypeVar("U")
+
+
+class ResponseHeaders(Mapping[str, str]):
+    """An immutable, case-insensitive mapping of safe response headers."""
+
+    __slots__ = ("_values",)
+
+    def __init__(self, values: Mapping[str, str] | None = None) -> None:
+        self._values = {str(name).lower(): str(value) for name, value in (values or {}).items()}
+
+    def __getitem__(self, name: str) -> str:
+        return self._values[name.lower()]
+
+    def __iter__(self) -> Iterator[str]:
+        return iter(self._values)
+
+    def __len__(self) -> int:
+        return len(self._values)
+
+    def __repr__(self) -> str:
+        return f"ResponseHeaders({self._values!r})"
+
+
+@dataclass(frozen=True, slots=True, repr=False)
+class HttpMetadata:
+    """Non-wire metadata associated with a decoded response.
+
+    ``location`` may contain a short-lived signed URL and is intentionally
+    omitted from representations. ``headers`` contains a sanitized Location
+    value, while this dedicated property retains the value for an explicitly
+    requested export workflow.
+    """
+
+    status_code: int
+    method: str
+    url: str
+    headers: Mapping[str, str] = field(default_factory=ResponseHeaders)
+    request_id: str | None = None
+    etag: str | None = None
+    location: str | None = field(default=None, repr=False)
+    attempts: int = 1
+    elapsed: float | None = None
+
+    def __post_init__(self) -> None:
+        object.__setattr__(self, "method", self.method.upper())
+        object.__setattr__(self, "url", sanitize_url(self.url))
+        if not isinstance(self.headers, ResponseHeaders):
+            object.__setattr__(self, "headers", ResponseHeaders(self.headers))
+        if self.attempts < 1:
+            raise ValueError("attempts must be at least 1")
+
+    def __repr__(self) -> str:
+        return (
+            "HttpMetadata("
+            f"status_code={self.status_code!r}, method={self.method!r}, "
+            "url=<redacted>, "
+            f"headers={self.headers!r}, "
+            f"request_id={self.request_id!r}, etag={self.etag!r}, "
+            f"has_location={self.location is not None}, attempts={self.attempts!r}, "
+            f"elapsed={self.elapsed!r})"
+        )
+
+
+@dataclass(frozen=True, slots=True)
+class ApiResponse(Generic[T]):
+    """A decoded value plus safe transport details."""
+
+    data: T
+    http: HttpMetadata
+    raw: bytes = field(default=b"", repr=False)
+
+    def __post_init__(self) -> None:
+        if not self.raw and isinstance(self.data, bytes):
+            object.__setattr__(self, "raw", self.data)
+
+    @property
+    def status_code(self) -> int:
+        return self.http.status_code
+
+    @property
+    def headers(self) -> Mapping[str, str]:
+        return self.http.headers
+
+    @property
+    def url(self) -> str:
+        return self.http.url
+
+    @property
+    def location(self) -> str | None:
+        return self.http.location
+
+    @property
+    def request_id(self) -> str | None:
+        return self.http.request_id
+
+    @property
+    def etag(self) -> str | None:
+        return self.http.etag
+
+    def with_data(self, value: U) -> ApiResponse[U]:
+        """Return the same HTTP response information with a decoded value."""
+
+        return ApiResponse(data=value, http=self.http, raw=self.raw)
+
+
+__all__ = ["ApiResponse", "HttpMetadata", "ResponseHeaders"]