plain.models 0.38.0__py3-none-any.whl → 0.39.0__py3-none-any.whl

plain/models/fields/reverse_related.py

@@ -20,7 +20,7 @@ from .mixins import FieldCacheMixin
 
 class ForeignObjectRel(FieldCacheMixin):
     """
-    Used by ForeignObject to store information about the relation.
+    Used by ForeignKey to store information about the relation.
 
     ``_meta.get_fields()`` returns this class to provide access to the field
     flags for the reverse relation.
@@ -43,7 +43,6 @@ class ForeignObjectRel(FieldCacheMixin):
         related_name=None,
         related_query_name=None,
         limit_choices_to=None,
-        parent_link=False,
         on_delete=None,
     ):
         self.field = field
@@ -51,7 +50,6 @@ class ForeignObjectRel(FieldCacheMixin):
         self.related_name = related_name
         self.related_query_name = related_query_name
         self.limit_choices_to = {} if limit_choices_to is None else limit_choices_to
-        self.parent_link = parent_link
         self.on_delete = on_delete
 
         self.symmetrical = False
@@ -128,7 +126,6 @@ class ForeignObjectRel(FieldCacheMixin):
             self.related_name,
             self.related_query_name,
             make_hashable(self.limit_choices_to),
-            self.parent_link,
             self.on_delete,
             self.symmetrical,
             self.multiple,
@@ -172,7 +169,7 @@ class ForeignObjectRel(FieldCacheMixin):
         qs = self.related_model._default_manager.complex_filter(limit_choices_to)
         if ordering:
             qs = qs.order_by(*ordering)
-        return (blank_choice if include_blank else []) + [(x.pk, str(x)) for x in qs]
+        return (blank_choice if include_blank else []) + [(x.id, str(x)) for x in qs]
 
     def is_hidden(self):
         """Should the related object be hidden?"""
@@ -249,11 +246,9 @@ class ManyToOneRel(ForeignObjectRel):
         self,
         field,
         to,
-        field_name,
         related_name=None,
         related_query_name=None,
         limit_choices_to=None,
-        parent_link=False,
         on_delete=None,
     ):
         super().__init__(
@@ -262,11 +257,10 @@ class ManyToOneRel(ForeignObjectRel):
             related_name=related_name,
             related_query_name=related_query_name,
             limit_choices_to=limit_choices_to,
-            parent_link=parent_link,
             on_delete=on_delete,
         )
 
-        self.field_name = field_name
+        self.field_name = "id"
 
     def __getstate__(self):
         state = super().__getstate__()
@@ -281,15 +275,13 @@ class ManyToOneRel(ForeignObjectRel):
         """
         Return the Field in the 'to' object to which this relationship is tied.
         """
-        field = self.model._meta.get_field(self.field_name)
+        field = self.model._meta.get_field("id")
         if not field.concrete:
-            raise exceptions.FieldDoesNotExist(
-                f"No related field named '{self.field_name}'"
-            )
+            raise exceptions.FieldDoesNotExist("No related field named 'id'")
         return field
 
     def set_field_name(self):
-        self.field_name = self.field_name or self.model._meta.pk.name
+        pass
 
 
 class ManyToManyRel(ForeignObjectRel):

plain/models/forms.py

@@ -37,7 +37,7 @@ def construct_instance(form, instance, fields=None):
     cleaned_data = form.cleaned_data
     file_field_list = []
     for f in opts.fields:
-        if isinstance(f, models.AutoField) or f.name not in cleaned_data:
+        if isinstance(f, models.PrimaryKeyField) or f.name not in cleaned_data:
             continue
         if fields is not None and f.name not in fields:
             continue
@@ -318,17 +318,6 @@ class BaseModelForm(BaseForm):
 
         exclude = self._get_validation_exclusions()
 
-        # Foreign Keys being used to represent inline relationships
-        # are excluded from basic field value validation. This is for two
-        # reasons: firstly, the value may not be supplied (#12507; the
-        # case of providing new values to the admin); secondly the
-        # object being referred to may not yet fully exist (#12749).
-        # However, these fields *must* be included in uniqueness checks,
-        # so this can't be part of _get_validation_exclusions().
-        for name, field in self.fields.items():
-            if isinstance(field, InlineForeignKeyField):
-                exclude.add(name)
-
         try:
             self.instance = construct_instance(self, self.instance, opts.fields)
         except ValidationError as e:
@@ -401,49 +390,6 @@ class ModelForm(BaseModelForm, metaclass=ModelFormMetaclass):
 # Fields #####################################################################
 
 
-class InlineForeignKeyField(Field):
-    """
-    A basic integer field that deals with validating the given value to a
-    given parent instance in an inline.
-    """
-
-    default_error_messages = {
-        "invalid_choice": "The inline value did not match the parent instance.",
-    }
-
-    def __init__(self, parent_instance, *args, pk_field=False, to_field=None, **kwargs):
-        self.parent_instance = parent_instance
-        self.pk_field = pk_field
-        self.to_field = to_field
-        if self.parent_instance is not None:
-            if self.to_field:
-                kwargs["initial"] = getattr(self.parent_instance, self.to_field)
-            else:
-                kwargs["initial"] = self.parent_instance.pk
-        kwargs["required"] = False
-        super().__init__(*args, **kwargs)
-
-    def clean(self, value):
-        if value in self.empty_values:
-            if self.pk_field:
-                return None
-            # if there is no value act as we did before.
-            return self.parent_instance
-        # ensure the we compare the values as equal types.
-        if self.to_field:
-            orig = getattr(self.parent_instance, self.to_field)
-        else:
-            orig = self.parent_instance.pk
-        if str(value) != str(orig):
-            raise ValidationError(
-                self.error_messages["invalid_choice"], code="invalid_choice"
-            )
-        return self.parent_instance
-
-    def has_changed(self, initial, data):
-        return False
-
-
 class ModelChoiceIteratorValue:
     def __init__(self, value, instance):
         self.value = value
@@ -509,7 +455,6 @@ class ModelChoiceField(ChoiceField):
         empty_label="---------",
         required=True,
         initial=None,
-        to_field_name=None,
         **kwargs,
     ):
         # Call Field instead of ChoiceField __init__() because we don't need
@@ -525,7 +470,6 @@ class ModelChoiceField(ChoiceField):
         else:
             self.empty_label = empty_label
         self.queryset = queryset
-        self.to_field_name = to_field_name
 
     def __deepcopy__(self, memo):
         result = super(ChoiceField, self).__deepcopy__(memo)
@@ -561,17 +505,14 @@ class ModelChoiceField(ChoiceField):
 
     def prepare_value(self, value):
         if hasattr(value, "_meta"):
-            if self.to_field_name:
-                return value.serializable_value(self.to_field_name)
-            else:
-                return value.pk
+            return value.id
         return super().prepare_value(value)
 
     def to_python(self, value):
         if value in self.empty_values:
             return None
         try:
-            key = self.to_field_name or "pk"
+            key = "id"
             if isinstance(value, self.queryset.model):
                 value = getattr(value, key)
             value = self.queryset.get(**{key: value})
@@ -598,7 +539,7 @@ class ModelMultipleChoiceField(ModelChoiceField):
     default_error_messages = {
         "invalid_list": "Enter a list of values.",
         "invalid_choice": "Select a valid choice. %(value)s is not one of the available choices.",
-        "invalid_pk_value": "“%(pk)s” is not a valid value.",
+        "invalid_id_value": "'%(id)s' is not a valid value.",
     }
 
     def __init__(self, queryset, **kwargs):
@@ -632,7 +573,7 @@ class ModelMultipleChoiceField(ModelChoiceField):
         corresponding objects. Raise a ValidationError if a given value is
         invalid (not a valid PK, not in the queryset, etc.)
         """
