esgvoc 1.0.1__py3-none-any.whl → 1.1.1__py3-none-any.whl

esgvoc/apps/drs/generator.py

@@ -1,7 +1,7 @@
 from typing import Any, Iterable, Mapping, cast
 
 import esgvoc.api.projects as projects
-from esgvoc.api.project_specs import DrsCollection, DrsConstant, DrsPartKind, DrsSpecification, DrsType
+from esgvoc.api.project_specs import DrsSpecification, DrsType
 from esgvoc.api.search import MatchingTerm
 from esgvoc.apps.drs.report import (
     AssignedTerm,
@@ -177,47 +177,54 @@ class DrsGenerator(DrsApplication):
         part_position: int = 0
         for part in specs.parts:
             part_position += 1
-            if part.kind == DrsPartKind.COLLECTION:
-                collection_part = cast(DrsCollection, part)
-                collection_id = collection_part.collection_id
-                if collection_id in mapping:
-                    part_value = mapping[collection_id]
-                    if has_to_valid_terms:
-                        matching_terms = projects.valid_term_in_collection(part_value, self.project_id, collection_id)
-                        if not matching_terms:
-                            issue = InvalidTerm(
-                                term=part_value,
-                                term_position=part_position,
-                                collection_id_or_constant_value=collection_id,
-                            )
-                            errors.append(issue)
-                            part_value = DrsGenerationReport.INVALID_TAG
-                else:
-                    other_issue = MissingTerm(collection_id=collection_id, collection_position=part_position)
-                    if collection_part.is_required:
-                        errors.append(other_issue)
-                        part_value = DrsGenerationReport.MISSING_TAG
+            collection_id = part.source_collection
+            if collection_id in mapping:
+                part_value = mapping[collection_id]
+                if has_to_valid_terms:
+                    if part.source_collection_term is None:
+                        matching_terms = projects.valid_term_in_collection(part_value,
+                                                                           self.project_id,
+                                                                           collection_id)
                     else:
-                        warnings.append(other_issue)
-                        continue  # The for loop.
+                        matching_terms = projects.valid_term(
+                            part_value,
+                            self.project_id,
+                            collection_id,
+                            part.source_collection_term).validated
+                    if not matching_terms:
+                        issue = InvalidTerm(term=part_value,
+                                            term_position=part_position,
+                                            collection_id_or_constant_value=collection_id)
+                        errors.append(issue)
+                        part_value = DrsGenerationReport.INVALID_TAG
             else:
-                constant_part = cast(DrsConstant, part)
-                part_value = constant_part.value
+                other_issue = MissingTerm(collection_id=collection_id, collection_position=part_position)
+                if part.is_required:
+                    errors.append(other_issue)
+                    part_value = DrsGenerationReport.MISSING_TAG
+                else:
+                    warnings.append(other_issue)
+                    continue  # The for loop.
 
             drs_expression += part_value + specs.separator
 
-        drs_expression = drs_expression[0 : len(drs_expression) - len(specs.separator)]
+        drs_expression = drs_expression[0: len(drs_expression) - len(specs.separator)]
         return drs_expression, errors, warnings
 
     def _generate_from_bag_of_terms(self, terms: Iterable[str], specs: DrsSpecification) -> DrsGenerationReport:  # noqa E127
         collection_terms_mapping: dict[str, set[str]] = dict()
         for term in terms:
-            matching_terms: list[MatchingTerm] = []
-            for col in [part.collection_id for part in specs.parts if part.kind == DrsPartKind.COLLECTION]:
-                matching_terms_in_col = projects.valid_term_in_collection(term, self.project_id, col)
-                for mtic in matching_terms_in_col:
-                    matching_terms.append(mtic)
-            # matching_terms = projects.valid_term_in_project(term, self.project_id)
+            matching_terms: list[MatchingTerm] = list()
+            for part in specs.parts:
+                if part.source_collection_term is None:
+                    matching_terms.extend(projects.valid_term_in_collection(term, self.project_id,
+                                                                            part.source_collection))
+                else:
+                    if projects.valid_term(term, self.project_id, part.source_collection,
+                                           part.source_collection_term).validated:
+                        matching_terms.append(MatchingTerm(project_id=self.project_id,
+                                                           collection_id=part.source_collection,
+                                                           term_id=part.source_collection_term))
             for matching_term in matching_terms:
                 if matching_term.collection_id not in collection_terms_mapping:
                     collection_terms_mapping[matching_term.collection_id] = set()
@@ -230,15 +237,13 @@ class DrsGenerator(DrsApplication):
         if self.pedantic:
             errors.extend(warnings)
             warnings.clear()
-        return DrsGenerationReport(
-            project_id=self.project_id,
-            type=specs.type,
-            given_mapping_or_bag_of_terms=terms,
-            mapping_used=mapping,
-            generated_drs_expression=drs_expression,
-            errors=cast(list[GenerationError], errors),
-            warnings=cast(list[GenerationWarning], warnings),
-        )
+        return DrsGenerationReport(project_id=self.project_id,
+                                   type=specs.type,
+                                   given_mapping_or_bag_of_terms=terms,
+                                   mapping_used=mapping,
+                                   generated_drs_expression=drs_expression,
+                                   errors=cast(list[GenerationError], errors),
+                                   warnings=cast(list[GenerationWarning], warnings))
 
     @staticmethod
     def _resolve_conflicts(
@@ -329,7 +334,7 @@ class DrsGenerator(DrsApplication):
             wining_id_and_term_pairs: list[tuple[str, str]] = list()
             for collection_ids in conflicting_collection_ids_list:
                 for collection_index in range(0, len(collection_ids)):
-                    collection_set = collection_ids[collection_index + 1 :] + collection_ids[:collection_index]
+                    collection_set = collection_ids[collection_index + 1:] + collection_ids[:collection_index]
                     diff: set[str] = collection_terms_mapping[collection_ids[collection_index]].difference(
                         *[
                             collection_terms_mapping[index]  # noqa E127

esgvoc/apps/drs/validator.py

@@ -3,10 +3,7 @@ from typing import cast
 import esgvoc.api.projects as projects
 import esgvoc.apps.drs.constants as constants
 from esgvoc.api.project_specs import (
-    DrsCollection,
-    DrsConstant,
     DrsPart,
-    DrsPartKind,
     DrsSpecification,
     DrsType,
     ProjectSpecs,
@@ -44,19 +41,12 @@ class DrsApplication:
         project_specs: ProjectSpecs | None = projects.get_project(project_id)
         if not project_specs:
             raise EsgvocNotFoundError(f"unable to find project '{project_id}'")
-        for specs in project_specs.drs_specs:
-            match specs.type:
-                case DrsType.DIRECTORY:
-                    self.directory_specs: DrsSpecification = specs
-                    """The DRS directory specs of the project."""
-                case DrsType.FILE_NAME:
-                    self.file_name_specs: DrsSpecification = specs
-                    """The DRS file name specs of the project."""
-                case DrsType.DATASET_ID:
-                    self.dataset_id_specs: DrsSpecification = specs
-                    """The DRS dataset id specs of the project."""
-                case _:
-                    raise EsgvocDbError(f"unsupported DRS specs type '{specs.type}'")
+        self.directory_specs: DrsSpecification = project_specs.drs_specs[DrsType.DIRECTORY]
+        """The DRS directory specs of the project."""
+        self.file_name_specs: DrsSpecification = project_specs.drs_specs[DrsType.FILE_NAME]
+        """The DRS file name specs of the project."""
+        self.dataset_id_specs: DrsSpecification = project_specs.drs_specs[DrsType.DATASET_ID]
+        """The DRS dataset id specs of the project."""
 
     def _get_full_file_name_extension(self) -> str:
         """
@@ -229,21 +219,18 @@ class DrsValidator(DrsApplication):
         return sorted(issues, key=lambda issue: issue.column if issue.column else 0)
 
     def _validate_term(self, term: str, part: DrsPart) -> bool:
-        match part.kind:
-            case DrsPartKind.COLLECTION:
-                casted_part: DrsCollection = cast(DrsCollection, part)
-                matching_terms = projects.valid_term_in_collection(term,
-                                                                   self.project_id,
-                                                                   casted_part.collection_id)
-                if len(matching_terms) > 0:
-                    return True
-                else:
-                    return False
-            case DrsPartKind.CONSTANT:
-                part_casted: DrsConstant = cast(DrsConstant, part)
-                return part_casted.value != term
-            case _:
-                raise EsgvocDbError(f"unsupported DRS specs part type '{part.kind}'")
+        if part.source_collection_term is None:
+            matching_terms = projects.valid_term_in_collection(
+                term,
+                self.project_id,
+                part.source_collection)
+            if len(matching_terms) > 0:
+                return True
+            else:
+                return False
+        else:
+            return projects.valid_term(term, self.project_id, part.source_collection,
+                                       part.source_collection_term).validated
 
     def _create_report(self,
                        type: DrsType,
@@ -268,13 +255,12 @@ class DrsValidator(DrsApplication):
         matching_code_mapping = dict()
         while part_index < part_max_index:
             term = terms[term_index]
-            part = specs.parts[part_index]
+            part: DrsPart = specs.parts[part_index]
             if self._validate_term(term, part):
                 term_index += 1
                 part_index += 1
                 matching_code_mapping[part.__str__()] = 0
-            elif part.kind == DrsPartKind.CONSTANT or \
-                 cast(DrsCollection, part).is_required:  # noqa E127
+            elif part.is_required:
                 issue: ComplianceIssue = InvalidTerm(term=term,
                                                      term_position=term_index+1,
                                                      collection_id_or_constant_value=str(part))
@@ -298,8 +284,7 @@ class DrsValidator(DrsApplication):
             for index in range(part_index, part_max_index):
                 part = specs.parts[index]
                 issue = MissingTerm(collection_id=str(part), collection_position=index+1)
-                if part.kind == DrsPartKind.CONSTANT or \
-                   cast(DrsCollection, part).is_required:
+                if part.is_required:
                     errors.append(issue)
                 else:
                     warnings.append(issue)
@@ -308,8 +293,7 @@ class DrsValidator(DrsApplication):
             for index in range(term_index, term_max_index):
                 term = terms[index]
                 part = specs.parts[part_index]
-                if part.kind != DrsPartKind.CONSTANT           and \
-                   (not cast(DrsCollection, part).is_required) and \
+                if (not part.is_required) and \
                     matching_code_mapping[part.__str__()] < 0: # noqa E125
                     issue = ExtraTerm(term=term, term_position=index, collection_id=str(part))
                 else: