patch-package-py 0.1.0__py3-none-any.whl

patch_package_py/__init__.py

@@ -0,0 +1,2 @@
+from .core import *  # noqa: F403
+from .cli import cli as cli

patch_package_py/cli.py

@@ -0,0 +1,128 @@
+import argparse
+import sys
+from pathlib import Path
+from patch_package_py import (
+    prepare_patch_workspace,
+    commit_changes,
+    apply_patch,
+    Resolver,
+    find_site_packages,
+    PATCH_INFO_FILE,
+    CLI_NAME,
+)
+from logging import getLogger
+import logging
+
+logger = getLogger(__name__)
+logging.basicConfig(level=logging.INFO, format="%(message)s")
+
+
+def cmd_patch(args):
+    package_name = args.package
+    resolver = Resolver()
+    package = resolver.resolve_in_venv(Path.cwd() / ".venv", package_name)
+    if not package:
+        logger.error(
+            "Error: No package found",
+        )
+        sys.exit(1)
+    module_path, version = package
+    prepare_patch_workspace(module_path, package_name, version)
+
+
+def cmd_commit(args):
+    edit_path = Path(args.path)
+    if not edit_path.exists() or not edit_path.is_dir():
+        logger.error(
+            f"Error: Path {edit_path} does not exist or is not a directory",
+        )
+        sys.exit(1)
+    import subprocess
+
+    git_dir = subprocess.run(
+        ["git", "rev-parse", "--show-toplevel"],
+        cwd=edit_path,
+        capture_output=True,
+        text=True,
+        check=True,
+    ).stdout.strip()
+    with open(Path(git_dir) / PATCH_INFO_FILE, "r") as f:
+        import json
+
+        info = json.load(f)
+    site_packages_dir = Path(info["site_packages_path"])
+    commit_changes(info["package_name"], info["version"], site_packages_dir)
+    import shutil
+
+    shutil.rmtree(info["temp_dir"])
+
+
+def cmd_apply(args):
+    patches_dir = Path.cwd() / "patches"
+    site_packages_dir = find_site_packages(Path.cwd() / ".venv")
+
+    if not patches_dir.exists():
+        logger.error(
+            f"Error: Patches directory {patches_dir} does not exist",
+        )
+        sys.exit(1)
+
+    if not site_packages_dir.exists():
+        logger.error(
+            f"Error: Site-packages directory {site_packages_dir} does not exist",
+        )
+        sys.exit(1)
+
+    patch_files = list(patches_dir.glob("*.patch"))
+
+    if not patch_files:
+        logger.info(f"No patch files found in {patches_dir}")
+        return
+
+    success_count = 0
+    for patch_file in patch_files:
+        try:
+            apply_patch(patch_file, site_packages_dir)
+            success_count += 1
+        except Exception as e:
+            logger.error(f"✗ Failed to apply {patch_file.name}: {e}")
+
+    logger.info(f"Applied {success_count}/{len(patch_files)} patches successfully")
+
+
+def cli():
+    parser = argparse.ArgumentParser(
+        prog=CLI_NAME, description="A Python package patching tool"
+    )
+
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # patch command
+    workspace_parser = subparsers.add_parser(
+        "patch", help="Prepare for patching a package"
+    )
+    workspace_parser.add_argument("package", help="Package name")
+    workspace_parser.set_defaults(func=cmd_patch)
+
+    # commit command
+    commit_parser = subparsers.add_parser(
+        "commit", help="Commit changes and create a patch file"
+    )
+    commit_parser.add_argument("path", help="Edit patch given by `patch` command")
+    commit_parser.set_defaults(func=cmd_commit)
+
+    # apply command
+    apply_parser = subparsers.add_parser("apply", help="Apply patches")
+    apply_parser.set_defaults(func=cmd_apply)
+
+    args = parser.parse_args()
+
+    if not args.command:
+        parser.print_help()
+        sys.exit(1)
+
+    try:
+        args.func(args)
+    except Exception as e:
+        logger.error(f"Error: {e}")
+        sys.exit(1)

patch_package_py/core.py

