autopub 0.3.0__py3-none-any.whl → 0.4.0__py3-none-any.whl

autopub/base copy.py

@@ -0,0 +1,159 @@
+import os
+import re
+import subprocess
+
+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_WORKFLOW"):
+    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:
+    raise SystemExit(f"Could not find pyproject file at: {PYPROJECT_FILE}")
+
+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:
+    raise SystemExit(
+        "Could not determine project name. Under the pyproject file's "
+        '[tool.autopub] header, add:\nproject-name = "YourProjectName"'
+    )
+
+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"])
+
+BUILD_SYSTEM = dict_get(config, ["tool", "autopub", "build-system"])
+if not BUILD_SYSTEM:
+    build_requires = dict_get(config, ["build-system", "requires"])
+    if "poetry" in build_requires:
+        BUILD_SYSTEM = "poetry"
+    elif "setuptools" in build_requires:
+        BUILD_SYSTEM = "setuptools"
+
+# 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"):
+    return subprocess.check_output(popenargs).decode(encoding).strip()
+
+
+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():
+    VERSION_REGEX = re.compile(r"^version\s*=\s*\"(?P<version>\d+\.\d+\.\d+)\"$")
+
+    with open(PYPROJECT_FILE) as f:
+        for line in f:
+            match = VERSION_REGEX.match(line)
+
+            if match:
+                return match.group("version")
+
+    return None
+
+
+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:
+            raise SystemExit(
+                "The RELEASE file should start with 'Release type' and "
+                "specify one of the following values: major, minor, or patch."
+            )
+
+        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:
+        raise SystemExit("git-username and git-email must be defined in the pyproject file")
+    git(["config", "user.name", GIT_USERNAME])
+    git(["config", "user.email", GIT_EMAIL])

autopub/create_github_release.py

@@ -5,20 +5,20 @@ 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,
+    check_exit_code,
+    configure_git,
+    get_project_version,
     get_release_info,
+    run_process,
 )
 
 
 def create_github_release():
     try:
-        from github_release import gh_release_create, gh_asset_upload
+        from .vendor.github_release import gh_asset_upload, gh_release_create
     except ModuleNotFoundError:
         print("Cannot create GitHub release due to missing dependency: github_release")
         sys.exit(1)

autopub/prepare_release copy.py

@@ -0,0 +1,119 @@
+import os
+import re
+import sys
+
+sys.path.append(os.path.dirname(__file__))  # noqa
+
+from datetime import datetime
+
+from base import (
+    configure_git,
+    get_release_info,
+    run_process,
+    CHANGELOG_FILE,
+    CHANGELOG_HEADER,
+    ROOT,
+    VERSION_HEADER,
+    VERSION_STRINGS,
+)
+
+
+def find_existing_changelog_files():
+    changelogs = []
+    changelog_paths = [ROOT, ROOT / "docs"]
+    changelog_names = ["CHANGELOG", "CHANGES", "HISTORY"]
+    changelog_extensions = ["", ".md", ".markdown", ".mdown", ".mkd", ".rst", ".txt"]
+    for path in changelog_paths:
+        for name in changelog_names:
+            for ext in changelog_extensions:
+                changelog = path / f"{name}{ext}"
+                if changelog.is_file():
+                    changelogs.append(changelog)
+    if len(changelogs) > 0:
+        print(f"Specified changelog file not found: {CHANGELOG_FILE}")
+        print("Maybe set 'changelog-file' setting to discovered existing file:\n")
+        for changelog in changelogs:
+            print(f"{changelog}\n")
+        sys.exit(1)
+
+
+def validate_release():
+    if not CHANGELOG_FILE.is_file():
+        find_existing_changelog_files()
+
+    if not os.environ.get("PYPI_PASSWORD"):
+        print("PYPI_PASSWORD environment variable is not set.")
+        sys.exit(1)
+
+
+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()
+    validate_release()
+
+    POETRY_DUMP_VERSION_OUTPUT = re.compile(
+        r"Bumping version from \d+\.\d+\.\d+ to (?P<version>\d+\.\d+\.\d+)"
+    )
+
+    release_type, release_changelog = get_release_info()
+
+    output = run_process(["poetry", "version", release_type])
+    version_match = POETRY_DUMP_VERSION_OUTPUT.match(output)
+
+    if not version_match:
+        print("Unable to bump the project version using Poetry")
+        sys.exit(1)
+
+    new_version = version_match.group("version")
+
+    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)
+        f.write("\n")
+
+        f.write("".join(old_changelog_data))