makepatch 0.0.1__py3-none-any.whl → 0.2.0__py3-none-any.whl

makepatch/__hooks__.py

@@ -0,0 +1,7 @@
+from hatchling.plugin import hookimpl
+from makepatch.hooks import PatcherBuildHook
+
+
+@hookimpl
+def hatch_register_build_hook():
+    return PatcherBuildHook

makepatch/__init__.py

@@ -0,0 +1,2 @@
+from .__hook__ import hatch_register_build_hook
+from .hooks import PatcherBuildHook

makepatch/_config.py

@@ -1,18 +1,59 @@
+import os
 from collections.abc import Iterable
-from typing import final, Annotated
+from pathlib import Path
+from typing import final, Annotated, ClassVar
 
 from pydantic import BaseModel, Field
+from pydantic.json_schema import SkipJsonSchema
 
+if __debug__ and __import__("typing").TYPE_CHECKING:
+
+    from makepatch._types.hatch import HatchHookInterface
 
-__config = None
 
 @final
-class ClippyConfig(BaseModel):
+class PatcherConfig(BaseModel):
+    __INTERNAL: ClassVar[object] = object()
+    __INSTANCE: ClassVar[PatcherConfig | None] = None
+
     module_source: Annotated[str, Field(alias="module-source")]
     excludes: Annotated[Iterable[str], Field(default_factory=frozenset)]
-    dev_excludes: Annotated[Iterable[str], Field(alias="module-source", default_factory=frozenset)]
+    dev_excludes: Annotated[Iterable[str], Field(alias="dev-excludes", default_factory=frozenset)]
+
+    module_name: Annotated[SkipJsonSchema[str], Field(exclude=True)]
+    project_root: Annotated[SkipJsonSchema[Path], Field(exclude=True)]
+
+    def __init__(self, obj: object, /, **kwargs):
+        if obj is not self.__INTERNAL:
+            raise RuntimeError("Security error: External initialization is prohibited")
+        if "/" in kwargs["module-source"]:
+            _, kwargs["module_name"] = str(kwargs["module-source"]).rsplit(os.sep, 1)
+        else:
+            kwargs["module_name"] = kwargs["module-source"]
+        super().__init__(**kwargs)
+
+    @classmethod
+    def from_hatch(cls, hook: HatchHookInterface, /) -> PatcherConfig:
+        if PatcherConfig.__INSTANCE:
+            raise RuntimeError(f"{cls.__name__} already initialized")
+
+        config = hook.config["options"]
+        config["project_root"] = Path(hook.root).resolve()
+        PatcherConfig.__INSTANCE = PatcherConfig(PatcherConfig.__INTERNAL, **config)
+        assert PatcherConfig.__INSTANCE
+        return PatcherConfig.__INSTANCE
+
+    @classmethod
+    def from_pyproject(cls, root: Path, /):
+        pyproject_toml = (root / "pyproject.toml").resolve()
+        if not pyproject_toml.exists() or not pyproject_toml.is_file():
+            raise FileNotFoundError(f"{pyproject_toml} does not exist or is not a file")
 
-    def __init__(self, /):
-        global __config
-        if __config:
-            raise RuntimeError("Configuration already initialized")
+        import tomllib
+        try:
+            with open(pyproject_toml, 'rb') as f:
+                config = tomllib.load(f)["tool"]["hatch"]["build"]["hooks"]["makepatch"]["options"]
+                config["project_root"] = Path(root).resolve()
+                return PatcherConfig(PatcherConfig.__INTERNAL, **config)
+        except tomllib.TOMLDecodeError as e:
+            raise RuntimeError(f"Cannot parse pyproject.toml") from e

makepatch/_types/__init__.pyi

@@ -0,0 +1 @@
+from .hatch import HatchHookInterface

makepatch/_types/hatch.pyi

