pymelos 0.1.3__py3-none-any.whl

pymelos/git/tags.py

@@ -0,0 +1,242 @@
+"""Git tag operations."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+from pymelos.git.repo import run_git_command
+
+
+@dataclass(frozen=True, slots=True)
+class Tag:
+    """Represents a git tag.
+
+    Attributes:
+        name: Tag name.
+        sha: Commit SHA the tag points to.
+        is_annotated: Whether this is an annotated tag.
+    """
+
+    name: str
+    sha: str
+    is_annotated: bool = False
+
+
+def list_tags(cwd: Path, pattern: str | None = None) -> list[Tag]:
+    """List all tags in the repository.
+
+    Args:
+        cwd: Working directory.
+        pattern: Optional glob pattern to filter tags.
+
+    Returns:
+        List of tags sorted by version (if semver) or name.
+    """
+    args = ["tag", "-l"]
+    if pattern:
+        args.append(pattern)
+
+    # Also get the commit SHA for each tag
+    args.extend(["--format=%(refname:short)%00%(objectname:short)%00%(objecttype)"])
+
+    result = run_git_command(args, cwd=cwd)
+
+    tags: list[Tag] = []
+    for line in result.stdout.strip().split("\n"):
+        if not line:
+            continue
+        parts = line.split("\x00")
+        if len(parts) >= 3:
+            name, sha, obj_type = parts[:3]
+            tags.append(
+                Tag(
+                    name=name,
+                    sha=sha,
+                    is_annotated=obj_type == "tag",
+                )
+            )
+
+    return tags
+
+
+def get_latest_tag(
+    cwd: Path,
+    pattern: str | None = None,
+    prefix: str | None = None,
+) -> Tag | None:
+    """Get the latest tag, optionally matching a pattern.
+
+    Args:
+        cwd: Working directory.
+        pattern: Glob pattern for tag names.
+        prefix: Tag prefix to filter by (e.g., "v" or "pkg-name@").
+
+    Returns:
+        Latest tag or None if no tags found.
+    """
+    # Use git describe to find the latest tag
+    args = ["describe", "--tags", "--abbrev=0"]
+    if pattern:
+        args.extend(["--match", pattern])
+
+    result = run_git_command(args, cwd=cwd, check=False)
+    if result.returncode != 0:
+        return None
+
+    tag_name = result.stdout.strip()
+    if not tag_name:
+        return None
+
+    if prefix and not tag_name.startswith(prefix):
+        return None
+
+    # Get the SHA
+    sha_result = run_git_command(["rev-parse", f"{tag_name}^{{commit}}"], cwd=cwd)
+    sha = sha_result.stdout.strip()
+
+    return Tag(name=tag_name, sha=sha)
+
+
+def get_tags_for_commit(cwd: Path, commit: str) -> list[Tag]:
+    """Get all tags pointing to a specific commit.
+
+    Args:
+        cwd: Working directory.
+        commit: Commit SHA.
+
+    Returns:
+        List of tags pointing to the commit.
+    """
+    result = run_git_command(["tag", "--points-at", commit], cwd=cwd)
+
+    tags: list[Tag] = []
+    for name in result.stdout.strip().split("\n"):
+        if name:
+            tags.append(Tag(name=name, sha=commit))
+
+    return tags
+
+
+def create_tag(
+    cwd: Path,
+    name: str,
+    message: str | None = None,
+    *,
+    commit: str | None = None,
+) -> Tag:
+    """Create a new git tag.
+
+    Args:
+        cwd: Working directory.
+        name: Tag name.
+        message: Tag message (creates annotated tag).
+        commit: Commit to tag. Defaults to HEAD.
+
+    Returns:
+        Created tag.
+    """
+    args = ["tag"]
+    if message:
+        args.extend(["-a", "-m", message])
+    args.append(name)
+    if commit:
+        args.append(commit)
+
+    run_git_command(args, cwd=cwd)
+
+    # Get the SHA
+    sha_result = run_git_command(["rev-parse", f"{name}^{{commit}}"], cwd=cwd)
+    sha = sha_result.stdout.strip()
+
+    return Tag(name=name, sha=sha, is_annotated=bool(message))
+
+
+def delete_tag(cwd: Path, name: str) -> None:
+    """Delete a git tag.
+
+    Args:
+        cwd: Working directory.
+        name: Tag name to delete.
+    """
+    run_git_command(["tag", "-d", name], cwd=cwd)
+
+
+# Pattern to extract version from various tag formats
+_VERSION_PATTERNS = [
+    re.compile(r"^v?(\d+\.\d+\.\d+.*)$"),  # v1.2.3 or 1.2.3
+    re.compile(r"^.+@(\d+\.\d+\.\d+.*)$"),  # pkg@1.2.3
+]
+
+
+def parse_version_from_tag(tag: str, prefix: str = "") -> str | None:
+    """Extract version string from a tag name.
+
+    Args:
+        tag: Tag name (e.g., "v1.2.3" or "pkg@1.2.3").
+        prefix: Expected prefix (e.g., "v" or "pkg@").
+
+    Returns:
+        Version string or None if not a version tag.
+    """
+    if prefix and tag.startswith(prefix):
+        return tag[len(prefix) :]
+
+    for pattern in _VERSION_PATTERNS:
+        if match := pattern.match(tag):
+            return match.group(1)
+
+    return None
+
+
+def get_package_tags(cwd: Path, package_name: str) -> list[Tag]:
+    """Get all tags for a specific package.
+
+    Uses the tag format: {package_name}@{version}
+
+    Args:
+        cwd: Working directory.
+        package_name: Package name.
+
+    Returns:
+        List of tags for the package.
+    """
+    pattern = f"{package_name}@*"
+    return list_tags(cwd, pattern=pattern)
+
+
+_SEMVER_PATTERN = re.compile(r"(\d+)\.(\d+)\.(\d+)(.*)?")
+
+
+def _parse_version_tuple(version: str | None, fallback: str) -> tuple[int, int, int, str]:
+    """Parse version string into sortable tuple."""
+    if not version:
+        return (0, 0, 0, fallback)
+
+    if match := _SEMVER_PATTERN.match(version):
+        major, minor, patch, rest = match.groups()
+        return (int(major), int(minor), int(patch), rest or "")
+
+    return (0, 0, 0, fallback)
+
+
+def get_latest_package_tag(cwd: Path, package_name: str) -> Tag | None:
+    """Get the latest tag for a specific package.
+
+    Args:
+        cwd: Working directory.
+        package_name: Package name.
+
+    Returns:
+        Latest tag for the package or None.
+    """
+    tags = get_package_tags(cwd, package_name)
+    if not tags:
+        return None
+
+    prefix = f"{package_name}@"
+    return max(
+        tags,
+        key=lambda t: _parse_version_tuple(parse_version_from_tag(t.name, prefix), t.name),
+    )

pymelos/types.py

@@ -0,0 +1,16 @@
+"""Common type definitions for pymelos."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TypeAlias
+
+# Path-related types
+PathLike: TypeAlias = str | Path
+
+# Filter types
+ScopePattern: TypeAlias = str  # Glob pattern like "core,api" or "*-lib"
+GitRef: TypeAlias = str  # Git reference like "main", "v1.0.0", "HEAD~5"
+
+# Package name type
+PackageName: TypeAlias = str

