[ENHANCEMENT] argilla: Remove exists method and change client behavior (#5199)

# Description
<!-- Please include a summary of the changes and the related issue.
Please also include relevant motivation and context. List any
dependencies that are required for this change. -->

This PR changes the resource existence flow. The `user.exists`,
`workspace.exists`, and `dataset.exists` methods have been removed and
the `client.datasets(...)`, `client.workspaces(...)`, and
`client.users(...)` methods return `None` if resource is not found.

Closes #5157
Closes #5121

**Type of change**
<!-- Please delete options that are not relevant. Remember to title the
PR according to the type of change -->

- Improvement (change adding some improvement to an existing
functionality)
- Documentation update

**How Has This Been Tested**
<!-- Please add some reference about how your feature has been tested.
-->

**Checklist**
<!-- Please go over the list and make sure you've taken everything into
account -->

- I added relevant documentation
- I followed the style guidelines of this project
- I did a self-review of my code
- I made corresponding changes to the documentation
- I confirm My changes generate no new warnings
- I have added tests that prove my fix is effective or that my feature
works
- I have added relevant notes to the CHANGELOG.md file (See
https://keepachangelog.com/)

Author: frascuchon

argilla/docs/how_to_guides/dataset.md

@@ -432,7 +432,7 @@ retrieved_dataset = client.datasets(name="my_dataset", workspace=workspace)
 
 ## Check dataset existence
 
-You can check if a retrieved dataset exists by calling the `exists` method on the `Dataset` class. This method returns a boolean value.
+You can check if a dataset exists. The `client.datasets` method will return `None` if the dataset was not found.
 
 ```python
 import argilla as rg
@@ -441,7 +441,7 @@ client = rg.Argilla(api_url="<api_url>", api_key="<api_key>")
 
 dataset = client.datasets(name="my_dataset")
 
-dataset_existed = dataset.exists()
+dataset_exist = dataset is not None
 ```
 
 ## Update a dataset

argilla/docs/how_to_guides/migrate_from_legacy_datasets.md

@@ -106,7 +106,7 @@ dataset.create()
     ```python
     dataset = client.datasets(name=dataset_name)
 
-    if dataset.exists():
+    if dataset is not None:
         dataset.delete()
     ```
 

argilla/docs/how_to_guides/workspace.md

@@ -86,7 +86,7 @@ retrieved_workspace = client.workspaces("my_workspace")
 
 ## Check workspace existence
 
-You can check if a workspace exists by calling the `exists` method on the `Workspace` class. This method returns a boolean value.
+You can check if a workspace exists. The `client.workspaces` method will return `None` if the workspace was not found.
 
 ```python
 import argilla as rg
@@ -95,7 +95,7 @@ client = rg.Argilla(api_url="<api_url>", api_key="<api_key>")
 
 workspace = client.workspaces("my_workspace")
 
-workspace_existed = workspace.exists()
+workspace_exists = workspace is not None
 ```
 
 ## List users in a workspace

argilla/src/argilla/client.py

@@ -110,15 +110,15 @@ def __init__(self, client: "Argilla") -> None:
         self._client = client
         self._api = client.api.users
 
-    def __call__(self, username: str, **kwargs) -> "User":
+    def __call__(self, username: str) -> "User":
         from argilla.users import User
 
         user_models = self._api.list()
         for model in user_models:
             if model.username == username:
                 return User(_model=model, client=self._client)
-        warnings.warn(f"User {username} not found. Creating a new user. Do `user.create()` to create the user.")
-        return User(username=username, client=self._client, **kwargs)
+
+        warnings.warn(f"User with username {username!r} not found.")
 
     def __iter__(self):
         return self._Iterator(self.list())
@@ -188,18 +188,13 @@ def __init__(self, client: "Argilla") -> None:
         self._client = client
         self._api = client.api.workspaces
 
-    def __call__(self, name: str, **kwargs) -> "Workspace":
-        from argilla.workspaces import Workspace
-
+    def __call__(self, name: str) -> Optional["Workspace"]:
         workspace_models = self._api.list()
 
         for model in workspace_models:
             if model.name == name:
                 return self._from_model(model)
-        warnings.warn(
-            f"Workspace {name} not found. Creating a new workspace. Do `workspace.create()` to create the workspace."
-        )
-        return Workspace(name=name, client=self._client, **kwargs)
+        warnings.warn(f"Workspace with name {name!r} not found.")
 
     def __iter__(self):
         return self._Iterator(self.list())
@@ -265,19 +260,16 @@ def __init__(self, client: "Argilla") -> None:
         self._client = client
         self._api = client.api.datasets
 
-    def __call__(self, name: str, workspace: Optional[Union["Workspace", str]] = None, **kwargs) -> "Dataset":
-        from argilla.datasets import Dataset
-
+    def __call__(self, name: str, workspace: Optional[Union["Workspace", str]] = None) -> Optional["Dataset"]:
         if isinstance(workspace, str):
             workspace = self._client.workspaces(workspace)
         elif workspace is None:
-            workspace = self._client.workspaces[0]
+            workspace = self._client.workspaces.default
 
         for dataset in workspace.datasets:
             if dataset.name == name:
                 return dataset.get()
-        warnings.warn(f"Dataset {name} not found. Creating a new dataset. Do `dataset.create()` to create the dataset.")
-        return Dataset(name=name, workspace=workspace, client=self._client, **kwargs)
+        warnings.warn(f"Dataset with name {name!r} not found in workspace {workspace.name!r}")
 
     def __iter__(self):
         return self._Iterator(self.list())

argilla/src/argilla/datasets/_export.py

@@ -52,8 +52,8 @@ def to_disk(self: "Dataset", path: str) -> str:
         # Export the dataset model, settings and records
         self._persist_dataset_model(path=dataset_path)
         self.settings.to_json(path=settings_path)
-        if self.exists():
-            self.records.to_json(path=records_path)
+        self.records.to_json(path=records_path)
+
         return path
 
     @classmethod

argilla/src/argilla/datasets/_resource.py

@@ -142,14 +142,6 @@ def get(self) -> "Dataset":
         self.settings.get()
         return self
 
-    def exists(self) -> bool:
-        """Checks if the dataset exists on the server
-
-        Returns:
-            bool: True if the dataset exists, False otherwise
-        """
-        return self.id and self._api.exists(self.id)
-
     def create(self) -> "Dataset":
         """Creates the dataset on the server with the `Settings` configuration.
 
@@ -202,7 +194,7 @@ def _resolve_workspace(self) -> Workspace:
             warnings.warn(f"Workspace not provided. Using default workspace: {workspace.name} id: {workspace.id}")
         elif isinstance(workspace, str):
             workspace = self._client.workspaces(workspace)
-            if not workspace.exists():
+            if workspace is None:
                 available_workspace_names = [ws.name for ws in self._client.workspaces]
                 raise NotFoundError(
                     f"Workspace with name { workspace} not found. Available workspaces: {available_workspace_names}"
@@ -216,8 +208,8 @@ def _resolve_workspace(self) -> Workspace:
         return workspace
 
     def _rollback_dataset_creation(self):
-        if self.exists() and not self._is_published():
+        if not self._is_published():
             self.delete()
 
     def _is_published(self) -> bool:
-        return self.exists() and self._model.status == "ready"
+        return self._model.status == "ready"

argilla/src/argilla/records/_dataset_records.py

@@ -11,7 +11,7 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
-
+import warnings
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Dict, Iterable, List, Optional, Sequence, Union
 from uuid import UUID
@@ -81,11 +81,10 @@ def _list(self) -> Sequence[Record]:
             yield Record.from_model(model=record_model, dataset=self.__dataset)
 
     def _fetch_from_server(self) -> List[RecordModel]:
-        if not self.__dataset.exists():
-            raise ValueError(f"Dataset {self.__dataset.name} does not exist on the server.")
-        if self._is_search_query():
-            return self._fetch_from_server_with_search()
-        return self._fetch_from_server_with_list()
+        if not self.__client.api.datasets.exists(self.__dataset.id):
+            warnings.warn(f"Dataset {self.__dataset.id!r} does not exist on the server. Skipping...")
+            return []
+        return self._fetch_from_server_with_search() if self._is_search_query() else self._fetch_from_server_with_list()
 
     def _fetch_from_server_with_list(self) -> List[RecordModel]:
         return self.__client.api.records.list(

argilla/src/argilla/users/_resource.py

@@ -98,15 +98,6 @@ def delete(self) -> None:
         # exists relies on the id, so we need to set it to None
         self._model = UserModel(username=self.username)
 
-    def exists(self) -> bool:
-        """Checks if the user exists in Argilla
-
-        Returns:
-            bool: True if the user exists, False otherwise.
-        """
-        # TODO - Implement the exist method in the API
-        return self.id is not None
-
     def add_to_workspace(self, workspace: "Workspace") -> "User":
         """Adds the user to a workspace. After adding a user to a workspace, it will have access to the datasets
         in the workspace.

argilla/src/argilla/workspaces/_resource.py

@@ -60,15 +60,6 @@ def __init__(
 
         self._model = WorkspaceModel(name=name, id=id)
 
-    def exists(self) -> bool:
-        """
-        Checks if the workspace exists in the server
-
-        Returns:
-            bool: True if the workspace exists, False otherwise
-        """
-        return self._api.exists(self.id)
-
     def add_user(self, user: Union["User", str]) -> "User":
         """Adds a user to the workspace. After adding a user to the workspace, it will have access to the datasets
         in the workspace.
@@ -192,12 +183,12 @@ def _list_users(self) -> List["User"]:
 
     def _delete_user_by_username(self, username: str) -> "User":
         user = self._workspace._client.users(username=username)
-        if not user.exists():
+        if user is None:
             raise ValueError(f"User {username} does not exist")
         return user.remove_from_workspace(workspace=self._workspace)
 
     def _add_user_by_username(self, username: str) -> "User":
         user = self._workspace._client.users(username=username)
-        if not user.exists():
+        if user is None:
             raise ValueError(f"User {username} does not exist")
         return user.add_to_workspace(workspace=self._workspace)

argilla/tests/integration/conftest.py

@@ -15,6 +15,7 @@
 import pytest
 
 import argilla as rg
+from argilla import Argilla, Workspace
 
 
 @pytest.fixture(scope="session")
@@ -34,3 +35,18 @@ def cleanup(client: rg.Argilla):
     for user in client.users:
         if user.username.startswith("test_"):
             user.delete()
+
+
+@pytest.fixture
+def workspace(client: Argilla) -> Workspace:
+    ws_name = "test-workspace"
+
+    workspace = client.workspaces(ws_name)
+    if workspace is None:
+        workspace = Workspace(name=ws_name).create()
+    yield workspace
+
+    for dataset in workspace.list_datasets():
+        dataset.delete()
+
+    workspace.delete()