import datetime

import tempfile

import uuid

from django.contrib import admin

from django.contrib.auth.models import User

from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation

from django.contrib.contenttypes.models import ContentType

from django.core.exceptions import ValidationError

from django.core.files.storage import FileSystemStorage

from django.db import models

class Section(models.Model):

    """

    A simple section that links to articles, to test linking to related items

    in admin views.

    """

    name = models.CharField(max_length=100)

    def __str__(self):

        return self.name

    @property

    def name_property(self):

        """

        A property that simply returns the name. Used to test #24461

        """

        return self.name

class Article(models.Model):

    """

    A simple article to test admin views. Test backwards compatibility.

    """

    title = models.CharField(max_length=100)

    content = models.TextField()

    date = models.DateTimeField()

    section = models.ForeignKey(Section, models.CASCADE, null=True, blank=True)

    another_section = models.ForeignKey(

        Section, models.CASCADE, null=True, blank=True, related_name="+"

    )

    sub_section = models.ForeignKey(

        Section, models.SET_NULL, null=True, blank=True, related_name="+"

    )

    def __str__(self):

        return self.title

    @admin.display(ordering="date", description="")

    def model_year(self):

        return self.date.year

    @admin.display(ordering="-date", description="")

    def model_year_reversed(self):

        return self.date.year

    @property

    @admin.display(ordering="date")

    def model_property_year(self):

        return self.date.year

    @property

    def model_month(self):

        return self.date.month

class Book(models.Model):

    """

    A simple book that has chapters.

    """

    name = models.CharField(max_length=100, verbose_name="¿Name?")

    def __str__(self):

        return self.name

class Promo(models.Model):

    name = models.CharField(max_length=100, verbose_name="¿Name?")

    book = models.ForeignKey(Book, models.CASCADE)

    author = models.ForeignKey(User, models.SET_NULL, blank=True, null=True)

    def __str__(self):

        return self.name

class Chapter(models.Model):

    title = models.CharField(max_length=100, verbose_name="¿Title?")

    content = models.TextField()

    book = models.ForeignKey(Book, models.CASCADE)

    class Meta:

        # Use a utf-8 bytestring to ensure it works (see #11710)

        verbose_name = "¿Chapter?"

    def __str__(self):

        return self.title

class ChapterXtra1(models.Model):

    chap = models.OneToOneField(Chapter, models.CASCADE, verbose_name="¿Chap?")

    xtra = models.CharField(max_length=100, verbose_name="¿Xtra?")

    guest_author = models.ForeignKey(User, models.SET_NULL, blank=True, null=True)

    def __str__(self):

        return "¿Xtra1: %s" % self.xtra

class ChapterXtra2(models.Model):

    chap = models.OneToOneField(Chapter, models.CASCADE, verbose_name="¿Chap?")

    xtra = models.CharField(max_length=100, verbose_name="¿Xtra?")

    def __str__(self):

        return "¿Xtra2: %s" % self.xtra

class RowLevelChangePermissionModel(models.Model):

    name = models.CharField(max_length=100, blank=True)

class CustomArticle(models.Model):

    content = models.TextField()

    date = models.DateTimeField()

class ModelWithStringPrimaryKey(models.Model):

    string_pk = models.CharField(max_length=255, primary_key=True)

    def __str__(self):

        return self.string_pk

    def get_absolute_url(self):

        return "/dummy/%s/" % self.string_pk

class Color(models.Model):

    value = models.CharField(max_length=10)

    warm = models.BooleanField(default=False)

    def __str__(self):

        return self.value

# we replicate Color to register with another ModelAdmin

class Color2(Color):

    class Meta:

        proxy = True

class Thing(models.Model):

    title = models.CharField(max_length=20)

    color = models.ForeignKey(Color, models.CASCADE, limit_choices_to={"warm": True})

    pub_date = models.DateField(blank=True, null=True)

    def __str__(self):

        return self.title

