convert to classes

Author: Phil Varner

stapi-fastapi/src/stapi_fastapi/backends/__init__.py

@@ -7,7 +7,6 @@
 from .root_backend import (
     GetOpportunitySearchRecord,
     GetOpportunitySearchRecords,
-    GetOrder,
     GetOrders,
     GetOrderStatuses,
 )
@@ -17,7 +16,6 @@
     "GetOpportunityCollection",
     "GetOpportunitySearchRecord",
     "GetOpportunitySearchRecords",
-    "GetOrder",
     "GetOrders",
     "GetOrderStatuses",
     "SearchOpportunities",

stapi-fastapi/src/stapi_fastapi/backends/root_backend.py

@@ -1,3 +1,4 @@
+from abc import abstractmethod
 from collections.abc import Callable, Coroutine
 from typing import Any, Generic, Protocol
 
@@ -8,70 +9,74 @@
 
 
 class GetOrders(Protocol, Generic[OrderStatusBound]):
-    """Callable class wrapping an async method that returns a list of Orders.
+    """Interface for getting a list of orders or a single order."""
 
-    Args:
-        next (str | None): A pagination token.
-        limit (int): The maximum number of orders to return in a page.
-        request (Request): FastAPI's Request object.
-
-    Returns:
-        A tuple containing a list of orders and a pagination token.
-
-        - Should return returns.result.Success[tuple[list[Order], returns.maybe.Some[str]]]
-          if including a pagination token
-        - Should return returns.result.Success[tuple[list[Order], returns.maybe.Nothing]]
-          if not including a pagination token
-        - Returning returns.result.Failure[Exception] will result in a 500.
-    """
-
-    async def __call__(
+    @abstractmethod
+    async def get_orders(
         self,
         next: str | None,
         limit: int,
         request: Request,
-    ) -> ResultE[tuple[list[Order[OrderStatusBound]], Maybe[str], Maybe[int]]]: ...
+    ) -> ResultE[tuple[list[Order[OrderStatusBound]], Maybe[str], Maybe[int]]]:
+        """Get a list of Order objects.
 
+        Args:
+            next (str | None): A pagination token.
+            limit (int): The maximum number of orders to return in a page.
+            request (Request): FastAPI's Request object.
 
-class GetOrder(Protocol, Generic[OrderStatusBound]):
-    """Callable class wrapping an async method that gets details for the order with `order_id`.
+        Returns:
+            A tuple containing a list of orders and a pagination token.
 
-    Args:
-        order_id (str): The order ID.
-        request (Request): FastAPI's Request object.
+            - Should return returns.result.Success[tuple[list[Order], returns.maybe.Some[str]]]
+              if including a pagination token
+            - Should return returns.result.Success[tuple[list[Order], returns.maybe.Nothing]]
+              if not including a pagination token
+            - Returning returns.result.Failure[Exception] will result in a 500.
+        """
 
-    Returns:
-        - Should return returns.result.Success[returns.maybe.Some[Order]] if order is found.
-        - Should return returns.result.Success[returns.maybe.Nothing] if the order is not found or if access is denied.
-        - Returning returns.result.Failure[Exception] will result in a 500.
-    """
+    @abstractmethod
+    async def get_order(self, order_id: str, request: Request) -> ResultE[Maybe[Order[OrderStatusBound]]]:
+        """Get details for the order with `order_id`.
 
-    async def __call__(self, order_id: str, request: Request) -> ResultE[Maybe[Order[OrderStatusBound]]]: ...
+        Args:
+            order_id (str): The order ID.
+            request (Request): FastAPI's Request object.
+
+        Returns:
+            - Should return returns.result.Success[returns.maybe.Some[Order]] if order is found.
+            - Should return returns.result.Success[returns.maybe.Nothing] if the order is not found or if access is
+              denied.
+            - Returning returns.result.Failure[Exception] will result in a 500.
+        """
 
 
 class GetOrderStatuses(Protocol, Generic[OrderStatusBound]):
