patch-package-py 0.1.4__tar.gz → 0.2.0__tar.gz

{patch_package_py-0.1.4 → patch_package_py-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: patch-package-py
-Version: 0.1.4
+Version: 0.2.0
 Summary: patch 3rd party Python packages
 Project-URL: Homepage, https://github.com/nomyfan/patch-package-py
 Project-URL: Repository, https://github.com/nomyfan/patch-package-py
@@ -30,6 +30,12 @@ A Python package patching tool that allows you to make and apply patches to thir
 uv add patch-package-py
 ```
 
+## Agent skill
+
+This repository includes an
+[agent skill](skills/patch-package-py/) for AI agents that support agent
+skills.
+
 ## Usage
 
 The tool provides three main commands via the `p12y` CLI:
@@ -58,14 +64,15 @@ p12y patch requests [-e <environment-path>]
 ### 2. Commit changes and create patch file
 
 ```bash
-p12y commit <edit_path>
+p12y commit <edit_path> [--skip-restore]
 ```
 
 After editing the package files, use this command to:
 
 - Generate a git diff of your changes
 - Create a `.patch` file in the `patches/` directory
-- Test that the patch can be applied successfully
+- Reinstall the original package in the target environment
+- Apply the new patch to the target environment
 
 Example:
 
@@ -73,6 +80,9 @@ Example:
 p12y commit /tmp/patch-requests-2.28.1-abc123/venv/lib/python3.11/site-packages/requests
 ```
 
+Use `--skip-restore` to write the patch file and apply it to the current target
+environment directly.
+
 ### 3. Apply patches
 
 ```bash
@@ -97,13 +107,21 @@ This command:
 
 - Uses `uv` for fast virtual environment creation and package installation
 - Leverages git for tracking changes and generating diffs
+- Reinstalls the target package during `commit` before applying the newly generated patch
 - Stores patch files in a `patches/` directory in your project root
 - Patch files are named using the format: `<package-name>+<version>.patch`
 
-## Using with poetry
+## Using with Poetry
 
-- detect the environment path using `poetry show -v`
-- use the -e / --env-path option for patch and/or apply.
+- Detect the environment path using `poetry env info --path`.
+- Use the `-e` / `--env-path` option for `patch` and `apply`.
+- `commit` reuses the environment path recorded by `patch -e`.
+
+```bash
+p12y patch requests -e "$(poetry env info --path)"
+p12y commit <edit_path>
+p12y apply -e "$(poetry env info --path)"
+```
 
 ## Requirements
 

{patch_package_py-0.1.4 → patch_package_py-0.2.0}/README.md

@@ -8,6 +8,12 @@ A Python package patching tool that allows you to make and apply patches to thir
 uv add patch-package-py
 ```
 
+## Agent skill
+
+This repository includes an
+[agent skill](skills/patch-package-py/) for AI agents that support agent
+skills.
+
 ## Usage
 
 The tool provides three main commands via the `p12y` CLI:
@@ -36,14 +42,15 @@ p12y patch requests [-e <environment-path>]
 ### 2. Commit changes and create patch file
 
 ```bash
-p12y commit <edit_path>
+p12y commit <edit_path> [--skip-restore]
 ```
 
 After editing the package files, use this command to:
 
 - Generate a git diff of your changes
 - Create a `.patch` file in the `patches/` directory
-- Test that the patch can be applied successfully
+- Reinstall the original package in the target environment
+- Apply the new patch to the target environment
 
 Example:
 
@@ -51,6 +58,9 @@ Example:
 p12y commit /tmp/patch-requests-2.28.1-abc123/venv/lib/python3.11/site-packages/requests
 ```
 
+Use `--skip-restore` to write the patch file and apply it to the current target
+environment directly.
+
 ### 3. Apply patches
 
 ```bash
@@ -75,13 +85,21 @@ This command:
 
 - Uses `uv` for fast virtual environment creation and package installation
 - Leverages git for tracking changes and generating diffs
+- Reinstalls the target package during `commit` before applying the newly generated patch
 - Stores patch files in a `patches/` directory in your project root
 - Patch files are named using the format: `<package-name>+<version>.patch`
 
-## Using with poetry
+## Using with Poetry
 
-- detect the environment path using `poetry show -v`
-- use the -e / --env-path option for patch and/or apply.
+- Detect the environment path using `poetry env info --path`.
+- Use the `-e` / `--env-path` option for `patch` and `apply`.
+- `commit` reuses the environment path recorded by `patch -e`.
+
+```bash
+p12y patch requests -e "$(poetry env info --path)"
+p12y commit <edit_path>
+p12y apply -e "$(poetry env info --path)"
+```
 
 ## Requirements
 

{patch_package_py-0.1.4 → patch_package_py-0.2.0}/patch_package_py/cli.py

@@ -33,7 +33,9 @@ def cmd_patch(args):
         )
         sys.exit(1)
     module_path, version = package
