intentionally does not have a related name models for default manager tests genericrelationgenericforeignkey tests contentobject field models for lookup ordering tests assume business logic forces every person to have at least one house models for nullable fk tests ticket 19607 ticket 21410 regression when relatedname models for manytomany with uuid pk test intentionally does not have a related name models for default manager tests genericrelation genericforeignkey tests content object field models for lookup ordering tests assume business logic forces every person to have at least one house models for nullable fk tests ticket 19607 ticket 21410 regression when related_name models for many to many with uuid pk test
import uuid

from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
from django.contrib.contenttypes.models import ContentType
from django.db import models
from django.db.models.query import ModelIterable
from django.utils.functional import cached_property


class Author(models.Model):
    name = models.CharField(max_length=50, unique=True)
    first_book = models.ForeignKey(
        "Book", models.CASCADE, related_name="first_time_authors"
    )
    favorite_authors = models.ManyToManyField(
        "self", through="FavoriteAuthors", symmetrical=False, related_name="favors_me"
    )

    class Meta:
        ordering = ["id"]

    def __str__(self):
        return self.name


class AuthorWithAge(Author):
    author = models.OneToOneField(Author, models.CASCADE, parent_link=True)
    age = models.IntegerField()


class FavoriteAuthors(models.Model):
    author = models.ForeignKey(
        Author, models.CASCADE, to_field="name", related_name="i_like"
    )
    likes_author = models.ForeignKey(
        Author, models.CASCADE, to_field="name", related_name="likes_me"
    )

    class Meta:
        ordering = ["id"]


class AuthorAddress(models.Model):
    author = models.ForeignKey(
        Author, models.CASCADE, to_field="name", related_name="addresses"
    )
    address = models.TextField()

    class Meta:
        ordering = ["id"]


class Book(models.Model):
    title = models.CharField(max_length=255)
    authors = models.ManyToManyField(Author, related_name="books")

    class Meta:
        ordering = ["id"]


class BookWithYear(Book):
    book = models.OneToOneField(Book, models.CASCADE, parent_link=True)
    published_year = models.IntegerField()
    aged_authors = models.ManyToManyField(AuthorWithAge, related_name="books_with_year")


class Bio(models.Model):
    author = models.OneToOneField(
        Author,
        models.CASCADE,
        primary_key=True,
        to_field="name",
    )
    books = models.ManyToManyField(Book, blank=True)


class Reader(models.Model):
    name = models.CharField(max_length=50)
    books_read = models.ManyToManyField(Book, related_name="read_by")

    class Meta:
        ordering = ["id"]

    def __str__(self):
        return self.name


class BookReview(models.Model):
    
    book = models.ForeignKey(BookWithYear, models.CASCADE, null=True)
    notes = models.TextField(null=True, blank=True)





class Qualification(models.Model):
    name = models.CharField(max_length=10)

    class Meta:
        ordering = ["id"]


class ModelIterableSubclass(ModelIterable):
    pass


class TeacherQuerySet(models.QuerySet):
    def __init__(self, *args, **kwargs):
        super().__init__(*args, **kwargs)
        self._iterable_class = ModelIterableSubclass


class TeacherManager(models.Manager):
    def get_queryset(self):
        return super().get_queryset().prefetch_related("qualifications")


class Teacher(models.Model):
    name = models.CharField(max_length=50)
    qualifications = models.ManyToManyField(Qualification)

    objects = TeacherManager()
    objects_custom = TeacherQuerySet.as_manager()

    class Meta:
        ordering = ["id"]

    def __str__(self):
        return "%s (%s)" % (
            self.name,
            ", ".join(q.name for q in self.qualifications.all()),
        )


class Department(models.Model):
    name = models.CharField(max_length=50)
    teachers = models.ManyToManyField(Teacher)

    class Meta:
        ordering = ["id"]





