metaxy 0.0.1.dev3__py3-none-any.whl

metaxy/cli/app.py

@@ -0,0 +1,97 @@
+"""Main Metaxy CLI application."""
+
+from pathlib import Path
+from typing import Annotated
+
+import cyclopts
+
+from metaxy import init_metaxy
+from metaxy._version import __version__
+from metaxy.cli.console import console, error_console
+
+# Main app
+app = cyclopts.App(
+    name="metaxy",  # pyrefly: ignore[unexpected-keyword]
+    version=__version__,  # pyrefly: ignore[unexpected-keyword]
+    console=console,  # pyrefly: ignore[unexpected-keyword]
+    error_console=error_console,  # pyrefly: ignore[unexpected-keyword]
+    config=cyclopts.config.Env(  # pyrefly: ignore[unexpected-keyword,implicit-import]
+        "METAXY_",  # Every environment variable for setting the arguments will begin with this.  # pyrefly: ignore[bad-argument-count]
+    ),
+    help_epilogue="Learn more in [Metaxy docs](https://anam-org.github.io/metaxy)",
+)
+
+
+@app.command
+def shell():
+    """Start interactive shell."""
+    app.interactive_shell()
+
+
+# Meta app for global parameters
+
+
+@app.meta.default
+def launcher(
+    *tokens: Annotated[str, cyclopts.Parameter(show=False, allow_leading_hyphen=True)],
+    config_file: Annotated[
+        Path | None,
+        cyclopts.Parameter(
+            None,
+            help="Global option. Path to the Metaxy configuration file. Defaults to auto-discovery.",
+        ),
+    ] = None,
+    project: Annotated[
+        str | None,
+        cyclopts.Parameter(
+            None,
+            help="Global option. Metaxy project to work with. Some commands may forbid setting this argument.",
+        ),
+    ] = None,
+    all_projects: Annotated[
+        bool,
+        cyclopts.Parameter(
+            name=["--all-projects"],
+            help="Global option. Operate on all available Metaxy projects. Some commands may forbid setting this argument.",
+        ),
+    ] = False,
+):
+    """Metaxy CLI.
+
+    Auto-discovers configuration (`metaxy.toml` or `pyproject.toml`) in current or parent directories.
+    Feature definitions are collected via [feature discovery](https://anam-org.github.io/metaxy/main/learn/feature-discovery/).
+    """
+    import logging
+    import os
+
+    logging.getLogger().setLevel(os.environ.get("METAXY_LOG_LEVEL", "INFO"))
+
+    # Load Metaxy configuration with parent directory search
+    # This handles TOML discovery, env vars, and entrypoint loading
+    config = init_metaxy(config_file=config_file, search_parents=True)
+
+    # Store config in context for commands to access
+    # Commands will instantiate and open store as needed
+    from metaxy.cli.context import AppContext
+
+    AppContext.set(config, cli_project=project, all_projects=all_projects)
+
+    # Run the actual command
+    app(tokens)
+
+
+# Register subcommands (lazy loading via import strings)
+app.command("metaxy.cli.migrations:app", name="migrations")
+app.command("metaxy.cli.graph:app", name="graph")
+app.command("metaxy.cli.graph_diff:app", name="graph-diff")
+app.command("metaxy.cli.list:app", name="list")
+app.command("metaxy.cli.metadata:app", name="metadata")
+
+
+def main():
+    """Entry point for the CLI."""
+    app.meta()
+
+
+if __name__ == "__main__":
+    main()

metaxy/cli/console.py

@@ -0,0 +1,13 @@
+import sys
+
+from rich.console import Console
+
+# Rich console for logs and status messages (goes to stderr)
+console = Console(file=sys.stderr, stderr=True)
+
+# Console for data output (goes to stdout)
+# This is used for outputting important data that scripts might want to capture
+data_console = Console(file=sys.stdout, highlight=False)
+
+# Error console (also goes to stderr)
+error_console = Console(file=sys.stderr, stderr=True, style="bold red", highlight=False)

metaxy/cli/context.py

