Add tests for ObfuscateTags plugin and remove aiohttp legacy code

- Add 35 unit tests for ObfuscateTags plugin covering:
  - Helper functions (has_no_obfuscation_group, obfuscate_private_tags, etc.)
  - before_request skip/apply conditions
  - before_response obfuscation for Entity, AddressTags, NeighborEntities
  - tagpack_uri_rule config option
- Remove aiohttp legacy support from plugin system (now FastAPI-only)
- Simplify gsrest/plugins/__init__.py (removed dual-framework logic)
- Update docstring in gsrest/routes/base.py

Author: Tommel71

gsrest/builtin/plugins/obfuscate_tags/obfuscate_tags.py

@@ -2,6 +2,7 @@
 from functools import partial
 from typing import Any
 
+from fastapi import Request
 from graphsenselib.tagstore.algorithms.obfuscate import (
     obfuscate_entity_actor,
     obfuscate_tag_if_not_public,
@@ -12,7 +13,6 @@
     get_request_header,
     get_request_path,
     get_request_query_string,
-    is_fastapi_request,
 )
 from openapi_server.models.address_tags import AddressTags
 from openapi_server.models.entity import Entity
@@ -25,14 +25,6 @@
 from openapi_server.models.search_result_level5 import SearchResultLevel5
 from openapi_server.models.search_result_level6 import SearchResultLevel6
 
-# Import aiohttp only for legacy support
-try:
-    from aiohttp import web
-    from multidict import CIMultiDict
-except ImportError:
-    web = None
-    CIMultiDict = None
-
 GROUPS_HEADER_NAME = "X-Consumer-Groups"
 NO_OBFUSCATION_MARKER_PATTERN = re.compile(r"(private|tags-private)")
 OBFUSCATION_MARKER_GROUP = "obfuscate"
@@ -73,7 +65,7 @@ def obfuscate_private_tags(tags):
 
 class ObfuscateTags(Plugin):
     @classmethod
