setuptools-git-versioning 2.0.0__py3-none-any.whl → 3.0.0__py3-none-any.whl

setuptools_git_versioning/__init__.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from setuptools_git_versioning.git import (
+    count_since,
+    get_all_tags,
+    get_branch,
+    get_branches,
+    get_latest_file_commit,
+    get_sha,
+    get_tag,
+    get_tags,
+    is_dirty,
+)
+from setuptools_git_versioning.setup import get_version, infer_version
+from setuptools_git_versioning.version import version_from_git
+
+if TYPE_CHECKING:
+    from setuptools.dist import Distribution
+
+
+def parse_config(dist: Distribution, attr: Any, value: Any) -> None:
+    "Dummy function used only to register in distutils"
+    return
+
+
+__all__ = [
+    "count_since",
+    "get_all_tags",
+    "get_branch",
+    "get_branches",
+    "get_latest_file_commit",
+    "get_sha",
+    "get_tag",
+    "get_tags",
+    "get_version",
+    "infer_version",
+    "is_dirty",
+    "version_from_git",
+]

setuptools_git_versioning/__main__.py

@@ -0,0 +1,3 @@
+from setuptools_git_versioning.cli import main
+
+main()

setuptools_git_versioning/cli.py

@@ -0,0 +1,36 @@
+import argparse
+import logging
+import sys
+
+from setuptools_git_versioning.log import DEBUG, LOG_FORMAT, VERBOSITY_LEVELS
+from setuptools_git_versioning.setup import get_version
+
+
+def get_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        prog="setuptools-git-versioning",
+        description="Get version based on git information and 'setup.py' or 'pyproject.toml' config",
+    )
+    parser.add_argument(
+        "root",
+        type=str,
+        default=None,
+        nargs="?",
+        help="Path to folder containing 'setup.py' or 'pyproject.toml' file. Default: current dir",
+    )
+    parser.add_argument(
+        "--verbose",
+        "-v",
+        action="count",
+        default=0,
+        help="Increase verbosity level. Can be used multiple times: -v for INFO messages, -vv for DEBUG",
+    )
+    return parser
+
+
+def main():
+    parser = get_parser()
+    namespace = parser.parse_args()
+    log_level = VERBOSITY_LEVELS.get(namespace.verbose, DEBUG)
+    logging.basicConfig(level=log_level, format=LOG_FORMAT, stream=sys.stderr)
+    print(str(get_version(root=namespace.root)))  # noqa: T201

setuptools_git_versioning/defaults.py

@@ -0,0 +1,26 @@
+from __future__ import annotations
+
+DEFAULT_TEMPLATE = "{tag}"
+DEFAULT_DEV_TEMPLATE = "{tag}.post{ccount}+git.{sha}"
+DEFAULT_DIRTY_TEMPLATE = "{tag}.post{ccount}+git.{sha}.dirty"
+DEFAULT_STARTING_VERSION = "0.0.1"
+DEFAULT_SORT_BY = "creatordate"
+DEFAULT_CONFIG = {
+    "template": DEFAULT_TEMPLATE,
+    "dev_template": DEFAULT_DEV_TEMPLATE,
+    "dirty_template": DEFAULT_DIRTY_TEMPLATE,
+    "starting_version": DEFAULT_STARTING_VERSION,
+    "version_callback": None,
+    "version_file": None,
+    "count_commits_from_version_file": False,
+    "tag_formatter": None,
+    "branch_formatter": None,
+    "tag_filter": None,
+    "sort_by": DEFAULT_SORT_BY,
+}
+
+
+def set_default_options(config: dict):
+    for key, value in DEFAULT_CONFIG.items():
+        config.setdefault(key, value)
+    return config

setuptools_git_versioning/factories.py

@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+import importlib
+import inspect
+import logging
+import os
+import re
+import sys
+from typing import Any, Callable
+
+from setuptools_git_versioning.log import DEBUG, INFO
+
+log = logging.getLogger(__name__)
+
+
+def add_to_sys_path(root: str | os.PathLike | None) -> None:
+    project_root = os.fspath(root) if root else os.getcwd()  # noqa: PTH109
+    if project_root not in sys.path:
+        log.log(DEBUG, "Adding '%s' folder to sys.path", project_root)
+        sys.path.insert(0, project_root)
+
+
+def import_reference(
+    ref: str,
+    package_name: str | None = None,
+    root: str | os.PathLike | None = None,
+) -> Any:
+    if ":" not in ref:
+        msg = f"Wrong reference name: {ref}"
+        raise NameError(msg)
+
+    add_to_sys_path(root)
+
+    module_name, attr = ref.split(":")
+    log.log(DEBUG, "Executing 'from %s.%s import %s'", package_name or "", module_name, attr)
+    module = importlib.import_module(module_name, package_name)
+
+    return getattr(module, attr)
+
+
+def load_callable(
+    inp: str,
+    package_name: str | None = None,
+    root: str | os.PathLike | None = None,
+) -> Callable:
+    ref = import_reference(inp, package_name, root=root)
+    if not callable(ref):
+        msg = f"{ref} of type {type(ref)} is not callable"
+        raise TypeError(msg)
+
+    return ref
+
+
+def _callable_factory(
+    callable_name: str,
+    regexp_or_ref: str | Callable,
+    callable_factory: Callable[[str], Callable],
+    package_name: str | None = None,
+    root: str | os.PathLike | None = None,
+) -> Callable:
+    log.log(INFO, "Parsing %s %r of type %r", callable_name, regexp_or_ref, type(regexp_or_ref).__name__)
+
+    if callable(regexp_or_ref):
+        log.log(DEBUG, "Value is callable with signature %s", inspect.Signature.from_callable(regexp_or_ref))
+        return regexp_or_ref
+
+    try:
+        return load_callable(regexp_or_ref, package_name, root=root)
+    except (ImportError, NameError) as e:
+        log.log(DEBUG, "%s is not a valid function reference: %s", callable_name, e)
+
+    try:
+        return callable_factory(regexp_or_ref)
+    except re.error as e:
+        log.exception("%s is not valid regexp neither a valid function reference", callable_name)
+        msg = f"Cannot parse {callable_name}"
+        raise ValueError(msg) from e
+
+
+def branch_formatter_factory(regexp: str) -> Callable[[str], str]:
+    pattern = re.compile(regexp)
+
+    def branch_formatter(branch: str) -> str:
+        match = pattern.match(branch)
+        if match:
+            return match.group("branch")
+
+        msg = f"Branch name {branch} does not match regexp '{regexp}'"
+        raise ValueError(msg)
+
+    return branch_formatter
+
+
+def create_branch_formatter(
+    branch_formatter: Callable[[str], str] | str,
+    package_name: str | None = None,
+    root: str | os.PathLike | None = None,
+):
+    return _callable_factory(
+        callable_name="branch_formatter",
+        regexp_or_ref=branch_formatter,
+        callable_factory=branch_formatter_factory,
+        package_name=package_name,
+        root=root,
+    )
+
+
+def tag_formatter_factory(regexp: str) -> Callable[[str], str]:
+    pattern = re.compile(regexp)
+
+    def tag_formatter(tag: str) -> str:
+        match = pattern.match(tag)
+        if match:
+            return match.group("tag")
+
+        msg = f"Tag name {tag} does not match regexp '{regexp}'"
+        raise ValueError(msg)
+
+    return tag_formatter
+
+
+def create_tag_formatter(
+    tag_formatter: Callable[[str], str] | str,
+    package_name: str | None = None,
+    root: str | os.PathLike | None = None,
+):
+    return _callable_factory(
+        callable_name="tag_formatter",
+        regexp_or_ref=tag_formatter,
+        callable_factory=tag_formatter_factory,
+        package_name=package_name,
+        root=root,
+    )
+
+
+def tag_filter_factory(regexp: str) -> Callable[[str], str | None]:
+    pattern = re.compile(regexp)
+
+    def tag_filter(tag: str) -> str | None:
+        match = pattern.match(tag)
+        if match:
+            log.info("Matched %s", tag)
+            return tag
+        return None
+
+    return tag_filter
+
+
+def create_tag_filter(
+    tag_filter: Callable[[str], str | None] | str,
+    package_name: str | None = None,
+    root: str | os.PathLike | None = None,
+):
+    return _callable_factory(
+        callable_name="tag_filter",
+        regexp_or_ref=tag_filter,
+        callable_factory=tag_filter_factory,
+        package_name=package_name,
+        root=root,
+    )

