Fix error with index on textfield, clear error for models

Author: abondar

CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+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.1
+
+### Fixed
+
+- Model creation errors now include the Django model name in the message
+  (e.g. `Failed to create Tortoise model 'ArticleTortoise' for Django model 'blog.article': …`)
+  instead of only showing the raw Tortoise exception.
+- Stopped mapping `unique` and `db_index` attributes to generated Tortoise
+  fields. The library relies on Django's existing database schema, so
+  Tortoise-level index declarations are unnecessary and caused
+  `ConfigurationError` for field types that reject them (e.g. `TextField`
+  with `unique=True`).

django_tortoise/code_generator.py

@@ -63,14 +63,13 @@ def _common_kwargs_source(field_info: FieldInfo) -> dict[str, str]:
 
     Mirrors ``fields._common_kwargs()`` but returns source-code strings
     instead of runtime values.
+
+    Note: ``unique`` and ``db_index`` are intentionally NOT emitted.
+    The library relies on the existing Django-managed database schema.
     """
     kwargs: dict[str, str] = {}
     if field_info.null:
         kwargs["null"] = "True"
-    if field_info.unique:
-        kwargs["unique"] = "True"
-    if field_info.db_index:
-        kwargs["db_index"] = "True"
     if field_info.primary_key:
         kwargs["primary_key"] = "True"
     # source_field when column differs from name

django_tortoise/fields.py

@@ -40,16 +40,17 @@ def _common_kwargs(field_info: FieldInfo) -> dict[str, Any]:
     """
     Extract common kwargs shared by most Tortoise fields.
 
-    Maps null, unique, db_index, primary_key, source_field (when DB column
+    Maps null, primary_key, source_field (when DB column
     differs from field name), and default values.
+
+    Note: ``unique`` and ``db_index`` are intentionally NOT mapped.
+    The library relies on the existing Django-managed database schema,
+    so Tortoise-level index/unique declarations are unnecessary and can
+    cause errors (e.g. ``TextField`` does not support ``unique`` in Tortoise).
     """
     kwargs: dict[str, Any] = {}
     if field_info.null:
         kwargs["null"] = True
-    if field_info.unique:
-        kwargs["unique"] = True
-    if field_info.db_index:
-        kwargs["db_index"] = True
     if field_info.primary_key:
         kwargs["primary_key"] = True
     # Map db_column -> source_field

django_tortoise/generator.py

@@ -57,14 +57,20 @@ def generate_tortoise_model(
     meta_class = _build_meta_class(model_info, tortoise_fields, tortoise_app_name)
     class_name = f"{model_info.model_class.__name__}Tortoise"
 
-    tortoise_model = type(
-        class_name,
-        (tortoise_models.Model,),
-        {
-            "Meta": meta_class,
-            **tortoise_fields,
-        },
-    )
+    try:
+        tortoise_model = type(
+            class_name,
+            (tortoise_models.Model,),
+            {
+                "Meta": meta_class,
+                **tortoise_fields,
+            },
+        )
+    except Exception as exc:
+        raise type(exc)(
+            f"Failed to create Tortoise model '{class_name}' for Django model "
+            f"'{model_info.app_label}.{model_info.model_name}': {exc}"
+        ) from exc
 
     logger.debug(
         "Generated Tortoise model '%s' for Django model '%s.%s' (table: %s, fields: %d)",
@@ -127,14 +133,20 @@ def generate_tortoise_model_full(
     meta_class = _build_meta_class(model_info, tortoise_fields, tortoise_app_name)
     class_name = f"{model_info.model_class.__name__}Tortoise"
 
-    tortoise_model = type(
-        class_name,
-        (tortoise_models.Model,),
-        {
-            "Meta": meta_class,
-            **tortoise_fields,
-        },
-    )
+    try:
+        tortoise_model = type(
+            class_name,
+            (tortoise_models.Model,),
+            {
+                "Meta": meta_class,
+                **tortoise_fields,
+            },
+        )
+    except Exception as exc:
+        raise type(exc)(
+            f"Failed to create Tortoise model '{class_name}' for Django model "
+            f"'{model_info.app_label}.{model_info.model_name}': {exc}"
+        ) from exc
 
     logger.debug(
         "Generated Tortoise model '%s' for Django model '%s.%s' "

tests/test_code_generator.py

@@ -98,20 +98,30 @@ class _DummyComment:
 class TestCommonKwargsSource:
     """Tests for _common_kwargs_source."""
 
-    def test_null_and_unique(self):
-        """TC-1.1: produces correct kwargs for null, unique."""
-        info = _make_field_info(null=True, unique=True)
+    def test_null_kwarg(self):
+        """TC-1.1: produces correct kwargs for null."""
+        info = _make_field_info(null=True)
         result = _common_kwargs_source(info)
         assert result["null"] == "True"
-        assert result["unique"] == "True"
 
-    def test_db_index_and_primary_key(self):
-        """TC-1.1: produces correct kwargs for db_index, primary_key."""
-        info = _make_field_info(db_index=True, primary_key=True)
+    def test_unique_not_in_output(self):
+        """unique is not included in kwargs source (DB schema handles it)."""
+        info = _make_field_info(unique=True)
+        result = _common_kwargs_source(info)
+        assert "unique" not in result
+
+    def test_primary_key_kwarg(self):
+        """TC-1.1: produces correct kwargs for primary_key."""
+        info = _make_field_info(primary_key=True)
         result = _common_kwargs_source(info)
-        assert result["db_index"] == "True"
         assert result["primary_key"] == "True"
 
+    def test_db_index_not_in_output(self):
+        """db_index is not included in kwargs source (DB schema handles it)."""
+        info = _make_field_info(db_index=True)
+        result = _common_kwargs_source(info)
+        assert "db_index" not in result
+
     def test_simple_literal_default_int(self):
         """TC-1.2: handles int default."""
         info = _make_field_info(has_default=True, default=42)

tests/test_fields.py

@@ -277,16 +277,17 @@ def test_null_field(self):
         result = convert_field(info)
         assert result.null is True
 
-    def test_unique_field(self):
+    def test_unique_not_mapped(self):
+        """unique is not mapped to Tortoise (DB schema handles it)."""
         info = _make_field_info(internal_type="IntegerField", unique=True)
         result = convert_field(info)
-        assert result.unique is True
+        assert result.unique is False
 
-    def test_db_index_field(self):
+    def test_db_index_not_mapped(self):
+        """db_index is not mapped to Tortoise (DB schema handles it)."""
         info = _make_field_info(internal_type="IntegerField", db_index=True)
         result = convert_field(info)
-        # Tortoise stores db_index as 'index' on the field instance
-        assert result.index is True
+        assert result.index is False
 
     def test_source_field_mapping(self):
         info = _make_field_info(

tests/test_generator.py

@@ -5,10 +5,45 @@
 classes from introspected Django model metadata.
 """
 
+import pytest
 from tortoise import models as tortoise_models
 
-from django_tortoise.generator import generate_tortoise_model
-from django_tortoise.introspection import ModelInfo, introspect_model
+from django_tortoise import generator
+from django_tortoise.generator import generate_tortoise_model, generate_tortoise_model_full
+from django_tortoise.introspection import FieldInfo, ModelInfo, introspect_model
+
+
+def _make_field_info(**overrides) -> FieldInfo:
+    """Helper to create FieldInfo with sensible defaults."""
+    defaults = dict(
+        name="test_field",
+        internal_type="CharField",
+        column="test_field",
+        primary_key=False,
+        null=False,
+        unique=False,
+        has_default=False,
+        default=None,
+        max_length=100,
+        max_digits=None,
+        decimal_places=None,
+        db_index=False,
+        choices=None,
+        enum_type=None,
+        is_relation=False,
+        related_model=None,
+        related_model_label=None,
+        on_delete=None,
+        related_name=None,
+        is_self_referential=False,
+        many_to_many=False,
+        through_model=None,
+        through_db_table=None,
+        is_auto_field=False,
+        django_field=None,
+    )
+    defaults.update(overrides)
+    return FieldInfo(**defaults)
 
 
 class TestGenerateBasicModel:
@@ -256,3 +291,51 @@ def test_unique_together_with_all_data_fields(self):
         assert tortoise_model is not None
         assert hasattr(tortoise_model.Meta, "unique_together")
         assert ("a", "b") in tortoise_model.Meta.unique_together
+
+
+class TestModelCreationErrorContext:
+    """Errors during model creation include model/field context."""
+
+    @pytest.fixture()
+    def failing_model_info(self):
+        fi = _make_field_info(
+            name="id",
+            internal_type="AutoField",
+            column="id",
+            primary_key=True,
+            is_auto_field=True,
+            max_length=None,
+        )
+        return ModelInfo(
+            model_class=type("MyModel", (), {}),
+            app_label="myapp",
+            model_name="mymodel",
+            db_table="myapp_mymodel",
+            fields=[fi],
+            unique_together=[],
+            is_abstract=False,
+            is_proxy=False,
+            is_managed=True,
+            pk_name="id",
+        )
+
+    @pytest.fixture()
+    def patch_failing_model(self, monkeypatch):
+        """Replace tortoise_models.Model with a class whose metaclass raises."""
+
+        class FailingModel:
+            def __init_subclass__(cls, **kwargs):
+                raise RuntimeError("simulated metaclass error")
+
+        fake_module = type("FakeModule", (), {"Model": FailingModel})()
+        monkeypatch.setattr(generator, "tortoise_models", fake_module)
+
+    def test_error_includes_model_context(self, failing_model_info, patch_failing_model):
+        """When type() raises during model creation, the error includes model context."""
+        with pytest.raises(RuntimeError, match=r"myapp\.mymodel"):
+            generate_tortoise_model(failing_model_info)
+
+    def test_error_includes_model_context_full(self, failing_model_info, patch_failing_model):
+        """generate_tortoise_model_full() also includes model context on error."""
+        with pytest.raises(RuntimeError, match=r"myapp\.mymodel"):
+            generate_tortoise_model_full(failing_model_info)