conda-workspaces 0.1.0__py3-none-any.whl

conda_workspaces/__init__.py

@@ -0,0 +1,8 @@
+"""conda-workspaces: Project-scoped multi-environment workspace management."""
+
+from __future__ import annotations
+
+try:
+    from ._version import __version__
+except ImportError:  # pragma: no cover
+    __version__ = "0.0.0.dev0"

conda_workspaces/__main__.py

@@ -0,0 +1,29 @@
+"""Standalone CLI entry point for ``cw`` (short for ``conda workspace``).
+
+This module allows running conda-workspaces without going through the
+conda plugin dispatch::
+
+    cw init
+    cw install
+    cw list
+    cw add -e dev pytest
+
+It reuses the same parser and execute logic as ``conda workspace``.
+"""
+
+from __future__ import annotations
+
+
+def main(args: list[str] | None = None) -> None:
+    """Entry point for the ``cw`` console script."""
+    from .cli.main import execute, generate_parser
+
+    parser = generate_parser()
+    parser.prog = "cw"
+
+    parsed = parser.parse_args(args)
+    raise SystemExit(execute(parsed))
+
+
+if __name__ == "__main__":
+    main()

conda_workspaces/_version.py

@@ -0,0 +1,34 @@
+# file generated by setuptools-scm
+# don't change, don't track in version control
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+TYPE_CHECKING = False
+if TYPE_CHECKING:
+    from typing import Tuple
+    from typing import Union
+
+    VERSION_TUPLE = Tuple[Union[int, str], ...]
+    COMMIT_ID = Union[str, None]
+else:
+    VERSION_TUPLE = object
+    COMMIT_ID = object
+
+version: str
+__version__: str
+__version_tuple__: VERSION_TUPLE
+version_tuple: VERSION_TUPLE
+commit_id: COMMIT_ID
+__commit_id__: COMMIT_ID
+
+__version__ = version = '0.1.0'
+__version_tuple__ = version_tuple = (0, 1, 0)
+
+__commit_id__ = commit_id = None

conda_workspaces/cli/__init__.py

@@ -0,0 +1,7 @@
+"""CLI package for ``conda workspace``."""
+
+from __future__ import annotations
+
+from .main import configure_parser, execute, generate_parser
+
+__all__ = ["configure_parser", "execute", "generate_parser"]

conda_workspaces/cli/activate.py