@@ -0,0 +1,57 @@
+from typing import Protocol, Any
+
+from hatchling.bridge.app import Application
+from hatchling.metadata.core import ProjectMetadata
+
+
+class HatchHookInterface(Protocol):
+    @property
+    def app(self, /) -> Application:
+        """
+        An instance of [Application](../utilities.md#hatchling.bridge.app.Application).
+        """
+
+    @property
+    def root(self, /) -> str:
+        """
+        The root of the project tree.
+        """
+
+    @property
+    def config(self, /) -> dict[str, Any]:
+        """
+        The cumulative hook configuration.
+
+        ```toml config-example
+        [tool.hatch.build.hooks.<PLUGIN_NAME>]
+        [tool.hatch.build.targets.<TARGET_NAME>.hooks.<PLUGIN_NAME>]
+        ```
+        """
+
+    @property
+    def metadata(self, /) -> ProjectMetadata:
+        ...
+
+    @property
+    def directory(self, /) -> str:
+        """
+        The build directory.
+        """
+
+    @property
+    def target_name(self, /) -> str:
+        """
+        The plugin name of the build target.
+        """
+
+    def dependencies(self, /) -> list[str]:  # noqa: PLR6301
+        """
+        A list of extra [dependencies](../../config/dependency.md) that must be installed
+        prior to builds.
+
+        !!! warning
+            - For this to have any effect the hook dependency itself cannot be dynamic and
+                must always be defined in `build-system.requires`.
+            - As the hook must be imported to call this method, imports that require these
+                dependencies must be evaluated lazily.
+        """

makepatch/core/__init__.py

@@ -0,0 +1 @@
+from ._patcher import PatchApplier

makepatch/core/_patcher.py

@@ -0,0 +1,125 @@
+import os
+import shutil
+import subprocess
+from typing import final
+
+from makepatch._config import PatcherConfig
+
+
+if __debug__ and __import__("typing").TYPE_CHECKING:
+    from pathlib import Path
+    from typing import Final
+
+
+@final
+class PatchApplier:
+    if __debug__ and __import__("typing").TYPE_CHECKING:
+        __slots__ = (
+            "__config",
+            "__excludes",
+            "__excludes_dev",
+            "__patches",
+            "__src",
+            "__sources",
+        )
+
+    def __init__(self, config: PatcherConfig, /) -> None:
+        self.__config: Final = config
+        self.__excludes: Final = set[str]()
+        self.__excludes_dev: Final = set[str]()
+
+        # resolve patches
+        self.__patches: Final = self.__resolve_path(config.project_root / "patches")
+
+        # INTENDED: required for later use
+        self.__src: Path | None = None
+        self.__sources: Path | None = None
+
+    def setup_required(self, /):
+        return not (self.__config.project_root / "work/patched").resolve().exists()
+
+    @staticmethod
+    def __resolve_path(path: Path, /):
+        path = path.resolve()
+        if not path.exists() or not path.is_dir():
+            raise RuntimeError(f"{path} does not exist or is not a directory")
+        return path
+
+    def resolve_src(self, /):
+        """
+        Resolves `module` src root, where the codes are placed
+        """
+        assert not self.__src
+        if not self.__sources:
+            self.__sources = self.__resolve_path(self.__config.project_root / "work/sources")
+        assert self.__sources
+        src = self.__src = self.__resolve_path(self.__sources / self.__config.module_source)
+
+        for glob in self.__config.excludes:
+            dirname = glob.split(os.sep, 1)[0]
+            for excluded in src.rglob(glob):
+                if (rel_str := str(excluded.relative_to(src))).startswith(dirname):
+                    self.__excludes.add(rel_str)
+
+    def resolve_sources(self, /):
+        """
+        Resolves entire git sources
+        """
+        assert not self.__sources
+        sources = self.__sources = self.__resolve_path(self.__config.project_root / "work/sources")
+
+        for glob in self.__config.dev_excludes:
+            dirname = glob.split(os.sep, 1)[0]
+            for excluded in sources.rglob(glob):
+                if (rel_str := str(excluded.relative_to(sources))).startswith(dirname):
+                    self.__excludes_dev.add(rel_str)
+
+    def copy(self, dst: Path, /):
+        if self.__excludes_dev:
+            src = self.__sources
+            excludes = self.__excludes_dev
+            filter_ = lambda path: path.is_relative_to(self.__src) and (str(path.relative_to(self.__src)) in self.__excludes)
+        else:
+            src = self.__src
+            excludes = self.__excludes
+            filter_ = None
+
+        assert src and excludes
+        for src_file in src.rglob("*"):
+            if not src_file.is_file():
+                assert src_file.exists()
+                continue
+
+            rel = src_file.relative_to(src)
+            if (str(rel) in excludes) or (filter_ and filter_(src_file)):
+                continue
+
+            dst_file = dst / rel
+            if dst_file.exists():
+                raise RuntimeError(f"Failed to copy file {rel}: file exists")
+            dst_file.parent.mkdir(parents=True, exist_ok=True)
+            shutil.copy2(src_file, dst_file)
+
+    def apply(self, dst: Path, /) -> bool:
+        total = []
+        for patch in self.__patches.rglob("*.patch"):
+            rel_patch = patch.relative_to(self.__patches)
+            total.append(rel_patch)
+
+            rel_dst = rel_patch.with_suffix("") # foo.py.patch -> foo.py
+            dst_file = dst / rel_dst
+            dst_file.parent.mkdir(parents=True, exist_ok=True)
+
+            res = subprocess.run(
+                ["patch", "--unified", str(dst_file), str(patch)],
+                capture_output=True,
+                text=True,
+            )
+            if res.returncode != 0:
+                print(f"Failed to apply {rel_patch}:\n\t"
+                      + "\n\t".join(res.stdout.splitlines()))
+                break
+        else:
+            print(f"Successfully applied {len(total)} patches")
+            return True
+        return False