@@ -0,0 +1,167 @@
+"""CLI application context for sharing state across commands."""
+
+from contextvars import ContextVar
+from dataclasses import dataclass
+from functools import cached_property
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from metaxy.config import MetaxyConfig
+    from metaxy.metadata_store.base import MetadataStore
+    from metaxy.models.feature import FeatureGraph
+
+
+# Context variable for storing the app context
+_app_context: ContextVar["AppContext | None"] = ContextVar("_app_context", default=None)
+
+
+@dataclass
+class AppContext:
+    """CLI application context.
+
+    Stores the config initialized by the meta app launcher.
+    """
+
+    config: "MetaxyConfig"
+    cli_project: (
+        str | None
+    )  # some CLI commands can be executed with a project different from the one in the Metaxy config
+    all_projects: bool = False  # some CLI commands can work with all projects
+
+    @classmethod
+    def set(
+        cls, config: "MetaxyConfig", cli_project: str | None, all_projects: bool = False
+    ) -> None:
+        """Initialize the app context.
+
+        Should be called at CLI startup.
+
+        Args:
+            config: Metaxy configuration
+            cli_project: CLI project override
+            all_projects: Whether to include all projects
+        """
+        if _app_context.get() is not None:
+            raise RuntimeError(
+                "AppContext already initialized. It is not allowed to call AppContext.set() again."
+            )
+        else:
+            from metaxy import load_features
+            from metaxy.config import MetaxyConfig
+
+            MetaxyConfig.set(config)
+            load_features()
+            _app_context.set(AppContext(config, cli_project, all_projects))
+
+    @classmethod
+    def get(cls) -> "AppContext":
+        """Get the app context.
+
+        Returns:
+            AppContext instance
+
+        Raises:
+            RuntimeError: If context not initialized
+        """
+        ctx = _app_context.get()
+        if ctx is None:
+            raise RuntimeError(
+                "CLI context not initialized. AppContext.set(config) should be called at CLI startup."
+            )
+        else:
+            return ctx
+
+    def reset(self) -> None:
+        """Reset the app context.
+
+        Raises:
+            RuntimeError: If context not initialized
+        """
+        ctx = _app_context.get()
+        if ctx is None:
+            raise RuntimeError(
+                "CLI context not initialized. AppContext.set(config) should be called at CLI startup."
+            )
+        else:
+            _app_context.set(None)
+
+    def get_store(self, name: str | None = None) -> "MetadataStore":
+        """Get and open a metadata store from config.
+
+        Store is retrieved from config context.
+
+        Returns:
+            Opened metadata store instance (within context manager)
+
+        Raises:
+            RuntimeError: If context not initialized
+        """
+        return self.config.get_store(name)
+
+    @cached_property
+    def graph(self) -> "FeatureGraph":
+        """Get the graph instance.
+
+        Returns:
+            Graph instance
+
+        Raises:
+            RuntimeError: If context not initialized
+        """
+        from metaxy.models.feature import FeatureGraph
+
+        return FeatureGraph.get_active()
+
+    def raise_command_cannot_override_project(self) -> None:
+        """Raise an error if the command cannot override project.
+
+        Raises:
+            SystemExit: If command cannot override project
+        """
+        if self.cli_project or self.all_projects:
+            from metaxy.cli.console import console
+
+            console.print(
+                f"[red]Error:[/red] This command can only be used with the project from Metaxy configuration: {self.config.project}.",
+                style="bold",
+            )
+            raise SystemExit(1)
+
+    @cached_property
+    def project(self) -> str | None:
+        """Get the project for the app invocation, in order of precedence:
+            - None if all projects are selected
+            - project from CLI input
+            - project from Metaxy configuration
+
+        Returns:
+            Project name or None if not set
+        """
+        return (
+            (self.cli_project or self.config.project) if not self.all_projects else None
+        )
+
+    def get_required_project(self) -> str:
+        """Get the project for commands that require a specific project.
+
+        This method ensures we have a valid project string, raising an error
+        if all_projects is True (which would make project None).
+
+        Returns:
+            Project name (never None)
+
+        Raises:
+            SystemExit: If all_projects is True (project would be None)
+        """
+        if self.all_projects:
+            from metaxy.cli.console import console
+
+            console.print(
+                "[red]Error:[/red] This command requires a specific project. "
+                "Cannot use --all-projects flag.",
+                style="bold",
+            )
+            raise SystemExit(1)
+
+        # Return the project (either from CLI or config, guaranteed to have a default)
+        return self.cli_project or self.config.project