openrewrite-remote 0.2.0__tar.gz

openrewrite_remote-0.2.0/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.1
+Name: openrewrite-remote
+Version: 0.2.0
+Summary: Remoting functionality for the OpenRewrite library.
+License: Apache-2.0
+Author: Moderne Inc.
+Author-email: support@moderne.io
+Requires-Python: >=3.9
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Requires-Dist: cbor2 (>=5.6.4,<6.0.0)
+Requires-Dist: openrewrite

openrewrite_remote-0.2.0/pyproject.toml

@@ -0,0 +1,37 @@
+[tool.poetry]
+name = "openrewrite-remote"
+version = "0.2.0"  # This will be replaced by the GitHub Actions workflow
+description = "Remoting functionality for the OpenRewrite library."
+authors = ["Moderne Inc. <support@moderne.io>"]
+license = "Apache-2.0"
+packages = [
+    { include = "rewrite" }
+]
+
+[tool.poetry.dependencies]
+python = ">=3.9"
+cbor2 = "^5.6.4"
+openrewrite = "*"
+#rewrite = { path = "../../../../openrewrite/rewrite-python/rewrite", develop = true }
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.3.2"
+mypy = "^1.11.1"
+poethepoet = "^0.27.0"
+
+[tool.mypy]
+python_version = "3.9"
+ignore_missing_imports = true
+strict = true
+
+warn_unused_ignores = true
+warn_return_any = true
+warn_unreachable = true
+
+[tool.poe.tasks]
+check-types = "mypy src"
+test = "pytest"
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"

openrewrite_remote-0.2.0/rewrite/remote/__init__.py

@@ -0,0 +1,7 @@
+__path__ = __import__('pkgutil').extend_path(__path__, __name__)
+
+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)]

openrewrite_remote-0.2.0/rewrite/remote/client.py

@@ -0,0 +1,40 @@
+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.python import Py
+from rewrite.java import Space, JavaType
+
+from rewrite import random_id, Cursor, PrintOutputCapture
+from rewrite.remote import RemotingContext, RemotePrinterFactory, SenderContext, ReceiverContext
+from rewrite.remote.python.receiver import PythonReceiver
+from rewrite.remote.python.sender import PythonSender
+
+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()

openrewrite_remote-0.2.0/rewrite/remote/event.py

@@ -0,0 +1,20 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import Optional
+
+
+class EventType(Enum):
+    NoChange = 0
+    Update = 1
+    Add = 2
+    Delete = 3
+    Move = 4
+    StartList = 5
+    EndList = 6
+
+
+@dataclass(frozen=True)
+class DiffEvent:
+    event_type: EventType
+    concrete_type: Optional[str] = None
+    msg: Optional[any] = None

openrewrite_remote-0.2.0/rewrite/remote/java/extensions.py

