refacto(models): split getmodelsusecase in two use cases (#890)

* split get model use cases

* fix bootstrap syntax

* add get_router_by_name_or_alias method

* Update unit coverage badge

* last fix

---------

Co-authored-by: leoguillaume <leoguillaume@users.noreply.github.com>

Author: leoguillaume

.github/badges/coverage.json

@@ -1 +1 @@
-{"schemaVersion":1,"label":"coverage","message":"56.00%","color":"red"}
+{"schemaVersion":1,"label":"coverage","message":"56.24%","color":"red"}

api/dependencies.py

@@ -36,7 +36,7 @@
 from api.use_cases.admin.routers import CreateRouterUseCase, DeleteRouterUseCase, GetOneRouterUseCase, GetRoutersUseCase, UpdateRouterUseCase
 from api.use_cases.admin.users import CreateUserUseCase
 from api.use_cases.health import GetHealthModelsUseCase
-from api.use_cases.models import GetModelsUseCase
+from api.use_cases.models import GetModelsUseCase, GetModelUseCase
 from api.utils.configuration import configuration
 from api.utils.context import global_context, request_context
 
@@ -139,13 +139,16 @@ def get_health_models_use_case_factory(
 
 
 # models use cases
-def get_models_use_case_factory(
-    postgres_session: AsyncSession = Depends(get_postgres_session),
-    request_context: RequestContext = Depends(get_request_context),
-) -> GetModelsUseCase:
+def get_models_use_case_factory(postgres_session: AsyncSession = Depends(get_postgres_session)) -> GetModelsUseCase:
     return GetModelsUseCase(
         router_repository=_router_repository(postgres_session),
-        user_id=request_context.get().user_id,
+        user_with_role_query=_user_with_role_query(postgres_session),
+    )
+
+
+def get_model_use_case_factory(postgres_session: AsyncSession = Depends(get_postgres_session)) -> GetModelUseCase:
+    return GetModelUseCase(
+        router_repository=_router_repository(postgres_session),
         user_with_role_query=_user_with_role_query(postgres_session),
     )
 

api/domain/model/errors.py

@@ -1,8 +1,5 @@
 from dataclasses import dataclass
 
-from api.domain.provider.entities import ProviderType
-from api.utils.variables import EndpointRoute
-
 
 @dataclass
 class InconsistentModelVectorSizeError:
@@ -13,18 +10,11 @@ class InconsistentModelVectorSizeError:
 
 @dataclass
 class ModelNotFoundError:
-    pass
+    name: str
 
 
 @dataclass
 class InconsistentModelMaxContextLengthError:
     expected_max_context_length: int
     actual_max_context_length: int
     router_name: str
-
-
-# @TODO: move to provider.errors.py
-@dataclass
-class UnsupportedEndpointError:
-    endpoint: EndpointRoute
-    provider_type: ProviderType | None = None

api/domain/provider/_providergateway.py

@@ -2,6 +2,7 @@
 from dataclasses import dataclass
 
 from api.domain.model.entities import ModelType as RouterType
+from api.domain.model.errors import ModelNotFoundError
 from api.domain.provider.entities import ProviderType
 from api.domain.provider.errors import ProviderNotReachableError
 
@@ -22,5 +23,5 @@ async def get_capabilities(
         key: str | None,
         timeout: int,
         model_name: str,
-    ) -> ProviderCapabilities | ProviderNotReachableError:
+    ) -> ProviderCapabilities | ModelNotFoundError | ProviderNotReachableError:
         pass

api/domain/provider/errors.py

@@ -1,5 +1,14 @@
 from dataclasses import dataclass
 
+from api.domain.provider.entities import ProviderType
+from api.utils.variables import EndpointRoute
+
+
+@dataclass
+class UnsupportedEndpointError:
+    endpoint: EndpointRoute
+    provider_type: ProviderType | None = None
+
 
 @dataclass
 class InvalidProviderTypeError:
@@ -14,11 +23,6 @@ class ProviderNotReachableError:
     detail: str
 
 
-@dataclass
-class ModelProviderNotFoundError:
-    model_name: str
-
-
 @dataclass
 class ProviderAlreadyExistsError:
     model_name: str

api/domain/router/_routerrepository.py

@@ -30,7 +30,7 @@ async def get_router_by_id(self, router_id: int) -> Router | RouterNotFoundError
         pass
 
     @abstractmethod
-    async def get_aliases_by_router_id(self, router_id: int) -> list[str]:
+    async def get_router_by_name_or_alias(self, name_or_alias: str) -> Router | RouterNotFoundError:
         pass
 
     @abstractmethod

api/domain/router/errors.py

@@ -13,4 +13,5 @@ class RouterNameAlreadyExistsError:
 
 @dataclass
 class RouterNotFoundError:
-    id: int
+    id: int | None = None
+    name: str | None = None

api/infrastructure/fastapi/endpoints/exceptions.py

@@ -69,10 +69,10 @@ def __init__(self, input_vector_size: int, model_vector_size: int, model_name: s
 # 404
 class ModelNotFoundHTTPException(HTTPException):
     status_code = 404
-    detail = "Model not found."
+    detail = "Model {name} not found."
 
-    def __init__(self) -> None:
-        super().__init__(status_code=self.status_code, detail=self.detail)
+    def __init__(self, name: str) -> None:
+        super().__init__(status_code=self.status_code, detail=f"Model {name} not found.")
 
 
 class RoleNotFoundHTTPException(HTTPException):

api/infrastructure/fastapi/endpoints/health.py

@@ -1,4 +1,4 @@
-from fastapi import APIRouter, Depends, Request, Security
+from fastapi import APIRouter, Depends, Security
 from fastapi.responses import JSONResponse
 
 from api.dependencies import get_health_models_use_case_factory, get_request_context
@@ -16,6 +16,9 @@
 
 @router.get(path=EndpointRoute.HEALTH, status_code=200)
 def get_health() -> JSONResponse:
+    """
+    Get the health of the API.
+    """
     return JSONResponse(content={"status": "ok"}, status_code=200)
 
 
@@ -26,20 +29,20 @@ def get_health() -> JSONResponse:
     responses=get_documentation_responses([]),
 )
 async def get_health_models(
-    request: Request,
     get_health_models_use_case: GetHealthModelsUseCase = Depends(get_health_models_use_case_factory),
     request_context: RequestContext = Depends(get_request_context),
 ) -> JSONResponse:
     """
-    Get a model by name and provide basic information.
+    Get the health of the models.
     """
 
     result = await get_health_models_use_case.execute(command=GetHealthModelsCommand(user_id=request_context.get().user_id))
 
     match result:
-        case GetHealthModelsUseCaseSuccess():
-            return ModelsHealthResponse(
-                data=[ModelHealthStatus.model_validate(model, from_attributes=True) for model in result.models],
+        case GetHealthModelsUseCaseSuccess(models):
+            return JSONResponse(
+                content=ModelsHealthResponse(data=[ModelHealthStatus.model_validate(model, from_attributes=True) for model in models]).model_dump(),
+                status_code=200,
             )
         case UserExpiredError():
             raise AccountExpiredHTTPException()

api/infrastructure/fastapi/endpoints/models.py

@@ -1,68 +1,66 @@
-from fastapi import APIRouter, Depends, Path, Request, Security
+from fastapi import APIRouter, Depends, Path, Security
 from fastapi.responses import JSONResponse
 
-from api.dependencies import get_models_use_case_factory
+from api.dependencies import get_model_use_case_factory, get_models_use_case_factory, get_request_context
 from api.domain.model.errors import ModelNotFoundError
 from api.domain.user.errors import UserExpiredError
 from api.infrastructure.fastapi.access import get_current_key
+from api.infrastructure.fastapi.context import RequestContext
 from api.infrastructure.fastapi.documentation import get_documentation_responses
-from api.infrastructure.fastapi.endpoints.exceptions import (
-    AccountExpiredHTTPException,
-    ModelNotFoundHTTPException,
-)
-from api.infrastructure.fastapi.schemas.models import ModelResponse, ModelsResponse
-from api.use_cases.models import GetModelsUseCase, GetModelUseCaseSucess
+from api.infrastructure.fastapi.endpoints.exceptions import AccountExpiredHTTPException, ModelNotFoundHTTPException
+from api.infrastructure.fastapi.schemas.models import Model, ModelsResponse
+from api.use_cases.models import GetModelCommand, GetModelsCommand, GetModelsUseCase, GetModelsUseCaseSucess, GetModelUseCase, GetModelUseCaseSucess
 from api.utils.variables import EndpointRoute, RouterName
 
 router = APIRouter(prefix="/v1", tags=[RouterName.MODELS.title()])
 
 
 @router.get(
-    path=EndpointRoute.MODELS + "/{model:path}",
+    path=EndpointRoute.MODELS,
     dependencies=[Security(dependency=get_current_key)],
     status_code=200,
-    response_model=ModelResponse,
-    responses=get_documentation_responses([ModelNotFoundHTTPException]),
+    response_model=ModelsResponse,
+    responses=get_documentation_responses([]),
 )
-async def get_model(
-    request: Request,
-    model: str = Path(description="The name of the model to get."),
+async def get_models(
     get_models_use_case: GetModelsUseCase = Depends(get_models_use_case_factory),
+    request_context: RequestContext = Depends(get_request_context),
 ) -> ModelNotFoundHTTPException | JSONResponse:
     """
-    Get a model by name and provide basic information.
+    Lists the currently available models and provides basic information.
     """
-    result = await get_models_use_case.execute(name=model)
+    command = GetModelsCommand(user_id=request_context.get().user_id)
+    result = await get_models_use_case.execute(command=command)
 
     match result:
-        case GetModelUseCaseSucess(models):
-            models = [ModelResponse(**model.model_dump()) for model in models]
-            model = models[0]
-            return JSONResponse(content=model.model_dump(), status_code=200)
-        case ModelNotFoundError():
-            raise ModelNotFoundHTTPException()
+        case GetModelsUseCaseSucess(models):
+            return JSONResponse(content=ModelsResponse.model_validate({"data": models}, from_attributes=True).model_dump(), status_code=200)
         case UserExpiredError():
             raise AccountExpiredHTTPException()
 
 
 @router.get(
-    path=EndpointRoute.MODELS,
+    path=EndpointRoute.MODELS + "/{model:path}",
     dependencies=[Security(dependency=get_current_key)],
     status_code=200,
-    response_model=ModelsResponse,
-    responses=get_documentation_responses([]),
+    response_model=Model,
+    responses=get_documentation_responses([ModelNotFoundHTTPException]),
 )
-async def get_models(
-    request: Request,
-    get_models_use_case: GetModelsUseCase = Depends(get_models_use_case_factory),
+async def get_model(
+    model: str = Path(description="The name of the model to get."),
+    get_model_use_case: GetModelUseCase = Depends(get_model_use_case_factory),
+    request_context: RequestContext = Depends(get_request_context),
 ) -> JSONResponse:
     """
-    Lists the currently available models and provides basic information.
+    Get a model by name and provide basic information.
     """
-    result = await get_models_use_case.execute(name=None)
+    command = GetModelCommand(user_id=request_context.get().user_id, name=model)
+    result = await get_model_use_case.execute(command=command)
+
     match result:
-        case GetModelUseCaseSucess(models):
-            models = [ModelResponse(**model.model_dump()) for model in models]
-            return JSONResponse(content=ModelsResponse(data=models).model_dump(), status_code=200)
+        case GetModelUseCaseSucess(model):
+            return JSONResponse(content=Model.model_validate(model, from_attributes=True).model_dump(), status_code=200)
+        case ModelNotFoundError(name):
+            raise ModelNotFoundHTTPException(name=name)
         case UserExpiredError():
             raise AccountExpiredHTTPException()