openrewrite-remote 0.13.2__py3-none-any.whl → 0.13.4__py3-none-any.whl

rewrite_remote/sender.py

@@ -2,39 +2,36 @@
 from __future__ import absolute_import
 
 import decimal
-from abc import ABC, abstractmethod
 from dataclasses import fields
 from pathlib import Path
 from typing import (
-    Any,
     Callable,
     ClassVar,
     Dict,
     Generic,
     List,
-    Optional,
     Protocol,
     TYPE_CHECKING,
     Type,
     TypeVar,
 )
 from uuid import UUID
+
 import cbor2
 from cbor2 import CBOREncoder
-
-from rewrite.visitor import TreeVisitor
 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 *
+from rewrite_remote.remote_utils import Operation
 from rewrite_remote.type_utils import (
     to_java_type_name,
     to_java_field_name,
     to_java_type_name_from_value,
 )
 
-from rewrite_remote import remote_utils
-from rewrite_remote.event import *
-from rewrite_remote.remote_utils import Operation
-
 if TYPE_CHECKING:
     from .remoting import RemotingContext
 
@@ -56,7 +53,7 @@ class OmniSender(Sender):
 
 class TreeSender(Protocol):
     def send_node(
-        self, diff_event: DiffEvent, visitor: Callable[["TreeSender"], None]
+            self, diff_event: DiffEvent, visitor: Callable[["TreeSender"], None]
     ) -> None: ...
 
     def send_value(self, diff_event: DiffEvent) -> None: ...
@@ -72,10 +69,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
@@ -86,7 +83,7 @@ class SenderContext(Generic[T]):
             # FIXME find better solution
             try:
                 if type_.__bases__.__contains__(entry_type) or issubclass(
-                    type_, entry_type
+                        type_, entry_type
                 ):
                     return factory()
             except:
@@ -94,15 +91,15 @@ class SenderContext(Generic[T]):
         raise ValueError(f"Unsupported sender type: {type_}")
 
     def fork(
-        self, visitor: TreeVisitor, before: Optional[Any] = None
+            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
@@ -116,10 +113,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),
@@ -128,7 +125,7 @@ class SenderContext(Generic[T]):
         )
 
     def send_value(
-        self, owner: Any, value_extractor: Callable[[T], Optional[V]]
+            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
@@ -140,7 +137,7 @@ class SenderContext(Generic[T]):
         self.send_typed_value_internal(after_value, before_value)
 
     def send_list_event(
-        self, after: Optional[List[V]], before: Optional[List[V]]
+            self, after: Optional[List[V]], before: Optional[List[V]]
     ) -> bool:
         if after == before:
             evt = DiffEvent(EventType.NoChange, None, None)
@@ -153,15 +150,15 @@ class SenderContext(Generic[T]):
 
         self.sender.send_value(evt)
         return (
-            evt.event_type != EventType.NoChange and evt.event_type != EventType.Delete
+                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 = (
@@ -193,10 +190,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
@@ -224,10 +221,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
@@ -273,10 +270,10 @@ 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)
@@ -325,15 +322,15 @@ 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
+            self, value: Any, type_name: Optional[str], encoder: CBOREncoder
     ) -> None:
         if value is None:
             encoder.encode_none(None)
@@ -388,10 +385,10 @@ class JsonSender(TreeSender):
                 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,60 +405,48 @@ INDEFINITE_ARRAY_START = b"\x9f"
 INDEFINITE_MAP_START = b"\xbf"
 BREAK_MARKER = b"\xff"
 
+ValueSerializer = Callable[[Any, Optional[str], CBOREncoder, SerializationContext], None]
 
-class ValueSerializer(ABC):
-
-    @abstractmethod
-    def serialize(
-        self,
-        value: Any,
-        type_name: Optional[str],
-        writer: CBOREncoder,
-        context: SerializationContext,
-    ) -> None:
-        pass
 
-    @staticmethod
-    def write_object_using_reflection(
+def write_object_using_reflection(
         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
-
-        encoder.write(INDEFINITE_MAP_START)
-        encoder.encode_string("@c")
-        encoder.encode_string(type_name or to_java_type_name(type(value)))
-        if with_id:
-            encoder.encode_string("@ref")
-            id = context.remoting_context.add(value)
-            encoder.encode_int(id)
-
-        for field in fields(value):
-            if field.name[0] == "_" and (
+) -> None:
+    if with_id and (id := context.remoting_context.try_get_id(value)):
+        encoder.encode_int(id)
+        return
+
+    encoder.write(INDEFINITE_MAP_START)
+    encoder.encode_string("@c")
+    encoder.encode_string(type_name or to_java_type_name(type(value)))
+    if with_id:
+        encoder.encode_string("@ref")
+        id = context.remoting_context.add(value)
+        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
-            ):
-                encoder.encode_string(to_java_field_name(field))
-                context.serialize(getattr(value, field.name), None, encoder)
-        encoder.write(BREAK_MARKER)
+        ):
+            encoder.encode_string(to_java_field_name(field))
+            context.serialize(getattr(value, field.name), None, encoder)
+    encoder.write(BREAK_MARKER)
 
 
 class DefaultValueSerializer(ValueSerializer):
+    def __call__(self, *args, **kwargs):
+        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)
@@ -470,7 +455,11 @@ 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)):
@@ -503,8 +492,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)
@@ -515,21 +504,21 @@ class DefaultValueSerializer(ValueSerializer):
         elif isinstance(value, complex):
             encoder.encode(str(value))
         else:
-            ValueSerializer.write_object_using_reflection(
+            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)
 

rewrite_remote/server.py

@@ -23,8 +23,7 @@ from rewrite import (
     Recipe,
 )
 from rewrite.java import J
-from rewrite.java.remote.receiver import JavaReceiver
-from rewrite.java.remote.sender import JavaSender
+from rewrite.java.remote import *
 from rewrite.python import Py
 from rewrite.python.parser import PythonParserBuilder
 from rewrite.python.remote.receiver import PythonReceiver

openrewrite_remote-0.13.2.dist-info/RECORD

@@ -1,14 +0,0 @@
-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.2.dist-info/METADATA,sha256=tFsowCEQH6-nSrm8SsD1GLGeRXq_cZvN82p_To920yU,386
-openrewrite_remote-0.13.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-openrewrite_remote-0.13.2.dist-info/entry_points.txt,sha256=SMukuF7TPjQr3IZIcH8f98-_QBCqYSbYXYrVv-5UzRI,69
-openrewrite_remote-0.13.2.dist-info/top_level.txt,sha256=ansTioSZ-62aH3F2L3d1Bua0pJF4GOtgQ1PpG-CzcP0,15
-openrewrite_remote-0.13.2.dist-info/RECORD,,