import functools

import inspect

import warnings

from functools import partial

from django import forms

from django.apps import apps

from django.conf import SettingsReference, settings

from django.core import checks, exceptions

from django.db import connection, router

from django.db.backends import utils

from django.db.models import Q

from django.db.models.constants import LOOKUP_SEP

from django.db.models.deletion import CASCADE, SET_DEFAULT, SET_NULL

from django.db.models.query_utils import PathInfo

from django.db.models.utils import make_model_tuple

from django.utils.deprecation import RemovedInDjango60Warning

from django.utils.functional import cached_property

from django.utils.translation import gettext_lazy as _

from . import Field

from .mixins import FieldCacheMixin

from .related_descriptors import (

ForeignKeyDeferredAttribute,

ForwardManyToOneDescriptor,

ForwardOneToOneDescriptor,

ManyToManyDescriptor,

ReverseManyToOneDescriptor,

ReverseOneToOneDescriptor,

)

from .related_lookups import (

RelatedExact,

RelatedGreaterThan,

RelatedGreaterThanOrEqual,

RelatedIn,

RelatedIsNull,

RelatedLessThan,

RelatedLessThanOrEqual,

)

from .reverse_related import ForeignObjectRel, ManyToManyRel, ManyToOneRel, OneToOneRel

RECURSIVE_RELATIONSHIP_CONSTANT = "self"

def resolve_relation(scope_model, relation):

"""

Transform relation into a model or fully-qualified model string of the form

"app_label.ModelName", relative to scope_model.

The relation argument can be:

* RECURSIVE_RELATIONSHIP_CONSTANT, i.e. the string "self", in which case

the model argument will be returned.

* A bare model name without an app_label, in which case scope_model's

app_label will be prepended.

* An "app_label.ModelName" string.

* A model class, which will be returned unchanged.

"""

# Check for recursive relations

if relation == RECURSIVE_RELATIONSHIP_CONSTANT:

relation = scope_model

# Look for an "app.Model" relation

if isinstance(relation, str):

if "." not in relation:

relation = "%s.%s" % (scope_model._meta.app_label, relation)

return relation

def lazy_related_operation(function, model, *related_models, **kwargs):

"""

Schedule `function` to be called once `model` and all `related_models`

have been imported and registered with the app registry. `function` will

be called with the newly-loaded model classes as its positional arguments,

plus any optional keyword arguments.

The `model` argument must be a model class. Each subsequent positional

argument is another model, or a reference to another model - see

`resolve_relation()` for the various forms these may take. Any relative

references will be resolved relative to `model`.

This is a convenience wrapper for `Apps.lazy_model_operation` - the app

registry model used is the one found in `model._meta.apps`.

"""

models = [model] + [resolve_relation(model, rel) for rel in related_models]

model_keys = (make_model_tuple(m) for m in models)

apps = model._meta.apps

return apps.lazy_model_operation(partial(function, **kwargs), *model_keys)

class RelatedField(FieldCacheMixin, Field):

"""Base class that all relational fields inherit from."""

# Field flags

one_to_many = False

one_to_one = False

many_to_many = False

many_to_one = False

def __init__(

self,

related_name=None,

related_query_name=None,

limit_choices_to=None,

**kwargs,

):

self._related_name = related_name

self._related_query_name = related_query_name

self._limit_choices_to = limit_choices_to

super().__init__(**kwargs)

@cached_property

def related_model(self):

# Can't cache this property until all the models are loaded.

apps.check_models_ready()

return self.remote_field.model

def check(self, **kwargs):

return [

*super().check(**kwargs),

*self._check_related_name_is_valid(),

*self._check_related_query_name_is_valid(),

*self._check_relation_model_exists(),

*self._check_referencing_to_swapped_model(),

*self._check_clashes(),

]

def _check_related_name_is_valid(self):

import keyword

related_name = self.remote_field.related_name

if related_name is None:

return []

is_valid_id = (

not keyword.iskeyword(related_name) and related_name.isidentifier()

)

if not (is_valid_id or related_name.endswith("+")):

