add Result and Maybe to return types of ProductBackend

Author: Phil Varner

CHANGELOG.md

@@ -13,7 +13,8 @@ none
 
 ### Changed
 
-- RootBackend protocol uses `returns` library types Result and Maybe instead of exceptions.
+- RootBackend and ProductBackend protocols use `returns` library types Result and Maybe instead of
+  raising exceptions.
 - Create Order endpoint from `.../order` to `.../orders`
 - Order field `id` must be a string, instead of previously allowing int. This is because while an
   order ID may an integral numeric value, it is not a "number" in the sense that math will be performed

bin/server.py

@@ -38,11 +38,13 @@ class MockRootBackend(RootBackend):
     def __init__(self, orders: MockOrderDB) -> None:
         self._orders: MockOrderDB = orders
 
-    async def get_orders(self, request: Request) -> OrderCollection:
+    async def get_orders(
+        self, request: Request
+    ) -> Result[OrderCollection, Maybe[Exception]]:
         """
         Show all orders.
         """
-        return OrderCollection(features=list(self._orders.values()))
+        return Success(OrderCollection(features=list(self._orders.values())))
 
     async def get_order(
         self, order_id: str, request: Request
@@ -67,41 +69,49 @@ async def search_opportunities(
         product_router: ProductRouter,
         search: OpportunityRequest,
         request: Request,
-    ) -> list[Opportunity]:
-        return [o.model_copy(update=search.model_dump()) for o in self._opportunities]
+    ) -> Result[list[Opportunity], Maybe[Exception]]:
+        try:
+            return Success(
+                [o.model_copy(update=search.model_dump()) for o in self._opportunities]
+            )
+        except Exception as e:
+            return Failure(e)
 
     async def create_order(
         self, product_router: ProductRouter, payload: OrderRequest, request: Request
-    ) -> Order:
+    ) -> Result[Order, Maybe[Exception]]:
         """
         Create a new order.
         """
-        order = Order(
-            id=str(uuid4()),
-            geometry=payload.geometry,
-            properties={
-                "product_id": product_router.product.id,
-                "created": datetime.now(timezone.utc),
-                "status": OrderStatus(
-                    timestamp=datetime.now(timezone.utc),
-                    status_code=OrderStatusCode.accepted,
-                ),
-                "search_parameters": {
-                    "geometry": payload.geometry,
-                    "datetime": payload.datetime,
-                    "filter": payload.filter,
-                },
-                "order_parameters": payload.order_parameters.model_dump(),
-                "opportunity_properties": {
-                    "datetime": "2024-01-29T12:00:00Z/2024-01-30T12:00:00Z",
-                    "off_nadir": 10,
+        try:
+            order = Order(
+                id=str(uuid4()),
+                geometry=payload.geometry,
+                properties={
+                    "product_id": product_router.product.id,
+                    "created": datetime.now(timezone.utc),
+                    "status": OrderStatus(
+                        timestamp=datetime.now(timezone.utc),
+                        status_code=OrderStatusCode.accepted,
+                    ),
+                    "search_parameters": {
+                        "geometry": payload.geometry,
+                        "datetime": payload.datetime,
+                        "filter": payload.filter,
+                    },
+                    "order_parameters": payload.order_parameters.model_dump(),
+                    "opportunity_properties": {
+                        "datetime": "2024-01-29T12:00:00Z/2024-01-30T12:00:00Z",
+                        "off_nadir": 10,
+                    },
                 },
-            },
-            links=[],
-        )
+                links=[],
+            )
 
-        self._orders[order.id] = order
-        return order
+            self._orders[order.id] = order
+            return Success(order)
+        except Exception as e:
+            return Failure(e)
 
 
 class MyOpportunityProperties(OpportunityProperties):

pyproject.toml

@@ -36,6 +36,9 @@ dev = "stapi_fastapi.__dev__:cli"
 [tool.ruff]
 line-length = 88
 
+[tool.ruff.format]
+quote-style = 'double'
+
 [tool.ruff.lint]
 extend-ignore = ["E501", "UP007", "UP034"]
 select = [

src/stapi_fastapi/backends/product_backend.py

@@ -3,6 +3,8 @@
 from typing import Protocol
 
 from fastapi import Request
+from returns.maybe import Maybe
+from returns.result import Result
 
 from stapi_fastapi.models.opportunity import Opportunity, OpportunityRequest
 from stapi_fastapi.models.order import Order, OrderRequest
@@ -15,25 +17,23 @@ async def search_opportunities(
         product_router: ProductRouter,
         search: OpportunityRequest,
         request: Request,
-    ) -> list[Opportunity]:
+    ) -> Result[list[Opportunity], Maybe[Exception]]:
         """
         Search for ordering opportunities for the  given search parameters.
 
-        Backends must validate search constraints and raise
+        Backends must validate search constraints and return
         `stapi_fastapi.exceptions.ConstraintsException` if not valid.
         """
-        ...
 
     async def create_order(
         self,
         product_router: ProductRouter,
         search: OrderRequest,
         request: Request,
-    ) -> Order:
+    ) -> Result[Order, Maybe[Exception]]:
         """
         Create a new order.
 
-        Backends must validate order payload and raise
+        Backends must validate order payload and return
         `stapi_fastapi.exceptions.ConstraintsException` if not valid.
         """
-        ...

src/stapi_fastapi/backends/root_backend.py

@@ -8,7 +8,9 @@
 
 
 class RootBackend(Protocol):  # pragma: nocover
-    async def get_orders(self, request: Request) -> OrderCollection:
+    async def get_orders(
+        self, request: Request
+    ) -> Result[OrderCollection, Maybe[Exception]]:
         """
         Return a list of existing orders.
         """

src/stapi_fastapi/routers/product_router.py

@@ -4,6 +4,8 @@
 
 from fastapi import APIRouter, HTTPException, Request, Response, status
 from geojson_pydantic.geometries import Geometry
+from returns.maybe import Maybe, Some
+from returns.result import Failure, Success
 
 from stapi_fastapi.constants import TYPE_GEOJSON, TYPE_JSON
 from stapi_fastapi.exceptions import ConstraintsException
@@ -158,27 +160,32 @@ async def search_opportunities(
         """
         Explore the opportunities available for a particular set of constraints
         """
-        try:
-            opportunities = await self.product.backend.search_opportunities(
-                self, search, request
-            )
-        except ConstraintsException as exc:
-            raise HTTPException(status.HTTP_422_UNPROCESSABLE_ENTITY, detail=exc.detail)
-
-        return OpportunityCollection(
-            features=opportunities,
-            links=[
-                Link(
-                    href=str(
-                        request.url_for(
-                            f"{self.root_router.name}:{self.product.id}:create-order",
+        match await self.product.backend.search_opportunities(self, search, request):
+            case Success(features):
+                return OpportunityCollection(
+                    features=features,
+                    links=[
+                        Link(
+                            href=str(
+                                request.url_for(
+                                    f"{self.root_router.name}:{self.product.id}:create-order",
+                                ),
+                            ),
+                            rel="create-order",
+                            type=TYPE_JSON,
                         ),
-                    ),
-                    rel="create-order",
-                    type=TYPE_JSON,
-                ),
-            ],
-        )
+                    ],
+                )
+            case Failure(Some(e)) if isinstance(e, ConstraintsException):
+                raise e
+            case Failure(Some(e)):
+                raise HTTPException(
+                    status.HTTP_500_INTERNAL_SERVER_ERROR, detail=e.detail
+                )
+            case Failure(Maybe.empty):
+                raise HTTPException(status.HTTP_500_INTERNAL_SERVER_ERROR)
+            case x:
+                raise AssertionError(f"Expected code to be unreachable {x}")
 
     def get_product_constraints(self: Self) -> JsonSchemaModel:
         """
@@ -198,16 +205,23 @@ async def create_order(
         """
         Create a new order.
         """
-        try:
-            order = await self.product.backend.create_order(
-                self,
-                payload,
-                request,
-            )
-        except ConstraintsException as exc:
-            raise HTTPException(status.HTTP_422_UNPROCESSABLE_ENTITY, detail=exc.detail)
-
-        location = str(self.root_router.generate_order_href(request, order.id))
-        order.links.append(Link(href=location, rel="self", type=TYPE_GEOJSON))
-        response.headers["Location"] = location
-        return order
+        match await self.product.backend.create_order(
+            self,
+            payload,
+            request,
+        ):
+            case Success(order):
+                location = str(self.root_router.generate_order_href(request, order.id))
+                order.links.append(Link(href=location, rel="self", type=TYPE_GEOJSON))
+                response.headers["Location"] = location
+                return order
+            case Failure(Some(e)) if isinstance(e, ConstraintsException):
+                raise e
+            case Failure(Some(e)):
+                raise HTTPException(
+                    status.HTTP_500_INTERNAL_SERVER_ERROR, detail=e.detail
+                )
+            case Failure(Maybe.empty):
+                raise HTTPException(status.HTTP_500_INTERNAL_SERVER_ERROR)
+            case x:
+                raise AssertionError(f"Expected code to be unreachable {x}")

tests/backends.py

@@ -27,11 +27,13 @@ class MockRootBackend(RootBackend):
     def __init__(self, orders: MockOrderDB) -> None:
         self._orders = orders
 
-    async def get_orders(self, request: Request) -> OrderCollection:
+    async def get_orders(
+        self, request: Request
+    ) -> Result[OrderCollection, Maybe[Exception]]:
         """
         Show all orders.
         """
-        return OrderCollection(features=list(self._orders.values()))
+        return Success(OrderCollection(features=list(self._orders.values())))
 
     async def get_order(
         self, order_id: str, request: Request
@@ -56,15 +58,17 @@ async def search_opportunities(
         product_router: ProductRouter,
         search: OpportunityRequest,
         request: Request,
-    ) -> list[Opportunity]:
-        return [o.model_copy(update=search.model_dump()) for o in self._opportunities]
+    ) -> Result[list[Opportunity], Maybe[Exception]]:
+        return Success(
+            [o.model_copy(update=search.model_dump()) for o in self._opportunities]
+        )
 
     async def create_order(
         self,
         product_router: ProductRouter,
         payload: OrderRequest,
         request: Request,
-    ) -> Order:
+    ) -> Result[Order, Maybe[Exception]]:
         """
         Create a new order.
         """
@@ -93,8 +97,10 @@ async def create_order(
                 links=[],
             )
             self._orders[order.id] = order
-            return order
+            return Success(order)
         else:
-            raise ConstraintsException(
-                f"not allowed: payload {payload.model_dump_json()} not in {[p.model_dump_json() for p in self._allowed_payloads]}"
+            return Failure(
+                ConstraintsException(
+                    f"not allowed: payload {payload.model_dump_json()} not in {[p.model_dump_json() for p in self._allowed_payloads]}"
+                )
             )