-        key = self.to_field_name or "pk"
+        key = self.to_field_name or "id"
         # deduplicate given values to avoid creating many querysets or
         # requiring the database backend deduplicate efficiently.
         try:
@@ -643,19 +584,19 @@ class ModelMultipleChoiceField(ModelChoiceField):
                 self.error_messages["invalid_list"],
                 code="invalid_list",
             )
-        for pk in value:
+        for id_val in value:
             try:
-                self.queryset.filter(**{key: pk})
+                self.queryset.filter(**{key: id_val})
             except (ValueError, TypeError):
                 raise ValidationError(
-                    self.error_messages["invalid_pk_value"],
-                    code="invalid_pk_value",
-                    params={"pk": pk},
+                    self.error_messages["invalid_id_value"],
+                    code="invalid_id_value",
+                    params={"id": id_val},
                 )
         qs = self.queryset.filter(**{f"{key}__in": value})
-        pks = {str(getattr(o, key)) for o in qs}
+        ids = {str(getattr(o, key)) for o in qs}
         for val in value:
-            if str(val) not in pks:
+            if str(val) not in ids:
                 raise ValidationError(
                     self.error_messages["invalid_choice"],
                     code="invalid_choice",
@@ -733,10 +674,8 @@ def modelfield_to_formfield(
     # Avoid a circular import
     from plain import models
 
-    # Auto fields aren't rendered by default
-    if isinstance(modelfield, models.AutoField) or issubclass(
-        modelfield.__class__, models.AutoField
-    ):
+    # Primary key fields aren't rendered by default
+    if isinstance(modelfield, models.PrimaryKeyField):
         return None
 
     if isinstance(modelfield, models.BooleanField):
@@ -784,7 +723,6 @@ def modelfield_to_formfield(
     if isinstance(modelfield, models.ForeignKey):
         return ModelChoiceField(
             queryset=modelfield.remote_field.model._default_manager,
-            to_field_name=modelfield.remote_field.field_name,
             **defaults,
         )
 

plain/models/lookups.py

@@ -319,7 +319,7 @@ class Exact(FieldGetDbPrepValueMixin, BuiltinLookup):
             if self.rhs.has_limit_one():
                 if not self.rhs.has_select_fields:
                     self.rhs.clear_select_clause()
-                    self.rhs.add_fields(["pk"])
+                    self.rhs.add_fields(["id"])
             else:
                 raise ValueError(
                     "The QuerySet value for an exact lookup must be limited to "
@@ -444,7 +444,7 @@ class In(FieldGetDbPrepValueIterableMixin, BuiltinLookup):
             self.rhs.clear_ordering(clear_default=True)
             if not self.rhs.has_select_fields:
                 self.rhs.clear_select_clause()
-                self.rhs.add_fields(["pk"])
+                self.rhs.add_fields(["id"])
         return super().get_prep_lookup()
 
     def process_rhs(self, compiler, connection):

plain/models/migrations/autodetector.py

@@ -536,7 +536,7 @@ class MigrationAutodetector:
                     if field.remote_field.model:
                         if field.primary_key:
                             primary_key_rel = field.remote_field.model
-                        elif not field.remote_field.parent_link:
+                        else:
                             related_fields[field_name] = field
                     if getattr(field.remote_field, "through", None):
                         related_fields[field_name] = field
@@ -938,31 +938,8 @@ class MigrationAutodetector:
                 if remote_field_name:
                     to_field_rename_key = rename_key + (remote_field_name,)
                     if to_field_rename_key in self.renamed_fields:
-                        # Repoint both model and field name because to_field
-                        # inclusion in ForeignKey.deconstruct() is based on
-                        # both.
+                        # Repoint model name only
                         new_field.remote_field.model = old_field.remote_field.model
-                        new_field.remote_field.field_name = (
-                            old_field.remote_field.field_name
-                        )
-                # Handle ForeignObjects which can have multiple from_fields/to_fields.
-                from_fields = getattr(new_field, "from_fields", None)
-                if from_fields:
-                    from_rename_key = (package_label, model_name)
-                    new_field.from_fields = tuple(
-                        [
-                            self.renamed_fields.get(
-                                from_rename_key + (from_field,), from_field
-                            )
-                            for from_field in from_fields
-                        ]
-                    )
-                    new_field.to_fields = tuple(
-                        [
-                            self.renamed_fields.get(rename_key + (to_field,), to_field)
-                            for to_field in new_field.to_fields
-                        ]
-                    )
                 dependencies.extend(
                     self._get_dependencies_for_foreign_key(
                         package_label,

plain/models/migrations/operations/fields.py

@@ -49,12 +49,6 @@ class FieldOperation(Operation):
         if model_name_lower == self.model_name_lower:
             if name == self.name:
                 return True
-            elif (
-                self.field
-                and hasattr(self.field, "from_fields")
-                and name in self.field.from_fields
-            ):
-                return True
         # Check if this operation remotely references the field.
         if self.field is None:
             return False

plain/models/migrations/state.py

@@ -281,33 +281,9 @@ class ProjectState:
                 f"{package_label}.{model_name} has no field named '{old_name}'"
             )
         fields[new_name] = found
-        for field in fields.values():
-            # Fix from_fields to refer to the new field.
-            from_fields = getattr(field, "from_fields", None)
-            if from_fields:
-                field.from_fields = tuple(
-                    [
-                        new_name if from_field_name == old_name else from_field_name
-                        for from_field_name in from_fields
-                    ]
-                )
-
-        # Fix to_fields to refer to the new field.
-        delay = True
+        # Check if there are any references to this field
         references = get_references(self, model_key, (old_name, found))
-        for *_, field, reference in references:
-            delay = False
-            if reference.to:
-                remote_field, to_fields = reference.to
-                if getattr(remote_field, "field_name", None) == old_name:
-                    remote_field.field_name = new_name
-                if to_fields:
-                    field.to_fields = tuple(
-                        [
-                            new_name if to_field_name == old_name else to_field_name
-                            for to_field_name in to_fields
-                        ]
-                    )
+        delay = not bool(references)
         if self._relations is not None:
             old_name_lower = old_name.lower()
             new_name_lower = new_name.lower()

plain/models/migrations/utils.py

@@ -72,23 +72,13 @@ def field_references(
     references_to = None
     references_through = None
     if resolve_relation(remote_field.model, *model_tuple) == reference_model_tuple:
-        to_fields = getattr(field, "to_fields", None)
+        # ForeignObject always references 'id'
         if (
             reference_field_name is None
-            or
-            # Unspecified to_field(s).
-            to_fields is None
-            or
-            # Reference to primary key.
-            (
-                None in to_fields
-                and (reference_field is None or reference_field.primary_key)
-            )
-            or
-            # Reference to field.
-            reference_field_name in to_fields
+            or reference_field_name == "id"
+            or (reference_field is None or reference_field.primary_key)
         ):
-            references_to = (remote_field, to_fields)
+            references_to = (remote_field, ["id"])
     through = getattr(remote_field, "through", None)
     if through and resolve_relation(through, *model_tuple) == reference_model_tuple:
         through_fields = remote_field.through_fields

plain/models/options.py

@@ -8,7 +8,7 @@ from plain.exceptions import FieldDoesNotExist
 from plain.models import models_registry
 from plain.models.constraints import UniqueConstraint
 from plain.models.db import db_connection
-from plain.models.fields import BigAutoField
+from plain.models.fields import PrimaryKeyField
 from plain.models.manager import Manager
 from plain.utils.datastructures import ImmutableList
 
@@ -78,8 +78,6 @@ class Options:
         self.required_db_features = []
         self.required_db_vendor = None
         self.meta = meta
-        self.pk = None
-        self.auto_field = None
 
         # For any non-abstract class, the concrete class is the model
         # in the end of the proxy_for_model chain. In particular, for
@@ -170,9 +168,8 @@ class Options:
         return new_objs
 
     def _prepare(self, model):
-        if self.pk is None:
-            auto = BigAutoField(primary_key=True, auto_created=True)
-            model.add_to_class("id", auto)
+        if not any(f.name == "id" for f in self.local_fields):
+            model.add_to_class("id", PrimaryKeyField())
 
     def add_manager(self, manager):
         self.local_managers.append(manager)
@@ -187,7 +184,6 @@ class Options:
             bisect.insort(self.local_many_to_many, field)
         else:
             bisect.insort(self.local_fields, field)
-            self.setup_pk(field)
 
         # If the field being added is a relation to another known field,
         # expire the cache on this field and the forward cache on the field
@@ -210,10 +206,6 @@ class Options:
         else:
             self._expire_cache(reverse=False)
 
-    def setup_pk(self, field):
-        if not self.pk and field.primary_key:
-            self.pk = field
-
     def __repr__(self):
         return f"<Options for {self.object_name}>"
 
@@ -624,7 +616,7 @@ class Options:
     @cached_property
     def _non_pk_concrete_field_names(self):
         """
-        Return a set of the non-pk concrete field names defined on the model.
+        Return a set of the non-primary key concrete field names defined on the model.
         """
         names = []
         for field in self.concrete_fields: