GeneralManager 0.5.2__py3-none-any.whl → 0.6.1__py3-none-any.whl

general_manager/interface/baseInterface.py

@@ -2,11 +2,9 @@ from __future__ import annotations
 from abc import ABC, abstractmethod
 from typing import (
     Type,
-    Generator,
     TYPE_CHECKING,
     Any,
     TypeVar,
-    Generic,
     Iterable,
     ClassVar,
     Callable,
@@ -21,7 +19,7 @@ if TYPE_CHECKING:
     from general_manager.manager.input import Input
     from general_manager.manager.generalManager import GeneralManager
     from general_manager.manager.meta import GeneralManagerMeta
-    from general_manager.manager.groupManager import GroupManager, GroupBucket
+    from general_manager.bucket.baseBucket import Bucket
 
 
 GeneralManagerType = TypeVar("GeneralManagerType", bound="GeneralManager")
@@ -73,7 +71,7 @@ class InterfaceBase(ABC):
         """
         Parses and validates input arguments into a structured identification dictionary.
         
-        Converts positional and keyword arguments into a dictionary keyed by input field names, handling normalization of argument names and checking for unexpected or missing arguments. Processes input fields in dependency order, casting and validating each value. Raises a `TypeError` for unexpected or missing arguments and a `ValueError` if circular dependencies among input fields are detected.
+        Converts positional and keyword arguments into a dictionary keyed by input field names, normalizing argument names and ensuring all required fields are present. Processes input fields in dependency order, casting and validating each value. Raises a `TypeError` for unexpected or missing arguments and a `ValueError` if circular dependencies among input fields are detected.
         
         Returns:
             A dictionary mapping input field names to their validated and cast values.
@@ -134,7 +132,7 @@ class InterfaceBase(ABC):
         """
         Validates the type and allowed values of an input field.
         
-        Checks that the provided value matches the expected type for the input field and, in debug mode, verifies that the value is among the allowed possible values if specified. Raises a TypeError for invalid types or possible value definitions, and a ValueError if the value is not permitted.
+        Ensures that the provided value matches the expected type for the specified input field. In debug mode, also checks that the value is among the allowed possible values if defined, supporting both callables and iterables. Raises a TypeError for invalid types or possible value definitions, and a ValueError if the value is not permitted.
         """
         input_field = self.input_fields[name]
         if not isinstance(value, input_field.type):
@@ -219,103 +217,15 @@ class InterfaceBase(ABC):
     @abstractmethod
     def getFieldType(cls, field_name: str) -> type:
         """
-        Returns the type of the field with the given name.
+        Returns the type of the specified input field.
+        
+        Args:
+            field_name: The name of the input field.
+        
+        Returns:
+            The Python type associated with the given field name.
+        
+        Raises:
+            NotImplementedError: This method must be implemented by subclasses.
         """
         raise NotImplementedError
-
-
-class Bucket(ABC, Generic[GeneralManagerType]):
-
-    def __init__(self, manager_class: Type[GeneralManagerType]):
-        self._manager_class = manager_class
-        self._data = None
-        self.excludes = {}
-        self.filters = {}
-
-    def __eq__(self, other: object) -> bool:
-        if not isinstance(other, self.__class__):
-            return False
-        return self._data == other._data and self._manager_class == other._manager_class
-
-    def __reduce__(self) -> str | tuple[Any, ...]:
-        return (
-            self.__class__,
-            (None, self._manager_class, self.filters, self.excludes),
-        )
-
-    @abstractmethod
-    def __or__(
-        self, other: Bucket[GeneralManagerType] | GeneralManager[GeneralManagerType]
-    ) -> Bucket[GeneralManagerType]:
-        raise NotImplementedError
-
-    @abstractmethod
-    def __iter__(
-        self,
-    ) -> Generator[GeneralManagerType | GroupManager[GeneralManagerType]]:
-        raise NotImplementedError
-
-    @abstractmethod
-    def filter(self, **kwargs: Any) -> Bucket[GeneralManagerType]:
-        raise NotImplementedError
-
-    @abstractmethod
-    def exclude(self, **kwargs: Any) -> Bucket[GeneralManagerType]:
-        raise NotImplementedError
-
-    @abstractmethod
-    def first(self) -> GeneralManagerType | GroupManager[GeneralManagerType] | None:
-        raise NotImplementedError
-
-    @abstractmethod
-    def last(self) -> GeneralManagerType | GroupManager[GeneralManagerType] | None:
-        raise NotImplementedError
-
-    @abstractmethod
-    def count(self) -> int:
-        raise NotImplementedError
-
-    @abstractmethod
-    def all(self) -> Bucket[GeneralManagerType]:
-        raise NotImplementedError
-
-    @abstractmethod
-    def get(
-        self, **kwargs: Any
-    ) -> GeneralManagerType | GroupManager[GeneralManagerType]:
-        raise NotImplementedError
-
-    @abstractmethod
-    def __getitem__(
-        self, item: int | slice
-    ) -> (
-        GeneralManagerType
-        | GroupManager[GeneralManagerType]
-        | Bucket[GeneralManagerType]
-    ):
-        raise NotImplementedError
-
-    @abstractmethod
-    def __len__(self) -> int:
-        raise NotImplementedError
-
-    @abstractmethod
-    def __contains__(self, item: GeneralManagerType) -> bool:
-        raise NotImplementedError
-
-    @abstractmethod
-    def sort(
-        self,
-        key: tuple[str] | str,
-        reverse: bool = False,
-    ) -> Bucket[GeneralManagerType]:
-        raise NotImplementedError
-
-    def group_by(self, *group_by_keys: str) -> GroupBucket[GeneralManagerType]:
-        """
-        This method groups the data by the given arguments.
-        It returns a GroupBucket with the grouped data.
-        """
-        from general_manager.manager.groupManager import GroupBucket
-
-        return GroupBucket(self._manager_class, group_by_keys, self)

general_manager/interface/calculationInterface.py

@@ -1,19 +1,8 @@
 from __future__ import annotations
 from datetime import datetime
-from typing import (
-    Any,
-    Type,
-    TYPE_CHECKING,
-    Callable,
-    Iterable,
-    Union,
-    Optional,
-    Generator,
-    List,
-)
+from typing import Any
 from general_manager.interface.baseInterface import (
     InterfaceBase,
-    Bucket,
     classPostCreationMethod,
     classPreCreationMethod,
     generalManagerClassName,
@@ -22,15 +11,10 @@ from general_manager.interface.baseInterface import (
     newlyCreatedGeneralManagerClass,
     newlyCreatedInterfaceClass,
     relatedClass,
-    GeneralManagerType,
     AttributeTypedDict,
 )
 from general_manager.manager.input import Input
-from general_manager.auxiliary.filterParser import parse_filters
-
-if TYPE_CHECKING:
-    from general_manager.manager.generalManager import GeneralManager
-    from general_manager.manager.meta import GeneralManagerMeta
+from general_manager.bucket.calculationBucket import CalculationBucket
 
 
 class CalculationInterface(InterfaceBase):
@@ -77,7 +61,15 @@ class CalculationInterface(InterfaceBase):
     def _preCreate(
         name: generalManagerClassName, attrs: attributes, interface: interfaceBaseClass
     ) -> tuple[attributes, interfaceBaseClass, None]:
-        # Felder aus der Interface-Klasse sammeln
+
+        """
+        Prepares attributes and a new interface class before creating a GeneralManager class.
+        
+        Collects all `Input` instances from the provided interface class, sets the interface type in the attributes, dynamically creates a new interface class with these input fields, and adds it to the attributes.
+        
+        Returns:
+            A tuple containing the updated attributes dictionary, the new interface class, and None.
+        """
         input_fields: dict[str, Input[Any]] = {}
         for key, value in vars(interface).items():
             if key.startswith("__"):
@@ -85,7 +77,6 @@ class CalculationInterface(InterfaceBase):
             if isinstance(value, Input):
                 input_fields[key] = value
 
-        # Interface-Typ bestimmen
         attrs["_interface_type"] = interface._interface_type
         interface_cls = type(
             interface.__name__, (interface,), {"input_fields": input_fields}
@@ -118,289 +109,12 @@ class CalculationInterface(InterfaceBase):
     @classmethod
     def getFieldType(cls, field_name: str) -> type:
         """
-        This method returns the field type for the given field name.
+        Returns the Python type of a specified input field.
+        
+        Raises:
+            KeyError: If the field name does not exist in input_fields.
         """
         input = cls.input_fields.get(field_name)
         if input is None:
-            raise ValueError(f"Field '{field_name}' not found in input fields.")
+            raise KeyError(f"Field '{field_name}' not found in input fields.")
         return input.type
-
-
-class CalculationBucket(Bucket[GeneralManagerType]):
-    def __init__(
-        self,
-        manager_class: Type[GeneralManagerType],
-        filter_definitions: Optional[dict[str, dict]] = None,
-        exclude_definitions: Optional[dict[str, dict]] = None,
-        sort_key: Optional[Union[str, tuple[str]]] = None,
-        reverse: bool = False,
-    ):
-        from general_manager.interface.calculationInterface import (
-            CalculationInterface,
-        )
-
-        super().__init__(manager_class)
-
-        interface_class = manager_class.Interface
-        if not issubclass(interface_class, CalculationInterface):
-            raise TypeError(
-                "CalculationBucket can only be used with CalculationInterface subclasses"
-            )
-        self.input_fields = interface_class.input_fields
-        self.filters = {} if filter_definitions is None else filter_definitions
-        self.excludes = {} if exclude_definitions is None else exclude_definitions
-        self.__current_combinations = None
-        self.sort_key = sort_key
-        self.reverse = reverse
-
-    def __reduce__(self) -> generalManagerClassName | tuple[Any, ...]:
-        return (
-            self.__class__,
-            (
-                self._manager_class,
-                self.filters,
-                self.excludes,
-                self.sort_key,
-                self.reverse,
-            ),
-        )
-
-    def __or__(
-        self, other: Bucket[GeneralManagerType] | GeneralManager[GeneralManagerType]
-    ) -> CalculationBucket[GeneralManagerType]:
-        from general_manager.manager.generalManager import GeneralManager
-
-        if isinstance(other, GeneralManager) and other.__class__ == self._manager_class:
-            return self.__or__(self.filter(id__in=[other.identification]))
-        if not isinstance(other, self.__class__):
-            raise ValueError("Cannot combine different bucket types")
-        if self._manager_class != other._manager_class:
-            raise ValueError("Cannot combine different manager classes")
-
-        combined_filters = {
-            key: value
-            for key, value in self.filters.items()
-            if key in other.filters and value == other.filters[key]
-        }
-
-        combined_excludes = {
-            key: value
-            for key, value in self.excludes.items()
-            if key in other.excludes and value == other.excludes[key]
-        }
-
-        return CalculationBucket(
-            self._manager_class,
-            combined_filters,
-            combined_excludes,
-        )
-
-    def __str__(self) -> str:
-        PRINT_MAX = 5
-        combinations = self.generate_combinations()
-        prefix = f"CalculationBucket ({len(combinations)})["
-        main = ",".join(
-            [
-                f"{self._manager_class.__name__}(**{comb})"
-                for comb in combinations[:PRINT_MAX]
-            ]
-        )
-        sufix = f"]"
-        if len(combinations) > PRINT_MAX:
-            sufix = f", ...]"
-
-        return f"{prefix}{main}{sufix} "
-
-    def __repr__(self) -> str:
-        return self.__str__()
-
-    def filter(self, **kwargs: Any) -> CalculationBucket:
-        filters = self.filters.copy()
-        excludes = self.excludes.copy()
-        filters.update(parse_filters(kwargs, self.input_fields))
-        return CalculationBucket(self._manager_class, filters, excludes)
-
-    def exclude(self, **kwargs: Any) -> CalculationBucket:
-        filters = self.filters.copy()
-        excludes = self.excludes.copy()
-        excludes.update(parse_filters(kwargs, self.input_fields))
-        return CalculationBucket(self._manager_class, filters, excludes)
-
-    def all(self) -> CalculationBucket:
-        return self
-
-    def __iter__(self) -> Generator[GeneralManagerType]:
-        combinations = self.generate_combinations()
-        for combo in combinations:
-            yield self._manager_class(**combo)
-
-    def generate_combinations(self) -> List[dict[str, Any]]:
-        if self.__current_combinations is None:
-            # Implementierung ähnlich wie im InputManager
-            sorted_inputs = self.topological_sort_inputs()
-            current_combinations = self._generate_combinations(
-                sorted_inputs, self.filters, self.excludes
-            )
-            if self.sort_key is not None:
-                sort_key = self.sort_key
-                if isinstance(sort_key, str):
-                    sort_key = (sort_key,)
-                key_func = lambda x: (tuple(x[key] for key in sort_key))
-                current_combinations = sorted(
-                    current_combinations,
-                    key=key_func,
-                )
-            if self.reverse:
-                current_combinations.reverse()
-            self.__current_combinations = current_combinations
-
-        return self.__current_combinations
-
-    def topological_sort_inputs(self) -> List[str]:
-        from collections import defaultdict
-
-        dependencies = {
-            name: field.depends_on for name, field in self.input_fields.items()
-        }
-        graph = defaultdict(set)
-        for key, deps in dependencies.items():
-            for dep in deps:
-                graph[dep].add(key)
-
-        visited = set()
-        sorted_inputs = []
-
-        def visit(node, temp_mark):
-            if node in visited:
-                return
-            if node in temp_mark:
-                raise ValueError(f"Cyclic dependency detected: {node}")
-            temp_mark.add(node)
-            for m in graph.get(node, []):
-                visit(m, temp_mark)
-            temp_mark.remove(node)
-            visited.add(node)
-            sorted_inputs.append(node)
-
-        for node in self.input_fields.keys():
-            if node not in visited:
-                visit(node, set())
-
-        sorted_inputs.reverse()
-        return sorted_inputs
-
-    def get_possible_values(
-        self, key_name: str, input_field: Input, current_combo: dict
-    ) -> Union[Iterable[Any], Bucket[Any]]:
-        # Hole mögliche Werte
-        if callable(input_field.possible_values):
-            depends_on = input_field.depends_on
-            dep_values = {dep_name: current_combo[dep_name] for dep_name in depends_on}
-            possible_values = input_field.possible_values(**dep_values)
-        elif isinstance(input_field.possible_values, (Iterable, Bucket)):
-            possible_values = input_field.possible_values
-        else:
-            raise TypeError(f"Invalid possible_values for input '{key_name}'")
-        return possible_values
-
-    def _generate_combinations(
-        self,
-        sorted_inputs: List[str],
-        filters: dict[str, dict],
-        excludes: dict[str, dict],
-    ) -> List[dict[str, Any]]:
-        def helper(index, current_combo):
-            if index == len(sorted_inputs):
-                yield current_combo.copy()
-                return
-            input_name: str = sorted_inputs[index]
-            input_field = self.input_fields[input_name]
-
-            # Hole mögliche Werte
-            possible_values = self.get_possible_values(
-                input_name, input_field, current_combo
-            )
-
-            # Wende die Filter an
-            field_filters = filters.get(input_name, {})
-            field_excludes = excludes.get(input_name, {})
-
-            if isinstance(possible_values, Bucket):
-                # Wende die Filter- und Exklusionsargumente direkt an
-                filter_kwargs = field_filters.get("filter_kwargs", {})
-                exclude_kwargs = field_excludes.get("filter_kwargs", {})
-                possible_values = possible_values.filter(**filter_kwargs).exclude(
-                    **exclude_kwargs
-                )
-            else:
-                # Wende die Filterfunktionen an
-                filter_funcs = field_filters.get("filter_funcs", [])
-                for filter_func in filter_funcs:
-                    possible_values = filter(filter_func, possible_values)
-
-                exclude_funcs = field_excludes.get("filter_funcs", [])
-                for exclude_func in exclude_funcs:
-                    possible_values = filter(
-                        lambda x: not exclude_func(x), possible_values
-                    )
-
-                possible_values = list(possible_values)
-
-            for value in possible_values:
-                if not isinstance(value, input_field.type):
-                    continue
-                current_combo[input_name] = value
-                yield from helper(index + 1, current_combo)
-                del current_combo[input_name]
-
-        return list(helper(0, {}))
-
-    def first(self) -> GeneralManagerType | None:
-        try:
-            return next(iter(self))
-        except StopIteration:
-            return None
-
-    def last(self) -> GeneralManagerType | None:
-        items = list(self)
-        if items:
-            return items[-1]
-        return None
-
-    def count(self) -> int:
-        return sum(1 for _ in self)
-
-    def __len__(self) -> int:
-        return self.count()
-
-    def __getitem__(
-        self, item: int | slice
-    ) -> GeneralManagerType | CalculationBucket[GeneralManagerType]:
-        items = self.generate_combinations()
-        result = items[item]
-        if isinstance(result, list):
-            new_bucket = CalculationBucket(self._manager_class)
-            new_bucket.filters = self.filters.copy()
-            new_bucket.excludes = self.excludes.copy()
-            return new_bucket
-        return self._manager_class(**result)
-
-    def __contains__(self, item: GeneralManagerType) -> bool:
-        return item in list(self)
-
-    def get(self, **kwargs: Any) -> GeneralManagerType:
-        filtered_bucket = self.filter(**kwargs)
-        items = list(filtered_bucket)
-        if len(items) == 1:
-            return items[0]
-        elif len(items) == 0:
-            raise ValueError("No matching calculation found.")
-        else:
-            raise ValueError("Multiple matching calculations found.")
-
-    def sort(
-        self, key: str | tuple[str], reverse: bool = False
-    ) -> CalculationBucket[GeneralManagerType]:
-        return CalculationBucket(
-            self._manager_class, self.filters, self.excludes, key, reverse
-        )