makepatch/hooks/__init__.py

@@ -1 +1 @@
-from ._patch import ClippyPatchHook
+from ._patch import PatcherBuildHook

makepatch/hooks/_patch.py

@@ -1,88 +1,60 @@
-import os
-from pathlib import Path
 from typing import override
 
 from hatchling.builders.hooks.plugin.interface import BuildHookInterface
 
-import shutil, subprocess, tomllib
+import shutil
 
-if __debug__ and __import__("typing").TYPE_CHECKING:
-    from typing import Any
+from makepatch._config import PatcherConfig
+from makepatch.core import PatchApplier
 
+if __debug__ and __import__("typing").TYPE_CHECKING:
+    from typing import Any, Final
 
-class ClippyPatchHook(BuildHookInterface):
-    @property
-    def __root(self):
-        return Path(self.root)
 
-    @property
-    def __config(self):
-        with open(self.__root / "pyproject.toml", "rb") as f:
-            pyproject = tomllib.load(f)
+class PatcherBuildHook(BuildHookInterface):
+    PLUGIN_NAME = "makepatch"
 
-        try:
-            config = pyproject["tool"]["patcher"]
-        except KeyError as e:
-            raise RuntimeError("[tool.patcher] not found in pyproject.toml") from e
-        return config["module-source"], frozenset(config.get("excludes", set()))
+    def __init__(self, /, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.__config: Final = PatcherConfig.from_hatch(self)
+        self.__patcher: Final = PatchApplier(self.__config)
 
     @override
     def initialize(self, version: str, build_data: dict[str, Any]) -> None:
-        module_name, exclude_globs = self.__config
+        config = self.__config
+        patcher = self.__patcher
+
+        if patcher.setup_required():
+            patcher.resolve_sources()
+            patcher.resolve_src()
 
-        src = self.__root / "work" / "sources" / module_name
-        if not src.exists(): raise RuntimeError(f"{src} not exists")
-        elif not src.is_dir(): raise RuntimeError(f"{src} is not a directory")
+            dst = config.project_root / "work/patched"
+            if dst.exists():
+                if not dst.is_dir(): raise RuntimeError(f"{dst} is not a directory")
+                shutil.rmtree(dst)
+            dst.mkdir(parents=True)
 
-        excludes = set()
-        for glob in exclude_globs:
-            excludes |= set(str(excluded.relative_to(src)) for excluded in src.rglob(glob) if str(excluded.relative_to(src)).startswith(glob.split(os.sep)[0]))
+            patcher.copy(dst)
+            patcher.apply(dst / config.module_source)
+            self.__success = False
+            return
 
-        patches = self.__root / "patches"
-        if not patches.exists(): raise RuntimeError(f"{patches} not exists")
-        elif not patches.is_dir(): raise RuntimeError(f"{patches} is not a directory")
+        patcher.resolve_src()
 
-        if str(module_name).startswith("src"):
-            module_name = module_name[4:]
-        dst = self.__root / "src" / module_name
+        dst = self.__dst = config.project_root / "src" / config.module_name
         if dst.exists():
             if not dst.is_dir(): raise RuntimeError(f"{dst} is not a directory")
             shutil.rmtree(dst)
         dst.mkdir(parents=True)
 
-        # Copy sources, skipping excludes
-        for src_file in src.rglob("*"):
-            if not src_file.is_file(): continue
-
-            rel = src_file.relative_to(src)
-            if str(rel) in excludes: continue
-
-            dst_file = dst / rel
-            dst_file.parent.mkdir(parents=True, exist_ok=True)
-            shutil.copy2(src_file, dst_file)
-
-        # Apply patches
-        for patch_file in sorted(patches.rglob("*.patch")):
-            rel_patch = patch_file.relative_to(patches)
-            # e.g. foo.py.patch → foo.py
-            target_rel = rel_patch.with_suffix("")
-            target = dst / target_rel
-
-            if not target.parent.exists():
-                target.parent.mkdir(parents=True, exist_ok=False)
-
-            result = subprocess.run(
-                ["patch", "--unified", str(target), str(patch_file)],
-                capture_output=True,
-                text=True,
-            )
-            if result.returncode != 0:
-                raise RuntimeError(f"Failed to apply {rel_patch}:\n{result.stderr}")
+        patcher.copy(dst)
+        self.__success = patcher.apply(dst)
 
+    @override
     def finalize(self, version: str, build_data: dict[str, Any], artifact_path: str) -> None:
-        module_source, _ = self.__config
-        if str(module_source).startswith("src"):
-            module_source = module_source[4:]
-        dst = self.__root / "src" / module_source
-        if dst.exists():
-            shutil.rmtree(dst)
+        if not self.__success:
+            return
+
+        if not self.__dst.exists() or not self.__dst.is_dir():
+            raise RuntimeError(f"{self.__dst} does not exists or is not a directory")
+        shutil.rmtree(self.__dst)

makepatch/scripts/__init__.py

@@ -0,0 +1,28 @@
+import shutil
+from pathlib import Path
+
+from makepatch._config import PatcherConfig
+from makepatch.core import PatchApplier
+
+if __debug__ and __import__("typing").TYPE_CHECKING:
+    from typing import Final
+
+
+from ._rebuild import rebuild_patches
+
+def init_patches():
+    root: Final = Path(__import__("os").getcwd())
+    config: Final = PatcherConfig.from_pyproject(root)
+    patcher: Final = PatchApplier(config)
+
+    patcher.resolve_sources()
+    patcher.resolve_src()
+
+    dst = root / "work" / "patched"
+    if dst.exists():
+        if not dst.is_dir(): raise RuntimeError(f"{dst} is not a directory")
+        shutil.rmtree(dst)
+    dst.mkdir(parents=True)
+
+    patcher.copy(dst)
+    exit(not patcher.apply(dst / config.module_source))

makepatch/scripts/_rebuild.py

@@ -0,0 +1,78 @@
+import os
+import re
+import subprocess
+
+from pathlib import Path
+
+from makepatch._config import PatcherConfig
+
+if __debug__ and __import__("typing").TYPE_CHECKING:
+    from typing import Final
+
+
+def rebuild_patches():
+    TIMESTAMP = re.compile(r"\t\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}.\d{9} \+\d{4}")
+    ARGS = (
+        "--ignore-trailing-space",
+        "--strip-trailing-cr",
+    )
+
+    root: Final = Path(os.getcwd())
+    config: Final = PatcherConfig.from_pyproject(root)
+
+    ref = root / "work/sources" / config.module_source
+    if not ref.exists() or not ref.is_dir():
+        raise RuntimeError(f"{ref} does not exists or is not a directory")
+
+    src = root / "work/patched" / config.module_source
+    if not ref.exists() or not ref.is_dir():
+        raise RuntimeError(f"{ref} does not exists or is not a directory")
+
+    patches = root / "patches"
+    if patches.exists():
+        if not patches.is_dir(): raise RuntimeError(f"{patches} is not a directory")
+        __import__("shutil").rmtree(patches)
+    patches.mkdir(parents=True)
+
+    excludes = set()
+    for glob in config.excludes:
+        dirname = glob.split(os.sep, 1)[0]
+        for excluded in src.rglob(glob):
+            if (rel_str := str(excluded.relative_to(src))).startswith(dirname):
+                excludes.add(rel_str)
+
+    generated = []
+    for target_file in sorted(src.rglob("*")):
+        if not target_file.is_file(): continue
+        if target_file.suffix == "pyc": continue
+        if (target_file.parent.name.startswith("__") and
+            target_file.parent.name.endswith("__")):
+            continue
+
+        rel_file = target_file.relative_to(src)
+        if str(rel_file) in excludes: continue
+
+        edited = target_file.relative_to(root)
+        origin = (ref / rel_file).relative_to(root)
+
+        result = subprocess.run(
+            ("diff", "--unified", *ARGS, "--new-file", str(origin), str(edited)),
+            capture_output=True,
+            text=True,
+        )
+        if result.returncode == 0:
+            continue
+        elif result.returncode != 1:
+            raise RuntimeError(f"Failed to generate a patch file for {edited} (return code {result.returncode}):"
+                               f"\n{result.stderr}")
+        else:
+            patch = patches / rel_file.with_suffix(rel_file.suffix + ".patch")
+            patch.parent.mkdir(parents=True, exist_ok=True)
+            with open(patch, "x") as f:
+                l = result.stdout.splitlines(keepends=True)
+                l[0] = TIMESTAMP.sub("", l[0])
+                l[1] = TIMESTAMP.sub("", l[1])
+                f.write(''.join(l))
+            generated.append(patch)
+    else:
+        print(f"Successfully generated {len(generated)} patches")

makepatch-0.2.0.dist-info/METADATA

@@ -0,0 +1,23 @@
+Metadata-Version: 2.4
+Name: makepatch
+Version: 0.2.0
+Summary: Hatch build hook to easily hard-fork packages with patches!
+Project-URL: source, https://github.com/AlphaKR93/packages/tree/main/python/makepatch
+Project-URL: issues, https://github.com/AlphaKR93/packages/issues
+Author-email: Alpha <dev@alpha93.kr>
+License-Expression: MIT
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Environment :: Plugins
+Classifier: Framework :: Hatch
+Classifier: Intended Audience :: Developers
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Topic :: Software Development :: Build Tools
+Requires-Python: >=3.12
+Requires-Dist: hatchling>=1.29.0
+Requires-Dist: pydantic>=2.13.0
+Requires-Dist: typing-extensions>=4.15.0; python_version < '3.15'

makepatch-0.2.0.dist-info/RECORD

@@ -0,0 +1,15 @@
+makepatch/__hooks__.py,sha256=Twwvsdvf5-wFb4aqUD9ApiTj_hpf_kOh_nedyX4a5yE,163
+makepatch/__init__.py,sha256=VGfjjIEpPnILrFlZqLzYhbUL6tqmhx1-e9uZOuVpQh4,86
+makepatch/_config.py,sha256=OA0SPKb8R5Q00cs6DwDu79kN6gW8vnDrKGvp6DCUfG8,2492
+makepatch/_types/__init__.pyi,sha256=SlDWSyq8IncNQKcgvjc9F7jyqKjTCSLW4HLTxgsSYcM,39
+makepatch/_types/hatch.pyi,sha256=MWAwNXZx1RXrdZ8sVLY8pinoOleSajjDatylnFsLprQ,1604
+makepatch/core/__init__.py,sha256=F943qvL-FwY0zkSuMxHuVzG55EVDICJYouAE1-3NrOU,36
+makepatch/core/_patcher.py,sha256=m5IsO66AC40i7rpHH1y5PE5VFW390svgZxA4SIw1930,4403
+makepatch/hooks/__init__.py,sha256=I7QNThkPOzPtvQiocyUoQKKdWNYWk5wiF-FVRz4LTjo,38
+makepatch/hooks/_patch.py,sha256=kSuzOjyeYTWEO457e5ikZI5RN8KGn22n5BVQEj1GOL8,1971
+makepatch/scripts/__init__.py,sha256=dggERiHtxr-wWJ6sHvfsfW3a9a3Io3CmNd7xvIC5AnY,769
+makepatch/scripts/_rebuild.py,sha256=iisw0dza8cr4o_FBvzcrNGmxeeje98XW2g6dHlJqsJ0,2810
+makepatch-0.2.0.dist-info/METADATA,sha256=Cp_Qi2UyIpNqoKsvTNebZNtXQT2XQrTIOgnmPZI_hRE,1003
+makepatch-0.2.0.dist-info/WHEEL,sha256=lCkmxWfQsSc9CfIClYeavTdQeEX2toPqufh9gI35EQA,87
+makepatch-0.2.0.dist-info/entry_points.txt,sha256=tDk_T8AJNcjy0KhBEXxf9wZBIAhv3l4pGekKOqXpNpY,159
+makepatch-0.2.0.dist-info/RECORD,,

{makepatch-0.0.1.dist-info → makepatch-0.2.0.dist-info}/WHEEL

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

makepatch-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,6 @@
+[console_scripts]
+apply-patches = makepatch.scripts:apply_patches
+rebuild-patches = makepatch.scripts:rebuild_patches
+
+[hatch]
+makepatch = makepatch.__hooks__

makepatch/__hook__.py

@@ -1,7 +0,0 @@
-from hatchling.plugin import hookimpl as _hook
-from src.clippy.hooks import ClippyPatchHook
-
-
-@_hook
-def __register_hatch_build_hooks():
-    return ClippyPatchHook

makepatch-0.0.1.dist-info/METADATA

@@ -1,8 +0,0 @@
-Metadata-Version: 2.3
-Name: makepatch
-Version: 0.0.1
-Summary: Hatch build hook to easily hard-fork packages with patches!
-Classifier: Framework :: Hatch
-Requires-Dist: hatchling>=1.29.0
-Requires-Dist: pydantic>=2.13.4
-Requires-Python: >=3.12

makepatch-0.0.1.dist-info/RECORD

@@ -1,10 +0,0 @@
-makepatch/__hook__.py,sha256=ov-ZExdRe2dhvnocD01_58Z37eBryz8sTaTAbFEHM-4,171
-makepatch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-makepatch/_config.py,sha256=GlyVVm9ZsolzDKSiupoTMTmOHVSNCMdyo-_AzArw3Wo,565
-makepatch/hooks/__init__.py,sha256=8JvonoGcrgihzhk7eUIwQPwr2oTL58IfF44tAk2vOYc,37
-makepatch/hooks/_patch.py,sha256=xjaKYDJkhekGfBomXOKH5pOiP209hNtt6G4kHv-kfQs,3335
-makepatch/scripts/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-makepatch-0.0.1.dist-info/WHEEL,sha256=fWriCkzqm-pffF5af4gJC9iI5FMFaJTuN9UxxxzOmdY,81
-makepatch-0.0.1.dist-info/entry_points.txt,sha256=8xpxWiGS9XHoBCcyoVcfkRfjW2WnvamePMfI3_WJsOs,141
-makepatch-0.0.1.dist-info/METADATA,sha256=2kQkR1g2KEOP011WEC73brgoEzEW_wM-HQsAhJbm6Q8,242
-makepatch-0.0.1.dist-info/RECORD,,

makepatch-0.0.1.dist-info/entry_points.txt

@@ -1,7 +0,0 @@
-[console_scripts]
-init = makepatch.scripts:init
-rebuild-patches = makepatch.scripts:rebuild_patches
-
-[hatch]
-makepatch = makepatch.__hook__
-