GeneralManager 0.0.0__py3-none-any.whl

general_manager/api/mutation.py

@@ -0,0 +1,143 @@
+import inspect
+from typing import get_type_hints, Optional, Union, List, Tuple, get_origin, get_args
+import graphene
+
+from general_manager.api.graphql import GraphQL
+from general_manager.manager.generalManager import GeneralManager
+
+
+def snake_to_pascal(s: str) -> str:
+    return "".join(p.title() for p in s.split("_"))
+
+
+def snake_to_camel(s: str) -> str:
+    parts = s.split("_")
+    return parts[0] + "".join(p.title() for p in parts[1:])
+
+
+def graphQlMutation(needs_role: Optional[str] = None, auth_required: bool = False):
+    """
+    Decorator to generate a graphene.Mutation from a function and register it.
+    :param auth_required: if True, enforces that info.context.user is authenticated.
+    """
+
+    def decorator(fn):
+        sig = inspect.signature(fn)
+        hints = get_type_hints(fn)
+
+        # Mutation name in PascalCase
+        mutation_name = snake_to_camel(fn.__name__)
+
+        # Build Arguments inner class dynamically
+        arg_fields = {}
+        for name, param in sig.parameters.items():
+            if name == "info":
+                continue
+            ann = hints.get(name)
+            if ann is None:
+                raise TypeError(
+                    f"Missing type hint for parameter {name} in {fn.__name__}"
+                )
+            required = True
+            default = param.default
+            has_default = default is not inspect._empty
+
+            # Prepare kwargs
+            kwargs = {}
+            if required:
+                kwargs["required"] = True
+            if has_default:
+                kwargs["default_value"] = default
+
+            # Handle Optional[...] → not required
+            origin = get_origin(ann)
+            if origin is Union and type(None) in get_args(ann):
+                required = False
+                # extract inner type
+                ann = [a for a in get_args(ann) if a is not type(None)][0]
+
+            # Resolve list types to List scalar
+            if get_origin(ann) is list or get_origin(ann) is List:
+                inner = get_args(ann)[0]
+                field = graphene.List(
+                    GraphQL._mapFieldToGrapheneBaseType(inner)(**kwargs)
+                )
+            else:
+                if isinstance(ann, GeneralManager):
+                    field = graphene.ID(**kwargs)
+                else:
+                    field = GraphQL._mapFieldToGrapheneBaseType(ann)(**kwargs)
+
+            arg_fields[name] = field
+
+        Arguments = type("Arguments", (), arg_fields)
+
+        # Build output fields: success, errors, + fn return types
+        outputs = {
+            "success": graphene.Boolean(required=True),
+            "errors": graphene.List(graphene.String),
+        }
+        return_ann: type | tuple[type] | None = hints.get("return")
+        if return_ann is None:
+            raise TypeError(f"Mutation {fn.__name__} missing return annotation")
+
+        # Unpack tuple return or single
+        out_types = (
+            list(get_args(return_ann))
+            if get_origin(return_ann) in (tuple, Tuple)
+            else [return_ann]
+        )
+        for out in out_types:
+            if not isinstance(out, type):
+                raise TypeError(
+                    f"Mutation {fn.__name__} return type {out} is not a type"
+                )
+            name = out.__name__
+            field_name = name[0].lower() + name[1:]
+            outputs[field_name] = GraphQL._mapFieldToGrapheneRead(out, field_name)
+
+        # Define mutate method
+        def _mutate(root, info, **kwargs):
+            # Auth check
+            if auth_required and not getattr(info.context, "user", None):
+                return mutation_class(
+                    **{"success": False, "errors": ["Authentication required"]}
+                )
+            try:
+                result = fn(info, **kwargs)
+                data = {}
+                if isinstance(result, tuple):
+                    # unpack according to outputs ordering after success/errors
+                    for (field, _), val in zip(
+                        outputs.items(), [None, None] + list(result)
+                    ):
+                        # skip success/errors
+                        if field in ("success", "errors"):
+                            continue
+                        data[field] = val
+                else:
+                    only = next(k for k in outputs if k not in ("success", "errors"))
+                    data[only] = result
+                data["success"] = True
+                data["errors"] = []
+                return mutation_class(**data)
+            except Exception as e:
+                return mutation_class(**{"success": False, "errors": [str(e)]})
+
+        # Assemble class dict
+        class_dict = {
+            "Arguments": Arguments,
+            "__doc__": fn.__doc__,
+            "mutate": staticmethod(_mutate),
+        }
+        class_dict.update(outputs)
+
+        # Create Mutation class
+        mutation_class = type(mutation_name, (graphene.Mutation,), class_dict)
+
+        if mutation_class.__name__ not in GraphQL._mutations:
+            GraphQL._mutations[mutation_class.__name__] = mutation_class
+
+        return fn
+
+    return decorator

general_manager/api/property.py

@@ -0,0 +1,20 @@
+from typing import Any, Callable, get_type_hints
+
+
+class GraphQLProperty(property):
+    def __init__(self, fget: Callable[..., Any], doc: str | None = None):
+        super().__init__(fget, doc=doc)
+        self.is_graphql_resolver = True
+        self.graphql_type_hint = get_type_hints(fget).get("return", None)
+
+
+def graphQlProperty(func: Callable[..., Any]):
+    from general_manager.cache.cacheDecorator import cached
+
+    """
+    Dekorator für GraphQL-Feld-Resolver, der automatisch:
+    - die Methode als benutzerdefiniertes Property registriert,
+    - die Resolver-Informationen speichert,
+    - den Field-Typ aus dem Type-Hint ableitet.
+    """
+    return GraphQLProperty(cached()(func))

general_manager/apps.py

@@ -0,0 +1,83 @@
+from django.apps import AppConfig
+import graphene
+from django.conf import settings
+from django.urls import path
+from graphene_django.views import GraphQLView
+from importlib import import_module
+from general_manager.manager.generalManager import GeneralManager
+from general_manager.manager.meta import GeneralManagerMeta
+from general_manager.manager.input import Input
+from general_manager.api.property import graphQlProperty
+from general_manager.api.graphql import GraphQL
+
+
+class GeneralmanagerConfig(AppConfig):
+    default_auto_field = "django.db.models.BigAutoField"
+    name = "general_manager"
+
+    def ready(self):
+
+        for general_manager_class in GeneralManagerMeta.all_classes:
+            attributes = getattr(general_manager_class.Interface, "input_fields", {})
+            for attribute_name, attribute in attributes.items():
+                if isinstance(attribute, Input) and issubclass(
+                    attribute.type, GeneralManager
+                ):
+                    connected_manager = attribute.type
+                    func = lambda x, attribute_name=attribute_name: general_manager_class.filter(
+                        **{attribute_name: x}
+                    )
+
+                    func.__annotations__ = {"return": general_manager_class}
+                    setattr(
+                        connected_manager,
+                        f"{general_manager_class.__name__.lower()}_list",
+                        graphQlProperty(func),
+                    )
+
+        for (
+            general_manager_class
+        ) in GeneralManagerMeta.pending_attribute_initialization:
+            attributes = general_manager_class.Interface.getAttributes()
+            setattr(general_manager_class, "_attributes", attributes)
+            GeneralManagerMeta.createAtPropertiesForAttributes(
+                attributes, general_manager_class
+            )
+
+        if getattr(settings, "AUTOCREATE_GRAPHQL", False):
+
+            for general_manager_class in GeneralManagerMeta.pending_graphql_interfaces:
+                GraphQL.createGraphqlInterface(general_manager_class)
+                GraphQL.createGraphqlMutation(general_manager_class)
+
+            query_class = type("Query", (graphene.ObjectType,), GraphQL._query_fields)
+            GraphQL._query_class = query_class
+
+            mutation_class = type(
+                "Mutation",
+                (graphene.ObjectType,),
+                {
+                    name: mutation.Field()
+                    for name, mutation in GraphQL._mutations.items()
+                },
+            )
+            GraphQL._mutation_class = mutation_class
+
+            schema = graphene.Schema(
+                query=GraphQL._query_class,
+                mutation=GraphQL._mutation_class,
+            )
+            self.add_graphql_url(schema)
+
+    def add_graphql_url(self, schema):
+        root_url_conf_path = getattr(settings, "ROOT_URLCONF", None)
+        graph_ql_url = getattr(settings, "GRAPHQL_URL", "graphql/")
+        if not root_url_conf_path:
+            raise Exception("ROOT_URLCONF not found in settings")
+        urlconf = import_module(root_url_conf_path)
+        urlconf.urlpatterns.append(
+            path(
+                graph_ql_url,
+                GraphQLView.as_view(graphiql=True, schema=schema),
+            )
+        )

general_manager/auxiliary/__init__.py

@@ -0,0 +1,2 @@
+from .noneToZero import noneToZero
+from .argsToKwargs import args_to_kwargs

general_manager/auxiliary/argsToKwargs.py

@@ -0,0 +1,25 @@
+from typing import Any, Iterable
+
+
+def args_to_kwargs(
+    args: tuple[Any, ...], keys: Iterable[Any], existing_kwargs: dict | None = None
+):
+    """
+    Wandelt *args in **kwargs um und kombiniert sie mit bestehenden **kwargs.
+
+    :param args: Tuple der positional arguments (z. B. *args).
+    :param keys: Liste der Schlüssel, die den Argumenten zugeordnet werden.
+    :param existing_kwargs: Optionales Dictionary mit bereits existierenden Schlüssel-Wert-Zuordnungen.
+    :return: Dictionary mit kombinierten **kwargs.
+    """
+    keys = list(keys)
+    if len(args) > len(keys):
+        raise ValueError("Mehr args als keys vorhanden.")
+
+    kwargs = {key: value for key, value in zip(keys, args)}
+    if existing_kwargs and any(key in kwargs for key in existing_kwargs):
+        raise ValueError("Konflikte in bestehenden kwargs.")
+    if existing_kwargs:
+        kwargs.update(existing_kwargs)
+
+    return kwargs

general_manager/auxiliary/filterParser.py

@@ -0,0 +1,97 @@
+from typing import Any, Callable, List
+
+
+def parse_filters(
+    filter_kwargs: dict[str, Any], possible_values: dict[str, Any]
+) -> dict[str, dict]:
+    from general_manager.manager.generalManager import GeneralManager
+
+    filters = {}
+    for kwarg, value in filter_kwargs.items():
+        parts = kwarg.split("__")
+        field_name = parts[0]
+        if field_name not in possible_values:
+            raise ValueError(f"Unknown input field '{field_name}' in filter")
+        input_field = possible_values[field_name]
+
+        lookup = "__".join(parts[1:]) if len(parts) > 1 else ""
+
+        if issubclass(input_field.type, GeneralManager):
+            # Sammle die Filter-Keyword-Argumente für das InputField
+            if lookup == "":
+                lookup = "id"
+                if not isinstance(value, GeneralManager):
+                    value = input_field.cast(value)
+                value = getattr(value, "id", value)
+            filters.setdefault(field_name, {}).setdefault("filter_kwargs", {})[
+                lookup
+            ] = value
+        else:
+            # Erstelle Filterfunktionen für Nicht-Bucket-Typen
+            if isinstance(value, (list, tuple)) and not isinstance(
+                value, input_field.type
+            ):
+                casted_value = [input_field.cast(v) for v in value]
+            else:
+                casted_value = input_field.cast(value)
+            filter_func = create_filter_function(lookup, casted_value)
+            filters.setdefault(field_name, {}).setdefault("filter_funcs", []).append(
+                filter_func
+            )
+    return filters
+
+
+def create_filter_function(lookup_str: str, value: Any) -> Callable[[Any], bool]:
+    parts = lookup_str.split("__") if lookup_str else []
+    if parts and parts[-1] in [
+        "exact",
+        "lt",
+        "lte",
+        "gt",
+        "gte",
+        "contains",
+        "startswith",
+        "endswith",
+        "in",
+    ]:
+        lookup = parts[-1]
+        attr_path = parts[:-1]
+    else:
+        lookup = "exact"
+        attr_path = parts
+
+    def filter_func(x):
+        for attr in attr_path:
+            if hasattr(x, attr):
+                x = getattr(x, attr)
+            else:
+                return False
+        return apply_lookup(x, lookup, value)
+
+    return filter_func
+
+
+def apply_lookup(x: Any, lookup: str, value: Any) -> bool:
+    try:
+        if lookup == "exact":
+            return x == value
+        elif lookup == "lt":
+            return x < value
+        elif lookup == "lte":
+            return x <= value
+        elif lookup == "gt":
+            return x > value
+        elif lookup == "gte":
+            return x >= value
+        elif lookup == "contains" and isinstance(x, str):
+            return value in x
+        elif lookup == "startswith" and isinstance(x, str):
+            return x.startswith(value)
+        elif lookup == "endswith" and isinstance(x, str):
+            return x.endswith(value)
+        elif lookup == "in":
+            return x in value
+        else:
+            return False
+    except TypeError as e:
+        return False

