autopub 0.2.2__py3-none-any.whl → 1.0.0a1__py3-none-any.whl

autopub/__init__.py

@@ -0,0 +1,182 @@
+from __future__ import annotations
+
+import hashlib
+import json
+from collections.abc import Iterable
+from pathlib import Path
+
+import frontmatter
+
+from autopub.exceptions import (
+    ArtifactHashMismatch,
+    ArtifactNotFound,
+    AutopubException,
+    NoPackageManagerPluginFound,
+    ReleaseFileEmpty,
+    ReleaseFileNotFound,
+    ReleaseNotesEmpty,
+    ReleaseTypeInvalid,
+    ReleaseTypeMissing,
+)
+from autopub.plugins import AutopubPackageManagerPlugin, AutopubPlugin
+from autopub.types import ReleaseInfo
+
+
+class Autopub:
+    RELEASE_FILE_PATH = "RELEASE.md"
+
+    def __init__(self, plugins: Iterable[type[AutopubPlugin]] = ()) -> None:
+        self.plugins = [plugin_class() for plugin_class in plugins]
+
+    @property
+    def release_file(self) -> Path:
+        return Path.cwd() / self.RELEASE_FILE_PATH
+
+    @property
+    def release_notes(self) -> str:
+        return self.release_file.read_text()
+
+    @property
+    def release_file_hash(self) -> str:
+        return hashlib.sha256(self.release_notes.encode("utf-8")).hexdigest()
+
+    @property
+    def release_data_file(self) -> Path:
+        return Path(".autopub") / "release_data.json"
+
+    # TODO: typed dict
+    @property
+    def release_data(self) -> ReleaseInfo:
+        if not self.release_data_file.exists():
+            raise ArtifactNotFound()
+
+        release_data = json.loads(self.release_data_file.read_text())
+
+        if release_data["hash"] != self.release_file_hash:
+            raise ArtifactHashMismatch()
+
+        return ReleaseInfo(
+            release_type=release_data["release_type"],
+            release_notes=release_data["release_notes"],
+            additional_info=release_data["plugin_data"],
+        )
+
+    def check(self) -> ReleaseInfo:
+        release_file = Path(self.RELEASE_FILE_PATH)
+
+        if not release_file.exists():
+            raise ReleaseFileNotFound()
+
+        try:
+            release_info = self._validate_release_notes(self.release_notes)
+        except AutopubException as e:
+            for plugin in self.plugins:
+                plugin.on_release_notes_invalid(e)
+            raise
+
+        for plugin in self.plugins:
+            plugin.on_release_notes_valid(release_info)
+
+        self._write_artifact(release_info)
+
+        return release_info
+
+    def build(self) -> None:
+        if not any(
+            isinstance(plugin, AutopubPackageManagerPlugin) for plugin in self.plugins
+        ):
+            raise NoPackageManagerPluginFound()
+
+        for plugin in self.plugins:
+            if isinstance(plugin, AutopubPackageManagerPlugin):
+                plugin.build()
+
+    def prepare(self) -> None:
+        for plugin in self.plugins:
+            plugin.prepare(self.release_data)
+
+    def publish(self, repository: str | None = None) -> None:
+        # TODO: shall we put this in a function, to make it
+        # clear that we are triggering the logic to check the release file?
+        self.release_data
+
+        for plugin in self.plugins:
+            if isinstance(plugin, AutopubPackageManagerPlugin):
+                plugin.publish(repository=repository)
+
+    def _write_artifact(self, release_info: ReleaseInfo) -> None:
+        data = {
+            "hash": self.release_file_hash,
+            "release_type": release_info.release_type,
+            "release_notes": release_info.release_notes,
+            "plugin_data": {
+                key: value
+                for plugin in self.plugins
+                for key, value in plugin.data.items()
+            },
+        }
+
+        self.release_data_file.parent.mkdir(exist_ok=True)
+        self.release_data_file.write_text(json.dumps(data))
+
+    def _deprecated_load(self, release_notes: str) -> ReleaseInfo:
+        # supports loading of old release notes format, which is
+        # deprecated and will be removed in a future release
+        # and looks like this:
+        # Release type: patch
+        # release notes here.
+
+        try:
+            release_info, release_notes = release_notes.split("\n", 1)
+        except ValueError as e:
+            raise ReleaseTypeMissing() from e
+
+        release_info = release_info.lower()
+
+        if not release_info.startswith("release type:"):
+            raise ReleaseTypeMissing()
+
+        release_type = release_info.split(":", 1)[1].strip().lower()
+
+        return ReleaseInfo(
+            release_type=release_type, release_notes=release_notes.strip()
+        )
+
+    def _load_from_frontmatter(self, release_notes: str) -> ReleaseInfo:
+        # supports loading of new release notes format, which looks like this:
+        # ---
+        # release type: patch
+        # ---
+        # release notes here.
+
+        post = frontmatter.loads(release_notes)
+
+        data: dict[str, str] = post.to_dict()
+
+        release_type = data.pop("release type").lower()
+
+        if release_type not in ("major", "minor", "patch"):
+            raise ReleaseTypeInvalid(release_type)
+
+        if post.content.strip() == "":
+            raise ReleaseNotesEmpty()
+
+        return ReleaseInfo(
+            release_type=release_type,
+            release_notes=post.content,
+            additional_info=data,
+        )
+
+    def _validate_release_notes(self, release_notes: str) -> ReleaseInfo:
+        if not release_notes:
+            raise ReleaseFileEmpty()
+
+        try:
+            release_info = self._load_from_frontmatter(release_notes)
+        except KeyError:
+            release_info = self._deprecated_load(release_notes)
+
+        for plugin in self.plugins:
+            plugin.validate_release_notes(release_info)
+
+        return release_info

