Migrate from apischema to cattrs, because apischema doesn't support Python 3.14 and is not actively maintained.

Author: Aksem

finecode_extension_runner/pyproject.toml

@@ -4,22 +4,19 @@ dynamic = ["version"]
 description = "Extension runner component for FineCode"
 authors = [{ name = "Vladyslav Hnatiuk", email = "aders1234@gmail.com" }]
 readme = "README.md"
-requires-python = ">=3.11, <= 3.14"
+requires-python = ">=3.11, < 3.15"
 dependencies = [
     "loguru==0.7.*",
     "click==8.1.*",
     "finecode_extension_api~=0.4.0a0",
     "deepmerge==2.0.*",
     "debugpy==1.8.*",
     "ordered-set==4.1.*",
-    "apischema==0.19.*",
+    "cattrs>=24.1",
 ]
 
 [dependency-groups]
-# file_python_import_linter is temporary disabled, because it isn't ported to the new finecode_extension_api yet
-# "fine_python_import_linter @ git+https://github.com/finecode-dev/finecode.git#subdirectory=extensions/fine_python_import_linter"
 dev_workspace = [
-    "build==1.2.2.post1",
     "finecode~=0.4.0a0",
     "finecode_dev_common_preset~=0.3.0a0",
 ]

finecode_extension_runner/src/finecode_extension_runner/_converter.py

@@ -0,0 +1,3 @@
+import cattrs
+
+converter = cattrs.Converter()

finecode_extension_runner/src/finecode_extension_runner/_services/merge_results.py

@@ -1,10 +1,10 @@
 import dataclasses
 
-import apischema
 from loguru import logger
 
 from finecode_extension_api import code_action
 from finecode_extension_runner import global_state, run_utils
+from finecode_extension_runner._converter import converter as _converter
 
 
 async def merge_results(action_name: str, results: list[dict]) -> dict:
@@ -37,7 +37,7 @@ async def merge_results(action_name: str, results: list[dict]) -> dict:
 
     merged: code_action.RunActionResult | None = None
     for result_dict in non_empty:
-        typed = apischema.deserialize(result_type, result_dict)
+        typed = _converter.structure(result_dict, result_type)
         if merged is None:
             merged = typed
         else:

finecode_extension_runner/src/finecode_extension_runner/_services/run_action.py

@@ -5,10 +5,12 @@
 import time
 import typing
 
-import apischema
+import cattrs
 import deepmerge
 from loguru import logger
 
