tgzr.package_management 0.100__tar.gz → 0.102__tar.gz

{tgzr_package_management-0.100 → tgzr_package_management-0.102}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: tgzr.package_management
-Version: 0.100
+Version: 0.102
 Summary: tgzr package_management engine
 Project-URL: Documentation, https://github.com/open-tgzr/tgzr.package_management#readme
 Project-URL: Issues, https://github.com/open-tgzr/tgzr.package_management/issues
@@ -20,6 +20,9 @@ Classifier: Programming Language :: Python :: Implementation :: PyPy
 Requires-Python: >=3.9
 Requires-Dist: hatch
 Requires-Dist: importlib-metadata
+Requires-Dist: msgspec
+Requires-Dist: packaging
+Requires-Dist: toml
 Requires-Dist: uv
 Description-Content-Type: text/markdown
 

{tgzr_package_management-0.100 → tgzr_package_management-0.102}/pyproject.toml

@@ -1,5 +1,5 @@
 [build-system]
-requires = ["hatchling", "hatch-vcs"] 
+requires = ["hatchling", "hatch-vcs"]
 build-backend = "hatchling.build"
 
 [project]
@@ -10,9 +10,7 @@ readme = "README.md"
 requires-python = ">=3.9"
 license = "GPL-3.0-or-later"
 keywords = []
