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

plain/models/fields/related.py

@@ -1,5 +1,3 @@
-import functools
-import inspect
 from functools import cached_property, partial
 
 from plain import exceptions, preflight
@@ -27,7 +25,7 @@ from .related_lookups import (
     RelatedLessThan,
     RelatedLessThanOrEqual,
 )
-from .reverse_related import ForeignObjectRel, ManyToManyRel, ManyToOneRel
+from .reverse_related import ManyToManyRel, ManyToOneRel
 
 RECURSIVE_RELATIONSHIP_CONSTANT = "self"
 
@@ -367,25 +365,15 @@ class RelatedField(FieldCacheMixin, Field):
         select all instances of self.related_field.model related through
         this field to obj. obj is an instance of self.model.
         """
-        base_q = Q.create(
+        return Q.create(
             [
                 (rh_field.attname, getattr(obj, lh_field.attname))
                 for lh_field, rh_field in self.related_fields
             ]
         )
-        descriptor_filter = self.get_extra_descriptor_filter(obj)
-        if isinstance(descriptor_filter, dict):
-            return base_q & Q(**descriptor_filter)
-        elif descriptor_filter:
-            return base_q & descriptor_filter
-        return base_q
 
     def set_attributes_from_rel(self):
-        self.name = self.name or (
-            self.remote_field.model._meta.model_name
-            + "_"
-            + self.remote_field.model._meta.pk.name
-        )
+        self.name = self.name or (self.remote_field.model._meta.model_name + "_" + "id")
         self.remote_field.set_field_name()
 
     def do_related_class(self, other, cls):
@@ -432,44 +420,58 @@ class RelatedField(FieldCacheMixin, Field):
         return self.name
 
 
-class ForeignObject(RelatedField):
-    """
-    Abstraction of the ForeignKey relation to support multi-column relations.
+class ForeignKey(RelatedField):
     """
+    Provide a many-to-one relation by adding a column to the local model
+    to hold the remote value.
 
-    # Field flags
-    many_to_many = False
-    many_to_one = True
-    one_to_many = False
+    ForeignKey targets the primary key (id) of the remote model.
+    """
 
-    requires_unique_target = True
+    descriptor_class = ForeignKeyDeferredAttribute
     related_accessor_class = ReverseManyToOneDescriptor
     forward_related_accessor_class = ForwardManyToOneDescriptor
-    rel_class = ForeignObjectRel
+    rel_class = ManyToOneRel
+
+    # Field flags - ForeignKey is many-to-one
+    many_to_one = True
+
+    empty_strings_allowed = False
+    default_error_messages = {
+        "invalid": "%(model)s instance with %(field)s %(value)r does not exist."
+    }
+    description = "Foreign Key (type determined by related field)"
 
     def __init__(
         self,
         to,
         on_delete,
-        from_fields,
-        to_fields,
-        rel=None,
         related_name=None,
         related_query_name=None,
         limit_choices_to=None,
-        parent_link=False,
+        db_index=True,
+        db_constraint=True,
         **kwargs,
     ):
-        if rel is None:
-            rel = self.rel_class(
-                self,
-                to,
-                related_name=related_name,
-                related_query_name=related_query_name,
-                limit_choices_to=limit_choices_to,
-                parent_link=parent_link,
-                on_delete=on_delete,
-            )
+        try:
+            to._meta.model_name
+        except AttributeError:
+            if not isinstance(to, str):
+                raise TypeError(
+                    f"{self.__class__.__name__}({to!r}) is invalid. First parameter to ForeignKey must be "
+                    f"either a model, a model name, or the string {RECURSIVE_RELATIONSHIP_CONSTANT!r}"
+                )
+        if not callable(on_delete):
+            raise TypeError("on_delete must be callable.")
+
+        rel = self.rel_class(
+            self,
+            to,
+            related_name=related_name,
+            related_query_name=related_query_name,
+            limit_choices_to=limit_choices_to,
+            on_delete=on_delete,
+        )
 
         super().__init__(
             rel=rel,
@@ -478,9 +480,8 @@ class ForeignObject(RelatedField):
             limit_choices_to=limit_choices_to,
             **kwargs,
         )