return [

checks.Error(

"The name '%s' is invalid related_name for field %s.%s"

% (

self.remote_field.related_name,

self.model._meta.object_name,

self.name,

),

hint=(

"Related name must be a valid Python identifier or end with a "

"'+'"

),

obj=self,

id="fields.E306",

)

]

return []

def _check_related_query_name_is_valid(self):

if self.remote_field.hidden:

return []

rel_query_name = self.related_query_name()

errors = []

if rel_query_name.endswith("_"):

errors.append(

checks.Error(

"Reverse query name '%s' must not end with an underscore."

% rel_query_name,

hint=(

"Add or change a related_name or related_query_name "

"argument for this field."

),

obj=self,

id="fields.E308",

)

)

if LOOKUP_SEP in rel_query_name:

errors.append(

checks.Error(

"Reverse query name '%s' must not contain '%s'."

% (rel_query_name, LOOKUP_SEP),

hint=(

"Add or change a related_name or related_query_name "

"argument for this field."

),

obj=self,

id="fields.E309",

)

)

return errors

def _check_relation_model_exists(self):

rel_is_missing = self.remote_field.model not in self.opts.apps.get_models()

rel_is_string = isinstance(self.remote_field.model, str)

model_name = (

self.remote_field.model

if rel_is_string

else self.remote_field.model._meta.object_name

)

if rel_is_missing and (

rel_is_string or not self.remote_field.model._meta.swapped

):

return [

checks.Error(

"Field defines a relation with model '%s', which is either "

"not installed, or is abstract." % model_name,

obj=self,

id="fields.E300",

)

]

return []

def _check_referencing_to_swapped_model(self):

if (

self.remote_field.model not in self.opts.apps.get_models()

and not isinstance(self.remote_field.model, str)

and self.remote_field.model._meta.swapped

):

return [

checks.Error(

"Field defines a relation with the model '%s', which has "

"been swapped out." % self.remote_field.model._meta.label,

hint="Update the relation to point at 'settings.%s'."

% self.remote_field.model._meta.swappable,

obj=self,

id="fields.E301",

)

]

return []

def _check_clashes(self):

"""Check accessor and reverse query name clashes."""

from django.db.models.base import ModelBase

errors = []

opts = self.model._meta

# f.remote_field.model may be a string instead of a model. Skip if

# model name is not resolved.

if not isinstance(self.remote_field.model, ModelBase):

return []

# Consider that we are checking field `Model.foreign` and the models

# are:

#

# class Target(models.Model):

# model = models.IntegerField()

# model_set = models.IntegerField()

#

# class Model(models.Model):

# foreign = models.ForeignKey(Target)

# m2m = models.ManyToManyField(Target)

# rel_opts.object_name == "Target"

rel_opts = self.remote_field.model._meta

# If the field doesn't install a backward relation on the target model

# (so `is_hidden` returns True), then there are no clashes to check

# and we can skip these fields.

rel_is_hidden = self.remote_field.hidden

rel_name = self.remote_field.accessor_name # i. e. "model_set"

rel_query_name = self.related_query_name() # i. e. "model"

# i.e. "app_label.Model.field".

field_name = "%s.%s" % (opts.label, self.name)

# Check clashes between accessor or reverse query name of `field`

# and any other field name -- i.e. accessor for Model.foreign is

# model_set and it clashes with Target.model_set.

potential_clashes = rel_opts.fields + rel_opts.many_to_many

for clash_field in potential_clashes:

if not rel_is_hidden and clash_field.name == rel_name:

clash_name = f"{rel_opts.label}.{clash_field.name}"

errors.append(

checks.Error(

f"Reverse accessor '{rel_opts.object_name}.{rel_name}' "

f"for '{field_name}' clashes with field name "

f"'{clash_name}'.",

hint=(

"Rename field '%s', or add/change a related_name "

"argument to the definition for field '%s'."

)

% (clash_name, field_name),

obj=self,

id="fields.E302",

)

)

if clash_field.name == rel_query_name:

clash_name = f"{rel_opts.label}.{clash_field.name}"

errors.append(

checks.Error(

"Reverse query name for '%s' clashes with field name '%s'."

% (field_name, clash_name),

hint=(

"Rename field '%s', or add/change a related_name "

"argument to the definition for field '%s'."

)

% (clash_name, field_name),

obj=self,

id="fields.E303",

)

)

