esgvoc 1.0.0__tar.gz → 1.0.1__tar.gz

{esgvoc-1.0.0 → esgvoc-1.0.1}/.pre-commit-config.yaml

@@ -22,14 +22,6 @@ repos:
       - id: ruff
         name: ruff-sort-imports
         args: [--select, I, --fix]
-  - repo: local
-    hooks:
-    -   id: wily
-        name: wily
-        entry: wily diff
-        verbose: true
-        language: python
-        additional_dependencies: [wily]
   - repo: https://github.com/PyCQA/flake8
     rev: 7.1.2
     hooks:

{esgvoc-1.0.0 → esgvoc-1.0.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: esgvoc
-Version: 1.0.0
+Version: 1.0.1
 Summary: python library and CLI to interact with WCRP CVs
 Project-URL: Repository, https://github.com/ESGF/esgf-vocab
 Author-email: Sébastien Gardoll <sebastien@gardoll.fr>, Guillaume Levavasseur <guillaume.levavasseur@ipsl.fr>, Laurent Troussellier <laurent.troussellier@ipsl.fr>
@@ -62,7 +62,6 @@ esgvoc install
 
 ```bash
 pip install -e .
-wily setup
 pip install pre-commit
 pre-commit install
 ```
@@ -71,6 +70,5 @@ pre-commit install
 
 ```bash
 uv sync
-uv run wily setup
 uv run pre-commit install
 ```

{esgvoc-1.0.0 → esgvoc-1.0.1}/README.md

@@ -43,7 +43,6 @@ esgvoc install
 
 ```bash
 pip install -e .
-wily setup
 pip install pre-commit
 pre-commit install
 ```
@@ -52,6 +51,5 @@ pre-commit install
 
 ```bash
 uv sync
-uv run wily setup
 uv run pre-commit install
 ```

{esgvoc-1.0.0 → esgvoc-1.0.1}/pyproject.toml

@@ -53,7 +53,6 @@ dev = [
     "sphinx-copybutton>=0.5.2",
     "pre-commit>=4.1.0",
     "flake8>=7.1.2",
-    "wily>=1.25.0",
     "ruff>=0.11.0",
     "pyright>=1.1.396",
     "mypy>=1.13.0",

{esgvoc-1.0.0 → esgvoc-1.0.1}/src/esgvoc/__init__.py

@@ -1,3 +1,3 @@
 import esgvoc.core.logging_handler  # noqa
 
-__version__ = "1.0.0"
+__version__ = "1.0.1"

{esgvoc-1.0.0 → esgvoc-1.0.1}/src/esgvoc/api/data_descriptors/__init__.py

@@ -20,6 +20,7 @@ from esgvoc.api.data_descriptors.initialisation_index import InitialisationIndex
 from esgvoc.api.data_descriptors.institution import Institution
 from esgvoc.api.data_descriptors.known_branded_variable import KnownBrandedVariable
 from esgvoc.api.data_descriptors.license import License
+from esgvoc.api.data_descriptors.member_id import MemberId
 from esgvoc.api.data_descriptors.mip_era import MipEra
 from esgvoc.api.data_descriptors.model_component import ModelComponent
 from esgvoc.api.data_descriptors.obs_type import ObsType
@@ -87,5 +88,6 @@ DATA_DESCRIPTOR_CLASS_MAPPING: dict[str, type[DataDescriptor]] = {
     "title": Title,
     "contact": Contact,
     "region": Region,
+    "member_id": MemberId,
     "obs_type": ObsType,  # obs4Mips
 }

esgvoc-1.0.1/src/esgvoc/api/data_descriptors/member_id.py

@@ -0,0 +1,9 @@
+from esgvoc.api.data_descriptors.data_descriptor import CompositeTermDataDescriptor
+
+
+class MemberId(CompositeTermDataDescriptor):
+    """
+    The member_id uniquely identifies a specific model simulation within an experiment. It is created by combining the sub_experiment, which describes the setup or timing of the simulation (like a specific start year), and the variant_label, which details the configuration of the model (including initial conditions, physics, and forcings). Together, they form a code like s1960-r1i1p1f1. This allows users to distinguish between different ensemble members and understand how each run differs from others within the same experiment.
+    """
+
+    description: str

{esgvoc-1.0.0 → esgvoc-1.0.1}/src/esgvoc/api/projects.py

@@ -1,3 +1,4 @@
+import itertools
 import re
 from typing import Iterable, Sequence
 
@@ -72,9 +73,86 @@ def _get_composite_term_separator_parts(term: UTerm | PTerm) -> tuple[str, list]
     return separator, parts
 
 
+def _valid_value_composite_term_with_separator(
+    value: str, term: UTerm | PTerm, universe_session: Session, project_session: Session
+) -> list[UniverseTermError | ProjectTermError]:
+    result = []
+    separator, parts = _get_composite_term_separator_parts(term)
+    required_indices = {i for i, p in enumerate(parts) if p.get("is_required", False)}
+
+    splits = value.split(separator)
+    nb_splits = len(splits)
+    nb_parts = len(parts)
+
+    if nb_splits > nb_parts:
+        return [_create_term_error(value, term)]
+
+    # Generate all possible assignments of split values into parts
+    # Only keep those that include all required parts
+    all_positions = [i for i in range(nb_parts)]
+    valid_combinations = [
+        comb for comb in itertools.combinations(all_positions, nb_splits) if required_indices.issubset(comb)
+    ]
+
+    for positions in valid_combinations:
+        candidate = [None] * nb_parts
+        for idx, pos in enumerate(positions):
+            candidate[pos] = splits[idx]
+
+        # Separator structure validation:
+        # - No leading separator if the first part is None
+        # - No trailing separator if the last part is None
+        # - No double separators where two adjacent optional parts are missing
+        if candidate[0] is None and value.startswith(separator):
+            continue
+        if candidate[-1] is None and value.endswith(separator):
+            continue
+        if any(
+            candidate[i] is None and candidate[i + 1] is None and separator * 2 in value for i in range(nb_parts - 1)
+        ):
+            continue  # invalid double separator between two missing parts
+
+        # Validate each filled part value
+        all_valid = True
+        for i, given_value in enumerate(candidate):
+            if given_value is None:
+                if parts[i].get("is_required", False):
+                    all_valid = False
+                    break
+                continue  # optional and missing part is allowed
+
+            part = parts[i]
+
+            # Resolve term ID list if not present
+            if "id" not in part:
+                terms = universe.get_all_terms_in_data_descriptor(part["type"], None)
+                part["id"] = [term.id for term in terms]
+            if isinstance(part["id"], str):
+                part["id"] = [part["id"]]
+
+            # Try all possible term IDs to find a valid match
+            valid_for_this_part = False
+            for id in part["id"]:
+                part_copy = dict(part)
+                part_copy["id"] = id
+                resolved_term = _resolve_term(part_copy, universe_session, project_session)
+                errors = _valid_value(given_value, resolved_term, universe_session, project_session)
+                if not errors:
+                    valid_for_this_part = True
+                    break
+            if not valid_for_this_part:
+                all_valid = False
+                break
+
+        if all_valid:
+            return []  # At least one valid combination found
+
+    return [_create_term_error(value, term)]  # No valid combination found
+
+
 # TODO: support optionality of parts of composite.
 # It is backtrack possible for more than one missing parts.
-def _valid_value_composite_term_with_separator(
+def _valid_value_composite_term_with_separator2(
     value: str, term: UTerm | PTerm, universe_session: Session, project_session: Session
 ) -> list[UniverseTermError | ProjectTermError]:
     result = list()
@@ -1113,16 +1191,16 @@ def find_items_in_project(
                 collection_column = col(PCollectionFTS5.id)  # TODO: use specs when implemented!
                 term_column = col(PTermFTS5.specs)  # type: ignore
             collection_where_condition = collection_column.match(processed_expression)
-            collection_statement = select(PCollectionFTS5.id,
-                                          text("'collection' AS TYPE"),
-                                          text(f"'{project_id}' AS TYPE"),
-                                          text('rank')).where(collection_where_condition)
+            collection_statement = select(
+                PCollectionFTS5.id, text("'collection' AS TYPE"), text(f"'{project_id}' AS TYPE"), text("rank")
+            ).where(collection_where_condition)
             term_where_condition = term_column.match(processed_expression)
-            term_statement = select(PTermFTS5.id,
-                                    text("'term' AS TYPE"),
-                                    PCollection.id,
-                                    text('rank')).join(PCollection) \
-                                                 .where(term_where_condition)
-            result = execute_find_item_statements(session, processed_expression, collection_statement,
-                                                  term_statement, limit, offset)
+            term_statement = (
+                select(PTermFTS5.id, text("'term' AS TYPE"), PCollection.id, text("rank"))
+                .join(PCollection)
+                .where(term_where_condition)
+            )
+            result = execute_find_item_statements(
+                session, processed_expression, collection_statement, term_statement, limit, offset
+            )
     return result

{esgvoc-1.0.0 → esgvoc-1.0.1}/src/esgvoc/apps/drs/generator.py

@@ -2,6 +2,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.search import MatchingTerm
 from esgvoc.apps.drs.report import (
     AssignedTerm,
     ConflictingCollections,
@@ -92,8 +93,7 @@ class DrsGenerator(DrsApplication):
         :rtype: DrsGeneratorReport
         """
         report = self._generate_from_mapping(mapping, self.file_name_specs)
-        report.generated_drs_expression = report.generated_drs_expression + \
-                                          self._get_full_file_name_extension() # noqa E127
+        report.generated_drs_expression = report.generated_drs_expression + self._get_full_file_name_extension()  # noqa E127
         return report
 
     def generate_file_name_from_bag_of_terms(self, terms: Iterable[str]) -> DrsGenerationReport:
@@ -108,12 +108,10 @@ class DrsGenerator(DrsApplication):
         :rtype: DrsGeneratorReport
         """
         report = self._generate_from_bag_of_terms(terms, self.file_name_specs)
-        report.generated_drs_expression = report.generated_drs_expression + \
-                                          self._get_full_file_name_extension() # noqa E127
+        report.generated_drs_expression = report.generated_drs_expression + self._get_full_file_name_extension()  # noqa E127
         return report
 
-    def generate_from_mapping(self, mapping: Mapping[str, str],
-                              drs_type: DrsType | str) -> DrsGenerationReport:
+    def generate_from_mapping(self, mapping: Mapping[str, str], drs_type: DrsType | str) -> DrsGenerationReport:
         """
         Generate a DRS expression from a mapping of collection ids and terms.
 
@@ -134,8 +132,7 @@ class DrsGenerator(DrsApplication):
             case _:
                 raise EsgvocDbError(f"unsupported drs type '{drs_type}'")
 
-    def generate_from_bag_of_terms(self, terms: Iterable[str], drs_type: DrsType | str) \
-                                                                             -> DrsGenerationReport: # noqa E127
+    def generate_from_bag_of_terms(self, terms: Iterable[str], drs_type: DrsType | str) -> DrsGenerationReport:  # noqa E127
         """
         Generate a DRS expression from an unordered bag of terms.
 
@@ -156,23 +153,24 @@ class DrsGenerator(DrsApplication):
             case _:
                 raise EsgvocDbError(f"unsupported drs type '{drs_type}'")
 
-    def _generate_from_mapping(self, mapping: Mapping[str, str], specs: DrsSpecification) \
-                                                                            -> DrsGenerationReport: # noqa E127
+    def _generate_from_mapping(self, mapping: Mapping[str, str], specs: DrsSpecification) -> DrsGenerationReport:  # noqa E127
         drs_expression, errors, warnings = self.__generate_from_mapping(mapping, specs, True)
         if self.pedantic:
             errors.extend(warnings)
             warnings.clear()
-        return DrsGenerationReport(project_id=self.project_id, type=specs.type,
-                                   given_mapping_or_bag_of_terms=mapping,
-                                   mapping_used=mapping,
-                                   generated_drs_expression=drs_expression,
-                                   errors=cast(list[GenerationError], errors),
-                                   warnings=cast(list[GenerationWarning], warnings))
-
-    def __generate_from_mapping(self, mapping: Mapping[str, str],
-                                specs: DrsSpecification,
-                                has_to_valid_terms: bool) \
-                                        -> tuple[str, list[GenerationIssue], list[GenerationIssue]]: # noqa E127
+        return DrsGenerationReport(
+            project_id=self.project_id,
+            type=specs.type,
+            given_mapping_or_bag_of_terms=mapping,
+            mapping_used=mapping,
+            generated_drs_expression=drs_expression,
+            errors=cast(list[GenerationError], errors),
+            warnings=cast(list[GenerationWarning], warnings),
+        )
+
+    def __generate_from_mapping(
+        self, mapping: Mapping[str, str], specs: DrsSpecification, has_to_valid_terms: bool
+    ) -> tuple[str, list[GenerationIssue], list[GenerationIssue]]:  # noqa E127
         errors: list[GenerationIssue] = list()
         warnings: list[GenerationIssue] = list()
         drs_expression = ""
@@ -185,18 +183,17 @@ class DrsGenerator(DrsApplication):
                 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)
+                        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)
+                            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)
+                    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
@@ -209,14 +206,18 @@ class DrsGenerator(DrsApplication):
 
             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
+    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 = projects.valid_term_in_project(term, self.project_id)
+            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)
             for matching_term in matching_terms:
                 if matching_term.collection_id not in collection_terms_mapping:
                     collection_terms_mapping[matching_term.collection_id] = set()
@@ -229,15 +230,20 @@ 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(collection_terms_mapping: dict[str, set[str]]) \
-                                               -> tuple[dict[str, set[str]], list[GenerationIssue]]: # noqa E127
+    def _resolve_conflicts(
+        collection_terms_mapping: dict[str, set[str]],
+    ) -> tuple[dict[str, set[str]], list[GenerationIssue]]:  # noqa E127
         warnings: list[GenerationIssue] = list()
         conflicting_collection_ids_list: list[list[str]] = list()
         collection_ids: list[str] = list(collection_terms_mapping.keys())
@@ -247,13 +253,16 @@ class DrsGenerator(DrsApplication):
             conflicting_collection_ids: list[str] = list()
             for r_collection_index in range(l_collection_index + 1, len_collection_ids):
                 if collection_terms_mapping[collection_ids[l_collection_index]].isdisjoint(
-                       collection_terms_mapping[collection_ids[r_collection_index]]):
+                    collection_terms_mapping[collection_ids[r_collection_index]]
+                ):
                     continue
                 else:
                     not_registered = True
                     for cc_ids in conflicting_collection_ids_list:
