[MIG] fastapi: Add support for multiple Odoo cache sequences and fix linting

[FIX] fastapi: Apply linting recommendations in 18

Author: lembregtse

fastapi/middleware.py

@@ -9,7 +9,7 @@
 
 """
 
-from typing import Iterable
+from collections.abc import Iterable
 
 import a2wsgi
 from a2wsgi.asgi import ASGIResponder

fastapi/models/fastapi_endpoint.py

@@ -121,7 +121,7 @@ def _registered_endpoint_rule_keys(self):
         return tuple(res)
 
     @api.model
-    def _routing_impacting_fields(self) -> Tuple[str, ...]:
+    def _routing_impacting_fields(self) -> tuple[str, ...]:
         """The list of fields requiring to refresh the mount point of the pp
         into odoo if modified"""
         return ("root_path", "save_http_session")

fastapi/pools/event_loop.py

@@ -4,8 +4,8 @@
 import asyncio
 import queue
 import threading
+from collections.abc import Generator
 from contextlib import contextmanager
-from typing import Generator
 
 
 class EventLoopPool:
@@ -16,7 +16,8 @@ def __get_event_loop_and_thread(
         self,
     ) -> tuple[asyncio.AbstractEventLoop, threading.Thread]:
         """
-        Get an event loop from the pool. If no event loop is available, create a new one.
+        Get an event loop from the pool. If no event loop is available,
+        create a new one.
         """
         try:
             return self.pool.get_nowait()
@@ -47,9 +48,11 @@ def shutdown(self):
     @contextmanager
     def get_event_loop(self) -> Generator[asyncio.AbstractEventLoop, None, None]:
         """
-        Get an event loop from the pool. If no event loop is available, create a new one.
+        Get an event loop from the pool. If no event loop is available,
+        create a new one.
 
-        After the context manager exits, the event loop is returned to the pool for reuse.
+        After the context manager exits, the event loop is returned to
+        the pool for reuse.
         """
         loop, thread = self.__get_event_loop_and_thread()
         try:

fastapi/pools/fastapi_app.py

@@ -4,8 +4,8 @@
 import queue
 import threading
 from collections import defaultdict
+from collections.abc import Generator
 from contextlib import contextmanager
-from typing import Generator
 
 from odoo.api import Environment
 
@@ -45,8 +45,8 @@ class FastApiAppPool:
     updated by the increment of the `cache_sequence` SQL sequence.  This cache sequence
     on the registry is reloaded from the DB on each request made to a specific database.
     When an app is retrieved from the pool, we always compare the cache sequence of
-    the pool with the cache sequence of the registry. If the two sequences are different,
-    we invalidate the pool and save the new cache sequence on the pool.
+    the pool with the cache sequence of the registry. If the two sequences are
+    different, we invalidate the pool and save the new cache sequence on the pool.
 
     The cache is based on a defaultdict of defaultdict of queue.Queue. We are cautious
     that the use of defaultdict is not thread-safe for operations that modify the
@@ -61,10 +61,10 @@ class FastApiAppPool:
     """
 
     def __init__(self):
-        self._queue_by_db_by_root_path: dict[
-            str, dict[str, queue.Queue[FastAPI]]
-        ] = defaultdict(lambda: defaultdict(queue.Queue))
-        self.__cache_sequence = 0
+        self._queue_by_db_by_root_path: dict[str, dict[str, queue.Queue[FastAPI]]] = (
+            defaultdict(lambda: defaultdict(queue.Queue))
+        )
+        self.__cache_sequences = {}
         self._lock = threading.Lock()
 
     def __get_pool(self, env: Environment, root_path: str) -> queue.Queue[FastAPI]:
@@ -102,25 +102,31 @@ def get_app(
         finally:
             self.__return_app(env, app, root_path)
 
-    @property
-    def cache_sequence(self) -> int:
-        return self.__cache_sequence
+    def get_cache_sequence(self, key: str) -> int:
+        with self._lock:
+            return self.__cache_sequences.get(key, 0)
 
-    @cache_sequence.setter
-    def cache_sequence(self, value: int) -> None:
-        if value != self.__cache_sequence:
-            with self._lock:
-                self.__cache_sequence = value
+    def set_cache_sequence(self, key: str, value: int) -> None:
+        with self._lock:
+            if (
+                key not in self.__cache_sequences
+                or value != self.__cache_sequences[key]
+            ):
+                self.__cache_sequences[key] = value
 
     def _check_cache(self, env: Environment) -> None:
-        cache_sequence = env.registry.cache_sequence
-        if cache_sequence != self.cache_sequence and self.cache_sequence != 0:
-            _logger.info(
-                "Cache registry updated, reset fastapi_app pool for the current "
-                "database"
-            )
-            self.invalidate(env)
-        self.cache_sequence = cache_sequence
+        cache_sequences = env.registry.cache_sequences
+        for key, value in cache_sequences.items():
+            if (
+                value != self.get_cache_sequence(key)
+                and self.get_cache_sequence(key) != 0
+            ):
+                _logger.info(
+                    "Cache registry updated, reset fastapi_app pool for the current "
+                    "database"
+                )
+                self.invalidate(env)
+            self.set_cache_sequence(key, value)
 
     def invalidate(self, env: Environment, root_path: str | None = None) -> None:
         db_name = env.cr.dbname