syft-rds 0.1.1.dev4__tar.gz → 0.1.1.dev5__tar.gz

{syft_rds-0.1.1.dev4 → syft_rds-0.1.1.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: syft-rds
-Version: 0.1.1.dev4
+Version: 0.1.1.dev5
 Summary: Doing remote data science with SyftBox
 License-File: LICENSE
 Requires-Python: >=3.9

{syft_rds-0.1.1.dev4 → syft_rds-0.1.1.dev5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "syft-rds"
-version = "0.1.1-dev.4"
+version = "0.1.1-dev.5"
 description = "Doing remote data science with SyftBox"
 readme = "README.md"
 requires-python = ">=3.9"

{syft_rds-0.1.1.dev4 → syft_rds-0.1.1.dev5}/src/syft_rds/__init__.py

@@ -1,4 +1,4 @@
-__version__ = "0.1.1-dev.4"
+__version__ = "0.1.1-dev.5"
 
 from syft_rds.utils.paths import RDS_NOTEBOOKS_PATH, RDS_REPO_PATH  # noqa
 from syft_rds.jupyter_utils.display import display  # noqa

syft_rds-0.1.1.dev5/src/syft_rds/client/exceptions.py

@@ -0,0 +1,18 @@
+class RDSClientError(Exception):
+    pass
+
+
+class RDSValidationError(RDSClientError):
+    pass
+
+
+class DatasetExistsError(RDSClientError):
+    pass
+
+
+class DatasetNotFoundError(RDSClientError):
+    pass
+
+
+class JobNotFoundError(RDSClientError):
+    pass

syft_rds-0.1.1.dev4/src/syft_rds/client/local_stores/dataset.py → syft_rds-0.1.1.dev5/src/syft_rds/client/local_stores/_dataset.py

@@ -129,7 +129,7 @@ class DatasetUrlManager:
 
     @staticmethod
     def get_private_dataset_syftbox_url(
-        datasite_email: str, dataset_name: str, path: Union[Path, str]
+        datasite_email: str, dataset_name: str, path: Union[Path, str] = None
     ) -> SyftBoxURL:
         """Generate a SyftBox URL for the private dataset."""
         return SyftBoxURL(

syft_rds-0.1.1.dev5/src/syft_rds/client/local_stores/dataset/__init__.py

@@ -0,0 +1,3 @@
+from .store import DatasetLocalStore
+
+__all__ = ["DatasetLocalStore"]

syft_rds-0.1.1.dev5/src/syft_rds/client/local_stores/dataset/constants.py

@@ -0,0 +1,4 @@
+# Constants for path segments to avoid magic strings
+DIRECTORY_PUBLIC = "public"
+DIRECTORY_PRIVATE = "private"
+DIRECTORY_DATASETS = "datasets"

syft_rds-0.1.1.dev5/src/syft_rds/client/local_stores/dataset/managers/__init__.py

@@ -0,0 +1,11 @@
+from .files import DatasetFilesManager
+from .path import DatasetPathManager
+from .schema import DatasetSchemaManager
+from .url import DatasetUrlManager
+
+__all__ = [
+    "DatasetFilesManager",
+    "DatasetPathManager",
+    "DatasetSchemaManager",
+    "DatasetUrlManager",
+]

syft_rds-0.1.1.dev5/src/syft_rds/client/local_stores/dataset/managers/files.py

@@ -0,0 +1,211 @@
+import shutil
+from pathlib import Path
+from typing import Union
+from loguru import logger
+
+from syft_rds.models.models import DatasetCreate
+
+from .path import DatasetPathManager
+
+
+class DatasetFilesManager:
+    """Manages file operations for datasets."""
+
+    def __init__(self, path_manager: DatasetPathManager) -> None:
+        """
+        Initialize the files manager.
+
+        Args:
+            path_manager: The path manager to use
+        """
+        self._path_manager = path_manager
+
+    def validate_file_extensions(
+        self, path: Union[str, Path], mock_path: Union[str, Path]
+    ) -> None:
+        """
+        Validate that both directories contain the same file extensions.
+
+        Args:
+            path: Path to the original data directory
+            mock_path: Path to the mock data directory
+
+        Raises:
+            ValueError: If the directories contain different file extensions
+        """
+        path = Path(path)
+        mock_path = Path(mock_path)
+
+        if not (path.is_dir() and mock_path.is_dir()):
+            raise ValueError("Both paths must be directories")
+
+        # Get all file extensions from the first directory into a set
+        path_extensions = self._collect_file_extensions(path)
+
+        # Get all file extensions from the second directory into a set
+        mock_extensions = self._collect_file_extensions(mock_path)
+
+        # Compare the sets of extensions
+        if path_extensions != mock_extensions:
+            self._report_extension_differences(
+                path, mock_path, path_extensions, mock_extensions
+            )
+
+    def _collect_file_extensions(self, directory: Path) -> set:
+        """Collect all file extensions from a directory."""
+        extensions = set()
+        for file_path in directory.glob("**/*"):
+            if file_path.is_file() and file_path.suffix:
+                extensions.add(file_path.suffix.lower())
+        return extensions
+
+    def _report_extension_differences(
+        self, path: Path, mock_path: Path, path_extensions: set, mock_extensions: set
+    ) -> None:
+        """Report differences in file extensions between directories."""
+        extra_in_path = path_extensions - mock_extensions
+        extra_in_mock = mock_extensions - path_extensions
+
+        error_msg = "Directories contain different file extensions:\n"
+        if extra_in_path:
+            error_msg += f"Extensions in {path} but not in {mock_path}: {', '.join(extra_in_path)}\n"
+        if extra_in_mock:
+            error_msg += f"Extensions in {mock_path} but not in {path}: {', '.join(extra_in_mock)}"
+
+        raise ValueError(error_msg)
+
+    def copy_directory(self, src: Union[str, Path], dest_dir: Path) -> Path:
+        """
+        Copy a directory to a destination path.
+
+        Args:
+            src: Source directory
+            dest_dir: Destination directory
+
+        Returns:
+            Path to the destination directory
+
+        Raises:
+            ValueError: If the source is not a directory
+        """
+        src_path = Path(src)
+        dest_dir.mkdir(parents=True, exist_ok=True)
+
+        if not src_path.is_dir():
+            raise ValueError(f"Source path is not a directory: {src_path}")
+
+        # Iterate through all items in the source directory
+        for item in src_path.iterdir():
+            item_dest = dest_dir / item.name
+
+            if item.is_dir():
+                # Recursively copy subdirectories
+                shutil.copytree(item, item_dest, dirs_exist_ok=True)
+            else:
+                # Copy files
+                shutil.copy2(item, dest_dir)
+        return dest_dir
+
+    def copy_mock_to_public_syftbox_dir(
+        self, dataset_name: str, mock_path: Union[str, Path]
+    ) -> Path:
+        """Copy mock data to the public SyftBox directory."""
+        public_dataset_dir: Path = self._path_manager.get_local_public_dataset_dir(
+            dataset_name
+        )
+        return self.copy_directory(mock_path, public_dataset_dir)
+
+    def copy_private_to_private_syftbox_dir(
+        self,
+        dataset_name: str,
+        path: Union[str, Path],
+    ) -> Path:
+        """Copy private data to the private SyftBox directory."""
+        private_dataset_dir: Path = self._path_manager.get_local_private_dataset_dir(
+            dataset_name
+        )
+        return self.copy_directory(path, private_dataset_dir)
+
+    def copy_description_file_to_public_syftbox_dir(
+        self, dataset_name: str, description_path: Union[str, Path, None]
+    ) -> Path | None:
+        """Copy description file to the public SyftBox directory."""
+        if not description_path:
+            return
+
+        public_dataset_dir: Path = self._path_manager.get_local_public_dataset_dir(
+            dataset_name
+        )
+        if not Path(description_path).exists():
+            raise ValueError(f"Description file does not exist: {description_path}")
+        dest_path = public_dataset_dir / Path(description_path).name
+        shutil.copy2(description_path, dest_path)
+        return dest_path
+
+    def copy_dataset_files(self, dataset_create: DatasetCreate) -> None:
+        """Copy all necessary files for a new dataset."""
+        self.copy_mock_to_public_syftbox_dir(
+            dataset_create.name, dataset_create.mock_path
+        )
+        self.copy_description_file_to_public_syftbox_dir(
+            dataset_create.name, dataset_create.description_path
+        )
+        self.copy_private_to_private_syftbox_dir(
+            dataset_create.name, dataset_create.path
+        )
+
+    def cleanup_dataset_files(self, name: str) -> None:
+        """
+        Remove all dataset files for a given dataset name.
+
+        Args:
+            name: Name of the dataset to clean up
+
+        Raises:
+            RuntimeError: If cleanup fails
+        """
+        try:
+            public_dir = self._path_manager.get_local_public_dataset_dir(name)
+            private_dir = self._path_manager.get_local_private_dataset_dir(name)
+
+            self._safe_remove_directory(public_dir)
+            self._safe_remove_directory(private_dir)
+        except Exception as e:
+            logger.error(f"Failed to cleanup dataset files: {str(e)}")
+            raise RuntimeError(f"Failed to clean up dataset '{name}'") from e
+
+    def move_dataset_files(
+        self, src_dataset_name: str, dst_dataset_name: str, overwrite: bool = False
+    ) -> None:
+        src_public_dir = self._path_manager.get_local_public_dataset_dir(
+            src_dataset_name
+        )
+        src_private_dir: Path = self._path_manager.get_local_private_dataset_dir(
+            src_dataset_name
+        )
+
+        if not src_public_dir.exists() or not src_private_dir.exists():
+            raise FileNotFoundError("Source directories don't exist.")
+
+        dst_public_dir: Path = self._path_manager.get_local_public_dataset_dir(
+            dst_dataset_name
+        )
+        dst_private_dir: Path = self._path_manager.get_local_private_dataset_dir(
+            dst_dataset_name
+        )
+
+        if not overwrite and (dst_public_dir.exists() or dst_private_dir.exists()):
+            raise FileExistsError("Destination directories already exist.")
+
+        if dst_public_dir.exists():
+            shutil.rmtree(dst_public_dir)
+        if dst_private_dir.exists():
+            shutil.rmtree(dst_private_dir)
+
+        shutil.move(src_public_dir, dst_public_dir)
+        shutil.move(src_private_dir, dst_private_dir)
+
+    def _safe_remove_directory(self, directory: Path) -> None:
+        """Safely remove a directory if it exists."""
+        if directory.exists():
+            shutil.rmtree(directory)

syft_rds-0.1.1.dev5/src/syft_rds/client/local_stores/dataset/managers/path.py

@@ -0,0 +1,78 @@
+from pathlib import Path
+from typing import Union
+from syft_core import Client as SyftBoxClient
+
+from ..constants import DIRECTORY_DATASETS, DIRECTORY_PRIVATE, DIRECTORY_PUBLIC
+
+
+class DatasetPathManager:
+    """Manages filesystem paths for dataset operations."""
+
+    def __init__(self, syftbox_client: SyftBoxClient):
+        """
+        Initialize the path manager.
+
+        Args:
+            syftbox_client: The SyftBox client
+            host: The host identifier
+        """
+        self.syftbox_client = syftbox_client
+
+    def get_local_public_dataset_dir(self, dataset_name: str) -> Path:
+        """Get the local public directory path for a dataset."""
+        return (
+            self.syftbox_client.my_datasite
+            / DIRECTORY_PUBLIC
+            / DIRECTORY_DATASETS
+            / dataset_name
+        )
+
+    def get_local_private_dataset_dir(self, dataset_name: str) -> Path:
+        """Get the local private directory path for a dataset."""
+        return (
+            self.syftbox_client.my_datasite
+            / DIRECTORY_PRIVATE
+            / DIRECTORY_DATASETS
+            / dataset_name
+        )
+
+    def get_local_public_datasets_dir(self) -> Path:
+        """Get the local base public directory for all datasets."""
+        return self.syftbox_client.my_datasite / DIRECTORY_PUBLIC / DIRECTORY_DATASETS
+
+    @property
+    def syftbox_client_email(self) -> str:
+        """Get the email of the SyftBox client."""
+        return self.syftbox_client.email
+
+    def validate_path_exists(self, path: Union[str, Path]) -> None:
+        """
+        Validate that a path exists.
+
+        Args:
+            path: The path to validate
+
+        Raises:
+            ValueError: If the path doesn't exist
+        """
+        if not Path(path).exists():
+            raise FileNotFoundError(f"Path does not exist: {path}")
+
+    def validate_directory_paths(
+        self, path: Union[str, Path], mock_path: Union[str, Path]
+    ) -> None:
+        """
+        Validate that both paths are directories.
+
+        Args:
+            path: The first path to validate
+            mock_path: The second path to validate
+
+        Raises:
+            ValueError: If either path is not a directory
+        """
+        path, mock_path = Path(path), Path(mock_path)
+        if not (path.is_dir() and mock_path.is_dir()):
+            raise NotADirectoryError(
+                f"Mock and private data paths must be directories: {path} and {mock_path}"
+            )

syft_rds-0.1.1.dev5/src/syft_rds/client/local_stores/dataset/managers/schema.py

@@ -0,0 +1,89 @@
+from pathlib import Path
+
+from syft_core import SyftBoxURL
+from syft_rds.models.models import Dataset, DatasetCreate
+from syft_rds.store.store import YAMLStore
+
+from .path import DatasetPathManager
+from .url import DatasetUrlManager
+
+
+class DatasetSchemaManager:
+    """Manages schema operations for datasets."""
+
+    def __init__(self, path_manager: DatasetPathManager, store: YAMLStore) -> None:
+        """
+        Initialize the schema manager.
+
+        Args:
+            path_manager: The path manager to use
+            store: The RDS store for persistence
+        """
+        self._path_manager = path_manager
+        self._schema_store = store
+
+    def create(self, dataset_create: DatasetCreate) -> Dataset:
+        """
+        Create a dataset schema.
+
+        Args:
+            dataset_create: Dataset creation data
+
+        Returns:
+            The created dataset
+        """
+        syftbox_client_email = self._path_manager.syftbox_client_email
+
+        # Generate URLs for the dataset components
+        mock_url = DatasetUrlManager.get_mock_dataset_syftbox_url(
+            syftbox_client_email, dataset_create.name, Path(dataset_create.mock_path)
+        )
+        private_url = DatasetUrlManager.get_private_dataset_syftbox_url(
+            syftbox_client_email, dataset_create.name, Path(dataset_create.path)
+        )
+
+        readme_url: SyftBoxURL = (
+            DatasetUrlManager.get_readme_syftbox_url(
+                syftbox_client_email,
+                dataset_create.name,
+                Path(dataset_create.description_path),
+            )
+            if dataset_create.description_path
+            else None
+        )
+
+        # Create the dataset schema object
+        # TODO: Could we not unpack DatasetCreate directly?
+        dataset = Dataset(
+            name=dataset_create.name,
+            private=private_url,
+            mock=mock_url,
+            tags=dataset_create.tags,
+            summary=dataset_create.summary,
+            readme=readme_url,
+            auto_approval=dataset_create.auto_approval,
+        )
+        if dataset_create.runtime:
+            dataset.runtime = dataset_create.runtime
+
+        # Persist the schema to store
+        self._schema_store.create(dataset)
+        return dataset
+
+    def delete(self, name: str) -> bool:
+        """
+        Delete a dataset by name.
+
+        Args:
+            name: Name of the dataset to delete
+
+        Returns:
+            True if deleted, False if not found
+        """
+        queried_result: list[Dataset] = self._schema_store.get_all(
+            filters={"name": name}
+        )
+        if not queried_result:
+            return False
+        first_res: Dataset = queried_result[0]
+        return self._schema_store.delete(first_res.uid)

syft_rds-0.1.1.dev5/src/syft_rds/client/local_stores/dataset/managers/url.py

@@ -0,0 +1,48 @@
+from pathlib import Path
+from typing import Union
+from syft_core import SyftBoxURL
+
+from ..constants import DIRECTORY_DATASETS, DIRECTORY_PRIVATE, DIRECTORY_PUBLIC
+
+
+class DatasetUrlManager:
+    """Manages SyftBox URLs for datasets."""
+
+    @staticmethod
+    def get_mock_dataset_syftbox_url(
+        datasite_email: str, dataset_name: str, mock_path: Union[Path, str] = None
+    ) -> SyftBoxURL:
+        """Generate a SyftBox URL for the mock dataset."""
+        return SyftBoxURL(
+            f"syft://{datasite_email}/{DIRECTORY_PUBLIC}/{DIRECTORY_DATASETS}/{dataset_name}"
+        )
+
+    @staticmethod
+    def get_private_dataset_syftbox_url(
+        datasite_email: str, dataset_name: str, path: Union[Path, str] = None
+    ) -> SyftBoxURL:
+        """Generate a SyftBox URL for the private dataset."""
+        return SyftBoxURL(
+            f"syft://{datasite_email}/{DIRECTORY_PRIVATE}/{DIRECTORY_DATASETS}/{dataset_name}"
+        )
+
+    @staticmethod
+    def get_readme_syftbox_url(
+        datasite_email: str, dataset_name: str, readme_path: Union[Path, str]
+    ) -> SyftBoxURL:
+        """Generate a SyftBox URL for the readme file."""
+        return SyftBoxURL(
+            f"syft://{datasite_email}/{DIRECTORY_PUBLIC}/{DIRECTORY_DATASETS}/{dataset_name}/{Path(readme_path).name}"
+        )
+
+    @staticmethod
+    def update_readme_syftbox_url(
+        url: SyftBoxURL, *, dataset_name: str = None
+    ) -> SyftBoxURL:
+        path = Path(url.path)
+        datasite_email = url.host
+
+        if dataset_name:
+            path = path.parent.parent / dataset_name / path.name
+
+        return SyftBoxURL(f"syft://{datasite_email}/{path}")

syft_rds-0.1.1.dev5/src/syft_rds/client/local_stores/dataset/store.py

@@ -0,0 +1,223 @@
+from pathlib import Path
+import traceback
+from typing import TYPE_CHECKING, Final, Type, Union
+from syft_rds.client.exceptions import DatasetExistsError, DatasetNotFoundError
+from syft_rds.client.local_stores.base import CRUDLocalStore
+from syft_rds.models.models import (
+    Dataset,
+    DatasetCreate,
+    DatasetUpdate,
+    GetAllRequest,
+    GetOneRequest,
+)
+from syft_core import Client as SyftBoxClient
+
+from .managers import (
+    DatasetPathManager,
+    DatasetFilesManager,
+    DatasetUrlManager,
+    DatasetSchemaManager,
+)
+
+if TYPE_CHECKING:
+    from syft_rds.client.rds_client import RDSClientConfig
+
+
+class DatasetLocalStore(CRUDLocalStore[Dataset, DatasetCreate, DatasetUpdate]):
+    """Local store for dataset operations."""
+
+    ITEM_TYPE: Final[Type[Dataset]] = Dataset
+
+    def __init__(self, config: "RDSClientConfig", syftbox_client: SyftBoxClient):
+        """
+        Initialize the dataset local store.
+
+        Args:
+            config: The RDS client configuration
+            syftbox_client: The SyftBox client
+        """
+        super().__init__(config, syftbox_client)
+        self._path_manager = DatasetPathManager(self.syftbox_client)
+        self._files_manager = DatasetFilesManager(self._path_manager)
+        self._schema_manager = DatasetSchemaManager(self._path_manager, self.store)
+
+    def _validate_dataset_paths(
+        self,
+        name: str,
+        path: Union[str, Path],
+        mock_path: Union[str, Path],
+    ) -> None:
+        """
+        Validate all aspects of dataset paths.
+
+        Args:
+            name: Dataset name
+            path: Path to private data
+            mock_path: Path to mock data
+
+        Raises:
+            DatasetExistsError: if the Dataset name already exists
+            FileNotFoundError: if the private/mock paths don't exist
+            NotADirectoryError: if the provided private/mock paths are not directories
+        """
+        self._validate_dataset_name_unique(name)
+        self._validate_path_existence(path, mock_path)
+        self._validate_file_extensions(path, mock_path)
+
+    def _validate_dataset_name_unique(self, name: str) -> None:
+        """Validate that dataset name is unique."""
+        if (
+            self._path_manager.get_local_public_dataset_dir(name).exists()
+            or self._path_manager.get_local_private_dataset_dir(name).exists()
+        ):
+            raise DatasetExistsError(f"Dataset with name '{name}' already exists")
+
+    def _validate_path_existence(
+        self, path: Union[str, Path], mock_path: Union[str, Path]
+    ) -> None:
+        """Validate that paths exist and are directories."""
+        self._path_manager.validate_path_exists(path)
+        self._path_manager.validate_path_exists(mock_path)
+        self._path_manager.validate_directory_paths(path, mock_path)
+
+    def _validate_file_extensions(
+        self, path: Union[str, Path], mock_path: Union[str, Path]
+    ) -> None:
+        """Validate that file extensions match between directories."""
+        self._files_manager.validate_file_extensions(path, mock_path)
+
+    def create(self, dataset_create: DatasetCreate) -> Dataset:
+        """
+        Create a new dataset.
+
+        Args:
+            dataset_create: Dataset creation data
+
+        Returns:
+            The created dataset
+
+        Raises:
+            RuntimeError: If creation fails
+        """
+        self._validate_dataset_paths(
+            dataset_create.name,
+            dataset_create.path,
+            dataset_create.mock_path,
+        )
+        try:
+            self._files_manager.copy_dataset_files(dataset_create)
+            dataset = self._schema_manager.create(dataset_create)
+            return dataset._register_client_id_recursive(self.config.uid)
+        except Exception as e:
+            self._files_manager.cleanup_dataset_files(dataset_create.name)
+            self._schema_manager.delete(dataset_create.name)
+            raise RuntimeError(
+                f"Failed to create dataset '{dataset_create.name}': {str(e)}"
+            ) from e
+
+    def get_all(self, request: GetAllRequest) -> list[Dataset]:
+        """
+        Get all datasets.
+
+        Args:
+            request: The get all request object
+
+        Returns:
+            List of all datasets
+        """
+        return super().get_all(request)
+
+    def update(self, update_item: DatasetUpdate) -> Dataset:
+        """
+        Update an existing dataset.
+
+        Args:
+            update_dataset: The dataset update data
+
+        Returns:
+            The updated dataset
+
+        Raises:
+            RuntimeError: If update fails
+        """
+        try:
+            existing_dataset = self.store.get_by_uid(update_item.uid)
+            if existing_dataset is None:
+                raise DatasetNotFoundError(
+                    f"Dataset with uid {update_item.uid} not found"
+                )
+
+            updated_dataset = existing_dataset.apply_update(update_item, in_place=False)
+
+            if update_item.name:
+                self._validate_dataset_name_unique(update_item.name)
+                syftbox_client_email = self._path_manager.syftbox_client_email
+                old_dataset_name = existing_dataset.name
+                new_dataset_name = update_item.name
+
+                self._files_manager.move_dataset_files(
+                    old_dataset_name, new_dataset_name
+                )
+
+                new_private_url = DatasetUrlManager.get_private_dataset_syftbox_url(
+                    syftbox_client_email, updated_dataset.name
+                )
+                new_mock_url = DatasetUrlManager.get_mock_dataset_syftbox_url(
+                    syftbox_client_email, updated_dataset.name
+                )
+                new_readme_url = DatasetUrlManager.update_readme_syftbox_url(
+                    updated_dataset.readme, dataset_name=updated_dataset.name
+                )
+
+                updated_dataset.private = new_private_url
+                updated_dataset.mock = new_mock_url
+                updated_dataset.readme = new_readme_url
+
+            if update_item.path:
+                self._files_manager.copy_private_to_private_syftbox_dir(
+                    updated_dataset.name, update_item.path
+                )
+
+            updated_dataset = self.store.update(updated_dataset.uid, updated_dataset)
+            return updated_dataset._register_client_id_recursive(self.config.uid)
+        except DatasetExistsError:
+            raise
+        except Exception as e:
+            print(traceback.format_exc())
+            raise RuntimeError(
+                f"Failed to update dataset with uid {update_item.uid}: {str(e)}"
+            )
+
+    def get(self, request: GetOneRequest) -> Dataset:
+        """
+        Get a dataset based on name / id
+
+        Args:
+            request: The get one request object
+
+        Returns:
+            The dataset
+        """
+        return super().get_one(request)
+
+    def delete_by_name(self, name: str) -> bool:
+        """
+        Delete a dataset by name.
+
+        Args:
+            name: Name of the dataset to delete
+
+        Returns:
+            True if deleted, False if not found
+
+        Raises:
+            RuntimeError: If deletion fails
+        """
+        try:
+            schema_deleted = self._schema_manager.delete(name)
+            if schema_deleted:
+                self._files_manager.cleanup_dataset_files(name)
+                return True
+            return False
+        except Exception as e:
+            raise RuntimeError(f"Failed to delete dataset '{name}'") from e

{syft_rds-0.1.1.dev4 → syft_rds-0.1.1.dev5}/src/syft_rds/models/base.py

@@ -83,14 +83,14 @@ class ItemBase(BaseModel, ABC):
                 f"Cannot apply update with UID {other.uid} to instance with UID {self.uid}"
             )
         if isinstance(other, type(self)):
-            update_dict = other.model_dump()
+            update_dict = other.model_dump(exclude_unset=True, exclude_none=True)
         elif isinstance(other, ItemBaseUpdate):
             update_target_type = other.get_target_model()
             if other.get_target_model() is not type(self):
                 raise ValueError(
                     f"Attempted to apply update for {update_target_type} to {type(self)}"
                 )
-            update_dict = other.model_dump(exclude_unset=True)
+            update_dict = other.model_dump(exclude_unset=True, exclude_none=True)
             update_dict["updated_at"] = _utcnow()
         else:
             raise TypeError(

{syft_rds-0.1.1.dev4 → syft_rds-0.1.1.dev5}/src/syft_rds/models/models.py

@@ -436,6 +436,10 @@ class DatasetCreate(ItemBaseCreate[Dataset]):
 
 
 class DatasetUpdate(ItemBaseUpdate[Dataset]):
+    name: Optional[str] = None
+    path: Optional[str] = Field(
+        description="Path of the new private dataset directory", default=None
+    )
     summary: Optional[str] = None
     auto_approval: Optional[list[str]] = Field(
         default_factory=list,

{syft_rds-0.1.1.dev4 → syft_rds-0.1.1.dev5}/src/syft_rds/store/store.py

@@ -195,7 +195,7 @@ class YAMLStore(Generic[T]):
         return record
 
     @ensure_store_exists
-    def update(self, uid: str | UUID, record: T) -> Optional[T]:
+    def update(self, uid: str | UUID, record: T) -> T:
         """
         Update a record by UID
 
@@ -204,14 +204,17 @@ class YAMLStore(Generic[T]):
             record: New data to update with
 
         Returns:
-            Updated record if found, None otherwise
+            Updated record
+
+        Raises:
+            FileNotFoundError: If no record with the given UID exists
         """
         if not isinstance(record, self.item_type):
             raise TypeError(f"`record` must be of type {self.item_type.__name__}")
 
         existing_record = self.get_by_uid(uid)
         if not existing_record:
-            return None
+            raise FileNotFoundError(f"Record with UID {uid} does not exist")
 
         # Update the record
         updated_record = existing_record.model_copy(

syft_rds-0.1.1.dev4/src/syft_rds/client/exceptions.py

@@ -1,6 +0,0 @@
-class RDSClientError(Exception):
-    pass
-
-
-class RDSValidationError(RDSClientError):
-    pass