-                        if collection_ids[l_collection_index] in cc_ids and \
-                           collection_ids[r_collection_index] in cc_ids:
+                        if (
+                            collection_ids[l_collection_index] in cc_ids
+                            and collection_ids[r_collection_index] in cc_ids
+                        ):
                             not_registered = False
                             break
                     if not_registered:
@@ -287,10 +296,12 @@ class DrsGenerator(DrsApplication):
             #     raise errors, remove the faulty collections and their term.
             if collection_ids_with_len_eq_1_list:
                 for collection_ids_to_be_removed in collection_ids_with_len_eq_1_list:
-                    DrsGenerator._remove_ids_from_conflicts(conflicting_collection_ids_list,
-                                                            collection_ids_to_be_removed)
-                    DrsGenerator._remove_term_from_other_term_sets(collection_terms_mapping,
-                                                                   collection_ids_to_be_removed)
+                    DrsGenerator._remove_ids_from_conflicts(
+                        conflicting_collection_ids_list, collection_ids_to_be_removed
+                    )
+                    DrsGenerator._remove_term_from_other_term_sets(
+                        collection_terms_mapping, collection_ids_to_be_removed
+                    )
                 # Every time conflicting_collection_ids_list is modified, we must restart the loop,
                 # as conflicting collections may be resolved.
                 continue