class Actor(models.Model):

    name = models.CharField(max_length=50)

    age = models.IntegerField()

    title = models.CharField(max_length=50, null=True, blank=True)

    def __str__(self):

        return self.name

class Inquisition(models.Model):

    expected = models.BooleanField(default=False)

    leader = models.ForeignKey(Actor, models.CASCADE)

    country = models.CharField(max_length=20)

    def __str__(self):

        return "by %s from %s" % (self.leader, self.country)

class Sketch(models.Model):

    title = models.CharField(max_length=100)

    inquisition = models.ForeignKey(

        Inquisition,

        models.CASCADE,

        limit_choices_to={

            "leader__name": "Palin",

            "leader__age": 27,

            "expected": False,

        },

    )

    defendant0 = models.ForeignKey(

        Actor,

        models.CASCADE,

        limit_choices_to={"title__isnull": False},

        related_name="as_defendant0",

    )

    defendant1 = models.ForeignKey(

        Actor,

        models.CASCADE,

        limit_choices_to={"title__isnull": True},

        related_name="as_defendant1",

    )

    def __str__(self):

        return self.title

def today_callable_dict():

    return {"last_action__gte": datetime.datetime.today()}

def today_callable_q():

    return models.Q(last_action__gte=datetime.datetime.today())

class Character(models.Model):

    username = models.CharField(max_length=100)

    last_action = models.DateTimeField()

    def __str__(self):

        return self.username

class StumpJoke(models.Model):

    variation = models.CharField(max_length=100)

    most_recently_fooled = models.ForeignKey(

        Character,

        models.CASCADE,

        limit_choices_to=today_callable_dict,

        related_name="+",

    )

    has_fooled_today = models.ManyToManyField(

        Character, limit_choices_to=today_callable_q, related_name="+"

    )

    def __str__(self):

        return self.variation

class Fabric(models.Model):

    NG_CHOICES = (

        (

            "Textured",

            (

                ("x", "Horizontal"),

                ("y", "Vertical"),

            ),

        ),

        ("plain", "Smooth"),

    )

    surface = models.CharField(max_length=20, choices=NG_CHOICES)

class Person(models.Model):

    GENDER_CHOICES = (

        (1, "Male"),

        (2, "Female"),

    )

    name = models.CharField(max_length=100)

    gender = models.IntegerField(choices=GENDER_CHOICES)

    age = models.IntegerField(default=21)

    alive = models.BooleanField(default=True)

    def __str__(self):

        return self.name

class Persona(models.Model):

    """

    A simple persona associated with accounts, to test inlining of related

    accounts which inherit from a common accounts class.

    """

    name = models.CharField(blank=False, max_length=80)

    def __str__(self):

        return self.name

class Account(models.Model):

    """

    A simple, generic account encapsulating the information shared by all

    types of accounts.

    """

    username = models.CharField(blank=False, max_length=80)

    persona = models.ForeignKey(Persona, models.CASCADE, related_name="accounts")

    servicename = "generic service"

    def __str__(self):

        return "%s: %s" % (self.servicename, self.username)

class FooAccount(Account):

    """A service-specific account of type Foo."""

    servicename = "foo"

class BarAccount(Account):

    """A service-specific account of type Bar."""

    servicename = "bar"

class Subscriber(models.Model):

    name = models.CharField(blank=False, max_length=80)

    email = models.EmailField(blank=False, max_length=175)

    def __str__(self):

        return "%s (%s)" % (self.name, self.email)

class ExternalSubscriber(Subscriber):

    pass

class OldSubscriber(Subscriber):

    pass

class Media(models.Model):

    name = models.CharField(max_length=60)

class Podcast(Media):

    release_date = models.DateField()

    class Meta:

        ordering = ("release_date",)  # overridden in PodcastAdmin

class Vodcast(Media):

    media = models.OneToOneField(

        Media, models.CASCADE, primary_key=True, parent_link=True

    )

    released = models.BooleanField(default=False)

class Parent(models.Model):

    name = models.CharField(max_length=128)

    def clean(self):

        if self.name == "_invalid":

            raise ValidationError("invalid")

