pymelos 0.1.3__py3-none-any.whl

pymelos/versioning/semver.py

@@ -0,0 +1,249 @@
+"""Semantic versioning utilities."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from enum import Enum, auto
+
+
+class BumpType(Enum):
+    """Version bump types."""
+
+    MAJOR = auto()
+    MINOR = auto()
+    PATCH = auto()
+    NONE = auto()
+
+    def __gt__(self, other: BumpType) -> bool:
+        if not isinstance(other, BumpType):
+            return NotImplemented
+        # MAJOR > MINOR > PATCH > NONE
+        order = {BumpType.MAJOR: 3, BumpType.MINOR: 2, BumpType.PATCH: 1, BumpType.NONE: 0}
+        return order[self] > order[other]
+
+    def __lt__(self, other: BumpType) -> bool:
+        if not isinstance(other, BumpType):
+            return NotImplemented
+        return not (self > other or self == other)
+
+
+# SemVer regex pattern
+SEMVER_PATTERN = re.compile(
+    r"^(?P<major>0|[1-9]\d*)\.(?P<minor>0|[1-9]\d*)\.(?P<patch>0|[1-9]\d*)"
+    r"(?:-(?P<prerelease>(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*)"
+    r"(?:\.(?:0|[1-9]\d*|\d*[a-zA-Z-][0-9a-zA-Z-]*))*))?"
+    r"(?:\+(?P<build>[0-9a-zA-Z-]+(?:\.[0-9a-zA-Z-]+)*))?$"
+)
+
+
+@dataclass(frozen=True, slots=True)
+class Version:
+    """Semantic version representation.
+
+    Follows the Semantic Versioning 2.0.0 specification.
+    """
+
+    major: int
+    minor: int
+    patch: int
+    prerelease: str | None = None
+    build: str | None = None
+
+    @classmethod
+    def parse(cls, version_str: str) -> Version:
+        """Parse a version string.
+
+        Args:
+            version_str: Version string like "1.2.3" or "1.2.3-alpha.1+build.123".
+
+        Returns:
+            Parsed Version.
+
+        Raises:
+            ValueError: If the version string is invalid.
+        """
+        # Strip leading 'v' if present
+        if version_str.startswith("v"):
+            version_str = version_str[1:]
+
+        match = SEMVER_PATTERN.match(version_str)
+        if not match:
+            raise ValueError(f"Invalid semantic version: {version_str}")
+
+        return cls(
+            major=int(match.group("major")),
+            minor=int(match.group("minor")),
+            patch=int(match.group("patch")),
+            prerelease=match.group("prerelease"),
+            build=match.group("build"),
+        )
+
+    @classmethod
+    def from_parts(
+        cls,
+        major: int = 0,
+        minor: int = 0,
+        patch: int = 0,
+        prerelease: str | None = None,
+    ) -> Version:
+        """Create a version from parts."""
+        return cls(major=major, minor=minor, patch=patch, prerelease=prerelease)
+
+    def bump(
+        self,
+        bump_type: BumpType,
+        prerelease_tag: str | None = None,
+    ) -> Version:
+        """Return a new version with the specified bump applied.
+
+        Args:
+            bump_type: Type of version bump.
+            prerelease_tag: Prerelease identifier (e.g., "alpha", "beta", "rc").
+
+        Returns:
+            New bumped version.
+        """
+        if bump_type == BumpType.NONE:
+            return self
+
+        if bump_type == BumpType.MAJOR:
+            new_version = Version(self.major + 1, 0, 0)
+        elif bump_type == BumpType.MINOR:
+            new_version = Version(self.major, self.minor + 1, 0)
+        else:  # PATCH
+            new_version = Version(self.major, self.minor, self.patch + 1)
+
+        if prerelease_tag:
+            return Version(
+                new_version.major,
+                new_version.minor,
+                new_version.patch,
+                prerelease=f"{prerelease_tag}.1",
+            )
+
+        return new_version
+
+    def bump_prerelease(self, tag: str | None = None) -> Version:
+        """Bump the prerelease version.
+
+        Args:
+            tag: Prerelease tag (uses existing if not provided).
+
+        Returns:
+            New version with bumped prerelease.
+        """
+        if self.prerelease:
+            # Parse existing prerelease: "alpha.1" -> "alpha.2"
+            parts = self.prerelease.rsplit(".", 1)
+            if len(parts) == 2 and parts[1].isdigit():
+                new_pre = f"{parts[0]}.{int(parts[1]) + 1}"
+            else:
+                new_pre = f"{self.prerelease}.1"
+            return Version(self.major, self.minor, self.patch, prerelease=new_pre)
+        elif tag:
+            return Version(self.major, self.minor, self.patch, prerelease=f"{tag}.1")
+        else:
+            return self
+
+    @property
+    def is_prerelease(self) -> bool:
+        """Check if this is a prerelease version."""
+        return self.prerelease is not None
+
+    @property
+    def base_version(self) -> Version:
+        """Get the version without prerelease or build metadata."""
+        return Version(self.major, self.minor, self.patch)
+
+    def __str__(self) -> str:
+        """Convert to version string."""
+        version = f"{self.major}.{self.minor}.{self.patch}"
+        if self.prerelease:
+            version += f"-{self.prerelease}"
+        if self.build:
+            version += f"+{self.build}"
+        return version
+
+    def __lt__(self, other: Version) -> bool:
+        """Compare versions for sorting."""
+        if not isinstance(other, Version):
+            return NotImplemented
+
+        # Compare major.minor.patch
+        if (self.major, self.minor, self.patch) != (other.major, other.minor, other.patch):
+            return (self.major, self.minor, self.patch) < (other.major, other.minor, other.patch)
+
+        # Prerelease versions have lower precedence
+        if self.prerelease and not other.prerelease:
+            return True
+        if not self.prerelease and other.prerelease:
+            return False
+        if self.prerelease and other.prerelease:
+            return self._compare_prerelease(self.prerelease, other.prerelease) < 0
+
+        return False
+
+    @staticmethod
+    def _compare_prerelease(a: str, b: str) -> int:
+        """Compare prerelease identifiers."""
+        a_parts = a.split(".")
+        b_parts = b.split(".")
+
+        for a_part, b_part in zip(a_parts, b_parts, strict=False):
+            # Numeric identifiers have lower precedence than alphanumeric
+            a_is_num = a_part.isdigit()
+            b_is_num = b_part.isdigit()
+
+            if a_is_num and b_is_num:
+                diff = int(a_part) - int(b_part)
+                if diff != 0:
+                    return diff
+            elif a_is_num:
+                return -1
+            elif b_is_num:
+                return 1
+            else:
+                if a_part < b_part:
+                    return -1
+                if a_part > b_part:
+                    return 1
+
+        # Shorter prerelease has lower precedence
+        return len(a_parts) - len(b_parts)
+
+
+def is_valid_semver(version_str: str) -> bool:
+    """Check if a string is a valid semantic version.
+
+    Args:
+        version_str: Version string to check.
+
+    Returns:
+        True if valid semver.
+    """
+    try:
+        Version.parse(version_str)
+        return True
+    except ValueError:
+        return False
+
+
+def compare_versions(v1: str, v2: str) -> int:
+    """Compare two version strings.
+
+    Args:
+        v1: First version.
+        v2: Second version.
+
+    Returns:
+        -1 if v1 < v2, 0 if equal, 1 if v1 > v2.
+    """
+    ver1 = Version.parse(v1)
+    ver2 = Version.parse(v2)
+
+    if ver1 < ver2:
+        return -1
+    if ver2 < ver1:
+        return 1
+    return 0

pymelos/versioning/updater.py

@@ -0,0 +1,146 @@
+"""Version file updates."""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from pymelos.compat import tomllib
+
+
+def update_pyproject_version(path: Path, new_version: str) -> None:
+    """Update version in pyproject.toml.
+
+    Args:
+        path: Path to pyproject.toml.
+        new_version: New version string.
+    """
+    content = path.read_text(encoding="utf-8")
+
+    # Update version in [project] section
+    # Match: version = "x.y.z"
+    pattern = r'(version\s*=\s*["\'])[\d.]+(-[\w.]+)?(["\'])'
+    replacement = rf"\g<1>{new_version}\g<3>"
+
+    new_content = re.sub(pattern, replacement, content, count=1)
+
+    if new_content == content:
+        raise ValueError(f"Could not find version in {path}")
+
+    path.write_text(new_content, encoding="utf-8")
+
+
+def get_pyproject_version(path: Path) -> str:
+    """Get version from pyproject.toml.
+
+    Args:
+        path: Path to pyproject.toml.
+
+    Returns:
+        Version string.
+
+    Raises:
+        ValueError: If version not found.
+    """
+    with open(path, "rb") as f:
+        data = tomllib.load(f)
+
+    version = data.get("project", {}).get("version")
+    if not version:
+        raise ValueError(f"No version found in {path}")
+    return version
+
+
+def update_init_version(path: Path, new_version: str) -> bool:
+    """Update __version__ in __init__.py if it exists.
+
+    Args:
+        path: Path to __init__.py.
+        new_version: New version string.
+
+    Returns:
+        True if updated, False if no __version__ found.
+    """
+    if not path.exists():
+        return False
+
+    content = path.read_text(encoding="utf-8")
+
+    # Match: __version__ = "x.y.z"
+    pattern = r'(__version__\s*=\s*["\'])[\d.]+(-[\w.]+)?(["\'])'
+    replacement = rf"\g<1>{new_version}\g<3>"
+
+    new_content = re.sub(pattern, replacement, content)
+
+    if new_content == content:
+        return False
+
+    path.write_text(new_content, encoding="utf-8")
+    return True
+
+
+def find_version_files(package_path: Path) -> list[Path]:
+    """Find files that might contain version information.
+
+    Args:
+        package_path: Path to package directory.
+
+    Returns:
+        List of paths to version files.
+    """
+    files: list[Path] = []
+
+    # pyproject.toml
+    pyproject = package_path / "pyproject.toml"
+    if pyproject.exists():
+        files.append(pyproject)
+
+    # src/<package>/__init__.py
+    src_dir = package_path / "src"
+    if src_dir.is_dir():
+        for init_file in src_dir.glob("*/__init__.py"):
+            files.append(init_file)
+
+    # Direct __init__.py
+    for init_file in package_path.glob("*/__init__.py"):
+        if init_file.parent.name != "tests":
+            files.append(init_file)
+
+    return files
+
+
+def update_all_versions(
+    package_path: Path,
+    package_name: str,
+    new_version: str,
+) -> list[Path]:
+    """Update version in all relevant files.
+
+    Args:
+        package_path: Path to package directory.
+        package_name: Package name (for finding __init__.py).
+        new_version: New version string.
+
+    Returns:
+        List of files that were updated.
+    """
+    updated: list[Path] = []
+
+    # Update pyproject.toml
+    pyproject = package_path / "pyproject.toml"
+    if pyproject.exists():
+        update_pyproject_version(pyproject, new_version)
+        updated.append(pyproject)
+
+    # Update __init__.py files
+    # Try src/<package>/__init__.py first
+    src_init = package_path / "src" / package_name.replace("-", "_") / "__init__.py"
+    if update_init_version(src_init, new_version):
+        updated.append(src_init)
+
+    # Try <package>/__init__.py
+    direct_init = package_path / package_name.replace("-", "_") / "__init__.py"
+    if update_init_version(direct_init, new_version):
+        updated.append(direct_init)
+
+    return updated

pymelos/workspace/__init__.py

@@ -0,0 +1,33 @@
+"""Workspace discovery and management."""
+
+from pymelos.workspace.discovery import (
+    discover_packages,
+    expand_package_patterns,
+    find_package_at_path,
+    is_workspace_root,
+)
+from pymelos.workspace.graph import DependencyGraph
+from pymelos.workspace.package import (
+    Package,
+    get_package_name_from_path,
+    load_package,
+    parse_dependency_name,
+)
+from pymelos.workspace.workspace import Workspace
+
+__all__ = [
+    # Workspace
+    "Workspace",
+    # Package
+    "Package",
+    "load_package",
+    "parse_dependency_name",
+    "get_package_name_from_path",
+    # Graph
+    "DependencyGraph",
+    # Discovery
+    "discover_packages",
+    "expand_package_patterns",
+    "find_package_at_path",
+    "is_workspace_root",
+]

pymelos/workspace/discovery.py

@@ -0,0 +1,138 @@
+"""Workspace and package discovery."""
+
+from __future__ import annotations
+
+import fnmatch
+from pathlib import Path
+
+from pymelos.config import PyMelosConfig
+from pymelos.workspace.package import Package, get_package_name_from_path, load_package
+
+
+def expand_package_patterns(
+    root: Path,
+    patterns: list[str],
+    ignore_patterns: list[str] | None = None,
+) -> list[Path]:
+    """Expand glob patterns to find package directories.
+
+    Args:
+        root: Workspace root directory.
+        patterns: Glob patterns like ["packages/*", "libs/*"].
+        ignore_patterns: Patterns to exclude.
+
+    Returns:
+        List of paths to package directories (containing pyproject.toml).
+    """
+    ignore_patterns = ignore_patterns or []
+    package_paths: list[Path] = []
+
+    for pattern in patterns:
+        # Handle both relative and absolute patterns
+        base_pattern = pattern[1:] if pattern.startswith("/") else pattern
+
+        # Expand the glob pattern
+        for path in root.glob(base_pattern):
+            if not path.is_dir():
+                continue
+
+            # Check if it has a pyproject.toml
+            if not (path / "pyproject.toml").is_file():
+                continue
+
+            # Check ignore patterns
+            rel_path = path.relative_to(root)
+            rel_str = str(rel_path)
+
+            ignored = False
+            for ignore in ignore_patterns:
+                if fnmatch.fnmatch(rel_str, ignore) or fnmatch.fnmatch(path.name, ignore):
+                    ignored = True
+                    break
+
+            if not ignored:
+                package_paths.append(path)
+
+    # Remove duplicates while preserving order
+    seen: set[Path] = set()
+    unique_paths: list[Path] = []
+    for p in package_paths:
+        resolved = p.resolve()
+        if resolved not in seen:
+            seen.add(resolved)
+            unique_paths.append(resolved)
+
+    return sorted(unique_paths, key=lambda p: p.name)
+
+
+def discover_packages(
+    root: Path,
+    config: PyMelosConfig,
+) -> dict[str, Package]:
+    """Discover all packages in the workspace.
+
+    Args:
+        root: Workspace root directory.
+        config: Workspace configuration.
+
+    Returns:
+        Dictionary mapping package names to Package instances.
+    """
+    # First pass: find all package paths and their names
+    package_paths = expand_package_patterns(root, config.packages, config.ignore)
+
+    # Get all package names for workspace dependency detection
+    workspace_package_names: set[str] = set()
+    for path in package_paths:
+        name = get_package_name_from_path(path)
+        if name:
+            # Normalize name for comparison
+            workspace_package_names.add(name.lower().replace("-", "_"))
+
+    # Second pass: fully load all packages
+    packages: dict[str, Package] = {}
+    for path in package_paths:
+        package = load_package(path, workspace_package_names)
+        packages[package.name] = package
+
+    return packages
+
+
+def find_package_at_path(
+    root: Path,
+    config: PyMelosConfig,
+    target_path: Path,
+) -> Package | None:
+    """Find the package that contains a given path.
+
+    Args:
+        root: Workspace root directory.
+        config: Workspace configuration.
+        target_path: Path to search for.
+
+    Returns:
+        Package that contains the path, or None if not found.
+    """
+    target_path = target_path.resolve()
+    packages = discover_packages(root, config)
+
+    for package in packages.values():
+        try:
+            target_path.relative_to(package.path)
+            return package
+        except ValueError:
+            continue
+
+    return None
+
+
+def is_workspace_root(path: Path) -> bool:
+    """Check if a path is a workspace root (contains pymelos.yaml).
+
+    Args:
+        path: Path to check.
+
+    Returns:
+        True if path contains pymelos.yaml or pymelos.yml.
+    """
+    return (path / "pymelos.yaml").is_file() or (path / "pymelos.yml").is_file()