openrewrite-remote 0.11.0__py3-none-any.whl → 0.13.0__py3-none-any.whl

openrewrite_remote-0.13.0.dist-info/METADATA

@@ -0,0 +1,12 @@
+Metadata-Version: 2.1
+Name: openrewrite-remote
+Version: 0.13.0
+Summary: Remoting functionality for the OpenRewrite library.
+Author-email: "Moderne Inc." <support@moderne.io>
+License: Moderne, Inc. Commercial License
+Requires-Python: <4,>=3.9
+Requires-Dist: cbor2==5.6.5
+Requires-Dist: openrewrite
+Requires-Dist: pip>=24.3.1
+Requires-Dist: pypi-simple>=1.6.1
+Requires-Dist: toml>=0.10.2

openrewrite_remote-0.13.0.dist-info/RECORD

@@ -0,0 +1,14 @@
+rewrite_remote/__init__.py,sha256=uuLrPH--ewvE-5owXbNItXDfjCypMXQgsm-72hO_dtc,286
+rewrite_remote/client.py,sha256=95ZCAtVOngF0ZqqKnOsrweUeGKruf3UKGPXNGTrNyy0,1853
+rewrite_remote/event.py,sha256=texLJD1mcFkpBpiXAa-Rmip0Tgqm2OlBpRPHFZyWcBs,359
+rewrite_remote/receiver.py,sha256=U50jtbhmAVy361Vm5Bwd-amv19KcS8ltDRBOy2nC51E,18983
+rewrite_remote/remote_utils.py,sha256=wUo9WZoldgCLihFJGf6RaE1SufhDiEPCFlX74tcODVM,10552
+rewrite_remote/remoting.py,sha256=83Wvvj8tMCkUjOam0wWevWJeN-uHW1k9lGdoCsI0u0g,13690
+rewrite_remote/sender.py,sha256=pa68X6bjvCQW_25wuVtHq0ByjA6WgI1Rl3EbL8CcvX4,20003
+rewrite_remote/server.py,sha256=mKI9_PVvBuShoQmfqk0EhNA70CUJOtyzHB3xv-cNBYs,9413
+rewrite_remote/type_utils.py,sha256=oVrB0olWFSCqhmg2nTU2wrwiAU7kBCUscjwdHK7gf3Y,4219
+openrewrite_remote-0.13.0.dist-info/METADATA,sha256=ufTVYfANQruG21mIlcj0tg0TcrcOsR4R2cV7Cva-Gzk,386
+openrewrite_remote-0.13.0.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+openrewrite_remote-0.13.0.dist-info/entry_points.txt,sha256=SMukuF7TPjQr3IZIcH8f98-_QBCqYSbYXYrVv-5UzRI,69
+openrewrite_remote-0.13.0.dist-info/top_level.txt,sha256=ansTioSZ-62aH3F2L3d1Bua0pJF4GOtgQ1PpG-CzcP0,15
+openrewrite_remote-0.13.0.dist-info/RECORD,,

{openrewrite_remote-0.11.0.dist-info → openrewrite_remote-0.13.0.dist-info}/WHEEL

@@ -1,4 +1,5 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.1
+Generator: setuptools (75.6.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
+

openrewrite_remote-0.13.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+start_python_remoting = rewrite_remote.server:main

openrewrite_remote-0.13.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+rewrite_remote

rewrite_remote/__init__.py

@@ -0,0 +1,12 @@
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)
+from typing import TypeVar
+
+from .receiver import *
+from .sender import *
+from .remoting import *
+
+__all__ = [
+    name
+    for name in dir()
+    if not name.startswith("_") and not isinstance(globals()[name], TypeVar)
+]

rewrite_remote/client.py