-    """Callable class wrapping an async method that gets statuses for the order with `order_id`.
-
-    Args:
-        order_id (str): The order ID.
-        next (str | None): A pagination token.
-        limit (int): The maximum number of statuses to return in a page.
-        request (Request): FastAPI's Request object.
-
-    Returns:
-        A tuple containing a list of order statuses and a pagination token.
-
-        - Should return returns.result.Success[returns.maybe.Some[tuple[list[OrderStatus], returns.maybe.Some[str]]]
-          if order is found and including a pagination token.
-        - Should return returns.result.Success[returns.maybe.Some[tuple[list[OrderStatus], returns.maybe.Nothing]]]
-          if order is found and not including a pagination token.
-        - Should return returns.result.Success[returns.maybe.Nothing] if the order is not found or if access is denied.
-        - Returning returns.result.Failure[Exception] will result in a 500.
-    """
-
-    async def __call__(
+    """Callable class wrapping an async method that gets statuses for the order with `order_id`."""
+
+    @abstractmethod
+    async def get_order_statuses(
         self, order_id: str, _next: str | None, limit: int, request: Request
-    ) -> ResultE[Maybe[tuple[list[OrderStatusBound], Maybe[str]]]]: ...
+    ) -> ResultE[Maybe[tuple[list[OrderStatusBound], Maybe[str]]]]:
+        """Method that gets statuses for the order with `order_id`.
+
+        Args:
+            order_id (str): The order ID.
+            next (str | None): A pagination token.
+            limit (int): The maximum number of statuses to return in a page.
+            request (Request): FastAPI's Request object.
+
+        Returns:
+            A tuple containing a list of order statuses and a pagination token.
+
+            - Should return returns.result.Success[returns.maybe.Some[tuple[list[OrderStatus], returns.maybe.Some[str]]]
+              if order is found and including a pagination token.
+            - Should return returns.result.Success[returns.maybe.Some[tuple[list[OrderStatus], returns.maybe.Nothing]]]
+              if order is found and not including a pagination token.
+            - Should return returns.result.Success[returns.maybe.Nothing] if the order is not found or if access is
+              denied.
+            - Returning returns.result.Failure[Exception] will result in a 500.
+        """
 
 
 GetOpportunitySearchRecords = Callable[

stapi-fastapi/src/stapi_fastapi/routers/root_router.py

@@ -26,7 +26,6 @@
     GetOpportunitySearchRecord,
     GetOpportunitySearchRecords,
     GetOpportunitySearchRecordStatuses,
-    GetOrder,
     GetOrders,
     GetOrderStatuses,
 )