setuptools_git_versioning/git.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+import logging
+import os
+import subprocess  # nosec
+from contextlib import suppress
+from pathlib import Path
+from typing import Callable
+
+from setuptools_git_versioning.defaults import DEFAULT_SORT_BY
+from setuptools_git_versioning.log import DEBUG
+
+log = logging.getLogger(__name__)
+
+
+def _exec(*cmd: str, root: str | os.PathLike | None = None) -> list[str]:
+    log.log(DEBUG, "Executing %r at '%s'", cmd, root or Path.cwd())
+    try:
+        stdout = subprocess.check_output(cmd, text=True, cwd=root)  # noqa: S603
+    except subprocess.CalledProcessError as e:
+        stdout = e.output
+    lines = stdout.splitlines()
+    return [line.rstrip() for line in lines if line.rstrip()]
+
+
+def get_branches(root: str | os.PathLike | None = None) -> list[str]:
+    """Return list of branch names in the git repository"""
+    branches = _exec("git", "branch", "-l", "--format", "%(refname:short)", root=root)
+    return branches or []
+
+
+def get_branch(root: str | os.PathLike | None = None) -> str | None:
+    """Return branch name pointing to HEAD, or None"""
+    branches = _exec("git", "rev-parse", "--abbrev-ref", "HEAD", root=root)
+    return branches[0] if branches else None
+
+
+def get_all_tags(sort_by: str = DEFAULT_SORT_BY, root: str | os.PathLike | None = None) -> list[str]:
+    """Return list of tags in the git repository"""
+    tags = _exec("git", "tag", f"--sort=-{sort_by}", root=root)
+    return tags or []
+
+
+def get_tags(
+    sort_by: str = DEFAULT_SORT_BY,
+    filter_callback: Callable[[str], str | None] | None = None,
+    root: str | os.PathLike | None = None,
+) -> list[str]:
+    """Return list of tags merged into HEAD history tree"""
+    tags = _exec("git", "tag", f"--sort=-{sort_by}", "--merged", root=root)
+    if filter_callback:
+        # pull the tags that don't start with tag_prefix out of the list
+        return list(filter(filter_callback, tags))
+    return tags or []
+
+
+def get_tag(*args, **kwargs) -> str | None:
+    """Return latest tag merged into HEAD history tree"""
+    tags = get_tags(*args, **kwargs)
+    return tags[0] if tags else None
+
+
+def get_sha(name: str = "HEAD", root: str | os.PathLike | None = None) -> str | None:
+    """Get commit SHA-1 hash"""
+    sha = _exec("git", "rev-list", "-n", "1", name, root=root)
+    return sha[0] if sha else None
+
+
+def get_latest_file_commit(path: str | os.PathLike, root: str | os.PathLike | None = None) -> str | None:
+    """Get SHA-1 hash of latest commit of the file in the repository"""
+    sha = _exec("git", "log", "-n", "1", "--pretty=format:%H", "--", os.fspath(path), root=root)
+    return sha[0] if sha else None
+
+
+def is_dirty(root: str | os.PathLike | None = None) -> bool:
+    """Check index status, and return True if there are some uncommitted changes"""
+    res = _exec("git", "status", "--short", root=root)
+    return bool(res)
+
+
+def count_since(name: str, root: str | os.PathLike | None = None) -> int | None:
+    """Get number of commits between HEAD and the commit, or None if they are not related"""
+    res = _exec("git", "rev-list", "--count", "HEAD", f"^{name}", root=root)
+    if res:
+        with suppress(ValueError, TypeError):
+            return int(res[0])
+    return None

setuptools_git_versioning/log.py