-authors = [
-  { name = "Dee", email = "dee.sometech@gmail.com" },
-]
+authors = [{ name = "Dee", email = "dee.sometech@gmail.com" }]
 classifiers = [
   "Development Status :: 4 - Beta",
   "Programming Language :: Python",
@@ -26,8 +24,11 @@ classifiers = [
 ]
 
 dependencies = [
+  "packaging",
   "uv",
   "hatch",
+  'msgspec',
+  "toml",
   "importlib-metadata", # needed to support modern Distribution api with py3.9
 ]
 
@@ -55,9 +56,7 @@ artifacts = ['_version.py']
 packages = ["src/tgzr"]
 
 [tool.hatch.envs.types]
-extra-dependencies = [
-  "mypy>=1.0.0",
-]
+extra-dependencies = ["mypy>=1.0.0"]
 
 [tool.hatch.envs.types.scripts]
 check = "mypy --install-types --non-interactive {args:src/tgzr/package_management tests}"
@@ -66,19 +65,14 @@ check = "mypy --install-types --non-interactive {args:src/tgzr/package_managemen
 source_pkgs = ["tgzr.package_management", "tests"]
 branch = true
 parallel = true
-omit = [
-  "src/tgzr/package_management/_version.py",
-]
+omit = ["src/tgzr/package_management/_version.py"]
 
 [tool.coverage.paths]
-tgzr.package_management = ["src/tgzr/package_management", "*/tgzr.package_management/src/tgzr/package_management"]
+tgzr.package_management = [
+  "src/tgzr/package_management",
+  "*/tgzr.package_management/src/tgzr/package_management",
+]
 tests = ["tests", "*/tgzr/package_management/tests"]
 
 [tool.coverage.report]
-exclude_lines = [
-  "no cov",
-  "if __name__ == .__main__.:",
-  "if TYPE_CHECKING:",
-]
-
-
+exclude_lines = ["no cov", "if __name__ == .__main__.:", "if TYPE_CHECKING:"]

{tgzr_package_management-0.100 → tgzr_package_management-0.102}/tgzr/package_management/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.100'
-__version_tuple__ = version_tuple = (0, 100)
+__version__ = version = '0.102'
+__version_tuple__ = version_tuple = (0, 102)
 
 __commit_id__ = commit_id = None

tgzr_package_management-0.102/tgzr/package_management/distribution.py

@@ -0,0 +1,8 @@
+from __future__ import annotations
+
+from importlib_metadata import Distribution as _CoreDistribution
+
+
+class Distribution(_CoreDistribution):
+    # TODO: add a better API for location
+    pass

{tgzr_package_management-0.100 → tgzr_package_management-0.102}/tgzr/package_management/package_manager.py

@@ -1,14 +1,32 @@
 from __future__ import annotations
+from typing import Literal
 
 import os
 import platform
 from pathlib import Path
 
 from .venv import Venv
+from .workspace import Workspace
 
 
 class PackageManager:
     def __init__(self, root: Path) -> None:
+        """
+        The venvs and workspace created by this manager will
+        be located in their group folder:
+            root/
+                group1/
+                    venv1
+                    venv2
+                    workspace1
+                group2/
+                    venv3
+                    venv4
+                    workspace2
+                group3/
+                    workspace3
+        """
+
         self._root = root
 
     @property
@@ -73,3 +91,24 @@ class PackageManager:
         venv.create(prompt, clear_existing=exist_ok)
         venv.install_uv()
         return venv
+
+    def get_workspace_path(self, workspace_name: str, group: str) -> Path:
+        return self.root / group / workspace_name
+
+    def get_workspace(self, workspace_name: str, group: str) -> Workspace:
+        return Workspace(self.get_workspace_path(workspace_name, group))
+
+    def create_workspace(
+        self,
+        workspace_name: str,
+        group: str,
+        description: str | None = None,
+        python_version: str | None = None,
+        vcs: Literal["git", "none"] | None = None,
+        exist_ok: bool = False,
+    ):
+        workspace = self.get_workspace(workspace_name, group)
+        if workspace.exists() and not exist_ok:
+            raise ValueError(f"The workspace {workspace.path} already exists!")
+
+        workspace.create(description, python_version, vcs)

{tgzr_package_management-0.100 → tgzr_package_management-0.102}/tgzr/package_management/plugin_manager.py

@@ -10,12 +10,10 @@ from typing import (
     Generic,
 )
 
-import sys
 import importlib_metadata
 import inspect
 import logging
 
-import rich
 
 T = TypeVar("T", bound="Plugin")
 
@@ -59,6 +57,23 @@ class Plugin:
 PluginType = TypeVar("PluginType", bound=Plugin)
 
 
+class PluginManagerRegistry:
+    """
+    A Registry containing all the PluginManager instances.
+    This is used for documenting/inspecting plugins usage.
+    """
+
+    _PLUGIN_MANAGERS: set[PluginManager] = set()
+
+    @classmethod
+    def register(cls, plugin_manager: PluginManager):
+        cls._PLUGIN_MANAGERS.add(plugin_manager)
+
+    @classmethod
+    def get_plugin_managers(cls) -> set[PluginManager]:
+        return cls._PLUGIN_MANAGERS.copy()
+
+
 class PluginManager(Generic[PluginType]):
     EP_GROUP = "your_plugin_entry_point_group"
 
@@ -67,6 +82,8 @@ class PluginManager(Generic[PluginType]):
         return get_args(cls.__orig_bases__[0])[0]  # type: ignore __orig_bases__ trust me bro.
 
     def __init__(self):
+        PluginManagerRegistry.register(self)
+
         self._broken: list[tuple[importlib_metadata.EntryPoint, Exception]] = []
         self._loaded: list[PluginType] = []
         self._needs_loading: bool = True
@@ -107,7 +124,7 @@ class PluginManager(Generic[PluginType]):
                 plugin_or_list_of_plugins = loaded()  # type: ignore
             except Exception as err:
                 raise ValueError(
-                    f"Error while executing callable entry point value (ep={entry_point}): {err}"
+                    f"Error while executing callable entry point value (ep={entry_point}): {err} ({loaded=}, {ManagedPluginType=})"
                 )
             return self._resolve_plugins(
                 loaded=plugin_or_list_of_plugins, entry_point=entry_point

tgzr_package_management-0.102/tgzr/package_management/pyproject.py

@@ -0,0 +1,262 @@
+"""
+
+API to edit pyproject.toml files.
+
+Originally from https://jcristharif.com/msgspec/examples/pyproject-toml.html
+
+"""
+
+from __future__ import annotations
+from typing import Any
+
+from pathlib import Path
+
+import msgspec
+
+
+class Base(
+    msgspec.Struct,
+    omit_defaults=True,
+    forbid_unknown_fields=True,
+    rename="kebab",
+):
+    """A base class holding some common settings.
+
+    - We set ``omit_defaults = True`` to omit any fields containing only their
+      default value from the output when encoding.
+    - We set ``forbid_unknown_fields = True`` to error nicely if an unknown
+      field is present in the input TOML. This helps catch typo errors early,
+      and is also required per PEP 621.
+    - We set ``rename = "kebab"`` to rename all fields to use kebab case when
+      encoding/decoding, as this is the convention used in pyproject.toml. For
+      example, this will rename ``requires_python`` to ``requires-python``.
+    """
+
+    pass
+
+
+class BuildSystem(Base):
+    requires: list[str] = []
+    build_backend: str | None = None
+    backend_path: list[str] = []
+
+
+class Readme(Base):
+    file: str | None = None
+    text: str | None = None
+    content_type: str | None = None
+
+
+class License(Base):
+    file: str | None = None
+    text: str | None = None
+
+
+class Contributor(Base):
+    name: str | None = None
+    email: str | None = None
+
+
+class Project(Base):
+    name: str | None = None
+    version: str | None = None
+    description: str | None = None
+    readme: str | Readme | None = None
+    license: str | License | None = None
+    authors: list[Contributor] = []
+    maintainers: list[Contributor] = []
+    keywords: list[str] | None = None
+    classifiers: list[str] = []
+    urls: dict[str, str] = {}
+    requires_python: str | None = None
+    dependencies: list[str] = []
+    optional_dependencies: dict[str, list[str]] = {}
+    scripts: dict[str, str] = {}
+    gui_scripts: dict[str, str] = {}
+    entry_points: dict[str, dict[str, str]] = {}
+    dynamic: list[str] = []
+
+
+class ToolUVSource(Base):
+    index: str | None = None
+    workspace: bool | None = False
+    path: str | None = None
+    editable: bool | None = None
+
+
+class ToolUVIndex(Base):
+    name: str
+    url: str
+    explicit: bool | None = None
+
+
+class ToolUVWorkspace(Base):
+    members: list[str] = []
+
+
+class ToolUV(Base):
+    sources: dict[str, ToolUVSource] = {}
+    index: list[ToolUVIndex] = []
+    workspace: ToolUVWorkspace | None = None
+
+
+class ToolHatchMetadata(Base):
+    allow_custom_classifiers: bool | None = False
+
+
+class ToolHatchVersion(Base):
+    path: str | None = None
+    source: str | None = None
+    fallback_version: str | None = None
+
+
+class ToolHatchBuildTarget(Base):
+    artifacts: list[str] = []
+    packages: list[str] = []
+    hooks: dict[str, Any] = {}
+
+
+class ToolHatchBuild(Base):
+    artifacts: list[str] = []
+    packages: list[str] = []
+    hooks: dict[str, Any] = {}
+    targets: dict[str, ToolHatchBuildTarget] = {}
+
+
+class ToolHatch(Base):
+    metadata: dict[str, str | bool] = {}
+    envs: dict[str, Any] | None = None
+    version: ToolHatchVersion | None = None
+    build: ToolHatchBuild | None = None
+    # publish: dict[str, str] | None = {}
+
+
+class ToolCoverageRun(Base):
+    source_pkgs: list[str] = msgspec.field(default=[], name="source_pkgs")
+    branch: bool = True
+    parallel: bool = True
+    omit: list[str] = []
+
+
+class ToolCoverage(Base):
+    run: Any | None = None
+    paths: dict[str, Any] = {}
+    report: Any | None = None
+
+
+class ToolSetuptoolsScme(Base):
+    version_file: str | None = msgspec.field(default=None, name="version_file")
+
+
+class ToolRuffLintISort(Base):
+    force_sort_within_sections: bool = False
+
+
+class ToolRuffLint(Base):
+    isort: ToolRuffLintISort | None = None
+
+
+class ToolRuff(Base):
+    lint: ToolRuffLint | None = None
+
+
+class ToolMypy(Base):
+    check_untyped_defs: bool = False
+    disallow_untyped_defs: bool = False
+    disallow_untyped_calls: bool = False
+    overrides: list[Any] = []
+
+
+class Tools(Base):
+    """
+    We can't specify a Tool subclass depending on the Tool name,
+    so this Tool struct needs to handle ALL the tools we need at
+    once :/
+    Sucks, but good enough for me :p
+    """
+
+    hatch: ToolHatch | None = None
+    uv: ToolUV | None = None
+    coverage: ToolCoverage | None = None
+    setuptools_scm: ToolSetuptoolsScme | None = msgspec.field(
+        default=None, name="setuptools_scm"
+    )
+    ruff: ToolRuff | None = None
+    mypy: ToolMypy | None = None
+    setuptools: Any | None = None
+
+
+class PyProject(Base):
+
+    build_system: BuildSystem | None = None
+    project: Project | None = None
+    dependency_groups: dict[str, list[str]] = {}
+    tool: Tools | None = None
+
+    def set_filepath(self, filepath: Path):
+        self._filepath = filepath
+
+
+def load_pyproject(filepath: Path | str):
+    filepath = Path(filepath)
+    with filepath.open() as fp:
+        data = fp.read()
+    pyproject = msgspec.toml.decode(data, type=PyProject)
+    return pyproject
+
+
+def save_pyproject(pyproject: PyProject, filepath: Path | str):
+    filepath = Path(filepath)
+    data = msgspec.toml.encode(pyproject)
+    with filepath.open("wb") as fp:
+        fp.write(data)
+
+
+def test():
+    import toml
+    import json
+    import rich
+    import dictdiffer
+
+    stats = dict(
+        tested=0,
+        failed=0,
+    )
+
+    def assert_roundtrip(path: str | Path):
+        stats["tested"] += 1
+        path = Path(path)
+        try:
+            pp = load_pyproject(path)
+        except Exception as err:
+            raise Exception(f"pyproject load failed for {path}: {err}")
+        pp_dict = json.loads(msgspec.json.encode(pp))
+        toml_dict = toml.load(path)
+        try:
+            assert pp_dict == toml_dict
+        except AssertionError:
+            stats["failed"] += 1
+            if 0:
+                print(10 * "##")
+                rich.print(pp_dict)
+                print(10 * "--")
+                rich.print(toml_dict)
+
+            print(f"Diff found for {str(path)}:")
+            for diff in dictdiffer.diff(pp_dict, toml_dict):
+                print(diff)
+
+            print(f"Roundtrip failed for {str(path)}!")
+
+    root_path = Path("/home/dee/DEV/_OPEN-TGZR_")
+    for folder in root_path.iterdir():
+        pyproject_filename = folder / "pyproject.toml"
+        if pyproject_filename.exists():
+            print("Testing", pyproject_filename)
+            assert_roundtrip(pyproject_filename)
+
+    print(f"Stats: {stats}")
+
+
+if __name__ == "__main__":
+    test()

{tgzr_package_management-0.100 → tgzr_package_management-0.102}/tgzr/package_management/venv.py

@@ -194,26 +194,26 @@ class Venv:
             ret.append(dist)
         return ret
 
-    def get_packages_slow(self) -> list[tuple[str, str, str]]:
-        stdout, stderr = self.get_cmd_output(
-            cmd_name="uv",
-            # cmd_args=["pip", "tree", "-d", "0"],
-            cmd_args=["pip", "list", "--format", "json"],
-        )
-        try:
-            data = json.loads(stdout)
-        except Exception as err:
-            raise ValueError(f"Error parsing pip list output: {err}")
-        ret = []
-        for entry in data:
-            ret.append(
-                (
-                    entry["name"],
-                    entry["version"],
-                    entry.get("editable_project_location"),
-                )
-            )
-        return ret
+    # def get_packages_slow(self) -> list[tuple[str, str, str]]:
+    #     stdout, stderr = self.get_cmd_output(
+    #         cmd_name="uv",
+    #         # cmd_args=["pip", "tree", "-d", "0"],
+    #         cmd_args=["pip", "list", "--format", "json"],
+    #     )
+    #     try:
+    #         data = json.loads(stdout)
+    #     except Exception as err:
+    #         raise ValueError(f"Error parsing pip list output: {err}")
+    #     ret = []
+    #     for entry in data:
+    #         ret.append(
+    #             (
+    #                 entry["name"],
+    #                 entry["version"],
+    #                 entry.get("editable_project_location"),
+    #             )
+    #         )
+    #     return ret
 
     def get_plugins(
         self, group_filter: str | None
@@ -230,23 +230,70 @@ class Venv:
                     plugins.append([ep, dist])
         return plugins
 
-    def get_plugins_slow(
-        self, group_filter: str | None
-    ) -> list[importlib_metadata.EntryPoint]:
-        cmd_args = ["studio", "plugins-here", "--format", "json"]
-        if group_filter:
-            cmd_args.extend(["--group-filter", group_filter])
-        stdout, stderr = self.get_cmd_output("tgzr", cmd_args)
-        # print("???", [stdout, stderr])
-        stdout = stdout.split(">>> JSON:", 1)[-1]
-
-        data = json.loads(stdout)
-        # print("-->", data)
-        ret = []
-        for entry in data:
-            # print(entry)
-            ep = importlib_metadata.EntryPoint(
-                entry["name"], entry["value"], entry["group"]
-            )
-            ret.append(ep)
-        return ret
+    # def get_plugins_slow(
+    #     self, group_filter: str | None
+    # ) -> list[importlib_metadata.EntryPoint]:
+    #     cmd_args = ["studio", "plugins-here", "--format", "json"]
+    #     if group_filter:
+    #         cmd_args.extend(["--group-filter", group_filter])
+    #     stdout, stderr = self.get_cmd_output("tgzr", cmd_args)
+    #     # print("???", [stdout, stderr])
+    #     stdout = stdout.split(">>> JSON:", 1)[-1]
+
+    #     data = json.loads(stdout)
+    #     # print("-->", data)
+    #     ret = []
+    #     for entry in data:
+    #         # print(entry)
+    #         ep = importlib_metadata.EntryPoint(
+    #             entry["name"], entry["value"], entry["group"]
+    #         )
+    #         ret.append(ep)
+    #     return ret
+
+    def hatch_version_bump(self, package_path: Path, bump_type: str):
+        hatch_exe = self.get_exe("hatch")
+        subprocess.call(
+            [hatch_exe, "version", bump_type],
+            cwd=package_path,
+        )
+
+    def hatch_build(
+        self,
+        package_path: str | Path,
+        dist_path: str | Path,
+        allow_custom_classifiers=True,
+    ):
+        env = None
+        if allow_custom_classifiers:
+            env = os.environ.copy()
+            # This is needed to build a package with custom classifiers:
+            env["HATCH_METADATA_CLASSIFIERS_NO_VERIFY"] = "1"
+
+        hatch_exe = self.get_exe("hatch")
+        subprocess.call(
+            [hatch_exe, "build", "-t", "sdist", dist_path],
+            cwd=package_path,
+            env=env,
+        )
+
+    def hatch_publish(
+        self, package_path: str | Path, dist_path: Path, repo_url: str, **options: str
+    ):
+        hatch_options = sum([["-o", f"{k}={v}"] for k, v in options.items()], [])
+        hatch_exe = self.get_exe("hatch")
+        cmd = [
+            hatch_exe,
+            "publish",
+            # "--publisher",
+            # "tgzr-pipeline-asset",
+            "--repo",
+            repo_url,
+            *hatch_options,
+            *dist_path.iterdir(),
+        ]
+        # print("--->", cmd)
+        subprocess.call(
+            cmd,
+            cwd=package_path,
+        )

tgzr_package_management-0.102/tgzr/package_management/workspace.py

@@ -0,0 +1,264 @@
+from __future__ import annotations
+from typing import Literal, Any
+
+import os
+from pathlib import Path
+import subprocess
+import subprocess
+import logging
+
+from packaging.requirements import Requirement
+import uv
+
+from . import pyproject
+from .pyproject import (
+    PyProject,
+    Project,
+    Tools,
+    ToolUV,
+    ToolUVIndex,
+    ToolUVSource,
+    ToolUVWorkspace,
+)
+from .venv import Venv
+
+logger = logging.getLogger(__name__)
+
+
+class Workspace:
+    """
+    A uv workspace
+    """
+
+    def __init__(
+        self,
+        path: Path | str,
+    ) -> None:
+        self._path = Path(path)
+        self._pyproject_filename = self._path / "pyproject.toml"
+        self._pyproject: PyProject | None = None
+
+    @property
+    def path(self) -> Path:
+        """The Path of the workspace."""
+        return self._path
+
+    @property
+    def name(self) -> str:
+        """The name of the workspace folder."""
+        return self._path.name
+
+    @property
+    def group(self) -> str:
+        """The name of the parent folder (sometime representing a group of workspaces)."""
+        return self._path.parent.name
+
+    def exists(self) -> bool:
+        """
+        Returns True if the folder exists and contains a pyproject.toml
+        NB: It could be True for non-workspace folders, we assume you don't mess up your project paths.
+        """
+        return self._path.exists() and self._pyproject_filename.exists()
+
+    def venv(self) -> Venv:
+        venv_name = ".venv"
+        return Venv(self.path / venv_name)
+
+    def create(
+        self,
+        description: str | None = None,
+        python_version: str | None = None,
+        vcs: Literal["git", "none"] | None = None,
+    ) -> None:
+        description = (
+            description
+            or "A UV workspace, managed by tgzr.package_management.workspcace."
+        )
+        descr_args = []
+        if description is not None:
+            descr_args = ["--description", description]
+
+        py_args = []
+        if python_version is not None:
+            py_args = ["-p", python_version]
+
+        uv_exe = uv.find_uv_bin()
+        cmd = [
+            uv_exe,
+            "init",
+            "--no-package",
+            "--vcs",
+            vcs,
+            *py_args,
+            "--no-workspace",
+            *descr_args,
+            "--author-from",
+            "auto",
+            str(self.path),
+        ]
+        print(f"Creating workspace {self.path}: {cmd}")
+        subprocess.check_call(cmd)
+
+    @property
+    def pyproject(self) -> PyProject:
+        if self._pyproject is None:
+            self._pyproject = pyproject.load_pyproject(self._pyproject_filename)
+            if self.pyproject.tool is None:
+                self.pyproject.tool = Tools(uv=ToolUV())
+            if self.pyproject.tool.uv is None:
+                self.pyproject.tool.uv = ToolUV()
+
+        return self._pyproject
+
+    @property
+    def tool_uv(self) -> ToolUV:
+        """The PyProject.tool.uv configuration."""
+        return self.pyproject.tool.uv  # type: ignore self.pyproject ensure it's not None!
+
+    def save_pyproject(self) -> None:
+        pyproject.save_pyproject(self.pyproject, self._pyproject_filename)
+
+    def get_index(self, name: str) -> ToolUVIndex | None:
+        for index in self.tool_uv.index:
+            if index.name == name:
+                return index
+
+    def ensure_index(self, name: str, url: str, explicit: bool | None = None) -> None:
+        """
+        Will create or update the index with name `name`.
+        """
+        index_to_set = ToolUVIndex(name=name, url=url, explicit=explicit)
+        found = False
+        for index in self.tool_uv.index:
+            if index == index_to_set:
+                # it is already set exactly as requested
+                return
+
+            if index.name == index_to_set.name:
+                found = True
+                index.url = index_to_set.url
+                index.explicit = index_to_set.explicit
+                break
+        if not found:
+            self.tool_uv.index.append(index_to_set)
+        self.save_pyproject()
+
+    def set_source(
+        self,
+        source_name: str,
+        index_name: str | None = None,
+        workspace: bool | None = None,
+        path: Path | str | None = None,
+        editable: bool | None = None,
+    ) -> None:
+        """
+        Beware: not all combinations of index/workspace/path/editable are valid!
+
+        When index_name is given, an index with that name must already
+        have been defined. You can use `self.ensure_index()` if needed.
+        """
+        source = self.tool_uv.sources.get(source_name)
+        if source is None:
+            source = ToolUVSource()
+            self.tool_uv.sources[source_name] = source
+
+        if index_name is not None:
+            source.index = index_name
+
+        if workspace is not None:
+            source.workspace = workspace
+
+        if path is not None:
+            source.path = str(path)
+
+        if editable is not None:
+            source.editable = editable
+
+        self.save_pyproject()
+
+    def add_dependencies(self, group: str = "", *new_requirements):
+        if self.pyproject.project is None:
+            self.pyproject.project = Project()
+
+        if group is None:
+            deps = self.pyproject.project.dependencies
+        else:
+            try:
+                deps = self.pyproject.dependency_groups[group]
+            except KeyError:
+                deps = []
+                self.pyproject.dependency_groups[group] = deps
+
+        to_remove = []
+        for new in new_requirements:
+            new_req = Requirement(new)
+            for old in deps:
+                if Requirement(old).name == new_req.name:
+                    to_remove.append(old)
+                    break
+            deps.append(new)
+
+        for obsolet in to_remove:
+            deps.remove(obsolet)
+
+        self.save_pyproject()
+
+    def add_member(self, member: str):
+        if self.tool_uv.workspace is None:
+            self.tool_uv.workspace = ToolUVWorkspace()
+        self.tool_uv.workspace.members.append(member)
+        self.save_pyproject()
+
+    def run(self, console_script_name: str, *args, **extra_env: str):
+        uv_exe = uv.find_uv_bin()
+        cmd = [
+            uv_exe,
+            "run",
+            # "--python",
+            # str(python),
+            "--directory",
+            str(self.path),
+            console_script_name,
+            *args,
+        ]
+        env = None
+        if extra_env:
+            env = os.environ.copy()
+            env.update(extra_env)
+
+        print(f"Workspace run: {self.path}: {cmd}")
+        subprocess.check_call(cmd)
+
+    def run_python_command(self, command: str) -> None:
+        uv_exe = uv.find_uv_bin()
+        cmd = [
+            uv_exe,
+            "run",
+            # "--python",
+            # str(python),
+            "--directory",
+            str(self.path),
+            "python",
+            "-c",
+            command,
+        ]
+        print(f"Workspace run python cmd: {self.path}: {cmd}")
+        subprocess.check_call(cmd)
+
+    def sync(
+        self, allow_upgrade: bool = True, allow_custom_classifiers: bool = False
+    ) -> None:
+        env = None
+        if allow_custom_classifiers:
+            env = os.environ.copy()
+            # This is needed to build the packages with custom classifiers:
+            env["HATCH_METADATA_CLASSIFIERS_NO_VERIFY"] = "1"
+
+        more_options = []
+        if allow_upgrade:
+            more_options.append("--upgrade")
+
+        uv_exe = uv.find_uv_bin()
+        cmd = [uv_exe, "--project", self.path, "sync", *more_options]
+        print(f"Sync workspace {self.path}: {cmd}")
+        subprocess.check_call(cmd, env=env)