pymelos/uv/__init__.py

@@ -0,0 +1,44 @@
+"""uv CLI integration."""
+
+from pymelos.uv.client import (
+    check_uv_installed,
+    get_uv_executable,
+    get_uv_version,
+    run_uv,
+    run_uv_async,
+)
+from pymelos.uv.publish import (
+    build,
+    build_and_publish,
+    check_publishable,
+    publish,
+)
+from pymelos.uv.sync import (
+    add_dependency,
+    lock,
+    pip_list,
+    remove_dependency,
+    sync,
+    sync_async,
+)
+
+__all__ = [
+    # Client
+    "get_uv_executable",
+    "run_uv",
+    "run_uv_async",
+    "get_uv_version",
+    "check_uv_installed",
+    # Sync
+    "sync",
+    "sync_async",
+    "lock",
+    "add_dependency",
+    "remove_dependency",
+    "pip_list",
+    # Publish
+    "build",
+    "publish",
+    "build_and_publish",
+    "check_publishable",
+]

pymelos/uv/client.py

@@ -0,0 +1,167 @@
+"""uv CLI wrapper."""
+
+from __future__ import annotations
+
+import asyncio
+import os
+import subprocess
+from pathlib import Path
+
+from pymelos.errors import ExecutionError
+
+
+def get_uv_executable() -> str:
+    """Get the path to the uv executable.
+
+    Returns:
+        Path to uv executable.
+
+    Raises:
+        ExecutionError: If uv is not installed.
+    """
+    # Check if uv is in PATH
+    result = subprocess.run(
+        ["which", "uv"],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    if result.returncode == 0:
+        return result.stdout.strip()
+
+    # Check common locations
+    common_paths = [
+        Path.home() / ".cargo" / "bin" / "uv",
+        Path.home() / ".local" / "bin" / "uv",
+        Path("/usr/local/bin/uv"),
+    ]
+
+    for path in common_paths:
+        if path.exists():
+            return str(path)
+
+    raise ExecutionError(
+        "uv is not installed. Install it with: curl -LsSf https://astral.sh/uv/install.sh | sh"
+    )
+
+
+def run_uv(
+    args: list[str],
+    cwd: Path | None = None,
+    *,
+    env: dict[str, str] | None = None,
+    check: bool = True,
+) -> subprocess.CompletedProcess[str]:
+    """Run a uv command synchronously.
+
+    Args:
+        args: Command arguments (without 'uv').
+        cwd: Working directory.
+        env: Additional environment variables.
+        check: Raise on non-zero exit.
+
+    Returns:
+        Completed process.
+
+    Raises:
+        ExecutionError: If command fails and check is True.
+    """
+    uv = get_uv_executable()
+    cmd = [uv] + args
+
+    run_env = os.environ.copy()
+    if env:
+        run_env.update(env)
+
+    result = subprocess.run(
+        cmd,
+        cwd=cwd,
+        capture_output=True,
+        text=True,
+        env=run_env,
+        check=False,
+    )
+
+    if check and result.returncode != 0:
+        raise ExecutionError(
+            f"uv command failed: {' '.join(args)}\n{result.stderr}",
+            exit_code=result.returncode,
+            stderr=result.stderr,
+        )
+
+    return result
+
+
+async def run_uv_async(
+    args: list[str],
+    cwd: Path | None = None,
+    *,
+    env: dict[str, str] | None = None,
+    check: bool = True,
+) -> tuple[int, str, str]:
+    """Run a uv command asynchronously.
+
+    Args:
+        args: Command arguments (without 'uv').
+        cwd: Working directory.
+        env: Additional environment variables.
+        check: Raise on non-zero exit.
+
+    Returns:
+        Tuple of (exit_code, stdout, stderr).
+
+    Raises:
+        ExecutionError: If command fails and check is True.
+    """
+    uv = get_uv_executable()
+    cmd = [uv] + args
+
+    run_env = os.environ.copy()
+    if env:
+        run_env.update(env)
+
+    process = await asyncio.create_subprocess_exec(
+        *cmd,
+        cwd=cwd,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+        env=run_env,
+    )
+
+    stdout_bytes, stderr_bytes = await process.communicate()
+    stdout = stdout_bytes.decode("utf-8", errors="replace")
+    stderr = stderr_bytes.decode("utf-8", errors="replace")
+    exit_code = process.returncode or 0
+
+    if check and exit_code != 0:
+        raise ExecutionError(
+            f"uv command failed: {' '.join(args)}\n{stderr}",
+            exit_code=exit_code,
+            stderr=stderr,
+        )
+
+    return exit_code, stdout, stderr
+
+
+def get_uv_version() -> str:
+    """Get the installed uv version.
+
+    Returns:
+        Version string.
+    """
+    result = run_uv(["--version"])
+    # "uv 0.5.10" -> "0.5.10"
+    return result.stdout.strip().split()[-1]
+
+
+def check_uv_installed() -> bool:
+    """Check if uv is installed and accessible.
+
+    Returns:
+        True if uv is installed.
+    """
+    try:
+        get_uv_executable()
+        return True
+    except ExecutionError:
+        return False

pymelos/uv/publish.py

@@ -0,0 +1,162 @@
+"""uv build and publish operations."""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from pymelos.errors import PublishError
+from pymelos.uv.client import run_uv
+
+
+def build(
+    cwd: Path,
+    *,
+    sdist: bool = True,
+    wheel: bool = True,
+    out_dir: Path | None = None,
+) -> Path:
+    """Build package distributions.
+
+    Args:
+        cwd: Package directory.
+        sdist: Build source distribution.
+        wheel: Build wheel.
+        out_dir: Output directory (defaults to dist/).
+
+    Returns:
+        Path to dist directory.
+    """
+    args = ["build"]
+
+    if not sdist:
+        args.append("--no-sdist")
+    if not wheel:
+        args.append("--no-wheel")
+    if out_dir:
+        args.extend(["--out-dir", str(out_dir)])
+
+    run_uv(args, cwd=cwd)
+
+    return out_dir or (cwd / "dist")
+
+
+def publish(
+    cwd: Path,
+    *,
+    repository: str | None = None,
+    token: str | None = None,
+    username: str | None = None,
+    password: str | None = None,
+    dist_dir: Path | None = None,
+) -> None:
+    """Publish package to a registry.
+
+    Args:
+        cwd: Package directory.
+        repository: Repository URL.
+        token: API token for authentication.
+        username: Username for authentication.
+        password: Password for authentication.
+        dist_dir: Directory containing distributions.
+
+    Raises:
+        PublishError: If publish fails.
+    """
+    args = ["publish"]
+
+    if repository:
+        args.extend(["--publish-url", repository])
+    if token:
+        args.extend(["--token", token])
+    if username:
+        args.extend(["--username", username])
+    if password:
+        args.extend(["--password", password])
+
+    # Add distribution files
+    dist = dist_dir or (cwd / "dist")
+    if not dist.exists():
+        raise PublishError(
+            f"Distribution directory not found: {dist}. Run 'uv build' first.",
+            package_name=cwd.name,
+        )
+
+    # Find distribution files
+    dists = list(dist.glob("*.tar.gz")) + list(dist.glob("*.whl"))
+    if not dists:
+        raise PublishError(
+            f"No distributions found in {dist}",
+            package_name=cwd.name,
+        )
+
+    # Add all distribution files
+    args.extend(str(d) for d in dists)
+
+    try:
+        run_uv(args, cwd=cwd)
+    except Exception as e:
+        raise PublishError(str(e), package_name=cwd.name, registry=repository) from e
+
+
+def build_and_publish(
+    cwd: Path,
+    *,
+    repository: str | None = None,
+    token: str | None = None,
+    clean_first: bool = True,
+) -> None:
+    """Build and publish a package.
+
+    Args:
+        cwd: Package directory.
+        repository: Repository URL.
+        token: API token.
+        clean_first: Remove existing dist/ before building.
+    """
+    dist_dir = cwd / "dist"
+
+    if clean_first and dist_dir.exists():
+        import shutil
+
+        shutil.rmtree(dist_dir)
+
+    build(cwd)
+    publish(cwd, repository=repository, token=token, dist_dir=dist_dir)
+
+
+def check_publishable(cwd: Path) -> list[str]:
+    """Check if a package can be published.
+
+    Args:
+        cwd: Package directory.
+
+    Returns:
+        List of issues (empty if publishable).
+    """
+    issues: list[str] = []
+
+    pyproject = cwd / "pyproject.toml"
+    if not pyproject.exists():
+        issues.append("No pyproject.toml found")
+        return issues
+
+    from pymelos.compat import tomllib
+
+    with open(pyproject, "rb") as f:
+        data = tomllib.load(f)
+
+    project = data.get("project", {})
+
+    # Required fields for publishing
+    required = ["name", "version", "description"]
+    for field in required:
+        if not project.get(field):
+            issues.append(f"Missing required field: project.{field}")
+
+    # Recommended fields
+    if not project.get("readme"):
+        issues.append("Missing recommended field: project.readme")
+    if not project.get("license"):
+        issues.append("Missing recommended field: project.license")
+
+    return issues