GeneralManager 0.0.0__py3-none-any.whl

general_manager/factory/factories.py

@@ -0,0 +1,287 @@
+from __future__ import annotations
+from typing import TYPE_CHECKING, Type, Callable, Union, Any, TypeVar, Literal, cast
+from factory.declarations import LazyFunction, LazyAttribute, LazyAttributeSequence
+from factory.faker import Faker
+import exrex  # type: ignore
+from django.db import models
+from django.core.validators import RegexValidator
+from factory.django import DjangoModelFactory
+from django.utils import timezone
+import random
+from decimal import Decimal
+from general_manager.measurement.measurement import Measurement
+from general_manager.measurement.measurementField import MeasurementField
+from datetime import date, datetime, time
+
+if TYPE_CHECKING:
+    from general_manager.interface.databaseInterface import (
+        DBBasedInterface,
+    )
+
+modelsModel = TypeVar("modelsModel", bound=models.Model)
+
+
+class AutoFactory(DjangoModelFactory[modelsModel]):
+    """
+    A factory class that automatically generates values for model fields,
+    including handling of unique fields and constraints.
+    """
+
+    interface: Type[DBBasedInterface]
+    _adjustmentMethod: (
+        Callable[..., Union[dict[str, Any], list[dict[str, Any]]]] | None
+    ) = None
+
+    @classmethod
+    def _generate(  # type: ignore
+        cls, strategy: Literal["build", "create"], params: dict[str, Any]
+    ) -> models.Model | list[models.Model]:
+        cls._original_params = params
+        model = getattr(cls._meta, "model")
+        if not issubclass(model, models.Model):
+            raise ValueError("Model must be a type")
+        field_name_list, to_ignore_list = cls.interface.handleCustomFields(model)
+
+        fields = [
+            field
+            for field in model._meta.get_fields()
+            if field.name not in to_ignore_list
+        ]
+        special_fields: list[models.Field[Any, Any]] = [
+            getattr(model, field_name) for field_name in field_name_list
+        ]
+        pre_declations = getattr(cls._meta, "pre_declarations", [])
+        post_declarations = getattr(cls._meta, "post_declarations", [])
+        declared_fields: set[str] = set(pre_declations) | set(post_declarations)
+
+        field_list: list[models.Field[Any, Any] | models.ForeignObjectRel] = [
+            *fields,
+            *special_fields,
+        ]
+
+        for field in field_list:
+            if field.name in [*params, *declared_fields]:
+                continue  # Skip fields that are already set
+            if isinstance(field, models.AutoField) or field.auto_created:
+                continue  # Skip auto fields
+            params[field.name] = get_field_value(field)
+
+        obj: list[models.Model] | models.Model = super()._generate(strategy, params)
+        if isinstance(obj, list):
+            for item in obj:  # type: ignore
+                if not isinstance(item, models.Model):
+                    raise ValueError("Model must be a type")
+                cls._handleManyToManyFieldsAfterCreation(item, params)
+        else:
+            cls._handleManyToManyFieldsAfterCreation(obj, params)
+        return obj
+
+    @classmethod
+    def _handleManyToManyFieldsAfterCreation(
+        cls, obj: models.Model, attrs: dict[str, Any]
+    ) -> None:
+        for field in obj._meta.many_to_many:
+            if field.name in attrs:
+                m2m_values = attrs[field.name]
+            else:
+                m2m_values = get_m2m_field_value(field)
+            if m2m_values:
+                getattr(obj, field.name).set(m2m_values)
+
+    @classmethod
+    def _adjust_kwargs(cls, **kwargs: dict[str, Any]) -> dict[str, Any]:
+        # Remove ManyToMany fields from kwargs before object creation
+        model: Type[models.Model] = getattr(cls._meta, "model")
+        m2m_fields = {field.name for field in model._meta.many_to_many}
+        for field_name in m2m_fields:
+            kwargs.pop(field_name, None)
+        return kwargs
+
+    @classmethod
+    def _create(  # type: ignore
+        cls, model_class: Type[models.Model], *args: list[Any], **kwargs: dict[str, Any]
+    ) -> models.Model | list[models.Model]:
+        kwargs = cls._adjust_kwargs(**kwargs)
+        if cls._adjustmentMethod is not None:
+            return cls.__createWithGenerateFunc(strategy=True, params=kwargs)
+        return cls._modelCreation(model_class, **kwargs)
+
+    @classmethod
+    def _build(  # type: ignore
+        cls, model_class: Type[models.Model], *args: list[Any], **kwargs: dict[str, Any]
+    ) -> models.Model | list[models.Model]:
+        kwargs = cls._adjust_kwargs(**kwargs)
+        if cls._adjustmentMethod is not None:
+            return cls.__createWithGenerateFunc(strategy=False, params=kwargs)
+        return cls._modelBuilding(model_class, **kwargs)
+
+    @classmethod
+    def _modelCreation(
+        cls, model_class: Type[models.Model], **kwargs: dict[str, Any]
+    ) -> models.Model:
+        obj = model_class()
+        for field, value in kwargs.items():
+            setattr(obj, field, value)
+        obj.full_clean()
+        obj.save()
+        return obj
+
+    @classmethod
+    def _modelBuilding(
+        cls, model_class: Type[models.Model], **kwargs: dict[str, Any]
+    ) -> models.Model:
+        obj = model_class()
+        for field, value in kwargs.items():
+            setattr(obj, field, value)
+        return obj
+
+    @classmethod
+    def __createWithGenerateFunc(
+        cls, strategy: bool, params: dict[str, Any]
+    ) -> models.Model | list[models.Model]:
+        model_cls = getattr(cls._meta, "model")
+        if cls._adjustmentMethod is None:
+            raise ValueError("generate_func is not defined")
+        records = cls._adjustmentMethod(**params)
+        if isinstance(records, dict):
+            if strategy:
+                return cls._modelCreation(model_cls, **records)
+            return cls._modelBuilding(model_cls, **records)
+
+        created_objects: list[models.Model] = []
+        for record in records:
+            if strategy:
+                created_objects.append(cls._modelCreation(model_cls, **record))
+            else:
+                created_objects.append(cls._modelBuilding(model_cls, **record))
+        return created_objects
+
+
+def get_field_value(field: models.Field[Any, Any] | models.ForeignObjectRel) -> object:
+    """
+    Returns a suitable value for a given Django model field.
+    """
+    if field.null:
+        if random.choice([True] + 9 * [False]):
+            return None
+
+    if isinstance(field, MeasurementField):
+        base_unit = field.base_unit
+        value = Decimal(str(random.uniform(0, 10_000))[:10])
+        return LazyFunction(lambda: Measurement(value, base_unit))
+    elif isinstance(field, models.CharField):
+        max_length = field.max_length or 100
+        # Check for RegexValidator
+        regex = None
+        for validator in field.validators:
+            if isinstance(validator, RegexValidator):
+                regex = getattr(validator.regex, "pattern", None)
+                break
+        if regex:
+            # Use exrex to generate a string matching the regex
+            return LazyFunction(lambda: exrex.getone(regex))  # type: ignore
+        else:
+            return cast(str, Faker("text", max_nb_chars=max_length))
+    elif isinstance(field, models.TextField):
+        return cast(str, Faker("paragraph"))
+    elif isinstance(field, models.IntegerField):
+        return cast(int, Faker("random_int"))
+    elif isinstance(field, models.DecimalField):
+        max_digits = field.max_digits
+        decimal_places = field.decimal_places
+        left_digits = max_digits - decimal_places
+        return cast(
+            Decimal,
+            Faker(
+                "pydecimal",
+                left_digits=left_digits,
+                right_digits=decimal_places,
+                positive=True,
+            ),
+        )
+    elif isinstance(field, models.FloatField):
+        return cast(float, Faker("pyfloat", positive=True))
+    elif isinstance(field, models.DateField):
+        return cast(date, Faker("date_between", start_date="-1y", end_date="today"))
+    elif isinstance(field, models.DateTimeField):
+        return cast(
+            datetime,
+            Faker(
+                "date_time_between",
+                start_date="-1y",
+                end_date="now",
+                tzinfo=timezone.utc,
+            ),
+        )
+    elif isinstance(field, models.BooleanField):
+        return cast(bool, Faker("pybool"))
+    elif isinstance(field, models.ForeignKey):
+        # Create or get an instance of the related model
+        if hasattr(field.related_model, "_general_manager_class"):
+            related_factory = field.related_model._general_manager_class.Factory
+            return related_factory()
+        else:
+            # If no factory exists, pick a random existing instance
+            related_instances = list(field.related_model.objects.all())
+            if related_instances:
+                return LazyFunction(lambda: random.choice(related_instances))
+            else:
+                raise ValueError(
+                    f"No factory found for {field.related_model.__name__} and no instances found"
+                )
+    elif isinstance(field, models.OneToOneField):
+        # Similar to ForeignKey
+        if hasattr(field.related_model, "_general_manager_class"):
+            related_factory = field.related_model._general_manager_class.Factory
+            return related_factory()
+        else:
+            # If no factory exists, pick a random existing instance
+            related_instances = list(field.related_model.objects.all())
+            if related_instances:
+                return LazyFunction(lambda: random.choice(related_instances))
+            else:
+                raise ValueError(
+                    f"No factory found for {field.related_model.__name__} and no instances found"
+                )
+    elif isinstance(field, models.EmailField):
+        return cast(str, Faker("email"))
+    elif isinstance(field, models.URLField):
+        return cast(str, Faker("url"))
+    elif isinstance(field, models.GenericIPAddressField):
+        return cast(str, Faker("ipv4"))
+    elif isinstance(field, models.UUIDField):
+        return cast(str, Faker("uuid4"))
+    elif isinstance(field, models.DurationField):
+        return cast(time, Faker("time_delta"))
+    else:
+        return None  # For unsupported field types
+
+
+def get_m2m_field_value(field: models.ManyToManyField[Any, Any]) -> list[models.Model]:
+    """
+    Returns a list of instances for a ManyToMany field.
+    """
+    related_factory = globals().get(f"{field.related_model.__name__}Factory")
+    existing_instances = list(field.related_model.objects.all())
+
+    if related_factory:
+        # Use existing instances if available, otherwise create new ones
+        if existing_instances:
+            max_instances = len(existing_instances)
+            num_instances = random.randint(0, min(max_instances, 15))
+            return random.sample(existing_instances, num_instances)
+        else:
+            # No existing instances, create a few
+            num_to_create = random.randint(1, 3)
+            new_instances = [related_factory() for _ in range(num_to_create)]
+            return new_instances
+    else:
+        # No factory exists, use existing instances
+        if existing_instances:
+            max_instances = len(existing_instances)
+            num_instances = random.randint(0, max_instances)
+            return random.sample(existing_instances, num_instances)
+        else:
+            raise ValueError(
+                f"No factory found for {field.related_model.__name__} and no instances found"
+            )

