only use solver_service interface when listing all solver releases

Author: bisgaard-itis

services/api-server/src/simcore_service_api_server/_service_solvers.py

@@ -2,13 +2,18 @@
 
 from common_library.pagination_tools import iter_pagination_params
 from fastapi import Depends
+from models_library.api_schemas_catalog.services import ServiceListFilters
 from models_library.basic_types import VersionStr
 from models_library.products import ProductName
-from models_library.rest_pagination import MAXIMUM_NUMBER_OF_ITEMS_PER_PAGE
+from models_library.rest_pagination import (
+    MAXIMUM_NUMBER_OF_ITEMS_PER_PAGE,
+    PageMetaInfoLimitOffset,
+)
 from models_library.services_enums import ServiceType
 from models_library.services_history import ServiceRelease
 from models_library.users import UserID
 from packaging.version import Version
+from pydantic import NonNegativeInt, PositiveInt
 
 from .models.schemas.solvers import Solver, SolverKeyId
 from .services_rpc.catalog import CatalogService
@@ -74,27 +79,25 @@ async def get_latest_release(
     async def solver_release_history(
         self,
         *,
-        user_id: int,
+        user_id: UserID,
         solver_key: SolverKeyId,
-        product_name: str,
-    ) -> list[Solver]:
+        product_name: ProductName,
+        offset: NonNegativeInt,
+        limit: PositiveInt,
+    ) -> tuple[list[Solver], PageMetaInfoLimitOffset]:
 
-        service_releases: list[ServiceRelease] = []
-        for page_params in iter_pagination_params(limit=DEFAULT_PAGINATION_LIMIT):
-            releases, page_meta = await self._catalog_service.list_release_history(
-                user_id=user_id,
-                service_key=solver_key,
-                product_name=product_name,
-                offset=page_params.offset,
-                limit=page_params.limit,
-            )
-            page_params.total_number_of_items = page_meta.total
-            service_releases.extend(releases)
+        releases, page_meta = await self._catalog_service.list_release_history(
+            user_id=user_id,
+            service_key=solver_key,
+            product_name=product_name,
+            offset=offset,
+            limit=limit,
+        )
 
         service_instance = await self._catalog_service.get(
             user_id=user_id,
             name=solver_key,
-            version=service_releases[-1].version,
+            version=releases[-1].version,
             product_name=product_name,
         )
 
@@ -106,5 +109,25 @@ async def solver_release_history(
                 name=service_instance.name,
                 service=service,
             )
-            for service in service_releases
-        ]
+            for service in releases
+        ], page_meta
+
+    async def latest_solvers(
+        self,
+        *,
+        user_id: UserID,
+        product_name: ProductName,
+        offset: NonNegativeInt,
+        limit: PositiveInt,
+    ) -> tuple[list[Solver], PageMetaInfoLimitOffset]:
+        """Lists the latest solvers with pagination."""
+        services, page_meta = await self._catalog_service.list_latest_releases(
+            user_id=user_id,
+            product_name=product_name,
+            offset=offset,
+            limit=limit,
+            filters=ServiceListFilters(service_type=ServiceType.COMPUTATIONAL),
+        )
+
+        solvers = [Solver.create_from_service(service) for service in services]
+        return solvers, page_meta

services/api-server/src/simcore_service_api_server/api/routes/solvers.py

@@ -129,46 +129,34 @@ async def get_solvers_page(
 )
 async def list_solvers_releases(
     user_id: Annotated[int, Depends(get_current_user_id)],
-    catalog_service: Annotated[CatalogService, Depends()],
+    solver_service: Annotated[SolverService, Depends(SolverService)],
     url_for: Annotated[Callable, Depends(get_reverse_url_mapper)],
     product_name: Annotated[str, Depends(get_product_name)],
 ):
 
-    latest_releases = []
+    latest_solvers: list[Solver] = []
     for page_params in iter_pagination_params(limit=DEFAULT_PAGINATION_LIMIT):
-        services, page_meta = await catalog_service.list_latest_releases(
+        solvers, page_meta = await solver_service.latest_solvers(
             user_id=user_id,
             product_name=product_name,
             offset=page_params.offset,
             limit=page_params.limit,
-            filters=ServiceListFilters(service_type=ServiceType.COMPUTATIONAL),
         )
         page_params.total_number_of_items = page_meta.total
-        latest_releases.extend(services)
+        latest_solvers.extend(solvers)
 
     all_solvers = []
-    for service_release in latest_releases:
+    for solver in latest_solvers:
         for page_params in iter_pagination_params(limit=DEFAULT_PAGINATION_LIMIT):
-            services, page_meta = await catalog_service.list_release_history(
+            solvers, page_meta = await solver_service.solver_release_history(
                 product_name=product_name,
                 user_id=user_id,
-                service_key=service_release.key,
+                solver_key=solver.id,
                 offset=page_params.offset,
                 limit=page_params.limit,
             )
             page_params.total_number_of_items = page_meta.total
-            all_solvers.extend(
-                [
-                    Solver.create_from_service_release(
-                        service_key=service_release.key,
-                        description=service_release.description,
-                        contact=service_release.contact,
-                        name=service_release.name,
-                        service=service,
-                    )
-                    for service in services
-                ]
-            )
+            all_solvers.extend(solvers)
 
     for solver in all_solvers:
         solver.url = url_for(