autopub/cli/__init__.py

@@ -0,0 +1,121 @@
+from typing import Optional, TypedDict
+
+import rich
+import typer
+from rich.console import Group
+from rich.markdown import Markdown
+from rich.padding import Padding
+from rich.panel import Panel
+from typing_extensions import Annotated
+
+from autopub import Autopub
+from autopub.cli.plugins import find_plugins
+from autopub.exceptions import AutopubException
+
+app = typer.Typer()
+
+
+class State(TypedDict):
+    plugins: list[str]
+
+
+state: State = {"plugins": []}
+
+
+@app.command()
+def check():
+    """This commands checks if the current PR has a valid release file."""
+
+    autopub = Autopub(plugins=find_plugins(state["plugins"]))
+
+    try:
+        release_info = autopub.check()
+    except AutopubException as e:
+        rich.print(Panel.fit(f"[red]{e.message}"))
+
+        raise typer.Exit(1) from e
+    else:
+        rich.print(
+            Padding(
+                Group(
+                    (
+                        "[bold on bright_magenta] Release type: [/] "
+                        f"[yellow italic underline]{release_info.release_type}[/]\n"
+                    ),
+                    "[bold on bright_magenta] Release notes: [/]\n",
+                    Markdown(release_info.release_notes),
+                    "\n---\n\n[green bold]Release file is valid![/] 🚀",
+                ),
+                (1, 1),
+            )
+        )
+
+
+@app.command()
+def build():
+    autopub = Autopub(plugins=find_plugins(state["plugins"]))
+
+    try:
+        autopub.build()
+    except AutopubException as e:
+        rich.print(Panel.fit(f"[red]{e.message}"))
+
+        raise typer.Exit(1) from e
+    else:
+        rich.print(Panel.fit("[green]Build succeeded"))
+
+
+@app.command()
+def prepare():
+    autopub = Autopub(plugins=find_plugins(state["plugins"]))
+
+    try:
+        autopub.prepare()
+    except AutopubException as e:
+        rich.print(Panel.fit(f"[red]{e.message}"))
+
+        raise typer.Exit(1) from e
+    else:
+        rich.print(Panel.fit("[green]Preparation succeeded"))
+
+
+@app.command()
+def publish(
+    repository: Annotated[
+        Optional[str],
+        typer.Option("--repository", "-r", help="Repository to publish to"),
+    ] = None,
+):
+    autopub = Autopub(plugins=find_plugins(state["plugins"]))
+
+    try:
+        autopub.publish(repository=repository)
+    except AutopubException as e:
+        rich.print(Panel.fit(f"[red]{e.message}"))
+
+        raise typer.Exit(1) from e
+    else:
+        rich.print(Panel.fit("[green]Publishing succeeded"))
+
+
+@app.callback(invoke_without_command=True)
+def main(
+    plugins: list[str] = typer.Option(
+        [],
+        "--plugin",
+        "-p",
+        help="List of plugins to use",
+    ),
+    should_show_version: Annotated[
+        Optional[bool], typer.Option("--version", is_eager=True)
+    ] = None,
+):
+    state["plugins"] = plugins
+    state["plugins"].extend(["bump_version"])
+
+    if should_show_version:
+        from importlib.metadata import version
+
+        print(version("autopub"))
+
+        raise typer.Exit()

