pymelos 0.1.3__py3-none-any.whl

pymelos/workspace/graph.py

@@ -0,0 +1,238 @@
+"""Dependency graph building and topological sorting."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from dataclasses import dataclass, field
+from graphlib import CycleError, TopologicalSorter
+
+from pymelos.errors import CyclicDependencyError
+from pymelos.workspace.package import Package
+
+
+@dataclass
+class DependencyGraph:
+    """Package dependency graph with topological ordering support.
+
+    Attributes:
+        packages: Dictionary of package name to Package.
+        _sorter: Cached TopologicalSorter instance.
+    """
+
+    packages: dict[str, Package]
+    _edges: dict[str, set[str]] = field(default_factory=dict, init=False)
+    _reverse_edges: dict[str, set[str]] = field(default_factory=dict, init=False)
+
+    def __post_init__(self) -> None:
+        """Build the dependency edges."""
+        # Initialize edge sets
+        for name in self.packages:
+            self._edges[name] = set()
+            self._reverse_edges[name] = set()
+
+        # Build edges: package -> its workspace dependencies
+        for name, package in self.packages.items():
+            for dep in package.workspace_dependencies:
+                # Normalize and check if dependency exists in workspace
+                normalized_dep = dep.lower().replace("-", "_")
+                for pkg_name in self.packages:
+                    if pkg_name.lower().replace("-", "_") == normalized_dep:
+                        self._edges[name].add(pkg_name)
+                        self._reverse_edges[pkg_name].add(name)
+                        break
+
+    @property
+    def roots(self) -> list[Package]:
+        """Get packages with no dependencies (leaf nodes)."""
+        return [self.packages[name] for name, deps in self._edges.items() if not deps]
+
+    @property
+    def leaves(self) -> list[Package]:
+        """Get packages that nothing depends on (top-level packages)."""
+        return [
+            self.packages[name]
+            for name, dependents in self._reverse_edges.items()
+            if not dependents
+        ]
+
+    def get_dependencies(self, name: str) -> list[Package]:
+        """Get direct dependencies of a package.
+
+        Args:
+            name: Package name.
+
+        Returns:
+            List of packages this package depends on.
+        """
+        deps = self._edges.get(name, set())
+        return [self.packages[d] for d in deps if d in self.packages]
+
+    def get_dependents(self, name: str) -> list[Package]:
+        """Get packages that depend on this package.
+
+        Args:
+            name: Package name.
+
+        Returns:
+            List of packages that depend on this package.
+        """
+        deps = self._reverse_edges.get(name, set())
+        return [self.packages[d] for d in deps if d in self.packages]
+
+    def get_transitive_dependencies(self, name: str) -> list[Package]:
+        """Get all transitive dependencies of a package.
+
+        Args:
+            name: Package name.
+
+        Returns:
+            List of all packages this package transitively depends on.
+        """
+        result: set[str] = set()
+        stack = list(self._edges.get(name, set()))
+
+        while stack:
+            dep = stack.pop()
+            if dep not in result:
+                result.add(dep)
+                stack.extend(self._edges.get(dep, set()))
+
+        return [self.packages[d] for d in result if d in self.packages]
+
+    def get_transitive_dependents(self, name: str) -> list[Package]:
+        """Get all packages that transitively depend on this package.
+
+        Args:
+            name: Package name.
+
+        Returns:
+            List of all packages that transitively depend on this package.
+        """
+        result: set[str] = set()
+        stack = list(self._reverse_edges.get(name, set()))
+
+        while stack:
+            dep = stack.pop()
+            if dep not in result:
+                result.add(dep)
+                stack.extend(self._reverse_edges.get(dep, set()))
+
+        return [self.packages[d] for d in result if d in self.packages]
+
+    def get_affected_packages(self, changed: set[str]) -> list[Package]:
+        """Get all packages affected by changes to the given packages.
+
+        This includes the changed packages themselves plus all their
+        transitive dependents.
+
+        Args:
+            changed: Set of changed package names.
+
+        Returns:
+            List of all affected packages.
+        """
+        affected: set[str] = set(changed)
+
+        for name in changed:
+            if name in self.packages:
+                dependents = self.get_transitive_dependents(name)
+                affected.update(p.name for p in dependents)
+
+        return [self.packages[n] for n in affected if n in self.packages]
+
+    def topological_order(self) -> Iterator[Package]:
+        """Iterate packages in topological order (dependencies first).
+
+        Yields:
+            Packages in dependency order.
+
+        Raises:
+            CyclicDependencyError: If a cycle is detected.
+        """
+        sorter: TopologicalSorter[str] = TopologicalSorter()
+
+        for name, deps in self._edges.items():
+            sorter.add(name, *deps)
+
+        try:
+            sorter.prepare()
+        except CycleError as e:
+            # Extract cycle from error
+            cycle = list(e.args[1]) if len(e.args) > 1 else []
+            raise CyclicDependencyError(cycle) from e
+
+        while sorter.is_active():
+            for name in sorter.get_ready():
+                yield self.packages[name]
+                sorter.done(name)
+
+    def parallel_batches(self) -> Iterator[list[Package]]:
+        """Iterate packages in batches that can be executed in parallel.
+
+        Each batch contains packages that can run concurrently because their
+        dependencies are all satisfied.
+
+        Yields:
+            Lists of packages that can run in parallel.
+
+        Raises:
+            CyclicDependencyError: If a cycle is detected.
+        """
+        sorter: TopologicalSorter[str] = TopologicalSorter()
+
+        for name, deps in self._edges.items():
+            sorter.add(name, *deps)
+
+        try:
+            sorter.prepare()
+        except CycleError as e:
+            cycle = list(e.args[1]) if len(e.args) > 1 else []
+            raise CyclicDependencyError(cycle) from e
+
+        while sorter.is_active():
+            ready = list(sorter.get_ready())
+            if ready:
+                yield [self.packages[name] for name in ready]
+                for name in ready:
+                    sorter.done(name)
+
+    def reverse_topological_order(self) -> Iterator[Package]:
+        """Iterate packages in reverse topological order (dependents first).
+
+        Useful for operations like cleaning that should process dependents
+        before their dependencies.
+
+        Yields:
+            Packages in reverse dependency order.
+        """
+        # Collect in list and reverse
+        ordered = list(self.topological_order())
+        yield from reversed(ordered)
+
+    def subgraph(self, names: set[str]) -> DependencyGraph:
+        """Create a subgraph containing only the specified packages.
+
+        Args:
+            names: Set of package names to include.
+
+        Returns:
+            New DependencyGraph with only the specified packages.
+        """
+        filtered_packages = {name: pkg for name, pkg in self.packages.items() if name in names}
+        return DependencyGraph(packages=filtered_packages)
+
+    def to_dict(self) -> dict[str, list[str]]:
+        """Convert graph to adjacency list representation.
+
+        Returns:
+            Dictionary mapping package names to their dependency names.
+        """
+        return {name: sorted(deps) for name, deps in self._edges.items()}
+
+    def __len__(self) -> int:
+        """Number of packages in the graph."""
+        return len(self.packages)
+
+    def __contains__(self, name: str) -> bool:
+        """Check if a package is in the graph."""
+        return name in self.packages

pymelos/workspace/package.py

@@ -0,0 +1,191 @@
+"""Package model and metadata extraction."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from pymelos.compat import tomllib
+from pymelos.errors import ConfigurationError
+
+
+@dataclass(frozen=True, slots=True)
+class Package:
+    """Represents a package in the monorepo.
+
+    Attributes:
+        name: Package name from pyproject.toml.
+        path: Absolute path to the package directory.
+        version: Package version string.
+        description: Package description.
+        dependencies: Set of runtime dependency package names.
+        dev_dependencies: Set of dev dependency package names.
+        workspace_dependencies: Set of local workspace package names this depends on.
+        scripts: Package-level scripts from pyproject.toml.
+    """
+
+    name: str
+    path: Path
+    version: str
+    description: str | None = None
+    dependencies: frozenset[str] = field(default_factory=frozenset)
+    dev_dependencies: frozenset[str] = field(default_factory=frozenset)
+    workspace_dependencies: frozenset[str] = field(default_factory=frozenset)
+    scripts: dict[str, str] = field(default_factory=dict)
+
+    @property
+    def pyproject_path(self) -> Path:
+        """Path to the package's pyproject.toml."""
+        return self.path / "pyproject.toml"
+
+    @property
+    def src_path(self) -> Path:
+        """Path to the package's src directory."""
+        return self.path / "src"
+
+    @property
+    def tests_path(self) -> Path:
+        """Path to the package's tests directory."""
+        return self.path / "tests"
+
+    def has_dependency(self, name: str) -> bool:
+        """Check if this package depends on another package."""
+        return name in self.dependencies or name in self.workspace_dependencies
+
+    def has_workspace_dependency(self, other: Package) -> bool:
+        """Check if this package depends on another workspace package."""
+        return other.name in self.workspace_dependencies
+
+
+def parse_dependency_name(dep: str) -> str:
+    """Extract package name from a dependency specifier.
+
+    Examples:
+        "requests>=2.0" -> "requests"
+        "numpy[extra]" -> "numpy"
+        "my-pkg @ file://..." -> "my-pkg"
+    """
+    # Handle URL-based dependencies
+    if " @ " in dep:
+        dep = dep.split(" @ ")[0]
+
+    # Handle extras
+    if "[" in dep:
+        dep = dep.split("[")[0]
+
+    # Handle version specifiers
+    for sep in (">=", "<=", "==", "!=", ">", "<", "~=", ";"):
+        if sep in dep:
+            dep = dep.split(sep)[0]
+
+    return dep.strip().lower().replace("-", "_")
+
+
+def load_package(path: Path, workspace_packages: set[str] | None = None) -> Package:
+    """Load a package from its directory.
+
+    Args:
+        path: Path to the package directory.
+        workspace_packages: Set of known workspace package names for detecting
+            local dependencies.
+
+    Returns:
+        Package instance with metadata from pyproject.toml.
+
+    Raises:
+        ConfigurationError: If pyproject.toml is missing or invalid.
+    """
+    pyproject_path = path / "pyproject.toml"
+    if not pyproject_path.is_file():
+        raise ConfigurationError(
+            "No pyproject.toml found in package directory",
+            path=path,
+        )
+
+    try:
+        with open(pyproject_path, "rb") as f:
+            data = tomllib.load(f)
+    except tomllib.TOMLDecodeError as e:
+        raise ConfigurationError(
+            f"Invalid pyproject.toml: {e}",
+            path=pyproject_path,
+        ) from e
+
+    project = data.get("project", {})
+    if not project:
+        raise ConfigurationError(
+            "pyproject.toml missing [project] section",
+            path=pyproject_path,
+        )
+
+    name = project.get("name")
+    if not name:
+        raise ConfigurationError(
+            "pyproject.toml missing project.name",
+            path=pyproject_path,
+        )
+
+    version = project.get("version", "0.0.0")
+    description = project.get("description")
+
+    # Parse dependencies
+    raw_deps = project.get("dependencies", [])
+    dependencies = frozenset(parse_dependency_name(d) for d in raw_deps if isinstance(d, str))
+
+    # Parse dev dependencies from optional-dependencies
+    optional_deps = project.get("optional-dependencies", {})
+    dev_deps_list = optional_deps.get("dev", [])
+    dev_dependencies = frozenset(
+        parse_dependency_name(d) for d in dev_deps_list if isinstance(d, str)
+    )
+
+    # Identify workspace dependencies from uv sources
+    uv_config = data.get("tool", {}).get("uv", {})
+    uv_sources = uv_config.get("sources", {})
+    workspace_deps: set[str] = set()
+
+    for dep_name, source in uv_sources.items():
+        if isinstance(source, dict) and source.get("workspace"):
+            workspace_deps.add(dep_name.lower().replace("-", "_"))
+
+    # Also check if any dependencies match known workspace packages
+    if workspace_packages:
+        for dep in dependencies | dev_dependencies:
+            normalized = dep.lower().replace("-", "_")
+            if normalized in workspace_packages:
+                workspace_deps.add(normalized)
+
+    # Parse scripts from pyproject.toml
+    scripts = project.get("scripts", {})
+
+    return Package(
+        name=name,
+        path=path.resolve(),
+        version=version,
+        description=description,
+        dependencies=dependencies,
+        dev_dependencies=dev_dependencies,
+        workspace_dependencies=frozenset(workspace_deps),
+        scripts=dict(scripts) if scripts else {},
+    )
+
+
+def get_package_name_from_path(path: Path) -> str | None:
+    """Try to extract package name from pyproject.toml without full loading.
+
+    Args:
+        path: Path to the package directory.
+
+    Returns:
+        Package name if found, None otherwise.
+    """
+    pyproject_path = path / "pyproject.toml"
+    if not pyproject_path.is_file():
+        return None
+
+    try:
+        with open(pyproject_path, "rb") as f:
+            data = tomllib.load(f)
+        return data.get("project", {}).get("name")
+    except (tomllib.TOMLDecodeError, OSError):
+        return None

pymelos/workspace/workspace.py

@@ -0,0 +1,218 @@
+"""Workspace aggregate root."""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from pymelos.config import PyMelosConfig, load_config
+from pymelos.errors import PackageNotFoundError
+from pymelos.workspace.discovery import discover_packages
+from pymelos.workspace.graph import DependencyGraph
+from pymelos.workspace.package import Package
+
+
+@dataclass
+class Workspace:
+    """The root aggregate for a pymelos workspace.
+
+    Attributes:
+        root: Path to workspace root directory.
+        config: Loaded configuration from pymelos.yaml.
+        config_path: Path to the pymelos.yaml file.
+        packages: Dictionary mapping package names to Package instances.
+    """
+
+    root: Path
+    config: PyMelosConfig
+    config_path: Path
+    packages: dict[str, Package] = field(default_factory=dict)
+    _graph: DependencyGraph | None = field(default=None, init=False, repr=False)
+
+    @classmethod
+    def discover(cls, start_path: Path | None = None) -> Workspace:
+        """Discover and load workspace from current or specified directory.
+
+        Args:
+            start_path: Directory to start searching from. Defaults to cwd.
+
+        Returns:
+            Loaded Workspace instance.
+
+        Raises:
+            WorkspaceNotFoundError: If no pymelos.yaml found.
+            ConfigurationError: If configuration is invalid.
+        """
+        if start_path is None:
+            start_path = Path.cwd()
+
+        config, config_path = load_config(start_path=start_path)
+        root = config_path.parent
+
+        packages = discover_packages(root, config)
+
+        return cls(
+            root=root,
+            config=config,
+            config_path=config_path,
+            packages=packages,
+        )
+
+    @classmethod
+    def from_config(cls, config_path: Path) -> Workspace:
+        """Load workspace from explicit config file path.
+
+        Args:
+            config_path: Path to pymelos.yaml.
+
+        Returns:
+            Loaded Workspace instance.
+        """
+        config, config_path = load_config(path=config_path)
+        root = config_path.parent
+
+        packages = discover_packages(root, config)
+
+        return cls(
+            root=root,
+            config=config,
+            config_path=config_path,
+            packages=packages,
+        )
+
+    @property
+    def name(self) -> str:
+        """Workspace name from configuration."""
+        return self.config.name
+
+    @property
+    def graph(self) -> DependencyGraph:
+        """Dependency graph for packages."""
+        if self._graph is None:
+            self._graph = DependencyGraph(packages=self.packages)
+        return self._graph
+
+    def get_package(self, name: str) -> Package:
+        """Get a package by name.
+
+        Args:
+            name: Package name.
+
+        Returns:
+            Package instance.
+
+        Raises:
+            PackageNotFoundError: If package doesn't exist.
+        """
+        package = self.packages.get(name)
+        if package is None:
+            raise PackageNotFoundError(name, list(self.packages.keys()))
+        return package
+
+    def has_package(self, name: str) -> bool:
+        """Check if a package exists in the workspace.
+
+        Args:
+            name: Package name.
+
+        Returns:
+            True if package exists.
+        """
+        return name in self.packages
+
+    def filter_packages(
+        self,
+        scope: str | None = None,
+        ignore: list[str] | None = None,
+        names: list[str] | None = None,
+    ) -> list[Package]:
+        """Filter packages by criteria.
+
+        Args:
+            scope: Comma-separated names or glob patterns.
+            ignore: Patterns to exclude.
+            names: Explicit list of package names.
+
+        Returns:
+            List of matching packages.
+        """
+        from pymelos.filters import apply_filters
+
+        return apply_filters(
+            packages=list(self.packages.values()),
+            scope=scope,
+            ignore=ignore,
+            names=names,
+        )
+
+    def topological_order(
+        self,
+        packages: list[Package] | None = None,
+    ) -> Iterator[Package]:
+        """Iterate packages in dependency order.
+
+        Args:
+            packages: Subset of packages to order. Defaults to all.
+
+        Yields:
+            Packages in topological order.
+        """
+        if packages is None:
+            yield from self.graph.topological_order()
+        else:
+            names = {p.name for p in packages}
+            subgraph = self.graph.subgraph(names)
+            yield from subgraph.topological_order()
+
+    def parallel_batches(
+        self,
+        packages: list[Package] | None = None,
+    ) -> Iterator[list[Package]]:
+        """Iterate packages in parallel-safe batches.
+
+        Args:
+            packages: Subset of packages. Defaults to all.
+
+        Yields:
+            Batches of packages that can run in parallel.
+        """
+        if packages is None:
+            yield from self.graph.parallel_batches()
+        else:
+            names = {p.name for p in packages}
+            subgraph = self.graph.subgraph(names)
+            yield from subgraph.parallel_batches()
+
+    def get_affected_packages(self, changed: list[Package]) -> list[Package]:
+        """Get all packages affected by changes to given packages.
+
+        Args:
+            changed: List of changed packages.
+
+        Returns:
+            All affected packages including transitive dependents.
+        """
+        changed_names = {p.name for p in changed}
+        affected = self.graph.get_affected_packages(changed_names)
+        return list(affected)
+
+    def refresh(self) -> None:
+        """Reload packages from disk.
+
+        Call this after making changes to pyproject.toml files.
+        """
+        self.packages = discover_packages(self.root, self.config)
+        self._graph = None
+
+    def __len__(self) -> int:
+        """Number of packages in workspace."""
+        return len(self.packages)
+
+    def __iter__(self) -> Iterator[Package]:
+        """Iterate over all packages."""
+        return iter(self.packages.values())
+
+    def __contains__(self, name: str) -> bool:
+        """Check if package name exists."""
+        return name in self.packages