Finish error handling in prepare_runners and prepare_envs handlers. Extend iprojectinfoprovider with methods for current project and project raw config of any project, not only current

Author: Aksem

finecode_extension_api/src/finecode_extension_api/actions/dump_config.py

@@ -1,8 +1,8 @@
 import dataclasses
 import pathlib
+import pprint
 import sys
 import typing
-import pprint
 
 if sys.version_info >= (3, 12):
     from typing import override

finecode_extension_api/src/finecode_extension_api/interfaces/iprojectinfoprovider.py

@@ -1,5 +1,12 @@
+import pathlib
 from typing import Any, Protocol
 
 
 class IProjectInfoProvider(Protocol):
-    async def get_project_raw_config(self) -> dict[str, Any]: ...
+    def get_current_project_def_path(self) -> pathlib.Path: ...
+
+    async def get_project_raw_config(
+        self, project_def_path: pathlib.Path
+    ) -> dict[str, Any]: ...
+
+    async def get_current_project_raw_config(self) -> dict[str, Any]: ...

finecode_extension_runner/src/finecode_extension_runner/_services/run_action.py

@@ -21,17 +21,14 @@
 last_run_id: int = 0
 partial_result_sender: partial_result_sender_module.PartialResultSender
 handler_config_merger = deepmerge.Merger(
-    [
-        (list, ["override"]),
-        (dict, ["merge"]),
-        (set, ["override"])
-    ],
+    [(list, ["override"]), (dict, ["merge"]), (set, ["override"])],
     #  all other types:
     ["override"],
     # strategies in the case where the types conflict:
-    ["override"]
+    ["override"],
 )
 
+
 class ActionFailedException(Exception):
     def __init__(self, message: str) -> None:
         self.message = message
