autopub 0.3.0__tar.gz → 1.0.0a1__tar.gz

{autopub-0.3.0 → autopub-1.0.0a1}/PKG-INFO

@@ -1,20 +1,19 @@
 Metadata-Version: 2.1
 Name: autopub
-Version: 0.3.0
+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.7,<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.7
 Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
@@ -27,8 +26,12 @@ 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
@@ -87,3 +90,4 @@ For systems such as Travis CI in which only one deployment step is permitted, th
 [Travis CI]: https://travis-ci.org
 [build]: https://pypa-build.readthedocs.io
 [Twine]: https://twine.readthedocs.io/
+

{autopub-0.3.0 → autopub-1.0.0a1}/README.md

@@ -51,4 +51,4 @@ For systems such as Travis CI in which only one deployment step is permitted, th
 [CircleCI]: https://circleci.com
 [Travis CI]: https://travis-ci.org
 [build]: https://pypa-build.readthedocs.io
-[Twine]: https://twine.readthedocs.io/
+[Twine]: https://twine.readthedocs.io/

autopub-1.0.0a1/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-1.0.0a1/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-1.0.0a1/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-1.0.0a1/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-1.0.0a1/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-1.0.0a1/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-1.0.0a1/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-1.0.0a1/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-1.0.0a1/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-1.0.0a1/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.3.0 → autopub-1.0.0a1}/pyproject.toml

@@ -1,8 +1,11 @@
+[project]
+requires-python = ">=3.8"
+
 [tool.poetry]
 name = "autopub"
-version = "0.3.0"
+version = "1.0.0-alpha.1"
 description = "Automatic package release upon pull request merge"
-authors = ["Justin Mayer <entroP@gmail.com>"]
+authors = ["Justin Mayer <entroP@gmail.com>", "Patrick Arminio <patrick.arminio@gmail.com>"]
 license = "AGPL-3.0"
 readme = "README.md"
 keywords = ["automatic", "packaging", "publish", "release", "version"]
@@ -18,17 +21,22 @@ classifiers = [
     "Topic :: System :: Systems Administration",
 ]
 
+
 [tool.poetry.urls]
 "Issue Tracker" = "https://github.com/autopub/autopub/issues"
 
 [tool.poetry.dependencies]
-python = "^3.7"
+python = "^3.8"
 tomlkit = ">= 0.5, < 2.0"
 githubrelease = {version = "^1.5.9", optional = true}
 httpx = {version = "=0.16.1", optional = true}
+typer = "^0.9.0"
+rich = "^12.5.1"
+python-frontmatter = "^1.0.0"
 build = "^0.10.0"
 twine = "^4.0.2"
 dunamai = "^1.17.0"
+time-machine = "^2.13.0"
 
 [tool.poetry.dev-dependencies]
 githubrelease = "^1.5"
@@ -43,18 +51,19 @@ myst-parser = "^0.15"
 Sphinx = "^4.2"
 
 # Linting
-black = {version = "^19.3b0", allow-prereleases = true}
-flake8 = "^3.8"
-flake8-black = "^0.2"
-flake8-bugbear = "^20.0"
-flake8-fixme = "^1.1"
-flake8-markdown = "^0.2.0"
+black = "23.3.0"
+mypy = "^0.971"
+pytest = "^7.1.2"
+pytest-httpserver = "^1.0.8"
 
 [tool.poetry.extras]
 github = ["githubrelease", "httpx"]
 
 [tool.poetry.scripts]
-autopub = "autopub.autopub:main"
+autopub = "autopub.cli:app"
+
+[tool.poetry.group.dev.dependencies]
+pytest-cov = "^4.1.0"
 
 [tool.autopub]
 project-name = "AutoPub"
@@ -62,6 +71,18 @@ git-username = "botpub"
 git-email = "botpub@autopub.rocks"
 append-github-contributor = true
 
+
+[tool.ruff]
+select = [
+  "I",
+  "E",
+  "F",
+  "UP",
+]
+exclude = ["typings"]
+force-exclude = true
+
+
 [build-system]
 requires = ["poetry-core>=1.0.0"]
 build-backend = "poetry.core.masonry.api"

autopub-0.3.0/autopub/autopub.py