-    def before_request(cls, context: dict, request: Any) -> Any:
+    def before_request(cls, context: dict, request: Request) -> dict | None:
         groups = [
             x.strip()
             for x in get_request_header(request, GROUPS_HEADER_NAME, "").split(",")
@@ -83,47 +75,27 @@ def before_request(cls, context: dict, request: Any) -> Any:
         query_string = get_request_query_string(request)
 
         if has_no_obfuscation_group(groups):
-            return request if not is_fastapi_request(request) else None
+            return None
         if "include_labels=true" in query_string.lower():
-            return request if not is_fastapi_request(request) else None
+            return None
         if "/search" == path:
-            return request if not is_fastapi_request(request) else None
+            return None
         if "/bulk" in path:
-            return request if not is_fastapi_request(request) else None
+            return None
         if re.match(re.compile("/tags"), path):
-            return request if not is_fastapi_request(request) else None
+            return None
         if re.match(re.compile("/[a-z]{3}/addresses/[^/]+$"), path):
             # to avoid loading actors for address
-            return request if not is_fastapi_request(request) else None
-
-        # For FastAPI, return header modifications dict
-        if is_fastapi_request(request):
-            return {GROUPS_HEADER_NAME: OBFUSCATION_MARKER_GROUP}
-
-        # For aiohttp, clone request with modified headers
-        if web is not None and CIMultiDict is not None:
-            headers = dict(request.headers)
-            headers[GROUPS_HEADER_NAME] = OBFUSCATION_MARKER_GROUP
-            headers = CIMultiDict(**headers)
-            return request.clone(headers=headers)
+            return None
 
-        return request
+        return {GROUPS_HEADER_NAME: OBFUSCATION_MARKER_GROUP}
 
     @classmethod
-    def before_response(cls, context: dict, request: Any, result: Any) -> None:
-        # Get groups from headers (check for FastAPI header modifications first)
-        if is_fastapi_request(request):
-            # For FastAPI, check request.state for header modifications
-            header_mods = getattr(request.state, "header_modifications", {})
-            if GROUPS_HEADER_NAME in header_mods:
-                groups = [header_mods[GROUPS_HEADER_NAME]]
-            else:
-                groups = [
-                    x.strip()
-                    for x in get_request_header(request, GROUPS_HEADER_NAME, "").split(
-                        ","
-                    )
-                ]
+    def before_response(cls, context: dict, request: Request, result: Any) -> None:
+        # Get groups from headers (check for header modifications first)
+        header_mods = getattr(request.state, "header_modifications", {})
+        if GROUPS_HEADER_NAME in header_mods:
+            groups = [header_mods[GROUPS_HEADER_NAME]]
         else:
             groups = [
                 x.strip()

gsrest/plugins/__init__.py

@@ -2,42 +2,28 @@
 import inspect
 from typing import Any
 
-# Support both aiohttp and FastAPI request types
-try:
-    from aiohttp import web as aiohttp_web
-
-    AioHTTPRequest = aiohttp_web.Request
-except ImportError:
-    AioHTTPRequest = None
-
-try:
-    from fastapi import Request as FastAPIRequest
-except ImportError:
-    FastAPIRequest = None
+from fastapi import Request
 
 
 class Plugin(abc.ABC):
     """Base class for plugins.
 
     Plugins can implement before_request and before_response hooks to modify
-    request handling and responses. The interface is designed to work with
-    both aiohttp (legacy) and FastAPI (new) request objects.
+    request handling and responses.
     """
 
     @classmethod
     @abc.abstractmethod
-    def before_request(cls, context: dict, request: Any) -> Any:
+    def before_request(cls, context: dict, request: Request) -> dict | None:
         """Called before request processing.
 
-        For aiohttp: Can return a modified request or the original.
-        For FastAPI: Should modify request.state and return None or a dict
-                    of header modifications.
+        Returns None to skip modifications, or a dict of header modifications.
         """
-        return request
+        return None
 
     @classmethod
     @abc.abstractmethod
-    def before_response(cls, context: dict, request: Any, result: Any) -> None:
+    def before_response(cls, context: dict, request: Request, result: Any) -> None:
         """Called after response is prepared but before serialization.
 
         Can modify the result object in place.
@@ -52,37 +38,19 @@ def get_subclass(module):
             continue
         if issubclass(kls, Plugin):
             return kls
-    raise TypeError(f"{module.__name__} does not implement " "gsrest.plugins.Plugin")
-
-
-def is_fastapi_request(request: Any) -> bool:
-    """Check if request is a FastAPI Request object."""
-    if FastAPIRequest is not None:
-        return isinstance(request, FastAPIRequest)
-    return False
-
-
-def is_aiohttp_request(request: Any) -> bool:
-    """Check if request is an aiohttp Request object."""
-    if AioHTTPRequest is not None:
-        return isinstance(request, AioHTTPRequest)
-    return False
+    raise TypeError(f"{module.__name__} does not implement gsrest.plugins.Plugin")
 
 
-def get_request_path(request: Any) -> str:
-    """Get the request path from either request type."""
-    if is_fastapi_request(request):
-        return request.url.path
-    return request.path
+def get_request_path(request: Request) -> str:
+    """Get the request path."""
+    return request.url.path
 
 
-def get_request_query_string(request: Any) -> str:
-    """Get the query string from either request type."""
-    if is_fastapi_request(request):
-        return str(request.query_params)
-    return request.query_string
+def get_request_query_string(request: Request) -> str:
+    """Get the query string."""
+    return str(request.query_params)
 
 
-def get_request_header(request: Any, name: str, default: str = "") -> str:
-    """Get a header value from either request type."""
+def get_request_header(request: Request, name: str, default: str = "") -> str:
+    """Get a header value."""
     return request.headers.get(name, default)

gsrest/routes/base.py

@@ -18,7 +18,8 @@ class RequestAdapter:
     """Adapter to make FastAPI Request compatible with existing service layer.
 
     This adapter provides a unified interface that the service layer expects,
-    bridging FastAPI's Request object with the legacy aiohttp-style access patterns.
+    bridging FastAPI's Request object with the dict-style access patterns
+    used by the service layer.
     """
 
     def __init__(