# Check clashes between accessors/reverse query names of `field` and

# any other field accessor -- i. e. Model.foreign accessor clashes with

# Model.m2m accessor.

potential_clashes = (r for r in rel_opts.related_objects if r.field is not self)

for clash_field in potential_clashes:

if not rel_is_hidden and clash_field.accessor_name == rel_name:

clash_name = (

f"{clash_field.related_model._meta.label}.{clash_field.field.name}"

)

errors.append(

checks.Error(

f"Reverse accessor '{rel_opts.object_name}.{rel_name}' "

f"for '{field_name}' clashes with reverse accessor for "

f"'{clash_name}'.",

hint=(

"Add or change a related_name argument "

"to the definition for '%s' or '%s'."

)

% (field_name, clash_name),

obj=self,

id="fields.E304",

)

)

if clash_field.accessor_name == rel_query_name:

clash_name = (

f"{clash_field.related_model._meta.label}.{clash_field.field.name}"

)

errors.append(

checks.Error(

"Reverse query name for '%s' clashes with reverse query name "

"for '%s'." % (field_name, clash_name),

hint=(

"Add or change a related_name argument "

"to the definition for '%s' or '%s'."

)

% (field_name, clash_name),

obj=self,

id="fields.E305",

)

)

return errors

def db_type(self, connection):

# By default related field will not have a column as it relates to

# columns from another table.

return None

def contribute_to_class(self, cls, name, private_only=False, **kwargs):

super().contribute_to_class(cls, name, private_only=private_only, **kwargs)

self.opts = cls._meta

if not cls._meta.abstract:

if self.remote_field.related_name:

related_name = self.remote_field.related_name

else:

related_name = self.opts.default_related_name

if related_name:

related_name %= {

"class": cls.__name__.lower(),

"model_name": cls._meta.model_name.lower(),

"app_label": cls._meta.app_label.lower(),

}

self.remote_field.related_name = related_name

if self.remote_field.related_query_name:

related_query_name = self.remote_field.related_query_name % {

"class": cls.__name__.lower(),

"app_label": cls._meta.app_label.lower(),

}

self.remote_field.related_query_name = related_query_name

def resolve_related_class(model, related, field):

field.remote_field.model = related

field.do_related_class(related, model)

lazy_related_operation(

resolve_related_class, cls, self.remote_field.model, field=self

)

def deconstruct(self):

name, path, args, kwargs = super().deconstruct()

if self._limit_choices_to:

kwargs["limit_choices_to"] = self._limit_choices_to

if self._related_name is not None:

kwargs["related_name"] = self._related_name

if self._related_query_name is not None:

kwargs["related_query_name"] = self._related_query_name

return name, path, args, kwargs

def get_forward_related_filter(self, obj):

"""

Return the keyword arguments that when supplied to

self.model.object.filter(), would select all instances related through

this field to the remote obj. This is used to build the querysets

returned by related descriptors. obj is an instance of

self.related_field.model.

"""

return {

"%s__%s" % (self.name, rh_field.name): getattr(obj, rh_field.attname)

for _, rh_field in self.related_fields

}

def get_reverse_related_filter(self, obj):

"""

Complement to get_forward_related_filter(). Return the keyword

arguments that when passed to self.related_field.model.object.filter()

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(

[

(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

@property

def swappable_setting(self):

"""

Get the setting that this is powered from for swapping, or None

if it's not swapped in / marked with swappable=False.

"""

if self.swappable:

# Work out string form of "to"

if isinstance(self.remote_field.model, str):

to_string = self.remote_field.model

else:

to_string = self.remote_field.model._meta.label

return apps.get_swappable_settings_name(to_string)

return None

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

)

if self.verbose_name is None:

self.verbose_name = self.remote_field.model._meta.verbose_name

self.remote_field.set_field_name()

def do_related_class(self, other, cls):

self.set_attributes_from_rel()

self.contribute_to_related_class(other, self.remote_field)

def get_limit_choices_to(self):

"""

Return ``limit_choices_to`` for this model field.

If it is a callable, it will be invoked and the result will be

returned.