-
-        self.from_fields = from_fields
-        self.to_fields = to_fields
+        self.db_index = db_index
+        self.db_constraint = db_constraint
 
     def __copy__(self):
         obj = super().__copy__()
@@ -489,143 +490,6 @@ class ForeignObject(RelatedField):
         obj.__dict__.pop("reverse_path_infos", None)
         return obj
 
-    def check(self, **kwargs):
-        return [
-            *super().check(**kwargs),
-            *self._check_to_fields_exist(),
-            *self._check_unique_target(),
-        ]
-
-    def _check_to_fields_exist(self):
-        # Skip nonexistent models.
-        if isinstance(self.remote_field.model, str):
-            return []
-
-        errors = []
-        for to_field in self.to_fields:
-            if to_field:
-                try:
-                    self.remote_field.model._meta.get_field(to_field)
-                except exceptions.FieldDoesNotExist:
-                    errors.append(
-                        preflight.Error(
-                            f"The to_field '{to_field}' doesn't exist on the related "
-                            f"model '{self.remote_field.model._meta.label}'.",
-                            obj=self,
-                            id="fields.E312",
-                        )
-                    )
-        return errors
-
-    def _check_unique_target(self):
-        rel_is_string = isinstance(self.remote_field.model, str)
-        if rel_is_string or not self.requires_unique_target:
-            return []
-
-        try:
-            self.foreign_related_fields
-        except exceptions.FieldDoesNotExist:
-            return []
-
-        if not self.foreign_related_fields:
-            return []
-
-        unique_foreign_fields = {
-            frozenset([f.name])
-            for f in self.remote_field.model._meta.get_fields()
-            if getattr(f, "primary_key", False)
-        }
-        unique_foreign_fields.update(
-            {
-                frozenset(uc.fields)
-                for uc in self.remote_field.model._meta.total_unique_constraints
-            }
-        )
-        foreign_fields = {f.name for f in self.foreign_related_fields}
-        has_unique_constraint = any(u <= foreign_fields for u in unique_foreign_fields)
-
-        if not has_unique_constraint and len(self.foreign_related_fields) > 1:
-            field_combination = ", ".join(
-                f"'{rel_field.name}'" for rel_field in self.foreign_related_fields
-            )
-            model_name = self.remote_field.model.__name__
-            return [
-                preflight.Error(
-                    f"No subset of the fields {field_combination} on model '{model_name}' is unique.",
-                    hint=(
-                        "Add a set of "
-                        "fields to a unique constraint (via "
-                        "a UniqueConstraint (without condition) in the "
-                        "model Meta.constraints)."
-                    ),
-                    obj=self,
-                    id="fields.E310",
-                )
-            ]
-        elif not has_unique_constraint:
-            field_name = self.foreign_related_fields[0].name
-            model_name = self.remote_field.model.__name__
-            return [
-                preflight.Error(
-                    f"'{model_name}.{field_name}' must be unique because it is referenced by "
-                    "a foreign key.",
-                    hint=(
-                        "Add a UniqueConstraint (without condition) in the model "
-                        "Meta.constraints."
-                    ),
-                    obj=self,
-                    id="fields.E311",
-                )
-            ]
-        else:
-            return []
-
-    def deconstruct(self):
-        name, path, args, kwargs = super().deconstruct()
-        kwargs["on_delete"] = self.remote_field.on_delete
-        kwargs["from_fields"] = self.from_fields
-        kwargs["to_fields"] = self.to_fields
-
-        if self.remote_field.parent_link:
-            kwargs["parent_link"] = self.remote_field.parent_link
-        if isinstance(self.remote_field.model, SettingsReference):
-            kwargs["to"] = self.remote_field.model
-        elif isinstance(self.remote_field.model, str):
-            if "." in self.remote_field.model:
-                package_label, model_name = self.remote_field.model.split(".")
-                kwargs["to"] = f"{package_label}.{model_name.lower()}"
-            else:
-                kwargs["to"] = self.remote_field.model.lower()
-        else:
-            kwargs["to"] = self.remote_field.model._meta.label_lower
-        return name, path, args, kwargs
-
-    def resolve_related_fields(self):
-        if not self.from_fields or len(self.from_fields) != len(self.to_fields):
-            raise ValueError(
-                "Foreign Object from and to fields must be the same non-zero length"
-            )
-        if isinstance(self.remote_field.model, str):
-            raise ValueError(
-                f"Related model {self.remote_field.model!r} cannot be resolved"
-            )
-        related_fields = []
-        for index in range(len(self.from_fields)):
-            from_field_name = self.from_fields[index]
-            to_field_name = self.to_fields[index]
-            from_field = (
-                self
-                if from_field_name == RECURSIVE_RELATIONSHIP_CONSTANT
-                else self.opts.get_field(from_field_name)
-            )
-            to_field = (
-                self.remote_field.model._meta.pk
-                if to_field_name is None
-                else self.remote_field.model._meta.get_field(to_field_name)
-            )
-            related_fields.append((from_field, to_field))
-        return related_fields
-
     @cached_property
     def related_fields(self):
         return self.resolve_related_fields()