+from finecode_extension_runner._converter import converter as _converter
+
 from finecode_extension_api import code_action, textstyler, service
 from finecode_extension_api.interfaces import iprojectactionrunner
 from finecode_extension_runner import (
@@ -620,7 +622,7 @@ async def run_action_raw(
     if action_exec_info.payload_type is not None:
         payload = typing.cast(
             code_action.RunActionPayload,
-            apischema.deserialize(action_exec_info.payload_type, request.params),
+            _converter.structure(request.params, action_exec_info.payload_type),
         )
 
     wal_run_id = getattr(options, "wal_run_id", None)
@@ -754,7 +756,7 @@ async def run_handlers_raw(
     if action_exec_info.payload_type is not None and request.params:
         payload = typing.cast(
             code_action.RunActionPayload,
-            apischema.deserialize(action_exec_info.payload_type, request.params),
+            _converter.structure(request.params, action_exec_info.payload_type),
         )
 
     wal_run_id = getattr(options, "wal_run_id", None)
@@ -906,8 +908,8 @@ async def ensure_handler_instantiated(
 
     def get_handler_config(param_type):
         try:
-            return apischema.deserialize(param_type, handler_raw_config)
-        except apischema.ValidationError as exception:
+            return _converter.structure(handler_raw_config, param_type)
+        except cattrs.ClassValidationError as exception:
             raise ActionFailedException(str(exception)) from exception
 
     def get_process_executor(param_type):
@@ -1090,9 +1092,9 @@ def get_run_context(param_type):
                 if stream_result is None:
                     stream_result = typing.cast(
                         code_action.RunActionResult,
-                        apischema.deserialize(
+                        _converter.structure(
+                            _converter.unstructure(partial_result),
                             type(partial_result),
-                            dataclasses.asdict(partial_result),
                         ),
                     )
                 else:
@@ -1205,10 +1207,7 @@ async def run_subresult_coros_concurrently(
                 action_subresult_dict = dataclasses.asdict(coro_result)
                 action_subresult = typing.cast(
                     code_action.RunActionResult,
-                    apischema.deserialize(
-                        action_subresult_type,
-                        action_subresult_dict,
-                    ),
+                    _converter.structure(action_subresult_dict, action_subresult_type),
                 )
             else:
                 action_subresult.update(coro_result)

finecode_extension_runner/src/finecode_extension_runner/er_server.py

@@ -25,7 +25,6 @@
 import threading
 import typing
 
-import apischema
 from loguru import logger
 from lsprotocol import converters as lsp_converters
 from lsprotocol import types
@@ -34,6 +33,7 @@
 from finecode_extension_api import code_action
 from finecode_extension_api.interfaces import ifileeditor
 from finecode_extension_runner import er_wal, global_state, schemas, services
+from finecode_extension_runner._converter import converter as _converter
 from finecode_extension_runner._services import merge_results as merge_results_service
 from finecode_extension_runner._services import run_action as run_action_service
 from finecode_extension_runner.di import resolver
@@ -446,9 +446,8 @@ async def run_action(server: ErServer, params: dict | None) -> dict:
     )
 
     request = schemas.RunActionRequest(action_name=action_name, params=action_params)
-    options_schema = apischema.deserialize(
-        schemas.RunActionOptions,
-        options if options is not None else {},
+    options_schema = _converter.structure(
+        options if options is not None else {}, schemas.RunActionOptions
     )
     status: str = "success"
 
@@ -553,9 +552,8 @@ async def run_handlers(server: ErServer, params: dict | None) -> dict:
         params=action_params,
         previous_result=previous_result,
     )
-    options_schema = apischema.deserialize(
-        schemas.RunActionOptions,
-        options if options is not None else {},
+    options_schema = _converter.structure(
+        options if options is not None else {}, schemas.RunActionOptions
     )
     status: str = "success"
 

finecode_extension_runner/src/finecode_extension_runner/impls/project_action_runner.py

@@ -6,12 +6,12 @@
 import typing
 from typing import Any, Awaitable, Callable
 
-import apischema
 from loguru import logger
 
 from finecode_extension_api import code_action
 from finecode_extension_api.interfaces import iprojectactionrunner
 from finecode_extension_runner import domain, run_utils
+from finecode_extension_runner._converter import converter as _converter
 
 
 PayloadT = typing.TypeVar("PayloadT", bound=code_action.RunActionPayload)
@@ -117,7 +117,7 @@ def _build_result(
     ) -> ResultT:
         return typing.cast(
             ResultT,
-            apischema.deserialize(action_type.RESULT_TYPE, raw_result),
+            _converter.structure(raw_result, action_type.RESULT_TYPE),
         )
 
     async def run_action(

finecode_extension_runner/src/finecode_extension_runner/impls/workspace_action_runner.py

@@ -5,9 +5,9 @@
 import typing
 from typing import Any, Awaitable, Callable
 
-import apischema
 from finecode_extension_api import code_action
 from finecode_extension_api.interfaces import iworkspaceactionrunner
+from finecode_extension_runner._converter import converter as _converter
 
 PayloadT = typing.TypeVar("PayloadT", bound=code_action.RunActionPayload)
 ResultT = typing.TypeVar("ResultT", bound=code_action.RunActionResult)
@@ -46,8 +46,8 @@ async def run_action_in_projects(
         )
         results_by_project: dict = raw["resultsByProject"]
         return {
-            pathlib.Path(k): apischema.deserialize(
-                action_type.RESULT_TYPE, next(iter(v.values()), {})  # type: ignore[attr-defined]
+            pathlib.Path(k): _converter.structure(
+                next(iter(v.values()), {}), action_type.RESULT_TYPE
             )
             for k, v in results_by_project.items()
         }

finecode_jsonrpc/pyproject.toml

@@ -4,11 +4,11 @@ version = "0.1.0a1"
 description = "JSON-RPC client implementation for FineCode"
 authors = [{ name = "Vladyslav Hnatiuk", email = "aders1234@gmail.com" }]
 readme = "README.md"
-requires-python = ">=3.11, <= 3.14"
+requires-python = ">=3.11, < 3.15"
 dependencies = [
     "loguru==0.7.*",
     "culsans==0.11.*",
-    "apischema==0.19.*",
+    "cattrs>=24.1",
     "finecode_extension_api~=0.4.0a0",
 ]
 

finecode_jsonrpc/src/finecode_jsonrpc/_converter.py

@@ -0,0 +1,34 @@
+import dataclasses
+
+import cattrs
+from cattrs.gen import make_dict_structure_fn, make_dict_unstructure_fn, override
+
+
+def _to_camel(name: str) -> str:
+    parts = name.split("_")
+    return parts[0] + "".join(p.title() for p in parts[1:])
+
+
+def _camel_structure_fn(cls, conv):
+    overrides = {
+        f.name: override(rename=_to_camel(f.name))
+        for f in dataclasses.fields(cls)
+        if _to_camel(f.name) != f.name
+    }
+    return make_dict_structure_fn(cls, conv, **overrides)
+
+
+def _camel_unstructure_fn(cls, conv):
+    overrides = {
+        f.name: override(rename=_to_camel(f.name))
+        for f in dataclasses.fields(cls)
+        if _to_camel(f.name) != f.name
+    }
+    return make_dict_unstructure_fn(cls, conv, **overrides)
+
+
+_is_dc = lambda t: dataclasses.is_dataclass(t) and isinstance(t, type)
+
+converter = cattrs.Converter()
+converter.register_structure_hook_factory(_is_dc, _camel_structure_fn)
+converter.register_unstructure_hook_factory(_is_dc, _camel_unstructure_fn)

finecode_jsonrpc/src/finecode_jsonrpc/client.py

@@ -17,8 +17,9 @@
 import uuid
 from pathlib import Path
 
-import apischema
+import cattrs
 import culsans
+from finecode_jsonrpc._converter import converter as _converter
 from finecode_jsonrpc import _io_thread
 from loguru import logger
 
@@ -370,9 +371,7 @@ def notify(self, method: str, params: typing.Any | None = None) -> None:
             raise ValueError(f"Type of notification params for {method} not found")
 
         if notification_params_type is not None:
-            notification_params_dict = apischema.serialize(
-                notification_params_type, params, aliaser=apischema.utils.to_camel_case
-            )
+            notification_params_dict = _converter.unstructure(params)
         else:
             notification_params_dict = None
 
@@ -408,9 +407,7 @@ def send_request_sync(
         )
 
         if request_params_type is not None:
-            request_params_dict = apischema.serialize(
-                request_params_type, params, aliaser=apischema.utils.to_camel_case
-            )
+            request_params_dict = _converter.unstructure(params)
         else:
             request_params_dict = None
 
@@ -469,9 +466,7 @@ async def send_request(
         )
 
         if request_params_type is not None:
-            request_params_dict = apischema.serialize(
-                request_params_type, params, aliaser=apischema.utils.to_camel_case
-            )
+            request_params_dict = _converter.unstructure(params)
         else:
             request_params_dict = None
 
@@ -567,13 +562,9 @@ async def handle_message(self, message: dict[str, typing.Any]) -> None:
                     return
 
                 try:
-                    response_error = apischema.deserialize(
-                        ResponseError,
-                        data=message["error"],
-                        aliaser=apischema.utils.to_camel_case,
-                    )
-                except apischema.ValidationError as error:
-                    exception = InvalidResponse(". ".join(error.messages))
+                    response_error = _converter.structure(message["error"], ResponseError)
+                except cattrs.ClassValidationError as error:
+                    exception = InvalidResponse(str(error))
 
                     # avoid race condition: request is sent, then cancelled and the server
                     # sends the response before processing the cancel notification
@@ -609,10 +600,8 @@ async def handle_message(self, message: dict[str, typing.Any]) -> None:
                     return
 
                 try:
-                    request = apischema.deserialize(
-                        request_type, message, aliaser=apischema.utils.to_camel_case
-                    )
-                except apischema.ValidationError as error:
+                    request = _converter.structure(message, request_type)
+                except cattrs.ClassValidationError as error:
                     # Invalid request parameters - send 'Invalid params' error
                     logger.warning(
                         f"Invalid params for method {message.get('method')}: {error.messages} | {self.readable_id}"
@@ -666,10 +655,8 @@ async def handle_message(self, message: dict[str, typing.Any]) -> None:
 
                 result_type = self._expected_result_type_by_msg_id[message_id]
                 try:
-                    response = apischema.deserialize(
-                        result_type, message, aliaser=apischema.utils.to_camel_case
-                    )
-                except apischema.ValidationError as error:
+                    response = _converter.structure(message, result_type)
+                except cattrs.ClassValidationError as error:
                     logger.error("errro")
                     logger.exception(error)
                     exception = InvalidResponse(". ".join(error.messages))
@@ -714,10 +701,8 @@ async def handle_message(self, message: dict[str, typing.Any]) -> None:
 
             try:
                 notification_type = self.message_types[method][0]
-                notification = apischema.deserialize(
-                    notification_type, message, aliaser=apischema.utils.to_camel_case
-                )
-            except (KeyError, apischema.ValidationError) as error:
+                notification = _converter.structure(message, notification_type)
+            except (KeyError, cattrs.ClassValidationError) as error:
                 logger.warning(
                     f"Failed to deserialize notification {method}: {error} | {self.readable_id}"
                 )
@@ -741,9 +726,7 @@ async def run_feature_impl(
             response_dict = {
                 "jsonrpc": self.VERSION,
                 "id": message_id,
-                "result": apischema.serialize(
-                    result_type, result, aliaser=apischema.utils.to_camel_case
-                ),
+                "result": _converter.unstructure(result),
             }
 
             response_str = json.dumps(response_dict)
@@ -1223,13 +1206,9 @@ async def read_messages_from_reader(
                                 continue
 
                             try:
-                                result = apischema.deserialize(
-                                    result_type,
-                                    raw_result,
-                                    aliaser=apischema.utils.to_camel_case,
-                                )
-                            except apischema.ValidationError as error:
-                                exception = InvalidResponse(". ".join(error.messages))
+                                result = _converter.structure(raw_result, result_type)
+                            except cattrs.ClassValidationError as error:
+                                exception = InvalidResponse(str(error))
                                 if not future.cancelled():
                                     future.set_exception(exception)
                                 continue