"""

if callable(self.remote_field.limit_choices_to):

return self.remote_field.limit_choices_to()

return self.remote_field.limit_choices_to

def formfield(self, **kwargs):

"""

Pass ``limit_choices_to`` to the field being constructed.

Only passes it if there is a type that supports related fields.

This is a similar strategy used to pass the ``queryset`` to the field

being constructed.

"""

defaults = {}

if hasattr(self.remote_field, "get_related_field"):

# If this is a callable, do not invoke it here. Just pass

# it in the defaults for when the form class will later be

# instantiated.

limit_choices_to = self.remote_field.limit_choices_to

defaults.update(

{

"limit_choices_to": limit_choices_to,

}

)

defaults.update(kwargs)

return super().formfield(**defaults)

def related_query_name(self):

"""

Define the name that can be used to identify this related object in a

table-spanning query.

"""

return (

self.remote_field.related_query_name

or self.remote_field.related_name

or self.opts.model_name

)

@property

def target_field(self):

"""

When filtering against this relation, return the field on the remote

model against which the filtering should happen.

"""

target_fields = self.path_infos[-1].target_fields

if len(target_fields) > 1:

raise exceptions.FieldError(

"The relation has multiple target fields, but only single target field "

"was asked for"

)

return target_fields[0]

@cached_property

def cache_name(self):

return self.name

class ForeignObject(RelatedField):

"""

Abstraction of the ForeignKey relation to support multi-column relations.

"""

# Field flags

many_to_many = False

many_to_one = True

one_to_many = False

one_to_one = False

requires_unique_target = True

related_accessor_class = ReverseManyToOneDescriptor

forward_related_accessor_class = ForwardManyToOneDescriptor

rel_class = ForeignObjectRel

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,

swappable=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,

)

super().__init__(

rel=rel,

related_name=related_name,

related_query_name=related_query_name,

limit_choices_to=limit_choices_to,

**kwargs,

)

self.from_fields = from_fields

self.to_fields = to_fields

self.swappable = swappable

def __copy__(self):

obj = super().__copy__()

# Remove any cached PathInfo values.

obj.__dict__.pop("path_infos", None)

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(

checks.Error(

"The to_field '%s' doesn't exist on the related "

"model '%s'."

% (to_field, 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 []

has_unique_constraint = any(

rel_field.unique for rel_field in self.foreign_related_fields

)

if not has_unique_constraint:

foreign_fields = {f.name for f in self.foreign_related_fields}

remote_opts = self.remote_field.model._meta

has_unique_constraint = any(

frozenset(ut) <= foreign_fields for ut in remote_opts.unique_together

) or any(

frozenset(uc.fields) <= foreign_fields

for uc in remote_opts.total_unique_constraints

)

if not has_unique_constraint:

if 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 [

checks.Error(

f"No subset of the fields {field_combination} on model "

f"'{model_name}' is unique.",

hint=(

"Mark a single field as unique=True or add a set of "

"fields to a unique constraint (via unique_together "

"or a UniqueConstraint (without condition) in the "

"model Meta.constraints)."

),

obj=self,

id="fields.E310",

)

]

else:

field_name = self.foreign_related_fields[0].name

model_name = self.remote_field.model.__name__

return [

checks.Error(

f"'{model_name}.{field_name}' must be unique because it is "

"referenced by a foreign key.",

hint=(

"Add unique=True to this field or add a "

"UniqueConstraint (without condition) in the model "

"Meta.constraints."

),

obj=self,

id="fields.E311",

)

]

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, str):

if "." in self.remote_field.model:

app_label, model_name = self.remote_field.model.split(".")

kwargs["to"] = "%s.%s" % (app_label, model_name.lower())

else:

kwargs["to"] = self.remote_field.model.lower()

else:

kwargs["to"] = self.remote_field.model._meta.label_lower

# If swappable is True, then see if we're actually pointing to the target

# of a swap.

swappable_setting = self.swappable_setting

if swappable_setting is not None:

# If it's already a settings reference, error

if hasattr(kwargs["to"], "setting_name"):

if kwargs["to"].setting_name != swappable_setting:

raise ValueError(

"Cannot deconstruct a ForeignKey pointing to a model "

"that is swapped in place of more than one model (%s and %s)"

% (kwargs["to"].setting_name, swappable_setting)

)

# Set it

kwargs["to"] = SettingsReference(

kwargs["to"],

swappable_setting,

)

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(

"Related model %r cannot be resolved" % self.remote_field.model

)

related_fields = []

for from_field_name, to_field_name in zip(self.from_fields, self.to_fields):

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()

@cached_property

def reverse_related_fields(self):

return [(rhs_field, lhs_field) for lhs_field, rhs_field in self.related_fields]

@cached_property

def local_related_fields(self):

return tuple(lhs_field for lhs_field, rhs_field in self.related_fields)

@cached_property

def foreign_related_fields(self):

return tuple(

rhs_field for lhs_field, rhs_field in self.related_fields if rhs_field

)

def get_local_related_value(self, instance):

return self.get_instance_value_for_fields(instance, self.local_related_fields)

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 = []

opts = instance._meta

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:

possible_parent_link = opts.get_ancestor_link(field.model)

if (

not possible_parent_link

or possible_parent_link.primary_key

or possible_parent_link.model._meta.abstract

):

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

def get_joining_columns(self, reverse_join=False):

warnings.warn(

"ForeignObject.get_joining_columns() is deprecated. Use "

"get_joining_fields() instead.",

RemovedInDjango60Warning,

)

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

)

def get_reverse_joining_columns(self):

warnings.warn(

"ForeignObject.get_reverse_joining_columns() is deprecated. Use "

"get_reverse_joining_fields() instead.",

RemovedInDjango60Warning,

)

return self.get_joining_columns(reverse_join=True)

def get_joining_fields(self, reverse_join=False):

return tuple(

self.reverse_related_fields if reverse_join else self.related_fields

)

def get_reverse_joining_fields(self):

return self.get_joining_fields(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

condition is something that responds to as_sql(compiler, connection)

method.

Note that currently referring both the 'alias' and 'related_alias'

will not work in some conditions, like subquery pushdown.

A parallel method is get_extra_descriptor_filter() which is used in

instance.fieldname related object fetching.

"""

