esgvoc 0.1.2__py3-none-any.whl → 0.2.1__py3-none-any.whl

esgvoc/api/projects.py

@@ -8,7 +8,8 @@ from esgvoc.api._utils import (get_universe_session, instantiate_pydantic_term,
                                instantiate_pydantic_terms)
 from esgvoc.api.report import (ProjectTermError, UniverseTermError,
                                ValidationError, ValidationReport)
-from esgvoc.api.search import MatchingTerm, SearchSettings, create_str_comparison_expression
+from esgvoc.api.search import MatchingTerm, SearchSettings, _create_str_comparison_expression
+from esgvoc.api.project_specs import ProjectSpecs
 from esgvoc.core.db.connection import DBConnection
 from esgvoc.core.db.models.mixins import TermKind
 from esgvoc.core.db.models.project import Collection, Project, PTerm
@@ -17,6 +18,24 @@ from pydantic import BaseModel
 from sqlmodel import Session, and_, select
 
 
+# [OPTIMIZATION]
+_VALID_TERM_IN_COLLECTION_CACHE: dict[str, list[MatchingTerm]] = dict()
+_VALID_VALUE_AGAINST_GIVEN_TERM_CACHE: dict[str, list[ValidationError]] = dict()
+
+
+def get_project_specs(project_id: str) -> ProjectSpecs:
+    project_specs = find_project(project_id)
+    if not project_specs:
+        msg = f'Unable to find project {project_id}'
+        raise ValueError(msg)
+    try:
+        result = ProjectSpecs(**project_specs)
+    except Exception as e:
+        msg = f'Unable to read specs in project {project_id}'
+        raise RuntimeError(msg) from e
+    return result
+
+
 def _get_project_connection(project_id: str) -> DBConnection|None:
     return service.state_service.projects[project_id].db_connection
 
@@ -31,7 +50,7 @@ def _get_project_session_with_exception(project_id: str) -> Session:
 def _resolve_term(term_composite_part: dict,
                   universe_session: Session,
                   project_session: Session) -> UTerm|PTerm:
-    '''First find the term in the universe than in the current project'''
+    # First find the term in the universe than in the current project
     term_id = term_composite_part[esgvoc.core.constants.TERM_ID_JSON_KEY]
     term_type = term_composite_part[esgvoc.core.constants.TERM_TYPE_JSON_KEY]
     uterms = universe._find_terms_in_data_descriptor(data_descriptor_id=term_type,
@@ -156,9 +175,11 @@ def _valid_value_for_term_composite(value: str,
 
 def _create_term_error(value: str, term: UTerm|PTerm) -> ValidationError:
     if isinstance(term, UTerm):
-        return UniverseTermError(value, term)
+        return UniverseTermError(value=value, term=term.specs, term_kind=term.kind,
+                                 data_descriptor_id=term.data_descriptor.id)
     else:
-        return ProjectTermError(value, term)
+        return ProjectTermError(value=value, term=term.specs, term_kind=term.kind,
+                                collection_id=term.collection.id)
 
 
 def _valid_value(value: str,
@@ -184,13 +205,11 @@ def _valid_value(value: str,
     return result
 
 
-def _check_and_strip_value(value: str) -> str:
-    if not value:
+def _check_value(value: str) -> str:
+    if not value or value.isspace():
         raise ValueError('value should be set')
-    if result:= value.strip():
-        return result
     else:
-        raise ValueError('value should not be empty')
+        return value
 
 
 def _search_plain_term_and_valid_value(value: str,
@@ -223,26 +242,33 @@ def _valid_value_against_all_terms_of_collection(value: str,
 
 
 def _valid_value_against_given_term(value: str,
+                                    project_id: str,
                                     collection_id: str,
                                     term_id: str,
                                     universe_session: Session,
                                     project_session: Session)\
                                         -> list[ValidationError]:
-    try:
-        terms = _find_terms_in_collection(collection_id,
-                                          term_id,
-                                          project_session,
-                                          None)
-        if terms:
-            term = terms[0]
-            result = _valid_value(value, term, universe_session, project_session)
-        else:
-            raise ValueError(f'unable to find term {term_id} ' +
-                             f'in collection {collection_id}')
-    except Exception as e:
-        msg = f'unable to valid term {term_id} ' +\
-              f'in collection {collection_id}'
-        raise RuntimeError(msg) from e
+    # [OPTIMIZATION]
+    key = value + project_id + collection_id + term_id
+    if key in _VALID_VALUE_AGAINST_GIVEN_TERM_CACHE:
+        result = _VALID_VALUE_AGAINST_GIVEN_TERM_CACHE[key]
+    else:
+        try:
+            terms = _find_terms_in_collection(collection_id,
+                                              term_id,
+                                              project_session,
+                                              None)
+            if terms:
+                term = terms[0]
+                result = _valid_value(value, term, universe_session, project_session)
+            else:
+                raise ValueError(f'unable to find term {term_id} ' +
+                                 f'in collection {collection_id}')
+        except Exception as e:
+            msg = f'unable to valid term {term_id} ' +\
+                  f'in collection {collection_id}'
+            raise RuntimeError(msg) from e
+        _VALID_VALUE_AGAINST_GIVEN_TERM_CACHE[key] = result
     return result
 
 
@@ -256,14 +282,14 @@ def valid_term(value: str,
     a report that contains the possible errors.
     
     Behavior based on the nature of the term:
-    - plain term: the function try to match the value on the drs_name field.
-    - term pattern: the function try to match the value on the pattern field (regex).
-    - term composite: 
-        - if the composite has got a separator, the function splits the value according to the
-          separator of the term then it try to match every part of the composite
-          with every split of the value.
-        - if the composite hasn't got a separator, the function aggregates the parts of the composite
-          so as to compare it as a regex to the value.
+        - plain term: the function try to match the value on the drs_name field.
+        - term pattern: the function try to match the value on the pattern field (regex).
+        - term composite: 
+            - if the composite has got a separator, the function splits the value according to the\
+              separator of the term then it try to match every part of the composite\
+              with every split of the value.
+            - if the composite hasn't got a separator, the function aggregates the parts of the \
+              composite so as to compare it as a regex to the value.
 
     If any of the provided ids (`project_id`, `collection_id` or `term_id`) is not found,
     the function raises a ValueError.
@@ -280,12 +306,12 @@ def valid_term(value: str,
     :rtype: ValidationReport
     :raises ValueError: If any of the provided ids is not found
     """
-    value = _check_and_strip_value(value)
+    value = _check_value(value)
     with get_universe_session() as universe_session, \
          _get_project_session_with_exception(project_id) as project_session:
-        errors = _valid_value_against_given_term(value, collection_id, term_id,
+        errors = _valid_value_against_given_term(value, project_id, collection_id, term_id,
                                                  universe_session, project_session)
-        return ValidationReport(value, errors)
+        return ValidationReport(expression=value, errors=errors)
 
 
 def _valid_term_in_collection(value: str,
@@ -294,28 +320,38 @@ def _valid_term_in_collection(value: str,
                               universe_session: Session,
                               project_session: Session) \
                                 -> list[MatchingTerm]:
-    value = _check_and_strip_value(value)
-    result = list()
-    collections = _find_collections_in_project(collection_id,
-                                               project_session,
-                                               None)
-    if collections:
-        collection = collections[0]
-        match collection.term_kind:
-            case TermKind.PLAIN:
-                term_id_found = _search_plain_term_and_valid_value(value, collection_id,
-                                                                   project_session)
-                if term_id_found:
-                    result.append(MatchingTerm(project_id, collection_id, term_id_found))
-            case _:
-                term_ids_found = _valid_value_against_all_terms_of_collection(value, collection,
-                                                                              universe_session,
-                                                                              project_session)
-                for term_id_found in term_ids_found:
-                    result.append(MatchingTerm(project_id, collection_id, term_id_found))
+    # [OPTIMIZATION]
+    key = value + project_id + collection_id
+    if key in _VALID_TERM_IN_COLLECTION_CACHE:
+        result = _VALID_TERM_IN_COLLECTION_CACHE[key]
     else:
-        msg = f'unable to find collection {collection_id}'
-        raise ValueError(msg)
+        value = _check_value(value)
+        result = list()
+        collections = _find_collections_in_project(collection_id,
+                                                   project_session,
+                                                   None)
+        if collections:
+            collection = collections[0]
+            match collection.term_kind:
+                case TermKind.PLAIN:
+                    term_id_found = _search_plain_term_and_valid_value(value, collection_id,
+                                                                       project_session)
+                    if term_id_found:
+                        result.append(MatchingTerm(project_id=project_id,
+                                                   collection_id=collection_id,
+                                                   term_id=term_id_found))
+                case _:
+                    term_ids_found = _valid_value_against_all_terms_of_collection(value, collection,
+                                                                                  universe_session,
+                                                                                  project_session)
+                    for term_id_found in term_ids_found:
+                        result.append(MatchingTerm(project_id=project_id,
+                                                   collection_id=collection_id,
+                                                   term_id=term_id_found))
+        else:
+            msg = f'unable to find collection {collection_id}'
+            raise ValueError(msg)
+        _VALID_TERM_IN_COLLECTION_CACHE[key] = result
     return result
 
 
@@ -328,14 +364,14 @@ def valid_term_in_collection(value: str,
     returns the terms that the value matches.
     
     Behavior based on the nature of the term:
-    - plain term: the function try to match the value on the drs_name field.
-    - term pattern: the function try to match the value on the pattern field (regex).
-    - term composite: 
-        - if the composite has got a separator, the function splits the value according to the
-          separator of the term then it try to match every part of the composite
-          with every split of the value.
-        - if the composite hasn't got a separator, the function aggregates the parts of the composite
-          so as to compare it as a regex to the value.
+        - plain term: the function try to match the value on the drs_name field.
+        - term pattern: the function try to match the value on the pattern field (regex).
+        - term composite: 
+            - if the composite has got a separator, the function splits the value according to the \
+              separator of the term then it try to match every part of the composite \
+              with every split of the value.
+            - if the composite hasn't got a separator, the function aggregates the parts of the \
+              composite so as to compare it as a regex to the value.
 
     If any of the provided ids (`project_id` or `collection_id`) is not found,
     the function raises a ValueError.
@@ -374,14 +410,14 @@ def valid_term_in_project(value: str, project_id: str) -> list[MatchingTerm]:
     returns the terms that the value matches.
     
     Behavior based on the nature of the term:
-    - plain term: the function try to match the value on the drs_name field.
-    - term pattern: the function try to match the value on the pattern field (regex).
-    - term composite: 
-        - if the composite has got a separator, the function splits the value according to the
-          separator of the term then it try to match every part of the composite
-          with every split of the value.
-        - if the composite hasn't got a separator, the function aggregates the parts of the composite
-          so as to compare it as a regex to the value.
+        - plain term: the function try to match the value on the drs_name field.
+        - term pattern: the function try to match the value on the pattern field (regex).
+        - term composite: 
+            - if the composite has got a separator, the function splits the value according to the \
+              separator of the term then it try to match every part of the composite \
+              with every split of the value.
+            - if the composite hasn't got a separator, the function aggregates the parts of the \
+              composite so as to compare it as a regex to the value.
 
     If the `project_id` is not found, the function raises a ValueError.
 
@@ -404,14 +440,14 @@ def valid_term_in_all_projects(value: str) -> list[MatchingTerm]:
     returns the terms that the value matches.
     
     Behavior based on the nature of the term:
-    - plain term: the function try to match the value on the drs_name field.
-    - term pattern: the function try to match the value on the pattern field (regex).
-    - term composite: 
-        - if the composite has got a separator, the function splits the value according to the
-          separator of the term then it try to match every part of the composite
-          with every split of the value.
-        - if the composite hasn't got a separator, the function aggregates the parts of the composite
-          so as to compare it as a regex to the value.
+        - plain term: the function try to match the value on the drs_name field.
+        - term pattern: the function try to match the value on the pattern field (regex).
+        - term composite: 
+            - if the composite has got a separator, the function splits the value according to the \
+              separator of the term then it try to match every part of the composite \
+              with every split of the value.
+            - if the composite hasn't got a separator, the function aggregates the parts of the \
+              composite so as to compare it as a regex to the value.
 
     :param value: A value to be validated
     :type value: str
@@ -431,10 +467,10 @@ def _find_terms_in_collection(collection_id: str,
                               term_id: str,
                               session: Session,
                               settings: SearchSettings|None = None) -> Sequence[PTerm]:
-    """Settings only apply on the term_id comparison."""
-    where_expression = create_str_comparison_expression(field=PTerm.id,
-                                                        value=term_id,
-                                                        settings=settings)
+    # Settings only apply on the term_id comparison.
+    where_expression = _create_str_comparison_expression(field=PTerm.id,
+                                                         value=term_id,
+                                                         settings=settings)
     statement = select(PTerm).join(Collection).where(Collection.id==collection_id,
                                                      where_expression)
     results = session.exec(statement)
@@ -458,9 +494,9 @@ def find_terms_in_collection(project_id:str,
     the function returns an empty list.
     
     Behavior based on search type:
-    - `EXACT` and absence of `settings`: returns zero or one Pydantic term instance in the list.
-    - `REGEX`, `LIKE`, `STARTS_WITH` and `ENDS_WITH`: returns zero, one or more
-      Pydantic term instances in the list.
+        - `EXACT` and absence of `settings`: returns zero or one Pydantic term instance in the list.
+        - `REGEX`, `LIKE`, `STARTS_WITH` and `ENDS_WITH`: returns zero, one or more \
+          Pydantic term instances in the list.
 
     :param project_id: A project id
     :type project_id: str
@@ -486,10 +522,10 @@ def _find_terms_from_data_descriptor_in_project(data_descriptor_id: str,
                                                 session: Session,
                                                 settings: SearchSettings|None = None) \
                                                    -> Sequence[PTerm]:
-    """Settings only apply on the term_id comparison."""
-    where_expression = create_str_comparison_expression(field=PTerm.id,
-                                                        value=term_id,
-                                                        settings=settings)
+    # Settings only apply on the term_id comparison.
+    where_expression = _create_str_comparison_expression(field=PTerm.id,
+                                                         value=term_id,
+                                                         settings=settings)
     statement = select(PTerm).join(Collection).where(Collection.data_descriptor_id==data_descriptor_id,
                                                      where_expression)
     results = session.exec(statement)
@@ -514,10 +550,10 @@ def find_terms_from_data_descriptor_in_project(project_id: str,
     the function returns an empty list.
     
     Behavior based on search type:
-    - `EXACT` and absence of `settings`: returns zero or one Pydantic term instance and
-      collection id in the list.
-    - `REGEX`, `LIKE`, `STARTS_WITH` and `ENDS_WITH`: returns zero, one or more
-      Pydantic term instances and collection ids in the list.
+        - `EXACT` and absence of `settings`: returns zero or one Pydantic term instance and \
+          collection id in the list.
+        - `REGEX`, `LIKE`, `STARTS_WITH` and `ENDS_WITH`: returns zero, one or more \
+          Pydantic term instances and collection ids in the list.
 
     :param project_id: A project id
     :type project_id: str
@@ -527,7 +563,7 @@ def find_terms_from_data_descriptor_in_project(project_id: str,
     :type term_id: str
     :param settings: The search settings
     :type settings: SearchSettings|None
-    :returns: A list of tuple of Pydantic term instances and related collection ids.
+    :returns: A list of tuple of Pydantic term instances and related collection ids. \
     Returns an empty list if no matches are found.
     :rtype: list[tuple[BaseModel, str]]
     """
@@ -548,7 +584,7 @@ def find_terms_from_data_descriptor_in_project(project_id: str,
 def find_terms_from_data_descriptor_in_all_projects(data_descriptor_id: str,
                                                     term_id: str,
                                                     settings: SearchSettings|None = None) \
-                                                       -> list[tuple[BaseModel, str]]:
+                                                    -> list[tuple[list[tuple[BaseModel, str]], str]]:
     """
     Finds one or more terms in all projects which are instances of the given data descriptor
     in the universe, based on the specified search settings, in the given collection of a project.
@@ -561,10 +597,10 @@ def find_terms_from_data_descriptor_in_all_projects(data_descriptor_id: str,
     the function returns an empty list.
     
     Behavior based on search type:
-    - `EXACT` and absence of `settings`: returns zero or one Pydantic term instance and
-      collection id in the list.
-    - `REGEX`, `LIKE`, `STARTS_WITH` and `ENDS_WITH`: returns zero, one or more
-      Pydantic term instances and collection ids in the list.
+        - `EXACT` and absence of `settings`: returns zero or one Pydantic term instance and \
+          collection id in the list.
+        - `REGEX`, `LIKE`, `STARTS_WITH` and `ENDS_WITH`: returns zero, one or more \
+          Pydantic term instances and collection ids in the list.
 
     :param data_descriptor_id: A data descriptor
     :type data_descriptor_id: str
@@ -572,26 +608,27 @@ def find_terms_from_data_descriptor_in_all_projects(data_descriptor_id: str,
     :type term_id: str
     :param settings: The search settings
     :type settings: SearchSettings|None
-    :returns: A list of tuple of Pydantic term instances and related collection ids.
+    :returns: A list of tuple of matching terms with their collection id, per project. \
     Returns an empty list if no matches are found.
-    :rtype: list[tuple[BaseModel, str]]
+    :rtype: list[tuple[list[tuple[BaseModel, str]], str]]
     """
     project_ids = get_all_projects()
-    result = list()
+    result: list[tuple[list[tuple[BaseModel, str]], str]] = list()
     for project_id in project_ids:
-        result.extend(find_terms_from_data_descriptor_in_project(project_id,
-                                                                 data_descriptor_id,
-                                                                 term_id,
-                                                                 settings))
+        matching_terms = find_terms_from_data_descriptor_in_project(project_id,
+                                                                    data_descriptor_id,
+                                                                    term_id,
+                                                                    settings)
+        result.append((matching_terms, project_id))
     return result
 
 
 def _find_terms_in_project(term_id: str,
                            session: Session,
                            settings: SearchSettings|None) -> Sequence[PTerm]:
-    where_expression = create_str_comparison_expression(field=PTerm.id,
-                                                        value=term_id,
-                                                        settings=settings)
+    where_expression = _create_str_comparison_expression(field=PTerm.id,
+                                                         value=term_id,
+                                                         settings=settings)
     statement = select(PTerm).where(where_expression)
     results = session.exec(statement).all()
     return results
@@ -668,8 +705,7 @@ def get_all_terms_in_collection(project_id: str,
     :type project_id: str
     :param collection_id: A collection id
     :type collection_id: str
-    :returns: a list of Pydantic term instances.
-    Returns an empty list if no matches are found.
+    :returns: a list of Pydantic term instances. Returns an empty list if no matches are found.
     :rtype: list[BaseModel]
     """
     result = list()
@@ -688,9 +724,9 @@ def _find_collections_in_project(collection_id: str,
                                  session: Session,
                                  settings: SearchSettings|None) \
                                     -> Sequence[Collection]:
-    where_exp = create_str_comparison_expression(field=Collection.id,
-                                                 value=collection_id,
-                                                 settings=settings)
+    where_exp = _create_str_comparison_expression(field=Collection.id,
+                                                  value=collection_id,
+                                                  settings=settings)
     statement = select(Collection).where(where_exp)
     results = session.exec(statement)
     result = results.all()
@@ -713,9 +749,9 @@ def find_collections_in_project(project_id: str,
     an empty list.
         
     Behavior based on search type:
-    - `EXACT` and absence of `settings`: returns zero or one collection context in the list.
-    - `REGEX`, `LIKE`, `STARTS_WITH` and `ENDS_WITH`: returns zero, one or more
-      collection contexts in the list.
+        - `EXACT` and absence of `settings`: returns zero or one collection context in the list.
+        - `REGEX`, `LIKE`, `STARTS_WITH` and `ENDS_WITH`: returns zero, one or more \
+          collection contexts in the list.
 
     :param project_id: A project id
     :type project_id: str
@@ -723,8 +759,7 @@ def find_collections_in_project(project_id: str,
     :type collection_id: str
     :param settings: The search settings
     :type settings: SearchSettings|None
-    :returns: A list of collection contexts.
-    Returns an empty list if no matches are found.
+    :returns: A list of collection contexts. Returns an empty list if no matches are found.
     :rtype: list[dict]
     """
     result = list()
@@ -753,8 +788,7 @@ def get_all_collections_in_project(project_id: str) -> list[str]:
 
     :param project_id: A project id
     :type project_id: str
-    :returns: A list of collection ids.
-    Returns an empty list if no matches are found.
+    :returns: A list of collection ids. Returns an empty list if no matches are found.
     :rtype: list[str]
     """
     result = list()
@@ -782,8 +816,7 @@ def get_all_terms_in_project(project_id: str) -> list[BaseModel]:
 
     :param project_id: A project id
     :type project_id: str
-    :returns: A list of Pydantic term instances.
-    Returns an empty list if no matches are found.
+    :returns: A list of Pydantic term instances. Returns an empty list if no matches are found.
     :rtype: list[BaseModel]
     """
     result = list()
@@ -819,8 +852,7 @@ def find_project(project_id: str) -> dict|None:
     
     :param project_id: A project id to be found
     :type project_id: str
-    :returns: The specs of the project found.
-    Returns `None` if no matches are found.
+    :returns: The specs of the project found. Returns `None` if no matches are found.
     :rtype: dict|None
     """
     result = None
@@ -848,7 +880,5 @@ if __name__ == "__main__":
         print('OK')
     else:
         print(vr)
-        from esgvoc.api import BasicValidationErrorVisitor
-        visitor = BasicValidationErrorVisitor()
         for error in vr.errors:
-            print(error.accept(visitor))
+            print(error)

esgvoc/api/report.py

@@ -1,80 +1,106 @@
+from pydantic import BaseModel, computed_field
 from abc import ABC, abstractmethod
-from typing import Any
+from typing import Any, Protocol
 
 import esgvoc.core.constants as api_settings
 from esgvoc.core.db.models.mixins import TermKind
-from esgvoc.core.db.models.project import PTerm
-from esgvoc.core.db.models.universe import UTerm
 
 
-class ValidationErrorVisitor(ABC):
-    @abstractmethod
+class ValidationErrorVisitor(Protocol):
+    """
+    Specifications for a term validation error visitor.
+    """
     def visit_universe_term_error(self, error: "UniverseTermError") -> Any:
+        """Visit a universe term error."""
         pass
 
-    @abstractmethod
     def visit_project_term_error(self, error: "ProjectTermError") -> Any:
+        """Visit a project term error."""
         pass
 
 
-class BasicValidationErrorVisitor(ValidationErrorVisitor):
-    def visit_universe_term_error(self, error: "UniverseTermError") -> Any:
-        term_id = error.term[api_settings.TERM_ID_JSON_KEY]
-        result = f"The term {term_id} from the data descriptor {error.data_descriptor_id} "+\
-                 f"does not validate the given value '{error.value}'"
-        return result
-
-    def visit_project_term_error(self, error: "ProjectTermError") -> Any:
-        term_id = error.term[api_settings.TERM_ID_JSON_KEY]
-        result = f"The term {term_id} from the collection {error.collection_id} "+\
-                 f"does not validate the given value '{error.value}'"
-        return result
-
-
-class ValidationError(ABC):
-    def __init__(self,
-                 value: str):
-        self.value: str = value
+class ValidationError(BaseModel, ABC):
+    """
+    Generic class for the term validation error.
+    """
+    value: str
+    """The given value that is invalid."""
+    term: dict
+    """JSON specification of the term."""
+    term_kind: TermKind
+    """The kind of term."""
     
     @abstractmethod
     def accept(self, visitor: ValidationErrorVisitor) -> Any:
+        """
+        Accept a validation error visitor.
+
+        :param visitor: The validation error visitor.
+        :type visitor: ValidationErrorVisitor
+        :return: Depending on the visitor.
+        :rtype: Any
+        """
         pass
 
 class UniverseTermError(ValidationError):
-    def __init__(self,
-                 value: str,
-                 term: UTerm):
-        super().__init__(value)
-        self.term: dict = term.specs
-        self.term_kind: TermKind = term.kind
-        self.data_descriptor_id: str = term.data_descriptor.id
+    """
+    A validation error on a term from the universe.
+    """
+    
+    data_descriptor_id: str
+    """The data descriptor that the term belongs."""
 
     def accept(self, visitor: ValidationErrorVisitor) -> Any:
         return visitor.visit_universe_term_error(self)
+    
+    def __str__(self) -> str:
+        term_id = self.term[api_settings.TERM_ID_JSON_KEY]
+        result = f"The term {term_id} from the data descriptor {self.data_descriptor_id} "+\
+                 f"does not validate the given value '{self.value}'"
+        return result
+    def __repr__(self) -> str:
+        return self.__str__()
 
 
 class ProjectTermError(ValidationError):
-    def __init__(self,
-                 value: str,
-                 term: PTerm):
-        super().__init__(value)
-        self.term: dict = term.specs
-        self.term_kind: TermKind = term.kind
-        self.collection_id: str = term.collection.id
+    """
+    A validation error on a term from a project.
+    """
+    
+    collection_id: str
+    """The collection id that the term belongs"""
 
     def accept(self, visitor: ValidationErrorVisitor) -> Any:
         return visitor.visit_project_term_error(self)
-
-
-class ValidationReport:
-    def __init__(self,
-                 given_expression: str,
-                 errors: list[ValidationError]):
-        self.expression: str = given_expression
-        self.errors: list[ValidationError] = errors
-        self.nb_errors = len(self.errors) if self.errors else 0
-        self.validated: bool = False if errors else True
-        self.message = f"'{self.expression}' has {self.nb_errors} error(s)"
+    
+    def __str__(self) -> str:
+        term_id = self.term[api_settings.TERM_ID_JSON_KEY]
+        result = f"The term {term_id} from the collection {self.collection_id} "+\
+                 f"does not validate the given value '{self.value}'"
+        return result
+    def __repr__(self) -> str:
+        return self.__str__()
+
+
+class ValidationReport(BaseModel):
+    """
+    Term validation report.
+    """
+    expression: str
+    """The given expression."""
+    errors: list[ValidationError]
+    """The validation errors."""
+    @computed_field # type: ignore
+    @property
+    def nb_errors(self) -> int:
+        """The number of validation errors."""
+        return len(self.errors) if self.errors else 0
+    @computed_field # type: ignore
+    @property
+    def validated(self) -> bool:
+        """The expression is validated or not."""
+        return False if self.errors else True
+        
    
     def __len__(self) -> int:
         return self.nb_errors
@@ -82,5 +108,7 @@ class ValidationReport:
     def __bool__(self) -> bool:
         return self.validated
     
+    def __str__(self) -> str:
+        return f"'{self.expression}' has {self.nb_errors} error(s)"
     def __repr__(self) -> str:
-        return self.message
+        return self.__str__()