@@ -579,7 +576,9 @@ async def run_subresult_coros_sequentially(
         try:
             coro_result = await coro
         except Exception as e:
-            logger.error(f"Unhandled exception in subresult coroutine({action_name}, run {run_id}):")
+            logger.error(
+                f"Unhandled exception in subresult coroutine({action_name}, run {run_id}):"
+            )
             logger.exception(e)
             raise ActionFailedException(
                 f"Running action handlers of '{action_name}' failed(Run {run_id}): {e}"

finecode_extension_runner/src/finecode_extension_runner/action_handlers/dependency_config_utils.py

@@ -5,46 +5,67 @@
 def make_project_config_pip_compatible(
     project_raw_config: dict[str, typing.Any], config_file_path: pathlib.Path
 ) -> None:
-    # TODO: what to do with included groups in dependency groups? Inherit config from its env?
     finecode_config = project_raw_config.get("tool", {}).get("finecode", {})
     # apply changes to dependencies from env configuration to deps groups
-    for env_name, env_config in finecode_config.get("env", {}).items():
-        if "dependencies" not in env_config:
-            continue
-
-        env_deps_group = project_raw_config.get("dependency-groups", {}).get(
-            env_name, []
+    for env_name in finecode_config.get("env", {}).keys():
+        make_env_deps_pip_compatible(
+            env_name=env_name,
+            project_raw_config=project_raw_config,
+            config_file_path=config_file_path,
         )
-        dependencies = env_config["dependencies"]
-        for dep_name, dep_params in dependencies.items():
-            # handle 'path'. 'editable' cannot be handled here because dependency
-            # specifier doesn't support it. It will read and processed by
-            # `install_deps` action
-            if "path" in dep_params:
-                # replace dependency version / source in dependency group to this path
-                #
-                # check all dependencies because it can be duplicated: e.g. as explicit
-                # dependency and as dependency of action handler.
-                dep_indexes_in_group: list[int] = []
-                for idx, dep in enumerate(env_deps_group):
-                    # check for string because dependency can be also dictionary like '{ "include-group": "runtime"}'
-                    if isinstance(dep, str) and get_dependency_name(dep) == dep_name:
+
+
+def make_env_deps_pip_compatible(
+    env_name: str,
+    project_raw_config: dict[str, typing.Any],
+    config_file_path: pathlib.Path,
+) -> None:
+    env_config = (
+        project_raw_config.get("tool", {})
+        .get("finecode", {})
+        .get("env", {})
+        .get(env_name, None)
+    )
+    if env_config is None or "dependencies" not in env_config:
+        return
+
+    env_deps_group = project_raw_config.get("dependency-groups", {}).get(env_name, [])
+    dependencies = env_config["dependencies"]
+    for dep_name, dep_params in dependencies.items():
+        # handle 'path'. 'editable' cannot be handled here because dependency
+        # specifier doesn't support it. It will read and processed by
+        # `install_deps` action
+        if "path" in dep_params:
+            # replace dependency version / source in dependency group to this path
+            #
+            # check all dependencies because it can be duplicated: e.g. as explicit
+            # dependency and as dependency of action handler.
+            dep_indexes_in_group: list[int] = []
+            for idx, dep in enumerate(env_deps_group):
+                if isinstance(dep, dict):
+                    if "include-group" in dep:
+                        included_group = dep["include-group"]
+                        make_env_deps_pip_compatible(
+                            env_name=included_group,
+                            project_raw_config=project_raw_config,
+                            config_file_path=config_file_path,
+                        )
+                elif isinstance(dep, str):
+                    if get_dependency_name(dep) == dep_name:
                         dep_indexes_in_group.append(idx)
 
-                if len(dep_indexes_in_group) == 0:
-                    continue
+            if len(dep_indexes_in_group) == 0:
+                continue
 
-                resolved_path_to_dep = pathlib.Path(dep_params["path"])
-                if not resolved_path_to_dep.is_absolute():
-                    # resolve relative to project dir where project def file is
-                    resolved_path_to_dep = (
-                        config_file_path.parent / resolved_path_to_dep
-                    )
-                new_dep_str_in_group = (
-                    f"{dep_name} @ file://{resolved_path_to_dep.as_posix()}"
-                )
-                for idx in dep_indexes_in_group:
-                    env_deps_group[idx] = new_dep_str_in_group
+            resolved_path_to_dep = pathlib.Path(dep_params["path"])
+            if not resolved_path_to_dep.is_absolute():
+                # resolve relative to project dir where project def file is
+                resolved_path_to_dep = config_file_path.parent / resolved_path_to_dep
+            new_dep_str_in_group = (
+                f"{dep_name} @ file://{resolved_path_to_dep.as_posix()}"
+            )
+            for idx in dep_indexes_in_group:
+                env_deps_group[idx] = new_dep_str_in_group
 
 
 def get_dependency_name(dependency_str: str) -> str:
@@ -58,11 +79,6 @@ def get_dependency_name(dependency_str: str) -> str:
     return dependency_str
 
 
-class FailedToGetDependencies(Exception):
-    def __init__(self, message: str) -> None:
-        self.message = message
-
-
 def raw_dep_to_dep_dict(raw_dep: str, env_deps_config: dict) -> dict[str, str | bool]:
     name = get_dependency_name(raw_dep)
     version_or_source = raw_dep[len(name) :]
@@ -73,3 +89,10 @@ def raw_dep_to_dep_dict(raw_dep: str, env_deps_config: dict) -> dict[str, str |
         "editable": editable,
     }
     return dep_dict
+
+
+__all__ = [
+    "make_project_config_pip_compatible",
+    "get_dependency_name",
+    "raw_dep_to_dep_dict",
+]

finecode_extension_runner/src/finecode_extension_runner/action_handlers/prepare_envs_read_configs.py

@@ -1,5 +1,8 @@
+import asyncio
 import dataclasses
+import pathlib
 import shutil
+import typing
 
 from finecode_extension_api import code_action
 from finecode_extension_api.actions import prepare_envs as prepare_envs_action
@@ -38,22 +41,30 @@ async def run(
         project_defs_pathes = set(
             [env_info.project_def_path for env_info in payload.envs]
         )
-        if len(project_defs_pathes) != 1:
-            raise code_action.ActionFailedException("PrepareEnvsReadConfigsHandler supports only reading config of envs from the current project")
+        raw_config_by_project_def_path: dict[pathlib.Path, dict[str, typing.Any]] = {}
 
-        project_raw_config = await self.project_info_provider.get_project_raw_config()
+        get_config_tasks: list[asyncio.Task] = []
+        async with asyncio.TaskGroup() as tg:
+            for project_def_path in project_defs_pathes:
+                task = tg.create_task(
+                    self.project_info_provider.get_project_raw_config(project_def_path)
+                )
+                get_config_tasks.append(task)
 
-        project_def_path = project_defs_pathes.pop()
-        project_dir_path = project_def_path.parent
-
-        dependency_config_utils.make_project_config_pip_compatible(
-            project_raw_config, project_def_path
-        )
+        for idx, project_def_path in enumerate(project_defs_pathes):
+            project_raw_config = get_config_tasks[idx].result()
+            dependency_config_utils.make_project_config_pip_compatible(
+                project_raw_config, project_def_path
+            )
+            raw_config_by_project_def_path[project_def_path] = project_raw_config
 
         for env_info in payload.envs:
             run_context.project_def_path_by_venv_dir_path[env_info.venv_dir_path] = (
-                project_def_path
+                env_info.project_def_path
             )
+            project_raw_config = raw_config_by_project_def_path[
+                env_info.project_def_path
+            ]
             run_context.project_def_by_venv_dir_path[env_info.venv_dir_path] = (
                 project_raw_config
             )

finecode_extension_runner/src/finecode_extension_runner/action_handlers/prepare_runners_read_configs.py

@@ -1,5 +1,8 @@
+import asyncio
 import dataclasses
+import pathlib
 import shutil
+import typing
 
 from finecode_extension_api import code_action
 from finecode_extension_api.actions import prepare_runners as prepare_runners_action
@@ -39,22 +42,30 @@ async def run(
         project_defs_pathes = set(
             [env_info.project_def_path for env_info in payload.envs]
         )
-        if len(project_defs_pathes) != 1:
-            raise code_action.ActionFailedException("PrepareRunnersReadConfigsHandler supports only reading config of envs from the current project")
+        raw_config_by_project_def_path: dict[pathlib.Path, dict[str, typing.Any]] = {}
 
-        project_raw_config = await self.project_info_provider.get_project_raw_config()
+        get_config_tasks: list[asyncio.Task] = []
+        async with asyncio.TaskGroup() as tg:
+            for project_def_path in project_defs_pathes:
+                task = tg.create_task(
+                    self.project_info_provider.get_project_raw_config(project_def_path)
+                )
+                get_config_tasks.append(task)
 
-        project_def_path = project_defs_pathes.pop()
-        project_dir_path = project_def_path.parent
-
-        dependency_config_utils.make_project_config_pip_compatible(
-            project_raw_config, project_def_path
-        )
+        for idx, project_def_path in enumerate(project_defs_pathes):
+            project_raw_config = get_config_tasks[idx].result()
+            dependency_config_utils.make_project_config_pip_compatible(
+                project_raw_config, project_def_path
+            )
+            raw_config_by_project_def_path[project_def_path] = project_raw_config
 
         for env_info in payload.envs:
             run_context.project_def_path_by_venv_dir_path[env_info.venv_dir_path] = (
-                project_def_path
+                env_info.project_def_path
             )
+            project_raw_config = raw_config_by_project_def_path[
+                env_info.project_def_path
+            ]
             run_context.project_def_by_venv_dir_path[env_info.venv_dir_path] = (
                 project_raw_config
             )

finecode_extension_runner/src/finecode_extension_runner/di/bootstrap.py

@@ -1,4 +1,6 @@
-from typing import Any, Callable, Type, TypeVar
+import functools
+import pathlib
+from typing import Any, Awaitable, Callable, Type, TypeVar
 
 try:
     import fine_python_ast
@@ -21,6 +23,7 @@
 )
 from finecode_extension_runner import global_state, schemas
 from finecode_extension_runner._services import run_action
+from finecode_extension_runner.di import _state
 from finecode_extension_runner.impls import (
     action_runner,
     command_runner,
@@ -29,10 +32,14 @@
     loguru_logger,
     project_info_provider,
 )
-from finecode_extension_runner.di import _state
 
 
-def bootstrap(get_document_func: Callable, save_document_func: Callable):
+def bootstrap(
+    get_document_func: Callable,
+    save_document_func: Callable,
+    project_def_path_getter: Callable[[], pathlib.Path],
+    project_raw_config_getter: Callable[[str], Awaitable[dict[str, Any]]],
+):
     # logger_instance = loguru_logger.LoguruLogger()
     logger_instance = loguru_logger.get_logger()
     command_runner_instance = command_runner.CommandRunner(logger=logger_instance)
@@ -62,7 +69,11 @@ def bootstrap(get_document_func: Callable, save_document_func: Callable):
         _state.factories[fine_python_mypy.IMypySingleAstProvider] = (
             mypy_single_ast_provider_factory
         )
-    _state.factories[iprojectinfoprovider.IProjectInfoProvider] = project_info_provider_factory
+    _state.factories[iprojectinfoprovider.IProjectInfoProvider] = functools.partial(
+        project_info_provider_factory,
+        project_def_path_getter=project_def_path_getter,
+        project_raw_config_getter=project_raw_config_getter,
+    )
 
     # TODO: parameters from config
 
@@ -97,5 +108,12 @@ def mypy_single_ast_provider_factory(container):
     )
 
 
-def project_info_provider_factory(container):
-    return project_info_provider.ProjectInfoProvider()
+def project_info_provider_factory(
+    container,
+    project_def_path_getter: Callable[[], pathlib.Path],
+    project_raw_config_getter: Callable[[str], Awaitable[dict[str, Any]]],
+):
+    return project_info_provider.ProjectInfoProvider(
+        project_def_path_getter=project_def_path_getter,
+        project_raw_config_getter=project_raw_config_getter,
+    )

finecode_extension_runner/src/finecode_extension_runner/impls/project_info_provider.py

@@ -1,10 +1,26 @@
-from typing import Any, Callable
+import pathlib
+from typing import Any, Awaitable, Callable
 
 from finecode_extension_api.interfaces import iprojectinfoprovider
 
-project_raw_config_getter: Callable
-
 
 class ProjectInfoProvider(iprojectinfoprovider.IProjectInfoProvider):
-    async def get_project_raw_config(self) -> dict[str, Any]:
-        return await project_raw_config_getter()
+    def __init__(
+        self,
+        project_def_path_getter: Callable[[], pathlib.Path],
+        project_raw_config_getter: Callable[[str], Awaitable[dict[str, Any]]],
+    ) -> None:
+        self.project_def_path_getter = project_def_path_getter
+        self.project_raw_config_getter = project_raw_config_getter
+
+    def get_current_project_def_path(self) -> pathlib.Path:
+        return self.project_def_path_getter()
+
+    async def get_project_raw_config(
+        self, project_def_path: pathlib.Path
+    ) -> dict[str, Any]:
+        return await self.project_raw_config_getter(str(project_def_path))
+
+    async def get_current_project_raw_config(self) -> dict[str, Any]:
+        current_project_path = self.get_current_project_def_path()
+        return await self.get_project_raw_config(project_def_path=current_project_path)