@@ -0,0 +1,70 @@
+import socket
+import tempfile
+from pathlib import Path
+
+import rewrite.java.tree as j
+import rewrite.python.tree as py
+from rewrite import Markers
+from rewrite import random_id, Cursor, PrintOutputCapture
+from rewrite.java import Space, JavaType
+from rewrite.python import Py
+from rewrite.python.remote.receiver import PythonReceiver
+from rewrite.python.remote.sender import PythonSender
+
+from .receiver import ReceiverContext
+from .remoting import (
+    RemotingContext,
+    RemotePrinterFactory,
+)
+from .sender import SenderContext
+
+SenderContext.register(Py, lambda: PythonSender())
+ReceiverContext.register(Py, lambda: PythonReceiver())
+
+# Path to the Unix domain socket
+SOCKET_PATH = tempfile.gettempdir() + "/rewrite-java.sock"
+
+# Create a Unix domain socket
+client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+
+# Connect the socket to the path where the server is listening
+client.connect(("localhost", 65432))
+print(f"Connected to {SOCKET_PATH}")
+
+try:
+    remoting = RemotingContext()
+    remoting.connect(client)
+    RemotePrinterFactory(remoting.client).set_current()
+
+    literal = j.Literal(
+        random_id(),
+        Space.SINGLE_SPACE,
+        Markers.EMPTY,
+        True,
+        "True",
+        None,
+        JavaType.Primitive(),
+    )
+    assert_ = py.AssertStatement(
+        random_id(),
+        Space.EMPTY,
+        Markers.EMPTY,
+        [j.JRightPadded(literal, Space.EMPTY, Markers.EMPTY)],
+    )
+    cu = py.CompilationUnit(
+        random_id(),
+        Space.EMPTY,
+        Markers.EMPTY,
+        Path("/foo.py"),
+        None,
+        None,
+        False,
+        None,
+        [],
+        [j.JRightPadded(assert_, Space.EMPTY, Markers.EMPTY)],
+        Space.EMPTY,
+    )
+    printed = cu.print(Cursor(None, Cursor.ROOT_VALUE), PrintOutputCapture(0))
+    assert printed == "assert True"
+finally:
+    client.close()

{rewrite/remote → rewrite_remote}/event.py

@@ -1,6 +1,6 @@
 from dataclasses import dataclass
 from enum import Enum
-from typing import Optional
+from typing import Optional, Any
 
 
 class EventType(Enum):
@@ -17,4 +17,4 @@ class EventType(Enum):
 class DiffEvent:
     event_type: EventType
     concrete_type: Optional[str] = None
-    msg: Optional[any] = None
+    msg: Optional[Any] = None

{rewrite/remote → rewrite_remote}/receiver.py

@@ -1,100 +1,136 @@
+# type: ignore
+# Ignoring type checking for this file because there is too many errors for now
+
 from collections import OrderedDict
 from enum import Enum
 from pathlib import Path
-from typing import Protocol, TypeVar, Optional, Type, Dict, Callable, List, cast, Iterable, Any, Tuple, \
-    get_args, TYPE_CHECKING
+from typing import (
+    Protocol,
+    TypeVar,
+    Optional,
+    Type,
+    Dict,
+    Callable,
+    List,
+    cast,
+    Iterable,
+    Any,
+    Tuple,
+    get_args,
+    TYPE_CHECKING,
+)
 from uuid import UUID
 
 import cbor2
 from cbor2 import CBORDecoder
-from rewrite import Markers, Marker, ParseErrorVisitor
-
+from cbor2._decoder import major_decoders
+from rewrite import (
+    Markers,
+    Marker,
+    ParseError,
+    ParseErrorVisitor,
+    SearchResult,
+    UnknownJavaMarker,
+)
 from rewrite import Tree, TreeVisitor, Cursor, FileAttributes
-from rewrite.remote.event import DiffEvent, EventType
+
+from .event import DiffEvent, EventType
 from . import remote_utils, type_utils
 
 if TYPE_CHECKING:
     from .remoting import RemotingContext
 
-A = TypeVar('T')
-T = TypeVar('T', bound=Tree)
-V = TypeVar('V')
-I = TypeVar('I')
-P = TypeVar('P')
+A = TypeVar("A")
+T = TypeVar("T", bound=Tree)
+V = TypeVar("V")
+I = TypeVar("I")
+P = TypeVar("P")
 
 
 class Receiver(Protocol):
-    def fork(self, context: 'ReceiverContext') -> 'ReceiverContext':
-        ...
+    def fork(self, context: "ReceiverContext") -> "ReceiverContext": ...
 
