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

esgvoc/__init__.py

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

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/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/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/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/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")

{esgvoc-1.0.0.dist-info → esgvoc-1.0.1.dist-info}/METADATA

@@ -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.dist-info → esgvoc-1.0.1.dist-info}/RECORD

@@ -1,12 +1,12 @@
-esgvoc/__init__.py,sha256=SqCq76RHIi9JrIf0WMxBBDxi9xz8C0CekkD81FYCr3U,66
+esgvoc/__init__.py,sha256=u3ucA4xC8eQ_WbPjLI1E9a3kvkwtU5n8TUNRaCFQMfs,66
 esgvoc/api/__init__.py,sha256=w68CdVRS553bDWezZoCTxIFq_vsP7mFluSoO4yUo_Uc,4130
 esgvoc/api/project_specs.py,sha256=ZvDAVn3-ZFpReCozK-_cVt6Sqkwrwww0X4vKUoxr1I4,5502
-esgvoc/api/projects.py,sha256=WCHI0bV0U4KSV4AfilI1_bLDnb3zJRgn6WzYQpkywCg,53826
+esgvoc/api/projects.py,sha256=LUasPF5cPSG1aD6vOkFwGNCMNSf5e--LdDtDkrMjcTU,56720
 esgvoc/api/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 esgvoc/api/report.py,sha256=OlK5ApnaikMKmC6FyJ1uTSBeTezZe85yTCJwsk14uZE,3526
 esgvoc/api/search.py,sha256=C4IRhfNezSV6ztwMXo-P8W_41qIPiO5nQXdU9etPy3k,7595
 esgvoc/api/universe.py,sha256=i3bSIwUvO8S3COLvn_fz2K9Diegfeniccwx6QZXzIGc,22842
-esgvoc/api/data_descriptors/__init__.py,sha256=_4aUux2mvtlGn7icu8Ncm7tkLdJlpsB_MTRtg3IcDaQ,4334
+esgvoc/api/data_descriptors/__init__.py,sha256=JFdB-Qfzxbws2zlWRqq77TTQFIlb6MosXe7fv9zimDg,4420
 esgvoc/api/data_descriptors/activity.py,sha256=uu7e-fNvk_0oOOrtVWujDIBbF88fvhqwUfqYS_2Fabs,621
 esgvoc/api/data_descriptors/area_label.py,sha256=Vyny3nmESGLOTVhGCE1iJbdITpN_wvB_onKy44dsVRY,842
 esgvoc/api/data_descriptors/branded_suffix.py,sha256=jliXbvygKjcxqipalRZT694nXGVUp0k4uAORzMX9B0I,822
@@ -29,6 +29,7 @@ esgvoc/api/data_descriptors/initialisation_index.py,sha256=VjgIHq1j7xoR5VvMW_eFR
 esgvoc/api/data_descriptors/institution.py,sha256=dUqyMS_HsLz72dvE4-9ZTIoF3QBXDKASC3OKoFX4S8w,547
 esgvoc/api/data_descriptors/known_branded_variable.py,sha256=IXeMgxkCPWssSuNU56O7GU6oOjJ-hju03ZKpDg0gz7Q,834
 esgvoc/api/data_descriptors/license.py,sha256=BQK8GcbGYuXHSei_CxXlbUct3SM0G15waJDEc6jyr7o,180
+esgvoc/api/data_descriptors/member_id.py,sha256=L9Kcbz6mtRZDqSJiIqQwTBoU8A4z8JgI3UTfn2ZiMo8,703
 esgvoc/api/data_descriptors/mip_era.py,sha256=ubxwqJL8xPgCZu7bmjg-vvphBlG_aqogwE-ewu3lB2Q,176
 esgvoc/api/data_descriptors/model_component.py,sha256=erKMHqSbZcVDsCPcSebIIMRTtgZToTdKEGQ8vB_zzYs,226
 esgvoc/api/data_descriptors/obs_type.py,sha256=uVbxIMFoYs9ySJ-unhOoW0h0ljdWsBNwYfwmlXOSRe8,143
@@ -55,12 +56,11 @@ esgvoc/apps/__init__.py,sha256=Kyq36qRjvTWN7gu4_iFaLOjNUYvW0k1xp8bvkgJlQ5w,269
 esgvoc/apps/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 esgvoc/apps/drs/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 esgvoc/apps/drs/constants.py,sha256=rVWq1QQwAFgISjvl3YzJDLLPNUPXHpqgv66spmjyPMQ,96
-esgvoc/apps/drs/generator.py,sha256=M0QMtpAaMU4E0142FPqdhix3n034CU_QaPuwvXsWtlA,22392
+esgvoc/apps/drs/generator.py,sha256=rFGuqbfAvYeWC9qQWqgI57Z48XZ3mhIC14XngVMTqJs,21667
 esgvoc/apps/drs/report.py,sha256=ZRu5l6T-U-hqY7O3ZwAseYbWZPcJiMhJ2dpFKZJE3Gk,17371
 esgvoc/apps/drs/validator.py,sha256=yNijdOPhF9adgZbya5Ugvs13GbL4MvgQepCT38A66vM,13825
 esgvoc/apps/jsg/cmip6_template.json,sha256=KJHhr0FSrIVB5kXVt57k_KtvB3uhs9Xz5hoX8ajAZis,1916