return None

def get_path_info(self, filtered_relation=None):

"""Get path from this field to the related model."""

opts = self.remote_field.model._meta

from_opts = self.model._meta

return [

PathInfo(

from_opts=from_opts,

to_opts=opts,

target_fields=self.foreign_related_fields,

join_field=self,

m2m=False,

direct=True,

filtered_relation=filtered_relation,

)

]

@cached_property

def path_infos(self):

return self.get_path_info()

def get_reverse_path_info(self, filtered_relation=None):

"""Get path from the related model to this field's model."""

opts = self.model._meta

from_opts = self.remote_field.model._meta

return [

PathInfo(

from_opts=from_opts,

to_opts=opts,

target_fields=(opts.pk,),

join_field=self.remote_field,

m2m=not self.unique,

direct=False,

filtered_relation=filtered_relation,

)

]

@cached_property

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))

def contribute_to_related_class(self, cls, related):

# Internal FK's - i.e., those with a related name ending with '+' -

# and swapped models don't get a related descriptor.

if not self.remote_field.hidden and not related.related_model._meta.swapped:

setattr(

cls._meta.concrete_model,

related.accessor_name,

self.related_accessor_class(related),

)

# While 'limit_choices_to' might be a callable, simply pass

# it along for later - this is too early because it's still

# model load time.

if self.remote_field.limit_choices_to:

cls._meta.related_fkey_lookups.append(

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

one_to_one = 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_constraint=True,

**kwargs,

):

try:

to._meta.model_name

except AttributeError:

if not isinstance(to, str):

raise TypeError(

"%s(%r) is invalid. First parameter to ForeignKey must be "

"either a model, a model name, or the string %r"

% (

self.__class__.__name__,

to,

RECURSIVE_RELATIONSHIP_CONSTANT,

)

)

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,

)

kwargs.setdefault("db_index", True)

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_constraint = db_constraint

def __class_getitem__(cls, *args, **kwargs):

return cls

def check(self, **kwargs):

return [

*super().check(**kwargs),

*self._check_on_delete(),

*self._check_unique(),