-    def receive(self, before: Optional[T], ctx: 'ReceiverContext') -> object:
-        ...
+    def receive(self, before: Optional[T], ctx: "ReceiverContext") -> object: ...
 
 
 class OmniReceiver(Receiver):
-    def fork(self, ctx: 'ReceiverContext') -> 'ReceiverContext':
+    def fork(self, ctx: "ReceiverContext") -> "ReceiverContext":
         raise NotImplementedError("Cannot fork OmniReceiver")
 
-    def receive(self, before: Optional['Tree'], ctx: 'ReceiverContext') -> 'Tree':
+    def receive(self, before: Optional["Tree"], ctx: "ReceiverContext") -> "Tree":
         visitor = self.Visitor()
         return visitor.visit(before, ctx)
 
-    class Visitor(TreeVisitor[Tree, 'ReceiverContext']):
-        def visit(self, tree: Optional[Tree], ctx: 'ReceiverContext', parent: Optional[Cursor] = None) -> Optional[
-            Tree]:
-            self.cursor = Cursor(self.cursor, tree)
+    class Visitor(TreeVisitor[Tree, "ReceiverContext"]):  # type: ignore
+        def visit(
+            self,
+            tree: Optional[Tree],
+            ctx: "ReceiverContext",
+            parent: Optional[Cursor] = None,
+        ) -> Optional[Tree]:
+            self.cursor = Cursor(self.cursor, tree)  # type: ignore
             tree = ctx.polymorphic_receive_tree(tree)
             self.cursor = self.cursor.parent
             return tree
 
 
 class TreeReceiver(Protocol):
-    def receive_node(self) -> DiffEvent:
-        ...
+    def receive_node(self) -> DiffEvent: ...
 
-    def receive_value(self, expected_type: Type) -> DiffEvent:
-        ...
+    def receive_value(self, expected_type: Type[Any]) -> DiffEvent: ...
 
 
 class ReceiverFactory(Protocol):
-    def create(self, type_name: str, ctx: 'ReceiverContext') -> Tree:
-        ...
+    def create(self, type_name: Optional[str], ctx: "ReceiverContext") -> Tree: ...
 
 
 class DetailsReceiver(Protocol[T]):
-    def receive_details(self, before: Optional[T], type: Optional[Type[T]], ctx: 'ReceiverContext') -> T:
+    def receive_details(
+        self, before: Optional[T], type: Optional[Type[T]], ctx: "ReceiverContext"
+    ) -> T:
         pass
 
 
 class ReceiverContext:
-    Registry: Dict[Type, Callable[[], Receiver]] = OrderedDict()
-
-    def __init__(self, receiver: TreeReceiver, visitor: Optional[TreeVisitor] = None,
-                 factory: ReceiverFactory = None):
+    Registry: Dict[Type[Any], Callable[[], Receiver]] = OrderedDict()
+
+    def __init__(
+        self,
+        receiver: TreeReceiver,
+        visitor: Optional[TreeVisitor] = None,
+        factory: Optional[ReceiverFactory] = None,
+    ):
         self.receiver = receiver
         self.visitor = visitor
         self.factory = factory
 
-    def fork(self, visitor: TreeVisitor, factory: ReceiverFactory) -> 'ReceiverContext':
+    def fork(self, visitor: TreeVisitor, factory: ReceiverFactory) -> "ReceiverContext":
         return ReceiverContext(self.receiver, visitor, factory)
 
-    def receive_any_tree(self, before) -> T:
-        return OmniReceiver().receive(before, self)
+    def receive_any_tree(self, before: Optional[T]) -> Optional[T]:
+        return cast(Optional[T], OmniReceiver().receive(before, self))
 
-    def receive_tree(self, before: Optional[Tree], tree_type: Optional[str], ctx: 'ReceiverContext') -> Tree:
+    def receive_tree(
+        self, before: Optional[Tree], tree_type: Optional[str], ctx: "ReceiverContext"
+    ) -> Tree:
         if before:
             return before.accept(self.visitor, ctx)
         else:
-            return self.factory.create(tree_type, ctx)
+            if self.factory is not None:
+                return self.factory.create(tree_type, ctx)
+            raise ValueError("Factory is not defined")
 
     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,
