GeneralManager 0.0.0__py3-none-any.whl

general_manager/manager/__init__.py

@@ -0,0 +1,3 @@
+from .generalManager import GeneralManager
+from .input import Input
+from ..api.property import graphQlProperty

general_manager/manager/generalManager.py

@@ -0,0 +1,136 @@
+from __future__ import annotations
+from typing import Generic, Type, Any, TYPE_CHECKING
+from general_manager.manager.meta import GeneralManagerMeta
+from general_manager.interface.baseInterface import (
+    InterfaceBase,
+    Bucket,
+    GeneralManagerType,
+)
+from general_manager.api.property import GraphQLProperty
+from general_manager.cache.cacheTracker import addDependency
+from general_manager.cache.signals import dataChange
+
+if TYPE_CHECKING:
+    from general_manager.permission.basePermission import BasePermission
+
+
+class GeneralManager(Generic[GeneralManagerType], metaclass=GeneralManagerMeta):
+    Interface: Type[InterfaceBase]
+    _attributes: dict[str, Any]
+
+    def __init__(self, *args: Any, **kwargs: Any):
+        self._interface = self.Interface(*args, **kwargs)
+        self.__id: dict[str, Any] = self._interface.identification
+        addDependency(self.__class__.__name__, "identification", f"{self.__id}")
+
+    def __str__(self):
+        return f"{self.__class__.__name__}(**{self.__id})"
+
+    def __repr__(self):
+        return f"{self.__class__.__name__}(**{self.__id})"
+
+    def __reduce__(self) -> str | tuple[Any, ...]:
+        return (self.__class__, tuple(self.__id.values()))
+
+    def __or__(
+        self, other: GeneralManager[GeneralManagerType] | Bucket[GeneralManagerType]
+    ) -> Bucket[GeneralManagerType]:
+        if isinstance(other, Bucket):
+            return other | self
+        elif isinstance(other, GeneralManager) and other.__class__ == self.__class__:
+            return self.filter(id__in=[self.__id, other.__id])
+        else:
+            raise TypeError(f"Unsupported type for union: {type(other)}")
+
+    @property
+    def identification(self):
+        return self.__id
+
+    def __iter__(self):
+        for key, value in self._attributes.items():
+            if callable(value):
+                yield key, value(self._interface)
+                continue
+            yield key, value
+        for name, value in self.__class__.__dict__.items():
+            if isinstance(value, (GraphQLProperty, property)):
+                yield name, getattr(self, name)
+
+    @classmethod
+    @dataChange
+    def create(
+        cls,
+        creator_id: int,
+        history_comment: str | None = None,
+        ignore_permission: bool = False,
+        **kwargs: dict[str, Any],
+    ) -> GeneralManager[GeneralManagerType]:
+        Permission: Type[BasePermission] | None = getattr(cls, "Permission", None)
+        if Permission is not None and not ignore_permission:
+            Permission.checkCreatePermission(kwargs, cls, creator_id)
+        identification = cls.Interface.create(
+            creator_id=creator_id, history_comment=history_comment, **kwargs
+        )
+        return cls(identification)
+
+    @dataChange
+    def update(
+        self,
+        creator_id: int,
+        history_comment: str | None = None,
+        ignore_permission: bool = False,
+        **kwargs: dict[str, Any],
+    ) -> GeneralManager[GeneralManagerType]:
+        Permission: Type[BasePermission] | None = getattr(self, "Permission", None)
+        if Permission is not None and not ignore_permission:
+            Permission.checkUpdatePermission(kwargs, self, creator_id)
+        self._interface.update(
+            creator_id=creator_id,
+            history_comment=history_comment,
+            **kwargs,
+        )
+        return self.__class__(**self.identification)
+
+    @dataChange
+    def deactivate(
+        self,
+        creator_id: int,
+        history_comment: str | None = None,
+        ignore_permission: bool = False,
+    ) -> GeneralManager[GeneralManagerType]:
+        Permission: Type[BasePermission] | None = getattr(self, "Permission", None)
+        if Permission is not None and not ignore_permission:
+            Permission.checkDeletePermission(self, creator_id)
+        self._interface.deactivate(
+            creator_id=creator_id, history_comment=history_comment
+        )
+        return self.__class__(**self.identification)
+
+    @classmethod
+    def filter(cls, **kwargs: Any) -> Bucket[GeneralManagerType]:
+        addDependency(cls.__name__, "filter", f"{cls.__parse_identification(kwargs)}")
+        return cls.Interface.filter(**kwargs)
+
+    @classmethod
+    def exclude(cls, **kwargs: Any) -> Bucket[GeneralManagerType]:
+        addDependency(cls.__name__, "exclude", f"{cls.__parse_identification(kwargs)}")
+        return cls.Interface.exclude(**kwargs)
+
+    @classmethod
+    def all(cls) -> Bucket[GeneralManagerType]:
+        return cls.Interface.filter()
+
+    @staticmethod
+    def __parse_identification(kwargs: dict[str, Any]) -> dict[str, Any] | None:
+        for key, value in kwargs.items():
+            if isinstance(value, GeneralManager):
+                kwargs[key] = value.identification
+            elif isinstance(value, list):
+                kwargs[key] = [
+                    v.identification for v in value if isinstance(v, GeneralManager)
+                ]
+            elif isinstance(value, tuple):
+                kwargs[key] = tuple(
+                    v.identification for v in value if isinstance(v, GeneralManager)
+                )
+        return kwargs if kwargs else None

general_manager/manager/groupManager.py

@@ -0,0 +1,288 @@
+from __future__ import annotations
+from typing import (
+    Type,
+    Generator,
+    Any,
+    Generic,
+    get_args,
+    cast,
+)
+import json
+from datetime import datetime, date, time
+from general_manager.api.graphql import GraphQLProperty
+from general_manager.measurement import Measurement
+from general_manager.manager.generalManager import GeneralManager
+from general_manager.interface.baseInterface import (
+    Bucket,
+    GeneralManagerType,
+)
+
+
+class GroupBucket(Bucket[GeneralManagerType]):
+
+    def __init__(
+        self,
+        manager_class: Type[GeneralManagerType],
+        group_by_keys: tuple[str, ...],
+        data: Bucket[GeneralManagerType],
+    ):
+        super().__init__(manager_class)
+        self.__checkGroupByArguments(group_by_keys)
+        self._group_by_keys = group_by_keys
+        self._data = self.__buildGroupedManager(data)
+        self._basis_data = data
+
+    def __checkGroupByArguments(self, group_by_keys: tuple[str, ...]) -> None:
+        """
+        This method checks if the given arguments are valid for the groupBy method.
+        It raises a TypeError if the arguments are not valid.
+        """
+        if not all(isinstance(arg, str) for arg in group_by_keys):
+            raise TypeError("groupBy() argument must be a string")
+        if not all(
+            arg in self._manager_class.Interface.getAttributes().keys()
+            for arg in group_by_keys
+        ):
+            raise TypeError(
+                f"groupBy() argument must be a valid attribute of {self._manager_class.__name__}"
+            )
+
+    def __buildGroupedManager(
+        self,
+        data: Bucket[GeneralManagerType],
+    ) -> list[GroupedManager[GeneralManagerType]]:
+        """
+        This method builds the grouped manager.
+        It returns a GroupBucket with the grouped data.
+        """
+        group_by_values = set()
+        for entry in data:
+            group_by_value = {}
+            for arg in self._group_by_keys:
+                group_by_value[arg] = getattr(entry, arg)
+            group_by_values.add(json.dumps(group_by_value))
+
+        groups = []
+        for group_by_value in group_by_values:
+            group_by_value = json.loads(group_by_value)
+            grouped_manager_objects = data.filter(**group_by_value)
+            groups.append(
+                GroupedManager(
+                    self._manager_class, group_by_value, grouped_manager_objects
+                )
+            )
+        return groups
+
+    def __or__(self, other: object) -> GroupBucket[GeneralManagerType]:
+        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")
+        return GroupBucket(
+            self._manager_class,
+            self._group_by_keys,
+            self._basis_data | other._basis_data,
+        )
+
+    def __iter__(self) -> Generator[GroupedManager[GeneralManagerType]]:
+        for grouped_manager in self._data:
+            yield grouped_manager
+
+    def filter(self, **kwargs: Any) -> GroupBucket[GeneralManagerType]:
+        new_basis_data = self._basis_data.filter(**kwargs)
+        return GroupBucket(
+            self._manager_class,
+            self._group_by_keys,
+            new_basis_data,
+        )
+
+    def exclude(self, **kwargs: Any) -> GroupBucket[GeneralManagerType]:
+        new_basis_data = self._basis_data.exclude(**kwargs)
+        return GroupBucket(
+            self._manager_class,
+            self._group_by_keys,
+            new_basis_data,
+        )
+
+    def first(self) -> GroupedManager[GeneralManagerType] | None:
+        try:
+            return next(iter(self))
+        except StopIteration:
+            return None
+
+    def last(self) -> GroupedManager[GeneralManagerType] | None:
+        items = list(self)
+        if items:
+            return items[-1]
+        return None
+
+    def count(self) -> int:
+        return sum(1 for _ in self)
+
+    def all(self) -> Bucket[GeneralManagerType]:
+        return self
+
+    def get(self, **kwargs: Any) -> GroupedManager[GeneralManagerType]:
+        first_value = self.filter(**kwargs).first()
+        if first_value is None:
+            raise ValueError(
+                f"Cannot find {self._manager_class.__name__} with {kwargs}"
+            )
+        return first_value
+
+    def __getitem__(
+        self, item: int | slice
+    ) -> GroupedManager[GeneralManagerType] | GroupBucket[GeneralManagerType]:
+        if isinstance(item, int):
+            return self._data[item]
+        elif isinstance(item, slice):
+            new_data = self._data[item]
+            new_base_data = None
+            for manager in new_data:
+                if new_base_data is None:
+                    new_base_data = manager._data
+                else:
+                    new_base_data = new_base_data | manager._data
+            if new_base_data is None:
+                raise ValueError("Cannot slice an empty GroupBucket")
+            return GroupBucket(self._manager_class, self._group_by_keys, new_base_data)
+        raise TypeError(f"Invalid argument type: {type(item)}. Expected int or slice.")
+
+    def __len__(self) -> int:
+        return self.count()
+
+    def __contains__(self, item: GeneralManagerType) -> bool:
+        return item in self._basis_data
+
+    def sort(
+        self,
+        key: tuple[str] | str,
+        reverse: bool = False,
+    ) -> Bucket[GeneralManagerType]:
+        if isinstance(key, str):
+            key = (key,)
+        if reverse:
+            sorted_data = self._data.sort(
+                key=lambda x: tuple([-getattr(x, k) for k in key])
+            )
+        else:
+            sorted_data = self._data.sort(
+                key=lambda x: tuple([getattr(x, k) for k in key])
+            )
+
+        new_bucket = GroupBucket(
+            self._manager_class, self._group_by_keys, self._basis_data
+        )
+        new_bucket._data = sorted_data
+        return new_bucket
+
+    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.
+        """
+        return GroupBucket(
+            self._manager_class, tuple([*self._group_by_keys, *group_by_keys]), self
+        )
+
+
+class GroupedManager(Generic[GeneralManagerType]):
+    """
+    This class is used to group the data of a GeneralManager.
+    It is used to create a new GeneralManager with the grouped data.
+    """
+
+    def __init__(
+        self,
+        manager_class: Type[GeneralManagerType],
+        group_by_value: dict[str, Any],
+        data: Bucket[GeneralManagerType],
+    ):
+        self._manager_class = manager_class
+        self._group_by_value = group_by_value
+        self._data = data
+        self._grouped_data: dict[str, Any] = {}
+
+    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
+            and self._group_by_value == other._group_by_value
+        )
+
+    def __hash__(self) -> int:
+        return hash(
+            (self._manager_class, frozenset(self._group_by_value.items()), self._data)
+        )
+
+    def __repr__(self) -> str:
+        return f"{self.__class__.__name__}({self._manager_class}, {self._group_by_value}, {self._data})"
+
+    def __iter__(self):
+        for attribute in self._manager_class.Interface.getAttributes().keys():
+            yield attribute, getattr(self, attribute)
+        for attribute, attr_value in self._manager_class.__dict__.items():
+            if isinstance(attr_value, GraphQLProperty):
+                yield attribute, getattr(self, attribute)
+
+    def __getattr__(self, item: str) -> Any:
+        if item in self._group_by_value:
+            return self._group_by_value[item]
+        if item not in self._grouped_data.keys():
+            self._grouped_data[item] = self.combineValue(item)
+        return self._grouped_data[item]
+
+    def combineValue(self, item: str) -> Any:
+        if item == "id":
+            return None
+
+        data_type = (
+            self._manager_class.Interface.getAttributeTypes().get(item, {}).get("type")
+        )
+        if data_type is None and item in self._manager_class.__dict__:
+            attr_value = self._manager_class.__dict__[item]
+            if isinstance(attr_value, GraphQLProperty):
+                type_hints = get_args(attr_value.graphql_type_hint)
+                data_type = (
+                    type_hints[0]
+                    if type_hints
+                    else cast(type, attr_value.graphql_type_hint)
+                )
+        if data_type is None:
+            raise AttributeError(f"{self.__class__.__name__} has no attribute {item}")
+
+        total_data = []
+        for entry in self._data:
+            total_data.append(getattr(entry, item))
+
+        new_data = None
+        if all([i is None for i in total_data]):
+            return new_data
+        total_data = [i for i in total_data if i is not None]
+
+        if issubclass(data_type, (Bucket, GeneralManager)):
+            for entry in total_data:
+                if new_data is None:
+                    new_data = entry
+                else:
+                    new_data = entry | new_data
+        elif issubclass(data_type, list):
+            new_data = []
+            for entry in total_data:
+                new_data.extend(entry)
+        elif issubclass(data_type, dict):
+            new_data = {}
+            for entry in total_data:
+                new_data.update(entry)
+        elif issubclass(data_type, str):
+            new_data = " ".join(total_data)
+        elif issubclass(data_type, (int, float, Measurement)):
+            new_data = sum(total_data)
+        elif issubclass(data_type, (datetime, date, time)):
+            new_data = max(total_data)
+        elif issubclass(data_type, bool):
+            new_data = any(total_data)
+
+        return new_data

general_manager/manager/input.py

@@ -0,0 +1,48 @@
+from __future__ import annotations
+from typing import Iterable, Optional, Callable, List, TypeVar, Generic, Any
+import inspect
+
+from general_manager.manager.generalManager import GeneralManager
+from datetime import date, datetime
+from general_manager.measurement import Measurement
+
+
+INPUT_TYPE = TypeVar("INPUT_TYPE", bound=type)
+
+
+class Input(Generic[INPUT_TYPE]):
+    def __init__(
+        self,
+        type: INPUT_TYPE,
+        possible_values: Optional[Callable | Iterable] = None,
+        depends_on: Optional[List[str]] = None,
+    ):
+        self.type = type
+        self.possible_values = possible_values
+        self.is_manager = issubclass(type, GeneralManager)
+
+        if depends_on is not None:
+            # Verwende die angegebenen Abhängigkeiten
+            self.depends_on = depends_on
+        elif callable(possible_values):
+            # Ermittele Abhängigkeiten automatisch aus den Parametern der Funktion
+            sig = inspect.signature(possible_values)
+            self.depends_on = list(sig.parameters.keys())
+        else:
+            # Keine Abhängigkeiten
+            self.depends_on = []
+
+    def cast(self, value: Any) -> Any:
+        if isinstance(value, self.type):
+            return value
+        if issubclass(self.type, GeneralManager):
+            if isinstance(value, dict):
+                return self.type(**value)  # type: ignore
+            return self.type(id=value)  # type: ignore
+        if self.type == date:
+            return date.fromisoformat(value)
+        if self.type == datetime:
+            return datetime.fromisoformat(value)
+        if self.type == Measurement and isinstance(value, str):
+            return Measurement.from_string(value)
+        return self.type(value)

general_manager/manager/meta.py

@@ -0,0 +1,75 @@
+from __future__ import annotations
+from general_manager.interface.baseInterface import (
+    InterfaceBase,
+)
+from django.conf import settings
+from typing import Any, Type, TYPE_CHECKING, Generic, TypeVar
+
+if TYPE_CHECKING:
+    from general_manager.interface.databaseInterface import ReadOnlyInterface
+    from general_manager.manager.generalManager import GeneralManager
+
+GeneralManagerType = TypeVar("GeneralManagerType", bound="GeneralManager")
+
+
+class GeneralManagerMeta(type):
+    all_classes: list[Type[GeneralManager]] = []
+    read_only_classes: list[Type[ReadOnlyInterface]] = []
+    pending_graphql_interfaces: list[Type[GeneralManager]] = []
+    pending_attribute_initialization: list[Type[GeneralManager]] = []
+    Interface: type[InterfaceBase]
+
+    def __new__(mcs, name: str, bases: tuple[type, ...], attrs: dict[str, Any]) -> type:
+        def createNewGeneralManagerClass(
+            mcs, name: str, bases: tuple[type, ...], attrs: dict[str, Any]
+        ) -> Type[GeneralManager]:
+            return super().__new__(mcs, name, bases, attrs)
+
+        if "Interface" in attrs:
+            interface = attrs.pop("Interface")
+            if not issubclass(interface, InterfaceBase):
+                raise TypeError(
+                    f"Interface must be a subclass of {InterfaceBase.__name__}"
+                )
+            preCreation, postCreation = interface.handleInterface()
+            attrs, interface_cls, model = preCreation(name, attrs, interface)
+            new_class = createNewGeneralManagerClass(mcs, name, bases, attrs)
+            postCreation(new_class, interface_cls, model)
+            mcs.pending_attribute_initialization.append(new_class)
+            mcs.all_classes.append(new_class)
+
+        else:
+            new_class = createNewGeneralManagerClass(mcs, name, bases, attrs)
+
+        if getattr(settings, "AUTOCREATE_GRAPHQL", False):
+            mcs.pending_graphql_interfaces.append(new_class)
+
+        return new_class
+
+    @staticmethod
+    def createAtPropertiesForAttributes(
+        attributes: dict[str, Any], new_class: Type[GeneralManager]
+    ):
+
+        def desciptorMethod(attr_name: str, new_class: type):
+            class Descriptor(Generic[GeneralManagerType]):
+                def __init__(self, attr_name: str, new_class: Type[GeneralManager]):
+                    self.attr_name = attr_name
+                    self.new_class = new_class
+
+                def __get__(
+                    self,
+                    instance: GeneralManager[GeneralManagerType] | None,
+                    owner: type | None = None,
+                ):
+                    if instance is None:
+                        return self.new_class.Interface.getFieldType(self.attr_name)
+                    attribute = instance._attributes[attr_name]
+                    if callable(attribute):
+                        return attribute(instance._interface)
+                    return attribute
+
+            return Descriptor(attr_name, new_class)
+
+        for attr_name in attributes.keys():
+            setattr(new_class, attr_name, desciptorMethod(attr_name, new_class))

general_manager/measurement/__init__.py

@@ -0,0 +1,2 @@
+from .measurement import Measurement
+from .measurementField import MeasurementField