use a nondefault name for the default manager for testing when upper case letter in app name regression for 4057 models to regression test 7572 20820 subclass of a model with a manytomanyfield for testticket20820 models to regression test 22421 models to regression test 11428 check for forward references in fks and m2ms with natural keys person doesn t actually have a dependency on store but we need to define one to test the behavior of the dependency resolution algorithm ome models with pathological circular dependencies model for regression test of 11101 base model with a naturalkey and a manager with getbynaturalkey fake the dependency for a circularity use a non default name for the default manager for testing when upper case letter in app name regression for 4057 models to regression test 7572 20820 subclass of a model with a manytomanyfield for test_ticket_20820 models to regression test 22421 models to regression test 11428 check for forward references in fks and m2ms with natural keys person doesn t actually have a dependency on store but we need to define one to test the behavior of the dependency resolution algorithm ome models with pathological circular dependencies model for regression test of 11101 base model with a natural_key and a manager with get_by_natural_key fake the dependency for a circularity
from django.contrib.auth.models import User
from django.db import models


class Animal(models.Model):
    name = models.CharField(max_length=150)
    latin_name = models.CharField(max_length=150)
    count = models.IntegerField()
    weight = models.FloatField()

    
    specimens = models.Manager()

    def __str__(self):
        return self.name


class Plant(models.Model):
    name = models.CharField(max_length=150)

    class Meta:
        
        db_table = "Fixtures_regress_plant"


class Stuff(models.Model):
    name = models.CharField(max_length=20, null=True)
    owner = models.ForeignKey(User, models.SET_NULL, null=True)

    def __str__(self):
        return self.name + " is owned by " + str(self.owner)


class Absolute(models.Model):
    name = models.CharField(max_length=40)


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

    class Meta:
        ordering = ("id",)


class Child(Parent):
    data = models.CharField(max_length=10)



class Channel(models.Model):
    name = models.CharField(max_length=255)


class Article(models.Model):
    title = models.CharField(max_length=255)
    channels = models.ManyToManyField(Channel)

    class Meta:
        ordering = ("id",)



class SpecialArticle(Article):
    pass



class CommonFeature(Article):
    class Meta:
        abstract = True


class Feature(CommonFeature):
    pass



class Widget(models.Model):
    name = models.CharField(max_length=255)

    class Meta:
        ordering = ("name",)

    def __str__(self):
        return self.name


class WidgetProxy(Widget):
    class Meta:
        proxy = True



class TestManager(models.Manager):
    def get_by_natural_key(self, key):
        return self.get(name=key)


class Store(models.Model):
    name = models.CharField(max_length=255, unique=True)
    main = models.ForeignKey("self", models.SET_NULL, null=True)

    objects = TestManager()

    class Meta:
        ordering = ("name",)

    def __str__(self):
        return self.name

    def natural_key(self):
        return (self.name,)


class Person(models.Model):
    name = models.CharField(max_length=255, unique=True)

    objects = TestManager()

    class Meta:
        ordering = ("name",)

    def __str__(self):
        return self.name

    
    
    def natural_key(self):
        return (self.name,)

    natural_key.dependencies = ["fixtures_regress.store"]


class Book(models.Model):
    name = models.CharField(max_length=255)
    author = models.ForeignKey(Person, models.CASCADE)
    stores = models.ManyToManyField(Store)

    class Meta:
        ordering = ("name",)

    def __str__(self):
        return "%s by %s (available at %s)" % (
            self.name,
            self.author.name,
            ", ".join(s.name for s in self.stores.all()),
        )


class NaturalKeyWithFKDependencyManager(models.Manager):
    def get_by_natural_key(self, name, author):
        return self.get(name=name, author__name=author)


class NaturalKeyWithFKDependency(models.Model):
    name = models.CharField(max_length=255)
    author = models.ForeignKey(Person, models.CASCADE)

    objects = NaturalKeyWithFKDependencyManager()

    class Meta:
        unique_together = ["name", "author"]

    def natural_key(self):
        return (self.name,) + self.author.natural_key()

    natural_key.dependencies = ["fixtures_regress.Person"]


class NKManager(models.Manager):
    def get_by_natural_key(self, data):
        return self.get(data=data)


class NKChild(Parent):
    data = models.CharField(max_length=10, unique=True)
    objects = NKManager()

    def natural_key(self):
        return (self.data,)

    def __str__(self):
        return "NKChild %s:%s" % (self.name, self.data)