general_manager/auxiliary/noneToZero.py

@@ -0,0 +1,12 @@
+from typing import Optional, TypeVar, Literal
+from general_manager.measurement import Measurement
+
+VALUE = TypeVar("VALUE", int, float, Measurement)
+
+
+def noneToZero(
+    value: Optional[VALUE],
+) -> VALUE | Literal[0]:
+    if value is None:
+        return 0
+    return value

general_manager/cache/cacheDecorator.py

@@ -0,0 +1,72 @@
+from typing import Callable, Optional
+from functools import wraps
+from django.core.cache import cache as django_cache
+from hashlib import sha256
+from general_manager.cache.cacheTracker import DependencyTracker
+from general_manager.cache.dependencyIndex import record_dependencies, get_full_index
+
+
+def cached(timeout: Optional[int] = None) -> Callable:
+    """
+    Decorator to cache the result of a function for a specified timeout.
+    If no timeout is provided, the cache will expire when a dependency is invalidated.
+    """
+
+    def decorator(func: Callable) -> Callable:
+
+        @wraps(func)
+        def wrapper(*args, **kwargs):
+            from general_manager.manager.generalManager import GeneralManager, Bucket
+
+            django_cache_key = sha256(
+                f"{func.__module__}.{func.__name__}:{args}:{kwargs}".encode(),
+                usedforsecurity=False,
+            ).hexdigest()
+            cached_result = django_cache.get(django_cache_key)
+            if cached_result is not None:
+                return cached_result
+            # Dependency Tracking aktivieren
+            with DependencyTracker() as dependencies:
+                result = func(*args, **kwargs)
+
+            def collect_model_dependencies(obj):
+                """Rekursiv Django-Model-Instanzen im Objekt finden."""
+                if isinstance(obj, GeneralManager):
+                    yield (
+                        obj.__class__.__name__,
+                        "identification",
+                        f"{obj.identification}",
+                    )
+                elif isinstance(obj, Bucket):
+                    yield (obj._manager_class.__name__, "filter", f"{obj.filters}")
+                    yield (obj._manager_class.__name__, "exclude", f"{obj.excludes}")
+                elif isinstance(obj, dict):
+                    for v in obj.values():
+                        yield from collect_model_dependencies(v)
+                elif isinstance(obj, (list, tuple, set)):
+                    for item in obj:
+                        yield from collect_model_dependencies(item)
+
+            if args and isinstance(args[0], GeneralManager):
+                self = args[0]
+                for attr_val in self.__dict__.values():
+                    for dependency_tuple in collect_model_dependencies(attr_val):
+                        dependencies.add(dependency_tuple)
+
+            for dependency_tuple in collect_model_dependencies(args):
+                dependencies.add(dependency_tuple)
+            for dependency_tuple in collect_model_dependencies(kwargs):
+                dependencies.add(dependency_tuple)
+
+            django_cache.set(django_cache_key, result, timeout)
+
+            if dependencies and not timeout:
+                record_dependencies(
+                    django_cache_key,
+                    dependencies,
+                )
+            return result
+
+        return wrapper
+
+    return decorator

general_manager/cache/cacheTracker.py

@@ -0,0 +1,33 @@
+import threading
+from general_manager.cache.dependencyIndex import general_manager_name
+from typing import Any, Literal
+
+
+# Thread-lokale Variable zur Speicherung der Abhängigkeiten
+_dependency_storage = threading.local()
+
+
+class DependencyTracker:
+    def __enter__(
+        self,
+    ) -> set[
+        tuple[general_manager_name, Literal["filter", "exclude", "identification"], str]
+    ]:
+        _dependency_storage.dependencies = set()
+        return _dependency_storage.dependencies
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        # Optional: Aufräumen oder weitere Verarbeitung
+        pass
+
+
+def addDependency(class_name: str, operation: str, identifier: str) -> None:
+    """
+    Adds a dependency to the dependency storage.
+    """
+    if hasattr(_dependency_storage, "dependencies"):
+        dependencies: set[
+            tuple[general_manager_name, Literal["filter", "exclude", "id"], str]
+        ] = _dependency_storage.dependencies
+
+        _dependency_storage.dependencies.add((class_name, operation, identifier))