class Child(models.Model):

    parent = models.ForeignKey(Parent, models.CASCADE, editable=False)

    name = models.CharField(max_length=30, blank=True)

    def clean(self):

        if self.name == "_invalid":

            raise ValidationError("invalid")

class PKChild(models.Model):

    """

    Used to check autocomplete to_field resolution when ForeignKey is PK.

    """

    parent = models.ForeignKey(Parent, models.CASCADE, primary_key=True)

    name = models.CharField(max_length=128)

    class Meta:

        ordering = ["parent"]

    def __str__(self):

        return self.name

class Toy(models.Model):

    child = models.ForeignKey(PKChild, models.CASCADE)

class EmptyModel(models.Model):

    def __str__(self):

        return "Primary key = %s" % self.id

temp_storage = FileSystemStorage(tempfile.mkdtemp())

class Gallery(models.Model):

    name = models.CharField(max_length=100)

class Picture(models.Model):

    name = models.CharField(max_length=100)

    image = models.FileField(storage=temp_storage, upload_to="test_upload")

    gallery = models.ForeignKey(Gallery, models.CASCADE, related_name="pictures")

class Language(models.Model):

    iso = models.CharField(max_length=5, primary_key=True)

    name = models.CharField(max_length=50)

    english_name = models.CharField(max_length=50)

    shortlist = models.BooleanField(default=False)

    def __str__(self):

        return self.iso

    class Meta:

        ordering = ("iso",)

# a base class for Recommender and Recommendation

class Title(models.Model):

    pass

class TitleTranslation(models.Model):

    title = models.ForeignKey(Title, models.CASCADE)

    text = models.CharField(max_length=100)

class Recommender(Title):

    pass

class Recommendation(Title):

    the_recommender = models.ForeignKey(Recommender, models.CASCADE)

class Collector(models.Model):

    name = models.CharField(max_length=100)

class Widget(models.Model):

    owner = models.ForeignKey(Collector, models.CASCADE)

    name = models.CharField(max_length=100)

class DooHickey(models.Model):

    code = models.CharField(max_length=10, primary_key=True)

    owner = models.ForeignKey(Collector, models.CASCADE)

    name = models.CharField(max_length=100)

class Grommet(models.Model):

    code = models.AutoField(primary_key=True)

    owner = models.ForeignKey(Collector, models.CASCADE)

    name = models.CharField(max_length=100)

class Whatsit(models.Model):

    index = models.IntegerField(primary_key=True)

    owner = models.ForeignKey(Collector, models.CASCADE)

    name = models.CharField(max_length=100)

class Doodad(models.Model):

    name = models.CharField(max_length=100)

class FancyDoodad(Doodad):

    owner = models.ForeignKey(Collector, models.CASCADE)

    expensive = models.BooleanField(default=True)

class Category(models.Model):

    collector = models.ForeignKey(Collector, models.CASCADE)

    order = models.PositiveIntegerField()

    class Meta:

        ordering = ("order",)

    def __str__(self):

        return "%s:o%s" % (self.id, self.order)

def link_posted_default():

    return datetime.date.today() - datetime.timedelta(days=7)

class Link(models.Model):

    posted = models.DateField(default=link_posted_default)

    url = models.URLField()

    post = models.ForeignKey("Post", models.CASCADE)

    readonly_link_content = models.TextField()

class PrePopulatedPost(models.Model):

    title = models.CharField(max_length=100)

    published = models.BooleanField(default=False)

    slug = models.SlugField()

class PrePopulatedSubPost(models.Model):

    post = models.ForeignKey(PrePopulatedPost, models.CASCADE)

    subtitle = models.CharField(max_length=100)

    subslug = models.SlugField()

