tessl/pypi-dunamai

Dynamic version generation from version control system tags supporting multiple VCS and versioning standards.

—

Pending

Overview

Eval results

Files

VCS Integration

Name: tessl/pypi-dunamai
Author: tessl

Extract version information from version control systems with support for Git, Mercurial, Darcs, Subversion, Bazaar, Fossil, and Pijul.

Capabilities

Auto-Detection

Automatically detect the version control system and extract version information from the current repository.

@classmethod
def from_any_vcs(
    cls,
    pattern: Union[str, Pattern] = Pattern.Default,
    latest_tag: bool = False,
    tag_dir: str = "tags",
    tag_branch: Optional[str] = None,
    full_commit: bool = False,
    strict: bool = False,
    path: Optional[Path] = None,
    pattern_prefix: Optional[str] = None,
    ignore_untracked: bool = False,
    commit_length: Optional[int] = None,
) -> "Version"

Parameters:

pattern: Regular expression or Pattern enum for parsing tags
latest_tag: Use the latest tag by date instead of the latest by version
tag_dir: Directory containing tags (for Subversion)
tag_branch: Limit search to specific branch (for Git)
full_commit: Include full commit hash instead of abbreviated
strict: Raise exception if no tags found
path: Repository path (defaults to current directory)
pattern_prefix: Additional prefix for pattern matching
ignore_untracked: Ignore untracked files when determining dirty state
commit_length: Length of commit hash to use

Usage Examples:

from dunamai import Version, Pattern
from pathlib import Path

# Auto-detect VCS in current directory
version = Version.from_any_vcs()
print(version.serialize())  # e.g., "1.2.3.post7.dev0+g29045e8"

# Auto-detect with custom options
version = Version.from_any_vcs(
    pattern=Pattern.DefaultUnprefixed,
    full_commit=True,
    strict=True
)

# Auto-detect in specific directory
version = Version.from_any_vcs(path=Path("/path/to/repo"))

# Use latest tag by date instead of version
version = Version.from_any_vcs(latest_tag=True)

Git Integration

Extract version information specifically from Git repositories with Git-specific options.

@classmethod
def from_git(
    cls,
    pattern: Union[str, Pattern] = Pattern.Default,
    latest_tag: bool = False,
    tag_branch: Optional[str] = None,
    full_commit: bool = False,
    strict: bool = False,
    path: Optional[Path] = None,
    pattern_prefix: Optional[str] = None,
    ignore_untracked: bool = False,
    commit_length: Optional[int] = None,
) -> "Version"

Git-Specific Parameters:

tag_branch: Only consider tags reachable from this branch
ignore_untracked: Don't consider untracked files when determining dirty state

Usage Examples:

from dunamai import Version

# Basic Git version extraction
version = Version.from_git()

# Git with branch filtering
version = Version.from_git(tag_branch="main")

# Git ignoring untracked files
version = Version.from_git(ignore_untracked=True)

# Git with full commit hash
version = Version.from_git(full_commit=True, commit_length=40)

# Git with custom tag pattern
version = Version.from_git(
    pattern=r"^release-(?P<base>\d+\.\d+\.\d+)$",
    pattern_prefix="release-"
)

Mercurial Integration

Extract version information from Mercurial repositories.

@classmethod
def from_mercurial(
    cls,
    pattern: Union[str, Pattern] = Pattern.Default,
    latest_tag: bool = False,
    full_commit: bool = False,
    strict: bool = False,
    path: Optional[Path] = None,
    pattern_prefix: Optional[str] = None,
    commit_length: Optional[int] = None,
) -> "Version"

Usage Examples:

from dunamai import Version

# Basic Mercurial version extraction
version = Version.from_mercurial()

# Mercurial with custom commit length
version = Version.from_mercurial(commit_length=12)

Darcs Integration

Extract version information from Darcs repositories.

@classmethod
def from_darcs(
    cls,
    pattern: Union[str, Pattern] = Pattern.Default,
    latest_tag: bool = False,
    strict: bool = False,
    path: Optional[Path] = None,
    pattern_prefix: Optional[str] = None,
    commit_length: Optional[int] = None,
) -> "Version"

Usage Examples:

from dunamai import Version

# Basic Darcs version extraction
version = Version.from_darcs()

# Darcs with strict mode
version = Version.from_darcs(strict=True)

Subversion Integration

Extract version information from Subversion repositories with tag directory support.

@classmethod
def from_subversion(
    cls,
    pattern: Union[str, Pattern] = Pattern.Default,
    latest_tag: bool = False,
    tag_dir: str = "tags",
    strict: bool = False,
    path: Optional[Path] = None,
    pattern_prefix: Optional[str] = None,
    commit_length: Optional[int] = None,
) -> "Version"

Subversion-Specific Parameters:

tag_dir: Directory containing tags (default: "tags")

Usage Examples:

from dunamai import Version

# Basic Subversion version extraction
version = Version.from_subversion()

# Subversion with custom tag directory
version = Version.from_subversion(tag_dir="releases")

Bazaar Integration

Extract version information from Bazaar repositories.

@classmethod
def from_bazaar(
    cls,
    pattern: Union[str, Pattern] = Pattern.Default,
    latest_tag: bool = False,
    strict: bool = False,
    path: Optional[Path] = None,
    pattern_prefix: Optional[str] = None,
    commit_length: Optional[int] = None,
) -> "Version"

Usage Examples:

from dunamai import Version

# Basic Bazaar version extraction
version = Version.from_bazaar()

Fossil Integration

Extract version information from Fossil repositories.

@classmethod
def from_fossil(
    cls,
    pattern: Union[str, Pattern] = Pattern.Default,
    latest_tag: bool = False,
    strict: bool = False,
    path: Optional[Path] = None,
    pattern_prefix: Optional[str] = None,
    commit_length: Optional[int] = None,
) -> "Version"

Usage Examples:

from dunamai import Version

# Basic Fossil version extraction
version = Version.from_fossil()

Pijul Integration

Extract version information from Pijul repositories.

@classmethod
def from_pijul(
    cls,
    pattern: Union[str, Pattern] = Pattern.Default,
    latest_tag: bool = False,
    strict: bool = False,
    path: Optional[Path] = None,
    pattern_prefix: Optional[str] = None,
    commit_length: Optional[int] = None,
) -> "Version"

Usage Examples:

from dunamai import Version

# Basic Pijul version extraction
version = Version.from_pijul()

Explicit VCS Selection

Use a specific VCS type instead of auto-detection.

@classmethod
def from_vcs(
    cls,
    vcs: Vcs,
    pattern: Union[str, Pattern] = Pattern.Default,
    latest_tag: bool = False,
    tag_dir: str = "tags",
    tag_branch: Optional[str] = None,
    full_commit: bool = False,
    strict: bool = False,
    path: Optional[Path] = None,
    pattern_prefix: Optional[str] = None,
    ignore_untracked: bool = False,
    commit_length: Optional[int] = None,
) -> "Version"

Usage Examples:

from dunamai import Version, Vcs

# Explicitly use Git
version = Version.from_vcs(Vcs.Git)

# Explicitly use Mercurial with options
version = Version.from_vcs(
    Vcs.Mercurial,
    full_commit=True,
    strict=True
)

Common Patterns

Repository Detection

from dunamai import Version
from pathlib import Path

# Try multiple paths
paths = [Path("."), Path("../"), Path("/some/repo")]
for path in paths:
    try:
        version = Version.from_any_vcs(path=path, strict=True)
        print(f"Found version {version} in {path}")
        break
    except Exception as e:
        print(f"No version found in {path}: {e}")

Fallback Strategy

from dunamai import Version, Vcs

# Try specific VCS first, fall back to auto-detection
try:
    version = Version.from_git(strict=True)
except:
    try:
        version = Version.from_any_vcs(strict=True)
    except:
        version = Version("0.0.0")  # Ultimate fallback

Custom Tag Patterns

from dunamai import Version

# Custom pattern for release tags like "release-1.2.3"
version = Version.from_any_vcs(
    pattern=r"^release-(?P<base>\d+\.\d+\.\d+)(-(?P<stage>\w+)\.(?P<revision>\d+))?$"
)

# Pattern for tags with metadata like "v1.2.3+linux"
version = Version.from_any_vcs(
    pattern=r"^v(?P<base>\d+\.\d+\.\d+)(\+(?P<tagged_metadata>.+))?$"
)

Install with Tessl CLI