autopub/cli/plugins.py

@@ -0,0 +1,37 @@
+from importlib import import_module
+
+from autopub.plugins import AutopubPlugin
+
+
+def _find_plugin(module: object) -> type[AutopubPlugin] | None:
+    for obj in module.__dict__.values():
+        if (
+            isinstance(obj, type)
+            and issubclass(obj, AutopubPlugin)
+            and obj is not AutopubPlugin
+        ):
+            return obj
+
+    return None
+
+
+def find_plugins(names: list[str]) -> list[type[AutopubPlugin]]:
+    plugins: list[type] = []
+
+    for plugin_name in names:
+        try:
+            # TODO: find plugins outside the autopub namespace
+            plugin_module = import_module(f"autopub.plugins.{plugin_name}")
+
+            plugin_class = _find_plugin(plugin_module)
+
+            if plugin_class is None:
+                print(f"Could not find plugin {plugin_name}")
+                # TODO: raise
+                continue
+
+            plugins.append(plugin_class)
+        except ImportError as e:
+            print(f"Error importing plugin {plugin_name}: {e}")
+
+    return plugins

autopub/exceptions.py

@@ -0,0 +1,47 @@
+class AutopubException(Exception):
+    message: str
+
+    def __init__(self) -> None:
+        super().__init__(self.message)
+
+
+class ReleaseFileNotFound(AutopubException):
+    message = "Release file not found"
+
+
+class ReleaseFileEmpty(AutopubException):
+    message = "Release file is empty"
+
+
+class ReleaseNotesEmpty(AutopubException):
+    message = "Release notes are empty"
+
+
+class ReleaseTypeMissing(AutopubException):
+    message: str = "Release note is missing release type"
+
+
+class ReleaseTypeInvalid(AutopubException):
+    def __init__(self, release_type: str):
+        self.message = f"Release type {release_type} is invalid"
+        super().__init__()
+
+
+class NoPackageManagerPluginFound(AutopubException):
+    message = "No package manager plugin found"
+
+
+class ArtifactNotFound(AutopubException):
+    message = "Artifact not found, did you run `autopub check`?"
+
+
+class ArtifactHashMismatch(AutopubException):
+    message = "Artifact hash mismatch, did you run `autopub check`?"
+
+
+class CommandFailed(AutopubException):
+    def __init__(self, command: list[str], returncode: int) -> None:
+        self.message = (
+            f"Command {' '.join(command)} failed with return code {returncode}"
+        )
+        super().__init__()

autopub/plugins/__init__.py

