openrewrite-remote 0.13.3__tar.gz → 0.13.5__tar.gz

{openrewrite_remote-0.13.3 → openrewrite_remote-0.13.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openrewrite-remote
-Version: 0.13.3
+Version: 0.13.5
 Summary: Remoting functionality for the OpenRewrite library.
 Author-email: "Moderne Inc." <support@moderne.io>
 License: Moderne, Inc. Commercial License

{openrewrite_remote-0.13.3 → openrewrite_remote-0.13.5}/openrewrite_remote.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: openrewrite-remote
-Version: 0.13.3
+Version: 0.13.5
 Summary: Remoting functionality for the OpenRewrite library.
 Author-email: "Moderne Inc." <support@moderne.io>
 License: Moderne, Inc. Commercial License

{openrewrite_remote-0.13.3 → openrewrite_remote-0.13.5}/pyproject.toml

@@ -5,7 +5,7 @@ build-backend = "setuptools.build_meta"
 [project]
 name = "openrewrite-remote"
 description = "Remoting functionality for the OpenRewrite library."
-version = "0.13.3" # Updated dynamically during release
+version = "0.13.5" # Updated dynamically during release
 authors = [{ name = "Moderne Inc.", email = "support@moderne.io" }]
 license = { text = "Moderne, Inc. Commercial License" }
 dependencies = [
@@ -24,11 +24,12 @@ exclude = []
 [dependency-groups]
 dev = [
     "pytest==8.3.4",
-    "pytest-asyncio==0.24.0",
-    "mypy==1.13.0",
+    "pytest-asyncio==0.25.0",
+    "mypy==1.14.0",
     "poethepoet==0.31.1",
-    "black==24.10.0",
     "pylint==3.3.2",
+    "ruff>=0.8.4",
+    "types-toml>=0.10.8.20240310",
 ]
 
 [project.scripts]
@@ -36,6 +37,8 @@ start_python_remoting = "rewrite_remote.server:main"
 
 [tool.poe.tasks]
 check-types = "mypy ./rewrite_remote"
-format = "black ./rewrite_remote ./tests"
+format = "ruff format ./rewrite_remote ./tests"
 test = "pytest"
-lint = "pylint ./rewrite_remote/**/*.py ./tests/**/*.py"
+lint-pylint = "pylint ./rewrite_remote/**/*.py ./tests/**/*.py"
+lint-ruff = "ruff check ./rewrite_remote ./tests"
+lint-ruff-fix = "ruff check --fix ./rewrite_remote ./tests"

{openrewrite_remote-0.13.3 → openrewrite_remote-0.13.5}/rewrite_remote/__init__.py

@@ -6,7 +6,5 @@ from .sender import *
 from .remoting import *
 
 __all__ = [
-    name
-    for name in dir()
-    if not name.startswith("_") and not isinstance(globals()[name], TypeVar)
+    name for name in dir() if not name.startswith("_") and not isinstance(globals()[name], TypeVar)
 ]

{openrewrite_remote-0.13.3 → openrewrite_remote-0.13.5}/rewrite_remote/handlers/handler_helpers.py

@@ -3,7 +3,7 @@ import socket
 import cbor2
 
 from rewrite_remote.remote_utils import COMMAND_END
-from rewrite_remote import RemotingMessageType, OK, ERROR
+from rewrite_remote import RemotingMessageType, ERROR
 
 
 def respond_with_error(message: str, sock: socket.socket) -> None:

{openrewrite_remote-0.13.3 → openrewrite_remote-0.13.5}/rewrite_remote/handlers/project_helper.py

@@ -54,9 +54,7 @@ def is_uv_project(tomlData: dict[str, Any]) -> bool:
     return "tool" in tomlData and "uv" in tomlData["tool"]
 
 
-def find_sub_projects_in_poetry(
-    tomlData: dict[str, Any], toml_path: str
-) -> list[Project]:
+def find_sub_projects_in_poetry(tomlData: dict[str, Any], toml_path: str) -> list[Project]:
     """
     Finds sub projects in a poetry project by looking for dependencies with a "path" key:
         [tool.poetry.dependencies]
@@ -78,9 +76,7 @@ def find_sub_projects_in_poetry(
     return subProjects
 
 
-def find_sub_projects_in_hatch(
-    tomlData: dict[str, Any], toml_path: str
-) -> list[Project]:
+def find_sub_projects_in_hatch(tomlData: dict[str, Any], toml_path: str) -> list[Project]:
     """
     Finds sub projects in a hatch project by looking for dependencies with a "path" key:
         [tool.hatch.envs.default.dependencies]
@@ -98,18 +94,14 @@ def find_sub_projects_in_hatch(
                         subProjects.append(
                             Project(
                                 project_name=dep_name,
-                                project_root=get_absolute_path(
-                                    toml_path, dep_value["path"]
-                                ),
+                                project_root=get_absolute_path(toml_path, dep_value["path"]),
                                 project_tool=f"hatch:{env_name}",
                             )
                         )
     return subProjects
 
 
-def find_sub_projects_in_uv_sources(
-    tomlData: dict[str, Any], toml_path: str
-) -> list[Project]:
+def find_sub_projects_in_uv_sources(tomlData: dict[str, Any], toml_path: str) -> list[Project]:
     """
     Finds sub projects in a uv project by looking at sources and workspace:
     [tool.uv.sources]
@@ -146,7 +138,8 @@ def find_sub_projects_in_uv_sources(
         for glob_pattern in uv_workspace["members"]:
             # Every directory included by the members globs (and not excluded by the exclude globs) must contain a pyproject.toml file
             directories = glob.glob(
-                os.path.join(os.path.dirname(toml_path), glob_pattern), recursive=True
+                os.path.join(os.path.dirname(toml_path), glob_pattern),
+                recursive=True,
             )
 
             for directory in directories:

{openrewrite_remote-0.13.3 → openrewrite_remote-0.13.5}/rewrite_remote/handlers/pypi_manager.py

@@ -4,6 +4,8 @@ import subprocess
 import importlib
 import inspect
 import pkgutil
+import site
+
 from dataclasses import dataclass
 
 from pypi_simple import PyPISimple
@@ -51,7 +53,11 @@ class InstalledRecipe:
 
 class InstalledPackage:
     def __init__(
-        self, name: str, version: str, source: str, recipes: List[InstalledRecipe]
+        self,
+        name: str,
+        version: str,
+        source: str,
+        recipes: List[InstalledRecipe],
     ):
         self.name = name
         self.version = version
@@ -87,14 +93,10 @@ class PyPiManager:
                     requestedVersion,
                 )
                 if result:
-                    print(
-                        f"Package {package_identifier} found in source: {source.source}"
-                    )
+                    print(f"Package {package_identifier} found in source: {source.source}")
                     return source
                 else:
-                    print(
-                        f"Package {package_identifier} not found in source: {source.source}"
-                    )
+                    print(f"Package {package_identifier} not found in source: {source.source}")
             except Exception as e:
                 print(f"Error checking source {source.source}: {e}")
 
@@ -161,9 +163,7 @@ class PyPiManager:
             raise RuntimeError(f"Failed to uninstall package {package_name}: {e}")
 
     @staticmethod
-    def load_recipe(
-        recipe_name: str, module_name: str, recipe_options: List[Option]
-    ) -> Recipe:
+    def load_recipe(recipe_name: str, module_name: str, recipe_options: List[Option]) -> Recipe:
         """
         Loads a recipe from the specified source.
         """
@@ -191,9 +191,7 @@ class PyPiManager:
                 raise RuntimeError(f"Package {package_name} is not installed.")
             return metadata
         except Exception as e:
-            raise RuntimeError(
-                f"Failed to load package details for {package_name}: {e}"
-            )
+            raise RuntimeError(f"Failed to load package details for {package_name}: {e}")
 
     @staticmethod
     def _get_package_metadata(package_name: str) -> Dict[str, Any]:
@@ -210,9 +208,7 @@ class PyPiManager:
             metadata_dict = {key.lower(): value for key, value in dist.metadata.items()}
             return metadata_dict
         except importlib.metadata.PackageNotFoundError:
-            print(
-                f"Package {package_name} not found in {DEFAULT_RECIPE_INSTALL_LOCATION}"
-            )
+            print(f"Package {package_name} not found in {DEFAULT_RECIPE_INSTALL_LOCATION}")
             return {}
 
     @staticmethod
@@ -225,6 +221,7 @@ class PyPiManager:
         module_name = module_name.replace("-", "_")
 
         try:
+            site.main(); # We want the recently installed module to be available to introspection
             module = importlib.import_module(module_name)
             submodules = [name for _, name, _ in pkgutil.iter_modules(module.__path__)]
 

{openrewrite_remote-0.13.3 → openrewrite_remote-0.13.5}/rewrite_remote/handlers/recipe_install_handler.py

@@ -111,9 +111,7 @@ def recipe_install_handler(
 
     # 4. Install the recipe
     try:
-        installable_recipes = PyPiManager.install_package(
-            package_id, package_version, valid_source
-        )
+        installable_recipes = PyPiManager.install_package(package_id, package_version, valid_source)
     except Exception as e:  # pylint: disable=broad-except
         respond_with_error(f"Failed to install package: {e}", sock)
         return

{openrewrite_remote-0.13.3 → openrewrite_remote-0.13.5}/rewrite_remote/handlers/run_recipe_load_and_visitor_handler.py

@@ -13,7 +13,7 @@ from rewrite_remote.remoting import (
 )
 
 from rewrite_remote.remote_utils import COMMAND_END
-from rewrite_remote.remoting import OK, RemotingContext, RemotingMessageType
+from rewrite_remote.remoting import RemotingContext
 from rewrite_remote.handlers.handler_helpers import respond_with_error
 
 from rewrite import InMemoryExecutionContext
@@ -98,9 +98,7 @@ def run_recipe_load_and_visitor_handler(
     RemotingExecutionContextView.view(ctx).remoting_context = remoting_ctx
 
     try:
-        recipe_instance = PyPiManager.load_recipe(
-            recipe_name, recipe_source, recipe_options
-        )
+        recipe_instance = PyPiManager.load_recipe(recipe_name, recipe_source, recipe_options)
     except Exception as e:
         respond_with_error(f"Failed to load recipe: {e}", sock)
         return
@@ -122,9 +120,7 @@ def run_recipe_load_and_visitor_handler(
 
     # 5. Write the response
     response_encoder = BytesIO()
-    RemotingMessenger.send_tree(
-        remoting_ctx, response_encoder, RemotingMessenger._state, received
-    )
+    RemotingMessenger.send_tree(remoting_ctx, response_encoder, RemotingMessenger._state, received)
 
     encoded_response = b""
     encoded_response += dumps(RemotingMessageType.Response)

{openrewrite_remote-0.13.3 → openrewrite_remote-0.13.5}/rewrite_remote/receiver.py

@@ -86,7 +86,10 @@ class ReceiverFactory(Protocol):
 
 class DetailsReceiver(Protocol[T]):
     def receive_details(
-        self, before: Optional[T], type: Optional[Type[T]], ctx: "ReceiverContext"
+        self,
+        before: Optional[T],
+        type: Optional[Type[T]],
+        ctx: "ReceiverContext",
     ) -> T:
         pass
 
@@ -111,7 +114,10 @@ class ReceiverContext:
         return cast(Optional[T], OmniReceiver().receive(before, self))
 
     def receive_tree(
-        self, before: Optional[Tree], tree_type: Optional[str], ctx: "ReceiverContext"
+        self,
+        before: Optional[Tree],
+        tree_type: Optional[str],
+        ctx: "ReceiverContext",
     ) -> Tree:
         if before:
             return before.accept(self.visitor, ctx)
@@ -123,9 +129,7 @@ class ReceiverContext:
     def polymorphic_receive_tree(self, before: Optional[Tree]) -> Optional[Tree]:
         diff_event = self.receiver.receive_node()
         if diff_event.event_type in (EventType.Add, EventType.Update):
-            tree_receiver = self.new_receiver(
-                diff_event.concrete_type or type(before).__name__
-            )
+            tree_receiver = self.new_receiver(diff_event.concrete_type or type(before).__name__)
             forked = tree_receiver.fork(self)
             return forked.receive_tree(
                 None if diff_event.event_type == EventType.Add else before,
@@ -159,7 +163,10 @@ class ReceiverContext:
         return before
 
     def receive_markers(
-        self, before: Optional[Markers], type: Optional[str], ctx: "ReceiverContext"
+        self,
+        before: Optional[Markers],
+        type: Optional[str],
+        ctx: "ReceiverContext",
     ) -> Markers:
         id_ = self.receive_value(getattr(before, "id", None), UUID)
         after_markers: Optional[List[Marker]] = self.receive_values(
@@ -177,9 +184,7 @@ class ReceiverContext:
     ) -> Optional[List[A]]:
         return remote_utils.receive_nodes(before, details, self)
 
-    def receive_values(
-        self, before: Optional[List[V]], type: Type[Any]
-    ) -> Optional[List[V]]:
+    def receive_values(self, before: Optional[List[V]], type: Type[Any]) -> Optional[List[V]]:
         return remote_utils.receive_values(before, type, self)
 
     def receive_value(self, before: Optional[V], type: Type[Any]) -> Optional[V]:
@@ -198,7 +203,7 @@ class ReceiverContext:
         ReceiverContext.Registry[type_] = receiver_factory
 
 
-ValueDeserializer = Callable[[Type[Any], CBORDecoder, "DeserializationContext"], Optional[Any]]
+ValueDeserializer = Callable[[str, CBORDecoder, "DeserializationContext"], Optional[Any]]
 
 
 class DefaultValueDeserializer(ValueDeserializer):
@@ -256,7 +261,7 @@ class DeserializationContext:
         initial_byte = decoder.read(1)[0]
         major_type = initial_byte >> 5
         subtype = initial_byte & 31
-        concrete_type = None
+        concrete_type: Optional[str] = None
 
         # Object ID for Marker, JavaType, etc.
         if major_type == 0:
@@ -275,7 +280,9 @@ class DeserializationContext:
                     for _ in range(subtype):
                         array.append(self.deserialize(expected_elem_type, decoder))
                 else:
-                    while not (value := self.deserialize(expected_elem_type, decoder)) == break_marker:
+                    while (
+                        not (value := self.deserialize(expected_elem_type, decoder)) == break_marker
+                    ):
                         array.append(value)
                 return array
             else:
@@ -301,7 +308,7 @@ class DeserializationContext:
                     id_ = UUID(bytes=decoder.decode())
                 return SearchResult(id_, desc)
 
-            if (deser := self.value_deserializers.get(concrete_type)):
+            if deser := self.value_deserializers.get(concrete_type):
                 return deser(concrete_type, decoder, self)
 
             for type_, value_deserializer in self.value_deserializers.items():
@@ -378,9 +385,7 @@ class DeserializationContext:
             if concrete_type == "java.math.BigDecimal":
                 return decoder.decode()
 
-            raise NotImplementedError(
-                f"No deserialization implemented for: {concrete_type}"
-            )
+            raise NotImplementedError(f"No deserialization implemented for: {concrete_type}")
 
         if state == cbor2.CborReaderState.ARRAY:
             decoder.read_array_start()
@@ -425,9 +430,7 @@ class DeserializationContext:
             for type_, deserializer in self.value_deserializers.items():
                 if issubclass(actual_type, type_):
                     return deserializer.deserialize(actual_type, decoder, self)
-        raise NotImplementedError(
-            f"No deserialization implemented for: {expected_type}"
-        )
+        raise NotImplementedError(f"No deserialization implemented for: {expected_type}")
 
 
 class JsonReceiver(TreeReceiver):
@@ -448,11 +451,7 @@ class JsonReceiver(TreeReceiver):
             concrete_type = None
 
             if event_type in {EventType.Add, EventType.Update}:
-                if (
-                    event_type == EventType.Add
-                    and len(array) > 1
-                    and isinstance(array[1], str)
-                ):
+                if event_type == EventType.Add and len(array) > 1 and isinstance(array[1], str):
                     concrete_type = array[1]
 
             elif event_type not in {
@@ -522,21 +521,15 @@ class ParseErrorReceiver(Receiver):
             parse_error = parse_error.with_markers(
                 ctx.receive_node(parse_error.markers, ctx.receive_markers)
             )
-            parse_error = parse_error.with_source_path(
-                ctx.receive_value(parse_error.source_path)
-            )
+            parse_error = parse_error.with_source_path(ctx.receive_value(parse_error.source_path))
             parse_error = parse_error.with_file_attributes(
                 ctx.receive_value(parse_error.file_attributes)
             )
-            parse_error = parse_error.with_charset_name(
-                ctx.receive_value(parse_error.charset_name)
-            )
+            parse_error = parse_error.with_charset_name(ctx.receive_value(parse_error.charset_name))
             parse_error = parse_error.with_charset_bom_marked(
                 ctx.receive_value(parse_error.charset_bom_marked)
             )
-            parse_error = parse_error.with_checksum(
-                ctx.receive_value(parse_error.checksum)
-            )
+            parse_error = parse_error.with_checksum(ctx.receive_value(parse_error.checksum))
             parse_error = parse_error.with_text(ctx.receive_value(parse_error.text))
             # parse_error = parse_error.with_erroneous(ctx.receive_tree(parse_error.erroneous))
             return parse_error

{openrewrite_remote-0.13.3 → openrewrite_remote-0.13.5}/rewrite_remote/remote_utils.py

@@ -57,9 +57,7 @@ def receive_nodes(
             elif diff_event.event_type == EventType.NoChange:
                 after[i] = None  # Or some default value
             else:
-                raise NotImplementedError(
-                    f"Unexpected operation: {diff_event.event_type}"
-                )
+                raise NotImplementedError(f"Unexpected operation: {diff_event.event_type}")
         return after  # type: ignore
     elif list_event.event_type == EventType.Update:
         return _receive_updated_nodes(before, list_event.msg, details, ctx)  # type: ignore
@@ -85,7 +83,11 @@ def _receive_updated_nodes(
         if evt.event_type in (EventType.NoChange, EventType.EndList):
             break
 
-        if evt.event_type in (EventType.Delete, EventType.Update, EventType.Add):
+        if evt.event_type in (
+            EventType.Delete,
+            EventType.Update,
+            EventType.Add,
+        ):
             if not modified:
                 after_list = _copy_range(before, before_idx)
                 modified = True
@@ -97,9 +99,7 @@ def _receive_updated_nodes(
         elif evt.event_type == EventType.Delete:
             before_idx += 1
         elif evt.event_type == EventType.Update:
-            after_list.append(
-                details.receive_details(before[before_idx], evt.concrete_type, ctx)
-            )
+            after_list.append(details.receive_details(before[before_idx], evt.concrete_type, ctx))
             before_idx += 1
         elif evt.event_type == EventType.Add:
             after_list.append(details.receive_details(None, evt.concrete_type, ctx))
@@ -130,9 +130,7 @@ def receive_values(
             elif diff_event.event_type == EventType.NoChange:
                 after[i] = None  # Or some default value
             else:
-                raise NotImplementedError(
-                    f"Unexpected operation: {diff_event.event_type}"
-                )
+                raise NotImplementedError(f"Unexpected operation: {diff_event.event_type}")
         return after  # type: ignore
     elif list_event.event_type == EventType.Update:
         return _receive_updated_values(before, list_event.msg, type, ctx)  # type: ignore
@@ -155,7 +153,11 @@ def _receive_updated_values(
         if evt.event_type in (EventType.NoChange, EventType.EndList):
             break
 
-        if evt.event_type in (EventType.Delete, EventType.Update, EventType.Add):
+        if evt.event_type in (
+            EventType.Delete,
+            EventType.Update,
+            EventType.Add,
+        ):
             if not modified:
                 after_list = _copy_range(before, before_idx)
                 modified = True
@@ -239,16 +241,20 @@ def calculate_list_diff(
 
                 # If elements at current indices are not equal, figure out the operation
                 if before_id not in after_map:
-                    consumer(Operation.Delete, before_idx, -1, before[before_idx], None)
+                    consumer(
+                        Operation.Delete,
+                        before_idx,
+                        -1,
+                        before[before_idx],
+                        None,
+                    )
                     before_idx += 1
                 else:
                     consumer(Operation.Add, -1, after_idx, None, after[after_idx])
                     after_idx += 1
 
 
-def create_index_map(
-    lst: List[T], from_index: int, id_function: Callable[[T], I]
-) -> Dict[I, int]:
+def create_index_map(lst: List[T], from_index: int, id_function: Callable[[T], I]) -> Dict[I, int]:
     result = {}
     for i in range(from_index, len(lst)):
         result[id_function(lst[i])] = i

{openrewrite_remote-0.13.3 → openrewrite_remote-0.13.5}/rewrite_remote/remoting.py

@@ -12,8 +12,6 @@ from typing import (
     Dict,
     Optional,
     Type,
-    List,
-    Tuple,
     Callable,
     cast,
     Union,
@@ -108,14 +106,16 @@ class RemotingContext:
     def new_sender_context(self, output_stream: Any) -> "SenderContext":
         return SenderContext(
             JsonSender(
-                output_stream, SerializationContext(self, self._value_serializers)
+                output_stream,
+                SerializationContext(self, self._value_serializers),
             )
         )
 
     def new_receiver_context(self, input_stream: Any) -> "ReceiverContext":
         return ReceiverContext(
             JsonReceiver(
-                input_stream, DeserializationContext(self, self._value_deserializers)
+                input_stream,
+                DeserializationContext(self, self._value_deserializers),
             )
         )
 
@@ -160,7 +160,6 @@ ERROR = 1
 
 
 class RemotingMessenger:
-
     def __init__(
         self,
         context: RemotingContext,
@@ -249,9 +248,7 @@ class RemotingMessenger:
         root_cursor = Cursor(None, Cursor.ROOT_VALUE)
         ctx = InMemoryExecutionContext()
         RemotingExecutionContextView.view(ctx).remoting_context = self._context
-        print_output = received.print(
-            Cursor(root_cursor, received), PrintOutputCapture(0)
-        )
+        print_output = received.print(Cursor(root_cursor, received), PrintOutputCapture(0))
 
         response_stream = BytesIO()
         cbor2.dump(RemotingMessageType.Response, response_stream)
@@ -280,7 +277,9 @@ class RemotingMessenger:
 
     def send_print_request(self, sock: socket.socket, cursor: Cursor):
         self.__send_request_stream(
-            sock, "print", lambda s: self.send_tree(s, cast(Tree, cursor.value))
+            sock,
+            "print",
+            lambda s: self.send_tree(s, cast(Tree, cursor.value)),
         )
         if self.recv_byte(sock) != RemotingMessageType.Response:
             raise ValueError("Unexpected message type.")
@@ -302,7 +301,9 @@ class RemotingMessenger:
         sock.sendall(dumps(b.getvalue()))
 
     def receive_tree(
-        self, data: Union[BinaryIO, socket.socket], before: Optional[Tree] = None
+        self,
+        data: Union[BinaryIO, socket.socket],
+        before: Optional[Tree] = None,
     ):
         receiver_context = self._context.new_receiver_context(BytesIO(cbor2.load(data)))
         return receiver_context.receive_any_tree(before)

{openrewrite_remote-0.13.3 → openrewrite_remote-0.13.5}/rewrite_remote/sender.py

@@ -21,6 +21,7 @@ import cbor2
 from cbor2 import CBOREncoder
 from rewrite import Tree, Markers, Marker, ParseErrorVisitor, Cursor, Style
 from rewrite.visitor import TreeVisitor
+from rewrite.java import JavaType
 
 from rewrite_remote import remote_utils
 from rewrite_remote.event import *
@@ -51,9 +52,7 @@ class OmniSender(Sender):
 
 
 class TreeSender(Protocol):
-    def send_node(
-            self, diff_event: DiffEvent, visitor: Callable[["TreeSender"], None]
-    ) -> None: ...
+    def send_node(self, diff_event: DiffEvent, visitor: Callable[["TreeSender"], None]) -> None: ...
 
     def send_value(self, diff_event: DiffEvent) -> None: ...
 
@@ -68,10 +67,10 @@ class SenderContext(Generic[T]):
     Registry: Dict[Type[Any], Callable[[], Sender]] = {}
 
     def __init__(
-            self,
-            sender: "TreeSender",
-            visitor: TreeVisitor = None,
-            before: Optional[Any] = None,
+        self,
+        sender: "TreeSender",
+        visitor: TreeVisitor = None,
+        before: Optional[Any] = None,
     ):
         self.sender = sender
         self.visitor = visitor
@@ -81,24 +80,20 @@ class SenderContext(Generic[T]):
         for entry_type, factory in self.Registry.items():
             # FIXME find better solution
             try:
-                if type_.__bases__.__contains__(entry_type) or issubclass(
-                        type_, entry_type
-                ):
+                if type_.__bases__.__contains__(entry_type) or issubclass(type_, entry_type):
                     return factory()
             except:
                 pass
         raise ValueError(f"Unsupported sender type: {type_}")
 
-    def fork(
-            self, visitor: TreeVisitor, before: Optional[Any] = None
-    ) -> "SenderContext[T]":
+    def fork(self, visitor: TreeVisitor, before: Optional[Any] = None) -> "SenderContext[T]":
         return SenderContext(self.sender, visitor, before)
 
     def visit(
-            self,
-            consumer: Callable[[V, "SenderContext"], None],
-            after: V,
-            before: Optional[V] = None,
+        self,
+        consumer: Callable[[V, "SenderContext"], None],
+        after: V,
+        before: Optional[V] = None,
     ) -> None:
         save_before = self.before
         self.before = before
@@ -112,10 +107,10 @@ class SenderContext(Generic[T]):
         OmniSender().send(after, before, self)
 
     def send_node(
-            self,
-            owner: A,
-            extractor: Callable[[A], Optional[V]],
-            details: Callable[[V, "SenderContext[T]"], None],
+        self,
+        owner: A,
+        extractor: Callable[[A], Optional[V]],
+        details: Callable[[V, "SenderContext[T]"], None],
     ) -> None:
         self.send_node_internal(
             extractor(owner),
@@ -123,9 +118,7 @@ class SenderContext(Generic[T]):
             details,
         )
 
-    def send_value(
-            self, owner: Any, value_extractor: Callable[[T], Optional[V]]
-    ) -> None:
+    def send_value(self, owner: Any, value_extractor: Callable[[T], Optional[V]]) -> None:
         after_value = value_extractor(owner)
         before_value = value_extractor(self.before) if self.before is not None else None
         self.send_value_internal(after_value, before_value)
@@ -135,9 +128,7 @@ class SenderContext(Generic[T]):
         before_value = value_extractor(self.before) if self.before is not None else None
         self.send_typed_value_internal(after_value, before_value)
 
-    def send_list_event(
-            self, after: Optional[List[V]], before: Optional[List[V]]
-    ) -> bool:
+    def send_list_event(self, after: Optional[List[V]], before: Optional[List[V]]) -> bool:
         if after == before:
             evt = DiffEvent(EventType.NoChange, None, None)
         elif before is None:
@@ -148,21 +139,17 @@ class SenderContext(Generic[T]):
             evt = DiffEvent(EventType.Update, None, len(after))
 
         self.sender.send_value(evt)
-        return (
-                evt.event_type != EventType.NoChange and evt.event_type != EventType.Delete
-        )
+        return evt.event_type != EventType.NoChange and evt.event_type != EventType.Delete
 
     def send_nodes(
-            self,
-            owner: A,
-            element_extractor: Callable[[A], List[V]],
-            details: Callable[[V, "SenderContext"], None],
-            id_function: Callable[[V], I],
+        self,
+        owner: A,
+        element_extractor: Callable[[A], List[V]],
+        details: Callable[[V, "SenderContext"], None],
+        id_function: Callable[[V], I],
     ) -> None:
         after_list = element_extractor(owner)
-        before_list = (
-            element_extractor(self.before) if self.before is not None else None
-        )
+        before_list = element_extractor(self.before) if self.before is not None else None
 
         if self.send_list_event(after_list, before_list):
             if before_list is not None:
@@ -174,14 +161,10 @@ class SenderContext(Generic[T]):
                 id_function,
                 lambda op, _1, _2, bv, av: {
                     Operation.Delete: lambda: self.send_node_internal(av, bv, details),
-                    Operation.NoChange: lambda: self.send_node_internal(
-                        av, bv, details
-                    ),
+                    Operation.NoChange: lambda: self.send_node_internal(av, bv, details),
                     Operation.Add: lambda: self.send_node_internal(av, bv, details),
                     Operation.Update: lambda: self.send_node_internal(av, bv, details),
-                    Operation.Move: lambda: NotImplementedError(
-                        "Unexpected operation: " + str(op)
-                    ),
+                    Operation.Move: lambda: NotImplementedError("Unexpected operation: " + str(op)),
                 }[op](),
             )
 
@@ -189,10 +172,10 @@ class SenderContext(Generic[T]):
                 self.sender.send_value(DiffEvent(EventType.EndList, None, None))
 
     def send_values(
-            self,
-            owner: T,
-            value_extractor: Callable[[T], List[V]],
-            id_function: Callable[[V], I],
+        self,
+        owner: T,
+        value_extractor: Callable[[T], List[V]],
+        id_function: Callable[[V], I],
     ) -> None:
         after_list = value_extractor(owner)
         before_list = value_extractor(self.before) if self.before is not None else None
@@ -210,9 +193,7 @@ class SenderContext(Generic[T]):
                     Operation.NoChange: lambda: self.send_value_internal(av, bv),
                     Operation.Add: lambda: self.send_value_internal(av, bv),
                     Operation.Update: lambda: self.send_value_internal(av, bv),
-                    Operation.Move: lambda: NotImplementedError(
-                        "Unexpected operation: " + str(op)
-                    ),
+                    Operation.Move: lambda: NotImplementedError("Unexpected operation: " + str(op)),
                 }[op](),
             )
 
@@ -220,10 +201,10 @@ class SenderContext(Generic[T]):
                 self.sender.send_value(DiffEvent(EventType.EndList, None, None))
 
     def send_typed_values(
-            self,
-            owner: T,
-            value_extractor: Callable[[T], List[V]],
-            id_function: Callable[[V], I],
+        self,
+        owner: T,
+        value_extractor: Callable[[T], List[V]],
+        id_function: Callable[[V], I],
     ) -> None:
         after_list = value_extractor(owner)
         before_list = value_extractor(self.before) if self.before is not None else None
@@ -241,9 +222,7 @@ class SenderContext(Generic[T]):
                     Operation.NoChange: lambda: self.send_typed_value_internal(av, bv),
                     Operation.Add: lambda: self.send_typed_value_internal(av, bv),
                     Operation.Update: lambda: self.send_typed_value_internal(av, bv),
-                    Operation.Move: lambda: NotImplementedError(
-                        "Unexpected operation: " + str(op)
-                    ),
+                    Operation.Move: lambda: NotImplementedError("Unexpected operation: " + str(op)),
                 }[op](),
             )
 
@@ -269,17 +248,15 @@ class SenderContext(Generic[T]):
         return isinstance(after, (Tree, Markers)) or isinstance(before, (Tree, Markers))
 
     def send_node_internal(
-            self,
-            after: Optional[V],
-            before: Optional[V],
-            details: Callable[[V, "SenderContext"], None],
+        self,
+        after: Optional[V],
+        before: Optional[V],
+        details: Callable[[V, "SenderContext"], None],
     ) -> None:
         if self.are_equal(after, before):
             evt = DiffEvent(EventType.NoChange, None, None)
         elif before is None:
-            concrete_type = (
-                to_java_type_name(type(after)) if after is not None else None
-            )
+            concrete_type = to_java_type_name(type(after)) if after is not None else None
             evt = DiffEvent(EventType.Add, concrete_type, None)
         elif after is None:
             evt = DiffEvent(EventType.Delete, None, None)
@@ -292,9 +269,7 @@ class SenderContext(Generic[T]):
         if self.before is not None and self.are_equal(after, before):
             evt = DiffEvent(EventType.NoChange, None, None)
         elif self.before is None or before is None:
-            concrete_type = (
-                to_java_type_name(type(after)) if isinstance(after, Marker) else None
-            )
+            concrete_type = to_java_type_name(type(after)) if isinstance(after, Marker) else None
             evt = DiffEvent(EventType.Add, concrete_type, after)
         elif after is None:
             evt = DiffEvent(EventType.Delete, None, None)
@@ -307,9 +282,7 @@ class SenderContext(Generic[T]):
         if self.before is not None and self.are_equal(after, before):
             evt = DiffEvent(EventType.NoChange, None, None)
         elif self.before is None or before is None:
-            concrete_type = (
-                to_java_type_name_from_value(after) if after is not None else None
-            )
+            concrete_type = to_java_type_name_from_value(after) if after is not None else None
             evt = DiffEvent(EventType.Add, concrete_type, after)
         elif after is None:
             evt = DiffEvent(EventType.Delete, None, None)
@@ -321,23 +294,21 @@ class SenderContext(Generic[T]):
 
 class SerializationContext:
     def __init__(
-            self,
-            remoting_context: "RemotingContext",
-            value_serializers: Optional[Dict[Type[Any], "ValueSerializer"]] = None,
+        self,
+        remoting_context: "RemotingContext",
+        value_serializers: Optional[Dict[Type[Any], "ValueSerializer"]] = None,
     ):
         self.remoting_context = remoting_context
         self.value_serializers = value_serializers or {}
 
-    def serialize(
-            self, value: Any, type_name: Optional[str], encoder: CBOREncoder
-    ) -> None:
+    def serialize(self, value: Any, type_name: Optional[str], encoder: CBOREncoder) -> None:
         if value is None:
             encoder.encode_none(None)
             return
 
         for type_cls, serializer in self.value_serializers.items():
             if isinstance(value, type_cls):
-                serializer.serialize(value, type_name, encoder, self)
+                serializer(value, type_name, encoder, self)
                 return
 
         DefaultValueSerializer().serialize(value, type_name, encoder, self)
@@ -352,7 +323,6 @@ class JsonSender(TreeSender):
         self._encoder = cbor2.CBOREncoder(self._stream)
 
     def send_node(self, diff_event, visitor) -> None:
-
         if diff_event.event_type in (EventType.Add, EventType.Update):
             self._encoder.encode(
                 [diff_event.event_type.value]
@@ -374,20 +344,16 @@ class JsonSender(TreeSender):
 
     def send_value(self, diff_event):
         if diff_event.event_type in (EventType.Add, EventType.Update):
-            self._encoder.encode_length(
-                4, 3 if diff_event.concrete_type is not None else 2
-            )
+            self._encoder.encode_length(4, 3 if diff_event.concrete_type is not None else 2)
             self._encoder.encode_int(diff_event.event_type.value)
             if diff_event.concrete_type is not None:
                 self._encoder.encode(diff_event.concrete_type)
-            self._context.serialize(
-                diff_event.msg, diff_event.concrete_type, self._encoder
-            )
+            self._context.serialize(diff_event.msg, diff_event.concrete_type, self._encoder)
         elif diff_event.event_type in (
-                EventType.Delete,
-                EventType.NoChange,
-                EventType.StartList,
-                EventType.EndList,
+            EventType.Delete,
+            EventType.NoChange,
+            EventType.StartList,
+            EventType.EndList,
         ):
             self._encoder.encode([diff_event.event_type.value])
         else:
@@ -408,16 +374,12 @@ ValueSerializer = Callable[[Any, Optional[str], CBOREncoder, SerializationContex
 
 
 def write_object_using_reflection(
-        value: Any,
-        type_name: Optional[str],
-        with_id: bool,
-        encoder: CBOREncoder,
-        context: SerializationContext,
+    value: Any,
+    type_name: Optional[str],
+    with_id: bool,
+    encoder: CBOREncoder,
+    context: SerializationContext,
 ) -> None:
-    if type(value).__qualname__ == "JavaType.Primitive":
-        # FIXME implement type attribution support
-        encoder.encode(["org.openrewrite.java.tree.JavaType$Primitive", 0])
-        return
     if with_id and (id := context.remoting_context.try_get_id(value)):
         encoder.encode_int(id)
         return
@@ -432,8 +394,7 @@ def write_object_using_reflection(
 
     for field in fields(value):
         if field.name[0] == "_" and (
-                not hasattr(field.type, "__origin__")
-                or field.type.__origin__ is not ClassVar
+            not hasattr(field.type, "__origin__") or field.type.__origin__ is not ClassVar
         ):
             encoder.encode_string(to_java_field_name(field))
             context.serialize(getattr(value, field.name), None, encoder)
@@ -445,11 +406,11 @@ class DefaultValueSerializer(ValueSerializer):
         return self.serialize(*args, **kwargs)
 
     def serialize(
-            self,
-            value: Any,
-            type_name: Optional[str],
-            encoder: CBOREncoder,
-            context: SerializationContext,
+        self,
+        value: Any,
+        type_name: Optional[str],
+        encoder: CBOREncoder,
+        context: SerializationContext,
     ) -> None:
         if isinstance(value, (int, float, str, bool, decimal.Decimal)):
             encoder.encode(value)
@@ -458,7 +419,16 @@ class DefaultValueSerializer(ValueSerializer):
         elif isinstance(value, UUID):
             encoder.encode(value.bytes)
         elif isinstance(value, Enum):
-            encoder.encode(value.value)
+            if isinstance(value, JavaType.Primitive):
+                # FIXME implement type attribution support
+                encoder.encode(
+                    [
+                        "org.openrewrite.java.tree.JavaType$Primitive",
+                        value.value,
+                    ]
+                )
+            else:
+                encoder.encode(value.value)
         elif isinstance(value, Path):
             encoder.encode(str(value))
         elif isinstance(value, (list, set, tuple)):
@@ -491,8 +461,8 @@ class DefaultValueSerializer(ValueSerializer):
                 encoder.encode_int(id)
                 for field in fields(value):
                     if field.name[0] == "_" and (
-                            not hasattr(field.type, "__origin__")
-                            or field.type.__origin__ is not ClassVar
+                        not hasattr(field.type, "__origin__")
+                        or field.type.__origin__ is not ClassVar
                     ):
                         encoder.encode_string(to_java_field_name(field))
                         context.serialize(getattr(value, field.name), None, encoder)
@@ -503,21 +473,19 @@ class DefaultValueSerializer(ValueSerializer):
         elif isinstance(value, complex):
             encoder.encode(str(value))
         else:
-            ValueSerializer.write_object_using_reflection(
-                value, type_name, False, encoder, context
-            )
+            write_object_using_reflection(value, type_name, False, encoder, context)
 
 
 def delegate_based_serializer(
-        delegate: Callable[[Any, Optional[str], CBOREncoder, SerializationContext], None]
+    delegate: Callable[[Any, Optional[str], CBOREncoder, SerializationContext], None],
 ) -> Type[ValueSerializer]:
     class DelegateBasedSerializer(ValueSerializer):
         def serialize(
-                self,
-                value: Any,
-                type_name: Optional[str],
-                encoder: CBOREncoder,
-                context: SerializationContext,
+            self,
+            value: Any,
+            type_name: Optional[str],
+            encoder: CBOREncoder,
+            context: SerializationContext,
         ) -> None:
             delegate(value, type_name, encoder, context)
 

{openrewrite_remote-0.13.3 → openrewrite_remote-0.13.5}/rewrite_remote/server.py

@@ -30,7 +30,9 @@ from rewrite.python.remote.receiver import PythonReceiver
 from rewrite.python.remote.sender import PythonSender
 
 from rewrite_remote.handlers.hello_world_handler import hello_world_handler
-from rewrite_remote.handlers.recipe_install_handler import recipe_install_handler
+from rewrite_remote.handlers.recipe_install_handler import (
+    recipe_install_handler,
+)
 from rewrite_remote.handlers.run_recipe_load_and_visitor_handler import (
     run_recipe_load_and_visitor_handler,
 )
@@ -86,9 +88,7 @@ class Server:
         self._path = path
         self.timeout = timeout
         self._remoting_context = RemotingContext()
-        self._remoting_context._recipe_factories["test"] = (
-            lambda recipe_options: Recipe()
-        )
+        self._remoting_context._recipe_factories["test"] = lambda recipe_options: Recipe()
         self._messenger = RemotingMessenger(
             self._remoting_context,
             {
@@ -132,9 +132,7 @@ class Server:
                     except socket.timeout:
                         current_time = time.time()
                         if current_time - last_activity_time >= self.timeout:
-                            print(
-                                "No new connections for 5 minutes, shutting down server."
-                            )
+                            print("No new connections for 5 minutes, shutting down server.")
                             break
 
     def handle_client(self, sock: socket.socket) -> None:
@@ -175,7 +173,10 @@ class Server:
             sock.close()
 
     def parse_python_source(
-        self, stream: BytesIO, sock: socket.socket, remoting_ctx: RemotingContext
+        self,
+        stream: BytesIO,
+        sock: socket.socket,
+        remoting_ctx: RemotingContext,
     ) -> None:
         remoting_ctx.reset()
         source = cbor2.load(stream)
@@ -199,7 +200,10 @@ class Server:
             sock.sendall(response_stream.getvalue())
 
     def parse_python_file(
-        self, stream: BytesIO, sock: socket.socket, remoting_ctx: RemotingContext
+        self,
+        stream: BytesIO,
+        sock: socket.socket,
+        remoting_ctx: RemotingContext,
     ) -> None:
         remoting_ctx.reset()
         path = cbor2.load(stream)
@@ -209,7 +213,14 @@ class Server:
             PythonParserBuilder()
             .build()
             .parse_inputs(
-                [ParserInput(Path(path), None, True, lambda: read_file_contents(path))],
+                [
+                    ParserInput(
+                        Path(path),
+                        None,
+                        True,
+                        lambda: read_file_contents(path),
+                    )
+                ],
                 None,
                 ctx,
             )