-                diff_event.concrete_type, forked
+                diff_event.concrete_type,
+                forked,
             )
         elif diff_event.event_type == EventType.Delete:
             return None
@@ -108,8 +144,11 @@ class ReceiverContext:
                 return factory()
         raise ValueError(f"Unsupported receiver type: {type_name}")
 
-    def receive_node(self, before: Optional[A],
-                     details: Callable[[Optional[A], Optional[str], 'ReceiverContext'], A]) -> Optional[A]:
+    def receive_node(
+        self,
+        before: Optional[A],
+        details: Callable[[Optional[A], Optional[str], "ReceiverContext"], A],
+    ) -> Optional[A]:
         evt = self.receiver.receive_node()
         if evt.event_type == EventType.Delete:
             return None
@@ -119,24 +158,34 @@ class ReceiverContext:
             return details(before, evt.concrete_type, self)
         return before
 
-    def receive_markers(self, before: Optional[Markers], type: Optional[str], ctx: 'ReceiverContext') -> Markers:
-        id_ = self.receive_value(getattr(before, 'id', None), UUID)
-        after_markers = self.receive_values(getattr(before, 'markers', None), Marker)
+    def receive_markers(
+        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(
+            getattr(before, "markers", None), Marker
+        )
         if before:
             return before.with_id(id_).with_markers(after_markers)
         else:
             return Markers(id_, after_markers)
 
-    def receive_nodes(self, before: Optional[List[A]], details: Callable[[Optional[A], Optional[str], 'ReceiverContext'], A]) -> Optional[List[A]]:
+    def receive_nodes(
+        self,
+        before: Optional[List[A]],
+        details: Callable[[Optional[A], Optional[str], "ReceiverContext"], A],
+    ) -> Optional[List[A]]:
         return remote_utils.receive_nodes(before, details, self)
 
-    def receive_values(self, before: Optional[List[V]], type: Type) -> 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) -> Optional[V]:
+    def receive_value(self, before: Optional[V], type: Type[Any]) -> Optional[V]:
         return self.receive_value0(before, type)
 
-    def receive_value0(self, before: Optional[V], type: Type) -> Optional[V]:
+    def receive_value0(self, before: Optional[V], type: Type[Any]) -> Optional[V]:
         evt = self.receiver.receive_value(type)
         if evt.event_type in (EventType.Update, EventType.Add):
             return evt.msg
@@ -145,67 +194,136 @@ class ReceiverContext:
         return before
 
     @staticmethod
-    def register(type_: Type, receiver_factory: Callable[[], Receiver]):
+    def register(type_: Type[Any], receiver_factory: Callable[[], Receiver]) -> None:
         ReceiverContext.Registry[type_] = receiver_factory
 
 
 class ValueDeserializer(Protocol):
-    def deserialize(self, type_: Optional[Type], reader: CBORDecoder, context: 'DeserializationContext') -> Optional[Any]:
-        ...
+    def deserialize(
+        self,
+        type_: Optional[Type[Any]],
+        reader: CBORDecoder,
+        context: "DeserializationContext",
+    ) -> Optional[Any]: ...
 
 
 class DefaultValueDeserializer(ValueDeserializer):
-    def deserialize(self, expected_type: Optional[Type], reader: CBORDecoder, context: 'DeserializationContext') -> Any:
-        cbor_map = reader.decode_map()
-        error_message = "No deserializer found for: " + ", ".join(f"{k}: {v}" for k, v in cbor_map.items())
+    def deserialize(
+        self,
+        expected_type: Optional[Type[Any]],
+        reader: CBORDecoder,
+        context: "DeserializationContext",
+    ) -> Any:
+        cbor_map = reader.decode_map(subtype=None)
+        error_message = "No deserializer found for: " + ", ".join(
+            f"{k}: {v}" for k, v in cbor_map.items()
+        )
         raise NotImplementedError(error_message)
 
 
 class DeserializationContext:
     DefaultDeserializer = DefaultValueDeserializer()
 