@@ -1,83 +0,0 @@
-import argparse
-import os
-import sys
-
-sys.path.append(os.path.dirname(__file__))  # noqa
-
-from build_release import build_release
-from check_release import check_release
-from commit_release import git_commit_and_push
-from create_github_release import create_github_release
-from deploy_release import deploy_release
-from prepare_release import prepare_release
-from publish_release import publish_release
-
-
-def check(arguments):
-    check_release()
-
-
-def prepare(arguments):
-    prepare_release()
-
-
-def build(arguments):
-    build_release()
-
-
-def commit(arguments):
-    git_commit_and_push()
-
-
-def githubrelease(arguments):
-    create_github_release()
-
-
-def publish(arguments):
-    publish_release()
-
-
-def deploy(arguments):
-    deploy_release()
-
-
-def parse_arguments():
-    try:
-        version = __import__("pkg_resources").get_distribution("autopub").version
-    except Exception:
-        version = "unknown"
-
-    parser = argparse.ArgumentParser()
-    parser.add_argument("--version", action="version", version=version)
-
-    subparsers = parser.add_subparsers()
-
-    check_parser = subparsers.add_parser("check")
-    check_parser.set_defaults(func=check)
-
-    prepare_parser = subparsers.add_parser("prepare")
-    prepare_parser.set_defaults(func=prepare)
-
-    build_parser = subparsers.add_parser("build")
-    build_parser.set_defaults(func=build)
-
-    commit_parser = subparsers.add_parser("commit")
-    commit_parser.set_defaults(func=commit)
-
-    githubrelease_parser = subparsers.add_parser("githubrelease")
-    githubrelease_parser.set_defaults(func=githubrelease)
-
-    publish_parser = subparsers.add_parser("publish")
-    publish_parser.set_defaults(func=publish)
-
-    deploy_parser = subparsers.add_parser("deploy")
-    deploy_parser.set_defaults(func=deploy)
-
-    arguments = parser.parse_args()
-
-    return arguments
-
-
-def main():
-    arguments = parse_arguments()
-    arguments.func(arguments)

autopub-0.3.0/autopub/base.py

