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

{openrewrite_remote-0.13.2.dist-info → openrewrite_remote-0.13.4.dist-info}/METADATA

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

openrewrite_remote-0.13.4.dist-info/RECORD

@@ -0,0 +1,23 @@
+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=9oIdupOcV9z6eY-c2uFL1yfujbTQTgbXgTPG9Qx_ipc,20008
+rewrite_remote/remote_utils.py,sha256=wUo9WZoldgCLihFJGf6RaE1SufhDiEPCFlX74tcODVM,10552
+rewrite_remote/remoting.py,sha256=s0qVJlKTKhLZw8-9CJB1dJ4sPeKVkwIldI2WYEGULHY,13365
+rewrite_remote/sender.py,sha256=z42hmAIXai_dazQ-DhMwv_fDSi0AA2orUT2juWX2UJg,20056
+rewrite_remote/server.py,sha256=LDk4mUs33DX1s8HMCh3rC5lkpN8luyDu1CLeDQXczlY,9343
+rewrite_remote/type_utils.py,sha256=oVrB0olWFSCqhmg2nTU2wrwiAU7kBCUscjwdHK7gf3Y,4219
+rewrite_remote/handlers/__init__.py,sha256=ED6jHcYiuYpr_0vjGz0zx2lrrmJT9sDJCzIljoDfmlM,65
+rewrite_remote/handlers/handler_helpers.py,sha256=CIAXtlzrsE-z5RmzlXBZihT1rfrRLHFttq8Ni_8AH9U,516
+rewrite_remote/handlers/hello_world_handler.py,sha256=NQScHfCJKofdImBgELL8tXtG_KnVyXj683C3Ae7xcKU,1298
+rewrite_remote/handlers/list_projects_handler.py,sha256=ukkCST7whpCxQ0omCWWw9W27Su3rFSnnEIhAS6T4iOU,2007
+rewrite_remote/handlers/project_helper.py,sha256=_zGzniyEgmBB4k14Oy4Sm7B3Lt1MoXKQLOJxofEELGI,7130
+rewrite_remote/handlers/pypi_manager.py,sha256=z4JJarLkNRztQaSLHCh5GViag7ce7E36ARBDqJLQREc,10269
+rewrite_remote/handlers/recipe_install_handler.py,sha256=D6n5d84pS-HBWNiND-qZt-SfB33uFHV0ntZf2ZQ1Imo,4942
+rewrite_remote/handlers/run_recipe_load_and_visitor_handler.py,sha256=Pppn90g2z0z3U9m4_3a3X9Wu0Qh_pvkhoxWgadjAHRs,4146
+rewrite_remote/handlers/types.py,sha256=5TK_oFp-7iy1iACWisuQJsa_WHTsqcPrV9nQTZ-_xgo,518
+openrewrite_remote-0.13.4.dist-info/METADATA,sha256=jL-ze_dwxBxu6JQADFZO2s_QJLF7IxPJwEQdU1pTLaI,386
+openrewrite_remote-0.13.4.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+openrewrite_remote-0.13.4.dist-info/entry_points.txt,sha256=SMukuF7TPjQr3IZIcH8f98-_QBCqYSbYXYrVv-5UzRI,69
+openrewrite_remote-0.13.4.dist-info/top_level.txt,sha256=ansTioSZ-62aH3F2L3d1Bua0pJF4GOtgQ1PpG-CzcP0,15
+openrewrite_remote-0.13.4.dist-info/RECORD,,

rewrite_remote/handlers/__init__.py

@@ -0,0 +1 @@
+__path__ = __import__("pkgutil").extend_path(__path__, __name__)

rewrite_remote/handlers/handler_helpers.py

@@ -0,0 +1,16 @@
+import logging
+import socket
+import cbor2
+
+from rewrite_remote.remote_utils import COMMAND_END
+from rewrite_remote import RemotingMessageType, OK, ERROR
+
+
+def respond_with_error(message: str, sock: socket.socket) -> None:
+    logging.error(f"[Server] Error: {message}")
+    encoded_message = b""
+    encoded_message += cbor2.dumps(RemotingMessageType.Response)
+    encoded_message += cbor2.dumps(ERROR)
+    encoded_message += cbor2.dumps(message)
+    encoded_message += COMMAND_END
+    sock.sendall(encoded_message)

rewrite_remote/handlers/hello_world_handler.py