@@ -0,0 +1,40 @@
+from __future__ import annotations
+
+import subprocess
+from typing import Any, Protocol, runtime_checkable
+
+from autopub.exceptions import AutopubException, CommandFailed
+from autopub.types import ReleaseInfo
+
+
+class AutopubPlugin:
+    data: dict[str, object] = {}
+
+    def run_command(self, command: list[str]) -> None:
+        try:
+            subprocess.run(command, check=True)
+        except subprocess.CalledProcessError as e:
+            raise CommandFailed(command=command, returncode=e.returncode) from e
+
+    def prepare(self, release_info: ReleaseInfo) -> None:  # pragma: no cover
+        ...
+
+    def validate_release_notes(self, release_info: ReleaseInfo):  # pragma: no cover
+        ...
+
+    def on_release_notes_valid(self, release_info: ReleaseInfo):  # pragma: no cover
+        ...
+
+    def on_release_notes_invalid(self, exception: AutopubException):  # pragma: no cover
+        ...
+
+
+@runtime_checkable
+class AutopubPackageManagerPlugin(Protocol):
+    def build(self) -> None:  # pragma: no cover
+        ...
+
+    def publish(
+        self, repository: str | None = None, **kwargs: Any
+    ) -> None:  # pragma: no cover
+        ...

autopub/plugins/bump_version.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import pathlib
+
+import tomlkit
+from dunamai import Version
+
+from autopub.plugins import AutopubPlugin
+from autopub.types import ReleaseInfo
+
+
+class BumpVersionPlugin(AutopubPlugin):
+    @property
+    def pyproject_config(self) -> tomlkit.TOMLDocument:
+        content = pathlib.Path("pyproject.toml").read_text()
+
+        return tomlkit.parse(content)
+
+    def _get_version(self, config: tomlkit.TOMLDocument) -> str:
+        try:
+            return config["tool"]["poetry"]["version"]  # type: ignore
+        except KeyError:
+            return config["project"]["version"]  # type: ignore
+
+    def _update_version(self, config: tomlkit.TOMLDocument, new_version: str) -> None:
+        try:
+            config["tool"]["poetry"]["version"] = new_version  # type: ignore
+        except KeyError:
+            config["project"]["version"] = new_version  # type: ignore
+
+    def prepare(self, release_info: ReleaseInfo) -> None:
+        config = self.pyproject_config
+
+        version = Version(self._get_version(config))
+
+        bump_type = {"major": 0, "minor": 1, "patch": 2}[release_info.release_type]
+        new_version = version.bump(bump_type).serialize()
+
+        self._update_version(config, new_version)
+
+        pathlib.Path("pyproject.toml").write_text(tomlkit.dumps(config))  # type: ignore

autopub/plugins/pdm.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+from typing import Any
+
+from autopub.plugins import AutopubPackageManagerPlugin, AutopubPlugin
+
+
+class PDMPlugin(AutopubPlugin, AutopubPackageManagerPlugin):
+    def build(self) -> None:
+        self.run_command(["pdm", "build"])
+
+    def publish(self, repository: str | None = None, **kwargs: Any) -> None:
+        additional_args: list[str] = []
+
+        if repository:
+            additional_args += ["--repository", repository]
+
+        self.run_command(["pdm", "publish", *additional_args])

autopub/plugins/poetry.py

@@ -0,0 +1,16 @@
+from __future__ import annotations
+
+from autopub.plugins import AutopubPackageManagerPlugin, AutopubPlugin
+
+
+class PoetryPlugin(AutopubPlugin, AutopubPackageManagerPlugin):
+    def build(self) -> None:
+        self.run_command(["poetry", "build"])
+
+    def publish(self, repository: str | None = None, **kwargs: str) -> None:
+        additional_args: list[str] = []
+
+        if repository:
+            additional_args += ["--repository", repository]
+
+        self.run_command(["poetry", "publish", *additional_args])

autopub/plugins/update_changelog.py

@@ -0,0 +1,50 @@
+from __future__ import annotations
+
+from datetime import date
+from pathlib import Path
+
+from autopub.plugins import AutopubPlugin
+from autopub.types import ReleaseInfo
+
+# TODO: from config
+CHANGELOG_HEADER = "========="
+VERSION_HEADER = "-"
+
+
+class UpdateChangelogPlugin(AutopubPlugin):
+    @property
+    def changelog_file(self) -> Path:
+        return Path("CHANGELOG.md")
+
+    def post_prepare(self, release_info: ReleaseInfo) -> None:
+        assert release_info.version is not None
+
+        if not self.changelog_file.exists():
+            self.changelog_file.write_text(f"CHANGELOG\n{CHANGELOG_HEADER}\n\n")
+
+        current_date = date.today().strftime("%Y-%m-%d")
+
+        old_changelog_data = ""
+        header = ""
+
+        lines = self.changelog_file.read_text().splitlines()
+
+        for index, line in enumerate(lines):
+            if CHANGELOG_HEADER != line.strip():
+                continue
+
+            old_changelog_data = lines[index + 1 :]
+            header = lines[: index + 1]
+            break
+
+        with self.changelog_file.open("w") as f:
+            f.write("\n".join(header))
+            f.write("\n")
+
+            new_version_header = f"{release_info.version} - {current_date}"
+
+            f.write(f"\n{new_version_header}\n")
+            f.write(f"{VERSION_HEADER * len(new_version_header)}\n\n")
+            f.write(release_info.release_notes)
+            f.write("\n")
+            f.write("\n".join(old_changelog_data))

autopub/types.py

@@ -0,0 +1,11 @@
+import dataclasses
+
+
+@dataclasses.dataclass
+class ReleaseInfo:
+    """Release information."""
+
+    release_type: str
+    release_notes: str
+    additional_info: dict[str, str] = dataclasses.field(default_factory=dict)
+    version: str | None = None

{autopub-0.2.2.dist-info → autopub-1.0.0a1.dist-info}/METADATA

@@ -1,31 +1,37 @@
 Metadata-Version: 2.1
 Name: autopub
-Version: 0.2.2
+Version: 1.0.0a1
 Summary: Automatic package release upon pull request merge
 Home-page: https://github.com/autopub/autopub
 License: AGPL-3.0
 Keywords: automatic,packaging,publish,release,version
 Author: Justin Mayer
 Author-email: entroP@gmail.com
-Requires-Python: >=3.6,<4.0
+Requires-Python: >=3.8,<4.0
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: GNU Affero General Public License v3
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.6
-Classifier: Programming Language :: Python :: 3.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Software Distribution
 Classifier: Topic :: System :: Systems Administration
 Provides-Extra: github
-Requires-Dist: githubrelease (>=1.5.8,<2.0.0); extra == "github"
-Requires-Dist: httpx (==0.16.1); extra == "github"
+Requires-Dist: build (>=0.10.0,<0.11.0)
+Requires-Dist: dunamai (>=1.17.0,<2.0.0)
+Requires-Dist: githubrelease (>=1.5.9,<2.0.0) ; extra == "github"
+Requires-Dist: httpx (==0.16.1) ; extra == "github"
+Requires-Dist: python-frontmatter (>=1.0.0,<2.0.0)
+Requires-Dist: rich (>=12.5.1,<13.0.0)
+Requires-Dist: time-machine (>=2.13.0,<3.0.0)
 Requires-Dist: tomlkit (>=0.5,<2.0)
+Requires-Dist: twine (>=4.0.2,<5.0.0)
+Requires-Dist: typer (>=0.9.0,<0.10.0)
 Project-URL: Issue Tracker, https://github.com/autopub/autopub/issues
 Project-URL: Repository, https://github.com/autopub/autopub
 Description-Content-Type: text/markdown
@@ -38,7 +44,7 @@ AutoPub enables project maintainers to release new package versions to PyPI by m
 
 ## Environment
 
-AutoPub is intended for use with continuous integration (CI) systems such as [GitHub Actions][], [CircleCI][], or [Travis CI][]. Projects used with AutoPub can be published via [Poetry][] or [setuptools][]. Contributions that add support for other CI and build systems are welcome.
+AutoPub is intended for use with continuous integration (CI) systems such as [GitHub Actions][], [CircleCI][], or [Travis CI][]. Projects used with AutoPub are built via [build][] and published via [Twine][]. Contributions that add support for other CI and build systems are welcome.
 
 ## Configuration
 
@@ -82,6 +88,6 @@ For systems such as Travis CI in which only one deployment step is permitted, th
 [GitHub Actions]: https://github.com/features/actions
 [CircleCI]: https://circleci.com
 [Travis CI]: https://travis-ci.org
-[Poetry]: https://poetry.eustace.io
-[setuptools]: https://setuptools.readthedocs.io/
+[build]: https://pypa-build.readthedocs.io
+[Twine]: https://twine.readthedocs.io/
 

autopub-1.0.0a1.dist-info/RECORD

@@ -0,0 +1,15 @@
+autopub/__init__.py,sha256=zcNp8aJE_jo-D5xvDuWNZ-ZK6c67NqbTaKtwfGJWtZs,5576
+autopub/cli/__init__.py,sha256=XG1QVlKPv7svwFOcuosBzXr9AIy9xKDTuOPfI14dtBs,2980
+autopub/cli/plugins.py,sha256=x80BsIpY81o6rv3MJTH2oTAZkqnAYp3MkjUtpPfxGfI,1021
+autopub/exceptions.py,sha256=JYn8sIYWCedhtO3XfftZ0M5M_rAPxiGQ4MGbWUaTYwE,1243
+autopub/plugins/__init__.py,sha256=HtnCcxvZqTUC79vs5aVpNHenRCNuTPpz1gAu2OYkCzg,1153
+autopub/plugins/bump_version.py,sha256=p-_q80pJDCUy-fKhp-9_9HWTWC2pKe2lFJnimuHHH7w,1338
+autopub/plugins/pdm.py,sha256=Pczye06fKg8_HMJDkEfMXQyvao9rZ7sqzTHFd6lLEpU,532
+autopub/plugins/poetry.py,sha256=d2LvW9RI7ZB3reBOXbcp1mqWmzQ06Uyg_T-MxTvlSBg,517
+autopub/plugins/update_changelog.py,sha256=MmDBGFs6v8zPn3NCfUumpF8YODhg5x2AdjyTzgq5bYQ,1456
+autopub/types.py,sha256=FcRH4l27nrkQFUQrbAKxNzPPJfzg_0DExZYsCu9Jdzk,249
+autopub-1.0.0a1.dist-info/LICENSE,sha256=hIahDEOTzuHCU5J2nd07LWwkLW7Hko4UFO__ffsvB-8,34523
+autopub-1.0.0a1.dist-info/METADATA,sha256=hJImNEz5eaUoQoG1Ziu44EuCP5Wwjo-s9NBUiFWLiMk,3757
+autopub-1.0.0a1.dist-info/WHEEL,sha256=d2fvjOD7sXsVzChCqf0Ty0JbHKBaLYwDbGQDwQTnJ50,88
+autopub-1.0.0a1.dist-info/entry_points.txt,sha256=oeTav5NgCxif6mcZ_HeVGgGv5LzS4DwdI01nr4bO1IM,43
+autopub-1.0.0a1.dist-info/RECORD,,

{autopub-0.2.2.dist-info → autopub-1.0.0a1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.1.0b2
+Generator: poetry-core 1.7.0
 Root-Is-Purelib: true
 Tag: py3-none-any

autopub-1.0.0a1.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+autopub=autopub.cli:app
+