@@ -1,160 +0,0 @@
-import os
-import re
-import subprocess
-import sys
-from pathlib import Path
-
-from tomlkit import parse
-
-
-def dict_get(_dict, keys, default=None):
-    """Query nested dictionary with list of keys, returning None if not found."""
-    for key in keys:
-        if isinstance(_dict, dict):
-            _dict = _dict.get(key, default)
-        else:
-            return default
-    return _dict
-
-
-# Determine CI/CD environment
-
-if os.environ.get("CIRCLECI"):
-    CI_SYSTEM = "circleci"
-    CIRCLE_PROJECT_USERNAME = os.environ.get("CIRCLE_PROJECT_USERNAME")
-    CIRCLE_PROJECT_REPONAME = os.environ.get("CIRCLE_PROJECT_REPONAME")
-    REPO_SLUG = f"{CIRCLE_PROJECT_USERNAME}/{CIRCLE_PROJECT_REPONAME}"
-elif os.environ.get("GITHUB_ACTIONS") == "true":
-    CI_SYSTEM = "github"
-    REPO_SLUG = os.environ.get("GITHUB_REPOSITORY")
-elif os.environ.get("TRAVIS"):
-    CI_SYSTEM = "travis"
-    REPO_SLUG = os.environ.get("TRAVIS_REPO_SLUG")
-else:
-    CI_SYSTEM = os.environ.get("CI_SYSTEM", None)
-    REPO_SLUG = os.environ.get("REPO_SLUG", None)
-
-# Project root and file name configuration
-
-PROJECT_ROOT = os.environ.get("PROJECT_ROOT")
-PYPROJECT_FILE_NAME = os.environ.get("PYPROJECT_FILE_NAME", "pyproject.toml")
-
-if PROJECT_ROOT:
-    ROOT = Path(PROJECT_ROOT)
-else:
-    ROOT = Path(
-        subprocess.check_output(["git", "rev-parse", "--show-toplevel"])
-        .decode("ascii")
-        .strip()
-    )
-
-PYPROJECT_FILE = ROOT / PYPROJECT_FILE_NAME
-
-# Retrieve configuration from pyproject file
-
-if os.path.exists(PYPROJECT_FILE):
-    config = parse(open(PYPROJECT_FILE).read())
-else:
-    print(f"Could not find pyproject file at: {PYPROJECT_FILE}")
-    sys.exit(1)
-
-PROJECT_NAME = dict_get(config, ["tool", "autopub", "project-name"])
-if not PROJECT_NAME:
-    PROJECT_NAME = dict_get(config, ["tool", "poetry", "name"])
-if not PROJECT_NAME:
-    PROJECT_NAME = dict_get(config, ["project", "name"])
-if not PROJECT_NAME:
-    print(
-        "Could not determine project name. Under the pyproject file's "
-        '[tool.autopub] header, add:\nproject-name = "YourProjectName"'
-    )
-    sys.exit(1)
-
-RELEASE_FILE_NAME = dict_get(
-    config, ["tool", "autopub", "release-file"], default="RELEASE.md"
-)
-RELEASE_FILE = ROOT / RELEASE_FILE_NAME
-
-CHANGELOG_FILE_NAME = dict_get(
-    config, ["tool", "autopub", "changelog-file"], default="CHANGELOG.md"
-)
-CHANGELOG_FILE = ROOT / CHANGELOG_FILE_NAME
-
-CHANGELOG_HEADER = dict_get(
-    config, ["tool", "autopub", "changelog-header"], default="========="
-)
-
-VERSION_HEADER = dict_get(config, ["tool", "autopub", "version-header"], default="-")
-VERSION_STRINGS = dict_get(config, ["tool", "autopub", "version-strings"], default=[])
-
-TAG_PREFIX = dict_get(config, ["tool", "autopub", "tag-prefix"], default="")
-
-PYPI_URL = dict_get(config, ["tool", "autopub", "pypi-url"])
-
-# Git configuration
-
-GIT_USERNAME = dict_get(config, ["tool", "autopub", "git-username"])
-GIT_EMAIL = dict_get(config, ["tool", "autopub", "git-email"])
-
-# GitHub
-
-GITHUB_TOKEN = os.environ.get("GITHUB_TOKEN", None)
-APPEND_GITHUB_CONTRIBUTOR = dict_get(
-    config, ["tool", "autopub", "append-github-contributor"], False
-)
-
-
-def run_process(popenargs, encoding="utf-8", env=None):
-    if env is not None:
-        env = {**os.environ, **env}
-    try:
-        return subprocess.check_output(popenargs, encoding=encoding, env=env).strip()
-    except subprocess.CalledProcessError as e:
-        print(e.output, file=sys.stderr)
-        sys.exit(1)
-
-
-def git(popenargs):
-    # Do not decode ASCII for commit messages so emoji are preserved
-    return subprocess.check_output(["git", *popenargs])
-
-
-def check_exit_code(popenargs):
-    return subprocess.call(popenargs, shell=True)
-
-
-def get_project_version():
-    # Backwards compat: Try poetry first and then fall "back" to standards
-    version = dict_get(config, ["tool", "poetry", "version"])
-    if version is None:
-        return dict_get(config, ["project", "version"])
-    else:
-        return version
-
-
-def get_release_info():
-    RELEASE_TYPE_REGEX = re.compile(r"^[Rr]elease [Tt]ype: (major|minor|patch)$")
-
-    with open(RELEASE_FILE, "r") as f:
-        line = f.readline()
-        match = RELEASE_TYPE_REGEX.match(line)
-
-        if not match:
-            print(
-                "The RELEASE file should start with 'Release type' and "
-                "specify one of the following values: major, minor, or patch."
-            )
-            sys.exit(1)
-
-        type_ = match.group(1)
-        changelog = "".join([l for l in f.readlines()]).strip()
-
-    return type_, changelog
-
-
-def configure_git():
-    if not GIT_USERNAME or not GIT_EMAIL:
-        print("git-username and git-email must be defined in the pyproject file")
-        sys.exit(1)
-    git(["config", "user.name", GIT_USERNAME])
-    git(["config", "user.email", GIT_EMAIL])

autopub-0.3.0/autopub/build_release.py

@@ -1,14 +0,0 @@
-import os
-import sys
-
-sys.path.append(os.path.dirname(__file__))  # noqa
-
-from base import git, run_process
-
-
-def build_release():
-    env = None
-    if "SOURCE_DATE_EPOCH" not in os.environ:
-        ctime = git(["log", "-1", "--pretty=%ct"]).decode().strip()
-        env = {"SOURCE_DATE_EPOCH": ctime}
-    run_process([sys.executable, "-m", "build"], env=env)

autopub-0.3.0/autopub/check_release.py

@@ -1,19 +0,0 @@
-import os
-import sys
-
-sys.path.append(os.path.dirname(__file__))  # noqa
-
-from base import CI_SYSTEM, RELEASE_FILE, run_process
-
-
-def check_release():
-    needs_release = os.path.exists(RELEASE_FILE)
-    if not needs_release:
-        print("Not releasing a new version because there is no RELEASE file.")
-        if CI_SYSTEM == "circleci":
-            run_process(["circleci", "step", "halt"])
-        elif CI_SYSTEM == "travis":
-            sys.exit(1)
-    if CI_SYSTEM == "github":
-        with open(os.path.expandvars("$GITHUB_OUTPUT"), "a") as f:
-            f.write("autopub_release={}\n".format("true" if needs_release else "false"))