@@ -645,52 +509,28 @@ class ForeignObject(RelatedField):
         )
 
     def get_local_related_value(self, instance):
-        return self.get_instance_value_for_fields(instance, self.local_related_fields)
+        # Always returns the value of the single local field
+        field = self.local_related_fields[0]
+        if field.primary_key:
+            return (instance.id,)
+        return (getattr(instance, field.attname),)
 
     def get_foreign_related_value(self, instance):
-        return self.get_instance_value_for_fields(instance, self.foreign_related_fields)
-
-    @staticmethod
-    def get_instance_value_for_fields(instance, fields):
-        ret = []
-        for field in fields:
-            # Gotcha: in some cases (like fixture loading) a model can have
-            # different values in parent_ptr_id and parent's id. So, use
-            # instance.pk (that is, parent_ptr_id) when asked for instance.id.
-            if field.primary_key:
-                ret.append(instance.pk)
-                continue
-            ret.append(getattr(instance, field.attname))
-        return tuple(ret)
-
-    def get_attname_column(self):
-        attname, column = super().get_attname_column()
-        return attname, None
+        # Always returns the id of the foreign instance
+        return (instance.id,)
 
     def get_joining_columns(self, reverse_join=False):
-        source = self.reverse_related_fields if reverse_join else self.related_fields
-        return tuple(
-            (lhs_field.column, rhs_field.column) for lhs_field, rhs_field in source
-        )
+        # Always returns a single column pair
+        if reverse_join:
+            from_field, to_field = self.related_fields[0]
+            return ((to_field.column, from_field.column),)
+        else:
+            from_field, to_field = self.related_fields[0]
+            return ((from_field.column, to_field.column),)
 
     def get_reverse_joining_columns(self):
         return self.get_joining_columns(reverse_join=True)
 
