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

general_manager/factory/autoFactory.py

@@ -3,7 +3,7 @@ from typing import TYPE_CHECKING, Type, Callable, Union, Any, TypeVar, Literal
 from django.db import models
 from factory.django import DjangoModelFactory
 from general_manager.factory.factories import getFieldValue, getManyToManyFieldValue
-
+from django.contrib.contenttypes.fields import GenericForeignKey
 
 if TYPE_CHECKING:
     from general_manager.interface.databaseInterface import (
@@ -29,16 +29,16 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
         cls, strategy: Literal["build", "create"], params: dict[str, Any]
     ) -> models.Model | list[models.Model]:
         """
-        Generates and populates a Django model instance or list of instances with automatic field value assignment.
+        Generates and populates one or more Django model instances with automatic field value assignment.
         
-        Automatically assigns values to unset model fields, including handling custom and special fields, and processes many-to-many relationships after instance creation or building. Raises a ValueError if the model is not a subclass of Django's Model.
+        Automatically fills unset model fields, excluding generic foreign keys and auto-created fields, and handles custom and special fields as defined by the interface. After instance creation or building, processes many-to-many relationships. Raises a ValueError if the model is not a subclass of Django's Model.
         
-        Args:
-            strategy: Specifies whether to build (unsaved) or create (saved) the instance(s).
-            params: Field values to use for instance generation; missing fields are auto-filled.
+        Parameters:
+            strategy (Literal["build", "create"]): Determines whether to build (unsaved) or create (saved) the instance(s).
+            params (dict[str, Any]): Field values to use for instance generation; missing fields are auto-filled.
         
         Returns:
-            A single model instance or a list of model instances, depending on the input parameters and strategy.
+            models.Model or list[models.Model]: The generated model instance or list of instances.
         """
         cls._original_params = params
         model = cls._meta.model
@@ -50,6 +50,7 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
             field
             for field in model._meta.get_fields()
             if field.name not in to_ignore_list
+            and not isinstance(field, GenericForeignKey)
         ]
         special_fields: list[models.Field[Any, Any]] = [
             getattr(model, field_name) for field_name in field_name_list
@@ -72,7 +73,7 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
 
         obj: list[models.Model] | models.Model = super()._generate(strategy, params)
         if isinstance(obj, list):
-            for item in obj:  # type: ignore
+            for item in obj:
                 if not isinstance(item, models.Model):
                     raise ValueError("Model must be a type")
                 cls._handleManyToManyFieldsAfterCreation(item, params)
@@ -85,9 +86,9 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
         cls, obj: models.Model, attrs: dict[str, Any]
     ) -> None:
         """
-        Sets many-to-many field values on a Django model instance after creation.
+        Assigns related objects to all many-to-many fields of a Django model instance after it has been created.
         
-        For each many-to-many field, assigns related objects from the provided attributes if available; otherwise, generates values using `getManyToManyFieldValue`. The related objects are set using the Django ORM's `set` method.
+        For each many-to-many field, sets the related objects from the provided attributes if available; otherwise, generates related objects automatically. Uses the Django ORM's `set` method to establish the relationships.
         """
         for field in obj._meta.many_to_many:
             if field.name in attrs:
@@ -101,10 +102,10 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
     def _adjust_kwargs(cls, **kwargs: dict[str, Any]) -> dict[str, Any]:
         # Remove ManyToMany fields from kwargs before object creation
         """
-        Removes many-to-many field entries from keyword arguments before model instance creation.
+        Removes many-to-many fields from the provided keyword arguments before creating or building a model instance.
         
         Returns:
-            The keyword arguments dictionary with many-to-many fields removed.
+            dict[str, Any]: The keyword arguments with any many-to-many fields excluded.
         """
         model: Type[models.Model] = cls._meta.model
         m2m_fields = {field.name for field in model._meta.many_to_many}
