GeneralManager 0.10.3__py3-none-any.whl → 0.10.4__py3-none-any.whl

general_manager/factory/factories.py

@@ -1,8 +1,8 @@
 from __future__ import annotations
-from typing import Any, cast
+from typing import Any, cast, TYPE_CHECKING
 from factory.declarations import LazyFunction
 from factory.faker import Faker
-import exrex  # type: ignore
+import exrex
 from django.db import models
 from django.core.validators import RegexValidator
 import random
@@ -11,12 +11,17 @@ from general_manager.measurement.measurement import Measurement
 from general_manager.measurement.measurementField import MeasurementField
 from datetime import date, datetime, time, timezone
 
+if TYPE_CHECKING:
+    from general_manager.factory.autoFactory import AutoFactory
 
-def getFieldValue(field: models.Field[Any, Any] | models.ForeignObjectRel) -> object:
+
+def getFieldValue(
+    field: models.Field[Any, Any] | models.ForeignObjectRel,
+) -> object:
     """
-    Generates an appropriate value for a given Django model field for use in testing or data factories.
+    Generate a suitable fake or factory value for a given Django model field, for use in tests or data factories.
     
-    If the field allows null values, there is a 10% chance of returning None. Handles a wide range of Django field types, including measurement, text, numeric, date/time, boolean, relational, and specialized fields, returning a suitable fake or factory-generated value for each. For relational fields (OneToOneField and ForeignKey), attempts to use a factory if available or selects a random existing instance; raises ValueError if neither is possible. Returns None for unsupported field types.
+    Returns a value appropriate for the field type, including support for measurement, text, numeric, date/time, boolean, email, URL, IP address, UUID, duration, and character fields (with regex support). For relational fields (OneToOneField and ForeignKey), attempts to use a related model factory or select a random existing instance; raises ValueError if neither is available. Returns None for unsupported field types or with a 10% chance if the field allows null values.
     """
     if field.null:
         if random.choice([True] + 9 * [False]):
@@ -62,78 +67,103 @@ def getFieldValue(field: models.Field[Any, Any] | models.ForeignObjectRel) -> ob
         return cast(date, Faker("date_between", start_date="-1y", end_date="today"))
     elif isinstance(field, models.BooleanField):
         return cast(bool, Faker("pybool"))
+    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"))
+    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))
+        else:
+            return cast(str, Faker("text", max_nb_chars=max_length))
     elif isinstance(field, models.OneToOneField):
-        if hasattr(field.related_model, "_general_manager_class"):
-            related_factory = field.related_model._general_manager_class.Factory
+        related_model = getRelatedModel(field)
+        if hasattr(related_model, "_general_manager_class"):
+            related_factory = related_model._general_manager_class.Factory  # type: ignore
             return related_factory()
         else:
             # If no factory exists, pick a random existing instance
-            related_instances = list(field.related_model.objects.all())
+            related_instances = list(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"
+                    f"No factory found for {related_model.__name__} and no instances found"
                 )
     elif isinstance(field, models.ForeignKey):
+        related_model = getRelatedModel(field)
         # Create or get an instance of the related model
-        if hasattr(field.related_model, "_general_manager_class"):
+        if hasattr(related_model, "_general_manager_class"):
             create_a_new_instance = random.choice([True, True, False])
             if not create_a_new_instance:
-                existing_instances = list(field.related_model.objects.all())
+                existing_instances = list(related_model.objects.all())
                 if existing_instances:
                     # Pick a random existing instance
                     return LazyFunction(lambda: random.choice(existing_instances))
 
-            related_factory = field.related_model._general_manager_class.Factory
+            related_factory = related_model._general_manager_class.Factory  # type: ignore
             return related_factory()
 
         else:
             # If no factory exists, pick a random existing instance
-            related_instances = list(field.related_model.objects.all())
+            related_instances = list(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"
+                    f"No factory found for {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"))
-    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))
     else:
-        return None  # For unsupported field types
+        return None
+
+
+def getRelatedModel(
+    field: models.ForeignObjectRel | models.Field[Any, Any],
+) -> type[models.Model]:
+    """
+    Return the related model class for a given Django relational field.
+    
+    Raises:
+        ValueError: If the field does not have a related model defined.
+    """
+    related_model = field.related_model
+    if related_model is None:
+        raise ValueError(f"Field {field.name} does not have a related model defined.")
+    if related_model == "self":
+        related_model = field.model
+    return related_model  # For unsupported field types
 
 
 def getManyToManyFieldValue(
     field: models.ManyToManyField,
 ) -> list[models.Model]:
     """
-    Returns a list of instances for a ManyToMany field.
+    Generate a list of model instances to associate with a ManyToMany field for testing or factory purposes.
+    
+    If a related model factory is available, creates new instances as needed. Otherwise, selects from existing instances. Raises a ValueError if neither a factory nor existing instances are available.
+    
+    Returns:
+        list[models.Model]: A list of related model instances for the ManyToMany field.
     """
     related_factory = None
-    related_instances = list(field.related_model.objects.all())
-    if hasattr(field.related_model, "_general_manager_class"):
-        related_factory = field.related_model._general_manager_class.Factory
+    related_model = getRelatedModel(field)
+    related_instances = list(related_model.objects.all())
+    if hasattr(related_model, "_general_manager_class"):
+        related_factory = related_model._general_manager_class.Factory  # type: ignore
 
     min_required = 0 if field.blank else 1
     number_of_instances = random.randint(min_required, 10)
@@ -158,5 +188,5 @@ def getManyToManyFieldValue(
         return existing_instances
     else:
         raise ValueError(
-            f"No factory found for {field.related_model.__name__} and no instances found"
+            f"No factory found for {related_model.__name__} and no instances found"
         )

general_manager/interface/baseInterface.py

@@ -69,12 +69,12 @@ class InterfaceBase(ABC):
         **kwargs: dict[str, Any],
     ) -> dict[str, Any]:
         """
-        Parses and validates input arguments into a structured identification dictionary.
+        Parse and validate input arguments into a dictionary of input field values.
 
-        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.
+        Positional and keyword arguments are mapped to input field names, with normalization of argument names (e.g., removing trailing `_id`). Ensures all required fields are present and no unexpected arguments are provided. Processes input fields in dependency order, casting and validating each value. Raises a `TypeError` for missing or unexpected arguments and a `ValueError` if circular dependencies are detected.
 
         Returns:
-            A dictionary mapping input field names to their validated and cast values.
+            dict[str, Any]: A dictionary mapping input field names to their validated and cast values.
         """
         identification = {}
         kwargs = args_to_kwargs(args, self.input_fields.keys(), kwargs)

general_manager/interface/databaseBasedInterface.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Type, Any, Callable, TYPE_CHECKING, TypeVar, Generic
+from typing import Type, Any, Callable, TYPE_CHECKING, TypeVar, Generic, cast
 from django.db import models
 from datetime import datetime, timedelta
 from general_manager.measurement.measurement import Measurement
@@ -25,13 +25,13 @@ from general_manager.interface.models import (
     GeneralManagerModel,
     getFullCleanMethode,
 )
+from django.contrib.contenttypes.fields import GenericForeignKey
 
 if TYPE_CHECKING:
     from general_manager.rule.rule import Rule
 
 modelsModel = TypeVar("modelsModel", bound=models.Model)
 
-
 MODEL_TYPE = TypeVar("MODEL_TYPE", bound=GeneralManagerBasisModel)
 
 
@@ -43,12 +43,12 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         self,
         *args: list[Any],
         search_date: datetime | None = None,
-        **kwargs: dict[str, Any],
+        **kwargs: Any,
     ):
         """
-        Initialize the interface and load the associated model instance.
-
-        If `search_date` is provided, loads the historical record as of that date; otherwise, loads the current record.
+        Initialize the interface and load the associated model instance by primary key.
+        
+        If a `search_date` is provided, retrieves the historical record as of that date; otherwise, loads the current record.
         """
         super().__init__(*args, **kwargs)
         self.pk = self.identification["id"]