class TaggedItem(models.Model):
    tag = models.SlugField()
    content_type = models.ForeignKey(
        ContentType,
        models.CASCADE,
        related_name="taggeditem_set2",
    )
    object_id = models.PositiveIntegerField()
    content_object = GenericForeignKey("content_type", "object_id")
    created_by_ct = models.ForeignKey(
        ContentType,
        models.SET_NULL,
        null=True,
        related_name="taggeditem_set3",
    )
    created_by_fkey = models.PositiveIntegerField(null=True)
    created_by = GenericForeignKey(
        "created_by_ct",
        "created_by_fkey",
    )
    favorite_ct = models.ForeignKey(
        ContentType,
        models.SET_NULL,
        null=True,
        related_name="taggeditem_set4",
    )
    favorite_fkey = models.CharField(max_length=64, null=True)
    favorite = GenericForeignKey("favorite_ct", "favorite_fkey")

    class Meta:
        ordering = ["id"]


class Article(models.Model):
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    name = models.CharField(max_length=20)


class Bookmark(models.Model):
    url = models.URLField()
    tags = GenericRelation(TaggedItem, related_query_name="bookmarks")
    favorite_tags = GenericRelation(
        TaggedItem,
        content_type_field="favorite_ct",
        object_id_field="favorite_fkey",
        related_query_name="favorite_bookmarks",
    )

    class Meta:
        ordering = ["id"]


class Comment(models.Model):
    comment = models.TextField()

    
    content_type = models.ForeignKey(ContentType, models.CASCADE, null=True)
    object_pk = models.TextField()
    content_object = GenericForeignKey(ct_field="content_type", fk_field="object_pk")
    content_type_uuid = models.ForeignKey(
        ContentType, models.CASCADE, related_name="comments", null=True
    )
    object_pk_uuid = models.TextField()
    content_object_uuid = GenericForeignKey(
        ct_field="content_type_uuid", fk_field="object_pk_uuid"
    )

    class Meta:
        ordering = ["id"]





class House(models.Model):
    name = models.CharField(max_length=50)
    address = models.CharField(max_length=255)
    owner = models.ForeignKey("Person", models.SET_NULL, null=True)
    main_room = models.OneToOneField(
        "Room", models.SET_NULL, related_name="main_room_of", null=True
    )

    class Meta:
        ordering = ["id"]


class Room(models.Model):
    name = models.CharField(max_length=50)
    house = models.ForeignKey(House, models.CASCADE, related_name="rooms")

    class Meta:
        ordering = ["id"]


class Person(models.Model):
    name = models.CharField(max_length=50)
    houses = models.ManyToManyField(House, related_name="occupants")

    @property
    def primary_house(self):
        
        return sorted(self.houses.all(), key=lambda house: -house.rooms.count())[0]

    @property
    def all_houses(self):
        return list(self.houses.all())

    @cached_property
    def cached_all_houses(self):
        return self.all_houses

    class Meta:
        ordering = ["id"]





class Employee(models.Model):
    name = models.CharField(max_length=50)
    boss = models.ForeignKey("self", models.SET_NULL, null=True, related_name="serfs")

    class Meta:
        ordering = ["id"]





class LessonEntry(models.Model):
    name1 = models.CharField(max_length=200)
    name2 = models.CharField(max_length=200)


class WordEntry(models.Model):
    lesson_entry = models.ForeignKey(LessonEntry, models.CASCADE)
    name = models.CharField(max_length=200)





class Author2(models.Model):
    name = models.CharField(max_length=50, unique=True)
    first_book = models.ForeignKey(
        "Book", models.CASCADE, related_name="first_time_authors+"
    )
    favorite_books = models.ManyToManyField("Book", related_name="+")

    class Meta:
        ordering = ["id"]





class Pet(models.Model):
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    name = models.CharField(max_length=20)
    people = models.ManyToManyField(Person, related_name="pets")


class Flea(models.Model):
    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
    current_room = models.ForeignKey(
        Room, models.SET_NULL, related_name="fleas", null=True
    )
    pets_visited = models.ManyToManyField(Pet, related_name="fleas_hosted")
    people_visited = models.ManyToManyField(Person, related_name="fleas_hosted")