Poetry Dynamic Versioning

import poetry_dynamic_versioning

from poetry_dynamic_versioning import (
    _get_version,
    _get_and_apply_version,
    _get_config_from_path,
    _validate_config
)

[tool.poetry-dynamic-versioning]
enable = true

[build-system]
requires = ["poetry-core>=1.0.0", "poetry-dynamic-versioning>=1.0.0,<2.0.0"]
build-backend = "poetry_dynamic_versioning.backend"

# Install plugin
poetry self add "poetry-dynamic-versioning[plugin]"

# Enable in project
poetry dynamic-versioning enable

# Apply versioning manually
poetry dynamic-versioning

# Show current version
poetry dynamic-versioning show

from poetry_dynamic_versioning import _get_version, _get_config_from_path
from pathlib import Path

# Get configuration for current project
config = _get_config_from_path()

# Get dynamic version
version_string, version_obj = _get_version(config)
print(f"Dynamic version: {version_string}")

# Apply version to project files
from poetry_dynamic_versioning import _get_and_apply_version
project_name = _get_and_apply_version(retain=True, force=True)

def _get_config(local: Mapping) -> _Config: ...
def _get_config_from_path(start: Optional[Path] = None) -> Mapping: ...
def _validate_config(config: Optional[Mapping] = None) -> Sequence[str]: ...
def _default_config() -> Mapping: ...

def _get_version(config: _Config, name: Optional[str] = None) -> Tuple[str, Version]: ...
def _get_version_from_file(config: _Config) -> Optional[str]: ...
def _get_override_version(name: Optional[str], env: Optional[Mapping] = None) -> Optional[str]: ...

def _get_and_apply_version(
    pyproject_path: Optional[Path] = None,
    retain: bool = False,
    force: bool = False,
    io: bool = True
) -> Optional[str]: ...
def _apply_version(
    name: str,
    version: str,
    instance: Version,
    config: _Config,
    pyproject_path: Path,
    mode: _Mode,
    retain: bool = False
) -> None: ...
def _revert_version(retain: bool = False) -> None: ...

class DynamicVersioningPlugin(ApplicationPlugin):
    def activate(self, application: Application) -> None: ...

class DynamicVersioningCommand(Command):
    def handle(self) -> int: ...

def activate() -> None: ...
def deactivate() -> None: ...

def main() -> None: ...
def enable() -> None: ...
def show() -> None: ...
def apply(*, standalone: bool) -> None: ...

# From poetry_dynamic_versioning.__main__ module
def main() -> None:
    """
    Main entry point for the poetry-dynamic-versioning console script.
    
    Parses command-line arguments, sets CLI mode, and dispatches to
    appropriate CLI functions. Handles exceptions and exits with
    appropriate error codes.
    
    Used when package is executed as: python -m poetry_dynamic_versioning
    """

# From poetry_dynamic_versioning.backend module
# Re-exports all poetry.core.masonry.api functionality with patching

def activate() -> None:
    """
    Activate build backend patching system.
    
    Automatically called when backend is loaded. Checks configuration,
    applies patches if enabled, and registers cleanup handlers.
    """

def deactivate() -> None:
    """
    Deactivate patches and restore original state.
    
    Called automatically on exit to ensure repository cleanliness
    after build operations complete.
    """

def _debug(message: str) -> None:
    """
    Print debug message to stderr if debug mode is enabled.
    
    Parameters:
    - message: Debug message to print
    
    Debug mode is controlled by POETRY_DYNAMIC_VERSIONING_DEBUG environment variable.
    """

def _run_cmd(command: str, codes: Sequence[int] = (0,)) -> Tuple[int, str]:
    """
    Execute shell command and return result.
    
    Parameters:
    - command: Shell command to execute
    - codes: Acceptable exit codes (defaults to [0])
    
    Returns:
    Tuple[int, str]: Exit code and combined stdout/stderr output
    
    Raises:
    - RuntimeError: If command exits with unacceptable code
    """

def _escape_branch(value: Optional[str]) -> Optional[str]:
    """
    Escape branch name for safe usage in version strings.
    
    Parameters:
    - value: Branch name to escape
    
    Returns:
    Optional[str]: Escaped branch name with non-alphanumeric characters removed
    """

def _format_timestamp(value: Optional[dt.datetime]) -> Optional[str]:
    """
    Format datetime as timestamp string.
    
    Parameters:
    - value: Datetime to format
    
    Returns:
    Optional[str]: Formatted timestamp string (YYYYMMDDHHMMSS)
    """

def _find_higher_file(*names: str, start: Optional[Path] = None) -> Optional[Path]:
    """
    Find file in current directory or parent directories.
    
    Parameters:
    - names: File names to search for
    - start: Starting directory (defaults to current directory)
    
    Returns:
    Optional[Path]: Path to first found file, or None if not found
    """

def _get_pyproject_path(start: Optional[Path] = None) -> Optional[Path]:
    """
    Find pyproject.toml file in directory tree.
    
    Parameters:
    - start: Starting directory (defaults to current directory)
    
    Returns:
    Optional[Path]: Path to pyproject.toml file, or None if not found
    """

def _get_pyproject_path_from_poetry(pyproject) -> Path:
    """
    Extract pyproject.toml path from Poetry instance.
    
    Parameters:
    - pyproject: Poetry pyproject instance
    
    Returns:
    Path: Path to pyproject.toml file
    
    Raises:
    - RuntimeError: Unable to determine path from Poetry instance
    """

class _Mode(Enum):
    Classic = "classic"
    Pep621 = "pep621"

class _ProjectState:
    def __init__(
        self,
        path: Path,
        original_version: Optional[str],
        version: str,
        mode: _Mode,
        dynamic_array: Optional[tomlkit.items.Array],
        substitutions: Optional[MutableMapping[Path, str]] = None,
    ) -> None: ...

class _State:
    def __init__(self) -> None: ...
    patched_core_poetry_create: bool
    cli_mode: bool
    projects: MutableMapping[str, _ProjectState]