@@ -0,0 +1,18 @@
+from __future__ import annotations
+
+import logging
+
+# setuptools v60.2.0 changed default logging level to DEBUG: https://github.com/pypa/setuptools/pull/2974
+# to avoid printing information messages to the same output as version number,
+# use a custom levels below built-in DEBUG level (10)
+INFO = 9
+DEBUG = 8
+logging.addLevelName(INFO, "INF0")
+logging.addLevelName(DEBUG, "DE8UG")
+VERBOSITY_LEVELS = {
+    0: logging.WARNING,
+    1: INFO,
+    2: DEBUG,
+}
+
+LOG_FORMAT = "[%(asctime)s] %(levelname)+8s: %(message)s"

setuptools_git_versioning/setup.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+import logging
+import os
+import sys
+import textwrap
+from pathlib import Path
+from pprint import pformat
+from typing import TYPE_CHECKING
+
+from setuptools_git_versioning.defaults import set_default_options
+from setuptools_git_versioning.factories import add_to_sys_path
+from setuptools_git_versioning.log import DEBUG, INFO
+from setuptools_git_versioning.version import version_from_git
+
+if TYPE_CHECKING:
+    # avoid importing 'packaging' because setuptools-git-versioning can be installed using sdist
+    # where 'packaging' is not installed yet
+    from packaging.version import Version
+    from setuptools.dist import Distribution
+
+log = logging.getLogger(__name__)
+
+
+def read_toml(name_or_path: str | os.PathLike = "pyproject.toml", root: str | os.PathLike | None = None) -> dict:
+    project_root = Path(root) if root else Path.cwd()
+    file_path = project_root.joinpath(name_or_path)
+    if not file_path.exists():
+        log.log(INFO, "'%s' does not exist", file_path)
+        return {}
+
+    if not file_path.is_file():
+        msg = f"'{file_path}' is not a file"
+        raise OSError(msg)
+
+    log.log(INFO, "Trying 'pyproject.toml' ...")
+    try:
+        # for Python 3.11+
+        import tomllib
+
+        with file_path.open("rb") as file:
+            parsed_file = tomllib.load(file)
+    except (ImportError, NameError):
+        import tomli
+
+        with file_path.open("rb") as file:
+            parsed_file = tomli.load(file)
+
+    result = parsed_file.get("tool", {}).get("setuptools-git-versioning", None)
+    if result:
+        log.log(DEBUG, "'tool.setuptools-git-versioning' section content:\n%s", pformat(result))
+    return result
+
+
+def infer_version(dist: Distribution, root: str | os.PathLike | None = None) -> Version | None:
+    log.log(INFO, "Trying 'setup.py' ...")
+
+    # see above
+    import setuptools  # isort: skip  # noqa: F401
+
+    from distutils.errors import DistutilsOptionError, DistutilsSetupError
+
+    config = getattr(dist, "setuptools_git_versioning", None)
+    toml_config = read_toml(root=root)
+
+    if config is None:
+        config = toml_config
+    elif toml_config:
+        msg = (
+            "Both 'setup.py' and 'pyproject.toml' have 'setuptools_git_versioning' config section. "
+            "Please remove one of them"
+        )
+        raise DistutilsSetupError(msg)
+
+    if config is None:
+        # Nothing to do here
+        return None
+
+    if not isinstance(config, dict):
+        msg = f"Wrong config format. Expected dict, got: {config}"
+        raise DistutilsOptionError(msg)
+
+    if not config or not config.pop("enabled", True):
+        # Nothing to do here
+        return None
+
+    set_default_options(config)
+
+    version = version_from_git(dist.metadata.name, **config, root=root)
+    dist.metadata.version = str(version)
+    return version
+
+
+def infer_setup_py(name_or_path: str = "setup.py", root: str | os.PathLike | None = None) -> Version | None:
+    project_root = Path(root) if root else Path.cwd()
+    setup_py_path = project_root.joinpath(name_or_path)
+    if not setup_py_path.exists():
+        log.log(INFO, "'%s' does not exist", setup_py_path)
+        return None
+
+    # because we use distutils in this file, we need to ensure that setuptools is
+    # imported first so that it can do monkey patching. this is not always already
+    # done for us, for example, when running this in a test or as a module
+    import setuptools  # isort: skip  # noqa: F401
+
+    from distutils.core import run_setup
+
+    # distutils does not change current directory, causing version of 'setuptools_git_versioning'
+    # is being get instead of target package.
+    # also some setup.py files can contain imports of other files from the package,
+    # and if they will be missing from sys.path, import will fail.
+    # emulating `python setup.py` call by modifying current dir and sys.path, but restore everything back after import
+    original_cwd = os.getcwd()  # noqa: PTH109
+    original_sys_path = sys.path.copy()
+    original_sys_modules = sys.modules.copy()
+    try:
+        add_to_sys_path(project_root)
+        os.chdir(project_root)
+        dist = run_setup(os.fspath(setup_py_path), stop_after="init")
+        return infer_version(dist, root=root)
+    finally:
+        sys.path[:] = original_sys_path
+        sys.modules = original_sys_modules
+        os.chdir(original_cwd)
+
+
+def get_version(config: dict | None = None, root: str | os.PathLike | None = None) -> Version:
+    if not config:
+        log.log(INFO, "No explicit config passed")
+        log.log(INFO, "Searching for config files in '%s' folder", root or Path.cwd())
+        result = infer_setup_py(root=root)
+        if result is not None:
+            return result
+
+        config = read_toml(root=root)
+
+    if not config or not config.pop("enabled", True):
+        raise RuntimeError(
+            textwrap.dedent(
+                f"""
+                'setuptools-git-versioning' command can be used only
+                with 'pyproject.toml' or 'setup.py' file present in folder '{root or Path.cwd()}',
+                containing the 'enabled: True' setting
+                (see https://setuptools-git-versioning.readthedocs.io/en/stable/install.html)
+                """,
+            ),
+        )
+
+    set_default_options(config)
+    return version_from_git(**config, root=root)