-    prepare_patch_workspace(module_path, package_name, version)
+    prepare_patch_workspace(
+        module_path, package_name, version, env_path, amend=args.amend
+    )
 
 
 def cmd_commit(args):
@@ -57,7 +59,14 @@ def cmd_commit(args):
 
         info = json.load(f)
     site_packages_dir = Path(info["site_packages_path"])
-    commit_changes(info["package_name"], info["version"], site_packages_dir)
+    target_env_path = Path(info["target_env_path"])
+    commit_changes(
+        info["package_name"],
+        info["version"],
+        site_packages_dir,
+        target_env_path,
+        restore_target_package=not args.skip_restore,
+    )
     import shutil
 
     shutil.rmtree(info["temp_dir"])
@@ -91,9 +100,17 @@ def cmd_apply(args):
 
 
 def cli():
+    from importlib.metadata import version
+
     parser = argparse.ArgumentParser(
         prog=CLI_NAME, description="A Python package patching tool"
     )
+    parser.add_argument(
+        "-V",
+        "--version",
+        action="version",
+        version=f"patch-package-py {version('patch-package-py')}",
+    )
 
     subparsers = parser.add_subparsers(dest="command", help="Available commands")
 
@@ -103,6 +120,11 @@ def cli():
     )
     workspace_parser.add_argument("package", help="Package name")
     workspace_parser.add_argument("-e", "--env-path", help="Environment Path")
+    workspace_parser.add_argument(
+        "--amend",
+        action="store_true",
+        help="Apply existing patch file to the workspace so you can continue editing",
+    )
     workspace_parser.set_defaults(func=cmd_patch)
 
     # commit command
@@ -110,6 +132,11 @@ def cli():
         "commit", help="Commit changes and create a patch file"
     )
     commit_parser.add_argument("path", help="Edit patch given by `patch` command")
+    commit_parser.add_argument(
+        "--skip-restore",
+        action="store_true",
+        help="Skip reinstalling the target package before applying the new patch",
+    )
     commit_parser.set_defaults(func=cmd_commit)
 
     # apply command

{patch_package_py-0.1.4 → patch_package_py-0.2.0}/patch_package_py/core.py

@@ -89,8 +89,20 @@ class Resolver:
         return PurePosixPath(common_path_str)
 
 
+def find_existing_patch(package_name: str, version: str) -> Union[Path, None]:
+    patch_file = Path.cwd() / "patches" / f"{package_name}+{version}.patch"
+    if patch_file.exists():
+        return patch_file
+    return None
+
+
 def prepare_patch_workspace(
-    module_path: PurePosixPath, package_name: str, version: str
+    module_path: PurePosixPath,
+    package_name: str,
+    version: str,
+    target_env_path: Path,
+    *,
+    amend: bool = False,
 ):
     temp_dir = Path(tempfile.mkdtemp(prefix=f"patch-{package_name}-{version}-"))
     venv_path = temp_dir / "venv"