@@ -307,10 +318,8 @@ class DrsGenerator(DrsApplication):
                         warnings.append(issue)
             # 3.b Update conflicting collections.
             if wining_collection_ids:
-                DrsGenerator._remove_ids_from_conflicts(conflicting_collection_ids_list,
-                                                        wining_collection_ids)
-                DrsGenerator._remove_term_from_other_term_sets(collection_terms_mapping,
-                                                               wining_collection_ids)
+                DrsGenerator._remove_ids_from_conflicts(conflicting_collection_ids_list, wining_collection_ids)
+                DrsGenerator._remove_term_from_other_term_sets(collection_terms_mapping, wining_collection_ids)
                 # Every time conflicting_collection_ids_list is modified, we must restart the loop,
                 # as conflicting collections may be resolved.
                 continue
@@ -320,13 +329,15 @@ 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]
-                    diff: set[str] = collection_terms_mapping[collection_ids[collection_index]]\
-                                         .difference(*[collection_terms_mapping[index] # noqa E127
-                                                     for index in collection_set])
+                    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
+                            for index in collection_set
+                        ]
+                    )
                     if len(diff) == 1:
-                        wining_id_and_term_pairs.append((collection_ids[collection_index],
-                                                         _get_first_item(diff)))
+                        wining_id_and_term_pairs.append((collection_ids[collection_index], _get_first_item(diff)))
             # 4.b Update conflicting collections.
             if wining_id_and_term_pairs:
                 wining_collection_ids = list()
@@ -336,18 +347,17 @@ class DrsGenerator(DrsApplication):
                     collection_terms_mapping[collection_id].add(term)
                     issue = AssignedTerm(collection_id=collection_id, term=term)
                     warnings.append(issue)
-                DrsGenerator._remove_ids_from_conflicts(conflicting_collection_ids_list,
-                                                        wining_collection_ids)
-                DrsGenerator._remove_term_from_other_term_sets(collection_terms_mapping,
-                                                               wining_collection_ids)
+                DrsGenerator._remove_ids_from_conflicts(conflicting_collection_ids_list, wining_collection_ids)
+                DrsGenerator._remove_term_from_other_term_sets(collection_terms_mapping, wining_collection_ids)
                 continue
             else:
                 break  # Stop the loop when no progress is made.
         return collection_terms_mapping, warnings
 
     @staticmethod
-    def _check_collection_terms_mapping(collection_terms_mapping: dict[str, set[str]]) \
-                                                    -> tuple[dict[str, str], list[GenerationIssue]]: # noqa E127
+    def _check_collection_terms_mapping(
+        collection_terms_mapping: dict[str, set[str]],
+    ) -> tuple[dict[str, str], list[GenerationIssue]]:  # noqa E127
         errors: list[GenerationIssue] = list()
         # 1. Looking for collections that share strictly the same term(s).
         collection_ids: list[str] = list(collection_terms_mapping.keys())
@@ -363,8 +373,7 @@ class DrsGenerator(DrsApplication):
                 if l_term_set and (not l_term_set.difference(r_term_set)):
                     not_registered = True
                     for faulty_collections in faulty_collections_list:
-                        if l_collection_id in faulty_collections or \
-                           r_collection_id in faulty_collections:
+                        if l_collection_id in faulty_collections or r_collection_id in faulty_collections:
                             faulty_collections.add(l_collection_id)
                             faulty_collections.add(r_collection_id)
                             not_registered = False
@@ -373,8 +382,9 @@ class DrsGenerator(DrsApplication):
                         faulty_collections_list.append({l_collection_id, r_collection_id})
         for faulty_collections in faulty_collections_list:
             terms = collection_terms_mapping[_get_first_item(faulty_collections)]
-            issue = ConflictingCollections(collection_ids=_transform_set_and_sort(faulty_collections),
-                                           terms=_transform_set_and_sort(terms))
+            issue = ConflictingCollections(
+                collection_ids=_transform_set_and_sort(faulty_collections), terms=_transform_set_and_sort(terms)
+            )
             errors.append(issue)
             for collection_id in faulty_collections:
                 del collection_terms_mapping[collection_id]
@@ -386,25 +396,28 @@ class DrsGenerator(DrsApplication):
             if len_term_set == 1:
                 result[collection_id] = _get_first_item(term_set)
             elif len_term_set > 1:
-                other_issue = TooManyTermCollection(collection_id=collection_id,
-                                                    terms=_transform_set_and_sort(term_set))
+                other_issue = TooManyTermCollection(
+                    collection_id=collection_id, terms=_transform_set_and_sort(term_set)
+                )
                 errors.append(other_issue)
             # else: Don't add emptied collection to the result.
         return result, errors
 
     @staticmethod
-    def _remove_term_from_other_term_sets(collection_terms_mapping: dict[str, set[str]],
-                                          collection_ids_to_be_removed: list[str]) -> None:
+    def _remove_term_from_other_term_sets(
+        collection_terms_mapping: dict[str, set[str]], collection_ids_to_be_removed: list[str]
+    ) -> None:
         for collection_id_to_be_removed in collection_ids_to_be_removed:
             # Should only be one term.
             term_to_be_removed: str = _get_first_item(collection_terms_mapping[collection_id_to_be_removed])
             for collection_id in collection_terms_mapping.keys():
-                if (collection_id not in collection_ids_to_be_removed):
+                if collection_id not in collection_ids_to_be_removed:
                     collection_terms_mapping[collection_id].discard(term_to_be_removed)
 
     @staticmethod
-    def _remove_ids_from_conflicts(conflicting_collection_ids_list: list[list[str]],
-                                   collection_ids_to_be_removed: list[str]) -> None:
+    def _remove_ids_from_conflicts(
+        conflicting_collection_ids_list: list[list[str]], collection_ids_to_be_removed: list[str]
+    ) -> None:
         for collection_id_to_be_removed in collection_ids_to_be_removed:
             for conflicting_collection_ids in conflicting_collection_ids_list:
                 if collection_id_to_be_removed in conflicting_collection_ids:

{esgvoc-1.0.0 → esgvoc-1.0.1}/src/esgvoc/apps/jsg/json_schema_generator.py

@@ -1,5 +1,6 @@
 import contextlib
 import json
+from json import JSONEncoder
 from pathlib import Path
 from typing import Iterable
 
@@ -21,12 +22,12 @@ JSON_SCHEMA_TEMPLATE_FILE_NAME_TEMPLATE = '{project_id}_template.json'
 JSON_INDENTATION = 2
 
 
-def _process_plain(collection: PCollection, selected_field: str) -> list[str]:
-    result: list[str] = list()
+def _process_plain(collection: PCollection, selected_field: str) -> set[str]:
+    result: set[str] = set()
     for term in collection.terms:
         if selected_field in term.specs:
             value = term.specs[selected_field]
-            result.append(value)
+            result.add(value)
         else:
             raise EsgvocNotFoundError(f'missing key {selected_field} for term {term.id} in ' +
                                       f'collection {collection.id}')
@@ -86,8 +87,8 @@ class JsonPropertiesVisitor(GlobalAttributeVisitor, contextlib.AbstractContextMa
         return True
 
     def _generate_attribute_property(self, attribute_name: str, source_collection: str,
-                                     selected_field: str) -> tuple[str, str | list[str]]:
-        property_value: str | list[str]
+                                     selected_field: str) -> tuple[str, str | set[str]]:
+        property_value: str | set[str]
         property_key: str
         if source_collection not in self.collections:
             raise EsgvocNotFoundError(f"collection '{source_collection}' referenced by attribute " +
@@ -113,9 +114,9 @@ class JsonPropertiesVisitor(GlobalAttributeVisitor, contextlib.AbstractContextMa
         return property_key, property_value
 
     def visit_base_attribute(self, attribute_name: str, attribute: GlobalAttributeSpecBase) \
-            -> tuple[str, dict[str, str | list[str]]]:
+            -> tuple[str, dict[str, str | set[str]]]:
         attribute_key = _generate_attribute_key(self.project_id, attribute_name)
-        attribute_properties: dict[str, str | list[str]] = dict()
+        attribute_properties: dict[str, str | set[str]] = dict()
         attribute_properties['type'] = attribute.value_type.value
         property_key, property_value = self._generate_attribute_property(attribute_name,
                                                                          attribute.source_collection,
@@ -124,9 +125,9 @@ class JsonPropertiesVisitor(GlobalAttributeVisitor, contextlib.AbstractContextMa
         return attribute_key, attribute_properties
 
     def visit_specific_attribute(self, attribute_name: str, attribute: GlobalAttributeSpecSpecific) \
-            -> tuple[str, dict[str, str | list[str]]]:
+            -> tuple[str, dict[str, str | set[str]]]:
         attribute_key = _generate_attribute_key(self.project_id, attribute_name)
-        attribute_properties: dict[str, str | list[str]] = dict()
+        attribute_properties: dict[str, str | set[str]] = dict()
         attribute_properties['type'] = attribute.value_type.value
         property_key, property_value = self._generate_attribute_property(attribute_name,
                                                                          attribute.source_collection,
@@ -148,6 +149,14 @@ def _inject_properties(json_root: dict, properties: list[tuple]) -> None:
         json_root['definitions']['fields']['properties'][property[0]] = property[1]
 
 
+class SetEncoder(JSONEncoder):
+    def default(self, o):
+        if isinstance(o, set):
+            return list(o)
+        else:
+            return super().default(self, o)
+
+
 def generate_json_schema(project_id: str) -> str:
     """
     Generate json schema for the given project.
@@ -169,17 +178,17 @@ def generate_json_schema(project_id: str) -> str:
                      JsonPropertiesVisitor(project_id) as visitor:
                     file_content = file.read()
                     root = json.loads(file_content)
-                    properties: list[tuple[str, dict[str, str | list[str]]]] = list()
+                    properties: list[tuple[str, dict[str, str | set[str]]]] = list()
                     for attribute_name, attribute in project_specs.global_attributes_specs.items():
                         attribute_key, attribute_properties = attribute.accept(attribute_name, visitor)
                         properties.append((attribute_key, attribute_properties))
                 _inject_properties(root, properties)
                 _inject_global_attributes(root, project_id, project_specs.global_attributes_specs.keys())
-                return json.dumps(root, indent=JSON_INDENTATION)
+                return json.dumps(root, indent=JSON_INDENTATION, cls=SetEncoder)
             else:
                 raise EsgvocNotFoundError(f"global attributes for the project '{project_id}' " +
                                           "are not provided")
         else:
-            raise EsgvocNotFoundError(f"project '{project_id}' is not found")
+            raise EsgvocNotFoundError(f"specs of project '{project_id}' is not found")
     else:
         raise EsgvocNotFoundError(f"template for project '{project_id}' is not found")