@@ -83,7 +82,6 @@ class RootRouter(StapiFastapiBaseRouter, RootProvider, Generic[OrderStatusBound]
     def __init__(
         self,
         get_orders: GetOrders[OrderStatusBound],
-        get_order: GetOrder[OrderStatusBound],
         get_order_statuses: GetOrderStatuses[OrderStatusBound] | None = None,
         get_opportunity_search_records: GetOpportunitySearchRecords | None = None,
         get_opportunity_search_record: GetOpportunitySearchRecord | None = None,
@@ -100,7 +98,6 @@ def __init__(
         _conformances = set(conformances)
 
         self._get_orders = get_orders
-        self._get_order = get_order
         self.__get_order_statuses = get_order_statuses
         self.__get_opportunity_search_records = get_opportunity_search_records
         self.__get_opportunity_search_record = get_opportunity_search_record
@@ -275,7 +272,7 @@ async def get_orders(  # noqa: C901
     ) -> OrderCollection[OrderStatusBound]:
         links: list[Link] = []
         orders_count: int | None = None
-        match await self._get_orders(next, limit, request):
+        match await self._get_orders.get_orders(next, limit, request):
             case Success((orders, maybe_pagination_token, maybe_orders_count)):
                 for order in orders:
                     order.links.extend(self.order_links(order, request))
@@ -313,7 +310,7 @@ async def get_order(self, order_id: str, request: Request) -> Order[OrderStatus]
         """
         Get details for order with `order_id`.
         """
-        match await self._get_order(order_id, request):
+        match await self._get_orders.get_order(order_id, request):
             case Success(Some(order)):
                 order.links.extend(self.order_links(order, request))
                 return order  # type: ignore
@@ -340,7 +337,7 @@ async def get_order_statuses(
         limit: int = 10,
     ) -> OrderStatuses[OrderStatusBound]:
         links: list[Link] = []
-        match await self._get_order_statuses(order_id, next, limit, request):
+        match await self._get_order_statuses.get_order_statuses(order_id, next, limit, request):
             case Success(Some((statuses, maybe_pagination_token))):
                 links.append(self.order_statuses_link(request, order_id))
                 match maybe_pagination_token:

stapi-fastapi/tests/application.py

@@ -7,11 +7,10 @@
 from stapi_fastapi.routers.root_router import RootRouter
 
 from tests.backends import (
+    MockGetOrders,
+    MockGetOrderStatuses,
     mock_get_opportunity_search_record,
     mock_get_opportunity_search_records,
-    mock_get_order,
-    mock_get_order_statuses,
-    mock_get_orders,
 )
 from tests.shared import (
     InMemoryOpportunityDB,
@@ -30,9 +29,8 @@ async def lifespan(app: FastAPI) -> AsyncIterator[dict[str, Any]]:
 
 
 root_router = RootRouter(
-    get_orders=mock_get_orders,
-    get_order=mock_get_order,
-    get_order_statuses=mock_get_order_statuses,
+    get_orders=MockGetOrders(),
+    get_order_statuses=MockGetOrderStatuses(),
     get_opportunity_search_records=mock_get_opportunity_search_records,
     get_opportunity_search_record=mock_get_opportunity_search_record,
     conformances=[API.core],

stapi-fastapi/tests/backends.py

@@ -4,6 +4,7 @@
 from fastapi import Request
 from returns.maybe import Maybe, Nothing, Some
 from returns.result import Failure, ResultE, Success
+from stapi_fastapi.backends.root_backend import GetOrders, GetOrderStatuses
 from stapi_fastapi.routers.product_router import ProductRouter
 from stapi_pydantic import (
     Opportunity,
@@ -21,63 +22,65 @@
 )
 
 
-async def mock_get_orders(
-    next: str | None,
-    limit: int,
-    request: Request,
-) -> ResultE[tuple[list[Order], Maybe[str], Maybe[int]]]:
-    """
-    Return orders from backend.  Handle pagination/limit if applicable
-    """
-    count = 314
-    try:
-        start = 0
-        limit = min(limit, 100)
-        order_ids = [*request.state._orders_db._orders.keys()]
-
-        if next:
-            start = order_ids.index(next)
-        end = start + limit
-        ids = order_ids[start:end]
-        orders = [request.state._orders_db.get_order(order_id) for order_id in ids]
-
-        if end > 0 and end < len(order_ids):
-            return Success((orders, Some(request.state._orders_db._orders[order_ids[end]].id), Some(count)))
-        return Success((orders, Nothing, Some(count)))
-    except Exception as e:
-        return Failure(e)
-
-
-async def mock_get_order(order_id: str, request: Request) -> ResultE[Maybe[Order]]:
-    """
-    Show details for order with `order_id`.
-    """
-    try:
-        return Success(Maybe.from_optional(request.state._orders_db.get_order(order_id)))
-    except Exception as e:
-        return Failure(e)
-
-
-async def mock_get_order_statuses(
-    order_id: str, next: str | None, limit: int, request: Request
-) -> ResultE[Maybe[tuple[list[OrderStatus], Maybe[str]]]]:
-    try:
-        start = 0
-        limit = min(limit, 100)
-        statuses = request.state._orders_db.get_order_statuses(order_id)
-        if statuses is None:
-            return Success(Nothing)
-
-        if next:
-            start = int(next)
-        end = start + limit
-        stati = statuses[start:end]
-
-        if end > 0 and end < len(statuses):
-            return Success(Some((stati, Some(str(end)))))
-        return Success(Some((stati, Nothing)))
-    except Exception as e:
-        return Failure(e)
+class MockGetOrders(GetOrders):
+    async def get_orders(
+        self,
+        next: str | None,
+        limit: int,
+        request: Request,
+    ) -> ResultE[tuple[list[Order], Maybe[str], Maybe[int]]]:
+        """
+        Return orders from backend.  Handle pagination/limit if applicable
+        """
+        count = 314
+        try:
+            start = 0
+            limit = min(limit, 100)
+            order_ids = [*request.state._orders_db._orders.keys()]
+
+            if next:
+                start = order_ids.index(next)
+            end = start + limit
+            ids = order_ids[start:end]
+            orders = [request.state._orders_db.get_order(order_id) for order_id in ids]
+
+            if end > 0 and end < len(order_ids):
+                return Success((orders, Some(request.state._orders_db._orders[order_ids[end]].id), Some(count)))
+            return Success((orders, Nothing, Some(count)))
+        except Exception as e:
+            return Failure(e)
+
+    async def get_order(self, order_id: str, request: Request) -> ResultE[Maybe[Order]]:
+        """
+        Show details for order with `order_id`.
+        """
+        try:
+            return Success(Maybe.from_optional(request.state._orders_db.get_order(order_id)))
+        except Exception as e:
+            return Failure(e)
+
+
+class MockGetOrderStatuses(GetOrderStatuses):
+    async def get_order_statuses(
+        self, order_id: str, next: str | None, limit: int, request: Request
+    ) -> ResultE[Maybe[tuple[list[OrderStatus], Maybe[str]]]]:
+        try:
+            start = 0
+            limit = min(limit, 100)
+            statuses = request.state._orders_db.get_order_statuses(order_id)
+            if statuses is None:
+                return Success(Nothing)
+
+            if next:
+                start = int(next)
+            end = start + limit
+            stati = statuses[start:end]
+
+            if end > 0 and end < len(statuses):
+                return Success(Some((stati, Some(str(end)))))
+            return Success(Some((stati, Nothing)))
+        except Exception as e:
+            return Failure(e)
 
 
 async def mock_create_order(product_router: ProductRouter, payload: OrderPayload, request: Request) -> ResultE[Order]:

stapi-fastapi/tests/conftest.py

@@ -17,12 +17,11 @@
 )
 
 from .backends import (
+    MockGetOrders,
+    MockGetOrderStatuses,
     mock_get_opportunity_search_record,
     mock_get_opportunity_search_record_statuses,
     mock_get_opportunity_search_records,
-    mock_get_order,
-    mock_get_order_statuses,
-    mock_get_orders,
 )
 from .shared import (
     InMemoryOpportunityDB,
@@ -72,9 +71,8 @@ async def lifespan(app: FastAPI) -> AsyncIterator[dict[str, Any]]:
             pass
 
     root_router = RootRouter(
-        get_orders=mock_get_orders,
-        get_order=mock_get_order,
-        get_order_statuses=mock_get_order_statuses,
+        get_orders=MockGetOrders(),
+        get_order_statuses=MockGetOrderStatuses(),
         conformances=[API.core],
     )
 
@@ -107,9 +105,8 @@ async def lifespan(app: FastAPI) -> AsyncIterator[dict[str, Any]]:
             pass
 
     root_router = RootRouter(
-        get_orders=mock_get_orders,
-        get_order=mock_get_order,
-        get_order_statuses=mock_get_order_statuses,
+        get_orders=MockGetOrders(),
+        get_order_statuses=MockGetOrderStatuses(),
         get_opportunity_search_records=mock_get_opportunity_search_records,
         get_opportunity_search_record=mock_get_opportunity_search_record,
         get_opportunity_search_record_statuses=mock_get_opportunity_search_record_statuses,