@@ -0,0 +1,238 @@
+from pathlib import Path, PurePosixPath
+import tempfile
+import os
+import subprocess
+import sys
+from logging import getLogger
+import posixpath
+
+logger = getLogger(__name__)
+
+CLI_NAME = "p12y"
+PATCH_INFO_FILE = ".patch_info.json"
+
+
+def find_site_packages(venv: Path) -> Path:
+    # For Windows
+    if os.name == "nt":
+        return venv / "Lib" / "site-packages"
+
+    # For Unix-like systems
+    lib_path = venv / "lib"
+    if lib_path.exists():
+        python_dirs = list(lib_path.glob("python*"))
+        if python_dirs:
+            return python_dirs[0] / "site-packages"
+
+    raise FileNotFoundError("Could not determine site-packages directory.")
+
+
+class Resolver:
+    def resolve_in_venv(
+        self, venv: Path, package_name: str
+    ) -> tuple[PurePosixPath, str] | None:
+        site_packages_path = find_site_packages(venv)
+        dist_info = list(
+            site_packages_path.glob(f"{package_name.replace('-', '_')}-*.dist-info")
+        )
+        if not dist_info:
+            return None
+        if len(dist_info) != 1:
+            raise ValueError("unreachable")
+        dist_info_path = dist_info[0]
+        _, version = dist_info_path.stem.rsplit("-", 1)
+        files = self._parse_record_file(dist_info_path)
+        commonpath = self._find_commonpath(files)
+        return commonpath, version
+
+    def _parse_record_file(self, dist_info_path: Path) -> list[PurePosixPath]:
+        record_file = dist_info_path / "RECORD"
+        if not record_file.exists():
+            return []
+
+        files: list[PurePosixPath] = []
+        with record_file.open("r") as f:
+            for line in f:
+                line = line.strip()
+                if not line:
+                    continue
+
+                # Parse CSV-like format: path,hash,size
+                parts = line.split(",")
+                if len(parts) >= 1:
+                    file_path = parts[0]
+                    # Skip .dist-info files and external files
+                    if (
+                        ".dist-info/" not in file_path
+                        and not file_path.startswith("./")
+                        and not file_path.startswith("../")
+                    ):
+                        files.append(PurePosixPath(file_path))
+
+        return files
+
+    def _find_commonpath(self, files: list[PurePosixPath]) -> PurePosixPath:
+        if not files:
+            return PurePosixPath("")
+
+        if len(files) == 1:
+            # For single file, return its directory
+            return files[0].parent
+
+        common_path_str = posixpath.commonpath([str(p) for p in files])
+        return PurePosixPath(common_path_str)
+
+
+def prepare_patch_workspace(
+    module_path: PurePosixPath, package_name: str, version: str
+):
+    temp_dir = Path(tempfile.mkdtemp(prefix=f"patch-{package_name}-{version}-"))
+    venv_path = temp_dir / "venv"
+
+    # Create venv with uv using current Python version
+    subprocess.run(
+        ["uv", "venv", str(venv_path), "--python", sys.executable], check=True
+    )
+
+    # Install the package without dependencies using uv
+    subprocess.run(
+        [
+            "uv",
+            "pip",
+            "install",
+            "--no-deps",
+            f"{package_name}=={version}",
+            "--python",
+            str(
+                venv_path / ("Scripts/python.exe" if os.name == "nt" else "bin/python")
+            ),
+        ],
+        check=True,
+        cwd=temp_dir,
+    )
+
+    # Remove all directories ending with .dist-info
+    site_packages_path = find_site_packages(venv_path)
+    for dist_info in site_packages_path.glob("*.dist-info"):
+        if dist_info.is_dir():
+            import shutil
+
+            shutil.rmtree(dist_info)
+    # Remove _virtualenv.py and _virtualenv.pth if exist
+    for extra_file in ["_virtualenv.py", "_virtualenv.pth"]:
+        extra_path = site_packages_path / extra_file
+        if extra_path.exists():
+            extra_path.unlink()
+
+    git_path = site_packages_path.parent
+    edit_path = site_packages_path / module_path
+
+    with open(git_path / ".gitignore", "w") as f:
+        f.write(
+            "__pycache__/\n*.py[oc]\nbuild/\ndist/\nwheels/\n*.egg-info\n_virtualenv.py\n_virtualenv.pth"
+        )
+    with open(git_path / PATCH_INFO_FILE, "w") as f:
+        import json
+
+        json.dump(
+            {
+                "temp_dir": str(temp_dir.absolute()),
+                "venv_path": str(venv_path.absolute()),
+                "site_packages_path": str(site_packages_path.absolute()),
+                "package_name": package_name,
+                "version": version,
+            },
+            f,
+            indent=2,
+        )
+    subprocess.run(["git", "init"], cwd=git_path, check=True, capture_output=True)
+    subprocess.run(
+        ["git", "add", "."],
+        cwd=git_path,
+        check=True,
+        capture_output=True,
+    )
+    subprocess.run(
+        [
+            "git",
+            "commit",
+            "--no-gpg-sign",
+            "-m",
+            f"Initial commit of {package_name}=={version}",
+        ],
+        cwd=git_path,
+        check=True,
+        capture_output=True,
+    )
+
+    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:
+    diff_proc = subprocess.run(
+        ["git", "diff", "--relative"],
+        cwd=site_packages_path,
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+
+    diff_content = diff_proc.stdout
+    if not diff_content:
+        logger.info("No changes detected, nothing to commit.")
+        return
+    patch_file_name = f"{package_name}+{version}.patch"
+    patches_dir = Path.cwd() / "patches"
+    patches_dir.mkdir(exist_ok=True, parents=True)
+    patch_file_path = patches_dir / patch_file_name
+    with open(patch_file_path, "w") as f:
+        f.write(diff_content)
+
+    try:
+        apply_patch(patch_file_path, site_packages_path)
+    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}`"
+        )
+        return
+    logger.info(f"Patch created and applied for {package_name}=={version}")
+
+
+def apply_patch(patch_file: Path, site_packages_dir: Path) -> None:
+    # First, check if the patch is already applied using dry-run
+    try:
+        subprocess.run(
+            [
+                "patch",
+                "-p1",
+                "-N",
+                "--dry-run",
+                "--forward",
+                "-i",
+                str(patch_file.absolute()),
+            ],
+            cwd=site_packages_dir,
+            check=True,
+            capture_output=True,
+        )
+    except subprocess.CalledProcessError:
+        logger.warning(
+            f"Patch `{patch_file.stem}` appears to be already applied, skipping...",
+        )
+        return
+
+    # If dry-run succeeds, apply the patch for real
+    subprocess.run(
+        [
+            "patch",
+            "-p1",
+            "-N",
+            "--forward",
+            "-i",
+            str(patch_file.absolute()),
+        ],
+        cwd=site_packages_dir,
+        check=True,
+    )

patch_package_py-0.1.0.dist-info/METADATA

@@ -0,0 +1,108 @@
+Metadata-Version: 2.4
+Name: patch-package-py
+Version: 0.1.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
+Project-URL: Issues, https://github.com/nomyfan/patch-package-py/issues
+Author-email: nomyfan <nomyfan@live.com>
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT 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-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# patch-package-py
+
+A Python package patching tool that allows you to make and apply patches to third-party packages in your virtual environment.
+
+## Installation
+
+```bash
+uv add patch-package-py
+```
+
+## Usage
+
+The tool provides three main commands via the `p12y` CLI:
+
+### 1. Create a patch workspace
+
+```bash
+p12y patch <package_name>
+```
+
+This command:
+
+- Resolves the package from your current virtual environment (`.venv`)
+- Creates a temporary virtual environment
+- Installs the same version of the package without dependencies
+- Sets up a git repository for tracking changes
+- Provides a path where you can edit the package files
+
+Example:
+
+```bash
+p12y patch requests
+```
+
+### 2. Commit changes and create patch file
+
+```bash
+p12y commit <edit_path>
+```
+
+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
+
+Example:
+
+```bash
+p12y commit /tmp/patch-requests-2.28.1-abc123/venv/lib/python3.11/site-packages/requests
+```
+
+### 3. Apply patches
+
+```bash
+p12y apply
+```
+
+This command:
+
+- Looks for `.patch` files in the `patches/` directory
+- Applies them to the packages in your current virtual environment (`.venv`)
+- Reports success/failure for each patch
+
+## Workflow
+
+1. **Prepare for patching**: Run `p12y patch <package_name>` to set up a workspace
+2. **Make your changes**: Edit the files in the provided path
+3. **Create the patch**: Run `p12y commit <path>` to generate the patch file
+4. **Apply patches**: Run `p12y apply` in your project to apply all patches
+
+## How it works
+
+- Uses `uv` for fast virtual environment creation and package installation
+- Leverages git for tracking changes and generating diffs
+- Stores patch files in a `patches/` directory in your project root
+- Patch files are named using the format: `<package-name>+<version>.patch`
+
+## Requirements
+
+- Python ≥ 3.9
+- `uv` package manager
+- `git` version control system
+- `patch` utility (typically pre-installed on Unix-like systems)
+
+## License
+
+MIT

patch_package_py-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+patch_package_py/__init__.py,sha256=bSu9ttGPKG8PfZiNHM0-VMQmGnlNWcxGEp46pwZ-T_4,62
+patch_package_py/cli.py,sha256=2ktZP8ZTT6CSETrOKDEG83UB7ubl0YXeNr4vSfL4RGM,3518
+patch_package_py/core.py,sha256=_5KCnh30HiSc2WsAr8XdHjVUWsm-Mqe934IoDuBqS8Q,7338
+patch_package_py-0.1.0.dist-info/METADATA,sha256=CDcSahgN5ctu4qRNMv70R1OILjHjWyI6zGNJu8Okc_0,2900
+patch_package_py-0.1.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+patch_package_py-0.1.0.dist-info/entry_points.txt,sha256=5dr99rfwblqKup5172uzG4QcL2CDDz8JqoFWkTXc9M8,50
+patch_package_py-0.1.0.dist-info/RECORD,,

patch_package_py-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.27.0
+Root-Is-Purelib: true
+Tag: py3-none-any

patch_package_py-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+p12y = patch_package_py.cli:cli