GeneralManager 0.5.1__py3-none-any.whl → 0.6.0__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")
@@ -70,9 +68,17 @@ class InterfaceBase(ABC):
         *args: Any,
         **kwargs: dict[str, Any],
     ) -> dict[str, Any]:
+        """
+        Parses and validates input arguments into a structured identification dictionary.
+        
+        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.
+        """
         identification = {}
         kwargs = args_to_kwargs(args, self.input_fields.keys(), kwargs)
-        # Prüfe auf fehlende oder unerwartete Argumente
+        # Check for extra arguments
         extra_args = set(kwargs.keys()) - set(self.input_fields.keys())
         if extra_args:
             for extra_arg in extra_args:
@@ -85,7 +91,7 @@ class InterfaceBase(ABC):
         if missing_args:
             raise TypeError(f"Missing required arguments: {', '.join(missing_args)}")
 
-        # Verarbeite Felder unter Berücksichtigung von Abhängigkeiten
+        # process input fields with dependencies
         processed = set()
         while len(processed) < len(self.input_fields):
             progress_made = False
@@ -100,7 +106,7 @@ class InterfaceBase(ABC):
                     processed.add(name)
                     progress_made = True
             if not progress_made:
-                # Zirkuläre Abhängigkeit erkannt
+                # detect circular dependencies
                 unresolved = set(self.input_fields.keys()) - processed
                 raise ValueError(
                     f"Circular dependency detected among inputs: {', '.join(unresolved)}"
@@ -123,13 +129,18 @@ class InterfaceBase(ABC):
     def _process_input(
         self, name: str, value: Any, identification: dict[str, Any]
     ) -> None:
+        """
+        Validates the type and allowed values of an input field.
+        
+        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):
             raise TypeError(
                 f"Invalid type for {name}: {type(value)}, expected: {input_field.type}"
             )
         if settings.DEBUG:
-            # Prüfe mögliche Werte
+            # `possible_values` can be a callable or an iterable
             possible_values = input_field.possible_values
             if possible_values is not None:
                 if callable(possible_values):
@@ -206,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):
@@ -118,289 +102,18 @@ class CalculationInterface(InterfaceBase):
     @classmethod
     def getFieldType(cls, field_name: str) -> type:
         """
-        This method returns the field type for the given field 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 input field.
+        
+        Raises:
+            ValueError: If the specified 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.")
         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
-        )