autopub-0.3.0/autopub/commit_release.py

@@ -1,33 +0,0 @@
-import os
-import sys
-
-sys.path.append(os.path.dirname(__file__))  # noqa
-
-from base import (
-    get_project_version,
-    git,
-    configure_git,
-    PROJECT_NAME,
-    PYPROJECT_FILE_NAME,
-    CHANGELOG_FILE_NAME,
-    RELEASE_FILE_NAME,
-    VERSION_STRINGS,
-)
-
-
-def git_commit_and_push():
-    configure_git()
-
-    version = get_project_version()
-
-    git(["add", PYPROJECT_FILE_NAME])
-    git(["add", CHANGELOG_FILE_NAME])
-
-    if VERSION_STRINGS:
-        for version_file in VERSION_STRINGS:
-            git(["add", version_file])
-
-    git(["rm", "--cached", RELEASE_FILE_NAME])
-
-    git(["commit", "-m", f"Release {PROJECT_NAME} {version}"])
-    git(["push", "origin", "HEAD"])

autopub-0.3.0/autopub/create_github_release.py

@@ -1,66 +0,0 @@
-import os
-import sys
-import time
-
-sys.path.append(os.path.dirname(__file__))  # noqa
-
-from base import (
-    run_process,
-    check_exit_code,
-    get_project_version,
-    configure_git,
-    PROJECT_NAME,
-    REPO_SLUG,
-    TAG_PREFIX,
-    get_release_info,
-)
-
-
-def create_github_release():
-    try:
-        from github_release import gh_release_create, gh_asset_upload
-    except ModuleNotFoundError:
-        print("Cannot create GitHub release due to missing dependency: github_release")
-        sys.exit(1)
-
-    configure_git()
-    version = get_project_version()
-    tag = f"{TAG_PREFIX}{version}"
-
-    if not version:
-        print("Unable to determine the current version")
-        sys.exit(1)
-
-    tag_exists = (
-        check_exit_code([f'git show-ref --tags --quiet --verify -- "refs/tags/{tag}"'])
-        == 0
-    )
-
-    if not tag_exists:
-        run_process(["git", "tag", tag])
-        run_process(["git", "push", "--tags"])
-
-    _, changelog = get_release_info()
-
-    gh_release_create(
-        REPO_SLUG,
-        tag,
-        publish=True,
-        name=f"{PROJECT_NAME} {version}",
-        body=changelog,
-    )
-
-    # give some time to the API to get updated
-    # not sure if this is the proper way to fix the issue
-    # ideally the githubrelease package shouldn't need
-    # to do another API call to get the release since it
-    # should be returned by the create API.
-    # anyway, this fix might be good enough for the time being
-
-    time.sleep(2)
-
-    gh_asset_upload(
-        REPO_SLUG,
-        tag,
-        pattern="dist/*",
-    )

autopub-0.3.0/autopub/deploy_release.py

@@ -1,18 +0,0 @@
-import os
-import sys
-
-sys.path.append(os.path.dirname(__file__))  # noqa
-
-from build_release import build_release
-from create_github_release import create_github_release
-from commit_release import git_commit_and_push
-from prepare_release import prepare_release
-from publish_release import publish_release
-
-
-def deploy_release():
-    prepare_release()
-    build_release()
-    git_commit_and_push()
-    create_github_release()
-    publish_release()

autopub-0.3.0/autopub/github_contributor.py