class Post(models.Model):

    title = models.CharField(

        max_length=100, help_text="Some help text for the title (with Unicode ŠĐĆŽćžšđ)"

    )

    content = models.TextField(

        help_text="Some help text for the content (with Unicode ŠĐĆŽćžšđ)"

    )

    readonly_content = models.TextField()

    posted = models.DateField(

        default=datetime.date.today,

        help_text="Some help text for the date (with Unicode ŠĐĆŽćžšđ)",

    )

    public = models.BooleanField(null=True, blank=True)

    def awesomeness_level(self):

        return "Very awesome."

# Proxy model to test overridden fields attrs on Post model so as not to

# interfere with other tests.

class FieldOverridePost(Post):

    class Meta:

        proxy = True

class Gadget(models.Model):

    name = models.CharField(max_length=100)

    def __str__(self):

        return self.name

class Villain(models.Model):

    name = models.CharField(max_length=100)

    def __str__(self):

        return self.name

class SuperVillain(Villain):

    pass

class FunkyTag(models.Model):

    "Because we all know there's only one real use case for GFKs."

    name = models.CharField(max_length=25)

    content_type = models.ForeignKey(ContentType, models.CASCADE)

    object_id = models.PositiveIntegerField()

    content_object = GenericForeignKey("content_type", "object_id")

    def __str__(self):

        return self.name

class Plot(models.Model):

    name = models.CharField(max_length=100)

    team_leader = models.ForeignKey(Villain, models.CASCADE, related_name="lead_plots")

    contact = models.ForeignKey(Villain, models.CASCADE, related_name="contact_plots")

    tags = GenericRelation(FunkyTag)

    def __str__(self):

        return self.name

class PlotDetails(models.Model):

    details = models.CharField(max_length=100)

    plot = models.OneToOneField(Plot, models.CASCADE, null=True, blank=True)

    def __str__(self):

        return self.details

class PlotProxy(Plot):

    class Meta:

        proxy = True

class SecretHideout(models.Model):

    """Secret! Not registered with the admin!"""

    location = models.CharField(max_length=100)

    villain = models.ForeignKey(Villain, models.CASCADE)

    def __str__(self):

        return self.location

class SuperSecretHideout(models.Model):

    """Secret! Not registered with the admin!"""

    location = models.CharField(max_length=100)

    supervillain = models.ForeignKey(SuperVillain, models.CASCADE)

    def __str__(self):

        return self.location

class Bookmark(models.Model):

    name = models.CharField(max_length=60)

    tag = GenericRelation(FunkyTag, related_query_name="bookmark")

    def __str__(self):

        return self.name

class CyclicOne(models.Model):

    name = models.CharField(max_length=25)

    two = models.ForeignKey("CyclicTwo", models.CASCADE)

    def __str__(self):

        return self.name

class CyclicTwo(models.Model):

    name = models.CharField(max_length=25)

    one = models.ForeignKey(CyclicOne, models.CASCADE)

    def __str__(self):

        return self.name

class Topping(models.Model):

    name = models.CharField(max_length=20)

    def __str__(self):

        return self.name

class Pizza(models.Model):

    name = models.CharField(max_length=20)

    toppings = models.ManyToManyField("Topping", related_name="pizzas")

# Pizza's ModelAdmin has readonly_fields = ['toppings'].

# toppings is editable for this model's admin.

class ReadablePizza(Pizza):

    class Meta:

        proxy = True

# No default permissions are created for this model and both name and toppings

# are readonly for this model's admin.

class ReadOnlyPizza(Pizza):

    class Meta:

        proxy = True

        default_permissions = ()

class Album(models.Model):

    owner = models.ForeignKey(User, models.SET_NULL, null=True, blank=True)

    title = models.CharField(max_length=30)

class Song(models.Model):

    name = models.CharField(max_length=20)

    album = models.ForeignKey(Album, on_delete=models.RESTRICT)

    def __str__(self):

        return self.name

class Employee(Person):

    code = models.CharField(max_length=20)

    class Meta:

        ordering = ["name"]

class WorkHour(models.Model):

    datum = models.DateField()

    employee = models.ForeignKey(Employee, models.CASCADE)

class Manager(Employee):

    """

    A multi-layer MTI child.

    """

    pass

