[REFACTOR]: Unify validators signature (#5368)

# 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 reviews and unifies the existing validators:

1. Validator class signature is a `validate` class method
2. All dependencies are passed as an argument to the `validate` method.
3. If validator requires access to the DB, the session db will be passed
as the first `validate` argument.

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

- Bug fix (non-breaking change which fixes an issue)
- New feature (non-breaking change which adds functionality)
- Breaking change (fix or feature that would cause existing
functionality to not work as expected)
- Refactor (change restructuring the codebase without changing
functionality)
- 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-server/src/argilla_server/api/handlers/v1/datasets/records.py

@@ -236,9 +236,9 @@ async def _build_response_status_filter_for_search(
     return user_response_status_filter
 
 
-async def _validate_search_records_query(db: "AsyncSession", query: SearchRecordsQuery, dataset_id: UUID):
+async def _validate_search_records_query(db: "AsyncSession", query: SearchRecordsQuery, dataset: Dataset):
     try:
-        await search.validate_search_records_query(db, query, dataset_id)
+        await search.validate_search_records_query(db, query, dataset)
     except (ValueError, NotFoundError) as e:
         raise UnprocessableEntityError(str(e))
 
@@ -324,7 +324,7 @@ async def search_current_user_dataset_records(
 
     await authorize(current_user, DatasetPolicy.search_records(dataset))
 
-    await _validate_search_records_query(db, body, dataset_id)
+    await _validate_search_records_query(db, body, dataset)
 
     search_responses = await _get_search_responses(
         db=db,
@@ -385,7 +385,7 @@ async def search_dataset_records(
 
     await authorize(current_user, DatasetPolicy.search_records_with_all_responses(dataset))
 
-    await _validate_search_records_query(db, body, dataset_id)
+    await _validate_search_records_query(db, body, dataset)
 
     search_responses = await _get_search_responses(
         db=db,

argilla-server/src/argilla_server/api/schemas/v1/responses.py

@@ -102,10 +102,6 @@ class ResponseCreate(BaseModel):
     values: Optional[ResponseValuesCreate]
     status: ResponseStatus
 
-    @property
-    def is_submitted(self):
-        return self.status == ResponseStatus.submitted
-
 
 class ResponseFilterScope(BaseModel):
     entity: Literal["response"]

argilla-server/src/argilla_server/bulk/records_bulk.py

@@ -50,7 +50,7 @@ def __init__(self, db: AsyncSession, search_engine: SearchEngine):
         self._search_engine = search_engine
 
     async def create_records_bulk(self, dataset: Dataset, bulk_create: RecordsBulkCreate) -> RecordsBulk:
-        await RecordsBulkCreateValidator(bulk_create, db=self._db).validate_for(dataset)
+        await RecordsBulkCreateValidator.validate(self._db, bulk_create, dataset)
 
         async with self._db.begin_nested():
             records = [
@@ -98,7 +98,7 @@ async def _upsert_records_suggestions(
                         raise ValueError(f"question with question_id={suggestion_create.question_id} does not exist")
 
                     try:
-                        SuggestionCreateValidator(suggestion_create).validate_for(question.parsed_settings, record)
+                        SuggestionCreateValidator.validate(suggestion_create, question.parsed_settings, record)
                         upsert_many_suggestions.append(dict(**suggestion_create.dict(), record_id=record.id))
                     except (UnprocessableEntityError, ValueError) as ex:
                         raise ValueError(f"suggestion for question name={question.name} is not valid: {ex}")
@@ -131,7 +131,7 @@ async def _upsert_records_responses(
                     if response_create.user_id not in users_by_id:
                         raise ValueError(f"user with id {response_create.user_id} not found")
 
-                    ResponseCreateValidator(response_create).validate_for(record)
+                    ResponseCreateValidator.validate(response_create, record)
                     upsert_many_responses.append(dict(**response_create.dict(), record_id=record.id))
             except (UnprocessableEntityError, ValueError) as ex:
                 raise UnprocessableEntityError(
@@ -159,7 +159,7 @@ async def _upsert_records_vectors(
                     if not settings:
                         raise ValueError(f"vector with name={name} does not exist for dataset_id={record.dataset.id}")
 
-                    VectorValidator(value).validate_for(settings)
+                    VectorValidator.validate(value, settings)
                     upsert_many_vectors.append(dict(value=value, record_id=record.id, vector_settings_id=settings.id))
             except (UnprocessableEntityError, ValueError) as ex:
                 raise UnprocessableEntityError(
@@ -185,7 +185,7 @@ async def upsert_records_bulk(self, dataset: Dataset, bulk_upsert: RecordsBulkUp
         found_records = await self._fetch_existing_dataset_records(dataset, bulk_upsert.items)
         # found_records is passed to the validator to avoid querying the database again, but ideally, it should be
         # computed inside the validator
-        RecordsBulkUpsertValidator(bulk_upsert, self._db, found_records).validate_for(dataset)
+        RecordsBulkUpsertValidator.validate(bulk_upsert, dataset, found_records)
 
         records = []
         async with self._db.begin_nested():

argilla-server/src/argilla_server/contexts/datasets.py

@@ -615,7 +615,7 @@ async def _build_record_responses(
         try:
             cache = await validate_user_exists(db, response_create.user_id, cache)
 
-            ResponseCreateValidator(response_create).validate_for(record)
+            ResponseCreateValidator.validate(response_create, record)
 
             responses.append(
                 Response(
@@ -656,7 +656,7 @@ async def _build_record_suggestions(
                     raise UnprocessableEntityError(f"question_id={str(suggestion_create.question_id)} does not exist")
                 questions_cache[suggestion_create.question_id] = question
 
-            SuggestionCreateValidator(suggestion_create).validate_for(question.parsed_settings, record)
+            SuggestionCreateValidator.validate(suggestion_create, question.parsed_settings, record)
 
             suggestions.append(
                 Suggestion(
@@ -840,7 +840,7 @@ async def create_response(
             f"Response already exists for record with id `{record.id}` and by user with id `{user.id}`"
         )
 
-    ResponseCreateValidator(response_create).validate_for(record)
+    ResponseCreateValidator.validate(response_create, record)
 
     async with db.begin_nested():
         response = await Response.create(
@@ -866,7 +866,7 @@ async def create_response(
 async def update_response(
     db: AsyncSession, search_engine: SearchEngine, response: Response, response_update: ResponseUpdate
 ):
-    ResponseUpdateValidator(response_update).validate_for(response.record)
+    ResponseUpdateValidator.validate(response_update, response.record)
 
     async with db.begin_nested():
         response = await response.update(
@@ -890,7 +890,7 @@ async def update_response(
 async def upsert_response(
     db: AsyncSession, search_engine: SearchEngine, record: Record, user: User, response_upsert: ResponseUpsert
 ) -> Response:
-    ResponseUpsertValidator(response_upsert).validate_for(record)
+    ResponseUpsertValidator.validate(response_upsert, record)
 
     async with db.begin_nested():
         response = await Response.upsert(
@@ -963,7 +963,7 @@ async def upsert_suggestion(
     question: Question,
     suggestion_create: "SuggestionCreate",
 ) -> Suggestion:
-    SuggestionCreateValidator(suggestion_create).validate_for(question.parsed_settings, record)
+    SuggestionCreateValidator.validate(suggestion_create, question.parsed_settings, record)
 
     async with db.begin_nested():
         suggestion = await Suggestion.upsert(

argilla-server/src/argilla_server/contexts/questions.py

@@ -34,7 +34,7 @@ async def create_question(db: AsyncSession, dataset: Dataset, question_create: Q
             f"Question with name `{question_create.name}` already exists for dataset with id `{dataset.id}`"
         )
 
-    QuestionCreateValidator(question_create).validate_for(dataset)
+    QuestionCreateValidator.validate(question_create, dataset)
 
     return await Question.create(
         db,
@@ -48,14 +48,14 @@ async def create_question(db: AsyncSession, dataset: Dataset, question_create: Q
 
 
 async def update_question(db: AsyncSession, question: Question, question_update: QuestionUpdate) -> Question:
-    QuestionUpdateValidator(question_update).validate_for(question)
+    QuestionUpdateValidator.validate(question_update, question)
 
     params = question_update.dict(exclude_unset=True)
 
     return await question.update(db, **params)
 
 
 async def delete_question(db: AsyncSession, question: Question) -> Question:
-    QuestionDeleteValidator().validate_for(question.dataset)
+    QuestionDeleteValidator.validate(question.dataset)
 
     return await question.delete(db)

argilla-server/src/argilla_server/contexts/search.py

@@ -26,55 +26,61 @@
 )
 from argilla_server.api.schemas.v1.responses import ResponseFilterScope
 from argilla_server.api.schemas.v1.suggestions import SuggestionFilterScope
-from argilla_server.models import MetadataProperty, Question, Suggestion
+from argilla_server.models import MetadataProperty, Question, Suggestion, Dataset
 
 
 class SearchRecordsQueryValidator:
-    def __init__(self, db: AsyncSession, query: SearchRecordsQuery, dataset_id: UUID):
-        self._db = db
-        self._query = query
-        self._dataset_id = dataset_id
-
-    async def validate(self) -> None:
-        if self._query.filters:
-            for filter in self._query.filters.and_:
-                await self._validate_filter_scope(filter.scope)
-
-        if self._query.sort:
-            for order in self._query.sort:
-                await self._validate_filter_scope(order.scope)
-
-    async def _validate_filter_scope(self, filter_scope: FilterScope) -> None:
+    @classmethod
+    async def validate(cls, db: AsyncSession, dataset: Dataset, query: SearchRecordsQuery) -> None:
+        if query.filters:
+            for filter in query.filters.and_:
+                await cls._validate_filter_scope(db, dataset, filter.scope)
+
+        if query.sort:
+            for order in query.sort:
+                await cls._validate_filter_scope(db, dataset, order.scope)
+
+    @classmethod
+    async def _validate_filter_scope(cls, db: AsyncSession, dataset: Dataset, filter_scope: FilterScope) -> None:
         if isinstance(filter_scope, RecordFilterScope):
             return
         elif isinstance(filter_scope, ResponseFilterScope):
-            await self._validate_response_filter_scope(filter_scope)
+            await cls._validate_response_filter_scope(db, dataset, filter_scope)
         elif isinstance(filter_scope, SuggestionFilterScope):
-            await self._validate_suggestion_filter_scope(filter_scope)
+            await cls._validate_suggestion_filter_scope(db, dataset, filter_scope)
         elif isinstance(filter_scope, MetadataFilterScope):
-            await self._validate_metadata_filter_scope(filter_scope)
+            await cls._validate_metadata_filter_scope(db, dataset, filter_scope)
         else:
             raise ValueError(f"Unknown filter scope entity `{filter_scope.entity}`")
 
-    async def _validate_response_filter_scope(self, filter_scope: ResponseFilterScope) -> None:
+    @staticmethod
+    async def _validate_response_filter_scope(
+        db: AsyncSession, dataset: Dataset, filter_scope: ResponseFilterScope
+    ) -> None:
         if filter_scope.question is None:
             return
 
-        await Question.get_by_or_raise(self._db, name=filter_scope.question, dataset_id=self._dataset_id)
+        await Question.get_by_or_raise(db, name=filter_scope.question, dataset_id=dataset.id)
 
-    async def _validate_suggestion_filter_scope(self, filter_scope: SuggestionFilterScope) -> None:
-        await Question.get_by_or_raise(self._db, name=filter_scope.question, dataset_id=self._dataset_id)
+    @staticmethod
+    async def _validate_suggestion_filter_scope(
+        db: AsyncSession, dataset: Dataset, filter_scope: SuggestionFilterScope
+    ) -> None:
+        await Question.get_by_or_raise(db, name=filter_scope.question, dataset_id=dataset.id)
 
-    async def _validate_metadata_filter_scope(self, filter_scope: MetadataFilterScope) -> None:
+    @staticmethod
+    async def _validate_metadata_filter_scope(
+        db: AsyncSession, dataset: Dataset, filter_scope: MetadataFilterScope
+    ) -> None:
         await MetadataProperty.get_by_or_raise(
-            self._db,
+            db,
             name=filter_scope.metadata_property,
-            dataset_id=self._dataset_id,
+            dataset_id=dataset.id,
         )
 
 
-async def validate_search_records_query(db: AsyncSession, query: SearchRecordsQuery, dataset_id: UUID) -> None:
-    await SearchRecordsQueryValidator(db, query, dataset_id).validate()
+async def validate_search_records_query(db: AsyncSession, query: SearchRecordsQuery, dataset: Dataset) -> None:
+    await SearchRecordsQueryValidator.validate(db, dataset, query)
 
 
 async def get_dataset_suggestion_agents_by_question(db: AsyncSession, dataset_id: UUID) -> List[Mapping[str, Any]]:

argilla-server/src/argilla_server/validators/questions.py

@@ -27,22 +27,22 @@
 
 
 class QuestionCreateValidator:
-    def __init__(self, question_create: QuestionCreate):
-        self._question_create = question_create
+    @classmethod
+    def validate(cls, question_create: QuestionCreate, dataset: Dataset):
+        cls._validate_dataset_is_not_ready(dataset)
+        cls._validate_span_question_settings(question_create, dataset)
 
-    def validate_for(self, dataset: Dataset):
-        self._validate_dataset_is_not_ready(dataset)
-        self._validate_span_question_settings(dataset)
-
-    def _validate_dataset_is_not_ready(self, dataset):
+    @staticmethod
+    def _validate_dataset_is_not_ready(dataset):
         if dataset.is_ready:
             raise UnprocessableEntityError("questions cannot be created for a published dataset")
 
-    def _validate_span_question_settings(self, dataset: Dataset):
-        if self._question_create.settings.type != QuestionType.span:
+    @classmethod
+    def _validate_span_question_settings(cls, question_create: QuestionCreate, dataset: Dataset):
+        if question_create.settings.type != QuestionType.span:
             return
 
-        field = self._question_create.settings.field
+        field = question_create.settings.field
         field_names = [field.name for field in dataset.fields]
 
         if field not in field_names:
@@ -68,41 +68,44 @@ class QuestionUpdateValidator:
         QuestionType.span,
     ]
 
-    def __init__(self, question_update: QuestionUpdate):
-        self._question_update = question_update
-
-    def validate_for(self, question: Question):
-        self._validate_question_settings(question.parsed_settings)
+    @classmethod
+    def validate(cls, question_update: QuestionUpdate, question: Question):
+        cls._validate_question_settings(question_update, question.parsed_settings)
 
-    def _validate_question_settings(self, question_settings: QuestionSettings):
-        if not self._question_update.settings:
+    @classmethod
+    def _validate_question_settings(cls, question_update: QuestionUpdate, question_settings: QuestionSettings):
+        if not question_update.settings:
             return
 
-        self._validate_question_settings_type_is_the_same(question_settings, self._question_update.settings)
-        self._validate_question_settings_label_options(question_settings, self._question_update.settings)
-        self._validate_question_settings_visible_options(question_settings, self._question_update.settings)
-        self._validate_span_question_settings(question_settings, self._question_update.settings)
+        cls._validate_question_settings_type_is_the_same(question_settings, question_update.settings)
+        cls._validate_question_settings_label_options(question_settings, question_update.settings)
+        cls._validate_question_settings_visible_options(question_settings, question_update.settings)
+        cls._validate_span_question_settings(question_settings, question_update.settings)
 
+    @staticmethod
     def _validate_question_settings_type_is_the_same(
-        self, question_settings: QuestionSettings, question_settings_update: QuestionSettingsUpdate
+        question_settings: QuestionSettings, question_settings_update: QuestionSettingsUpdate
     ):
         if question_settings.type != question_settings_update.type:
             raise UnprocessableEntityError(
-                f"question type cannot be changed. expected '{question_settings.type}' but got '{question_settings_update.type}'"
+                "question type cannot be changed. "
+                f"expected '{question_settings.type}' but got '{question_settings_update.type}'"
             )
 
+    @classmethod
     def _validate_question_settings_label_options(
-        self, question_settings: QuestionSettings, question_settings_update: QuestionSettingsUpdate
+        cls, question_settings: QuestionSettings, question_settings_update: QuestionSettingsUpdate
     ):
-        if question_settings.type not in self.QUESTION_TYPES_WITH_LABEL_OPTIONS:
+        if question_settings.type not in cls.QUESTION_TYPES_WITH_LABEL_OPTIONS:
             return
 
         if question_settings_update.options is None:
             return
 
         if len(question_settings.options) != len(question_settings_update.options):
             raise UnprocessableEntityError(
-                f"the number of options cannot be modified. expected {len(question_settings.options)} but got {len(question_settings_update.options)}"
+                "the number of options cannot be modified. "
+                f"expected {len(question_settings.options)} but got {len(question_settings_update.options)}"
             )
 
         sorted_options = sorted(question_settings.options, key=lambda option: option.value)
@@ -118,10 +121,11 @@ def _validate_question_settings_label_options(
                 f"the option values cannot be modified. found unexpected option values: {unexpected_options!r}"
             )
 
+    @classmethod
     def _validate_question_settings_visible_options(
-        self, question_settings: QuestionSettings, question_settings_update: QuestionSettingsUpdate
+        cls, question_settings: QuestionSettings, question_settings_update: QuestionSettingsUpdate
     ):
-        if question_settings_update.type not in self.QUESTION_TYPES_WITH_VISIBLE_OPTIONS:
+        if question_settings_update.type not in cls.QUESTION_TYPES_WITH_VISIBLE_OPTIONS:
             return
 
         if question_settings_update.visible_options is None:
@@ -130,11 +134,13 @@ def _validate_question_settings_visible_options(
         number_of_options = len(question_settings.options)
         if question_settings_update.visible_options > number_of_options:
             raise UnprocessableEntityError(
-                f"the value for 'visible_options' must be less or equal to the number of items in 'options' ({number_of_options})"
+                "the value for 'visible_options' must be less or equal to "
+                f"the number of items in 'options' ({number_of_options})"
             )
 
+    @staticmethod
     def _validate_span_question_settings(
-        self, question_settings: SpanQuestionSettings, question_settings_update: QuestionSettingsUpdate
+        question_settings: SpanQuestionSettings, question_settings_update: QuestionSettingsUpdate
     ) -> None:
         if question_settings_update.type != QuestionType.span:
             return
@@ -146,9 +152,11 @@ def _validate_span_question_settings(
 
 
 class QuestionDeleteValidator:
-    def validate_for(self, dataset: Dataset):
-        self._validate_dataset_is_not_ready(dataset)
+    @classmethod
+    def validate(cls, dataset: Dataset):
+        cls._validate_dataset_is_not_ready(dataset)
 
-    def _validate_dataset_is_not_ready(self, dataset):
+    @staticmethod
+    def _validate_dataset_is_not_ready(dataset):
         if dataset.is_ready:
             raise UnprocessableEntityError("questions cannot be deleted for a published dataset")