async def test_describe_model_uuidpk_native(self):
        val = Tortoise.describe_model(UUIDPkModel, serializable=False)

        self.assertEqual(
            val,
            {
                "name":
                "models.UUIDPkModel",
                "app":
                "models",
                "table":
                "uuidpkmodel",
                "abstract":
                False,
                "description":
                None,
                "unique_together": [],
                "pk_field": {
                    "name": "id",
                    "field_type": fields.UUIDField,
                    "db_column": "id",
                    "python_type": uuid.UUID,
                    "generated": False,
                    "nullable": False,
                    "unique": False,
                    "indexed": False,
                    "default": uuid.uuid4,
                    "description": None,
                },
                "data_fields": [],
                "fk_fields": [],
                "backward_fk_fields": [{
                    "name": "children",
                    "field_type": fields.BackwardFKRelation,
                    "python_type": UUIDFkRelatedModel,
                    "generated": False,
                    "nullable": False,
                    "unique": False,
                    "indexed": False,
                    "default": None,
                    "description": None,
                }],
                "m2m_fields": [{
                    "name": "peers",
                    "field_type": fields.ManyToManyField,
                    "python_type": UUIDM2MRelatedModel,
                    "generated": False,
                    "nullable": False,
                    "unique": False,
                    "indexed": False,
                    "default": None,
                    "description": None,
                }],
            },
        )
Esempio n. 2
0
 async def get_resource(self, resource: str, exclude_readonly=False, exclude_m2m_field=True):
     assert self._inited, 'must call init() first!'
     model = getattr(self.models, resource)  # type:Type[Model]
     model_describe = Tortoise.describe_model(model)
     fields, search_fields = await self._build_resource_from_model_describe(resource, model, model_describe,
                                                                            exclude_readonly, exclude_m2m_field)
     return Resource(
         title=model_describe.get('description') or resource.title(),
         fields=fields,
         searchFields=search_fields
     )
Esempio n. 3
0
async def list_all(request):
    menu = Tortoise.apps.get("models")
    model_describe = Tortoise.describe_model(Book)
    fk_fields = [m["name"] for m in model_describe.get("fk_fields")]
    backward_fk_fields = [
        m["name"] for m in model_describe.get("backward_fk_fields")
    ]
    field_name_list = [
        i for i in Book._meta.fields_map if i not in backward_fk_fields
    ]
    if fk_fields:
        results = (await Book.all().prefetch_related(*fk_fields))
    else:
        results = (await Book.all().values(*field_name_list))
    return templates.TemplateResponse(
        "list.html", {
            "request": request,
            "results": results,
            "field_name_list": [i for i in field_name_list],
            "menu": [i for i in menu]
        })
Esempio n. 4
0
    async def test_describe_model_json(self):
        val = Tortoise.describe_model(JSONFields)

        self.assertEqual(
            val,
            {
                "name":
                "models.JSONFields",
                "app":
                "models",
                "table":
                "jsonfields",
                "abstract":
                False,
                "description":
                None,
                "unique_together": [],
                "pk_field": {
                    "name": "id",
                    "field_type": "IntField",
                    "db_column": "id",
                    "db_field_types": {
                        "": "INT"
                    },
                    "python_type": "int",
                    "generated": True,
                    "nullable": False,
                    "unique": True,
                    "indexed": True,
                    "default": None,
                    "description": None,
                },
                "data_fields": [
                    {
                        "name": "data",
                        "field_type": "JSONField",
                        "db_column": "data",
                        "db_field_types": {
                            "": "TEXT",
                            "postgres": "JSONB"
                        },
                        "python_type": ["dict", "list"],
                        "generated": False,
                        "nullable": False,
                        "unique": False,
                        "indexed": False,
                        "default": None,
                        "description": None,
                    },
                    {
                        "name": "data_null",
                        "field_type": "JSONField",
                        "db_column": "data_null",
                        "db_field_types": {
                            "": "TEXT",
                            "postgres": "JSONB"
                        },
                        "python_type": ["dict", "list"],
                        "generated": False,
                        "nullable": True,
                        "unique": False,
                        "indexed": False,
                        "default": None,
                        "description": None,
                    },
                    {
                        "name": "data_default",
                        "field_type": "JSONField",
                        "db_column": "data_default",
                        "db_field_types": {
                            "": "TEXT",
                            "postgres": "JSONB"
                        },
                        "python_type": ["dict", "list"],
                        "generated": False,
                        "nullable": False,
                        "unique": False,
                        "indexed": False,
                        "default": "{'a': 1}",
                        "description": None,
                    },
                ],
                "fk_fields": [],
                "backward_fk_fields": [],
                "o2o_fields": [],
                "backward_o2o_fields": [],
                "m2m_fields": [],
            },
        )
Esempio n. 5
0
    async def test_describe_model_uuidpk_relatednull(self):
        val = Tortoise.describe_model(UUIDFkRelatedNullModel,
                                      serializable=True)

        self.assertEqual(
            val,
            {
                "abstract":
                False,
                "app":
                "models",
                "backward_fk_fields": [],
                "backward_o2o_fields": [],
                "data_fields": [
                    {
                        "db_column": "name",
                        "db_field_types": {
                            "": "VARCHAR(50)"
                        },
                        "default": None,
                        "description": None,
                        "field_type": "CharField",
                        "generated": False,
                        "indexed": False,
                        "name": "name",
                        "nullable": True,
                        "python_type": "str",
                        "unique": False,
                    },
                    {
                        "db_column": "model_id",
                        "db_field_types": {
                            "": "CHAR(36)",
                            "postgres": "UUID"
                        },
                        "default": None,
                        "description": None,
                        "field_type": "UUIDField",
                        "generated": False,
                        "indexed": False,
                        "name": "model_id",
                        "nullable": True,
                        "python_type": "uuid.UUID",
                        "unique": False,
                    },
                    {
                        "db_column": "parent_id",
                        "db_field_types": {
                            "": "CHAR(36)",
                            "postgres": "UUID"
                        },
                        "default": None,
                        "description": None,
                        "field_type": "UUIDField",
                        "generated": False,
                        "indexed": True,
                        "name": "parent_id",
                        "nullable": True,
                        "python_type": "uuid.UUID",
                        "unique": True,
                    },
                ],
                "description":
                None,
                "fk_fields": [{
                    "default": None,
                    "description": None,
                    "field_type": "ForeignKeyFieldInstance",
                    "generated": False,
                    "indexed": False,
                    "name": "model",
                    "nullable": True,
                    "python_type": "models.UUIDPkModel",
                    "raw_field": "model_id",
                    "unique": False,
                }],
                "m2m_fields": [],
                "name":
                "models.UUIDFkRelatedNullModel",
                "o2o_fields": [{
                    "default": None,
                    "description": None,
                    "field_type": "OneToOneFieldInstance",
                    "generated": False,
                    "indexed": True,
                    "name": "parent",
                    "nullable": True,
                    "python_type": "models.UUIDPkModel",
                    "raw_field": "parent_id",
                    "unique": True,
                }],
                "pk_field": {
                    "db_column": "id",
                    "db_field_types": {
                        "": "CHAR(36)",
                        "postgres": "UUID"
                    },
                    "default": "<function uuid.uuid4>",
                    "description": None,
                    "field_type": "UUIDField",
                    "generated": False,
                    "indexed": True,
                    "name": "id",
                    "nullable": False,
                    "python_type": "uuid.UUID",
                    "unique": True,
                },
                "table":
                "uuidfkrelatednullmodel",
                "unique_together": [],
            },
        )
Esempio n. 6
0
    async def test_describe_model_uuidpk(self):
        val = Tortoise.describe_model(UUIDPkModel)

        self.assertEqual(
            val,
            {
                "name":
                "models.UUIDPkModel",
                "app":
                "models",
                "table":
                "uuidpkmodel",
                "abstract":
                False,
                "description":
                None,
                "unique_together": [],
                "pk_field": {
                    "name": "id",
                    "field_type": "UUIDField",
                    "db_column": "id",
                    "db_field_types": {
                        "": "CHAR(36)",
                        "postgres": "UUID"
                    },
                    "python_type": "uuid.UUID",
                    "generated": False,
                    "nullable": False,
                    "unique": True,
                    "indexed": True,
                    "default": "<function uuid.uuid4>",
                    "description": None,
                },
                "data_fields": [],
                "fk_fields": [],
                "backward_fk_fields": [
                    {
                        "name": "children",
                        "field_type": "BackwardFKRelation",
                        "python_type": "models.UUIDFkRelatedModel",
                        "generated": False,
                        "nullable": False,
                        "unique": False,
                        "indexed": False,
                        "default": None,
                        "description": None,
                    },
                ],
                "o2o_fields": [],
                "backward_o2o_fields": [],
                "m2m_fields": [{
                    "name": "peers",
                    "field_type": "ManyToManyFieldInstance",
                    "python_type": "models.UUIDM2MRelatedModel",
                    "generated": False,
                    "nullable": False,
                    "unique": False,
                    "indexed": False,
                    "default": None,
                    "description": None,
                }],
            },
        )
Esempio n. 7
0
    async def test_describe_model_source_native(self):
        val = Tortoise.describe_model(SourceFields, serializable=False)

        self.assertEqual(
            val,
            {
                "name":
                "models.SourceFields",
                "app":
                "models",
                "table":
                "sometable",
                "abstract":
                False,
                "description":
                "Source mapped fields",
                "unique_together": [["chars", "blip"]],
                "pk_field": {
                    "name": "eyedee",
                    "field_type": fields.IntField,
                    "db_column": "sometable_id",
                    "db_field_types": {
                        "": "INT"
                    },
                    "python_type": int,
                    "generated": True,
                    "nullable": False,
                    "unique": True,
                    "indexed": True,
                    "default": None,
                    "description": "Da PK",
                },
                "data_fields": [
                    {
                        "name": "chars",
                        "field_type": fields.CharField,
                        "db_column": "some_chars_table",
                        "db_field_types": {
                            "": "VARCHAR(50)"
                        },
                        "python_type": str,
                        "generated": False,
                        "nullable": False,
                        "unique": False,
                        "indexed": True,
                        "default": None,
                        "description": "Some chars",
                    },
                    {
                        "name": "blip",
                        "field_type": fields.CharField,
                        "db_column": "da_blip",
                        "db_field_types": {
                            "": "VARCHAR(50)"
                        },
                        "python_type": str,
                        "generated": False,
                        "nullable": False,
                        "unique": False,
                        "indexed": False,
                        "default": "BLIP",
                        "description": None,
                    },
                    {
                        "name": "fk_id",
                        "field_type": fields.IntField,
                        "db_column": "fk_sometable",
                        "db_field_types": {
                            "": "INT"
                        },
                        "python_type": int,
                        "generated": False,
                        "nullable": True,
                        "unique": False,
                        "indexed": False,
                        "default": None,
                        "description": "Tree!",
                    },
                    {
                        "name": "o2o_id",
                        "field_type": fields.IntField,
                        "db_column": "o2o_sometable",
                        "db_field_types": {
                            "": "INT"
                        },
                        "python_type": int,
                        "generated": False,
                        "nullable": True,
                        "unique": True,
                        "indexed": True,
                        "default": None,
                        "description": "Line",
                    },
                ],
                "fk_fields": [{
                    "name": "fk",
                    "field_type": ForeignKeyFieldInstance,
                    "raw_field": "fk_id",
                    "python_type": SourceFields,
                    "generated": False,
                    "nullable": True,
                    "unique": False,
                    "indexed": False,
                    "default": None,
                    "description": "Tree!",
                }],
                "backward_fk_fields": [{
                    "name": "fkrev",
                    "field_type": BackwardFKRelation,
                    "python_type": SourceFields,
                    "generated": False,
                    "nullable": True,
                    "unique": False,
                    "indexed": False,
                    "default": None,
                    "description": "Tree!",
                }],
                "o2o_fields": [{
                    "default": None,
                    "description": "Line",
                    "field_type": OneToOneFieldInstance,
                    "generated": False,
                    "indexed": True,
                    "name": "o2o",
                    "nullable": True,
                    "python_type": SourceFields,
                    "raw_field": "o2o_id",
                    "unique": True,
                }],
                "backward_o2o_fields": [{
                    "default": None,
                    "description": "Line",
                    "field_type": fields.BackwardOneToOneRelation,
                    "generated": False,
                    "indexed": False,
                    "name": "o2o_rev",
                    "nullable": True,
                    "python_type": SourceFields,
                    "unique": False,
                }],
                "m2m_fields": [
                    {
                        "name": "rel_to",
                        "field_type": ManyToManyFieldInstance,
                        "python_type": SourceFields,
                        "generated": False,
                        "nullable": False,
                        "unique": False,
                        "indexed": False,
                        "default": None,
                        "description": "M2M to myself",
                    },
                    {
                        "name": "rel_from",
                        "field_type": ManyToManyFieldInstance,
                        "python_type": SourceFields,
                        "generated": False,
                        "nullable": False,
                        "unique": False,
                        "indexed": False,
                        "default": None,
                        "description": "M2M to myself",
                    },
                ],
            },
        )
Esempio n. 8
0
    async def test_describe_model_straight(self):
        val = Tortoise.describe_model(StraightFields)

        self.assertEqual(
            val,
            {
                "name":
                "models.StraightFields",
                "app":
                "models",
                "table":
                "straightfields",
                "abstract":
                False,
                "description":
                "Straight auto-mapped fields",
                "unique_together": [["chars", "blip"]],
                "pk_field": {
                    "name": "eyedee",
                    "field_type": "IntField",
                    "db_column": "eyedee",
                    "db_field_types": {
                        "": "INT"
                    },
                    "python_type": "int",
                    "generated": True,
                    "nullable": False,
                    "unique": True,
                    "indexed": True,
                    "default": None,
                    "description": "Da PK",
                },
                "data_fields": [
                    {
                        "name": "chars",
                        "field_type": "CharField",
                        "db_column": "chars",
                        "db_field_types": {
                            "": "VARCHAR(50)"
                        },
                        "python_type": "str",
                        "generated": False,
                        "nullable": False,
                        "unique": False,
                        "indexed": True,
                        "default": None,
                        "description": "Some chars",
                    },
                    {
                        "name": "blip",
                        "field_type": "CharField",
                        "db_column": "blip",
                        "db_field_types": {
                            "": "VARCHAR(50)"
                        },
                        "python_type": "str",
                        "generated": False,
                        "nullable": False,
                        "unique": False,
                        "indexed": False,
                        "default": "BLIP",
                        "description": None,
                    },
                    {
                        "name": "fk_id",
                        "field_type": "IntField",
                        "db_column": "fk_id",
                        "db_field_types": {
                            "": "INT"
                        },
                        "python_type": "int",
                        "generated": False,
                        "nullable": True,
                        "unique": False,
                        "indexed": False,
                        "default": None,
                        "description": "Tree!",
                    },
                    {
                        "db_column": "o2o_id",
                        "db_field_types": {
                            "": "INT"
                        },
                        "default": None,
                        "description": "Line",
                        "field_type": "IntField",
                        "generated": False,
                        "indexed": True,
                        "name": "o2o_id",
                        "nullable": True,
                        "python_type": "int",
                        "unique": True,
                    },
                ],
                "fk_fields": [{
                    "name": "fk",
                    "field_type": "ForeignKeyFieldInstance",
                    "raw_field": "fk_id",
                    "python_type": "models.StraightFields",
                    "generated": False,
                    "nullable": True,
                    "unique": False,
                    "indexed": False,
                    "default": None,
                    "description": "Tree!",
                }],
                "backward_fk_fields": [{
                    "name": "fkrev",
                    "field_type": "BackwardFKRelation",
                    "python_type": "models.StraightFields",
                    "generated": False,
                    "nullable": True,
                    "unique": False,
                    "indexed": False,
                    "default": None,
                    "description": "Tree!",
                }],
                "o2o_fields": [{
                    "default": None,
                    "description": "Line",
                    "field_type": "OneToOneFieldInstance",
                    "generated": False,
                    "indexed": True,
                    "name": "o2o",
                    "nullable": True,
                    "python_type": "models.StraightFields",
                    "raw_field": "o2o_id",
                    "unique": True,
                }],
                "backward_o2o_fields": [{
                    "default": None,
                    "description": "Line",
                    "field_type": "BackwardOneToOneRelation",
                    "generated": False,
                    "indexed": False,
                    "name": "o2o_rev",
                    "nullable": True,
                    "python_type": "models.StraightFields",
                    "unique": False,
                }],
                "m2m_fields": [
                    {
                        "name": "rel_to",
                        "field_type": "ManyToManyFieldInstance",
                        "python_type": "models.StraightFields",
                        "generated": False,
                        "nullable": False,
                        "unique": False,
                        "indexed": False,
                        "default": None,
                        "description": "M2M to myself",
                    },
                    {
                        "name": "rel_from",
                        "field_type": "ManyToManyFieldInstance",
                        "python_type": "models.StraightFields",
                        "generated": False,
                        "nullable": False,
                        "unique": False,
                        "indexed": False,
                        "default": None,
                        "description": "M2M to myself",
                    },
                ],
            },
        )
    async def test_describe_model_json_native(self):
        val = Tortoise.describe_model(JSONFields, serializable=False)

        self.assertEqual(
            val,
            {
                "name":
                "models.JSONFields",
                "app":
                "models",
                "table":
                "jsonfields",
                "abstract":
                False,
                "description":
                None,
                "unique_together": [],
                "pk_field": {
                    "name": "id",
                    "field_type": fields.IntField,
                    "db_column": "id",
                    "python_type": int,
                    "generated": True,
                    "nullable": False,
                    "unique": False,
                    "indexed": False,
                    "default": None,
                    "description": None,
                },
                "data_fields": [
                    {
                        "name": "data",
                        "field_type": fields.JSONField,
                        "db_column": "data",
                        "python_type": (dict, list),
                        "generated": False,
                        "nullable": False,
                        "unique": False,
                        "indexed": False,
                        "default": None,
                        "description": None,
                    },
                    {
                        "name": "data_null",
                        "field_type": fields.JSONField,
                        "db_column": "data_null",
                        "python_type": (dict, list),
                        "generated": False,
                        "nullable": True,
                        "unique": False,
                        "indexed": False,
                        "default": None,
                        "description": None,
                    },
                    {
                        "name": "data_default",
                        "field_type": fields.JSONField,
                        "db_column": "data_default",
                        "python_type": (dict, list),
                        "generated": False,
                        "nullable": False,
                        "unique": False,
                        "indexed": False,
                        "default": {
                            "a": 1
                        },
                        "description": None,
                    },
                ],
                "fk_fields": [],
                "backward_fk_fields": [],
                "m2m_fields": [],
            },
        )
    async def test_describe_model_source(self):
        val = Tortoise.describe_model(SourceFields)

        self.assertEqual(
            val,
            {
                "name":
                "models.SourceFields",
                "app":
                "models",
                "table":
                "sometable",
                "abstract":
                False,
                "description":
                "Source mapped fields",
                "unique_together": [["chars", "blip"]],
                "pk_field": {
                    "name": "id",
                    "field_type": "IntField",
                    "db_column": "sometable_id",
                    "python_type": "int",
                    "generated": True,
                    "nullable": False,
                    "unique": False,
                    "indexed": False,
                    "default": None,
                    "description": "Da PK",
                },
                "data_fields": [
                    {
                        "name": "chars",
                        "field_type": "CharField",
                        "db_column": "some_chars_table",
                        "python_type": "str",
                        "generated": False,
                        "nullable": False,
                        "unique": False,
                        "indexed": True,
                        "default": None,
                        "description": "Some chars",
                    },
                    {
                        "name": "blip",
                        "field_type": "CharField",
                        "db_column": "da_blip",
                        "python_type": "str",
                        "generated": False,
                        "nullable": False,
                        "unique": False,
                        "indexed": False,
                        "default": "BLIP",
                        "description": None,
                    },
                    {
                        "name": "fk_id",
                        "field_type": "IntField",
                        "db_column": "fk_sometable",
                        "python_type": "int",
                        "generated": False,
                        "nullable": True,
                        "unique": False,
                        "indexed": False,
                        "default": None,
                        "description": "Tree!",
                    },
                ],
                "fk_fields": [{
                    "name": "fk",
                    "field_type": "ForeignKeyField",
                    "raw_field": "fk_id",
                    "python_type": "models.SourceFields",
                    "generated": False,
                    "nullable": True,
                    "unique": False,
                    "indexed": False,
                    "default": None,
                    "description": "Tree!",
                }],
                "backward_fk_fields": [{
                    "name": "fkrev",
                    "field_type": "BackwardFKRelation",
                    "python_type": "models.SourceFields",
                    "generated": False,
                    "nullable": False,
                    "unique": False,
                    "indexed": False,
                    "default": None,
                    "description": "Tree!",
                }],
                "m2m_fields": [
                    {
                        "name": "rel_to",
                        "field_type": "ManyToManyField",
                        "python_type": "models.SourceFields",
                        "generated": False,
                        "nullable": False,
                        "unique": False,
                        "indexed": False,
                        "default": None,
                        "description": "M2M to myself",
                    },
                    {
                        "name": "rel_from",
                        "field_type": "ManyToManyField",
                        "python_type": "models.SourceFields",
                        "generated": False,
                        "nullable": False,
                        "unique": False,
                        "indexed": False,
                        "default": None,
                        "description": "M2M to myself",
                    },
                ],
            },
        )
    async def test_describe_model_straight_native(self):
        val = Tortoise.describe_model(StraightFields, serializable=False)

        self.assertEqual(
            val,
            {
                "name":
                "models.StraightFields",
                "app":
                "models",
                "table":
                "straightfields",
                "abstract":
                False,
                "description":
                "Straight auto-mapped fields",
                "unique_together": [["chars", "blip"]],
                "pk_field": {
                    "name": "id",
                    "field_type": fields.IntField,
                    "db_column": "id",
                    "python_type": int,
                    "generated": True,
                    "nullable": False,
                    "unique": False,
                    "indexed": False,
                    "default": None,
                    "description": "Da PK",
                },
                "data_fields": [
                    {
                        "name": "chars",
                        "field_type": fields.CharField,
                        "db_column": "chars",
                        "python_type": str,
                        "generated": False,
                        "nullable": False,
                        "unique": False,
                        "indexed": True,
                        "default": None,
                        "description": "Some chars",
                    },
                    {
                        "name": "blip",
                        "field_type": fields.CharField,
                        "db_column": "blip",
                        "python_type": str,
                        "generated": False,
                        "nullable": False,
                        "unique": False,
                        "indexed": False,
                        "default": "BLIP",
                        "description": None,
                    },
                    {
                        "name": "fk_id",
                        "field_type": fields.IntField,
                        "db_column": "fk_id",
                        "python_type": int,
                        "generated": False,
                        "nullable": True,
                        "unique": False,
                        "indexed": False,
                        "default": None,
                        "description": "Tree!",
                    },
                ],
                "fk_fields": [{
                    "name": "fk",
                    "field_type": fields.ForeignKeyField,
                    "raw_field": "fk_id",
                    "python_type": StraightFields,
                    "generated": False,
                    "nullable": True,
                    "unique": False,
                    "indexed": False,
                    "default": None,
                    "description": "Tree!",
                }],
                "backward_fk_fields": [{
                    "name": "fkrev",
                    "field_type": fields.BackwardFKRelation,
                    "python_type": StraightFields,
                    "generated": False,
                    "nullable": False,
                    "unique": False,
                    "indexed": False,
                    "default": None,
                    "description": "Tree!",
                }],
                "m2m_fields": [
                    {
                        "name": "rel_to",
                        "field_type": fields.ManyToManyField,
                        "python_type": StraightFields,
                        "generated": False,
                        "nullable": False,
                        "unique": False,
                        "indexed": False,
                        "default": None,
                        "description": "M2M to myself",
                    },
                    {
                        "name": "rel_from",
                        "field_type": fields.ManyToManyField,
                        "python_type": StraightFields,
                        "generated": False,
                        "nullable": False,
                        "unique": False,
                        "indexed": False,
                        "default": None,
                        "description": "M2M to myself",
                    },
                ],
            },
        )
Esempio n. 12
0
    def test_early_init(self):

        self.maxDiff = None
        Event_TooEarly = pydantic_model_creator(Event)
        self.assertEqual(
            Event_TooEarly.schema(),
            {
                "title": "Event",
                "type": "object",
                "description":
                "The Event model docstring.<br/><br/>This is multiline docs.",
                "properties": {
                    "id": {
                        "title": "Id",
                        "type": "integer",
                        "maximum": 2147483647,
                        "minimum": 1
                    },
                    "name": {
                        "title": "Name",
                        "type": "string",
                        "description":
                        "The Event NAME<br/>It's pretty important",
                        "maxLength": 255,
                    },
                    "created_at": {
                        "title": "Created At",
                        "type": "string",
                        "format": "date-time",
                        "readOnly": True,
                    },
                },
                "required": ["id", "name", "created_at"],
                "additionalProperties": False,
            },
        )
        self.assertEqual(
            Tortoise.describe_model(Event),
            {
                "name":
                "None.",
                "app":
                None,
                "table":
                "",
                "abstract":
                False,
                "description":
                "The Event model docstring.",
                "docstring":
                "The Event model docstring.\n\nThis is multiline docs.",
                "unique_together": [],
                "pk_field": {
                    "name": "id",
                    "field_type": "IntField",
                    "db_column": "id",
                    "db_field_types": {
                        "": "INT"
                    },
                    "python_type": "int",
                    "generated": True,
                    "nullable": False,
                    "unique": True,
                    "indexed": True,
                    "default": None,
                    "description": None,
                    "docstring": None,
                    "constraints": {
                        "ge": 1,
                        "le": 2147483647
                    },
                },
                "data_fields": [
                    {
                        "name": "name",
                        "field_type": "CharField",
                        "db_column": "name",
                        "db_field_types": {
                            "": "VARCHAR(255)"
                        },
                        "python_type": "str",
                        "generated": False,
                        "nullable": False,
                        "unique": False,
                        "indexed": False,
                        "default": None,
                        "description": "The Event NAME",
                        "docstring": "The Event NAME\nIt's pretty important",
                        "constraints": {
                            "max_length": 255
                        },
                    },
                    {
                        "name": "created_at",
                        "field_type": "DatetimeField",
                        "db_column": "created_at",
                        "db_field_types": {
                            "": "TIMESTAMP",
                            "mysql": "DATETIME(6)"
                        },
                        "python_type": "datetime.datetime",
                        "generated": False,
                        "nullable": False,
                        "unique": False,
                        "indexed": False,
                        "default": None,
                        "description": None,
                        "docstring": None,
                        "constraints": {
                            "readOnly": True
                        },
                    },
                ],
                "fk_fields": [{
                    "name": "tournament",
                    "field_type": "ForeignKeyFieldInstance",
                    "raw_field": None,
                    "python_type": "None",
                    "generated": False,
                    "nullable": True,
                    "unique": False,
                    "indexed": False,
                    "default": None,
                    "description": None,
                    "docstring": None,
                    "constraints": {},
                }],
                "backward_fk_fields": [],
                "o2o_fields": [],
                "backward_o2o_fields": [],
                "m2m_fields": [],
            },
        )

        Tortoise.init_models(["tests.test_early_init"], "models")

        Event_Pydantic = pydantic_model_creator(Event)
        self.assertEqual(
            Event_Pydantic.schema(),
            {
                "title": "Event",
                "type": "object",
                "description":
                "The Event model docstring.<br/><br/>This is multiline docs.",
                "properties": {
                    "id": {
                        "title": "Id",
                        "type": "integer",
                        "maximum": 2147483647,
                        "minimum": 1
                    },
                    "name": {
                        "title": "Name",
                        "type": "string",
                        "description":
                        "The Event NAME<br/>It's pretty important",
                        "maxLength": 255,
                    },
                    "created_at": {
                        "title": "Created At",
                        "type": "string",
                        "format": "date-time",
                        "readOnly": True,
                    },
                    "tournament": {
                        "title": "Tournament",
                        "nullable": True,
                        "allOf": [{
                            "$ref": "#/definitions/Tournament"
                        }],
                    },
                },
                "definitions": {
                    "Tournament": {
                        "title": "Tournament",
                        "type": "object",
                        "properties": {
                            "id": {
                                "title": "Id",
                                "type": "integer",
                                "maximum": 2147483647,
                                "minimum": 1,
                            },
                            "name": {
                                "title": "Name",
                                "type": "string",
                                "maxLength": 100
                            },
                            "created_at": {
                                "title": "Created At",
                                "type": "string",
                                "format": "date-time",
                                "readOnly": True,
                            },
                        },
                        "required": ["id", "name", "created_at"],
                        "additionalProperties": False,
                    }
                },
                "required": ["id", "name", "created_at"],
                "additionalProperties": False,
            },
        )
        self.assertEqual(
            Tortoise.describe_model(Event),
            {
                "name":
                "models.Event",
                "app":
                "models",
                "table":
                "event",
                "abstract":
                False,
                "description":
                "The Event model docstring.",
                "docstring":
                "The Event model docstring.\n\nThis is multiline docs.",
                "unique_together": [],
                "pk_field": {
                    "name": "id",
                    "field_type": "IntField",
                    "db_column": "id",
                    "db_field_types": {
                        "": "INT"
                    },
                    "python_type": "int",
                    "generated": True,
                    "nullable": False,
                    "unique": True,
                    "indexed": True,
                    "default": None,
                    "description": None,
                    "docstring": None,
                    "constraints": {
                        "ge": 1,
                        "le": 2147483647
                    },
                },
                "data_fields": [
                    {
                        "name": "name",
                        "field_type": "CharField",
                        "db_column": "name",
                        "db_field_types": {
                            "": "VARCHAR(255)"
                        },
                        "python_type": "str",
                        "generated": False,
                        "nullable": False,
                        "unique": False,
                        "indexed": False,
                        "default": None,
                        "description": "The Event NAME",
                        "docstring": "The Event NAME\nIt's pretty important",
                        "constraints": {
                            "max_length": 255
                        },
                    },
                    {
                        "name": "created_at",
                        "field_type": "DatetimeField",
                        "db_column": "created_at",
                        "db_field_types": {
                            "": "TIMESTAMP",
                            "mysql": "DATETIME(6)"
                        },
                        "python_type": "datetime.datetime",
                        "generated": False,
                        "nullable": False,
                        "unique": False,
                        "indexed": False,
                        "default": None,
                        "description": None,
                        "docstring": None,
                        "constraints": {
                            "readOnly": True
                        },
                    },
                    {
                        "name": "tournament_id",
                        "field_type": "IntField",
                        "db_column": "tournament_id",
                        "db_field_types": {
                            "": "INT"
                        },
                        "python_type": "int",
                        "generated": False,
                        "nullable": True,
                        "unique": False,
                        "indexed": False,
                        "default": None,
                        "description": None,
                        "docstring": None,
                        "constraints": {
                            "ge": -2147483648,
                            "le": 2147483647
                        },
                    },
                ],
                "fk_fields": [{
                    "name": "tournament",
                    "field_type": "ForeignKeyFieldInstance",
                    "raw_field": "tournament_id",
                    "python_type": "models.Tournament",
                    "generated": False,
                    "nullable": True,
                    "unique": False,
                    "indexed": False,
                    "default": None,
                    "description": None,
                    "docstring": None,
                    "constraints": {},
                }],
                "backward_fk_fields": [],
                "o2o_fields": [],
                "backward_o2o_fields": [],
                "m2m_fields": [],
            },
        )