class Bonus(models.Model):

    recipient = models.ForeignKey(Manager, on_delete=models.CASCADE)

class Question(models.Model):

    big_id = models.BigAutoField(primary_key=True)

    question = models.CharField(max_length=20)

    posted = models.DateField(default=datetime.date.today)

    expires = models.DateTimeField(null=True, blank=True)

    related_questions = models.ManyToManyField("self")

    uuid = models.UUIDField(default=uuid.uuid4, unique=True)

    def __str__(self):

        return self.question

class Answer(models.Model):

    question = models.ForeignKey(Question, models.PROTECT)

    question_with_to_field = models.ForeignKey(

        Question,

        models.SET_NULL,

        blank=True,

        null=True,

        to_field="uuid",

        related_name="uuid_answers",

        limit_choices_to=~models.Q(question__istartswith="not"),

    )

    related_answers = models.ManyToManyField("self")

    answer = models.CharField(max_length=20)

    def __str__(self):

        return self.answer

class Answer2(Answer):

    class Meta:

        proxy = True

class Reservation(models.Model):

    start_date = models.DateTimeField()

    price = models.IntegerField()

class FoodDelivery(models.Model):

    DRIVER_CHOICES = (

        ("bill", "Bill G"),

        ("steve", "Steve J"),

    )

    RESTAURANT_CHOICES = (

        ("indian", "A Taste of India"),

        ("thai", "Thai Pography"),

        ("pizza", "Pizza Mama"),

    )

    reference = models.CharField(max_length=100)

    driver = models.CharField(max_length=100, choices=DRIVER_CHOICES, blank=True)

    restaurant = models.CharField(

        max_length=100, choices=RESTAURANT_CHOICES, blank=True

    )

    class Meta:

        unique_together = (("driver", "restaurant"),)

class CoverLetter(models.Model):

    author = models.CharField(max_length=30)

    date_written = models.DateField(null=True, blank=True)

    def __str__(self):

        return self.author

class Paper(models.Model):

    title = models.CharField(max_length=30)

    author = models.CharField(max_length=30, blank=True, null=True)

class ShortMessage(models.Model):

    content = models.CharField(max_length=140)

    timestamp = models.DateTimeField(null=True, blank=True)

class Telegram(models.Model):

    title = models.CharField(max_length=30)

    date_sent = models.DateField(null=True, blank=True)

    def __str__(self):

        return self.title

class Story(models.Model):

    title = models.CharField(max_length=100)

    content = models.TextField()

class OtherStory(models.Model):

    title = models.CharField(max_length=100)

    content = models.TextField()

class ComplexSortedPerson(models.Model):

    name = models.CharField(max_length=100)

    age = models.PositiveIntegerField()

    is_employee = models.BooleanField(null=True)

class PluggableSearchPerson(models.Model):

    name = models.CharField(max_length=100)

    age = models.PositiveIntegerField()

class PrePopulatedPostLargeSlug(models.Model):

    """

    Regression test for #15938: a large max_length for the slugfield must not

    be localized in prepopulated_fields_js.html or it might end up breaking

    the JavaScript (ie, using THOUSAND_SEPARATOR ends up with maxLength=1,000)

    """

    title = models.CharField(max_length=100)

    published = models.BooleanField(default=False)

    # `db_index=False` because MySQL cannot index large CharField (#21196).

    slug = models.SlugField(max_length=1000, db_index=False)

class AdminOrderedField(models.Model):

    order = models.IntegerField()

    stuff = models.CharField(max_length=200)

class AdminOrderedModelMethod(models.Model):

    order = models.IntegerField()

    stuff = models.CharField(max_length=200)

    @admin.display(ordering="order")

    def some_order(self):

        return self.order

class AdminOrderedAdminMethod(models.Model):

    order = models.IntegerField()

    stuff = models.CharField(max_length=200)

class AdminOrderedCallable(models.Model):

    order = models.IntegerField()

    stuff = models.CharField(max_length=200)