general_manager/factory/lazy_methods.py

@@ -0,0 +1,38 @@
+from typing import Any
+from factory.declarations import LazyFunction, LazyAttribute, LazyAttributeSequence
+import random
+from general_manager.measurement.measurement import Measurement
+from datetime import timedelta, date
+from faker import Faker
+
+fake = Faker()
+
+
+def LazyMeasurement(
+    min_value: int | float, max_value: int | float, unit: str
+) -> LazyFunction:
+    return LazyFunction(
+        lambda: Measurement(str(random.uniform(min_value, max_value))[:10], unit)
+    )
+
+
+def LazyDeltaDate(avg_delta_days: int, base_attribute: str) -> LazyAttribute:
+    return LazyAttribute(
+        lambda obj: (getattr(obj, base_attribute) or date.today())
+        + timedelta(days=random.randint(avg_delta_days // 2, avg_delta_days * 3 // 2))
+    )
+
+
+def LazyProjectName() -> LazyFunction:
+    return LazyFunction(
+        lambda: (
+            f"{fake.word().capitalize()} "
+            f"{fake.word().capitalize()} "
+            f"{fake.random_element(elements=('X', 'Z', 'G'))}"
+            f"-{fake.random_int(min=1, max=1000)}"
+        )
+    )
+
+
+def LazySapNumber() -> LazyAttributeSequence:
+    return LazyAttributeSequence(lambda obj, n: f"60{n:04d}")

general_manager/interface/__init__.py

@@ -0,0 +1,3 @@
+# from .baseInterface import InterfaceBase, Bucket
+# from .databaseInterface import DatabaseInterface, ReadOnlyInterface, DatabaseBucket
+# from .calculationInterface import CalculationInterface, CalculationBucket

general_manager/interface/baseInterface.py

@@ -0,0 +1,308 @@
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from typing import (
+    Type,
+    Generator,
+    TYPE_CHECKING,
+    Any,
+    TypeVar,
+    Generic,
+    Iterable,
+    ClassVar,
+    Callable,
+    TypedDict,
+)
+from datetime import datetime
+from django.conf import settings
+from django.db.models import Model
+from general_manager.auxiliary import args_to_kwargs
+
+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 GroupedManager, GroupBucket
+
+
+GeneralManagerType = TypeVar("GeneralManagerType", bound="GeneralManager")
+type generalManagerClassName = str
+type attributes = dict[str, Any]
+type interfaceBaseClass = Type[InterfaceBase]
+type newlyCreatedInterfaceClass = Type[InterfaceBase]
+type relatedClass = Type[Model] | None
+type newlyCreatedGeneralManagerClass = GeneralManagerMeta
+
+type classPreCreationMethod = Callable[
+    [generalManagerClassName, attributes, interfaceBaseClass],
+    tuple[attributes, interfaceBaseClass, relatedClass],
+]
+
+type classPostCreationMethod = Callable[
+    [newlyCreatedGeneralManagerClass, newlyCreatedInterfaceClass, relatedClass],
+    None,
+]
+
+
+class AttributeTypedDict(TypedDict):
+    """
+    This class is used to define the type of the attributes dictionary.
+    It is used to define the type of the attributes dictionary in the
+    GeneralManager class.
+    """
+
+    type: type
+    default: Any
+    is_required: bool
+    is_editable: bool
+
+
+class InterfaceBase(ABC):
+    _parent_class: ClassVar[Type[Any]]
+    _interface_type: ClassVar[str]
+    input_fields: dict[str, Input]
+
+    def __init__(self, *args: Any, **kwargs: Any):
+        self.identification = self.parseInputFieldsToIdentification(*args, **kwargs)
+        self.formatIdentification()
+
+    def parseInputFieldsToIdentification(
+        self,
+        *args: Any,
+        **kwargs: dict[str, Any],
+    ) -> dict[str, Any]:
+        identification = {}
+        kwargs = args_to_kwargs(args, self.input_fields.keys(), kwargs)
+        # Prüfe auf fehlende oder unerwartete Argumente
+        extra_args = set(kwargs.keys()) - set(self.input_fields.keys())
+        if extra_args:
+            for extra_arg in extra_args:
+                if extra_arg.replace("_id", "") in self.input_fields.keys():
+                    kwargs[extra_arg.replace("_id", "")] = kwargs.pop(extra_arg)
+                else:
+                    raise TypeError(f"Unexpected arguments: {', '.join(extra_args)}")
+
+        missing_args = set(self.input_fields.keys()) - set(kwargs.keys())
+        if missing_args:
+            raise TypeError(f"Missing required arguments: {', '.join(missing_args)}")
+
+        # Verarbeite Felder unter Berücksichtigung von Abhängigkeiten
+        processed = set()
+        while len(processed) < len(self.input_fields):
+            progress_made = False
+            for name, input_field in self.input_fields.items():
+                if name in processed:
+                    continue
+                depends_on = input_field.depends_on
+                if all(dep in processed for dep in depends_on):
+                    value = self.input_fields[name].cast(kwargs[name])
+                    self._process_input(name, value, identification)
+                    identification[name] = value
+                    processed.add(name)
+                    progress_made = True
+            if not progress_made:
+                # Zirkuläre Abhängigkeit erkannt
+                unresolved = set(self.input_fields.keys()) - processed
+                raise ValueError(
+                    f"Circular dependency detected among inputs: {', '.join(unresolved)}"
+                )
+        return identification
+
+    def formatIdentification(self) -> dict[str, Any]:
+        from general_manager.manager.generalManager import GeneralManager
+
+        for key, value in self.identification.items():
+            if isinstance(value, GeneralManager):
+                self.identification[key] = value.identification
+            elif isinstance(value, (list, tuple)):
+                self.identification[key] = [
+                    v.identification if isinstance(v, GeneralManager) else v
+                    for v in value
+                ]
+        return self.identification
+
+    def _process_input(
+        self, name: str, value: Any, identification: dict[str, Any]
+    ) -> None:
+        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 = input_field.possible_values
+            if possible_values is not None:
+                if callable(possible_values):
+                    depends_on = input_field.depends_on
+                    dep_values = {
+                        dep_name: identification.get(dep_name)
+                        for dep_name in depends_on
+                    }
+                    allowed_values = possible_values(**dep_values)
+                elif isinstance(possible_values, Iterable):
+                    allowed_values = possible_values
+                else:
+                    raise TypeError(f"Invalid type for possible_values of input {name}")
+
+                if value not in allowed_values:
+                    raise ValueError(
+                        f"Invalid value for {name}: {value}, allowed: {allowed_values}"
+                    )
+
+    @classmethod
+    def create(cls, *args: Any, **kwargs: Any) -> Any:
+        raise NotImplementedError
+
+    def update(self, *args: Any, **kwargs: Any) -> Any:
+        raise NotImplementedError
+
+    def deactivate(self, *args: Any, **kwargs: Any) -> Any:
+        raise NotImplementedError
+
+    @abstractmethod
+    def getData(self, search_date: datetime | None = None) -> Any:
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    def getAttributeTypes(cls) -> dict[str, AttributeTypedDict]:
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    def getAttributes(cls) -> dict[str, Any]:
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    def filter(cls, **kwargs: Any) -> Bucket[Any]:
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    def exclude(cls, **kwargs: Any) -> Bucket[Any]:
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    def handleInterface(
+        cls,
+    ) -> tuple[
+        classPreCreationMethod,
+        classPostCreationMethod,
+    ]:
+        """
+        This method returns a pre and a post GeneralManager creation method
+        and is called inside the GeneralManagerMeta class to initialize the
+        Interface.
+        The pre creation method is called before the GeneralManager instance
+        is created to modify the kwargs.
+        The post creation method is called after the GeneralManager instance
+        is created to modify the instance and add additional data.
+        """
+        raise NotImplementedError
+
+    @classmethod
+    @abstractmethod
+    def getFieldType(cls, field_name: str) -> type:
+        """
+        Returns the type of the field with the given name.
+        """
+        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 | GroupedManager[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 | GroupedManager[GeneralManagerType] | None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def last(self) -> GeneralManagerType | GroupedManager[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 | GroupedManager[GeneralManagerType]:
+        raise NotImplementedError
+
+    @abstractmethod
+    def __getitem__(
+        self, item: int | slice
+    ) -> (
+        GeneralManagerType
+        | GroupedManager[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)