class RefToNKChild(models.Model):
    text = models.CharField(max_length=10)
    nk_fk = models.ForeignKey(NKChild, models.CASCADE, related_name="ref_fks")
    nk_m2m = models.ManyToManyField(NKChild, related_name="ref_m2ms")

    def __str__(self):
        return "%s: Reference to %s [%s]" % (
            self.text,
            self.nk_fk,
            ", ".join(str(o) for o in self.nk_m2m.all()),
        )



class Circle1(models.Model):
    name = models.CharField(max_length=255, unique=True)

    def natural_key(self):
        return (self.name,)

    natural_key.dependencies = ["fixtures_regress.circle2"]


class Circle2(models.Model):
    name = models.CharField(max_length=255, unique=True)

    def natural_key(self):
        return (self.name,)

    natural_key.dependencies = ["fixtures_regress.circle1"]


class Circle3(models.Model):
    name = models.CharField(max_length=255, unique=True)

    def natural_key(self):
        return (self.name,)

    natural_key.dependencies = ["fixtures_regress.circle3"]


class Circle4(models.Model):
    name = models.CharField(max_length=255, unique=True)

    def natural_key(self):
        return (self.name,)

    natural_key.dependencies = ["fixtures_regress.circle5"]


class Circle5(models.Model):
    name = models.CharField(max_length=255, unique=True)

    def natural_key(self):
        return (self.name,)

    natural_key.dependencies = ["fixtures_regress.circle6"]


class Circle6(models.Model):
    name = models.CharField(max_length=255, unique=True)

    def natural_key(self):
        return (self.name,)

    natural_key.dependencies = ["fixtures_regress.circle4"]


class ExternalDependency(models.Model):
    name = models.CharField(max_length=255, unique=True)

    def natural_key(self):
        return (self.name,)

    natural_key.dependencies = ["fixtures_regress.book"]



class Thingy(models.Model):
    name = models.CharField(max_length=255)


class M2MToSelf(models.Model):
    parent = models.ManyToManyField("self", blank=True)


class BaseNKModel(models.Model):
    

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

    objects = NKManager()

    class Meta:
        abstract = True

    def __str__(self):
        return self.data

    def natural_key(self):
        return (self.data,)


class M2MSimpleA(BaseNKModel):
    b_set = models.ManyToManyField("M2MSimpleB")


class M2MSimpleB(BaseNKModel):
    pass


class M2MSimpleCircularA(BaseNKModel):
    b_set = models.ManyToManyField("M2MSimpleCircularB")


class M2MSimpleCircularB(BaseNKModel):
    a_set = models.ManyToManyField("M2MSimpleCircularA")


class M2MComplexA(BaseNKModel):
    b_set = models.ManyToManyField("M2MComplexB", through="M2MThroughAB")


class M2MComplexB(BaseNKModel):
    pass


class M2MThroughAB(BaseNKModel):
    a = models.ForeignKey(M2MComplexA, models.CASCADE)
    b = models.ForeignKey(M2MComplexB, models.CASCADE)


class M2MComplexCircular1A(BaseNKModel):
    b_set = models.ManyToManyField(
        "M2MComplexCircular1B", through="M2MCircular1ThroughAB"
    )


class M2MComplexCircular1B(BaseNKModel):
    c_set = models.ManyToManyField(
        "M2MComplexCircular1C", through="M2MCircular1ThroughBC"
    )


class M2MComplexCircular1C(BaseNKModel):
    a_set = models.ManyToManyField(
        "M2MComplexCircular1A", through="M2MCircular1ThroughCA"
    )


class M2MCircular1ThroughAB(BaseNKModel):
    a = models.ForeignKey(M2MComplexCircular1A, models.CASCADE)
    b = models.ForeignKey(M2MComplexCircular1B, models.CASCADE)


class M2MCircular1ThroughBC(BaseNKModel):
    b = models.ForeignKey(M2MComplexCircular1B, models.CASCADE)
    c = models.ForeignKey(M2MComplexCircular1C, models.CASCADE)


class M2MCircular1ThroughCA(BaseNKModel):
    c = models.ForeignKey(M2MComplexCircular1C, models.CASCADE)
    a = models.ForeignKey(M2MComplexCircular1A, models.CASCADE)


class M2MComplexCircular2A(BaseNKModel):
    b_set = models.ManyToManyField(
        "M2MComplexCircular2B", through="M2MCircular2ThroughAB"
    )


class M2MComplexCircular2B(BaseNKModel):
    def natural_key(self):
        return (self.data,)

    
    natural_key.dependencies = ["fixtures_regress.M2MComplexCircular2A"]


class M2MCircular2ThroughAB(BaseNKModel):
    a = models.ForeignKey(M2MComplexCircular2A, models.CASCADE)
    b = models.ForeignKey(M2MComplexCircular2B, models.CASCADE)