plain.models 0.44.0__py3-none-any.whl → 0.46.0__py3-none-any.whl

plain/models/base.py

@@ -4,7 +4,6 @@ import warnings
 from itertools import chain
 
 import plain.runtime
-from plain import preflight
 from plain.exceptions import (
     NON_FIELD_ERRORS,
     FieldDoesNotExist,
@@ -27,6 +26,7 @@ from plain.models.fields.reverse_related import ForeignObjectRel
 from plain.models.options import Options
 from plain.models.query import F, Q, QuerySet
 from plain.packages import packages_registry
+from plain.preflight import PreflightResult
 from plain.utils.encoding import force_str
 from plain.utils.hashable import make_hashable
 
@@ -984,14 +984,13 @@ class Model(metaclass=ModelBase):
             raise ValidationError(errors)
 
     @classmethod
-    def check(cls, **kwargs):
+    def preflight(cls):
         errors = []
 
-        database = kwargs.get("database", False)
         errors += [
-            *cls._check_fields(**kwargs),
+            *cls._check_fields(),
             *cls._check_m2m_through_same_relationship(),
-            *cls._check_long_column_names(database),
+            *cls._check_long_column_names(),
         ]
         clash_errors = (
             *cls._check_id_field(),
@@ -1006,17 +1005,17 @@ class Model(metaclass=ModelBase):
         if not clash_errors:
             errors.extend(cls._check_column_name_clashes())
         errors += [
-            *cls._check_indexes(database),
+            *cls._check_indexes(),
             *cls._check_ordering(),
-            *cls._check_constraints(database),
-            *cls._check_db_table_comment(database),
+            *cls._check_constraints(),
+            *cls._check_db_table_comment(),
         ]
 
         return errors
 
     @classmethod
-    def _check_db_table_comment(cls, database):
-        if not cls._meta.db_table_comment or not database:
+    def _check_db_table_comment(cls):
+        if not cls._meta.db_table_comment:
             return []
         errors = []
         if not (
@@ -1024,23 +1023,24 @@ class Model(metaclass=ModelBase):
             or "supports_comments" in cls._meta.required_db_features
         ):
             errors.append(
-                preflight.Warning(
-                    f"{db_connection.display_name} does not support comments on "
+                PreflightResult(
+                    fix=f"{db_connection.display_name} does not support comments on "
                     f"tables (db_table_comment).",
                     obj=cls,
-                    id="models.W046",
+                    id="models.db_table_comment_unsupported",
+                    warning=True,
                 )
             )
         return errors
 
     @classmethod
-    def _check_fields(cls, **kwargs):
+    def _check_fields(cls):
         """Perform all field checks."""
         errors = []
         for field in cls._meta.local_fields:
-            errors.extend(field.check(**kwargs))
+            errors.extend(field.preflight(from_model=cls))
         for field in cls._meta.local_many_to_many:
-            errors.extend(field.check(from_model=cls, **kwargs))
+            errors.extend(field.preflight(from_model=cls))
         return errors
 
     @classmethod
@@ -1067,11 +1067,11 @@ class Model(metaclass=ModelBase):
             )
             if signature in seen_intermediary_signatures:
                 errors.append(
-                    preflight.Error(
-                        "The model has two identical many-to-many relations "
+                    PreflightResult(
+                        fix="The model has two identical many-to-many relations "
                         f"through the intermediate model '{f.remote_field.through._meta.label}'.",
                         obj=cls,
-                        id="models.E003",
+                        id="models.duplicate_many_to_many_relations",
                     )
                 )
             else:
@@ -1085,10 +1085,10 @@ class Model(metaclass=ModelBase):
             f for f in cls._meta.local_fields if f.name == "id" and not f.auto_created
         ):
             return [
-                preflight.Error(
-                    "'id' is a reserved word that cannot be used as a field name.",
+                PreflightResult(
+                    fix="'id' is a reserved word that cannot be used as a field name.",
                     obj=cls,
-                    id="models.E004",
+                    id="models.reserved_field_name_id",
                 )
             ]
         return []
@@ -1110,11 +1110,11 @@ class Model(metaclass=ModelBase):
             )
             if clash and not id_conflict:
                 errors.append(
-                    preflight.Error(
-                        f"The field '{f.name}' clashes with the field '{clash.name}' "
+                    PreflightResult(
+                        fix=f"The field '{f.name}' clashes with the field '{clash.name}' "
                         f"from model '{clash.model._meta}'.",
                         obj=f,
-                        id="models.E006",
+                        id="models.field_name_clash",
                     )
                 )
             used_fields[f.name] = f
@@ -1134,12 +1134,11 @@ class Model(metaclass=ModelBase):
             # Ensure the column name is not already in use.
             if column_name and column_name in used_column_names:
                 errors.append(
-                    preflight.Error(
-                        f"Field '{f.name}' has column name '{column_name}' that is used by "
-                        "another field.",
-                        hint="Specify a 'db_column' for the field.",
+                    PreflightResult(
+                        fix=f"Field '{f.name}' has column name '{column_name}' that is used by "
+                        "another field. Specify a 'db_column' for the field.",
                         obj=cls,
-                        id="models.E007",
+                        id="models.db_column_clash",
                     )
                 )
             else:
@@ -1153,20 +1152,20 @@ class Model(metaclass=ModelBase):
         model_name = cls.__name__
         if model_name.startswith("_") or model_name.endswith("_"):
             errors.append(
-                preflight.Error(
-                    f"The model name '{model_name}' cannot start or end with an underscore "
+                PreflightResult(
+                    fix=f"The model name '{model_name}' cannot start or end with an underscore "
                     "as it collides with the query lookup syntax.",
                     obj=cls,
-                    id="models.E023",
+                    id="models.model_name_underscore_bounds",
                 )
             )
         elif LOOKUP_SEP in model_name:
             errors.append(
-                preflight.Error(
-                    f"The model name '{model_name}' cannot contain double underscores as "
+                PreflightResult(
+                    fix=f"The model name '{model_name}' cannot contain double underscores as "
                     "it collides with the query lookup syntax.",
                     obj=cls,
-                    id="models.E024",
+                    id="models.model_name_double_underscore",
                 )
             )
         return errors
@@ -1183,11 +1182,11 @@ class Model(metaclass=ModelBase):
         for accessor in related_field_accessors:
             if accessor in property_names:
                 errors.append(
-                    preflight.Error(
-                        f"The property '{accessor}' clashes with a related field "
+                    PreflightResult(
+                        fix=f"The property '{accessor}' clashes with a related field "
                         "accessor.",
                         obj=cls,
-                        id="models.E025",
+                        id="models.property_related_field_clash",
                     )
                 )
         return errors
@@ -1197,17 +1196,17 @@ class Model(metaclass=ModelBase):
         errors = []
         if sum(1 for f in cls._meta.local_fields if f.primary_key) > 1:
             errors.append(
-                preflight.Error(
-                    "The model cannot have more than one field with "
+                PreflightResult(
+                    fix="The model cannot have more than one field with "
                     "'primary_key=True'.",
                     obj=cls,
-                    id="models.E026",
+                    id="models.multiple_primary_keys",
                 )
             )
         return errors
 
     @classmethod
-    def _check_indexes(cls, database):
+    def _check_indexes(cls):
         """Check fields, names, and conditions of indexes."""
         errors = []
         references = set()
@@ -1216,20 +1215,20 @@ class Model(metaclass=ModelBase):
             # for cross-database compatibility with Oracle.
             if index.name[0] == "_" or index.name[0].isdigit():
                 errors.append(
-                    preflight.Error(
-                        f"The index name '{index.name}' cannot start with an underscore "
+                    PreflightResult(
+                        fix=f"The index name '{index.name}' cannot start with an underscore "
                         "or a number.",
                         obj=cls,
-                        id="models.E033",
+                        id="models.index_name_invalid_start",
                     ),
                 )
             if len(index.name) > index.max_name_length:
                 errors.append(
-                    preflight.Error(
-                        "The index name '%s' cannot be longer than %d "  # noqa: UP031
+                    PreflightResult(
+                        fix="The index name '%s' cannot be longer than %d "  # noqa: UP031
                         "characters." % (index.name, index.max_name_length),
                         obj=cls,
-                        id="models.E034",
+                        id="models.index_name_too_long",
                     ),
                 )
             if index.contains_expressions:
@@ -1237,61 +1236,46 @@ class Model(metaclass=ModelBase):
                     references.update(
                         ref[0] for ref in cls._get_expr_references(expression)
                     )
-        if (
-            database
-            and not (
-                db_connection.features.supports_partial_indexes
-                or "supports_partial_indexes" in cls._meta.required_db_features
-            )
-            and any(index.condition is not None for index in cls._meta.indexes)
-        ):
+        if not (
+            db_connection.features.supports_partial_indexes
+            or "supports_partial_indexes" in cls._meta.required_db_features
+        ) and any(index.condition is not None for index in cls._meta.indexes):
             errors.append(
-                preflight.Warning(
-                    f"{db_connection.display_name} does not support indexes with conditions.",
-                    hint=(
-                        "Conditions will be ignored. Silence this warning "
-                        "if you don't care about it."
-                    ),
+                PreflightResult(
+                    fix=f"{db_connection.display_name} does not support indexes with conditions. "
+                    "Conditions will be ignored. Silence this warning "
+                    "if you don't care about it.",
+                    warning=True,
                     obj=cls,
-                    id="models.W037",
+                    id="models.index_conditions_ignored",
                 )
             )
-        if (
-            database
-            and not (
-                db_connection.features.supports_covering_indexes
-                or "supports_covering_indexes" in cls._meta.required_db_features
-            )
-            and any(index.include for index in cls._meta.indexes)
-        ):
+        if not (
+            db_connection.features.supports_covering_indexes
+            or "supports_covering_indexes" in cls._meta.required_db_features
+        ) and any(index.include for index in cls._meta.indexes):
             errors.append(
-                preflight.Warning(
-                    f"{db_connection.display_name} does not support indexes with non-key columns.",
-                    hint=(
-                        "Non-key columns will be ignored. Silence this "
-                        "warning if you don't care about it."
-                    ),
+                PreflightResult(
+                    fix=f"{db_connection.display_name} does not support indexes with non-key columns. "
+                    "Non-key columns will be ignored. Silence this "
+                    "warning if you don't care about it.",
+                    warning=True,
                     obj=cls,
-                    id="models.W040",
+                    id="models.index_non_key_columns_ignored",
                 )
             )
-        if (
-            database
-            and not (
-                db_connection.features.supports_expression_indexes
-                or "supports_expression_indexes" in cls._meta.required_db_features
-            )
-            and any(index.contains_expressions for index in cls._meta.indexes)
-        ):
+        if not (
+            db_connection.features.supports_expression_indexes
+            or "supports_expression_indexes" in cls._meta.required_db_features
+        ) and any(index.contains_expressions for index in cls._meta.indexes):
             errors.append(
-                preflight.Warning(
-                    f"{db_connection.display_name} does not support indexes on expressions.",
-                    hint=(
-                        "An index won't be created. Silence this warning "
-                        "if you don't care about it."
-                    ),
+                PreflightResult(
+                    fix=f"{db_connection.display_name} does not support indexes on expressions. "
+                    "An index won't be created. Silence this warning "
+                    "if you don't care about it.",
+                    warning=True,
                     obj=cls,
-                    id="models.W043",
+                    id="models.index_on_foreign_key",
                 )
             )
         fields = [
@@ -1320,30 +1304,29 @@ class Model(metaclass=ModelBase):
                 field = forward_fields_map[field_name]
             except KeyError:
                 errors.append(
-                    preflight.Error(
-                        f"'{option}' refers to the nonexistent field '{field_name}'.",
+                    PreflightResult(
+                        fix=f"'{option}' refers to the nonexistent field '{field_name}'.",
                         obj=cls,
-                        id="models.E012",
+                        id="models.nonexistent_field_reference",
                     )
                 )
             else:
                 if isinstance(field.remote_field, models.ManyToManyRel):
                     errors.append(
-                        preflight.Error(
-                            f"'{option}' refers to a ManyToManyField '{field_name}', but "
+                        PreflightResult(
+                            fix=f"'{option}' refers to a ManyToManyField '{field_name}', but "
                             f"ManyToManyFields are not permitted in '{option}'.",
                             obj=cls,
-                            id="models.E013",
+                            id="models.m2m_field_in_meta_option",
                         )
                     )
                 elif field not in cls._meta.local_fields:
                     errors.append(
-                        preflight.Error(
-                            f"'{option}' refers to field '{field_name}' which is not local to model "
-                            f"'{cls._meta.object_name}'.",
-                            hint="This issue may be caused by multi-table inheritance.",
+                        PreflightResult(
+                            fix=f"'{option}' refers to field '{field_name}' which is not local to model "
+                            f"'{cls._meta.object_name}'. This issue may be caused by multi-table inheritance.",
                             obj=cls,
-                            id="models.E016",
+                            id="models.non_local_field_reference",
                         )
                     )
         return errors
@@ -1360,11 +1343,11 @@ class Model(metaclass=ModelBase):
 
         if not isinstance(cls._meta.ordering, list | tuple):
             return [
-                preflight.Error(
-                    "'ordering' must be a tuple or list (even if you want to order by "
+                PreflightResult(
+                    fix="'ordering' must be a tuple or list (even if you want to order by "
                     "only one field).",
                     obj=cls,
-                    id="models.E014",
+                    id="models.ordering_not_tuple_or_list",
                 )
             ]
 
@@ -1403,11 +1386,11 @@ class Model(metaclass=ModelBase):
                         fld.get_transform(part) is None and fld.get_lookup(part) is None
                     ):
                         errors.append(
-                            preflight.Error(
-                                "'ordering' refers to the nonexistent field, "
+                            PreflightResult(
+                                fix="'ordering' refers to the nonexistent field, "
                                 f"related field, or lookup '{field}'.",
                                 obj=cls,
-                                id="models.E015",
+                                id="models.ordering_nonexistent_field",
                             )
                         )
 
@@ -1430,23 +1413,21 @@ class Model(metaclass=ModelBase):
 
         for invalid_field in invalid_fields:
             errors.append(
-                preflight.Error(
-                    "'ordering' refers to the nonexistent field, related "
+                PreflightResult(
+                    fix="'ordering' refers to the nonexistent field, related "
                     f"field, or lookup '{invalid_field}'.",
                     obj=cls,
-                    id="models.E015",
+                    id="models.ordering_nonexistent_field",
                 )
             )
         return errors
 
     @classmethod
-    def _check_long_column_names(cls, database):
+    def _check_long_column_names(cls):
         """
         Check that any auto-generated column names are shorter than the limits
         for each database in which the model will be created.
         """
-        if not database:
-            return []
         errors = []
         allowed_len = None
 
@@ -1468,12 +1449,12 @@ class Model(metaclass=ModelBase):
                 and len(column_name) > allowed_len
             ):
                 errors.append(
-                    preflight.Error(
-                        f'Autogenerated column name too long for field "{column_name}". '
-                        f'Maximum length is "{allowed_len}" for the database.',
-                        hint="Set the column name manually using 'db_column'.",
+                    PreflightResult(
+                        fix=f'Autogenerated column name too long for field "{column_name}". '
+                        f'Maximum length is "{allowed_len}" for the database. '
+                        "Set the column name manually using 'db_column'.",
                         obj=cls,
-                        id="models.E018",
+                        id="models.autogenerated_column_name_too_long",
                     )
                 )
 
@@ -1492,15 +1473,13 @@ class Model(metaclass=ModelBase):
                     and len(rel_name) > allowed_len
                 ):
                     errors.append(
-                        preflight.Error(
-                            "Autogenerated column name too long for M2M field "
-                            f'"{rel_name}". Maximum length is "{allowed_len}" for the database.',
-                            hint=(
-                                "Use 'through' to create a separate model for "
-                                "M2M and then set column_name using 'db_column'."
-                            ),
+                        PreflightResult(
+                            fix="Autogenerated column name too long for M2M field "
+                            f'"{rel_name}". Maximum length is "{allowed_len}" for the database. '
+                            "Use 'through' to create a separate model for "
+                            "M2M and then set column_name using 'db_column'.",
                             obj=cls,
-                            id="models.E019",
+                            id="models.m2m_column_name_too_long",
                         )
                     )
 
@@ -1523,106 +1502,100 @@ class Model(metaclass=ModelBase):
                 yield from cls._get_expr_references(src_expr)
 
     @classmethod
-    def _check_constraints(cls, database):
+    def _check_constraints(cls):
         errors = []
-        if database:
-            if not (
-                db_connection.features.supports_table_check_constraints
-                or "supports_table_check_constraints" in cls._meta.required_db_features
-            ) and any(
-                isinstance(constraint, CheckConstraint)
-                for constraint in cls._meta.constraints
-            ):
-                errors.append(
-                    preflight.Warning(
-                        f"{db_connection.display_name} does not support check constraints.",
-                        hint=(
-                            "A constraint won't be created. Silence this "
-                            "warning if you don't care about it."
-                        ),
-                        obj=cls,
-                        id="models.W027",
-                    )
+        if not (
+            db_connection.features.supports_table_check_constraints
+            or "supports_table_check_constraints" in cls._meta.required_db_features
+        ) and any(
+            isinstance(constraint, CheckConstraint)
+            for constraint in cls._meta.constraints
+        ):
+            errors.append(
+                PreflightResult(
+                    fix=f"{db_connection.display_name} does not support check constraints. "
+                    "A constraint won't be created. Silence this "
+                    "warning if you don't care about it.",
+                    obj=cls,
+                    id="models.constraint_on_non_db_field",
+                    warning=True,
                 )
-            if not (
-                db_connection.features.supports_partial_indexes
-                or "supports_partial_indexes" in cls._meta.required_db_features
-            ) and any(
-                isinstance(constraint, UniqueConstraint)
-                and constraint.condition is not None
-                for constraint in cls._meta.constraints
-            ):
-                errors.append(
-                    preflight.Warning(
-                        f"{db_connection.display_name} does not support unique constraints with "
-                        "conditions.",
-                        hint=(
-                            "A constraint won't be created. Silence this "
-                            "warning if you don't care about it."
-                        ),
-                        obj=cls,
-                        id="models.W036",
-                    )
+            )
+
+        if not (
+            db_connection.features.supports_partial_indexes
+            or "supports_partial_indexes" in cls._meta.required_db_features
+        ) and any(
+            isinstance(constraint, UniqueConstraint)
+            and constraint.condition is not None
+            for constraint in cls._meta.constraints
+        ):
+            errors.append(
+                PreflightResult(
+                    fix=f"{db_connection.display_name} does not support unique constraints with "
+                    "conditions. A constraint won't be created. Silence this "
+                    "warning if you don't care about it.",
+                    obj=cls,
+                    id="models.constraint_on_virtual_field",
+                    warning=True,
                 )
-            if not (
-                db_connection.features.supports_deferrable_unique_constraints
-                or "supports_deferrable_unique_constraints"
-                in cls._meta.required_db_features
-            ) and any(
-                isinstance(constraint, UniqueConstraint)
-                and constraint.deferrable is not None
-                for constraint in cls._meta.constraints
-            ):
-                errors.append(
-                    preflight.Warning(
-                        f"{db_connection.display_name} does not support deferrable unique constraints.",
-                        hint=(
-                            "A constraint won't be created. Silence this "
-                            "warning if you don't care about it."
-                        ),
-                        obj=cls,
-                        id="models.W038",
-                    )
+            )
+
+        if not (
+            db_connection.features.supports_deferrable_unique_constraints
+            or "supports_deferrable_unique_constraints"
+            in cls._meta.required_db_features
+        ) and any(
+            isinstance(constraint, UniqueConstraint)
+            and constraint.deferrable is not None
+            for constraint in cls._meta.constraints
+        ):
+            errors.append(
+                PreflightResult(
+                    fix=f"{db_connection.display_name} does not support deferrable unique constraints. "
+                    "A constraint won't be created. Silence this "
+                    "warning if you don't care about it.",
+                    obj=cls,
+                    id="models.constraint_on_foreign_key",
+                    warning=True,
                 )
-            if not (
-                db_connection.features.supports_covering_indexes
-                or "supports_covering_indexes" in cls._meta.required_db_features
-            ) and any(
-                isinstance(constraint, UniqueConstraint) and constraint.include
-                for constraint in cls._meta.constraints
-            ):
-                errors.append(
-                    preflight.Warning(
-                        f"{db_connection.display_name} does not support unique constraints with non-key "
-                        "columns.",
-                        hint=(
-                            "A constraint won't be created. Silence this "
-                            "warning if you don't care about it."
-                        ),
-                        obj=cls,
-                        id="models.W039",
-                    )
+            )
+
+        if not (
+            db_connection.features.supports_covering_indexes
+            or "supports_covering_indexes" in cls._meta.required_db_features
+        ) and any(
+            isinstance(constraint, UniqueConstraint) and constraint.include
+            for constraint in cls._meta.constraints
+        ):
+            errors.append(
+                PreflightResult(
+                    fix=f"{db_connection.display_name} does not support unique constraints with non-key "
+                    "columns. A constraint won't be created. Silence this "
+                    "warning if you don't care about it.",
+                    obj=cls,
+                    id="models.constraint_on_m2m_field",
+                    warning=True,
                 )
-            if not (
-                db_connection.features.supports_expression_indexes
-                or "supports_expression_indexes" in cls._meta.required_db_features
-            ) and any(
-                isinstance(constraint, UniqueConstraint)
-                and constraint.contains_expressions
-                for constraint in cls._meta.constraints
-            ):
-                errors.append(
-                    preflight.Warning(
-                        f"{db_connection.display_name} does not support unique constraints on "
-                        "expressions.",
-                        hint=(
-                            "A constraint won't be created. Silence this "
-                            "warning if you don't care about it."
-                        ),
-                        obj=cls,
-                        id="models.W044",
-                    )
+            )
+
+        if not (
+            db_connection.features.supports_expression_indexes
+            or "supports_expression_indexes" in cls._meta.required_db_features
+        ) and any(
+            isinstance(constraint, UniqueConstraint) and constraint.contains_expressions
+            for constraint in cls._meta.constraints
+        ):
+            errors.append(
+                PreflightResult(
+                    fix=f"{db_connection.display_name} does not support unique constraints on "
+                    "expressions. A constraint won't be created. Silence this "
+                    "warning if you don't care about it.",
+                    obj=cls,
+                    id="models.constraint_on_self_referencing_fk",
+                    warning=True,
                 )
+            )
         fields = set(
             chain.from_iterable(
                 (*constraint.fields, *constraint.include)
@@ -1657,15 +1630,14 @@ class Model(metaclass=ModelBase):
                         isinstance(expr, RawSQL) for expr in constraint.check.flatten()
                     ):
                         errors.append(
-                            preflight.Warning(
-                                f"Check constraint {constraint.name!r} contains "
+                            PreflightResult(
+                                fix=f"Check constraint {constraint.name!r} contains "
                                 f"RawSQL() expression and won't be validated "
-                                f"during the model full_clean().",
-                                hint=(
-                                    "Silence this warning if you don't care about it."
-                                ),
+                                f"during the model full_clean(). "
+                                "Silence this warning if you don't care about it.",
+                                warning=True,
                                 obj=cls,
-                                id="models.W045",
+                                id="models.constraint_name_collision_autogenerated",
                             ),
                         )
         for field_name, *lookups in references:
@@ -1688,10 +1660,10 @@ class Model(metaclass=ModelBase):
                 and field.get_lookup(first_lookup) is None
             ):
                 errors.append(
-                    preflight.Error(
-                        f"'constraints' refers to the joined field '{LOOKUP_SEP.join([field_name] + lookups)}'.",
+                    PreflightResult(
+                        fix=f"'constraints' refers to the joined field '{LOOKUP_SEP.join([field_name] + lookups)}'.",
                         obj=cls,
-                        id="models.E041",
+                        id="models.constraint_refers_to_joined_field",
                     )
                 )
         errors.extend(cls._check_local_fields(fields, "constraints"))