dayhoff-tools 1.11.1__py3-none-any.whl → 1.11.3__py3-none-any.whl

dayhoff_tools/cli/main.py

@@ -4,13 +4,14 @@ import sys
 from importlib.metadata import PackageNotFoundError, version
 
 import typer
-
 from dayhoff_tools.cli.cloud_commands import aws_app, gcp_app
 from dayhoff_tools.cli.engine import engine_app, studio_app
 from dayhoff_tools.cli.utility_commands import (
+    add_dependency,
     build_and_upload_wheel,
     delete_local_branch,
-    install_dependencies,
+    remove_dependency,
+    sync_with_toml,
     test_github_actions_locally,
     update_dependencies,
 )
@@ -45,8 +46,13 @@ app.command("clean")(delete_local_branch)
 
 # Dependency Management
 app.command(
-    "install", help="Install dependencies based on pyproject.toml and sync environment."
-)(install_dependencies)
+    "tomlsync",
+    help="Sync environment with platform-specific TOML manifest (install/update dependencies).",
+)(sync_with_toml)
+app.command("add", help="Add a dependency to all platform manifests.")(add_dependency)
+app.command("remove", help="Remove a dependency from all platform manifests.")(
+    remove_dependency
+)
 app.command("update", help="Update dayhoff-tools (or all deps) and sync environment.")(
     update_dependencies
 )

dayhoff_tools/cli/utility_commands.py

@@ -110,8 +110,24 @@ def build_and_upload_wheel(bump_part: str = "patch"):
     publish_cmd = ["uv", "publish", "--token", token]
     print("Using UV_PUBLISH_TOKEN for authentication.")
 
-    pyproject_path = "pyproject.toml"
-    mac_manifest_path = "pyproject.mac.toml"
+    # Find the primary manifest (prefer AWS, then Mac, then Workstation)
+    pyproject_path = None
+    for candidate in [
+        "pyproject.aws.toml",
+        "pyproject.mac.toml",
+        "pyproject.workstation.toml",
+    ]:
+        if Path(candidate).exists():
+            pyproject_path = candidate
+            break
+
+    if not pyproject_path:
+        print(
+            "Error: No platform-specific manifest found (pyproject.aws.toml, pyproject.mac.toml, or pyproject.workstation.toml)"
+        )
+        return
+
+    print(f"Using manifest: {pyproject_path}")
     current_version = None  # Initialize in case the first try block fails
 
     try:
@@ -174,32 +190,54 @@ def build_and_upload_wheel(bump_part: str = "patch"):
             f.write(new_content)
         print(f"Updated {pyproject_path} with version {new_version}")
 
-        # Mirror version in pyproject.mac.toml if present (best-effort)
-        mac_updated = False
-        try:
-            mac_path = Path(mac_manifest_path)
-            if mac_path.exists():
-                mac_content = mac_path.read_text()
-                mac_pattern = re.compile(
+        # Mirror version in all other platform manifests (best-effort)
+        other_manifests = []
+        for candidate in [
+            "pyproject.aws.toml",
+            "pyproject.mac.toml",
+            "pyproject.workstation.toml",
+        ]:
+            if Path(candidate).exists() and candidate != pyproject_path:
+                other_manifests.append(Path(candidate))
+
+        for manifest_path in other_manifests:
+            try:
+                content = manifest_path.read_text()
+                pattern = re.compile(
                     f'^version\s*=\s*"{re.escape(current_version)}"', re.MULTILINE
                 )
-                mac_new_content, mac_replacements = mac_pattern.subn(
-                    f'version = "{new_version}"', mac_content
+                new_content, replacements = pattern.subn(
+                    f'version = "{new_version}"', content
                 )
-                if mac_replacements > 0:
-                    mac_path.write_text(mac_new_content)
-                    mac_updated = True
-                    print(f"Updated {mac_manifest_path} with version {new_version}")
-        except Exception as e:
-            print(f"Warning: Could not update {mac_manifest_path}: {e}")
+                if replacements > 0:
+                    manifest_path.write_text(new_content)
+                    print(f"Updated {manifest_path} with version {new_version}")
+            except Exception as e:
+                print(f"Warning: Could not update {manifest_path}: {e}")
         # --- End Version Bumping Logic ---
 
         # Build wheel and sdist
+        # UV expects pyproject.toml, so temporarily copy the platform manifest
+        backup_created = False
+        if pyproject_path != "pyproject.toml":
+            if Path("pyproject.toml").exists():
+                Path("pyproject.toml").rename("pyproject.toml.build.bak")
+                backup_created = True
+            Path(pyproject_path).read_text()
+            with open("pyproject.toml", "w") as f:
+                f.write(Path(pyproject_path).read_text())
+
         build_cmd = ["uv", "build"]
         # Print command in blue
         print(f"Running command: {BLUE}{' '.join(build_cmd)}{RESET}")
         subprocess.run(build_cmd, check=True)
 
+        # Restore original state
+        if pyproject_path != "pyproject.toml":
+            Path("pyproject.toml").unlink()
+            if backup_created:
+                Path("pyproject.toml.build.bak").rename("pyproject.toml")
+
         # Upload using uv publish with explicit arguments
         # Print masked command in blue
         print(f"Running command: {BLUE}{' '.join(publish_cmd_safe_print)}{RESET}")
@@ -260,23 +298,25 @@ def build_and_upload_wheel(bump_part: str = "patch"):
                         f"Warning: Could not find version {new_version} to revert in {pyproject_path}."
                     )
 
-                # Also revert mac manifest if we updated it
-                try:
-                    mac_path = Path(mac_manifest_path)
-                    if mac_path.exists():
-                        mac_content_revert = mac_path.read_text()
-                        mac_reverted, mac_num = pattern_revert.subn(
-                            f'version = "{current_version}"', mac_content_revert
-                        )
-                        if mac_num > 0:
-                            mac_path.write_text(mac_reverted)
+                # Also revert other platform manifests
+                for candidate in [
+                    "pyproject.aws.toml",
+                    "pyproject.mac.toml",
+                    "pyproject.workstation.toml",
+                ]:
+                    if Path(candidate).exists() and candidate != pyproject_path:
+                        try:
+                            content_revert = Path(candidate).read_text()
+                            reverted, num = pattern_revert.subn(
+                                f'version = "{current_version}"', content_revert
+                            )
+                            if num > 0:
+                                Path(candidate).write_text(reverted)
+                                print(f"Successfully reverted version in {candidate}.")
+                        except Exception as e2:
                             print(
-                                f"Successfully reverted version in {mac_manifest_path}."
+                                f"Warning: Failed to revert version change in {candidate}: {e2}"
                             )
-                except Exception as e2:
-                    print(
-                        f"Warning: Failed to revert version change in {mac_manifest_path}: {e2}"
-                    )
             except Exception as revert_e:
                 print(
                     f"Warning: Failed to revert version change in {pyproject_path}: {revert_e}"
@@ -306,23 +346,25 @@ def build_and_upload_wheel(bump_part: str = "patch"):
                     print(
                         f"Warning: Could not find version {new_version} to revert in {pyproject_path}."
                     )
-                # Also revert mac manifest if necessary
-                try:
-                    mac_path = Path(mac_manifest_path)
-                    if mac_path.exists():
-                        mac_content_revert = mac_path.read_text()
-                        mac_reverted, mac_num = pattern_revert.subn(
-                            f'version = "{current_version}"', mac_content_revert
-                        )
-                        if mac_num > 0:
-                            mac_path.write_text(mac_reverted)
+                # Also revert other platform manifests
+                for candidate in [
+                    "pyproject.aws.toml",
+                    "pyproject.mac.toml",
+                    "pyproject.workstation.toml",
+                ]:
+                    if Path(candidate).exists() and candidate != pyproject_path:
+                        try:
+                            content_revert = Path(candidate).read_text()
+                            reverted, num = pattern_revert.subn(
+                                f'version = "{current_version}"', content_revert
+                            )
+                            if num > 0:
+                                Path(candidate).write_text(reverted)
+                                print(f"Successfully reverted version in {candidate}.")
+                        except Exception as e2:
                             print(
-                                f"Successfully reverted version in {mac_manifest_path}."
+                                f"Warning: Failed to revert version change in {candidate}: {e2}"
                             )
-                except Exception as e2:
-                    print(
-                        f"Warning: Failed to revert version change in {mac_manifest_path}: {e2}"
-                    )
             except Exception as revert_e:
                 print(
                     f"Warning: Failed to revert version change in {pyproject_path}: {revert_e}"
@@ -332,7 +374,7 @@ def build_and_upload_wheel(bump_part: str = "patch"):
 # --- Dependency Management Commands ---
 
 
-def install_dependencies(
+def sync_with_toml(
     install_project: bool = typer.Option(
         False,
         "--install-project",
@@ -340,23 +382,154 @@ def install_dependencies(
         help="Install the local project package itself (with 'full' extras) into the environment.",
     ),
 ):
-    """Install dependencies respecting Mac devcontainer flow and the active venv.
-
-    Behavior:
-    - If running on Mac devcontainer (STUDIO_PLATFORM=mac) and `pyproject.mac.toml` exists:
+    """Sync environment with platform-specific TOML manifest (install/update dependencies).
+
+    Behavior by platform:
+    - Workstation (STUDIO_PLATFORM=workstation) with pyproject.workstation.toml:
+      * Uses pip with constraints.txt to preserve NGC PyTorch
+      * Parses dependencies directly from pyproject.workstation.toml
+      * Installs into .venv_workstation with --system-site-packages
+    - Mac (STUDIO_PLATFORM=mac) with pyproject.mac.toml:
       * Ensure `.mac_uv_project/pyproject.toml` is a copy of `pyproject.mac.toml`
-      * Run `uv lock` and `uv sync` in `.mac_uv_project` and always target the active venv with `--active`
+      * Run `uv lock` and `uv sync` in `.mac_uv_project` targeting active venv with `--active`
       * If `install_project` is true, install the project from repo root into the active env (editable, [full])
-    - Otherwise (default path):
-      * Operate in repo root, ensure lock, and `uv sync --active` so we don't create `.venv` accidentally
-      * If `install_project` is true, sync without `--no-install-project` (installs project)
+    - AWS (default) with pyproject.aws.toml:
+      * Uses UV in temp directory `.aws_uv_project` similar to Mac
+      * Run `uv lock` and `uv sync` targeting active venv
     """
     # ANSI color codes
     BLUE = "\033[94m"
     RESET = "\033[0m"
 
     try:
-        is_mac = os.environ.get("STUDIO_PLATFORM") == "mac"
+        platform = os.environ.get("STUDIO_PLATFORM", "aws")
+
+        # Workstation platform: use pip with constraints
+        if platform == "workstation" and Path("pyproject.workstation.toml").exists():
+            print(
+                "Installing dependencies for workstation platform (using pip + constraints)..."
+            )
+
+            # Check for constraints.txt
+            if not Path("constraints.txt").exists():
+                print(
+                    "Error: constraints.txt not found. Run direnv to generate it first."
+                )
+                sys.exit(1)
+
+            # Parse and install dependencies from pyproject.workstation.toml
+            import re
+
+            with open("pyproject.workstation.toml", "r") as f:
+                content = f.read()
+
+            # Extract dependencies list using line-by-line parsing to handle [] in package names
+            lines = content.split("\n")
+            in_deps = False
+            deps_lines = []
+
+            for line in lines:
+                if re.match(r"\s*dependencies\s*=\s*\[", line):
+                    in_deps = True
+                    continue
+                if in_deps:
+                    if re.match(r"^\s*\]\s*$", line):
+                        break
+                    deps_lines.append(line)
+
+            deps = []
+            for line in deps_lines:
+                line = line.strip()
+                if line.startswith('"') or line.startswith("'"):
+                    dep = re.sub(r'["\']', "", line)
+                    dep = re.sub(r",?\s*#.*$", "", dep)
+                    dep = dep.strip().rstrip(",")
+                    if dep:
+                        deps.append(dep)
+
+            if deps:
+                pip_cmd = (
+                    [sys.executable, "-m", "pip", "install"]
+                    + deps
+                    + ["-c", "constraints.txt"]
+                )
+                print(
+                    f"Running command: {BLUE}{' '.join(pip_cmd[:5])} ... -c constraints.txt{RESET}"
+                )
+                subprocess.run(pip_cmd, check=True)
+
+            # Install dev dependencies using line-by-line parsing
+            in_dev_groups = False
+            in_dev_list = False
+            dev_lines = []
+
+            for line in lines:
+                if re.match(r"\s*\[dependency-groups\]", line):
+                    in_dev_groups = True
+                    continue
+                if in_dev_groups and re.match(r"\s*dev\s*=\s*\[", line):
+                    in_dev_list = True
+                    continue
+                if in_dev_list:
+                    if re.match(r"^\s*\]\s*$", line):
+                        break
+                    dev_lines.append(line)
+
+            dev_deps = []
+            for line in dev_lines:
+                line = line.strip()
+                if line.startswith('"') or line.startswith("'"):
+                    dep = re.sub(r'["\']', "", line)
+                    dep = re.sub(r",?\s*#.*$", "", dep)
+                    dep = dep.strip().rstrip(",")
+                    if dep:
+                        dev_deps.append(dep)
+
+            if dev_deps:
+                print("Installing dev dependencies...")
+                pip_cmd = (
+                    [sys.executable, "-m", "pip", "install"]
+                    + dev_deps
+                    + ["-c", "constraints.txt"]
+                )
+                print(
+                    f"Running command: {BLUE}{' '.join(pip_cmd[:5])} ... -c constraints.txt{RESET}"
+                )
+                subprocess.run(pip_cmd, check=True)
+
+            # Install project if requested
+            if install_project:
+                repo_name = Path.cwd().name
+                if repo_name == "dayhoff-tools":
+                    pip_cmd = [
+                        sys.executable,
+                        "-m",
+                        "pip",
+                        "install",
+                        "-e",
+                        ".[full]",
+                        "-c",
+                        "constraints.txt",
+                    ]
+                else:
+                    pip_cmd = [
+                        sys.executable,
+                        "-m",
+                        "pip",
+                        "install",
+                        "-e",
+                        ".",
+                        "-c",
+                        "constraints.txt",
+                    ]
+                print(f"Running command: {BLUE}{' '.join(pip_cmd)}{RESET}")
+                subprocess.run(pip_cmd, check=True)
+
+            print("✅ Dependencies installed successfully (workstation)")
+            return
+
+        # Mac platform: use UV with pyproject.mac.toml
+        is_mac = platform == "mac"
         mac_manifest = Path("pyproject.mac.toml")
         if is_mac and mac_manifest.exists():
             # Mac devcontainer flow
@@ -399,29 +572,55 @@ def install_dependencies(
                 subprocess.run(sync_cmd, check=True, cwd=str(mac_uv_dir))
                 print("Dependencies synced successfully (project not installed).")
         else:
-            # Default behavior in repo root, but ensure we target the active env
-            print("Ensuring lock file matches pyproject.toml…")
-            lock_cmd = ["uv", "lock"]
-            print(f"Running command: {BLUE}{' '.join(lock_cmd)}{RESET}")
-            subprocess.run(lock_cmd, check=True, capture_output=True)
+            # AWS platform (or fallback): use UV with pyproject.aws.toml
+            aws_manifest = Path("pyproject.aws.toml")
+            if aws_manifest.exists():
+                # AWS devcontainer flow (similar to Mac)
+                aws_uv_dir = Path(".aws_uv_project")
+                aws_uv_dir.mkdir(parents=True, exist_ok=True)
+                aws_pyproject = aws_uv_dir / "pyproject.toml"
+                aws_pyproject.write_text(aws_manifest.read_text())
+
+                # Ensure lock matches manifest (in aws temp dir)
+                print("Ensuring lock file matches pyproject.aws.toml (AWS devcon)…")
+                lock_cmd = ["uv", "lock"]
+                print(f"Running command: {BLUE}{' '.join(lock_cmd)}{RESET}")
+                subprocess.run(
+                    lock_cmd, check=True, capture_output=True, cwd=str(aws_uv_dir)
+                )
 
-            if install_project:
-                print("Syncing dependencies into ACTIVE env (installing project)…")
-                sync_cmd = ["uv", "sync", "--all-groups", "--active"]
-                print(f"Running command: {BLUE}{' '.join(sync_cmd)}{RESET}")
-                subprocess.run(sync_cmd, check=True)
+                # Sync into the active environment
+                if install_project:
+                    print(
+                        "Syncing dependencies into ACTIVE env and installing project [full]…"
+                    )
+                    sync_cmd = ["uv", "sync", "--all-groups", "--active"]
+                    print(f"Running command: {BLUE}{' '.join(sync_cmd)}{RESET}")
+                    subprocess.run(sync_cmd, check=True, cwd=str(aws_uv_dir))
+                    # Install project from repo root
+                    pip_install_cmd = ["uv", "pip", "install", "-e", ".[full]"]
+                    print(f"Running command: {BLUE}{' '.join(pip_install_cmd)}{RESET}")
+                    subprocess.run(pip_install_cmd, check=True)
+                    print("Project installed with 'full' extras successfully.")
+                else:
+                    print(
+                        "Syncing dependencies into ACTIVE env (project not installed)…"
+                    )
+                    sync_cmd = [
+                        "uv",
+                        "sync",
+                        "--all-groups",
+                        "--no-install-project",
+                        "--active",
+                    ]
+                    print(f"Running command: {BLUE}{' '.join(sync_cmd)}{RESET}")
+                    subprocess.run(sync_cmd, check=True, cwd=str(aws_uv_dir))
+                    print("Dependencies synced successfully (project not installed).")
             else:
-                print("Syncing dependencies into ACTIVE env (project not installed)…")
-                sync_cmd = [
-                    "uv",
-                    "sync",
-                    "--all-groups",
-                    "--no-install-project",
-                    "--active",
-                ]
-                print(f"Running command: {BLUE}{' '.join(sync_cmd)}{RESET}")
-                subprocess.run(sync_cmd, check=True)
-                print("Dependencies synced successfully (project not installed).")
+                print(
+                    "Error: No platform-specific manifest found (pyproject.aws.toml, pyproject.mac.toml, or pyproject.workstation.toml)"
+                )
+                sys.exit(1)
 
     except subprocess.CalledProcessError as e:
         stderr_output = e.stderr.decode() if e.stderr else "No stderr output."
@@ -440,6 +639,252 @@ def install_dependencies(
         sys.exit(1)
 
 
+def _get_all_platform_manifests():
+    """Get list of all platform manifests that exist."""
+    manifest_files = []
+    for fname in [
+        "pyproject.aws.toml",
+        "pyproject.mac.toml",
+        "pyproject.workstation.toml",
+    ]:
+        if Path(fname).exists():
+            manifest_files.append(Path(fname))
+    return manifest_files
+
+
+def _update_all_manifests_for_dayhoff_tools(new_version: str):
+    """Update dayhoff-tools constraint in all platform manifests."""
+    import re
+
+    manifest_files = _get_all_platform_manifests()
+
+    if not manifest_files:
+        print("Warning: No platform manifests found to update.")
+        return
+
+    package_name = "dayhoff-tools"
+    package_name_esc = re.escape(package_name)
+
+    # Regex to match the dependency line, with optional extras and version spec
+    pattern = re.compile(
+        rf"^(\s*['\"]){package_name_esc}(\[[^]]+\])?(?:[><=~^][^'\"]*)?(['\"].*)$",
+        re.MULTILINE,
+    )
+
+    new_constraint_text = f">={new_version}"
+
+    def _repl(match: re.Match):
+        prefix = match.group(1)
+        extras = match.group(2) or ""
+        suffix = match.group(3)
+        return f"{prefix}{package_name}{extras}{new_constraint_text}{suffix}"
+
+    # Update all manifest files
+    for manifest_file in manifest_files:
+        try:
+            print(f"Updating {manifest_file} version constraint...")
+            content = manifest_file.read_text()
+            new_content, num_replacements = pattern.subn(_repl, content)
+            if num_replacements > 0:
+                manifest_file.write_text(new_content)
+                print(
+                    f"Updated dayhoff-tools constraint in {manifest_file} to '{new_constraint_text}'"
+                )
+            else:
+                print(
+                    f"Warning: Could not find dayhoff-tools dependency line in {manifest_file}"
+                )
+        except Exception as e:
+            print(f"Error updating {manifest_file}: {e}")
+
+
+def add_dependency(
+    package: str,
+    dev: bool = typer.Option(
+        False, "--dev", "-d", help="Add to dev dependencies instead of main."
+    ),
+):
+    """Add a dependency to all platform-specific manifests.
+
+    Args:
+        package: Package specification (e.g., "numpy>=1.24.0" or "pandas")
+        dev: If True, add to [dependency-groups] dev instead of [project] dependencies
+    """
+    import re
+
+    # ANSI color codes
+    BLUE = "\033[94m"
+    RESET = "\033[0m"
+
+    manifest_files = _get_all_platform_manifests()
+
+    if not manifest_files:
+        print(
+            "Error: No platform-specific manifests found (pyproject.aws.toml, pyproject.mac.toml, or pyproject.workstation.toml)"
+        )
+        sys.exit(1)
+
+    # Determine section to add to
+    section_name = "dev dependencies" if dev else "main dependencies"
+    print(f"Adding '{package}' to {section_name} in all platform manifests...")
+
+    # Parse package name to check for duplicates
+    package_name = re.split(r"[<>=~!\[]", package)[0].strip()
+
+    for manifest_file in manifest_files:
+        try:
+            content = manifest_file.read_text()
+
+            # Check if package already exists
+            existing_check = re.search(
+                rf'^(\s*["\']){re.escape(package_name)}[<>=~!\[]',
+                content,
+                re.MULTILINE,
+            )
+            if existing_check:
+                print(
+                    f"⚠️  Package '{package_name}' already exists in {manifest_file}, skipping"
+                )
+                continue
+
+            if dev:
+                # Add to [dependency-groups] dev section
+                # Use line-by-line parsing to handle [] in dependency names like dayhoff-tools[full]
+                lines = content.split("\n")
+                in_dev_groups = False
+                in_dev_list = False
+                dev_start_idx = None
+                dev_end_idx = None
+
+                for idx, line in enumerate(lines):
+                    if re.match(r"\s*\[dependency-groups\]", line):
+                        in_dev_groups = True
+                        continue
+                    if in_dev_groups and re.match(r"\s*dev\s*=\s*\[", line):
+                        in_dev_list = True
+                        dev_start_idx = idx
+                        continue
+                    if in_dev_list and re.match(r"^\s*\]\s*$", line):
+                        dev_end_idx = idx
+                        break
+
+                if dev_start_idx is None or dev_end_idx is None:
+                    print(
+                        f"Warning: Could not find [dependency-groups] dev section in {manifest_file}"
+                    )
+                    continue
+
+                # Insert new dependency before the closing ]
+                new_dep = f'    "{package}",'
+                lines.insert(dev_end_idx, new_dep)
+                new_content = "\n".join(lines)
+            else:
+                # Add to [project] dependencies section
+                # Use line-by-line parsing to handle [] in dependency names like dayhoff-tools[full]
+                lines = content.split("\n")
+                in_deps = False
+                deps_start_idx = None
+                deps_end_idx = None
+
+                for idx, line in enumerate(lines):
+                    if re.match(r"\s*dependencies\s*=\s*\[", line):
+                        in_deps = True
+                        deps_start_idx = idx
+                        continue
+                    if in_deps and re.match(r"^\s*\]\s*$", line):
+                        deps_end_idx = idx
+                        break
+
+                if deps_start_idx is None or deps_end_idx is None:
+                    print(
+                        f"Warning: Could not find dependencies section in {manifest_file}"
+                    )
+                    continue
+
+                # Insert new dependency before the closing ]
+                new_dep = f'    "{package}",'
+                lines.insert(deps_end_idx, new_dep)
+                new_content = "\n".join(lines)
+
+            manifest_file.write_text(new_content)
+            print(f"✅ Added '{package}' to {manifest_file}")
+
+        except Exception as e:
+            print(f"Error updating {manifest_file}: {e}")
+
+    print(f"\n✅ Added '{package}' to all platform manifests")
+    print(
+        f"\nRun {BLUE}dh tomlsync{RESET} to install the new dependency in your environment."
+    )
+
+
+def remove_dependency(
+    package: str,
+    dev: bool = typer.Option(
+        False, "--dev", "-d", help="Remove from dev dependencies instead of main."
+    ),
+):
+    """Remove a dependency from all platform-specific manifests.
+
+    Args:
+        package: Package name (e.g., "numpy" or "pandas")
+        dev: If True, remove from [dependency-groups] dev instead of [project] dependencies
+    """
+    import re
+
+    # ANSI color codes
+    BLUE = "\033[94m"
+    RESET = "\033[0m"
+
+    manifest_files = _get_all_platform_manifests()
+
+    if not manifest_files:
+        print(
+            "Error: No platform-specific manifests found (pyproject.aws.toml, pyproject.mac.toml, or pyproject.workstation.toml)"
+        )
+        sys.exit(1)
+
+    section_name = "dev dependencies" if dev else "main dependencies"
+    print(f"Removing '{package}' from {section_name} in all platform manifests...")
+
+    # Escape package name for regex
+    package_esc = re.escape(package)
+
+    removed_count = 0
+    for manifest_file in manifest_files:
+        try:
+            content = manifest_file.read_text()
+
+            # Pattern to match the dependency line (with optional version spec)
+            # Matches:  "package...",  or  "package...",\n
+            pattern = re.compile(
+                rf'^\s*["\']({package_esc}[<>=~!\[].+?|{package_esc})["\'],?\s*(?:#.*)?$',
+                re.MULTILINE,
+            )
+
+            new_content, num_removed = pattern.subn("", content)
+
+            if num_removed > 0:
+                # Clean up any double blank lines
+                new_content = re.sub(r"\n\n\n+", "\n\n", new_content)
+                manifest_file.write_text(new_content)
+                print(f"✅ Removed '{package}' from {manifest_file}")
+                removed_count += 1
+            else:
+                print(f"⚠️  Package '{package}' not found in {manifest_file}")
+
+        except Exception as e:
+            print(f"Error updating {manifest_file}: {e}")
+
+    if removed_count > 0:
+        print(f"\n✅ Removed '{package}' from {removed_count} platform manifest(s)")
+        print(
+            f"\nRun {BLUE}dh tomlsync{RESET} to uninstall the dependency from your environment."
+        )
+    else:
+        print(f"\n⚠️  Package '{package}' was not found in any manifests")
+
+
 def update_dependencies(
     update_all: bool = typer.Option(
         False,
@@ -448,29 +893,73 @@ def update_dependencies(
         help="Update all dependencies instead of just dayhoff-tools.",
     ),
 ):
-    """Update dependencies to newer versions (Mac-aware, active venv friendly).
+    """Update dependencies to newer versions (platform-aware).
 
     - Default Action (no flags): Updates only 'dayhoff-tools' package to latest,
       updates ALL manifest files with the version constraint, and syncs.
     - Flags:
-      --all/-a: Updates all dependencies (uv lock --upgrade) and syncs.
+      --all/-a: Updates all dependencies and syncs.
 
     Cross-platform behavior:
-    - Always updates BOTH `pyproject.toml` and `pyproject.mac.toml` (if they exist)
-      to ensure version consistency across AWS and Mac platforms.
-    - On Mac: If STUDIO_PLATFORM=mac and `pyproject.mac.toml` exists, operates in
-      `.mac_uv_project/` and copies `pyproject.mac.toml` to `.mac_uv_project/pyproject.toml`.
-    - Always uses `--active` for sync to target the active venv.
+    - Workstation: Uses pip to upgrade packages, regenerates constraints.txt
+    - Mac/AWS: Uses UV with platform-specific manifests (.mac_uv_project or .aws_uv_project)
+    - Always updates ALL platform manifests (pyproject.aws.toml, pyproject.mac.toml,
+      pyproject.workstation.toml) to ensure version consistency
     """
     # ANSI color codes
     BLUE = "\033[94m"
     RESET = "\033[0m"
 
-    is_mac = os.environ.get("STUDIO_PLATFORM") == "mac"
+    platform = os.environ.get("STUDIO_PLATFORM", "aws")
+
+    # Workstation platform: use pip upgrade
+    if platform == "workstation" and Path("pyproject.workstation.toml").exists():
+        print("Updating dependencies for workstation platform (using pip)...")
+
+        if update_all:
+            print("Error: --all flag not supported on workstation platform yet.")
+            print("Use 'pip install --upgrade <package>' manually for now.")
+            sys.exit(1)
+
+        # Update dayhoff-tools only (default behavior)
+        print("Upgrading dayhoff-tools to latest version...")
+        upgrade_cmd = [
+            sys.executable,
+            "-m",
+            "pip",
+            "install",
+            "--upgrade",
+            "dayhoff-tools[full]",
+        ]
+        print(f"Running command: {BLUE}{' '.join(upgrade_cmd)}{RESET}")
+        subprocess.run(upgrade_cmd, check=True)
+
+        # Get new version
+        result = subprocess.run(
+            [sys.executable, "-m", "pip", "show", "dayhoff-tools"],
+            capture_output=True,
+            text=True,
+            check=True,
+        )
+        version_line = [
+            l for l in result.stdout.split("\n") if l.startswith("Version:")
+        ]
+        if version_line:
+            new_version = version_line[0].split(":", 1)[1].strip()
+            print(f"Updated to dayhoff-tools {new_version}")
+
+            # Update all platform manifests with new constraint
+            _update_all_manifests_for_dayhoff_tools(new_version)
+
+        print("✅ Dependencies updated successfully (workstation)")
+        return
+
+    # Mac/AWS platforms: use UV
     mac_manifest = Path("pyproject.mac.toml")
+    aws_manifest = Path("pyproject.aws.toml")
     mac_uv_dir = Path(".mac_uv_project")
+    aws_uv_dir = Path(".aws_uv_project")
     lock_file_path = Path("uv.lock")
-    pyproject_path = Path("pyproject.toml")
 
     # Determine action based on flags
     lock_cmd = ["uv", "lock"]
@@ -492,15 +981,29 @@ def update_dependencies(
         )
 
     try:
-        # Choose working directory for uv operations
+        # Choose working directory for uv operations based on platform
         uv_cwd = None
-        manifest_path_for_constraint = pyproject_path
-        if is_mac and mac_manifest.exists():
+        manifest_path_for_constraint = None
+
+        if platform == "mac" and mac_manifest.exists():
             mac_uv_dir.mkdir(parents=True, exist_ok=True)
             (mac_uv_dir / "pyproject.toml").write_text(mac_manifest.read_text())
             uv_cwd = str(mac_uv_dir)
             lock_file_path = mac_uv_dir / "uv.lock"
             manifest_path_for_constraint = mac_manifest
+        elif aws_manifest.exists():
+            # AWS platform (default)
+            aws_uv_dir.mkdir(parents=True, exist_ok=True)
+            (aws_uv_dir / "pyproject.toml").write_text(aws_manifest.read_text())
+            uv_cwd = str(aws_uv_dir)
+            lock_file_path = aws_uv_dir / "uv.lock"
+            manifest_path_for_constraint = aws_manifest
+        else:
+            print(
+                "Error: No platform-specific manifest found (pyproject.aws.toml or pyproject.mac.toml)"
+            )
+            sys.exit(1)
+
         # Step 1: Run the update lock command
         print(action_description)
         print(f"Running command: {BLUE}{' '.join(lock_cmd)}{RESET}")
@@ -534,61 +1037,8 @@ def update_dependencies(
 
             print(f"Found dayhoff-tools version {locked_version} in lock file.")
 
-            # Update both manifest files to ensure consistency across platforms
-            manifest_files_to_update = []
-            if pyproject_path.exists():
-                manifest_files_to_update.append(pyproject_path)
-            if mac_manifest.exists():
-                manifest_files_to_update.append(mac_manifest)
-
-            if not manifest_files_to_update:
-                print("Warning: No manifest files found to update.")
-                return
-
-            package_name = "dayhoff-tools"
-            package_name_esc = re.escape(package_name)
-
-            # Regex to match the dependency line, with optional extras and version spec
-            pattern = re.compile(
-                rf"^(\s*['\"]){package_name_esc}(\[[^]]+\])?(?:[><=~^][^'\"]*)?(['\"].*)$",
-                re.MULTILINE,
-            )
-
-            new_constraint_text = f">={locked_version}"
-
-            def _repl(match: re.Match):
-                prefix = match.group(1)
-                extras = match.group(2) or ""
-                suffix = match.group(3)
-                return f"{prefix}{package_name}{extras}{new_constraint_text}{suffix}"
-
-            # Update all manifest files
-            updated_files = []
-            for manifest_file in manifest_files_to_update:
-                try:
-                    print(f"Updating {manifest_file} version constraint...")
-                    content = manifest_file.read_text()
-                    new_content, num_replacements = pattern.subn(_repl, content)
-                    if num_replacements > 0:
-                        manifest_file.write_text(new_content)
-                        print(
-                            f"Updated dayhoff-tools constraint in {manifest_file} to '{new_constraint_text}'"
-                        )
-                        updated_files.append(str(manifest_file))
-                    else:
-                        print(
-                            f"Warning: Could not find dayhoff-tools dependency line in {manifest_file}"
-                        )
-                except FileNotFoundError:
-                    print(f"Warning: {manifest_file} not found.")
-                except Exception as e:
-                    print(f"Error updating {manifest_file}: {e}")
-
-            if not updated_files:
-                print(
-                    "Warning: No manifest files were successfully updated with dayhoff-tools constraint."
-                )
-                print("Proceeding with sync despite manifest update failures.")
+            # Update all platform manifest files to ensure consistency
+            _update_all_manifests_for_dayhoff_tools(locked_version)
 
         # Step 3: Sync environment
         print("Syncing environment with updated lock file...")

{dayhoff_tools-1.11.1.dist-info → dayhoff_tools-1.11.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dayhoff-tools
-Version: 1.11.1
+Version: 1.11.3
 Summary: Common tools for all the repos at Dayhoff Labs
 Author: Daniel Martin-Alarcon
 Author-email: dma@dayhofflabs.com

{dayhoff_tools-1.11.1.dist-info → dayhoff_tools-1.11.3.dist-info}/RECORD

@@ -10,9 +10,9 @@ dayhoff_tools/cli/engine/engine_maintenance.py,sha256=S9w2_Ko2C3zKpzOux-iG8QUYn0
 dayhoff_tools/cli/engine/engine_management.py,sha256=s_H3FtMlKsdfzR8pwV-j2W2QX-Fypkqj2kPC0aTqC1A,19072
 dayhoff_tools/cli/engine/shared.py,sha256=Ecx6I1jtzmxQDn3BezKpgpQ4SJeZf4SZjUCLg-67p80,16844
 dayhoff_tools/cli/engine/studio_commands.py,sha256=VwTQujz32-uMcYusDRE73SdzRpgvIkv7ZAF4zRv6AzA,30266
-dayhoff_tools/cli/main.py,sha256=yXedWjo6hyvYd8N7IowE7Xpm9hO75ZSJmzNQIKwOp2A,5924
+dayhoff_tools/cli/main.py,sha256=Ii5boey--93yGthB_eS2LC7ZR3WHGsJXDHY7uElEtso,6169
 dayhoff_tools/cli/swarm_commands.py,sha256=5EyKj8yietvT5lfoz8Zx0iQvVaNgc3SJX1z2zQR6o6M,5614
-dayhoff_tools/cli/utility_commands.py,sha256=WQTHOh1MttuxaJjl2c6zMa4x7_JuaKMQgcyotYrU3GA,25883
+dayhoff_tools/cli/utility_commands.py,sha256=Yk2s09Dqkmv1CWJhhMV07Gy0-hZpQhkfiTSmOlykAa8,42185
 dayhoff_tools/deployment/base.py,sha256=48KE76QlWMeIZJefcBOZVbyChS2V_mgs7IQ31odPV2o,17806
 dayhoff_tools/deployment/deploy_aws.py,sha256=gfqh09hGbz0q3oPqVm0imd_CEjKF2k8moGNRIL26qqE,18614
 dayhoff_tools/deployment/deploy_gcp.py,sha256=xgaOVsUDmP6wSEMYNkm1yRNcVskfdz80qJtCulkBIAM,8860
@@ -33,7 +33,7 @@ dayhoff_tools/intake/uniprot.py,sha256=BZYJQF63OtPcBBnQ7_P9gulxzJtqyorgyuDiPeOJq
 dayhoff_tools/logs.py,sha256=DKdeP0k0kliRcilwvX0mUB2eipO5BdWUeHwh-VnsICs,838
 dayhoff_tools/sqlite.py,sha256=jV55ikF8VpTfeQqqlHSbY8OgfyfHj8zgHNpZjBLos_E,18672
 dayhoff_tools/warehouse.py,sha256=UETBtZD3r7WgvURqfGbyHlT7cxoiVq8isjzMuerKw8I,24475
-dayhoff_tools-1.11.1.dist-info/METADATA,sha256=NsKWCXtoQaMqYaHhSQi61uSbcIn3KTuHHxxjUNguB5U,2980
-dayhoff_tools-1.11.1.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-dayhoff_tools-1.11.1.dist-info/entry_points.txt,sha256=iAf4jteNqW3cJm6CO6czLxjW3vxYKsyGLZ8WGmxamSc,49
-dayhoff_tools-1.11.1.dist-info/RECORD,,
+dayhoff_tools-1.11.3.dist-info/METADATA,sha256=tESeKSHZIZHMi5ekLoJRkRTyBTON40yJ0oegecixNnY,2980
+dayhoff_tools-1.11.3.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+dayhoff_tools-1.11.3.dist-info/entry_points.txt,sha256=iAf4jteNqW3cJm6CO6czLxjW3vxYKsyGLZ8WGmxamSc,49
+dayhoff_tools-1.11.3.dist-info/RECORD,,