class Report(models.Model):

    title = models.CharField(max_length=100)

    def __str__(self):

        return self.title

class MainPrepopulated(models.Model):

    name = models.CharField(max_length=100)

    pubdate = models.DateField()

    status = models.CharField(

        max_length=20,

        choices=(("option one", "Option One"), ("option two", "Option Two")),

    )

    slug1 = models.SlugField(blank=True)

    slug2 = models.SlugField(blank=True)

    slug3 = models.SlugField(blank=True, allow_unicode=True)

class RelatedPrepopulated(models.Model):

    parent = models.ForeignKey(MainPrepopulated, models.CASCADE)

    name = models.CharField(max_length=75)

    fk = models.ForeignKey("self", models.CASCADE, blank=True, null=True)

    m2m = models.ManyToManyField("self", blank=True)

    pubdate = models.DateField()

    status = models.CharField(

        max_length=20,

        choices=(("option one", "Option One"), ("option two", "Option Two")),

    )

    slug1 = models.SlugField(max_length=50)

    slug2 = models.SlugField(max_length=60)

class UnorderedObject(models.Model):

    """

    Model without any defined `Meta.ordering`.

    Refs #16819.

    """

    name = models.CharField(max_length=255)

    bool = models.BooleanField(default=True)

class UndeletableObject(models.Model):

    """

    Model whose show_delete in admin change_view has been disabled

    Refs #10057.

    """

    name = models.CharField(max_length=255)

class UnchangeableObject(models.Model):

    """

    Model whose change_view is disabled in admin

    Refs #20640.

    """

class UserMessenger(models.Model):

    """

    Dummy class for testing message_user functions on ModelAdmin

    """

class Simple(models.Model):

    """

    Simple model with nothing on it for use in testing

    """

class Choice(models.Model):

    choice = models.IntegerField(

        blank=True,

        null=True,

        choices=((1, "Yes"), (0, "No"), (None, "No opinion")),

    )

class ParentWithDependentChildren(models.Model):

    """

    Issue #20522

    Model where the validation of child foreign-key relationships depends

    on validation of the parent

    """

    some_required_info = models.PositiveIntegerField()

    family_name = models.CharField(max_length=255, blank=False)

class DependentChild(models.Model):

    """

    Issue #20522

    Model that depends on validation of the parent class for one of its

    fields to validate during clean

    """

    parent = models.ForeignKey(ParentWithDependentChildren, models.CASCADE)

    family_name = models.CharField(max_length=255)

class _Manager(models.Manager):

    def get_queryset(self):

        return super().get_queryset().filter(pk__gt=1)

class FilteredManager(models.Model):

    def __str__(self):

        return "PK=%d" % self.pk

    pk_gt_1 = _Manager()

    objects = models.Manager()

class EmptyModelVisible(models.Model):

    """See ticket #11277."""

class EmptyModelHidden(models.Model):

    """See ticket #11277."""

class EmptyModelMixin(models.Model):

    """See ticket #11277."""

class State(models.Model):

    name = models.CharField(max_length=100, verbose_name="State verbose_name")

class City(models.Model):

    state = models.ForeignKey(State, models.CASCADE)

    name = models.CharField(max_length=100, verbose_name="City verbose_name")

    def get_absolute_url(self):

        return "/dummy/%s/" % self.pk

class Restaurant(models.Model):

    city = models.ForeignKey(City, models.CASCADE)

    name = models.CharField(max_length=100)

    def get_absolute_url(self):

        return "/dummy/%s/" % self.pk

class Worker(models.Model):

    work_at = models.ForeignKey(Restaurant, models.CASCADE)

    name = models.CharField(max_length=50)

    surname = models.CharField(max_length=50)

# Models for #23329

class ReferencedByParent(models.Model):

    name = models.CharField(max_length=20, unique=True)

class ParentWithFK(models.Model):

    fk = models.ForeignKey(

        ReferencedByParent,

        models.CASCADE,

        to_field="name",

        related_name="hidden+",

    )