-    def get_extra_descriptor_filter(self, instance):
-        """
-        Return an extra filter condition for related object fetching when
-        user does 'instance.fieldname', that is the extra filter is used in
-        the descriptor of the field.
-
-        The filter should be either a dict usable in .filter(**kwargs) call or
-        a Q-object. The condition will be ANDed together with the relation's
-        joining columns.
-
-        A parallel method is get_extra_restriction() which is used in
-        JOIN and subquery conditions.
-        """
-        return {}
-
     def get_extra_restriction(self, alias, related_alias):
         """
         Return a pair condition used for joining and subquery pushdown. The
@@ -733,7 +573,7 @@ class ForeignObject(RelatedField):
             PathInfo(
                 from_opts=from_opts,
                 to_opts=opts,
-                target_fields=(opts.pk,),
+                target_fields=(opts.get_field("id"),),
                 join_field=self.remote_field,
                 m2m=not self.primary_key,
                 direct=False,
@@ -745,14 +585,6 @@ class ForeignObject(RelatedField):
     def reverse_path_infos(self):
         return self.get_reverse_path_info()
 
-    @classmethod
-    @functools.cache
-    def get_class_lookups(cls):
-        bases = inspect.getmro(cls)
-        bases = bases[: bases.index(ForeignObject) + 1]
-        class_lookups = [parent.__dict__.get("class_lookups", {}) for parent in bases]
-        return cls.merge_dicts(class_lookups)
-
     def contribute_to_class(self, cls, name, private_only=False, **kwargs):
         super().contribute_to_class(cls, name, private_only=private_only, **kwargs)
         setattr(cls, self.name, self.forward_related_accessor_class(self))
@@ -773,95 +605,6 @@ class ForeignObject(RelatedField):
                     self.remote_field.limit_choices_to
                 )
 
-
-ForeignObject.register_lookup(RelatedIn)
-ForeignObject.register_lookup(RelatedExact)
-ForeignObject.register_lookup(RelatedLessThan)
-ForeignObject.register_lookup(RelatedGreaterThan)
-ForeignObject.register_lookup(RelatedGreaterThanOrEqual)
-ForeignObject.register_lookup(RelatedLessThanOrEqual)
-ForeignObject.register_lookup(RelatedIsNull)
-
-
-class ForeignKey(ForeignObject):
-    """
-    Provide a many-to-one relation by adding a column to the local model
-    to hold the remote value.
-
-    By default ForeignKey will target the pk of the remote model but this
-    behavior can be changed by using the ``to_field`` argument.
-    """
-
-    descriptor_class = ForeignKeyDeferredAttribute
-    # Field flags
-    many_to_many = False
-    many_to_one = True
-    one_to_many = False
-
-    rel_class = ManyToOneRel
-
-    empty_strings_allowed = False
-    default_error_messages = {
-        "invalid": "%(model)s instance with %(field)s %(value)r does not exist."
-    }
-    description = "Foreign Key (type determined by related field)"
-
-    def __init__(
-        self,
-        to,
-        on_delete,
-        related_name=None,
-        related_query_name=None,
-        limit_choices_to=None,
-        parent_link=False,
-        to_field=None,
-        db_index=True,
-        db_constraint=True,
-        **kwargs,
-    ):
-        try:
-            to._meta.model_name
-        except AttributeError:
-            if not isinstance(to, str):
-                raise TypeError(
-                    f"{self.__class__.__name__}({to!r}) is invalid. First parameter to ForeignKey must be "
-                    f"either a model, a model name, or the string {RECURSIVE_RELATIONSHIP_CONSTANT!r}"
-                )
-        else:
-            # For backwards compatibility purposes, we need to *try* and set
-            # the to_field during FK construction. It won't be guaranteed to
-            # be correct until contribute_to_class is called. Refs #12190.
-            to_field = to_field or (to._meta.pk and to._meta.pk.name)
-        if not callable(on_delete):
-            raise TypeError("on_delete must be callable.")
-
-        kwargs["rel"] = self.rel_class(
-            self,
-            to,
-            to_field,
-            related_name=related_name,
-            related_query_name=related_query_name,
-            limit_choices_to=limit_choices_to,
-            parent_link=parent_link,
-            on_delete=on_delete,
-        )
-
-        super().__init__(
-            to,
-            on_delete,
-            related_name=related_name,
-            related_query_name=related_query_name,
-            limit_choices_to=limit_choices_to,
-            from_fields=[RECURSIVE_RELATIONSHIP_CONSTANT],
-            to_fields=[to_field],
-            **kwargs,
-        )
-        self.db_index = db_index
-        self.db_constraint = db_constraint
-
-    def __class_getitem__(cls, *args, **kwargs):
-        return cls
-
     def check(self, **kwargs):
         return [
             *super().check(**kwargs),
@@ -896,8 +639,18 @@ class ForeignKey(ForeignObject):
 
     def deconstruct(self):
         name, path, args, kwargs = super().deconstruct()
-        del kwargs["to_fields"]
-        del kwargs["from_fields"]
+        kwargs["on_delete"] = self.remote_field.on_delete
+
+        if isinstance(self.remote_field.model, SettingsReference):
+            kwargs["to"] = self.remote_field.model
+        elif isinstance(self.remote_field.model, str):
+            if "." in self.remote_field.model:
+                package_label, model_name = self.remote_field.model.split(".")
+                kwargs["to"] = f"{package_label}.{model_name.lower()}"
+            else:
+                kwargs["to"] = self.remote_field.model.lower()
+        else:
+            kwargs["to"] = self.remote_field.model._meta.label_lower
 
         if self.db_index is not True:
             kwargs["db_index"] = self.db_index
@@ -905,13 +658,6 @@ class ForeignKey(ForeignObject):
         if self.db_constraint is not True:
             kwargs["db_constraint"] = self.db_constraint
 
-        # Rel needs more work.
-        to_meta = getattr(self.remote_field.model, "_meta", None)
-        if self.remote_field.field_name and (
-            not to_meta
-            or (to_meta.pk and self.remote_field.field_name != to_meta.pk.name)
-        ):
-            kwargs["to_field"] = self.remote_field.field_name
         return name, path, args, kwargs
 
     def to_python(self, value):
@@ -922,8 +668,6 @@ class ForeignKey(ForeignObject):
         return self.foreign_related_fields[0]
 
     def validate(self, value, model_instance):
-        if self.remote_field.parent_link:
-            return
         super().validate(value, model_instance)
         if value is None:
             return
@@ -938,14 +682,21 @@ class ForeignKey(ForeignObject):
                 code="invalid",
                 params={
                     "model": self.remote_field.model._meta.model_name,
-                    "pk": value,
+                    "id": value,
                     "field": self.remote_field.field_name,
                     "value": value,
-                },  # 'pk' is included for backwards compatibility
+                },
             )
 
     def resolve_related_fields(self):
-        related_fields = super().resolve_related_fields()
+        if isinstance(self.remote_field.model, str):
+            raise ValueError(
+                f"Related model {self.remote_field.model!r} cannot be resolved"
+            )
+        from_field = self
+        to_field = self.remote_field.model._meta.get_field("id")
+        related_fields = [(from_field, to_field)]
+
         for from_field, to_field in related_fields:
             if (
                 to_field
@@ -986,11 +737,6 @@ class ForeignKey(ForeignObject):
     def get_prep_value(self, value):
         return self.target_field.get_prep_value(value)
 
-    def contribute_to_related_class(self, cls, related):
-        super().contribute_to_related_class(cls, related)
-        if self.remote_field.field_name is None:
-            self.remote_field.field_name = cls._meta.pk.name
-
     def db_check(self, connection):
         return None
 
@@ -1008,15 +754,6 @@ class ForeignKey(ForeignObject):
             "collation": target_db_parameters.get("collation"),
         }
 
-    def convert_empty_strings(self, value, expression, connection):
-        if (not value) and isinstance(value, str):
-            return None
-        return value
-
-    def get_db_converters(self, connection):
-        converters = super().get_db_converters(connection)
-        return converters
-
     def get_col(self, alias, output_field=None):
         if output_field is None:
             output_field = self.target_field
@@ -1027,6 +764,16 @@ class ForeignKey(ForeignObject):
         return super().get_col(alias, output_field)
 
 
+# Register lookups for ForeignKey
+ForeignKey.register_lookup(RelatedIn)
+ForeignKey.register_lookup(RelatedExact)
+ForeignKey.register_lookup(RelatedLessThan)
+ForeignKey.register_lookup(RelatedGreaterThan)
+ForeignKey.register_lookup(RelatedGreaterThanOrEqual)
+ForeignKey.register_lookup(RelatedLessThanOrEqual)
+ForeignKey.register_lookup(RelatedIsNull)
+
+
 class ManyToManyField(RelatedField):
     """
     Provide a many-to-many relation by using an intermediary model that
@@ -1557,7 +1304,7 @@ class ManyToManyField(RelatedField):
         pass
 
     def value_from_object(self, obj):
-        return [] if obj.pk is None else list(getattr(obj, self.attname).all())
+        return [] if obj.id is None else list(getattr(obj, self.attname).all())
 
     def save_form_data(self, instance, data):
         getattr(instance, self.attname).set(data)

plain/models/fields/related_descriptors.py

@@ -408,10 +408,10 @@ def create_reverse_many_to_one_manager(superclass, rel):
                 pass  # nothing to clear from cache
 
         def get_queryset(self):
-            # Even if this relation is not to pk, we require still pk value.
+            # Even if this relation is not to primary key, we require still primary key value.
             # The wish is that the instance has been already saved to DB,
-            # although having a pk value isn't a guarantee of that.
-            if self.instance.pk is None:
+            # although having a primary key value isn't a guarantee of that.
+            if self.instance.id is None:
                 raise ValueError(
                     f"{self.instance.__class__.__name__!r} instance needs to have a "
                     f"primary key value before this relationship can be used."
@@ -456,7 +456,7 @@ def create_reverse_many_to_one_manager(superclass, rel):
                 setattr(obj, self.field.name, self.instance)
 
             if bulk:
-                pks = []
+                ids = []
                 for obj in objs:
                     check_and_update_obj(obj)
                     if obj._state.adding:
@@ -464,8 +464,8 @@ def create_reverse_many_to_one_manager(superclass, rel):
                             f"{obj!r} instance isn't saved. Use bulk=False or save "
                             "the object first."
                         )
-                    pks.append(obj.pk)
-                self.model._base_manager.filter(pk__in=pks).update(
+                    ids.append(obj.id)
+                self.model._base_manager.filter(id__in=ids).update(
                     **{
                         self.field.name: self.instance,
                     }
@@ -508,12 +508,12 @@ def create_reverse_many_to_one_manager(superclass, rel):
                         )
                     # Is obj actually part of this descriptor set?
                     if self.field.get_local_related_value(obj) == val:
-                        old_ids.add(obj.pk)
+                        old_ids.add(obj.id)
                     else:
                         raise self.field.remote_field.model.DoesNotExist(
                             f"{obj!r} is not related to {self.instance!r}."
                         )
-                self._clear(self.filter(pk__in=old_ids), bulk)
+                self._clear(self.filter(id__in=old_ids), bulk)
 
             def clear(self, *, bulk=True):
                 self._check_fk_val()
@@ -641,22 +641,22 @@ def create_forward_many_to_many_manager(superclass, rel, reverse):
             self.target_field = self.through._meta.get_field(self.target_field_name)
 
             self.core_filters = {}
-            self.pk_field_names = {}
+            self.id_field_names = {}
             for lh_field, rh_field in self.source_field.related_fields:
                 core_filter_key = f"{self.query_field_name}__{rh_field.name}"
                 self.core_filters[core_filter_key] = getattr(instance, rh_field.attname)
-                self.pk_field_names[lh_field.name] = rh_field.name
+                self.id_field_names[lh_field.name] = rh_field.name
 
             self.related_val = self.source_field.get_foreign_related_value(instance)
             if None in self.related_val:
                 raise ValueError(
-                    f'"{instance!r}" needs to have a value for field "{self.pk_field_names[self.source_field_name]}" before '
+                    f'"{instance!r}" needs to have a value for field "{self.id_field_names[self.source_field_name]}" before '
                     "this many-to-many relationship can be used."
                 )
-            # Even if this relation is not to pk, we require still pk value.
+            # Even if this relation is not to primary key, we require still primary key value.
             # The wish is that the instance has been already saved to DB,
-            # although having a pk value isn't a guarantee of that.
-            if instance.pk is None:
+            # although having a primary key value isn't a guarantee of that.
+            if instance.id is None:
                 raise ValueError(
                     f"{instance.__class__.__name__!r} instance needs to have a primary key value before "
                     "a many-to-many relationship can be used."

plain/models/fields/related_lookups.py

@@ -41,7 +41,7 @@ def get_normalized_value(value, lhs):
     from plain.models import Model
 
     if isinstance(value, Model):
-        if value.pk is None:
+        if value.id is None:
             raise ValueError("Model instances passed to related filters must be saved.")
         value_list = []
         sources = lhs.output_field.path_infos[-1].target_fields
@@ -55,7 +55,7 @@ def get_normalized_value(value, lhs):
             except AttributeError:
                 # A case like Restaurant.objects.filter(place=restaurant_instance),
                 # where place is a OneToOneField and the primary key of Restaurant.
-                return (value.pk,)
+                return (value.id,)
         return tuple(value_list)
     if not isinstance(value, tuple):
         return (value,)