Improved support for custom fields

Author: abondar

CHANGELOG.md

@@ -4,6 +4,20 @@ All notable changes to this project will be documented in this file.
 
 The format is based on [Keep a Changelog](https://keepachangelog.com/).
 
+## 0.1.2
+
+### Fixed
+
+- Custom Django field types (e.g. `CustomIDField(CharField)`) are now resolved
+  via MRO fallback when their `get_internal_type()` returns a name not in the
+  field map. The library walks the field's ancestor classes to find a supported
+  parent type, so models with custom primary key fields no longer lose their
+  only data field and fail silently.
+- Fixed `KeyError` / `ConnectionError` during Tortoise ORM initialization when
+  a model with only unsupported fields was referenced by ForeignKey from another
+  model. Failed models are now removed from the internal class name map so
+  downstream FK references are gracefully skipped instead of crashing.
+
 ## 0.1.1
 
 ### Fixed

django_tortoise/apps.py

@@ -73,6 +73,7 @@ def ready(self):
         for django_model, label, model_info in eligible:
             tortoise_model = generate_tortoise_model_full(model_info, class_name_map=class_name_map)
             if tortoise_model is None:
+                class_name_map.pop(django_model, None)
                 skipped_count += 1
                 continue
 

django_tortoise/code_generator.py

@@ -16,7 +16,7 @@
 from collections.abc import Callable
 from dataclasses import dataclass, field
 
-from django_tortoise.fields import ON_DELETE_MAP
+from django_tortoise.fields import ON_DELETE_MAP, resolve_internal_type
 from django_tortoise.introspection import FieldInfo, ModelInfo
 
 logger = logging.getLogger("django_tortoise")
@@ -402,14 +402,15 @@ def render_field_source(field_info: FieldInfo) -> str | None:
 
     Returns ``None`` if no renderer is registered for the field's internal_type.
     """
-    renderer = SOURCE_FIELD_MAP.get(field_info.internal_type)
-    if renderer is None:
+    resolved_type = resolve_internal_type(field_info, SOURCE_FIELD_MAP)
+    if resolved_type is None:
         logger.warning(
             "Unsupported Django field type '%s' on field '%s'. Skipping.",
             field_info.internal_type,
             field_info.name,
         )
         return None
+    renderer = SOURCE_FIELD_MAP[resolved_type]
     return renderer(field_info)
 
 

django_tortoise/fields.py

@@ -66,21 +66,66 @@ def _common_kwargs(field_info: FieldInfo) -> dict[str, Any]:
     return kwargs
 
 
+def resolve_internal_type(field_info: FieldInfo, field_map: dict[str, Any]) -> str | None:
+    """
+    Resolve a Django field's internal type to a known key in *field_map*.
+
+    If ``field_info.internal_type`` is already present in *field_map*, it is
+    returned immediately.  Otherwise, when ``field_info.django_field`` is
+    available, the function walks the Django field class's MRO looking for
+    an ancestor whose ``__name__`` is a key in *field_map*.
+
+    Returns ``None`` when no match is found (or when ``django_field`` is
+    ``None`` and the type is unknown).
+    """
+    import django.db.models
+
+    if field_info.internal_type in field_map:
+        return field_info.internal_type
+
+    if field_info.django_field is None:
+        return None
+
+    field_cls = type(field_info.django_field)
+    for ancestor in field_cls.__mro__:
+        # Skip the leaf class itself (already tried via internal_type).
+        if ancestor is field_cls:
+            continue
+        # Skip django.db.models.Field (returns self.__class__.__name__,
+        # which would give the leaf class name again).
+        if ancestor is django.db.models.Field:
+            continue
+        # Skip object.
+        if ancestor is object:
+            continue
+        if ancestor.__name__ in field_map:
+            logger.debug(
+                "Custom field type '%s' on '%s' resolved to '%s' via MRO fallback.",
+                field_info.internal_type,
+                field_info.name,
+                ancestor.__name__,
+            )
+            return ancestor.__name__
+
+    return None
+
+
 def convert_field(field_info: FieldInfo) -> tortoise_fields.Field | None:
     """
     Convert a FieldInfo to a Tortoise field instance.
 
     Returns None if no converter is registered for the field's internal_type,
     logging a warning in that case.
     """
-    converter = FIELD_MAP.get(field_info.internal_type)
-    if converter is None:
+    resolved_type = resolve_internal_type(field_info, FIELD_MAP)
+    if resolved_type is None:
         logger.warning(
             "Unsupported Django field type '%s' on field '%s'. Skipping.",
             field_info.internal_type,
             field_info.name,
         )
         return None
+    converter = FIELD_MAP[resolved_type]
     return converter(field_info)
 
 

django_tortoise/management/commands/generate_tortoise_models.py

@@ -83,8 +83,10 @@ def handle(self, *args, **options):
         models_by_app = defaultdict(list)
         for _django_model, _label, model_info in eligible:
             result = render_model_source(model_info, tortoise_app_name, class_name_map)
-            if result is not None:
-                models_by_app[model_info.app_label].append(result)
+            if result is None:
+                class_name_map.pop(model_info.model_class, None)
+                continue
+            models_by_app[model_info.app_label].append(result)
 
         # Create output directory if needed
         os.makedirs(output_dir, exist_ok=True)

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "django-tortoise-objects"
-version = "0.1.1"
+version = "0.1.2"
 description = "Bridge Django ORM models to Tortoise ORM for truly async database access"
 readme = "README.md"
 license = {text = "Apache-2.0"}

tests/test_code_generator.py

@@ -945,3 +945,81 @@ def test_on_delete_do_nothing_maps_to_no_action(self):
         assert result is not None
         _, source = result
         assert "OnDelete.NO_ACTION" in source
+
+
+# ---------------------------------------------------------------------------
+# MRO fallback tests for render_field_source
+# ---------------------------------------------------------------------------
+
+
+class TestRenderFieldSourceMROFallback:
+    """MRO fallback resolves custom field types in source rendering."""
+
+    def test_render_field_source_custom_field_mro_fallback(self):
+        """Custom CharField subclass resolves via MRO in source rendering."""
+        from django.db import models as django_models
+
+        class CustomIDField(django_models.CharField):
+            def get_internal_type(self):
+                return "CustomIDField"
+
+        django_field = CustomIDField(max_length=36)
+        info = _make_field_info(
+            name="custom_id",
+            internal_type="CustomIDField",
+            max_length=36,
+            primary_key=True,
+            django_field=django_field,
+        )
+        result = render_field_source(info)
+        assert result is not None
+        assert "fields.CharField(" in result
+
+    def test_render_field_source_custom_field_no_django_field(self):
+        """Unknown type with django_field=None returns None in source rendering."""
+        info = _make_field_info(
+            internal_type="CustomUnknownField",
+            django_field=None,
+        )
+        result = render_field_source(info)
+        assert result is None
+
+    def test_render_model_source_with_custom_pk_field(self):
+        """Model with custom PK field generates valid ModelSourceResult."""
+        from django.db import models as django_models
+
+        class CustomIDField(django_models.CharField):
+            def get_internal_type(self):
+                return "CustomIDField"
+
+        django_field = CustomIDField(max_length=36)
+
+        fi = _make_field_info(
+            name="id",
+            internal_type="CustomIDField",
+            column="id",
+            max_length=36,
+            primary_key=True,
+            django_field=django_field,
+        )
+
+        class _DummyModel:
+            __name__ = "CustomPKModel"
+            __module__ = "tests.testapp.models"
+
+        model_info = ModelInfo(
+            model_class=_DummyModel,
+            app_label="test",
+            model_name="custompkmodel",
+            db_table="test_custompkmodel",
+            fields=[fi],
+            unique_together=[],
+            is_abstract=False,
+            is_proxy=False,
+            is_managed=True,
+            pk_name="id",
+        )
+        result = render_model_source(model_info, "django_tortoise", {})
+        assert result is not None
+        assert isinstance(result, ModelSourceResult)
+        assert "fields.CharField(" in result.source