@@ -0,0 +1,33 @@
+"""``conda workspace activate`` — print activation instructions."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from conda.cli.common import print_activate
+
+from ..context import WorkspaceContext
+from ..exceptions import EnvironmentNotFoundError, EnvironmentNotInstalledError
+from ..parsers import detect_and_parse
+
+if TYPE_CHECKING:
+    import argparse
+
+
+def execute_activate(args: argparse.Namespace) -> int:
+    """Print activation instructions for a workspace environment."""
+    manifest_path = getattr(args, "file", None)
+    _, config = detect_and_parse(manifest_path)
+    ctx = WorkspaceContext(config)
+
+    env_name = args.env_name
+
+    if env_name not in config.environments:
+        raise EnvironmentNotFoundError(env_name, list(config.environments.keys()))
+
+    if not ctx.env_exists(env_name):
+        raise EnvironmentNotInstalledError(env_name)
+
+    prefix = ctx.env_prefix(env_name)
+    print_activate(str(prefix))
+    return 0

conda_workspaces/cli/add.py

@@ -0,0 +1,91 @@
+"""``conda workspace add`` — add dependencies to the workspace manifest."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import tomlkit
+
+from ..parsers import detect_workspace_file
+
+if TYPE_CHECKING:
+    import argparse
+
+
+def execute_add(args: argparse.Namespace) -> int:
+    """Add dependencies to the workspace manifest."""
+    manifest_path = getattr(args, "file", None) or detect_workspace_file()
+    specs = args.specs
+    is_pypi = getattr(args, "pypi", False)
+    feature = getattr(args, "feature", None)
+    environment = getattr(args, "environment", None)
+
+    # Determine which feature to target
+    target_feature = feature or environment  # environment name == feature name
+
+    text = manifest_path.read_text(encoding="utf-8")
+    doc = tomlkit.loads(text)
+
+    dep_key = "pypi-dependencies" if is_pypi else "dependencies"
+
+    if manifest_path.name == "pyproject.toml":
+        _add_to_pyproject(doc, specs, dep_key, target_feature)
+    else:
+        _add_to_toml(doc, specs, dep_key, target_feature)
+
+    manifest_path.write_text(tomlkit.dumps(doc), encoding="utf-8")
+
+    label = "PyPI" if is_pypi else "conda"
+    location = f"feature '{target_feature}'" if target_feature else "default"
+
+    print(
+        f"Added {len(specs)} {label} dependency(ies)"
+        f" to {location} in {manifest_path.name}"
+    )
+    return 0
+
+
+def _add_to_toml(
+    doc: tomlkit.TOMLDocument,
+    specs: list[str],
+    dep_key: str,
+    feature: str | None,
+) -> None:
+    """Add deps to a pixi.toml or conda.toml document."""
+    if feature:
+        feat_table = doc.setdefault("feature", tomlkit.table())
+        target = feat_table.setdefault(feature, tomlkit.table())
+    else:
+        target = doc
+
+    deps = target.setdefault(dep_key, tomlkit.table())
+    for spec in specs:
+        name, _, version = spec.partition(" ")
+        deps[name] = version.strip() if version.strip() else "*"
+
+
+def _add_to_pyproject(
+    doc: tomlkit.TOMLDocument,
+    specs: list[str],
+    dep_key: str,
+    feature: str | None,
+) -> None:
+    """Add deps to a pyproject.toml with [tool.pixi.*] tables."""
+    tool = doc.setdefault("tool", tomlkit.table())
+
+    # Prefer conda-workspaces table if it exists, else pixi
+    if "conda-workspaces" in tool:
+        source = tool["conda-workspaces"]
+    else:
+        source = tool.setdefault("pixi", tomlkit.table())
+
+    if feature:
+        feat_table = source.setdefault("feature", tomlkit.table())
+        target = feat_table.setdefault(feature, tomlkit.table())
+    else:
+        target = source
+
+    deps = target.setdefault(dep_key, tomlkit.table())
+    for spec in specs:
+        name, _, version = spec.partition(" ")
+        deps[name] = version.strip() if version.strip() else "*"

conda_workspaces/cli/clean.py

