Fix name conflict in runner context: introduce action cache and action handler cache inside of it, because handlers from different actions can have the same name

Aksem · Aksem · commit df8e57b773de · 2025-09-06T13:16:22.000+02:00
diff --git a/finecode_extension_runner/src/finecode_extension_runner/__main__.py b/finecode_extension_runner/src/finecode_extension_runner/__main__.py
@@ -1,4 +1,4 @@
 from finecode_extension_runner import cli
 
 if __name__ == "__main__":
-    cli.cli()
+    cli.main()
diff --git a/finecode_extension_runner/src/finecode_extension_runner/_services/run_action.py b/finecode_extension_runner/src/finecode_extension_runner/_services/run_action.py
@@ -79,16 +79,19 @@ async def run_action(
     #   returned. (experimental)
     # - execution of handlers can be concurrent or sequential. But executions of handler
     #   on iterable payloads(single parts) are always concurrent.
+    action_name = request.action_name
 
     try:
-        action_exec_info = global_state.runner_context.action_exec_info_by_name[
-            request.action_name
-        ]
+        action_cache = global_state.runner_context.action_cache_by_name[action_name]
     except KeyError:
+        action_cache = domain.ActionCache()
+        global_state.runner_context.action_cache_by_name[action_name] = action_cache
+
+    if action_cache.exec_info is not None:
+        action_exec_info = action_cache.exec_info
+    else:
         action_exec_info = create_action_exec_info(action)
-        global_state.runner_context.action_exec_info_by_name[request.action_name] = (
-            action_exec_info
-        )
+        action_cache.exec_info = action_exec_info
 
     # TODO: catch validation errors
     payload: code_action.RunActionPayload | None = None
@@ -140,6 +143,7 @@ async def run_action(
                     payload=payload,
                     run_context=run_context,
                     run_id=run_id,
+                    action_cache=action_cache,
                     action_context=action_context,
                     action_exec_info=action_exec_info,
                     runner_context=runner_context,
@@ -223,6 +227,7 @@ async def run_action(
                                     payload=payload,
                                     run_context=run_context,
                                     run_id=run_id,
+                                    action_cache=action_cache,
                                     action_context=action_context,
                                     action_exec_info=action_exec_info,
                                     runner_context=runner_context,
@@ -253,6 +258,7 @@ async def run_action(
                             payload=payload,
                             run_context=run_context,
                             run_id=run_id,
+                            action_cache=action_cache,
                             action_context=action_context,
                             action_exec_info=action_exec_info,
                             runner_context=runner_context,
@@ -379,19 +385,37 @@ async def execute_action_handler(
     run_context: code_action.RunActionContext | None,
     run_id: int,
     action_exec_info: domain.ActionExecInfo,
+    action_cache: domain.ActionCache,
     action_context: code_action.ActionContext,
     runner_context: context.RunnerContext,
 ) -> code_action.RunActionResult:
     logger.trace(f"R{run_id} | Run {handler.name} on {str(payload)[:100]}...")
+    if handler.name in action_cache.handler_cache_by_name:
+        handler_cache = action_cache.handler_cache_by_name[handler.name]
+    else:
+        handler_cache = domain.ActionHandlerCache()
+        action_cache.handler_cache_by_name[handler.name] = handler_cache
+    
     start_time = time.time_ns()
     execution_result: code_action.RunActionResult | None = None
+    
+    handler_global_config = runner_context.project.action_handler_configs.get(
+        handler.source, None
+    )
+    handler_raw_config = {}
+    if handler_global_config is not None:
+        handler_raw_config = handler_global_config
+    if handler_raw_config == {}:
+        # still empty, just assign
+        handler_raw_config = handler.config
+    else:
+        # not empty anymore, deep merge
+        handler_config_merger.merge(handler_raw_config, handler.config)
 
-    if handler.name in runner_context.action_handlers_instances_by_name:
-        handler_instance = runner_context.action_handlers_instances_by_name[
-            handler.name
-        ]
+    if handler_cache.instance is not None:
+        handler_instance = handler_cache.instance
         handler_run_func = handler_instance.run
-        exec_info = runner_context.action_handlers_exec_info_by_name[handler.name]
+        exec_info = handler_cache.exec_info
         logger.trace(
             f"R{run_id} | Instance of action handler {handler.name} found in cache"
         )
@@ -411,19 +435,6 @@ async def execute_action_handler(
                 f"Import of action handler '{handler.name}' failed(Run {run_id}): {handler.source}"
             )
 
-        handler_global_config = runner_context.project.action_handler_configs.get(
-            handler.source, None
-        )
-        handler_raw_config = {}
-        if handler_global_config is not None:
-            handler_raw_config = handler_global_config
-        if handler_raw_config == {}:
-            # still empty, just assign
-            handler_raw_config = handler.config
-        else:
-            # not empty anymore, deep merge
-            handler_config_merger.merge(handler_raw_config, handler.config)
-
         def get_handler_config(param_type):
             # TODO: validation errors
             return param_type(**handler_raw_config)
@@ -437,7 +448,7 @@ def get_process_executor(param_type):
         exec_info = domain.ActionHandlerExecInfo()
         # save immediately in context to be able to shutdown it if the first execution
         # is interrupted by stopping ER
-        runner_context.action_handlers_exec_info_by_name[handler.name] = exec_info
+        handler_cache.exec_info = exec_info
         if inspect.isclass(action_handler):
             args = resolve_func_args_with_di(
                 func=action_handler.__init__,
@@ -453,9 +464,7 @@ def get_process_executor(param_type):
                 exec_info.lifecycle = args["lifecycle"]
 
             handler_instance = action_handler(**args)
-            runner_context.action_handlers_instances_by_name[handler.name] = (
-                handler_instance
-            )
+            handler_cache.instance = handler_instance
             handler_run_func = handler_instance.run
         else:
             handler_run_func = action_handler
diff --git a/finecode_extension_runner/src/finecode_extension_runner/context.py b/finecode_extension_runner/src/finecode_extension_runner/context.py
@@ -1,20 +1,12 @@
-from dataclasses import dataclass, field
+from __future__ import annotations
 
-from finecode_extension_api import code_action
+from dataclasses import dataclass, field
 from finecode_extension_runner import domain
 
 
 @dataclass
 class RunnerContext:
     project: domain.Project
-    action_exec_info_by_name: dict[str, domain.ActionExecInfo] = field(
-        default_factory=dict
-    )
-    action_handlers_instances_by_name: dict[str, code_action.ActionHandler] = field(
-        default_factory=dict
-    )
-    action_handlers_exec_info_by_name: dict[str, domain.ActionHandlerExecInfo] = field(
-        default_factory=dict
-    )
+    action_cache_by_name: dict[str, domain.ActionCache] = field(default_factory=dict)
     # don't overwrite, only append and remove
     docs_owned_by_client: list[str] = field(default_factory=list)
diff --git a/finecode_extension_runner/src/finecode_extension_runner/di/resolver.py b/finecode_extension_runner/src/finecode_extension_runner/di/resolver.py
@@ -1,4 +1,4 @@
-from typing import Any, Callable, Type, TypeVar
+from typing import Type, TypeVar
 
 from finecode_extension_api import code_action
 
diff --git a/finecode_extension_runner/src/finecode_extension_runner/domain.py b/finecode_extension_runner/src/finecode_extension_runner/domain.py
@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import enum
+import dataclasses
 import typing
 from pathlib import Path
 
@@ -76,6 +77,18 @@ class ActionHandlerExecInfoStatus(enum.Enum):
     SHUTDOWN = enum.auto()
 
 
+@dataclasses.dataclass
+class ActionCache:
+    exec_info: ActionExecInfo | None = None
+    handler_cache_by_name: dict[str, ActionHandlerCache] = dataclasses.field(default_factory=dict)
+
+
+@dataclasses.dataclass
+class ActionHandlerCache:
+    instance: code_action.ActionHandler | None = None
+    exec_info: ActionHandlerExecInfo | None = None
+
+
 class TextDocumentInfo:
     def __init__(self, uri: str, version: str, text: str) -> None:
         self.uri = uri
diff --git a/finecode_extension_runner/src/finecode_extension_runner/services.py b/finecode_extension_runner/src/finecode_extension_runner/services.py
@@ -1,19 +1,12 @@
-import asyncio
-import collections.abc
 import importlib
-import inspect
 import sys
-import time
 import types
 import typing
 from pathlib import Path
 
 from loguru import logger
-from pydantic.dataclasses import dataclass as pydantic_dataclass
 
-from finecode_extension_api import code_action, textstyler
-from finecode_extension_runner import context, domain, global_state, run_utils, schemas
-from finecode_extension_runner._services import run_action as run_action_module
+from finecode_extension_runner import context, domain, global_state, schemas
 from finecode_extension_runner._services.run_action import (
     ActionFailedException,
     StopWithResponse,
@@ -96,49 +89,37 @@ def reload_action(action_name: str) -> None:
         # TODO: raise error
         return
 
-    actions_to_remove: list[str] = [
-        action_name,
-        *[handler.name for handler in action_obj.handlers],
-    ]
+    if action_name in global_state.runner_context.action_cache_by_name:
+        action_cache = global_state.runner_context.action_cache_by_name[action_name]
 
-    for _action_name in actions_to_remove:
-        try:
-            del global_state.runner_context.action_handlers_instances_by_name[
-                _action_name
-            ]
-            logger.trace(f"Removed '{_action_name}' instance from cache")
-        except KeyError:
-            logger.info(
-                f"Tried to reload action '{_action_name}', but it was not found"
-            )
+        for handler_name, handler_cache in action_cache.handler_cache_by_name.items():
+            if handler_cache.exec_info is not None:
+                shutdown_action_handler(
+                    action_handler_name=handler_name,
+                    exec_info=handler_cache.exec_info,
+                )
 
-        if (
-            _action_name
-            in global_state.runner_context.action_handlers_exec_info_by_name
-        ):
-            shutdown_action_handler(
-                action_handler_name=_action_name,
-                exec_info=global_state.runner_context.action_handlers_exec_info_by_name[
-                    _action_name
-                ],
-            )
+        del global_state.runner_context.action_cache_by_name[action_name]
+        logger.trace(f"Removed '{action_name}' instance from cache")
 
-        try:
-            action_obj = project_def.actions[action_name]
-        except KeyError:
-            logger.warning(f"Definition of action {action_name} not found")
-            continue
+    try:
+        action_obj = project_def.actions[action_name]
+    except KeyError:
+        logger.warning(f"Definition of action {action_name} not found")
+        return
 
-        action_source = action_obj.source
-        if action_source is None:
-            continue
-        action_package = action_source.split(".")[0]
+    sources_to_remove = [action_obj.source]
+    for handler in action_obj.handlers:
+        sources_to_remove.append(handler.source)
+
+    for source_to_remove in sources_to_remove:
+        source_package = source_to_remove.split(".")[0]
 
         loaded_package_modules = dict(
             [
                 (key, value)
                 for key, value in sys.modules.items()
-                if key.startswith(action_package)
+                if key.startswith(source_package)
                 and isinstance(value, types.ModuleType)
             ]
         )
@@ -147,7 +128,7 @@ def reload_action(action_name: str) -> None:
         for key in loaded_package_modules:
             del sys.modules[key]
 
-        logger.trace(f"Remove modules of package '{action_package}' from cache")
+        logger.trace(f"Remove modules of package '{source_package}' from cache")
 
 
 def resolve_package_path(package_name: str) -> str:
@@ -162,11 +143,13 @@ def resolve_package_path(package_name: str) -> str:
 
 
 def document_did_open(document_uri: str) -> None:
-    global_state.runner_context.docs_owned_by_client.append(document_uri)
+    if global_state.runner_context is not None:
+        global_state.runner_context.docs_owned_by_client.append(document_uri)
 
 
 def document_did_close(document_uri: str) -> None:
-    global_state.runner_context.docs_owned_by_client.remove(document_uri)
+    if global_state.runner_context is not None:
+        global_state.runner_context.docs_owned_by_client.remove(document_uri)
 
 
 def shutdown_action_handler(
@@ -190,19 +173,17 @@ def shutdown_action_handler(
 
 def shutdown_all_action_handlers() -> None:
     logger.trace("Shutdown all action handlers")
-    for (
-        action_handler_name,
-        exec_info,
-    ) in global_state.runner_context.action_handlers_exec_info_by_name.items():
-        shutdown_action_handler(
-            action_handler_name=action_handler_name, exec_info=exec_info
-        )
+    for action_cache in global_state.action_cache_by_name.values():
+        for handler_name, handler_cache in action_cache.handler_cache_by_name.items():
+            if handler_cache.exec_info is not None:
+                shutdown_action_handler(
+                    action_handler_name=handler_name, exec_info=handler_cache.exec_info
+                )
 
 
 def exit_action_handler(
     action_handler_name: str, exec_info: domain.ActionHandlerExecInfo
 ) -> None:
-    # action handler exec info expected to exist in runner_context
     if (
         exec_info.lifecycle is not None
         and exec_info.lifecycle.on_exit_callable is not None
@@ -216,11 +197,11 @@ def exit_action_handler(
 
 def exit_all_action_handlers() -> None:
     logger.trace("Exit all action handlers")
-    for (
-        action_handler_name,
-        exec_info,
-    ) in global_state.runner_context.action_handlers_exec_info_by_name.items():
-        exit_action_handler(
-            action_handler_name=action_handler_name, exec_info=exec_info
-        )
-    global_state.runner_context.action_handlers_exec_info_by_name = {}
+    for action_cache in global_state.action_cache_by_name.values():
+        for handler_name, handler_cache in action_cache.handler_cache_by_name.items():
+            if handler_cache.exec_info is not None:
+                exec_info = handler_cache.exec_info
+                exit_action_handler(
+                    action_handler_name=handler_name, exec_info=exec_info
+                )
+        action_cache.handler_cache_by_name = {}

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-from typing import Any, Callable, Type, TypeVar`
	`1`	`+from typing import Type, TypeVar`
`2`	`2`
`3`	`3`	`from finecode_extension_api import code_action`
`4`	`4`