GeneralManager 0.85.0__tar.gz → 0.86.1__tar.gz

{generalmanager-0.85.0/src/GeneralManager.egg-info → generalmanager-0.86.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.85.0
+Version: 0.86.1
 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.85.0 → generalmanager-0.86.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "GeneralManager"
-version = "0.85.0"
+version = "0.86.1"
 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.85.0 → generalmanager-0.86.1/src/GeneralManager.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: GeneralManager
-Version: 0.85.0
+Version: 0.86.1
 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.85.0 → generalmanager-0.86.1}/src/general_manager/api/graphql.py

@@ -47,6 +47,7 @@ from general_manager.bucket._materialized_bucket import MaterializedBucket
 from general_manager.bucket.group_bucket import GroupBucket
 from general_manager.bucket.request_bucket import RequestBucket
 from general_manager.bucket.indexing import freeze_bucket_index_value
+from general_manager.cache.cache_tracker import DependencyTracker
 from general_manager.cache.dependency_index import (
     Dependency,
 )
@@ -116,6 +117,7 @@ from general_manager.api.graphql_resolvers import (
     apply_pagination as _apply_pagination_fn,
     apply_grouping as _apply_grouping_fn,
     check_read_permission as _check_read_permission_fn,
+    check_read_permission_for_user as _check_read_permission_for_user_fn,
     can_read_instance_for_user as _can_read_instance_for_user_fn,
     create_measurement_resolver as _create_measurement_resolver_fn,
     create_normal_resolver as _create_normal_resolver_fn,
@@ -835,14 +837,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 +886,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 +1421,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,
@@ -2350,6 +2393,36 @@ class GraphQL:
             raise
         return item if readable else None
 
+    @classmethod
+    def _prepare_detail_subscription(
+        cls,
+        manager_class: type[GeneralManager],
+        identification: GraphQLIdentification,
+        user: object,
+        *,
+        property_names: Iterable[str] = (),
+    ) -> tuple[GeneralManager, set[Dependency]] | None:
+        """Hydrate and authorize before priming selected readable properties.
+
+        Call in a worker thread: construction, native permissions and property
+        reads may all access the ORM. Only hydration errors are suppressed;
+        permission-backend and property failures must fail the stream closed.
+        """
+        with DependencyTracker() as dependencies:
+            try:
+                instance, _ = cls._instantiate_manager(manager_class, identification)
+            except SUBSCRIPTION_HYDRATION_ERRORS:
+                return None
+            if not _can_read_instance_for_user_fn(instance, user):
+                return None
+            readable_properties = [
+                name
+                for name in property_names
+                if _check_read_permission_for_user_fn(instance, user, name)
+            ]
+            cls._prime_graphql_properties(instance, readable_properties)
+        return instance, dependencies
+
     @classmethod
     def _add_subscription_field(
         cls,
@@ -2370,7 +2443,7 @@ class GraphQL:
 
         Notes:
         - The subscribe function requires an available channel layer and subscribes the caller to channel groups derived from the instance identification and its resolved dependencies.
-        - The subscribe coroutine yields SubscriptionEvent objects with fields `item` (the current instance or None if it cannot be instantiated) and `action` (a string such as `"snapshot"` or other change actions).
+        - Detail events contain an authorized current instance and an action; unavailable or unreadable targets terminate the detail stream.
         - On termination the subscription cleans up listener tasks and unsubscribes from channel groups.
         """
         manager_field_name = pascal_to_snake(generalManagerClass.__name__)
@@ -2410,27 +2483,30 @@ class GraphQL:
             """
             Stream subscription events for a specific manager instance identified by the provided arguments.
 
-            Yields an initial `SubscriptionEvent` with `action` set to `"snapshot"` containing the current manager instance, then yields `SubscriptionEvent`s for each subsequent action. For subsequent events, `item` will be the re-instantiated manager instance or `None` if instantiation fails. The subscriber is registered on the manager's channel groups (including dependent managers' groups) and the channel subscriptions and background listener are cleaned up when the iterator is closed or cancelled.
-
-            Parameters:
-                identification: Identification fields required to locate the manager instance (maps to the manager's identification signature).
-
-            Returns:
-                AsyncIterator[SubscriptionEvent]: An asynchronous iterator that first yields a snapshot event and then yields update events; each event's `item` is the manager instance or `None` if it could not be instantiated.
+            Authorize the request user before property priming and registration.
+            Recheck access before each event; unavailable or unreadable targets
+            end the iterator without forwarding the queued action. Closing the
+            iterator removes its listeners and channel memberships.
             """
             identification_copy = deepcopy(identification)
             property_names = cls._subscription_property_names(info, generalManagerClass)
+            subscription_user = info.context.user
             try:
-                instance, dependency_records = await asyncio.to_thread(
-                    cls._instantiate_manager,
+                prepared = await asyncio.to_thread(
+                    cls._prepare_detail_subscription,
                     generalManagerClass,
                     identification_copy,
-                    collect_dependencies=True,
+                    subscription_user,
                     property_names=property_names,
                 )
             except Exception as exc:  # pragma: no cover - bubbled to GraphQL
                 raise GraphQLError(str(exc)) from exc
 
+            if prepared is None:
+                message = "Subscription target is unavailable or not readable."
+                raise GraphQLError(message)
+            instance, dependency_records = prepared
+
             try:
                 channel_layer = cast(
                     BaseChannelLayer, cls._get_channel_layer(strict=True)
@@ -2457,15 +2533,16 @@ class GraphQL:
                 group_names.add(cls._refresh_group_name(dependency_class))
 
             async def event_stream() -> AsyncIterator[SubscriptionEvent]:
-                """
-                Yield subscription events for a manager instance, starting with an initial snapshot followed by subsequent updates.
-
-                Returns:
-                    AsyncIterator[SubscriptionEvent]: An asynchronous iterator that first yields a `SubscriptionEvent` with `action` set to `"snapshot"` and `item` containing the current manager instance (or `None` if instantiation failed). Subsequent yields provide `SubscriptionEvent` values for each received action, where `action` is the action string and `item` is the (re-)instantiated manager or `None` if instantiation failed.
-
-                Notes:
-                    When the iterator is closed or exits, the background listener task is cancelled and the subscription's channel group memberships are discarded.
-                """
+                """Deliver authorized events and clean up on every exit path."""
+                # The iterator may be consumed long after subscribe() returns.
+                prepared = await asyncio.to_thread(
+                    cls._prepare_detail_subscription,
+                    generalManagerClass,
+                    identification_copy,
+                    subscription_user,
+                )
+                if prepared is None:
+                    return
                 channel_name = cast(str, await channel_layer.new_channel())
                 queue: asyncio.Queue[str] = asyncio.Queue[str]()
                 joined_groups = await _join_subscription_groups(
@@ -2482,19 +2559,29 @@ class GraphQL:
                     joined_groups,
                     listener_task,
                 ):
+                    # Group registration awaits I/O; access can change meanwhile.
+                    prepared = await asyncio.to_thread(
+                        cls._prepare_detail_subscription,
+                        generalManagerClass,
+                        identification_copy,
+                        subscription_user,
+                    )
+                    if prepared is None:
+                        return
+                    item, _ = prepared
                     clear_capability_context(info)
-                    yield SubscriptionEvent(item=instance, action="snapshot")
+                    yield SubscriptionEvent(item=item, action="snapshot")
                     while True:
                         action = await queue.get()
-                        try:
-                            item, _ = await asyncio.to_thread(
-                                cls._instantiate_manager,
-                                generalManagerClass,
-                                identification_copy,
-                                property_names=property_names,
-                            )
-                        except SUBSCRIPTION_HYDRATION_ERRORS:
-                            item = None
+                        prepared = await asyncio.to_thread(
+                            cls._prepare_detail_subscription,
+                            generalManagerClass,
+                            identification_copy,
+                            subscription_user,
+                        )
+                        if prepared is None:
+                            return
+                        item, _ = prepared
                         clear_capability_context(info)
                         yield SubscriptionEvent(item=item, action=action)
 

{generalmanager-0.85.0 → generalmanager-0.86.1}/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.85.0 → generalmanager-0.86.1}/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.85.0 → generalmanager-0.86.1}/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.85.0 → generalmanager-0.86.1}/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.85.0 → generalmanager-0.86.1}/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.85.0 → generalmanager-0.86.1}/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.85.0 → generalmanager-0.86.1}/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:
         """