@@ -0,0 +1,52 @@
+"""``conda workspace clean`` — remove installed workspace environments."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from conda.exceptions import CondaSystemExit, DryRunExit
+from conda.reporters import confirm_yn
+
+from ..context import WorkspaceContext
+from ..envs import clean_all, list_installed_environments, remove_environment
+from ..parsers import detect_and_parse
+
+if TYPE_CHECKING:
+    import argparse
+
+
+def execute_clean(args: argparse.Namespace) -> int:
+    """Remove installed workspace environments."""
+    manifest_path = getattr(args, "file", None)
+    _, config = detect_and_parse(manifest_path)
+    ctx = WorkspaceContext(config)
+
+    env_name = getattr(args, "environment", None)
+
+    try:
+        if env_name:
+            if not ctx.env_exists(env_name):
+                print(f"Environment '{env_name}' is not installed.")
+                return 0
+
+            confirm_yn(f"Remove environment '{env_name}'?")
+
+            remove_environment(ctx, env_name)
+            print(f"Removed environment '{env_name}'.")
+        else:
+            installed = list_installed_environments(ctx)
+            if not installed:
+                print("No environments installed.")
+                return 0
+
+            print(f"This will remove {len(installed)} environment(s):")
+            for name in installed:
+                print(f"  - {name}")
+            confirm_yn("Continue?")
+
+            clean_all(ctx)
+            print(f"Removed {len(installed)} environment(s).")
+    except (CondaSystemExit, DryRunExit):
+        return 0
+
+    return 0

conda_workspaces/cli/info.py

@@ -0,0 +1,71 @@
+"""``conda workspace info`` — show environment details."""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING
+
+from ..context import WorkspaceContext
+from ..envs import get_environment_info
+from ..parsers import detect_and_parse
+from ..resolver import resolve_environment
+
+if TYPE_CHECKING:
+    import argparse
+
+
+def execute_info(args: argparse.Namespace) -> int:
+    """Show details about an environment."""
+    manifest_path = getattr(args, "file", None)
+    _, config = detect_and_parse(manifest_path)
+    ctx = WorkspaceContext(config)
+
+    env_name = args.env_name
+    json_output = getattr(args, "json", False)
+
+    resolved = resolve_environment(config, env_name, ctx.platform)
+    install_info = get_environment_info(ctx, env_name)
+
+    info = {
+        "name": env_name,
+        "prefix": str(ctx.env_prefix(env_name)),
+        "installed": install_info["exists"],
+        "channels": [ch.canonical_name for ch in resolved.channels],
+        "platforms": resolved.platforms,
+        "solve_group": resolved.solve_group,
+        "conda_dependencies": {
+            name: dep.conda_build_form()
+            for name, dep in resolved.conda_dependencies.items()
+        },
+        "pypi_dependencies": {
+            name: str(dep) for name, dep in resolved.pypi_dependencies.items()
+        },
+    }
+
+    if install_info["exists"]:
+        info["packages_installed"] = install_info.get("packages", 0)
+
+    if json_output:
+        print(json.dumps(info, indent=2))
+    else:
+        print(f"Environment: {info['name']}")
+        print(f"Prefix:      {info['prefix']}")
+        print(f"Installed:   {'yes' if info['installed'] else 'no'}")
+        if info["installed"]:
+            print(f"Packages:    {info.get('packages_installed', '?')}")
+        print(f"Channels:    {', '.join(info['channels']) or '(none)'}")
+        print(f"Platforms:   {', '.join(info['platforms']) or '(all)'}")
+        if info["solve_group"]:
+            print(f"Solve group: {info['solve_group']}")
+
+        if info["conda_dependencies"]:
+            print("\nConda dependencies:")
+            for name, spec in sorted(info["conda_dependencies"].items()):
+                print(f"  - {spec}")
+
+        if info["pypi_dependencies"]:
+            print("\nPyPI dependencies:")
+            for name, spec in sorted(info["pypi_dependencies"].items()):
+                print(f"  - {spec}")
+
+    return 0

conda_workspaces/cli/init.py

@@ -0,0 +1,114 @@
+"""``conda workspace init`` — scaffold a new workspace manifest."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import tomlkit
+from conda.base.context import context as conda_context
+
+from ..exceptions import ManifestExistsError
+
+if TYPE_CHECKING:
+    import argparse
+
+
+def execute_init(args: argparse.Namespace) -> int:
+    """Create a new workspace manifest in the current directory."""
+    fmt = args.manifest_format
+    name = args.name or Path.cwd().name
+    channels = args.channels or ["conda-forge"]
+
+    if args.platforms:
+        platforms = args.platforms
+    else:
+        platforms = _detect_platforms()
+
+    if fmt == "pixi":
+        return _write_pixi_toml(name, channels, platforms)
+    elif fmt == "conda":
+        return _write_conda_toml(name, channels, platforms)
+    elif fmt == "pyproject":
+        return _write_pyproject_toml(name, channels, platforms)
+
+    return 1
+
+
+def _detect_platforms() -> list[str]:
+    """Auto-detect a reasonable set of platforms."""
+    current = conda_context.subdir
+    # Include a sensible default set based on current platform
+    defaults = {"linux-64", "osx-64", "osx-arm64", "win-64"}
+    defaults.add(current)
+    return sorted(defaults)
+
+
+def _write_pixi_toml(name: str, channels: list[str], platforms: list[str]) -> int:
+    path = Path("pixi.toml")
+    if path.exists():
+        raise ManifestExistsError(path)
+
+    doc = tomlkit.document()
+
+    ws = tomlkit.table()
+    ws.add("name", name)
+    ws.add("version", "0.1.0")
+    ws.add("channels", channels)
+    ws.add("platforms", platforms)
+    doc.add("workspace", ws)
+
+    deps = tomlkit.table()
+    doc.add("dependencies", deps)
+
+    path.write_text(tomlkit.dumps(doc), encoding="utf-8")
+    print(f"Created {path}")
+    return 0
+
+
+def _write_conda_toml(name: str, channels: list[str], platforms: list[str]) -> int:
+    path = Path("conda.toml")
+    if path.exists():
+        raise ManifestExistsError(path)
+
+    doc = tomlkit.document()
+
+    ws = tomlkit.table()
+    ws.add("name", name)
+    ws.add("version", "0.1.0")
+    ws.add("channels", channels)
+    ws.add("platforms", platforms)
+    doc.add("workspace", ws)
+
+    deps = tomlkit.table()
+    doc.add("dependencies", deps)
+
+    path.write_text(tomlkit.dumps(doc), encoding="utf-8")
+    print(f"Created {path}")
+    return 0
+
+
+def _write_pyproject_toml(name: str, channels: list[str], platforms: list[str]) -> int:
+    path = Path("pyproject.toml")
+
+    if path.exists():
+        text = path.read_text(encoding="utf-8")
+        doc = tomlkit.loads(text)
+    else:
+        doc = tomlkit.document()
+
+    tool = doc.setdefault("tool", tomlkit.table())
+    if "pixi" in tool:
+        raise ManifestExistsError("[tool.pixi] in pyproject.toml")
+
+    pixi = tomlkit.table()
+    ws = tomlkit.table()
+    ws.add("channels", channels)
+    ws.add("platforms", platforms)
+    pixi.add("workspace", ws)
+    pixi.add("dependencies", tomlkit.table())
+    tool.add("pixi", pixi)
+
+    path.write_text(tomlkit.dumps(doc), encoding="utf-8")
+    print(f"{'Updated' if path.exists() else 'Created'} {path}")
+    return 0