-esgvoc/apps/jsg/cmip6plus_template.json,sha256=4QNrZFT1I8RtxCHJvsNwXUiMQctWylZuzL3gvDgg3Ps,1936
-esgvoc/apps/jsg/json_schema_generator.py,sha256=ByLalwtoqZKtWUgOmPKcgA7hoCLwUss994ViBSqrfXE,9058
+esgvoc/apps/jsg/json_schema_generator.py,sha256=2Y8d3fnso_6b7aAO18_Zws4UoyJ2IRhT5kfDl_0ewGM,9274
 esgvoc/cli/config.py,sha256=MNrpYzEM9gwqCzPUs-ZzFv6Tg-p0ySMGeBUzB0nXXo0,18714
 esgvoc/cli/drs.py,sha256=PvVbLxef34A1IO600AFWOEWb5iLaWrBRHwwgMJ4u-PM,9237
 esgvoc/cli/find.py,sha256=DxpEvSbQIJ3-XL-pgH5RicBzS3asjG2Cn_fJhjXKSoU,4497
@@ -88,8 +88,8 @@ esgvoc/core/service/esg_voc.py,sha256=5G0P4_xmQzoI_RG_agpq-yHoYYZx220P27v2nPrpyN
 esgvoc/core/service/state.py,sha256=CGlVbmvW5WB6DKivzqz9i8PsMDKHGuNdIWyohQVdBhQ,11113
 esgvoc/core/service/configuration/config_manager.py,sha256=K-gU3Kd-eJMunxDKOk4x72CRcyJ50IZXLfqQgyI9zTs,8282
 esgvoc/core/service/configuration/setting.py,sha256=WJgo9ZjZJrTGR9WEBhp1d7ab0Yb2Y6XmnO1oImTPc2s,3042
-esgvoc-1.0.0.dist-info/METADATA,sha256=7Ik83PpoCIsgnlEGyuvj4wSWZsGD8vSjNQpAh6vSu8A,2066
-esgvoc-1.0.0.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
-esgvoc-1.0.0.dist-info/entry_points.txt,sha256=ZXufSC7Jlx1lb52U6Buv9IitJMcqAAXOerR2V9DaIto,48
-esgvoc-1.0.0.dist-info/licenses/LICENSE.txt,sha256=rWJoZt3vach8ZNdLq-Ee5djzCMFnJ1gIfBeJU5RIop4,21782
-esgvoc-1.0.0.dist-info/RECORD,,
+esgvoc-1.0.1.dist-info/METADATA,sha256=FKkE2Cw5w3QVFnkr4Wi6grYHeCS-lUvWXxm9D0GQFsg,2037
+esgvoc-1.0.1.dist-info/WHEEL,sha256=C2FUgwZgiLbznR-k0b_5k3Ai_1aASOXDss3lzCUsUug,87
+esgvoc-1.0.1.dist-info/entry_points.txt,sha256=ZXufSC7Jlx1lb52U6Buv9IitJMcqAAXOerR2V9DaIto,48
+esgvoc-1.0.1.dist-info/licenses/LICENSE.txt,sha256=rWJoZt3vach8ZNdLq-Ee5djzCMFnJ1gIfBeJU5RIop4,21782
+esgvoc-1.0.1.dist-info/RECORD,,

esgvoc/apps/jsg/cmip6plus_template.json

@@ -1,74 +0,0 @@
-{
-  "$schema": "http://json-schema.org/draft-07/schema#",
-  "$id": "https://stac-extensions.github.io/cmip6plus/v1.0.0/schema.json#",
-  "title": "CMIP6Plus Extension",
-  "description": "STAC CMIP6Plus Extension for STAC Items and STAC Collection Summaries.",
-  "type": "object",
-  "required": [
-    "stac_extensions"
-  ],
-  "properties": {
-    "stac_extensions": {
-      "type": "array",
-      "contains": {
-        "const": "https://stac-extensions.github.io/cmip6plus/v1.0.0/schema.json"
-      }
-    }
-  },
-  "oneOf": [
-    {
-      "$comment": "This is the schema for STAC Items.",
-      "type": "object",
-      "required": [
-        "type",
-        "properties"
-      ],
-      "properties": {
-        "type": {
-          "const": "Feature"
-        },
-        "properties": {
-          "allOf": [
-            {
-              "$ref": "#/definitions/require_any"
-            },
-            {
-              "$ref": "#/definitions/fields"
-            }
-          ]
-        }
-      }
-    },
-    {
-      "$comment": "This is the schema for STAC Collections, or more specifically only Collection Summaries in this case. By default, only checks the existence of the properties, but not the schema of the summaries.",
-      "type": "object",
-      "required": [
-        "type",
-        "summaries"
-      ],
-      "properties": {
-        "type": {
-          "const": "Collection"
-        },
-        "summaries": {
-          "$ref": "#/definitions/require_any"
-        }
-      }
-    }
-  ],
-  "definitions": {
-    "require_any": {
-      "$comment": "Please list all fields here so that we can force the existence of one of them in other parts of the schemas."
-    },
-    "fields": {
-      "$comment": " Don't require fields here, do that above in the corresponding schema.",
-      "type": "object",
-      "properties": {
-      },
-      "patternProperties": {
-        "^(?!cmip6plus:)": {}
-      },
-      "additionalProperties": false
-    }
-  }
-}