Remove strict git dependency on run (#236)

* remove strict git dep

* add rudimentary tests for app.py

* fix test

* better looking find_patchflow

* sort patchflow list

Author: CTY-git

patchwork/app.py

@@ -7,6 +7,7 @@
 from collections import deque
 from pathlib import Path
 from types import ModuleType
+from typing import Any
 
 import click
 import yaml
@@ -28,14 +29,6 @@
 _PATCHFLOW_MODULE_NAME = "patchwork.patchflows"
 
 
-def _get_config_path(config: str | None, patchflow: str) -> Path | None:
-    config_path = Path(config)
-    if config_path.is_dir():
-        patchwork_path = config_path / patchflow
-        if patchwork_path.is_dir():
-            return patchwork_path
-
-
 def _get_patchflow_names(base_path: Path | str | None) -> Iterable[str]:
     names = []
     if base_path is None:
@@ -48,7 +41,7 @@ def _get_patchflow_names(base_path: Path | str | None) -> Iterable[str]:
     for path in base_path.iterdir():
         if path.is_dir() and (path / f"{path.name}.py").is_file():
             names.append(path.name)
-    return names
+    return sorted(names)
 
 
 def list_option_callback(ctx: click.Context, param: click.Parameter, value: str | None) -> None:
@@ -181,21 +174,17 @@ def cli(
             # treat --key=value as a key-value pair
             inputs[key] = value
 
-    module = find_module(possbile_module_paths, patchflow)
-
-    try:
-        patchflow_class = getattr(module, patchflow_name)
-    except AttributeError:
-        logger.debug(f"Patchflow {patchflow} not found as a class in {module_path}")
+    patchflow_class = find_patchflow(possbile_module_paths, patchflow_name)
+    if patchflow_class is None:
+        logger.error(f"Patchflow {patchflow_name} not found in {possbile_module_paths}")
         exit(1)
 
     try:
-        repo = Repo(Path.cwd(), search_parent_directories=True)
         patched = PatchedClient(inputs.get("patched_api_key"))
         if not disable_telemetry:
             patched.send_public_telemetry(patchflow_name, inputs)
 
-        with patched.patched_telemetry(patchflow_name, repo, {}):
+        with patched.patched_telemetry(patchflow_name, {}):
             patchflow_instance = patchflow_class(inputs)
             patchflow_instance.run()
     except Exception as e:
@@ -209,20 +198,25 @@ def cli(
             file.write(serialize(inputs))
 
 
-def find_module(possible_module_paths: Iterable[str], patchflow: str) -> ModuleType | None:
+def find_patchflow(possible_module_paths: Iterable[str], patchflow: str) -> Any | None:
     for module_path in possible_module_paths:
         try:
             spec = importlib.util.spec_from_file_location("custom_module", module_path)
             module = importlib.util.module_from_spec(spec)
             spec.loader.exec_module(module)
-            return module
+            return getattr(module, patchflow)
+        except AttributeError:
+            logger.debug(f"Patchflow {patchflow} not found in {module_path}")
         except Exception:
             logger.debug(f"Patchflow {patchflow} not found as a file/directory in {module_path}")
 
         try:
-            return importlib.import_module(module_path)
+            module = importlib.import_module(module_path)
+            return getattr(module, patchflow)
         except ModuleNotFoundError:
             logger.debug(f"Patchflow {patchflow} not found as a module in {module_path}")
+        except AttributeError:
+            logger.debug(f"Patchflow {patchflow} not found in {module_path}")
 
     return None
 

patchwork/common/client/patched.py

@@ -9,6 +9,7 @@
 import sys
 import uuid
 from importlib import metadata
+from pathlib import Path
 from threading import Thread
 from typing import Any
 
@@ -167,7 +168,7 @@ def send_public_telemetry(self, patchflow: str, inputs: dict):
             logger.debug(f"Failed to send public telemetry: {e}")
 
     @contextlib.contextmanager
-    def patched_telemetry(self, patchflow: str, repo: Repo, inputs: dict):
+    def patched_telemetry(self, patchflow: str, inputs: dict):
         if not self.access_token:
             yield
             return
@@ -184,7 +185,8 @@ def patched_telemetry(self, patchflow: str, repo: Repo, inputs: dict):
             return
 
         try:
-            patchflow_run_id = self.record_patchflow_run(patchflow, repo, inputs)
+            repo = Repo(Path.cwd(), search_parent_directories=True)
+            patchflow_run_id = self.record_patchflow_run(patchflow, repo, self.__handle_telemetry_inputs(inputs))
         except Exception as e:
             logger.error(f"Failed to record patchflow run: {e}")
             yield

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "patchwork-cli"
-version = "0.0.21"
+version = "0.0.22"
 description = ""
 authors = ["patched.codes"]
 license = "AGPL"

tests/common/test_app.py

@@ -0,0 +1,118 @@
+from types import ModuleType
+
+import pytest
+import os
+from patchwork.app import cli, find_patchflow, _get_patchflow_names
+
+import click
+import yaml
+from patchwork.app import list_option_callback
+from click.testing import CliRunner
+
+
+@pytest.fixture
+def config_dir(tmp_path):
+    config_dir = tmp_path / "config"
+    config_dir.mkdir(parents=True, exist_ok=True)
+    return config_dir
+
+
+@pytest.fixture
+def patchflow_dir(config_dir):
+    patchflow_dir = config_dir / "noop"
+    patchflow_dir.mkdir(parents=True, exist_ok=True)
+    return patchflow_dir
+
+
+@pytest.fixture
+def patchflow_file(patchflow_dir):
+    patchflow_file = patchflow_dir / "noop.py"
+    patchflow_file.touch(exist_ok=True)
+    return patchflow_file
+
+
+@pytest.fixture
+def config_file(patchflow_dir):
+    config_file = patchflow_dir / "config.yaml"
+    config_file.touch(exist_ok=True)
+    return config_file
+
+
+@pytest.fixture
+def runner():
+    runner = CliRunner()
+    with runner.isolated_filesystem():
+        yield runner
+    return
+
+
+def test_default_list_option_callback(runner):
+    result = runner.invoke(cli, ['--list'])
+    assert result.exit_code == 0
+    assert result.output.strip() == """\
+AutoFix
+DependencyUpgrade
+GenerateDocstring
+GenerateREADME
+PRReview
+ResolveIssue"""
+
+
+def test_config_list_option_callback(runner, config_dir, patchflow_file):
+    filename = patchflow_file.name
+    name_without_ext = filename.replace(patchflow_file.suffix, '')
+    result = runner.invoke(cli, ['--list', '--config', str(config_dir)])
+    assert result.exit_code == 0
+    assert result.output.strip() == f"""\
+AutoFix
+DependencyUpgrade
+GenerateDocstring
+GenerateREADME
+PRReview
+ResolveIssue
+{name_without_ext}"""
+
+
+def test_cli_success(runner, config_dir, patchflow_file):
+    code = """\
+class noop:
+    def __init__(self, inputs):
+        pass
+    def run(self):
+        return dict(test='test')
+"""
+    patchflow_file.write_text(code)
+
+    result = runner.invoke(cli, ['noop', '--config', str(config_dir)])
+
+    assert result.exit_code == 0
+
+
+def test_cli_failure(runner):
+    result = runner.invoke(cli, ['noop', '--config', 'nonexistent'])
+    assert result.exit_code == 2
+
+
+def test_default_find_module():
+    # Try to import the module
+    patchflow = find_patchflow(["patchwork.patchflows"], "AutoFix")
+
+    # Check the output
+    assert isinstance(patchflow, type)
+    assert patchflow.__name__ == "AutoFix"
+
+
+def test_config_find_module(patchflow_file):
+    code = """\
+class noop:
+    def __init__(self, inputs):
+        pass
+    def run(self):
+        return dict(test='test')
+"""
+    patchflow_file.write_text(code)
+    patchflow = find_patchflow([str(patchflow_file.resolve()), "patchwork.patchflows"], "noop")
+
+    # Check the output
+    assert isinstance(patchflow, type)
+    assert patchflow.__name__ == "noop"