@@ -1,83 +0,0 @@
-import os
-import subprocess
-import sys
-
-sys.path.append(os.path.dirname(__file__))  # noqa
-
-from base import GITHUB_TOKEN, REPO_SLUG, APPEND_GITHUB_CONTRIBUTOR
-
-
-def append_github_contributor(file):
-    if not APPEND_GITHUB_CONTRIBUTOR:
-        return
-
-    try:
-        import httpx
-    except ModuleNotFoundError:
-        print("Cannot append the GitHub contributor due to missing dependency: httpx")
-        sys.exit(1)
-
-    org, repo = REPO_SLUG.split("/")
-    current_commit = (
-        subprocess.check_output(["git", "rev-parse", "HEAD"]).decode("ascii").strip()
-    )
-
-    response = httpx.post(
-        "https://api.github.com/graphql",
-        json={
-            "query": """query Contributor(
-                $owner: String!
-                $name: String!
-                $commit: GitObjectID!
-            ) {
-                repository(owner: $owner, name: $name) {
-                    object(oid: $commit) {
-                        __typename
-                        ... on Commit {
-                            associatedPullRequests(first: 1) {
-                                nodes {
-                                    number
-                                    author {
-                                        __typename
-                                        login
-                                        ... on User {
-                                            name
-                                        }
-                                    }
-                                }
-                            }
-                        }
-                    }
-                }
-            }""",
-            "variables": {"owner": org, "name": repo, "commit": current_commit},
-        },
-        headers={
-            "Content-Type": "application/json",
-            "Authorization": f"Bearer {GITHUB_TOKEN}",
-        },
-    )
-
-    payload = response.json()
-    commit = payload["data"]["repository"]["object"]
-
-    if not commit:
-        return
-
-    prs = commit["associatedPullRequests"]["nodes"]
-
-    if not prs:
-        return
-
-    pr = prs[0]
-
-    pr_number = pr["number"]
-    pr_author_username = pr["author"]["login"]
-    pr_author_fullname = pr["author"].get("name", "")
-
-    file.write("\n")
-    file.write("\n")
-    file.write(
-        f"Contributed by [{pr_author_fullname or pr_author_username}](https://github.com/{pr_author_username}) via [PR #{pr_number}](https://github.com/{REPO_SLUG}/pull/{pr_number}/)"
-    )
-    file.write("\n")

autopub-0.3.0/autopub/prepare_release.py

@@ -1,98 +0,0 @@
-import os
-import re
-import sys
-
-sys.path.append(os.path.dirname(__file__))  # noqa
-
-from datetime import datetime
-
-import tomlkit
-from base import (
-    CHANGELOG_FILE,
-    CHANGELOG_HEADER,
-    PYPROJECT_FILE,
-    ROOT,
-    VERSION_HEADER,
-    VERSION_STRINGS,
-    configure_git,
-    dict_get,
-    get_project_version,
-    get_release_info,
-)
-from dunamai import Version
-from github_contributor import append_github_contributor
-
-
-def update_version_strings(file_path, new_version):
-    version_regex = re.compile(r"(^_*?version_*?\s*=\s*['\"])(\d+\.\d+\.\d+)", re.M)
-    with open(file_path, "r+") as f:
-        content = f.read()
-        f.seek(0)
-        f.write(
-            re.sub(
-                version_regex,
-                lambda match: "{}{}".format(match.group(1), new_version),
-                content,
-            )
-        )
-        f.truncate()
-
-
-def prepare_release():
-    configure_git()
-
-    type_, release_changelog = get_release_info()
-
-    version = Version(get_project_version())
-    new_version = version.bump({"major": 0, "minor": 1, "patch": 2}[type_]).serialize()
-
-    with open(PYPROJECT_FILE, "r") as f:
-        config = tomlkit.load(f)
-
-    poetry = dict_get(config, ["tool", "poetry", "version"])
-    if poetry:
-        config["tool"]["poetry"]["version"] = new_version
-    else:
-        config["project"]["version"] = new_version
-
-    with open(PYPROJECT_FILE, "w") as f:
-        config = tomlkit.dump(config, f)
-
-    if VERSION_STRINGS:
-        for version_file in VERSION_STRINGS:
-            file_path = ROOT / version_file
-            update_version_strings(file_path, new_version)
-
-    current_date = datetime.utcnow().strftime("%Y-%m-%d")
-
-    old_changelog_data = ""
-    header = ""
-
-    if not CHANGELOG_FILE.is_file():
-        with open(CHANGELOG_FILE, "a+") as f:
-            f.write(f"CHANGELOG\n{CHANGELOG_HEADER}\n\n")
-
-    with open(CHANGELOG_FILE, "r") as f:
-        lines = f.readlines()
-
-    for index, line in enumerate(lines):
-        if CHANGELOG_HEADER != line.strip():
-            continue
-
-        old_changelog_data = lines[index + 1 :]
-        header = lines[: index + 1]
-        break
-
-    with open(CHANGELOG_FILE, "w") as f:
-        f.write("".join(header))
-
-        new_version_header = f"{new_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_changelog)
-        append_github_contributor(f)
-        f.write("\n")
-
-        f.write("".join(old_changelog_data))

autopub-0.3.0/autopub/publish_release.py

@@ -1,17 +0,0 @@
-import glob
-import os
-import sys
-
-sys.path.append(os.path.dirname(__file__))  # noqa
-
-from base import PYPI_URL, run_process
-
-
-def publish_release():
-    env = None
-    if PYPI_URL:
-        env = {"TWINE_REPOSITORY_URL": PYPI_URL}
-    dists = glob.glob("dist/*")
-    run_process(
-        [sys.executable, "-m", "twine", "upload", "--non-interactive", *dists], env=env
-    )