Debian Codegraph @

tests/fixtures_regress/models.py

raw
1 from django.contrib.auth.models import User
2 from django.db import models
3
4
5 class Animal(models.Model):
6 name = models.CharField(max_length=150)
7 latin_name = models.CharField(max_length=150)
8 count = models.IntegerField()
9 weight = models.FloatField()
10
11 # use a non-default name for the default manager
12 specimens = models.Manager()
13
14 def __str__(self):
15 return self.name
16
17
18 class Plant(models.Model):
19 name = models.CharField(max_length=150)
20
21 class Meta:
22 # For testing when upper case letter in app name; regression for #4057
23 db_table = "Fixtures_regress_plant"
24
25
26 class Stuff(models.Model):
27 name = models.CharField(max_length=20, null=True)
28 owner = models.ForeignKey(User, models.SET_NULL, null=True)
29
30 def __str__(self):
31 return self.name + " is owned by " + str(self.owner)
32
33
34 class Absolute(models.Model):
35 name = models.CharField(max_length=40)
36
37
38 class Parent(models.Model):
39 name = models.CharField(max_length=10)
40
41 class Meta:
42 ordering = ("id",)
43
44
45 class Child(Parent):
46 data = models.CharField(max_length=10)
47
48
49 # Models to regression test #7572, #20820
50 class Channel(models.Model):
51 name = models.CharField(max_length=255)
52
53
54 class Article(models.Model):
55 title = models.CharField(max_length=255)
56 channels = models.ManyToManyField(Channel)
57
58 class Meta:
59 ordering = ("id",)
60
61
62 # Subclass of a model with a ManyToManyField for test_ticket_20820
63 class SpecialArticle(Article):
64 pass
65
66
67 # Models to regression test #22421
68 class CommonFeature(Article):
69 class Meta:
70 abstract = True
71
72
73 class Feature(CommonFeature):
74 pass
75
76
77 # Models to regression test #11428
78 class Widget(models.Model):
79 name = models.CharField(max_length=255)
80
81 class Meta:
82 ordering = ("name",)
83
84 def __str__(self):
85 return self.name
86
87
88 class WidgetProxy(Widget):
89 class Meta:
90 proxy = True
91
92
93 # Check for forward references in FKs and M2Ms with natural keys
94 class TestManager(models.Manager):
95 def get_by_natural_key(self, key):
96 return self.get(name=key)
97
98
99 class Store(models.Model):
100 name = models.CharField(max_length=255, unique=True)
101 main = models.ForeignKey("self", models.SET_NULL, null=True)
102
103 objects = TestManager()
104
105 class Meta:
106 ordering = ("name",)
107
108 def __str__(self):
109 return self.name
110
111 def natural_key(self):
112 return (self.name,)
113
114
115 class Person(models.Model):
116 name = models.CharField(max_length=255, unique=True)
117
118 objects = TestManager()
119
120 class Meta:
121 ordering = ("name",)
122
123 def __str__(self):
124 return self.name
125
126 # Person doesn't actually have a dependency on store, but we need to define
127 # one to test the behavior of the dependency resolution algorithm.
128 def natural_key(self):
129 return (self.name,)
130
131 natural_key.dependencies = ["fixtures_regress.store"]
132
133
134 class Book(models.Model):
135 name = models.CharField(max_length=255)
136 author = models.ForeignKey(Person, models.CASCADE)
137 stores = models.ManyToManyField(Store)
138
139 class Meta:
140 ordering = ("name",)
141
142 def __str__(self):
143 return "%s by %s (available at %s)" % (
144 self.name,
145 self.author.name,
146 ", ".join(s.name for s in self.stores.all()),
147 )
148
149
150 class NaturalKeyWithFKDependencyManager(models.Manager):
151 def get_by_natural_key(self, name, author):
152 return self.get(name=name, author__name=author)
153
154
155 class NaturalKeyWithFKDependency(models.Model):
156 name = models.CharField(max_length=255)
157 author = models.ForeignKey(Person, models.CASCADE)
158
159 objects = NaturalKeyWithFKDependencyManager()
160
161 class Meta:
162 unique_together = ["name", "author"]
163
164 def natural_key(self):
165 return (self.name,) + self.author.natural_key()
166
167 natural_key.dependencies = ["fixtures_regress.Person"]
168
169
170 class NKManager(models.Manager):
171 def get_by_natural_key(self, data):
172 return self.get(data=data)
173
174
175 class NKChild(Parent):
176 data = models.CharField(max_length=10, unique=True)
177 objects = NKManager()
178
179 def natural_key(self):
180 return (self.data,)
181
182 def __str__(self):
183 return "NKChild %s:%s" % (self.name, self.data)
184
185
186 class RefToNKChild(models.Model):
187 text = models.CharField(max_length=10)
188 nk_fk = models.ForeignKey(NKChild, models.CASCADE, related_name="ref_fks")
189 nk_m2m = models.ManyToManyField(NKChild, related_name="ref_m2ms")
190
191 def __str__(self):
192 return "%s: Reference to %s [%s]" % (
193 self.text,
194 self.nk_fk,
195 ", ".join(str(o) for o in self.nk_m2m.all()),
196 )
197
198
199 # ome models with pathological circular dependencies
200 class Circle1(models.Model):
201 name = models.CharField(max_length=255, unique=True)
202
203 def natural_key(self):
204 return (self.name,)
205
206 natural_key.dependencies = ["fixtures_regress.circle2"]
207
208
209 class Circle2(models.Model):
210 name = models.CharField(max_length=255, unique=True)
211
212 def natural_key(self):
213 return (self.name,)
214
215 natural_key.dependencies = ["fixtures_regress.circle1"]
216
217
218 class Circle3(models.Model):
219 name = models.CharField(max_length=255, unique=True)
220
221 def natural_key(self):
222 return (self.name,)
223
224 natural_key.dependencies = ["fixtures_regress.circle3"]
225
226
227 class Circle4(models.Model):
228 name = models.CharField(max_length=255, unique=True)
229
230 def natural_key(self):
231 return (self.name,)
232
233 natural_key.dependencies = ["fixtures_regress.circle5"]
234
235
236 class Circle5(models.Model):
237 name = models.CharField(max_length=255, unique=True)
238
239 def natural_key(self):
240 return (self.name,)
241
242 natural_key.dependencies = ["fixtures_regress.circle6"]
243
244
245 class Circle6(models.Model):
246 name = models.CharField(max_length=255, unique=True)
247
248 def natural_key(self):
249 return (self.name,)
250
251 natural_key.dependencies = ["fixtures_regress.circle4"]
252
253
254 class ExternalDependency(models.Model):
255 name = models.CharField(max_length=255, unique=True)
256
257 def natural_key(self):
258 return (self.name,)
259
260 natural_key.dependencies = ["fixtures_regress.book"]
261
262
263 # Model for regression test of #11101
264 class Thingy(models.Model):
265 name = models.CharField(max_length=255)
266
267
268 class M2MToSelf(models.Model):
269 parent = models.ManyToManyField("self", blank=True)
270
271
272 class BaseNKModel(models.Model):
273 """
274 Base model with a natural_key and a manager with `get_by_natural_key`
275 """
276
277 data = models.CharField(max_length=20, unique=True)
278
279 objects = NKManager()
280
281 class Meta:
282 abstract = True
283
284 def __str__(self):
285 return self.data
286
287 def natural_key(self):
288 return (self.data,)
289
290
291 class M2MSimpleA(BaseNKModel):
292 b_set = models.ManyToManyField("M2MSimpleB")
293
294
295 class M2MSimpleB(BaseNKModel):
296 pass
297
298
299 class M2MSimpleCircularA(BaseNKModel):
300 b_set = models.ManyToManyField("M2MSimpleCircularB")
301
302
303 class M2MSimpleCircularB(BaseNKModel):
304 a_set = models.ManyToManyField("M2MSimpleCircularA")
305
306
307 class M2MComplexA(BaseNKModel):
308 b_set = models.ManyToManyField("M2MComplexB", through="M2MThroughAB")
309
310
311 class M2MComplexB(BaseNKModel):
312 pass
313
314
315 class M2MThroughAB(BaseNKModel):
316 a = models.ForeignKey(M2MComplexA, models.CASCADE)
317 b = models.ForeignKey(M2MComplexB, models.CASCADE)
318
319
320 class M2MComplexCircular1A(BaseNKModel):
321 b_set = models.ManyToManyField(
322 "M2MComplexCircular1B", through="M2MCircular1ThroughAB"
323 )
324
325
326 class M2MComplexCircular1B(BaseNKModel):
327 c_set = models.ManyToManyField(
328 "M2MComplexCircular1C", through="M2MCircular1ThroughBC"
329 )
330
331
332 class M2MComplexCircular1C(BaseNKModel):
333 a_set = models.ManyToManyField(
334 "M2MComplexCircular1A", through="M2MCircular1ThroughCA"
335 )
336
337
338 class M2MCircular1ThroughAB(BaseNKModel):
339 a = models.ForeignKey(M2MComplexCircular1A, models.CASCADE)
340 b = models.ForeignKey(M2MComplexCircular1B, models.CASCADE)
341
342
343 class M2MCircular1ThroughBC(BaseNKModel):
344 b = models.ForeignKey(M2MComplexCircular1B, models.CASCADE)
345 c = models.ForeignKey(M2MComplexCircular1C, models.CASCADE)
346
347
348 class M2MCircular1ThroughCA(BaseNKModel):
349 c = models.ForeignKey(M2MComplexCircular1C, models.CASCADE)
350 a = models.ForeignKey(M2MComplexCircular1A, models.CASCADE)
351
352
353 class M2MComplexCircular2A(BaseNKModel):
354 b_set = models.ManyToManyField(
355 "M2MComplexCircular2B", through="M2MCircular2ThroughAB"
356 )
357
358
359 class M2MComplexCircular2B(BaseNKModel):
360 def natural_key(self):
361 return (self.data,)
362
363 # Fake the dependency for a circularity
364 natural_key.dependencies = ["fixtures_regress.M2MComplexCircular2A"]
365
366
367 class M2MCircular2ThroughAB(BaseNKModel):
368 a = models.ForeignKey(M2MComplexCircular2A, models.CASCADE)
369 b = models.ForeignKey(M2MComplexCircular2B, models.CASCADE)