conda_workspaces/cli/install.py

@@ -0,0 +1,67 @@
+"""``conda workspace install`` — create or update workspace environments."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ..context import WorkspaceContext
+from ..envs import install_environment
+from ..lockfile import generate_lockfile, install_from_lockfile
+from ..parsers import detect_and_parse
+from ..resolver import resolve_all_environments, resolve_environment
+
+if TYPE_CHECKING:
+    import argparse
+
+
+def execute_install(args: argparse.Namespace) -> int:
+    """Install (create/update) workspace environments."""
+    manifest_path = getattr(args, "file", None)
+    _, config = detect_and_parse(manifest_path)
+    ctx = WorkspaceContext(config)
+
+    env_name = getattr(args, "environment", None)
+    force = getattr(args, "force_reinstall", False)
+    dry_run = getattr(args, "dry_run", False)
+    locked = getattr(args, "locked", False)
+
+    if locked:
+        return _install_locked(ctx, config, env_name)
+
+    if env_name:
+        resolved = resolve_environment(config, env_name, ctx.platform)
+        print(f"Installing environment '{env_name}'...")
+        install_environment(ctx, resolved, force_reinstall=force, dry_run=dry_run)
+        if not dry_run:
+            generate_lockfile(ctx, env_names=[env_name])
+        print(f"Environment '{env_name}' is ready at {ctx.env_prefix(env_name)}")
+    else:
+        resolved_all = resolve_all_environments(config, ctx.platform)
+        installed_names: list[str] = []
+        for name, resolved in resolved_all.items():
+            print(f"Installing environment '{name}'...")
+            install_environment(ctx, resolved, force_reinstall=force, dry_run=dry_run)
+            installed_names.append(name)
+            print(f"  -> {ctx.env_prefix(name)}")
+        if not dry_run:
+            generate_lockfile(ctx, env_names=installed_names)
+        print(f"\n{len(resolved_all)} environment(s) installed.")
+
+    return 0
+
+
+def _install_locked(ctx: WorkspaceContext, config: object, env_name: str | None) -> int:
+    """Install environments from existing lockfiles (no solving)."""
+    if env_name:
+        print(f"Installing environment '{env_name}' from lockfile...")
+        install_from_lockfile(ctx, env_name)
+        print(f"Environment '{env_name}' is ready at {ctx.env_prefix(env_name)}")
+    else:
+        resolved_all = resolve_all_environments(config, ctx.platform)
+        for name in resolved_all:
+            print(f"Installing environment '{name}' from lockfile...")
+            install_from_lockfile(ctx, name)
+            print(f"  -> {ctx.env_prefix(name)}")
+        print(f"\n{len(resolved_all)} environment(s) installed from lockfiles.")
+
+    return 0

conda_workspaces/cli/list.py

@@ -0,0 +1,55 @@
+"""``conda workspace list`` — list workspace environments."""
+
+from __future__ import annotations
+
+import json
+from typing import TYPE_CHECKING
+
+from ..context import WorkspaceContext
+from ..envs import list_installed_environments
+from ..parsers import detect_and_parse
+
+if TYPE_CHECKING:
+    import argparse
+
+
+def execute_list(args: argparse.Namespace) -> int:
+    """List environments defined in the workspace."""
+    manifest_path = getattr(args, "file", None)
+    _, config = detect_and_parse(manifest_path)
+    ctx = WorkspaceContext(config)
+
+    installed_only = getattr(args, "installed", False)
+    json_output = getattr(args, "json", False)
+
+    installed = set(list_installed_environments(ctx))
+
+    rows: list[dict[str, str | bool | list[str]]] = []
+    for name, env in sorted(config.environments.items()):
+        if installed_only and name not in installed:
+            continue
+        rows.append(
+            {
+                "name": name,
+                "features": env.features,
+                "solve_group": env.solve_group or "",
+                "installed": name in installed,
+            }
+        )
+
+    if json_output:
+        print(json.dumps(rows, indent=2))
+    else:
+        if not rows:
+            print("No environments found.")
+            return 0
+
+        # Header
+        print(f"{'Name':<20} {'Features':<30} {'Solve Group':<15} {'Installed'}")
+        print("-" * 75)
+        for row in rows:
+            feats = ", ".join(row["features"]) if row["features"] else "(default)"  # type: ignore[arg-type]
+            status = "yes" if row["installed"] else "no"
+            print(f"{row['name']:<20} {feats:<30} {row['solve_group']:<15} {status}")
+
+    return 0

conda_workspaces/cli/lock.py

@@ -0,0 +1,43 @@
+"""``conda workspace lock`` — generate lockfiles for workspace environments."""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ..context import WorkspaceContext
+from ..lockfile import generate_lockfile, lockfile_path
+from ..parsers import detect_and_parse
+from ..resolver import resolve_all_environments
+
+if TYPE_CHECKING:
+    import argparse
+
+
+def execute_lock(args: argparse.Namespace) -> int:
+    """Generate a ``conda.lock`` for installed workspace environments."""
+    manifest_path = getattr(args, "file", None)
+    _, config = detect_and_parse(manifest_path)
+    ctx = WorkspaceContext(config)
+
+    env_name = getattr(args, "environment", None)
+
+    if env_name:
+        if not ctx.env_exists(env_name):
+            from ..exceptions import EnvironmentNotInstalledError
+
+            raise EnvironmentNotInstalledError(env_name)
+        path = generate_lockfile(ctx, env_names=[env_name])
+        print(f"Lockfile written to {path}")
+    else:
+        resolved_all = resolve_all_environments(config, ctx.platform)
+        installed = [name for name in resolved_all if ctx.env_exists(name)]
+        skipped = [name for name in resolved_all if not ctx.env_exists(name)]
+        if installed:
+            path = generate_lockfile(ctx, env_names=installed)
+            for name in installed:
+                print(f"  {name} -> {path}")
+        for name in skipped:
+            print(f"  {name} — skipped (not installed)")
+        print(f"\n{len(installed)} environment(s) locked in {lockfile_path(ctx)}.")
+
+    return 0