class ChildOfReferer(ParentWithFK):

    pass

# Models for #23431

class InlineReferer(models.Model):

    pass

class ReferencedByInline(models.Model):

    name = models.CharField(max_length=20, unique=True)

class InlineReference(models.Model):

    referer = models.ForeignKey(InlineReferer, models.CASCADE)

    fk = models.ForeignKey(

        ReferencedByInline,

        models.CASCADE,

        to_field="name",

        related_name="hidden+",

    )

class Recipe(models.Model):

    rname = models.CharField(max_length=20, unique=True)

class Ingredient(models.Model):

    iname = models.CharField(max_length=20, unique=True)

    recipes = models.ManyToManyField(Recipe, through="RecipeIngredient")

class RecipeIngredient(models.Model):

    ingredient = models.ForeignKey(Ingredient, models.CASCADE, to_field="iname")

    recipe = models.ForeignKey(Recipe, models.CASCADE, to_field="rname")

# Model for #23839

class NotReferenced(models.Model):

    # Don't point any FK at this model.

    pass

# Models for #23934

class ExplicitlyProvidedPK(models.Model):

    name = models.IntegerField(primary_key=True)

class ImplicitlyGeneratedPK(models.Model):

    name = models.IntegerField(unique=True)

# Models for #25622

class ReferencedByGenRel(models.Model):

    content_type = models.ForeignKey(ContentType, on_delete=models.CASCADE)

    object_id = models.PositiveIntegerField()

    content_object = GenericForeignKey("content_type", "object_id")

class GenRelReference(models.Model):

    references = GenericRelation(ReferencedByGenRel)

class ParentWithUUIDPK(models.Model):

    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)

    title = models.CharField(max_length=100)

    def __str__(self):

        return str(self.id)

class RelatedWithUUIDPKModel(models.Model):

    parent = models.ForeignKey(

        ParentWithUUIDPK, on_delete=models.SET_NULL, null=True, blank=True

    )

class Author(models.Model):

    pass

class Authorship(models.Model):

    book = models.ForeignKey(Book, models.CASCADE)

    author = models.ForeignKey(Author, models.CASCADE)

class UserProxy(User):

    """Proxy a model with a different app_label."""

    class Meta:

        proxy = True

class ReadOnlyRelatedField(models.Model):

    chapter = models.ForeignKey(Chapter, models.CASCADE)

    language = models.ForeignKey(Language, models.CASCADE)

    user = models.ForeignKey(User, models.CASCADE)

class Héllo(models.Model):

    pass

class Box(models.Model):

    title = models.CharField(max_length=100)

    next_box = models.ForeignKey(

        "self", null=True, on_delete=models.SET_NULL, blank=True

    )

    next_box = models.ForeignKey(

        "self", null=True, on_delete=models.SET_NULL, blank=True

    )

class Country(models.Model):

    NORTH_AMERICA = "North America"

    SOUTH_AMERICA = "South America"

    EUROPE = "Europe"

    ASIA = "Asia"

    OCEANIA = "Oceania"

    ANTARCTICA = "Antarctica"

    CONTINENT_CHOICES = [

        (NORTH_AMERICA, NORTH_AMERICA),

        (SOUTH_AMERICA, SOUTH_AMERICA),

        (EUROPE, EUROPE),

        (ASIA, ASIA),

        (OCEANIA, OCEANIA),

        (ANTARCTICA, ANTARCTICA),

    ]

    name = models.CharField(max_length=80)

    continent = models.CharField(max_length=13, choices=CONTINENT_CHOICES)

    def __str__(self):

        return self.name

class Traveler(models.Model):

    born_country = models.ForeignKey(Country, models.CASCADE)

    living_country = models.ForeignKey(

        Country, models.CASCADE, related_name="living_country_set"

    )

    favorite_country_to_vacation = models.ForeignKey(

        Country,

        models.CASCADE,

        related_name="favorite_country_to_vacation_set",

        limit_choices_to={"continent": Country.ASIA},

    )