@@ -117,15 +118,12 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
         cls, model_class: Type[models.Model], *args: list[Any], **kwargs: dict[str, Any]
     ) -> models.Model | list[models.Model]:
         """
-        Creates and saves a Django model instance or instances, applying optional adjustment logic.
-        
-        If an adjustment method is defined, it is used to generate or modify field values before creation. Otherwise, the model is instantiated and saved with the provided attributes.
+        Create and save a Django model instance or multiple instances, optionally applying custom adjustment logic to field values.
         
-        Args:
-            model_class: The Django model class to instantiate.
+        If an adjustment method is defined, it is used to generate or modify field values before instance creation. Otherwise, the model is instantiated and saved with the provided attributes.
         
         Returns:
-            A saved model instance or a list of instances.
+            A saved model instance or a list of saved instances.
         """
         kwargs = cls._adjust_kwargs(**kwargs)
         if cls._adjustmentMethod is not None:
@@ -137,9 +135,12 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
         cls, model_class: Type[models.Model], *args: list[Any], **kwargs: dict[str, Any]
     ) -> models.Model | list[models.Model]:
         """
-        Constructs an unsaved instance or list of instances of the given Django model class.
+        Builds an unsaved instance or list of instances of the specified Django model class.
         
-        If an adjustment method is defined, it is used to generate or modify field values before building the instance(s). Many-to-many fields are removed from the keyword arguments prior to instantiation.
+        If an adjustment method is defined, it is used to generate or modify field values before building. Many-to-many fields are excluded from the keyword arguments prior to instantiation.
+        
+        Returns:
+            models.Model or list[models.Model]: The unsaved model instance or list of instances.
         """
         kwargs = cls._adjust_kwargs(**kwargs)
         if cls._adjustmentMethod is not None:
@@ -153,9 +154,9 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
         cls, model_class: Type[models.Model], **kwargs: dict[str, Any]
     ) -> models.Model:
         """
-        Creates and saves a Django model instance with the provided field values.
+        Create, validate, and save a Django model instance with the specified field values.
         
-        Initializes the model, assigns attributes from keyword arguments, validates the instance using `full_clean()`, and saves it to the database.
+        Initializes the model, assigns attributes from keyword arguments, performs validation with `full_clean()`, and saves the instance to the database.
         
         Returns:
             The saved Django model instance.
@@ -172,14 +173,14 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
         cls, model_class: Type[models.Model], **kwargs: dict[str, Any]
     ) -> models.Model:
         """
-        Constructs an unsaved instance of the specified Django model with provided field values.
+        Constructs an unsaved Django model instance with the specified field values.
         
-        Args:
-            model_class: The Django model class to instantiate.
-            **kwargs: Field values to set on the model instance.
+        Parameters:
+            model_class (Type[models.Model]): The Django model class to instantiate.
+            **kwargs: Field values to assign to the model instance.
         
         Returns:
-            An unsaved Django model instance with attributes set from kwargs.
+            models.Model: An unsaved instance of the specified model with attributes set from kwargs.
         """
         obj = model_class()
         for field, value in kwargs.items():
@@ -191,17 +192,16 @@ class AutoFactory(DjangoModelFactory[modelsModel]):
         cls, use_creation_method: bool, params: dict[str, Any]
     ) -> models.Model | list[models.Model]:
         """
-        Generates one or more model instances using the adjustment method for field values.
+        Creates or builds one or more model instances using the adjustment method to generate field values.
         
-        If the adjustment method returns a single dictionary, creates or builds a single model instance.
-        If it returns a list of dictionaries, creates or builds multiple instances accordingly.
+        If the adjustment method returns a single dictionary, a single instance is created or built. If it returns a list of dictionaries, multiple instances are created or built accordingly.
         
-        Args:
-            use_creation_method: If True, saves instances to the database; otherwise, builds unsaved instances.
-            params: Parameters to pass to the adjustment method for generating field values.
+        Parameters:
+            use_creation_method (bool): If True, instances are saved to the database; if False, instances are built but not saved.
+            params (dict[str, Any]): Arguments passed to the adjustment method for generating field values.
         
         Returns:
-            A single model instance or a list of model instances, depending on the adjustment method's output.
+            models.Model or list[models.Model]: The created or built model instance(s).
         
         Raises:
             ValueError: If the adjustment method is not defined.

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)