@@ -135,10 +135,10 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
     @classmethod
     def getAttributeTypes(cls) -> dict[str, AttributeTypedDict]:
         """
-        Return a dictionary mapping attribute names to metadata describing their types and properties.
-
-        The dictionary includes all model fields, custom fields, foreign keys, many-to-many, and reverse relation fields. For each attribute, the metadata specifies its Python type (translated from Django field types when possible), whether it is required, editable, derived, and its default value. For related models with a general manager class, the type is set to that class.
-
+        Return a dictionary mapping each attribute name of the model to its type information and metadata.
+        
+        The returned dictionary includes all standard model fields, custom fields, foreign keys, many-to-many, and reverse relation fields, excluding any GenericForeignKey fields. For each attribute, the metadata specifies its Python type (translated from Django field types when possible), whether it is required, editable, derived, and its default value. For related models with a general manager class, the type is set to that class.
+        
         Returns:
             dict[str, AttributeTypedDict]: Mapping of attribute names to their type information and metadata.
         """
@@ -163,7 +163,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         fields: dict[str, AttributeTypedDict] = {}
         field_name_list, to_ignore_list = cls.handleCustomFields(cls._model)
         for field_name in field_name_list:
-            field: models.Field = getattr(cls._model, field_name)
+            field = cast(models.Field, getattr(cls._model, field_name))
             fields[field_name] = {
                 "type": type(field),
                 "is_derived": False,
@@ -174,7 +174,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
 
         for field_name in cls.__getModelFields():
             if field_name not in to_ignore_list:
-                field: models.Field = getattr(cls._model, field_name).field
+                field = cast(models.Field, getattr(cls._model, field_name).field)
                 fields[field_name] = {
                     "type": type(field),
                     "is_derived": False,
@@ -185,20 +185,27 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
 
         for field_name in cls.__getForeignKeyFields():
             field = cls._model._meta.get_field(field_name)
+            if isinstance(field, GenericForeignKey):
+                continue
             related_model = field.related_model
+            if related_model == "self":
+                related_model = cls._model
             if related_model and hasattr(
                 related_model,
                 "_general_manager_class",
             ):
-                related_model = related_model._general_manager_class
+                related_model = related_model._general_manager_class  # type: ignore
 
             elif related_model is not None:
+                default = None
+                if hasattr(field, "default"):
+                    default = field.default  # type: ignore
                 fields[field_name] = {
                     "type": related_model,
                     "is_derived": False,
                     "is_required": not field.null,
                     "is_editable": field.editable,
-                    "default": field.default,
+                    "default": default,
                 }
 
         for field_name, field_call in [
@@ -212,11 +219,17 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
                     raise ValueError("Field name already exists.")
             field = cls._model._meta.get_field(field_name)
             related_model = cls._model._meta.get_field(field_name).related_model
+            if related_model == "self":
+                related_model = cls._model
+            if isinstance(field, GenericForeignKey):
+                continue
+
             if related_model and hasattr(
                 related_model,
                 "_general_manager_class",
             ):
-                related_model = related_model._general_manager_class
+                related_model = related_model._general_manager_class  # type: ignore
+
             if related_model is not None:
                 fields[f"{field_name}_list"] = {
                     "type": related_model,
@@ -234,9 +247,12 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
     @classmethod
     def getAttributes(cls) -> dict[str, Callable[[DBBasedInterface], Any]]:
         """
-        Returns a mapping of attribute names to callables that retrieve their values from a DBBasedInterface instance.
-
-        The returned dictionary includes accessors for custom fields, model fields, foreign keys (optionally returning related interface instances), many-to-many relations, and reverse relations. For related models that have a general manager class, the accessor returns an instance of that class; otherwise, it returns the related object or queryset directly. Raises a ValueError if a field name conflict occurs.
+        Return a dictionary mapping attribute names to callables that retrieve values from a DBBasedInterface instance.
+        
+        The mapping includes accessors for custom fields, standard model fields, foreign keys, many-to-many relations, and reverse relations. For related models with a general manager class, the accessor returns an instance of that class; otherwise, it returns the related object or queryset. Raises a ValueError if a field name conflict is detected.
+         
+        Returns:
+            dict: A dictionary where keys are attribute names and values are callables that extract the corresponding value from a DBBasedInterface instance.
         """
         field_values: dict[str, Any] = {}
 
@@ -258,7 +274,7 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
                 related_model,
                 "_general_manager_class",
             ):
-                generalManagerClass = related_model._general_manager_class
+                generalManagerClass = related_model._general_manager_class  # type: ignore
                 field_values[f"{field_name}"] = (
                     lambda self, field_name=field_name, manager_class=generalManagerClass: manager_class(
                         getattr(self._instance, field_name).pk
@@ -322,13 +338,13 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
     @staticmethod
     def _getCustomFields(model: Type[models.Model] | models.Model) -> list[str]:
         """
-        Returns a list of custom field names defined directly on the model class.
-
-        Args:
+        Return a list of custom field names defined directly as class attributes on the given Django model.
+        
+        Parameters:
             model: The Django model class or instance to inspect.
-
+        
         Returns:
-            A list of field names that are defined as class attributes on the model, not via Django's meta system.
+            A list of field names for fields declared directly on the model class, excluding those defined via Django's meta system.
         """
         return [
             field.name
@@ -337,11 +353,11 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         ]
 
     @classmethod
-    def __getModelFields(cls):
+    def __getModelFields(cls) -> list[str]:
         """
-        Returns a list of model field names that are not many-to-many or related fields.
-
-        Excludes fields representing many-to-many relationships and related models.
+        Return a list of field names for the model that are neither many-to-many nor related fields.
+        
+        Fields representing many-to-many relationships or relations to other models are excluded from the result.
         """
         return [
             field.name
@@ -350,9 +366,9 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         ]
 
     @classmethod
-    def __getForeignKeyFields(cls):
+    def __getForeignKeyFields(cls) -> list[str]:
         """
-        Returns a list of field names for all foreign key and one-to-one relations on the model.
+        Return a list of field names for all foreign key and one-to-one relations on the model, excluding generic foreign keys.
         """
         return [
             field.name
@@ -361,11 +377,11 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         ]
 
     @classmethod
-    def __getManyToManyFields(cls):
+    def __getManyToManyFields(cls) -> list[tuple[str, str]]:
         """
-        Returns a list of tuples containing the names of all many-to-many fields on the model.
-
-        Each tuple consists of the field name repeated twice.
+        Return a list of tuples representing all many-to-many fields on the model.
+        
+        Each tuple contains the field name twice. Fields that are generic foreign keys are excluded.
         """
         return [
             (field.name, field.name)
@@ -374,11 +390,11 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
         ]
 
     @classmethod
-    def __getReverseRelations(cls):
+    def __getReverseRelations(cls) -> list[tuple[str, str]]:
         """
-        Returns a list of tuples representing reverse one-to-many relations for the model.
-
-        Each tuple contains the related field's name and its default related accessor name.
+        Return a list of reverse one-to-many relations for the model, excluding generic foreign keys.
+        
+        Each tuple contains the related field's name and its default related accessor name (e.g., `fieldname_set`).
         """
         return [
             (field.name, f"{field.name}_set")
@@ -485,11 +501,15 @@ class DBBasedInterface(InterfaceBase, Generic[MODEL_TYPE]):
     @classmethod
     def getFieldType(cls, field_name: str) -> type:
         """
-        Returns the type associated with the specified field name.
-
-        If the field is a relation and its related model defines a `_general_manager_class`, that class is returned; otherwise, returns the Django field type.
+        Return the type associated with a given model field name.
+        
+        If the field is a relation and its related model has a `_general_manager_class` attribute, that class is returned; otherwise, returns the Django field type.
         """
         field = cls._model._meta.get_field(field_name)
-        if field.is_relation and field.related_model:
-            return field.related_model._general_manager_class
+        if (
+            field.is_relation
+            and field.related_model
+            and hasattr(field.related_model, "_general_manager_class")
+        ):
+            return field.related_model._general_manager_class  # type: ignore
         return type(field)

general_manager/manager/generalManager.py

@@ -1,5 +1,5 @@
 from __future__ import annotations
-from typing import Generic, Type, Any, TYPE_CHECKING, TypeVar
+from typing import Type, Any, TYPE_CHECKING, Self
 from general_manager.manager.meta import GeneralManagerMeta
 
 from general_manager.api.property import GraphQLProperty
@@ -9,17 +9,9 @@ from general_manager.bucket.baseBucket import Bucket
 
 if TYPE_CHECKING:
     from general_manager.permission.basePermission import BasePermission
-    from general_manager.interface.baseInterface import (
-        InterfaceBase,
-    )
-GeneralManagerType = TypeVar("GeneralManagerType", bound="GeneralManager")
-InterfaceType = TypeVar("InterfaceType", bound="InterfaceBase", covariant=True)
 
 
-class GeneralManager(
-    Generic[GeneralManagerType, InterfaceType], metaclass=GeneralManagerMeta
-):
-    Interface: Type[InterfaceType]
+class GeneralManager(metaclass=GeneralManagerMeta):
     Permission: Type[BasePermission]
     _attributes: dict[str, Any]
 
@@ -49,18 +41,15 @@ class GeneralManager(
 
     def __or__(
         self,
-        other: (
-            GeneralManager[GeneralManagerType, InterfaceType]
-            | Bucket[GeneralManagerType]
-        ),
-    ) -> Bucket[GeneralManagerType]:
+        other: Self | Bucket[Self],
+    ) -> Bucket[Self]:
         """
-        Combine this manager with another manager of the same class or a Bucket using the union operator.
+        Returns a Bucket containing the union of this manager and another manager of the same class or a Bucket.
 
-        If combined with a Bucket, returns the union of the Bucket and this manager. If combined with another manager of the same class, returns a Bucket containing both instances. Raises a TypeError for unsupported types.
+        If `other` is a Bucket, the result is the union of the Bucket and this manager. If `other` is a manager of the same class, the result is a Bucket containing both managers. Raises a TypeError if `other` is not a supported type.
 
         Returns:
-            Bucket[GeneralManagerType]: A Bucket containing the union of the involved managers.
+            Bucket[Self]: A Bucket containing the combined managers.
         """
         if isinstance(other, Bucket):
             return other | self
@@ -90,20 +79,20 @@ class GeneralManager(
         creator_id: int | None = None,
         history_comment: str | None = None,
         ignore_permission: bool = False,
-        **kwargs: dict[str, Any],
-    ) -> GeneralManager[GeneralManagerType, InterfaceType]:
+        **kwargs: Any,
+    ) -> Self:
         """
-        Creates a new managed object using the underlying interface and returns a corresponding manager instance.
+        Create a new managed object via the underlying interface and return a manager instance representing it.
 
-        Performs a permission check if a `Permission` class is defined and permission checks are not ignored. Passes all provided arguments to the interface's `create` method.
+        Performs a permission check unless `ignore_permission` is True. All additional keyword arguments are passed to the interface's `create` method.
 
         Parameters:
-            creator_id (int | None): Optional identifier for the creator of the object.
-            history_comment (str | None): Optional comment for audit or history tracking.
-            ignore_permission (bool): If True, skips the permission check.
+            creator_id (int | None): Optional ID of the user creating the object.
+            history_comment (str | None): Optional comment for audit or history purposes.
+            ignore_permission (bool): If True, bypasses the permission check.
 
         Returns:
-            GeneralManager[GeneralManagerType, InterfaceType]: A new manager instance for the created object.
+            Self: Manager instance for the newly created object.
         """
         if not ignore_permission:
             cls.Permission.checkCreatePermission(kwargs, cls, creator_id)
@@ -118,19 +107,19 @@ class GeneralManager(
         creator_id: int | None = None,
         history_comment: str | None = None,
         ignore_permission: bool = False,
-        **kwargs: dict[str, Any],
-    ) -> GeneralManager[GeneralManagerType, InterfaceType]:
+        **kwargs: Any,
+    ) -> Self:
         """
-        Update the underlying interface object with new data and return a new manager instance.
+        Update the managed object with new data and return a new manager instance reflecting the changes.
 
         Parameters:
-            creator_id (int | None): Optional identifier for the user performing the update.
+            creator_id (int | None): Identifier of the user performing the update, if applicable.
             history_comment (str | None): Optional comment describing the update.
-            ignore_permission (bool): If True, skips permission checks.
-            **kwargs: Additional fields to update on the interface object.
+            ignore_permission (bool): If True, bypasses permission checks.
+            **kwargs: Fields and values to update on the managed object.
 
         Returns:
-            GeneralManager[GeneralManagerType, InterfaceType]: A new manager instance reflecting the updated object.
+            Self: A new manager instance representing the updated object.
         """
         if not ignore_permission:
             self.Permission.checkUpdatePermission(kwargs, self, creator_id)
@@ -147,17 +136,17 @@ class GeneralManager(
         creator_id: int | None = None,
         history_comment: str | None = None,
         ignore_permission: bool = False,
-    ) -> GeneralManager[GeneralManagerType, InterfaceType]:
+    ) -> Self:
         """
-        Deactivates the underlying interface object and returns a new manager instance.
+        Deactivate the managed object and return a new manager instance representing its deactivated state.
 
         Parameters:
-            creator_id (int | None): Optional identifier for the user performing the deactivation.
-            history_comment (str | None): Optional comment describing the reason for deactivation.
-            ignore_permission (bool): If True, skips permission checks.
+            creator_id (int | None): Optional ID of the user performing the deactivation.
+            history_comment (str | None): Optional comment explaining the deactivation.
+            ignore_permission (bool): If True, bypasses permission checks.
 
         Returns:
-            GeneralManager[GeneralManagerType, InterfaceType]: A new instance representing the deactivated object.
+            Self: A new manager instance for the deactivated object.
         """
         if not ignore_permission:
             self.Permission.checkDeletePermission(self, creator_id)
@@ -167,21 +156,42 @@ class GeneralManager(
         return self.__class__(**self.identification)
 
     @classmethod
-    def filter(cls, **kwargs: Any) -> Bucket[GeneralManagerType]:
+    def filter(cls, **kwargs: Any) -> Bucket[Self]:
+        """
+        Return a bucket of managed objects matching the specified filter criteria.
+
+        Parameters:
+            kwargs: Field lookups used to filter the managed objects.
+
+        Returns:
+            Bucket[Self]: A collection of manager instances matching the filter conditions.
+        """
         DependencyTracker.track(
             cls.__name__, "filter", f"{cls.__parse_identification(kwargs)}"
         )
         return cls.Interface.filter(**kwargs)
 
     @classmethod
-    def exclude(cls, **kwargs: Any) -> Bucket[GeneralManagerType]:
+    def exclude(cls, **kwargs: Any) -> Bucket[Self]:
+        """
+        Return a bucket of managed objects excluding those that match the specified criteria.
+
+        Parameters:
+            kwargs: Field-value pairs used to determine which objects to exclude.
+
+        Returns:
+            Bucket[Self]: A collection of managed objects not matching the exclusion criteria.
+        """
         DependencyTracker.track(
             cls.__name__, "exclude", f"{cls.__parse_identification(kwargs)}"
         )
         return cls.Interface.exclude(**kwargs)
 
     @classmethod
-    def all(cls) -> Bucket[GeneralManagerType]:
+    def all(cls) -> Bucket[Self]:
+        """
+        Return a bucket containing all managed objects of this class.
+        """
         return cls.Interface.filter()
 
     @staticmethod