removes unnecessary hybrid lifespan

Author: GabrielBarberini

src/api.py

@@ -2,7 +2,6 @@
 
 import logging
 
-from contextlib import asynccontextmanager
 from fastapi import FastAPI, Request, status
 from fastapi.exceptions import RequestValidationError
 from fastapi.openapi.utils import get_openapi
@@ -19,8 +18,6 @@
 log = logging.getLogger(__name__)
 
 
-# --- REST application -------------------------------------------------------
-
 rest_app = FastAPI(
     title="Infinity API",
     swagger_ui_parameters={
@@ -99,31 +96,15 @@ async def validation_exception_handler(
     )
 
 
-# --- MCP server mounted under /mcp ------------------------------------------
+# --- MCP server mounted under /mcp -------
 mcp_app = build_mcp(rest_app).http_app(path="/")
 
-
-def _combine_lifespans(rest_lifespan, mcp_lifespan):
-    """Combine FastAPI and MCP lifespans."""
-
-    @asynccontextmanager
-    async def lifespan(app: FastAPI):
-        async with rest_lifespan(app):
-            async with mcp_lifespan(app):
-                yield
-
-    return lifespan
-
-
 app = FastAPI(
     docs_url=None,
     redoc_url=None,
     openapi_url=None,
-    lifespan=_combine_lifespans(
-        rest_app.router.lifespan_context, mcp_app.lifespan
-    ),
+    lifespan=mcp_app.lifespan,
 )
+
 app.mount("/mcp", mcp_app)
 app.mount("/", rest_app)
-
-__all__ = ["app", "rest_app"]

src/mcp/server.py

@@ -9,10 +9,10 @@
 def build_mcp(app: FastAPI) -> FastMCP:
     """
     Create or return a cached FastMCP server that mirrors the given FastAPI app.
-    
+
     Parameters:
         app (FastAPI): FastAPI application to mirror; the created FastMCP instance is cached on `app.state.mcp`.
-    
+
     Returns:
         FastMCP: The FastMCP instance corresponding to the provided FastAPI app.
     """
@@ -23,4 +23,4 @@ def build_mcp(app: FastAPI) -> FastMCP:
     settings.experimental.enable_new_openapi_parser = True
     mcp = FastMCP.from_fastapi(app, name=app.title)
     app.state.mcp = mcp  # type: ignore[attr-defined]
-    return mcp
+    return mcp

src/repositories/interface.py

@@ -37,17 +37,18 @@ def __init__(self):
 def repository_exception_handler(method):
     """
     Decorator that standardizes error handling and logging for repository coroutine methods.
-    
+
     Parameters:
         method (Callable): The asynchronous repository method to wrap.
-    
+
     Returns:
         wrapper (Callable): An async wrapper that:
             - re-raises PyMongoError after logging the exception,
             - re-raises RepositoryNotInitializedException after logging the exception,
             - logs any other exception and raises an HTTPException with status 500 and detail 'Unexpected error ocurred',
             - always logs completion of the repository method call with the repository name, method name, and kwargs.
     """
+
     @functools.wraps(method)
     async def wrapper(self, *args, **kwargs):
         try:
@@ -96,9 +97,9 @@ class RepositoryInterface:
     def __new__(cls, *args, **kwargs):
         """
         Ensure a single thread-safe instance exists for the subclass.
-        
+
         Creates and returns the singleton instance for this subclass, creating it if absent while holding a global thread lock to prevent concurrent instantiation.
-        
+
         Returns:
             The singleton instance of the subclass.
         """
@@ -111,11 +112,11 @@ def __new__(cls, *args, **kwargs):
     def __init__(self, model: ApiBaseModel, *, max_pool_size: int = 3):
         """
         Initialize the repository instance for a specific API model and configure its connection pool.
-        
+
         Parameters:
             model (ApiBaseModel): The API model used for validation and to determine the repository's collection.
             max_pool_size (int, optional): Maximum size of the MongoDB connection pool. Defaults to 3.
-        
+
         Notes:
             If the instance is already initialized, this constructor will not reconfigure it. Initialization of the underlying connection is started asynchronously.
         """
@@ -129,7 +130,7 @@ def __init__(self, model: ApiBaseModel, *, max_pool_size: int = 3):
     async def _async_init(self):
         """
         Perform idempotent, retry-safe asynchronous initialization of the repository instance.
-        
+
         Ensures a per-instance asyncio.Lock exists and acquires it to run initialization exactly once; on success it marks the instance as initialized and sets the internal _initialized_event so awaiters can proceed. If initialization fails, the original exception from _initialize_connection is propagated after logging.
         """
         if getattr(self, '_initialized', False):
@@ -155,7 +156,7 @@ async def _async_init(self):
     def _initialize(self):
         """
         Ensure the repository's asynchronous initializer is executed: run it immediately if no event loop is active, otherwise schedule it on the running loop.
-        
+
         If there is no running asyncio event loop, this method runs self._async_init() to completion on the current thread, blocking until it finishes. If an event loop is running, it schedules self._async_init() as a background task on that loop and returns immediately.
         """
         try:
@@ -168,7 +169,7 @@ def _initialize(self):
     async def __aenter__(self):
         """
         Waits for repository initialization to complete and returns the repository instance.
-        
+
         Returns:
             RepositoryInterface: The initialized repository instance.
         """
@@ -181,9 +182,9 @@ async def __aexit__(self, exc_type, exc_value, traceback):
     def _initialize_connection(self):
         """
         Initialize the MongoDB async client, store the connection string, and bind the collection for this repository instance.
-        
+
         This method fetches the MongoDB connection string from secrets, creates an AsyncMongoClient configured with pool and timeout settings, and sets self._collection to the repository's collection named by the model. On success it logs the initialized client; on failure it raises a ConnectionError.
-        
+
         Raises:
             ConnectionError: If the client or collection cannot be initialized.
         """
@@ -284,4 +285,4 @@ async def find_by_query(self, query: dict):
             parsed_model = self.model.model_validate(read_data)
             parsed_model.set_id(str(read_data["_id"]))
             parsed_models.append(parsed_model)
-        return parsed_models
+        return parsed_models

tests/unit/test_mcp/test_mcp_server.py

@@ -6,48 +6,49 @@
 from fastmcp.client import Client
 from fastapi.routing import APIRoute
 
-from src.api import app, rest_app
+from src.api import app
 from src.mcp.server import build_mcp
 
 
 @pytest.fixture(autouse=True)
 def reset_mcp_state():
     """
     Ensure the FastAPI app has no lingering MCP state before and after a test.
-    
-    This fixture deletes app.state.mcp if it exists, yields control to the test, and then deletes app.state.mcp again to guarantee the MCP state is cleared between tests.
+    This fixture deletes app.state.mcp if it exists,
+    yields control to the test, and then deletes app.state.mcp
+    again to guarantee the MCP state is cleared between tests.
     """
-    if hasattr(rest_app.state, 'mcp'):
-        delattr(rest_app.state, 'mcp')
+    if hasattr(app.state, 'mcp'):
+        delattr(app.state, 'mcp')
     yield
-    if hasattr(rest_app.state, 'mcp'):
-        delattr(rest_app.state, 'mcp')
+    if hasattr(app.state, 'mcp'):
+        delattr(app.state, 'mcp')
 
 
 def test_build_mcp_uses_fastapi_adapter():
     mock_mcp = MagicMock()
     with patch(
         'src.mcp.server.FastMCP.from_fastapi', return_value=mock_mcp
     ) as mock_factory:
-        result = build_mcp(rest_app)
+        result = build_mcp(app)
         assert result is mock_mcp
-        mock_factory.assert_called_once_with(rest_app, name=rest_app.title)
-        again = build_mcp(rest_app)
+        mock_factory.assert_called_once_with(app, name=app.title)
+        again = build_mcp(app)
         assert again is mock_mcp
         mock_factory.assert_called_once()
 
 
 @pytest.mark.asyncio
 async def test_mcp_tools_cover_registered_routes():
-    mcp_server = build_mcp(rest_app)
+    mcp_server = build_mcp(app)
 
     async with Client(mcp_server) as client:
         tools = await client.list_tools()
 
     tool_by_name = {tool.name: tool for tool in tools}
 
     expected = {}
-    for route in rest_app.routes:
+    for route in app.routes:
         if not isinstance(route, APIRoute) or not route.include_in_schema:
             continue
         tag = route.tags[0].lower()
@@ -70,7 +71,7 @@ async def test_mcp_tools_cover_registered_routes():
 @pytest.mark.asyncio
 async def test_combined_app_serves_rest_and_mcp(monkeypatch):
     monkeypatch.setattr('src.mcp.server.FastMCP.from_fastapi', MagicMock())
-    build_mcp(rest_app)
+    build_mcp(app)
 
     from httpx import ASGITransport, AsyncClient
 
@@ -81,4 +82,4 @@ async def test_combined_app_serves_rest_and_mcp(monkeypatch):
         resp_rest = await client.get('/health')
         assert resp_rest.status_code == 200
         resp_docs = await client.get('/docs')
-        assert resp_docs.status_code == 200
+        assert resp_docs.status_code == 200