GeneralManager 0.84.0__tar.gz → 0.86.0__tar.gz

{generalmanager-0.84.0/src/GeneralManager.egg-info → generalmanager-0.86.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.84.0
+Version: 0.86.0
 Summary: Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching.
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License: MIT License

{generalmanager-0.84.0 → generalmanager-0.86.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GeneralManager"
-version = "0.84.0"
+version = "0.86.0"
 description = "Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching."
 readme = "README.md"
 authors = [{ name = "Tim Kleindick", email = "tkleindick@yahoo.de" }]

{generalmanager-0.84.0 → generalmanager-0.86.0/src/GeneralManager.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.84.0
+Version: 0.86.0
 Summary: Modular Django-based data management framework with ORM, GraphQL, fine-grained permissions, rule validation, calculations and caching.
 Author-email: Tim Kleindick <tkleindick@yahoo.de>
 License: MIT License

{generalmanager-0.84.0 → generalmanager-0.86.0}/src/general_manager/api/graphql.py

@@ -835,14 +835,25 @@ class GraphQL:
         graphene_type_name = f"{generalManagerClass.__name__}Type"
         fields: GraphQLFieldMap = {}
 
+        # Only declared typed-list inputs opt into native list output semantics.
+        input_fields = getattr(interface_cls, "input_fields", {})
         # Map Attribute Types to Graphene Fields
-        for field_name, field_info in interface_cls.get_attribute_types().items():
+        for field_name, attribute_info in interface_cls.get_attribute_types().items():
+            field_info: Mapping[str, object] = attribute_info
+            input_field = input_fields.get(field_name)
+            is_collection_input = getattr(input_field, "is_collection", False) is True
+            if is_collection_input:
+                field_info = {**field_info, "is_collection_input": True}
             field_type = field_info["type"]
             resolved_manager_type = resolve_general_manager_type(
                 field_type,
                 cls.manager_registry,
             )
-            resolved_field_type = resolved_manager_type or field_type
+            resolved_field_type = (
+                field_type
+                if is_collection_input
+                else resolved_manager_type or field_type
+            )
             fields[field_name] = cls._map_field_to_graphene_read(
                 resolved_field_type,
                 field_name,
@@ -873,10 +884,22 @@ class GraphQL:
                     )
 
                 fields[resolver_name] = resolve_stored_file
+            elif is_collection_input:
+                fields[resolver_name] = (
+                    cls._create_measurement_resolver(field_name)
+                    if safe_issubclass(get_args(field_type)[0], Measurement)
+                    else _create_normal_resolver_fn(
+                        field_name,
+                        authorize_manager_collection=resolve_general_manager_type(
+                            get_args(field_type)[0], cls.manager_registry
+                        )
+                        is not None,
+                    )
+                )
             else:
                 fields[resolver_name] = cls._create_resolver(
                     field_name,
-                    resolved_field_type,
+                    cast(type, resolved_field_type),
                 )
             if (
                 field_name.endswith("_list")
@@ -1396,6 +1419,24 @@ class GraphQL:
         Returns:
             object: Graphene field or type configured for the attribute.
         """
+        if field_info and field_info.get("is_collection_input") is True:
+            element = get_args(field_type)[0]
+            manager_element = resolve_general_manager_type(
+                element, GraphQL.manager_registry
+            )
+            if manager_element is not None:
+                return graphene.List(
+                    graphene.NonNull(
+                        lambda: GraphQL.graphql_type_registry[manager_element.__name__]
+                    )
+                )
+            scalar = (
+                MeasurementType
+                if safe_issubclass(element, Measurement)
+                else GraphQL._map_field_to_graphene_base_type(element)
+            )
+            return graphene.List(graphene.NonNull(scalar))
+
         manager_type = resolve_general_manager_type(
             field_type,
             GraphQL.manager_registry,
@@ -1421,8 +1462,10 @@ class GraphQL:
                     attributes["order_by"] = graphene.Argument(
                         graphene.List(graphene.NonNull(ordering_types.input_type))
                     )
+                # Share the root page for this item type, rather than aliasing
+                # a reference manager XType with the root page of manager X.
                 page_type = GraphQL._get_or_create_page_type(
-                    field_type.__name__ + "Page",
+                    field_type.__name__ + "TypePage",
                     lambda: GraphQL.graphql_type_registry[field_type.__name__],
                 )
                 return graphene.Field(page_type, **attributes)

{generalmanager-0.84.0 → generalmanager-0.86.0}/src/general_manager/api/graphql_identifiers.py

@@ -92,8 +92,13 @@ def build_identification_arguments(
         # name is independent of the actual primary-key column name.
         is_orm_id = is_orm_identifier_input(manager_class, name)
         required = input_field.required or (for_mutation and is_orm_id)
+        is_collection = getattr(input_field, "is_collection", False) is True
+        element_type = (
+            input_field.collection_element_type if is_collection else input_field.type
+        )
+        assert element_type is not None
         manager_type = resolve_general_manager_type(
-            input_field.type, get_graphql_manager_registry()
+            element_type, get_graphql_manager_registry()
         )
         if manager_type is not None:
             # Reuse custom mutation support for structured/composite manager
@@ -101,16 +106,30 @@ def build_identification_arguments(
             from general_manager.api.mutation import (
                 _build_manager_argument_field,
                 _uses_single_id_input,
+                _get_or_create_manager_input_type,
             )
 
+            if is_collection:
+                reference = (
+                    graphene.ID
+                    if _uses_single_id_input(manager_type)
+                    else _get_or_create_manager_input_type(manager_type)
+                )
+                arguments[f"{name}_id"] = graphene.Argument(
+                    graphene.List(graphene.NonNull(reference)), required=required
+                )
+                continue
             arguments[f"{name}_id"] = (
                 graphene.Argument(graphene.ID, required=required)
                 if _uses_single_id_input(manager_type)
                 else _build_manager_argument_field(manager_type, required=required)
             )
         else:
-            scalar = map_identification_scalar(manager_class, name, input_field.type)
-            arguments[name] = graphene.Argument(scalar, required=required)
+            scalar = map_identification_scalar(manager_class, name, element_type)
+            arguments[name] = graphene.Argument(
+                graphene.List(graphene.NonNull(scalar)) if is_collection else scalar,
+                required=required,
+            )
     return arguments
 
 

{generalmanager-0.84.0 → generalmanager-0.86.0}/src/general_manager/api/graphql_resolvers.py

@@ -1339,12 +1339,15 @@ def create_measurement_resolver(field_name: str) -> Resolver:
     return resolver
 
 
-def create_normal_resolver(field_name: str) -> Resolver:
+def create_normal_resolver(
+    field_name: str, *, authorize_manager_collection: bool = False
+) -> Resolver:
     """
     Return a resolver for a scalar (non-list, non-Measurement) field.
 
     The generated resolver returns ``None`` when field read permission is denied;
-    otherwise it returns ``getattr(self, field_name)``.
+    otherwise it returns ``getattr(self, field_name)``. Typed manager collections
+    additionally omit members denied by the manager-level read gate.
     """
 
     def resolver(self: GeneralManager, info: GraphQLResolveInfo) -> object:
@@ -1356,11 +1359,18 @@ def create_normal_resolver(field_name: str) -> Resolver:
                 if relation_id is not _NO_GROUPED_RELATION_ID_ALIAS:
                     return relation_id
                 _validate_grouped_field_projection(self, field_name)
-            return project_grouped_field_value(
+            value = project_grouped_field_value(
                 self,
                 field_name,
                 read_grouped_field_value(self, field_name),
             )
+            if authorize_manager_collection and value is not None:
+                return [
+                    member
+                    for member in cast(list[GeneralManager], value)
+                    if can_read_instance_for_user(member, info.context.user)
+                ]
+            return value
 
         return resolve_with_read_permission(
             self,

{generalmanager-0.84.0 → generalmanager-0.86.0}/src/general_manager/api/graphql_search.py

@@ -805,6 +805,10 @@ def create_filter_options(
 
     filter_fields: dict[str, GrapheneFieldType] = {}
     for attr_name, attr_info in field_type.Interface.get_attribute_types().items():
+        # Native constructor selections do not add a new GraphQL filter language.
+        input_field = getattr(field_type.Interface, "input_fields", {}).get(attr_name)
+        if getattr(input_field, "is_collection", False) is True:
+            continue
         effective_attr_info = _get_filter_relation_info(
             field_type,
             attr_name,

{generalmanager-0.84.0 → generalmanager-0.86.0}/src/general_manager/api/graphql_subscriptions.py

@@ -348,7 +348,14 @@ def resolve_subscription_dependencies(
     interface_cls = manager_class.Interface
 
     for input_name, input_field in interface_cls.input_fields.items():
-        if not issubclass(input_field.type, GeneralManager):
+        manager_type = (
+            input_field.collection_element_type
+            if getattr(input_field, "is_collection", False) is True
+            else input_field.type
+        )
+        if not isinstance(manager_type, type) or not issubclass(
+            manager_type, GeneralManager
+        ):
             continue
 
         raw_value = instance._interface.identification.get(input_name)
@@ -359,7 +366,6 @@ def resolve_subscription_dependencies(
         for value in values:
             if isinstance(value, GeneralManager):
                 identification = deepcopy(value.identification)
-                manager_type = input_field.type
                 if (
                     manager_type is manager_class
                     and identification == instance.identification
@@ -375,7 +381,6 @@ def resolve_subscription_dependencies(
                 dep_list.append((manager_type, identification))
             elif isinstance(value, dict):
                 identification_dict = deepcopy(cast(Identification, value))
-                manager_type = input_field.type
                 if (
                     manager_type is manager_class
                     and identification_dict == instance.identification

{generalmanager-0.84.0 → generalmanager-0.86.0}/src/general_manager/api/mutation.py

@@ -180,6 +180,11 @@ def _get_or_create_manager_input_type(
     for input_name, input_field in _manager_input_fields(manager_class).items():
         field_type = input_field.type
         required = input_field.required
+        if get_origin(field_type) is list:
+            fields[input_name] = graphene.InputField(
+                _mutation_input_type(field_type), required=required
+            )
+            continue
         if _is_general_manager_type(field_type):
             if _uses_single_id_input(field_type):
                 fields[input_name] = graphene.ID(required=required)

{generalmanager-0.84.0 → generalmanager-0.86.0}/src/general_manager/bootstrap.py

@@ -368,7 +368,11 @@ def initialize_general_manager_classes(
         seen: set[str] = set()
         input_fields = getattr(general_manager_class.Interface, "input_fields", {})
         for attribute_name, attribute in input_fields.items():
-            if isinstance(attribute, Input) and issubclass(attribute.type, _GM):
+            if (
+                isinstance(attribute, Input)
+                and isinstance(attribute.type, type)
+                and issubclass(attribute.type, _GM)
+            ):
                 seen.add(attribute_name)
                 yield attribute_name, attribute.type
 

{generalmanager-0.84.0 → generalmanager-0.86.0}/src/general_manager/bucket/calculation_bucket.py

@@ -36,10 +36,15 @@ from general_manager.bucket._ordering import (
     validate_ordering_fields,
 )
 from general_manager.bucket.projection import ProjectionRows
-from general_manager.manager.input import Input, InputDomain
+from general_manager.manager.input import (
+    Input,
+    InputDomain,
+    _prepare_normalized_identification,
+)
 from general_manager.utils.filter_parser import (
     FilterFunction,
     ParsedFilters,
+    ParsedFilterCriteria,
     create_filter_function,
     parse_filters,
 )
@@ -240,6 +245,7 @@ class CalculationBucket(Bucket[GeneralManagerType]):
             parse_filters(group, possible_values) for group in self._exclude_call_groups
         )
 
+        self._normalized_collections: dict[Hashable, object] = {}
         self._data: list[Combination] | None = None
         self._allowed_identifications: list[Combination] | None = None
         self._sort_fields: tuple[str, ...] = ()
@@ -687,7 +693,7 @@ class CalculationBucket(Bucket[GeneralManagerType]):
         self._ensure_as_of_compatible()
         combinations = self.generate_combinations()
         for combo in combinations:
-            yield self._manager_class(**combo)
+            yield self._construct_manager(combo)
 
     def _project_rows(self, fields: tuple[str, ...]) -> ProjectionRows:
         """Project normalized calculation inputs without manager instances."""
@@ -712,7 +718,7 @@ class CalculationBucket(Bucket[GeneralManagerType]):
                 tuple(
                     resolve_calculation_input_value(
                         interface_class,
-                        identification,
+                        self._normalized_constructor_values(identification),
                         field,
                         resolved_values,
                     )
@@ -803,8 +809,8 @@ class CalculationBucket(Bucket[GeneralManagerType]):
             or any(len(group) > 1 for group in self._exclude_call_groups)
         )
 
-    @staticmethod
     def _matches_call_group(
+        self,
         manager: GeneralManagerType,
         group: ParsedFilters,
     ) -> bool:
@@ -814,9 +820,19 @@ class CalculationBucket(Bucket[GeneralManagerType]):
                 value = getattr(manager, field_name)
             except AttributeError:
                 return False
-            for filter_func in definitions.get("filter_funcs", []):
-                if not filter_func(value):
+            if "collection_criteria" in definitions:
+                dependencies = {
+                    name: getattr(manager, name)
+                    for name in self.input_fields[field_name].depends_on
+                }
+                if not self._collection_matches(
+                    field_name, value, definitions, dependencies
+                ):
                     return False
+            else:
+                for filter_func in definitions.get("filter_funcs", []):
+                    if not filter_func(value):
+                        return False
             for lookup, expected in definitions.get("filter_kwargs", {}).items():
                 identification = getattr(value, "identification", None)
                 lookup_parts = lookup.split("__") if lookup else []
@@ -904,13 +920,56 @@ class CalculationBucket(Bucket[GeneralManagerType]):
             identity_for=lambda combo: combo,
         )
 
+    def _normalize_collection(
+        self, name: str, value: object, context: Combination
+    ) -> object:
+        """Normalize a selection once for each dependency context in this plan."""
+        field = self.input_fields[name]
+        dependencies = {
+            dependency: context[dependency] for dependency in field.depends_on
+        }
+        key = (
+            name,
+            freeze_bucket_index_value(value),
+            freeze_bucket_index_value(dependencies),
+        )
+        if key not in self._normalized_collections:
+            self._normalized_collections[key] = field.cast(
+                value, dependencies, cache_context=(self._manager_class, name)
+            )
+        result = self._normalized_collections[key]
+        return list(result) if isinstance(result, list) else result
+
+    def _collection_matches(
+        self,
+        name: str,
+        value: object,
+        criteria: ParsedFilterCriteria,
+        context: Combination,
+    ) -> bool:
+        """Compare complete normalized selections with normalized alternatives."""
+        return all(
+            any(
+                value == self._normalize_collection(name, candidate, context)
+                for candidate in alternatives
+            )
+            for alternatives in criteria.get("collection_criteria", [])
+        )
+
+    def _normalized_constructor_values(self, combination: Combination) -> Combination:
+        """Mark normalized lists when reconstructing bucket managers or projections."""
+        return _prepare_normalized_identification(self._manager_class, combination)
+
+    def _construct_manager(self, combination: Combination) -> GeneralManagerType:
+        return self._manager_class(**self._normalized_constructor_values(combination))
+
     def _manager_combinations(
         self,
         combinations: list[Combination],
     ) -> list[GeneralManagerType]:
         """Instantiate managers for each raw input-combination dictionary."""
         self._ensure_as_of_compatible()
-        return [self._manager_class(**combo) for combo in combinations]
+        return [self._construct_manager(combo) for combo in combinations]
 
     @staticmethod
     def _manager_identifications(
@@ -1165,16 +1224,56 @@ class CalculationBucket(Bucket[GeneralManagerType]):
             input_name: str = sorted_inputs[index]
             input_field = self.input_fields[input_name]
 
-            possible_values = self.get_possible_values(
-                input_name, input_field, current_combo
-            )
+            field_filters = filters.get(input_name, {})
+            field_excludes = excludes.get(input_name, {})
+            possible_values: Iterable[object] | Bucket[GeneralManager] | None
+            if input_field.is_collection and input_field.possible_values is None:
+                if "candidate_values" in field_filters:
+                    possible_values = field_filters["candidate_values"]
+                elif input_field.required:
+                    raise InvalidPossibleValuesError(input_name)
+                else:
+                    possible_values = [None]
+            else:
+                possible_values = self.get_possible_values(
+                    input_name, input_field, current_combo
+                )
             if possible_values is None:
                 if input_passes_filters(input_name, current_combo):
                     yield from helper(index + 1, current_combo)
                 return
 
-            field_filters = filters.get(input_name, {})
-            field_excludes = excludes.get(input_name, {})
+            if input_field.is_collection:
+                from general_manager.interface.capabilities.calculation.input_resolution import (
+                    resolve_calculation_input_value,
+                )
+
+                resolved_dependencies: Combination = {}
+                for dependency in input_field.depends_on:
+                    resolve_calculation_input_value(
+                        cast(
+                            "type[CalculationInterface]", self._manager_class.Interface
+                        ),
+                        self._normalized_constructor_values(current_combo),
+                        dependency,
+                        resolved_dependencies,
+                    )
+                for raw_value in possible_values:
+                    value = self._normalize_collection(
+                        input_name, raw_value, resolved_dependencies
+                    )
+                    if not self._collection_matches(
+                        input_name, value, field_filters, resolved_dependencies
+                    ):
+                        continue
+                    if field_excludes and self._collection_matches(
+                        input_name, value, field_excludes, resolved_dependencies
+                    ):
+                        continue
+                    current_combo[input_name] = value
+                    yield from helper(index + 1, current_combo)
+                    del current_combo[input_name]
+                return
 
             # use filter_funcs and exclude_funcs to filter possible values
             if isinstance(possible_values, Bucket):
@@ -1197,7 +1296,9 @@ class CalculationBucket(Bucket[GeneralManagerType]):
                     possible_values = list(possible_values)
 
             for value in possible_values:
-                if not isinstance(value, input_field.type):
+                if not input_field.is_collection and not isinstance(
+                    value, input_field.type
+                ):
                     continue
                 current_combo[input_name] = value
                 yield from helper(index + 1, current_combo)
@@ -1247,7 +1348,7 @@ class CalculationBucket(Bucket[GeneralManagerType]):
         matching combinations have been found.
         """
         for combo in combinations:
-            manager = self._manager_class(**combo)
+            manager = self._construct_manager(combo)
             if (
                 allowed_identification_keys is not None
                 and freeze_bucket_index_value(manager.identification)
@@ -1371,10 +1472,10 @@ class CalculationBucket(Bucket[GeneralManagerType]):
 
             return MaterializedBucket(
                 self._manager_class,
-                tuple(self._manager_class(**combination) for combination in result),
+                tuple(self._construct_manager(combination) for combination in result),
                 snapshot=self._effective_search_date,
             )
-        return self._manager_class(**result)
+        return self._construct_manager(result)
 
     def __contains__(self, item: GeneralManagerType) -> bool:
         """

{generalmanager-0.84.0 → generalmanager-0.86.0}/src/general_manager/interface/base_interface.py

@@ -368,12 +368,40 @@ class InterfaceBase(ABC):
             **kwargs: Named identification values matching the interface's input field names.
         """
         identification = self.parse_input_fields_to_identification(*args, **kwargs)
+        has_collections = any(
+            getattr(field, "is_collection", False) is True
+            for field in self.input_fields.values()
+        )
+        if not has_collections:
+            from general_manager.manager.general_manager import GeneralManager
+
+            has_collections = any(
+                isinstance(value, GeneralManager)
+                and getattr(
+                    value.__dict__.get("_interface"), "_has_collection_inputs", False
+                )
+                is True
+                for value in identification.values()
+            )
+        if has_collections:
+            self._has_collection_inputs = True
+            # Preserve normalized objects before format_identification replaces managers.
+            self._resolved_input_values = {
+                name: list(value) if isinstance(value, list) else value
+                for name, value in identification.items()
+            }
         if len(identification) == 1:
             value = next(iter(identification.values()))
             if value.__class__ in _FORMATLESS_IDENTIFICATION_VALUE_TYPES:
                 self.identification = identification
                 return
         self.identification = self.format_identification(identification)
+        if has_collections:
+            from copy import deepcopy
+
+            for name, field in self.input_fields.items():
+                if getattr(field, "is_collection", False) is True:
+                    self.identification[name] = deepcopy(self.identification[name])
 
     @classmethod
     def set_capability_selection(cls, selection: "CapabilitySelection") -> None:
@@ -1086,7 +1114,9 @@ class InterfaceBase(ABC):
             if input_field.required:
                 raise InvalidInputTypeError(name, type(value), input_field.type)
             return
-        if not isinstance(value, input_field.type):
+        if getattr(input_field, "is_collection", False) is True:
+            input_field.validate_collection_type(value, name)
+        elif not isinstance(value, input_field.type):
             raise InvalidInputTypeError(name, type(value), input_field.type)
         if (
             input_field.min_value is not None or input_field.max_value is not None

{generalmanager-0.84.0 → generalmanager-0.86.0}/src/general_manager/interface/capabilities/calculation/input_resolution.py

@@ -13,7 +13,10 @@ if TYPE_CHECKING:  # pragma: no cover
 
 def track_manager_input(value: object) -> None:
     """Replay the identification dependency for a cached manager input."""
-    if isinstance(value, GeneralManager):
+    if isinstance(value, list):
+        for member in value:
+            track_manager_input(member)
+    elif isinstance(value, GeneralManager):
         value.__class__._track_identification_dependency(value.identification)
 
 
@@ -33,7 +36,12 @@ def resolve_calculation_input_value(
     if field_name in resolved_values:
         value = resolved_values[field_name]
         track_manager_input(value)
-        return value
+        return (
+            list(value)
+            if isinstance(value, list)
+            and interface_cls.input_fields[field_name].is_collection
+            else value
+        )
 
     field = interface_cls.input_fields[field_name]
     dependencies = {
@@ -52,4 +60,4 @@ def resolve_calculation_input_value(
     )
     track_manager_input(value)
     resolved_values[field_name] = value
-    return value
+    return list(value) if isinstance(value, list) and field.is_collection else value

{generalmanager-0.84.0 → generalmanager-0.86.0}/src/general_manager/manager/general_manager.py

@@ -388,9 +388,14 @@ class GeneralManager(metaclass=GeneralManagerMeta):
     def __reduce__(self) -> tuple[object, tuple[object, ...]]:
         """Provide snapshot-preserving pickling support for this manager."""
         effective = _legacy_effective_search_date(self)
+        from general_manager.manager.input import _prepare_normalized_identification
+
+        values = tuple(
+            _prepare_normalized_identification(self.__class__, self.__id).values()
+        )
         return (
             _reconstruct_general_manager,
-            (self.__class__, tuple(self.__id.values()), effective),
+            (self.__class__, values, effective),
         )
 
     def __or__(
@@ -433,6 +438,13 @@ class GeneralManager(metaclass=GeneralManagerMeta):
     @property
     def identification(self) -> dict[str, object]:
         """Return the identification dictionary used to fetch the managed object."""
+        if (
+            getattr(self.__dict__.get("_interface"), "_has_collection_inputs", False)
+            is True
+        ):
+            from copy import deepcopy
+
+            return deepcopy(self.__id)
         return self.__id
 
     @property
@@ -795,8 +807,9 @@ class GeneralManager(metaclass=GeneralManagerMeta):
             )
         return cast(Bucket[Self], cls.Interface.filter())
 
-    @staticmethod
+    @classmethod
     def __parse_identification(
+        cls,
         kwargs: dict[str, object],
     ) -> dict[str, object] | None:
         """
@@ -823,7 +836,17 @@ class GeneralManager(metaclass=GeneralManagerMeta):
 
         output: dict[str, object] = {}
         changed = False
+        fields = getattr(getattr(cls, "Interface", None), "input_fields", {})
         for key, value in kwargs.items():
+            input_name = key.split("__", 1)[0]
+            input_field = fields.get(input_name)
+            if input_field is None and input_name.endswith("_id"):
+                input_field = fields.get(input_name[:-3])
+            if getattr(input_field, "is_collection", False) is True:
+                # Collection casting retains resolved manager members; flattening
+                # them here would rerun nested collection normalizers.
+                output[key] = value
+                continue
             if isinstance(value, GeneralManager):
                 output[key] = GeneralManager.__lookup_identifier(value)
                 changed = True