-    def __init__(self, remoting_context: 'RemotingContext', value_deserializers: Optional[List[Tuple[Type, ValueDeserializer]]] = None):
+    value_deserializers: List[Tuple[Type, ValueDeserializer]]
+
+    def __init__(
+        self,
+        remoting_context: "RemotingContext",
+        value_deserializers: Optional[List[Tuple[Type, ValueDeserializer]]] = None,
+    ):
         self.remoting_context = remoting_context
         self.value_deserializers = value_deserializers or []
 
-    def deserialize(self, expected_type: Type, decoder: CBORDecoder) -> Any:
-        value = decoder.decode()
-        if value is None:
-            return None
-
+    def deserialize(self, expected_type: Type[Any], decoder: CBORDecoder) -> Any:
         if expected_type == UUID:
-            return UUID(bytes=value)
+            return UUID(bytes=decoder.decode())  # type: ignore
 
         if expected_type == str:
-            return value
+            return decoder.decode()
 
         if expected_type == bool:
-            return value
+            return decoder.decode()
 
         if expected_type == list:
-            return value
+            return decoder.decode()
 
         if expected_type == int:
-            return value
+            return decoder.decode()
 
         if expected_type == Path:
-            return Path(value)
+            return Path(decoder.decode())  # type: ignore
 
         if expected_type == float:
-            return value
+            return decoder.decode()
 
         if issubclass(expected_type, Enum):
-            return expected_type(value)
+            return expected_type(decoder.decode())
+
+        initial_byte = decoder.read(1)[0]
+        major_type = initial_byte >> 5
+        subtype = initial_byte & 31
+
+        # Object ID for Marker, JavaType, etc.
+        if major_type == 0:
+            obj_id = major_decoders[major_type](decoder, subtype)
+            return self.remoting_context.get_object(obj_id)
+
+        # arrays
+        elif major_type == 4:
+            pass
+
+        # objects
+        elif major_type == 5:
+            field_name = decoder.decode()
+            assert field_name == "@c"
+            concrete_type = decoder.decode()
+
+            if concrete_type == "org.openrewrite.marker.SearchResult":
+                field_name = decoder.decode()
+                if field_name == "description":
+                    desc = decoder.decode()
+                elif field_name == "id":
+                    id_ = UUID(bytes=decoder.decode())
+                field_name = decoder.decode()
+                if field_name == "description":
+                    desc = decoder.decode()
+                elif field_name == "id":
+                    id_ = UUID(bytes=decoder.decode())
+                return SearchResult(id_, desc)
+
+            for type, value_deserializer in self.value_deserializers:
+                pass
+
+            initial_byte = decoder.read(1)[0]
+            major_type = initial_byte >> 5
+            subtype = initial_byte & 31
+            while initial_byte != 0xFF:
+                field_name = decoder.decode_string(subtype)
+                field_value = decoder.decode()
+                initial_byte = decoder.read(1)[0]
+                major_type = initial_byte >> 5
+                subtype = initial_byte & 31
+            pass
+
+        else:
+            return major_decoders[major_type](decoder, subtype)
 
         state = decoder.peek_state()
 
-        if state in {cbor2.CborReaderState.BOOLEAN, cbor2.CborReaderState.UNSIGNED_INT,
-                     cbor2.CborReaderState.NEGATIVE_INT}:
+        if state in {
+            cbor2.CborReaderState.BOOLEAN,
+            cbor2.CborReaderState.UNSIGNED_INT,
+            cbor2.CborReaderState.NEGATIVE_INT,
+        }:
             result = decoder.read_int()
             obj = self.remoting_context.get_object(result)
             return obj if obj is not None else result
 
-        if state in {cbor2.CborReaderState.HALF_FLOAT, cbor2.CborReaderState.FLOAT, cbor2.CborReaderState.DOUBLE}:
+        if state in {
+            cbor2.CborReaderState.HALF_FLOAT,
+            cbor2.CborReaderState.FLOAT,
+            cbor2.CborReaderState.DOUBLE,
+        }:
             return decoder.read_double()
 
         if state == cbor2.CborReaderState.TEXT_STRING:
@@ -213,7 +331,11 @@ class DeserializationContext:
             if decoder.peek_state() == cbor2.CborReaderState.END_ARRAY:
                 return str_value
 
-            concrete_type = str_value if decoder.peek_state() != cbor2.CborReaderState.END_ARRAY else expected_type.__name__
+            concrete_type = (
+                str_value
+                if decoder.peek_state() != cbor2.CborReaderState.END_ARRAY
+                else expected_type.__name__
+            )
 
             if concrete_type == "org.openrewrite.FileAttributes":
                 map = decoder.read_cbor_map()
@@ -226,7 +348,7 @@ class DeserializationContext:
             if concrete_type == "java.lang.Integer":
                 return decoder.decode()
             if concrete_type == "java.lang.Character":
-                return decoder.decode()[0]
+                return decoder.decode()[0]  # type: ignore
             if concrete_type == "java.lang.Long":
                 return decoder.decode()
             if concrete_type == "java.lang.Double":
@@ -238,7 +360,9 @@ 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()
@@ -261,7 +385,10 @@ class DeserializationContext:
 
                 concrete_type = marker_map["@c"]
 
-                if concrete_type in {"org.openrewrite.marker.SearchResult", "Rewrite.Core.Marker.SearchResult"}:
+                if concrete_type in {
+                    "org.openrewrite.marker.SearchResult",
+                    "Rewrite.Core.Marker.SearchResult",
+                }:
                     desc = marker_map.get("description", None)
                     marker = SearchResult(UUID(bytes=marker_map["id"]), desc)
                 else:
@@ -280,7 +407,9 @@ class DeserializationContext:
             for type_, deserializer in self.value_deserializers:
                 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):
@@ -301,10 +430,19 @@ class JsonReceiver(TreeReceiver):
             concrete_type = None
 
             if event_type in {EventType.Add, EventType.Update}:
-                if event_type == EventType.Add 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 {EventType.Delete, EventType.NoChange, EventType.StartList, EventType.EndList}:
+            elif event_type not in {
+                EventType.Delete,
+                EventType.NoChange,
+                EventType.StartList,
+                EventType.EndList,
+            }:
                 raise NotImplementedError(event_type)
 
             if self.DEBUG:
@@ -322,14 +460,18 @@ class JsonReceiver(TreeReceiver):
         concrete_type = None
 
         if event_type in {EventType.Add, EventType.Update}:
-            if (bool(get_args(expected_type)) and
-                    issubclass(expected_type, (list, Iterable))):
+            if bool(expected_type) and issubclass(expected_type, (list, Iterable)):
                 # special case for list events
                 msg = self._decoder.decode()
             else:
                 msg = self._context.deserialize(expected_type, self._decoder)
 
-        elif event_type not in {EventType.Delete, EventType.NoChange, EventType.StartList, EventType.EndList}:
+        elif event_type not in {
+            EventType.Delete,
+            EventType.NoChange,
+            EventType.StartList,
+            EventType.EndList,
+        }:
             raise NotImplementedError(event_type)
 
         if length is None:
@@ -359,19 +501,34 @@ class ParseErrorReceiver(Receiver):
 
         def visit_parse_error(self, parse_error, ctx):
             parse_error = parse_error.with_id(ctx.receive_value(parse_error.id))
-            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_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_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_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_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_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_text(ctx.receive_value(parse_error.text))
             # parse_error = parse_error.with_erroneous(ctx.receive_tree(parse_error.erroneous))
             return parse_error
 
     class Factory(ReceiverFactory):
         def create(self, type_, ctx):
-            if type_ in ["rewrite.parser.ParseError", "org.openrewrite.tree.ParseError"]:
+            if type_ in [
+                "rewrite.parser.ParseError",
+                "org.openrewrite.tree.ParseError",
+            ]:
                 return ParseError(
                     ctx.receive_value(None),
                     ctx.receive_node(None, ctx.receive_markers),
@@ -381,6 +538,6 @@ class ParseErrorReceiver(Receiver):
                     ctx.receive_value(None),
                     ctx.receive_value(None),
                     ctx.receive_value(None),
-                    None  # ctx.receive_tree(None)
+                    None,  # ctx.receive_tree(None)
                 )
             raise NotImplementedError("No factory method for type: " + type_)