@@ -105,6 +117,7 @@ def prepare_patch_workspace(
             "pip",
             "install",
             "--no-deps",
+            "--link-mode=copy",
             f"{package_name}=={version}",
             "--python",
             str(
@@ -144,6 +157,7 @@ def prepare_patch_workspace(
                 "site_packages_path": str(site_packages_path.absolute()),
                 "package_name": package_name,
                 "version": version,
+                "target_env_path": str(target_env_path.absolute()),
             },
             f,
             indent=2,
@@ -154,6 +168,13 @@ def prepare_patch_workspace(
         stderr=subprocess.DEVNULL,
         stdout=subprocess.DEVNULL,
     )
+    subprocess.check_call(
+        ["git", "config", "user.name", "patch-package-py"], cwd=git_path
+    )
+    subprocess.check_call(
+        ["git", "config", "user.email", "noreply@patch-package-py.local"],
+        cwd=git_path,
+    )
     subprocess.check_call(
         ["git", "add", "."],
         cwd=git_path,
@@ -173,12 +194,85 @@ def prepare_patch_workspace(
         stdout=subprocess.DEVNULL,
     )
 
+    if amend:
+        existing_patch = find_existing_patch(package_name, version)
+        if existing_patch:
+            logger.info(f"Applying existing patch: {existing_patch.name}")
+            patch_args = [
+                "patch",
+                "-p1",
+                "-N",
+                "--forward",
+                "-i",
+                str(existing_patch.absolute()),
+            ]
+            try:
+                # Validate before modifying the workspace; recovery below
+                # handles residue if the real apply still fails unexpectedly.
+                subprocess.check_call(
+                    [*patch_args, "--dry-run"],
+                    cwd=site_packages_path,
+                    stderr=subprocess.DEVNULL,
+                    stdout=subprocess.DEVNULL,
+                )
+                subprocess.check_call(
+                    patch_args,
+                    cwd=site_packages_path,
+                )
+            except subprocess.CalledProcessError:
+                logger.warning(
+                    "Failed to apply existing patch. Starting from clean state."
+                )
+                subprocess.check_call(
+                    ["git", "add", "."],
+                    cwd=git_path,
+                    stderr=subprocess.DEVNULL,
+                    stdout=subprocess.DEVNULL,
+                )
+                subprocess.check_call(
+                    ["git", "reset", "--hard", "HEAD"],
+                    cwd=git_path,
+                    stderr=subprocess.DEVNULL,
+                    stdout=subprocess.DEVNULL,
+                )
+                subprocess.check_call(
+                    ["git", "clean", "-fdX"],
+                    cwd=git_path,
+                    stderr=subprocess.DEVNULL,
+                    stdout=subprocess.DEVNULL,
+                )
+
     logger.info(
         f"You can now edit the package in: {edit_path}. When done, run `{CLI_NAME} commit {edit_path}` in this directory to create the patch file."
     )
 
 
-def commit_changes(package_name: str, version: str, site_packages_path: Path) -> None:
+def venv_python(venv_path: Path) -> Path:
+    return venv_path / ("Scripts/python.exe" if os.name == "nt" else "bin/python")
+
+
+def restore_clean_package(package_name: str, version: str, env_path: Path) -> None:
+    subprocess.check_call(
+        [
+            "uv",
+            "pip",
+            "install",
+            "--force-reinstall",
+            "--no-deps",
+            f"{package_name}=={version}",
+            "--python",
+            str(venv_python(env_path)),
+        ]
+    )
+
+
+def commit_changes(
+    package_name: str,
+    version: str,
+    site_packages_path: Path,
+    target_env_path: Path,
+    restore_target_package: bool = True,
+) -> None:
     diff_content = subprocess.check_output(
         ["git", "diff", "--relative"],
         cwd=site_packages_path,
@@ -195,13 +289,26 @@ def commit_changes(package_name: str, version: str, site_packages_path: Path) ->
     with open(patch_file_path, "w") as f:
         f.write(diff_content)
 
-    current_site_packages = find_site_packages(Path.cwd() / ".venv")
+    if restore_target_package:
+        restore_clean_package(package_name, version, target_env_path)
+
+    current_site_packages = find_site_packages(target_env_path)
     try:
         apply_patch(patch_file_path, current_site_packages)
     except subprocess.CalledProcessError:
-        logger.error(
-            f"Error: failed to apply the patch after creation. There's maybe a conflict, you can try to reinstall the package and apply the patch manually via `{CLI_NAME} apply {patch_file_name}`"
-        )
+        msg = "Error: failed to apply the patch after creation."
+        if restore_target_package:
+            msg += (
+                " This may be caused by leftover files from a previous patch."
+                " Try manually removing them from the target environment"
+                f" and then run `{CLI_NAME} apply`."
+            )
+        else:
+            msg += (
+                " There's maybe a conflict, you can try to reinstall the package"
+                f" and apply the patch manually via `{CLI_NAME} apply`."
+            )
+        logger.error(msg)
         return
     logger.info(f"Patch created and applied for {package_name}=={version}")
 

{patch_package_py-0.1.4 → patch_package_py-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "patch-package-py"
-version = "0.1.4"
+version = "0.2.0"
 description = "patch 3rd party Python packages"
 readme = "README.md"
 requires-python = ">=3.9"