@@ -0,0 +1,40 @@
+from io import BytesIO
+import traceback
+import socket
+
+import cbor2
+
+from rewrite_remote import RemotingContext, RemotingMessageType, OK, ERROR
+
+
+def hello_world_handler(
+    stream: BytesIO, sock: socket.socket, remoting_ctx: RemotingContext
+) -> None:
+    """
+    A simple handler that responds to hello world command and response with string world
+    """
+    try:
+        remoting_ctx.reset()
+        request = cbor2.load(stream)
+
+        if request != "hello":
+            raise ValueError(f"Unexpected request: {request}")
+        else:
+            print("Did not receive 'hello' ")
+
+        # Prepare a response
+        response_stream = BytesIO()
+        cbor2.dump(RemotingMessageType.Response, response_stream)
+        cbor2.dump(OK, response_stream)
+        cbor2.dump("world", response_stream)
+        sock.sendall(response_stream.getvalue())
+
+    except (socket.error, cbor2.CBORDecodeError) as e:
+        print(f"Error in hello handler: {e}")
+        traceback.print_exc()
+        # Send an error response if something goes wrong
+        response_stream = BytesIO()
+        cbor2.dump(RemotingMessageType.Response, response_stream)
+        cbor2.dump(ERROR, response_stream)
+        cbor2.dump(traceback.format_exc(), response_stream)
+        sock.sendall(response_stream.getvalue())

rewrite_remote/handlers/list_projects_handler.py

@@ -0,0 +1,66 @@
+import logging
+import socket
+from io import BytesIO
+from typing import List
+from cbor2 import dumps, CBORDecoder
+
+from rewrite_remote.handlers.project_helper import list_projects
+from rewrite_remote.remote_utils import COMMAND_END
+from rewrite_remote.remoting import OK, RemotingContext, RemotingMessageType
+from rewrite_remote.handlers.handler_helpers import respond_with_error
+
+
+# Main command handler with the specified signature
+def list_projects_handler(
+    stream: BytesIO, sock: socket.socket, remoting_ctx: RemotingContext
+) -> None:
+    remoting_ctx.reset()
+
+    # 1. Read input from stream
+    try:
+        data = stream.read()
+        decoder = CBORDecoder(BytesIO(data))
+        root_project_file = str(decoder.decode())
+    except Exception as e:  # pylint: disable=broad-except
+        respond_with_error(f"Failed to decode arguments: {e}", sock)
+        return
+
+    if root_project_file == "" or root_project_file is None:
+        respond_with_error("root_project_file is required", sock)
+        return
+
+    # 2. Log the request
+    logging.info(
+        f"""[Server] Handling install-recipe request: {{
+        root_project_file: {root_project_file},
+    }}"""
+    )
+
+    # 3. Find projects
+    projects = list_projects(root_project_file)
+
+    # 4. Log the result
+    logging.info("[Server] Found %d project(s)", len(projects))
+    for project in projects:
+        logging.info(
+            " %s root at %s using %s",
+            project.project_name,
+            project.project_root,
+            project.project_tool,
+        )
+
+    # 5. Write response to stream
+    response: List[str] = []
+
+    for project in projects:
+        response.append(project.project_root)
+
+    # Encode the response using CBOR
+    encoded_response = b""
+    encoded_response += dumps(RemotingMessageType.Response)
+    encoded_response += dumps(OK)
+    encoded_response += dumps(response)
+    encoded_response += COMMAND_END
+    sock.sendall(encoded_response)
+
+    logging.info("[Server] Request completed.")

rewrite_remote/handlers/project_helper.py

@@ -0,0 +1,196 @@
+import os
+import glob
+import toml
+from typing import Any
+
+from dataclasses import dataclass
+
+
+@dataclass
+class Project:
+    project_name: str
+    project_root: str
+    project_tool: str
+
+
+def list_projects(pyproject_path: str) -> list[Project]:
+    """
+    Parses the pyproject.toml file to identify sub projects in a monorepo and returns a list of Projects.
+    """
+    if not os.path.isfile(pyproject_path):
+        raise FileNotFoundError(f"{pyproject_path} does not exist.")
+
+    # Load and parse the pyproject.toml file
+    with open(pyproject_path, "r") as file:
+        data = toml.load(file)
+
+    sub_projects: list[Project] = []
+
+    if is_poetry_project(data):
+        sub_projects = find_sub_projects_in_poetry(data, pyproject_path)
+    elif is_hatch_project(data):
+        sub_projects = find_sub_projects_in_hatch(data, pyproject_path)
+    elif is_uv_project(data):
+        sub_projects = find_sub_projects_in_uv_sources(data, pyproject_path)
+    else:
+        sub_projects = find_sub_projects_in_project_dependencies(data, pyproject_path)
+
+    return sub_projects
+
+
+def is_poetry_project(tomlData: dict[str, Any]) -> bool:
+    return (
+        "tool" in tomlData
+        and "poetry" in tomlData["tool"]
+        and "dependencies" in tomlData["tool"]["poetry"]
+    )
+
+
+def is_hatch_project(tomlData: dict[str, Any]) -> bool:
+    return "tool" in tomlData and "hatch" in tomlData["tool"]
+
+
+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]:
+    """
+    Finds sub projects in a poetry project by looking for dependencies with a "path" key:
+        [tool.poetry.dependencies]
+        python = "^3.9"
+        service-a = { path = "./services/service-a" }
+        service-b = { path = "./services/service-b" }
+        shared-lib = { path = "./shared-libraries/shared-lib" }
+    """
+    subProjects: list[Project] = []
+    for dep_name, dep_value in tomlData["tool"]["poetry"]["dependencies"].items():
+        if isinstance(dep_value, dict) and "path" in dep_value:
+            subProjects.append(
+                Project(
+                    project_name=dep_name,
+                    project_root=get_absolute_path(toml_path, dep_value["path"]),
+                    project_tool="poetry",
+                )
+            )
+    return subProjects
+
+
+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]
+        service-a = { path = "./services/service-a" }
+        service-b = { path = "./services/service-b" }
+    """
+    subProjects: list[Project] = []
+    hatch_envs = tomlData["tool"]["hatch"].get("envs", {})
+    for env_name, env_data in hatch_envs.items():
+        if isinstance(env_data, dict) and "dependencies" in env_data:
+            dependencies = env_data["dependencies"]
+            if isinstance(dependencies, dict):
+                for dep_name, dep_value in dependencies.items():
+                    if isinstance(dep_value, dict) and "path" in dep_value:
+                        subProjects.append(
+                            Project(
+                                project_name=dep_name,
+                                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]:
+    """
+    Finds sub projects in a uv project by looking at sources and workspace:
+    [tool.uv.sources]
+    service-a = { path = "./services/service-a" }
+    service-b = { path = "./services/service-b" }
+
+    [tool.uv.workspace]
+    members = ["packages/*"]
+    exclude = ["packages/excluded/*"]
+    """
+    subProjects: list[Project] = []
+    uv_sources = tomlData["tool"]["uv"].get("sources", {})
+    uv_workspace = tomlData["tool"]["uv"].get("workspace", {})
+    for source_name, source_data in uv_sources.items():
+        if isinstance(source_data, dict) and "path" in source_data:
+            subProjects.append(
+                Project(
+                    project_name=source_name,
+                    project_root=get_absolute_path(toml_path, source_data["path"]),
+                    project_tool="uv.sources",
+                )
+            )
+    if isinstance(uv_workspace, dict) and "members" in uv_workspace:
+        excluded_directories = []
+        exclude_globs = uv_workspace.get("exclude", [])
+        for exclude_glob in exclude_globs:
+            excluded_directories.extend(
+                glob.glob(
+                    os.path.join(os.path.dirname(toml_path), exclude_glob),
+                    recursive=True,
+                )
+            )
+
+        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
+            )
+
+            for directory in directories:
+                if (
+                    os.path.exists(os.path.join(directory, "pyproject.toml"))
+                    and directory not in excluded_directories
+                ):
+                    subProjects.append(
+                        Project(
+                            project_name=os.path.basename(directory),
+                            project_root=directory,
+                            project_tool="uv.workspace",
+                        )
+                    )
+
+    return subProjects
+
+
+def find_sub_projects_in_project_dependencies(
+    tomlData: dict[str, Any], toml_path: str
+) -> list[Project]:
+    """
+    Finds sub projects in a project dependencies by looking for dependencies with
+    the @ file:///${PROJECT_ROOT}//${SUBPROJECT_PATH} format:
+        [project]
+        dependencies = [
+            "service-a @ file:///${PROJECT_ROOT}//services/service-a",
+            "service-b @ file:///${PROJECT_ROOT}//services/service-b"
+        ]
+    """
+    subProjects: list[Project] = []
+    for dep in tomlData["project"]["dependencies"]:
+        if isinstance(dep, str) and dep.find("@ file:///${PROJECT_ROOT}//"):
+            rel_path = dep.split("@ file:///${PROJECT_ROOT}//")[1]
+            subProjects.append(
+                Project(
+                    project_name=os.path.basename(dep),
+                    project_root=get_absolute_path(toml_path, rel_path),
+                    project_tool="project.dependencies",
+                )
+            )
+    return subProjects
+
+
+def get_absolute_path(path_to_root_toml: str, path_to_sub_project: str) -> str:
+    path_to_root = os.path.dirname(path_to_root_toml)
+    return os.path.abspath(os.path.join(path_to_root, path_to_sub_project))

rewrite_remote/handlers/pypi_manager.py

@@ -0,0 +1,300 @@
+import os
+import sys
+import subprocess
+import importlib
+import inspect
+import pkgutil
+from dataclasses import dataclass
+
+from pypi_simple import PyPISimple
+from packaging.version import parse as parse_version
+from packaging.specifiers import SpecifierSet
+from rewrite import Recipe
+
+from typing import Optional, Dict, List, Any
+
+DEFAULT_PYPI_URL = "https://pypi.org/simple"
+DEFAULT_RECIPE_INSTALL_LOCATION = os.path.join(".", ".local_python_recipes")
+
+# Ensure that the directory is on sys.path
+if DEFAULT_RECIPE_INSTALL_LOCATION not in sys.path:
+    sys.path.insert(0, DEFAULT_RECIPE_INSTALL_LOCATION)
+
+
+class Source:
+    def __init__(
+        self,
+        source: str,
+        username: Optional[str] = None,
+        password: Optional[str] = None,
+        token: Optional[str] = None,
+    ):
+        self.source = source
+        self.username = username
+        self.password = password
+        self.token = token
+
+
+@dataclass
+class Option:
+    name: str
+    type: str
+    required: bool
+
+
+@dataclass
+class InstalledRecipe:
+    name: str
+    source: str
+    options: List[Option]
+
+
+class InstalledPackage:
+    def __init__(
+        self, name: str, version: str, source: str, recipes: List[InstalledRecipe]
+    ):
+        self.name = name
+        self.version = version
+        self.source = source
+        self.recipes = recipes
+
+
+class PyPiManager:
+    @staticmethod
+    def find_valid_source(
+        package_name: str,
+        requestedVersion: str,
+        package_sources: List[Source],
+        include_default_source: bool = True,
+    ) -> Optional[Source]:
+        """
+        Finds a valid source for the specified package using `pip show` with `--index-url`.
+        """
+        package_identifier = (
+            f"{package_name}=={requestedVersion}" if requestedVersion else package_name
+        )
+        if include_default_source and not any(
+            source.source == DEFAULT_PYPI_URL for source in package_sources
+        ):
+            package_sources.append(Source(source=DEFAULT_PYPI_URL))
+
+        for source in package_sources:
+            try:
+                authenticated_url = PyPiManager._get_authenticated_url(source)
+                result = PyPiManager._package_exists_in_registry(
+                    authenticated_url,
+                    package_name,
+                    requestedVersion,
+                )
+                if result:
+                    print(
+                        f"Package {package_identifier} found in source: {source.source}"
+                    )
+                    return source
+                else:
+                    print(
+                        f"Package {package_identifier} not found in source: {source.source}"
+                    )
+            except Exception as e:
+                print(f"Error checking source {source.source}: {e}")
+
+        return None
+
+    @staticmethod
+    def install_package(
+        package_name: str,
+        requestedVersion: Optional[str] = None,
+        package_source: Optional[Source] = None,
+    ) -> InstalledPackage:
+        """
+        Installs the specified package from a given source.
+        """
+        package_identifier = (
+            f"{package_name}=={requestedVersion}" if requestedVersion else package_name
+        )
+
+        pip_command = [
+            sys.executable,
+            "-m",
+            "pip",
+            "install",
+            package_identifier,
+            "--target",
+            DEFAULT_RECIPE_INSTALL_LOCATION,
+        ]
+
+        if package_source:
+            authenticated_url = PyPiManager._get_authenticated_url(package_source)
+            pip_command.extend(["--index-url", authenticated_url])
+        else:
+            pip_command.extend(["--index-url", DEFAULT_PYPI_URL])
+
+        # create directory if it does not exist
+        if not os.path.exists(DEFAULT_RECIPE_INSTALL_LOCATION):
+            os.makedirs(DEFAULT_RECIPE_INSTALL_LOCATION)
+
+        try:
+            subprocess.run(pip_command, check=True)
+            metadata = PyPiManager._get_package_metadata(package_name)
+            resolvedVersion = metadata.get("version", "")
+
+            discovered_recipes = PyPiManager._introspect_module(package_name)
+
+            return InstalledPackage(
+                name=package_name,
+                version=resolvedVersion,
+                source=package_source.source if package_source else DEFAULT_PYPI_URL,
+                recipes=discovered_recipes,
+            )
+        except Exception as e:
+            raise RuntimeError(f"Failed to install package {package_name}: {e}")
+
+    @staticmethod
+    def uninstall_package(package_name: str) -> None:
+        """
+        Uninstalls the specified package using pip.
+        """
+        try:
+            subprocess.run(["pip", "uninstall", "-y", package_name], check=True)
+            print(f"Package {package_name} uninstalled successfully.")
+        except Exception as e:
+            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:
+        """
+        Loads a recipe from the specified source.
+        """
+        try:
+            module = importlib.import_module(module_name)
+            recipe = getattr(module, recipe_name)
+
+            has_params = bool(inspect.signature(recipe).parameters)
+
+            if not has_params:
+                return recipe()
+            else:
+                return recipe(recipe_options)
+        except Exception as e:
+            raise RuntimeError(f"Failed to load recipe {recipe_name}: {e}")
+
+    @staticmethod
+    def load_package_details(package_name: str) -> Dict[str, Any]:
+        """
+        Loads package details using `pip show`.
+        """
+        try:
+            metadata = PyPiManager._get_package_metadata(package_name)
+            if not metadata:
+                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}"
+            )
+
+    @staticmethod
+    def _get_package_metadata(package_name: str) -> Dict[str, Any]:
+        """
+        Extracts metadata for an installed package using `pip show`.
+        """
+        # Ensure the custom install location is on sys.path
+        if DEFAULT_RECIPE_INSTALL_LOCATION not in sys.path:
+            sys.path.insert(0, DEFAULT_RECIPE_INSTALL_LOCATION)
+
+        try:
+            dist = importlib.metadata.distribution(package_name)
+            # Convert it into a dictionary of metadata fields
+            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}"
+            )
+            return {}
+
+    @staticmethod
+    def _introspect_module(module_name: str) -> List[InstalledRecipe]:
+        # Ensure the custom install location is on sys.path
+        if DEFAULT_RECIPE_INSTALL_LOCATION not in sys.path:
+            sys.path.insert(0, DEFAULT_RECIPE_INSTALL_LOCATION)
+
+        # Convert to snake case per proper import conventions
+        module_name = module_name.replace("-", "_")
+
+        try:
+            module = importlib.import_module(module_name)
+            submodules = [name for _, name, _ in pkgutil.iter_modules(module.__path__)]
+
+            discovered_recipes: List[InstalledRecipe] = []
+
+            for submodule in submodules:
+                full_submodule_name = f"{module_name}.{submodule}"
+                # Import each submodule
+                sm = importlib.import_module(full_submodule_name)
+
+                # Get all classes in the submodule
+                classes = inspect.getmembers(sm, inspect.isclass)
+
+                for class_name, class_obj in classes:
+                    # Check if class is a subclass of Recipe
+                    if issubclass(class_obj, Recipe) and class_obj is not Recipe:
+                        discovered_recipes.append(
+                            InstalledRecipe(
+                                name=class_name,
+                                source=full_submodule_name,
+                                options=[],  # TODO support options
+                            )
+                        )
+
+            return discovered_recipes
+        except Exception as e:
+            raise RuntimeError(f"Failed to introspect module {module_name}: {e}")
+
+    @staticmethod
+    def _package_exists_in_registry(
+        index_url: str, package_name: str, version: Optional[str] = None
+    ) -> bool:
+        if not index_url.endswith("/"):
+            index_url += "/"
+        client = PyPISimple(endpoint=index_url)
+
+        try:
+            project_page = client.get_project_page(package_name)
+            if not project_page:
+                return False
+
+            # When no version the presence of the package is enough to confirm a valid source
+            if version is None:
+                return True
+
+            specifier = SpecifierSet(f"=={version}")
+
+            # Hunt for a distribution that matches the requested version
+            for dist in project_page.packages:
+                if dist.version is not None:
+                    dist_version = parse_version(dist.version)
+                    if dist_version in specifier:
+                        return True
+
+            # No distributions matched the requested version specifier
+            return False
+
+        except Exception as e:  # pylint: disable=broad-except
+            print(f"Error checking package {package_name}: {e}")
+            return False
+
+    @staticmethod
+    def _get_authenticated_url(source: Source) -> str:
+        """
+        Returns the source URL with embedded authentication if username/password or token is provided.
+        """
+        if source.username and source.password:
+            return source.source.replace(
+                "https://", f"https://{source.username}:{source.password}@"
+            )
+        elif source.token:
+            return source.source.replace("https://", f"https://{source.token}@")
+        return source.source