@@ -0,0 +1,176 @@
+from functools import lru_cache
+from operator import attrgetter
+from typing import Type, Callable, TypeVar, Optional
+
+from rewrite.java import *
+from rewrite.remote import SenderContext, ReceiverContext
+
+T = TypeVar('T')
+
+def receive_container(container: Optional[JContainer[T]], _: Optional[str], ctx: ReceiverContext) -> JContainer[T]:
+    if container is not None:
+        container = container.with_before(ctx.receive_node(container.before, receive_space))
+        container = container.padding.with_elements(ctx.receive_nodes(container.padding.elements, receive_right_padded_tree))
+        container = container.with_markers(ctx.receive_node(container.markers, ctx.receive_markers))
+    else:
+        container = JContainer(
+            ctx.receive_node(None, receive_space),
+            ctx.receive_nodes(None, receive_right_padded_tree),
+            ctx.receive_node(None, ctx.receive_markers)
+        )
+    return container
+
+
+def send_container(container: JContainer[T], ctx: SenderContext):
+    ctx.send_node(container, attrgetter('before'), send_space)
+    ctx.send_nodes(container, attrgetter('padding.elements'), send_right_padded, lambda t: t.element.id)
+    ctx.send_node(container, attrgetter('markers'), ctx.send_markers)
+
+
+def send_left_padded(left_padded: JLeftPadded[T], ctx: SenderContext):
+    ctx.send_node(left_padded, attrgetter('before'), send_space)
+    if isinstance(left_padded.element, (J, Space)):
+        ctx.send_node(left_padded, attrgetter('element'), ctx.send_tree)
+    else:
+        ctx.send_value(left_padded, attrgetter('element'))
+    ctx.send_node(left_padded, attrgetter('markers'), ctx.send_markers)
+
+
+def send_right_padded(right_padded: JRightPadded[T], ctx: SenderContext):
+    if isinstance(right_padded.element, J):
+        ctx.send_node(right_padded, attrgetter('element'), ctx.send_tree)
+    elif isinstance(right_padded.element, Space):
+        ctx.send_node(right_padded, attrgetter('element'), send_space)
+    else:
+        ctx.send_value(right_padded, attrgetter('element'))
+    ctx.send_node(right_padded, attrgetter('after'), send_space)
+    ctx.send_node(right_padded, attrgetter('markers'), ctx.send_markers)
+
+
+def receive_space(space: Optional[Space], _: Optional[str], ctx: ReceiverContext) -> Space:
+    if space is not None:
+        space = space.with_comments(ctx.receive_nodes(space.comments, receive_comment))
+        space = space.with_whitespace(ctx.receive_value(space.whitespace, str))
+    else:
+        space = Space(
+            ctx.receive_values(None),
+            ctx.receive_value(None, str)
+        )
+
+    return space
+
+
+def receive_comment(comment: Optional[Comment], _: Optional[str], ctx: ReceiverContext) -> Comment:
+    if comment:
+        comment = comment.with_multiline(ctx.receive_value(comment.multiline, bool))
+        comment = comment.with_text(ctx.receive_value(comment.text, str))
+        comment = comment.with_suffix(ctx.receive_value(comment.suffix, str))
+        comment = comment.with_markers(ctx.receive_node(comment.markers, ctx.receive_markers))
+    else:
+        comment = TextComment(
+            ctx.receive_value(None, bool),
+            ctx.receive_value(None, str),
+            ctx.receive_value(None, str),
+            ctx.receive_node(None, ctx.receive_markers)
+        )
+    return comment
+
+
+def send_space(space: Space, ctx: SenderContext):
+    ctx.send_nodes(space, attrgetter('comments'), send_comment, lambda x: x)
+    ctx.send_value(space, attrgetter('whitespace'))
+
+
+def send_comment(comment: Comment, ctx: SenderContext):
+    ctx.send_value(comment, attrgetter('multiline'))
+    ctx.send_value(comment, attrgetter('text'))
+    ctx.send_value(comment, attrgetter('suffix'))
+    ctx.send_node(comment, attrgetter('markers'), ctx.send_markers)
+
+
+@lru_cache(maxsize=10)
+def left_padded_value_receiver(type_: Type) -> Callable[[Optional[JLeftPadded[T]], Optional[str], ReceiverContext], JLeftPadded[T]]:
+    def receiver(left_padded: Optional[JLeftPadded[T]], _: Optional[str], ctx: ReceiverContext) -> JLeftPadded[T]:
+        if left_padded is not None:
+            left_padded = left_padded.with_before(ctx.receive_node(left_padded.before, receive_space))
+            left_padded = left_padded.with_element(ctx.receive_value(left_padded.element, type_))
+            left_padded = left_padded.with_markers(ctx.receive_node(left_padded.markers, ctx.receive_markers))
+        else:
+            left_padded = JLeftPadded(
+                ctx.receive_node(None, receive_space),
+                ctx.receive_value(None, type_),
+                ctx.receive_node(None, ctx.receive_markers)
+            )
+        return left_padded
+    return receiver
+
+
+@lru_cache(maxsize=10)
+def left_padded_node_receiver(type_: Type) -> Callable[[Optional[JLeftPadded[T]], Optional[str], ReceiverContext], JLeftPadded[T]]:
+    if type_ is Space:
+        def space_receiver(left_padded: Optional[JLeftPadded[T]], _: Optional[str], ctx: ReceiverContext) -> JLeftPadded[T]:
+            if left_padded is not None:
+                left_padded = left_padded.with_before(ctx.receive_node(left_padded.before, receive_space))
+                left_padded = left_padded.with_element(ctx.receive_node(left_padded.element, receive_space))
+                left_padded = left_padded.with_markers(ctx.receive_node(left_padded.markers, ctx.receive_markers))
+            else:
+                left_padded = JLeftPadded(
+                    ctx.receive_node(None, receive_space),
+                    ctx.receive_node(None, receive_space),
+                    ctx.receive_node(None, ctx.receive_markers)
+                )
+            return left_padded
+        return space_receiver
+    else:
+        raise ValueError("Only Space is supported")
+
+
+def receive_left_padded_tree(left_padded: Optional[JLeftPadded[T]], _: Optional[str], ctx: ReceiverContext) -> JLeftPadded[T]:
+    if left_padded is not None:
+        left_padded = left_padded.with_before(ctx.receive_node(left_padded.before, receive_space))
+        left_padded = left_padded.with_element(ctx.receive_node(left_padded.element, ctx.receive_tree))
+        left_padded = left_padded.with_markers(ctx.receive_node(left_padded.markers, ctx.receive_markers))
+    else:
+        left_padded = JLeftPadded(
+            ctx.receive_node(None, receive_space),
+            ctx.receive_node(None, ctx.receive_tree),
+            ctx.receive_node(None, ctx.receive_markers)
+        )
+    return left_padded
+
+
+@lru_cache(maxsize=10)
+def right_padded_value_receiver(type_: Type) -> Callable[[Optional[JRightPadded[T]], Optional[str], ReceiverContext], JRightPadded[T]]:
+    def receiver(right_padded: Optional[JRightPadded[T]], _: Optional[str], ctx: ReceiverContext) -> JRightPadded[T]:
+        if right_padded is not None:
+            right_padded = right_padded.with_element(ctx.receive_value(right_padded.element, type_))
+            right_padded = right_padded.with_after(ctx.receive_node(right_padded.after, receive_space))
+            right_padded = right_padded.with_markers(ctx.receive_node(right_padded.markers, ctx.receive_markers))
+        else:
+            right_padded = JRightPadded(
+                ctx.receive_value(None, type_),
+                ctx.receive_node(None, receive_space),
+                ctx.receive_node(None, ctx.receive_markers)
+            )
+        return right_padded
+    return receiver
+
+
+@lru_cache(maxsize=10)
+def right_padded_node_receiver(type_: Type) -> Callable[[Optional[JRightPadded[T]], Optional[str], ReceiverContext], JRightPadded[T]]:
+    raise ValueError("Not implemented")
+
+
+def receive_right_padded_tree(right_padded: Optional[JRightPadded[T]], _: Optional[str],
+                              ctx: ReceiverContext) -> JRightPadded[T]:
+    if right_padded is not None:
+        right_padded = right_padded.with_element(ctx.receive_node(right_padded.element, ctx.receive_tree))
+        right_padded = right_padded.with_after(ctx.receive_node(right_padded.after, receive_space))
+        right_padded = right_padded.with_markers(ctx.receive_node(right_padded.markers, ctx.receive_markers))
+    else:
+        right_padded = JRightPadded(
+            ctx.receive_node(None, ctx.receive_tree),
+            ctx.receive_node(None, receive_space),
+            ctx.receive_node(None, ctx.receive_markers)
+        )
+    return right_padded