setuptools_git_versioning/subst.py

@@ -0,0 +1,71 @@
+from __future__ import annotations
+
+import logging
+import os
+import re
+from datetime import datetime, timezone
+from pprint import pformat
+
+from setuptools_git_versioning.log import DEBUG
+
+ENV_VARS_REGEXP = re.compile(r"\{env:(?P<name>[^:}]+):?(?P<default>[^}]+\}*)?\}", re.IGNORECASE | re.UNICODE)
+TIMESTAMP_REGEXP = re.compile(r"\{timestamp:?(?P<fmt>[^:}]+)?\}", re.IGNORECASE | re.UNICODE)
+
+log = logging.getLogger(__name__)
+
+
+def substitute_env_variables(template: str) -> str:
+    log.log(DEBUG, "Substitute environment variables in template %r", template)
+    for var, default_value in ENV_VARS_REGEXP.findall(template):
+        log.log(DEBUG, "Variable: %r", var)
+
+        default = default_value
+        if default_value.upper() == "IGNORE":
+            default = ""
+        elif not default_value:
+            default = "UNKNOWN"
+        log.log(DEBUG, "Default: %r", default)
+
+        value = os.environ.get(var, default)
+        log.log(DEBUG, "Value: %r", value)
+
+        template, _ = ENV_VARS_REGEXP.subn(value, template, count=1)
+
+    log.log(DEBUG, "Result: %r", template)
+    return template
+
+
+def substitute_timestamp(template: str) -> str:
+    log.log(DEBUG, "Substitute timestamps in template %r", template)
+
+    now = datetime.now(tz=timezone.utc).astimezone()
+    for fmt in TIMESTAMP_REGEXP.findall(template):
+        format_string = fmt or "%s"
+        log.log(DEBUG, "Format: %r", format_string)
+
+        result = now.strftime(format_string)
+        log.log(DEBUG, "Value: %r", result)
+
+        template, _ = TIMESTAMP_REGEXP.subn(result, template, count=1)
+
+    log.log(DEBUG, "Result: %r", template)
+    return template
+
+
+def resolve_substitutions(template: str, *args, **kwargs) -> str:
+    log.log(DEBUG, "Template: %r", template)
+    log.log(DEBUG, "Args:%s", pformat(args))
+
+    while True:
+        if "{env" in template:
+            new_template = substitute_env_variables(template)
+            if new_template == template:
+                break
+            template = new_template
+        else:
+            break
+
+    if "{timestamp" in template:
+        template = substitute_timestamp(template)
+
+    return template.format(*args, **kwargs)