Debian Codegraph @

tests/model_fields/models.py

raw
1 import json
2 import tempfile
3 import uuid
4
5 from django.contrib.contenttypes.fields import GenericForeignKey, GenericRelation
6 from django.contrib.contenttypes.models import ContentType
7 from django.core.files.storage import FileSystemStorage
8 from django.core.serializers.json import DjangoJSONEncoder
9 from django.db import connection, models
10 from django.db.models import F, Value
11 from django.db.models.fields.files import ImageFieldFile
12 from django.db.models.functions import Lower
13 from django.utils.functional import SimpleLazyObject
14 from django.utils.translation import gettext_lazy as _
15
16 from .storage import NoReadFileSystemStorage
17
18 try:
19 from PIL import Image
20 except ImportError:
21 Image = None
22
23
24 # Set up a temp directory for file storage.
25 temp_storage_dir = tempfile.mkdtemp()
26 temp_storage = FileSystemStorage(temp_storage_dir)
27
28 test_collation = SimpleLazyObject(
29 lambda: connection.features.test_collations["virtual"]
30 )
31
32
33 class Foo(models.Model):
34 a = models.CharField(max_length=10)
35 d = models.DecimalField(max_digits=5, decimal_places=3)
36
37
38 def get_foo():
39 return Foo.objects.get(id=1).pk
40
41
42 class Bar(models.Model):
43 b = models.CharField(max_length=10)
44 a = models.ForeignKey(Foo, models.CASCADE, default=get_foo, related_name="bars")
45
46
47 class Whiz(models.Model):
48 CHOICES = {
49 "Group 1": {
50 1: "First",
51 2: "Second",
52 },
53 "Group 2": (
54 (3, "Third"),
55 (4, "Fourth"),
56 ),
57 0: "Other",
58 5: _("translated"),
59 }
60 c = models.IntegerField(choices=CHOICES, null=True)
61
62
63 class WhizDelayed(models.Model):
64 c = models.IntegerField(choices=(), null=True)
65
66
67 # Contrived way of adding choices later.
68 WhizDelayed._meta.get_field("c").choices = Whiz.CHOICES
69
70
71 class WhizIter(models.Model):
72 c = models.IntegerField(choices=iter(Whiz.CHOICES.items()), null=True)
73
74
75 class WhizIterEmpty(models.Model):
76 c = models.CharField(choices=iter(()), blank=True, max_length=1)
77
78
79 class Choiceful(models.Model):
80 class Suit(models.IntegerChoices):
81 DIAMOND = 1, "Diamond"
82 SPADE = 2, "Spade"
83 HEART = 3, "Heart"
84 CLUB = 4, "Club"
85
86 def get_choices():
87 return [(i, str(i)) for i in range(3)]
88
89 no_choices = models.IntegerField(null=True)
90 empty_choices = models.IntegerField(choices=(), null=True)
91 with_choices = models.IntegerField(choices=[(1, "A")], null=True)
92 with_choices_dict = models.IntegerField(choices={1: "A"}, null=True)
93 with_choices_nested_dict = models.IntegerField(
94 choices={"Thing": {1: "A"}}, null=True
95 )
96 empty_choices_bool = models.BooleanField(choices=())
97 empty_choices_text = models.TextField(choices=())
98 choices_from_enum = models.IntegerField(choices=Suit)
99 choices_from_iterator = models.IntegerField(choices=((i, str(i)) for i in range(3)))
100 choices_from_callable = models.IntegerField(choices=get_choices)
101
102
103 class BigD(models.Model):
104 d = models.DecimalField(max_digits=32, decimal_places=30)
105
106
107 class FloatModel(models.Model):
108 size = models.FloatField()
109
110
111 class BigS(models.Model):
112 s = models.SlugField(max_length=255)
113
114
115 class UnicodeSlugField(models.Model):
116 s = models.SlugField(max_length=255, allow_unicode=True)
117
118
119 class AutoModel(models.Model):
120 value = models.AutoField(primary_key=True)
121
122
123 class BigAutoModel(models.Model):
124 value = models.BigAutoField(primary_key=True)
125
126
127 class SmallAutoModel(models.Model):
128 value = models.SmallAutoField(primary_key=True)
129
130
131 class SmallIntegerModel(models.Model):
132 value = models.SmallIntegerField()
133
134
135 class IntegerModel(models.Model):
136 value = models.IntegerField()
137
138
139 class BigIntegerModel(models.Model):
140 value = models.BigIntegerField()
141 null_value = models.BigIntegerField(null=True, blank=True)
142
143
144 class PositiveBigIntegerModel(models.Model):
145 value = models.PositiveBigIntegerField()
146
147
148 class PositiveSmallIntegerModel(models.Model):
149 value = models.PositiveSmallIntegerField()
150
151
152 class PositiveIntegerModel(models.Model):
153 value = models.PositiveIntegerField()
154
155
156 class Post(models.Model):
157 title = models.CharField(max_length=100)
158 body = models.TextField()
159
160
161 class NullBooleanModel(models.Model):
162 nbfield = models.BooleanField(null=True, blank=True)
163
164
165 class BooleanModel(models.Model):
166 bfield = models.BooleanField()
167
168
169 class DateTimeModel(models.Model):
170 d = models.DateField()
171 dt = models.DateTimeField()
172 t = models.TimeField()
173
174
175 class DurationModel(models.Model):
176 field = models.DurationField()
177
178
179 class NullDurationModel(models.Model):
180 field = models.DurationField(null=True)
181
182
183 class PrimaryKeyCharModel(models.Model):
184 string = models.CharField(max_length=10, primary_key=True)
185
186
187 class FksToBooleans(models.Model):
188 """Model with FKs to models with {Null,}BooleanField's, #15040"""
189
190 bf = models.ForeignKey(BooleanModel, models.CASCADE)
191 nbf = models.ForeignKey(NullBooleanModel, models.CASCADE)
192
193
194 class FkToChar(models.Model):
195 """Model with FK to a model with a CharField primary key, #19299"""
196
197 out = models.ForeignKey(PrimaryKeyCharModel, models.CASCADE)
198
199
200 class RenamedField(models.Model):
201 modelname = models.IntegerField(name="fieldname", choices=((1, "One"),))
202
203
204 class VerboseNameField(models.Model):
205 id = models.AutoField("verbose pk", primary_key=True)
206 field1 = models.BigIntegerField("verbose field1")
207 field2 = models.BooleanField("verbose field2", default=False)
208 field3 = models.CharField("verbose field3", max_length=10)
209 field4 = models.DateField("verbose field4")
210 field5 = models.DateTimeField("verbose field5")
211 field6 = models.DecimalField("verbose field6", max_digits=6, decimal_places=1)
212 field7 = models.EmailField("verbose field7")
213 field8 = models.FileField(
214 "verbose field8", storage=temp_storage, upload_to="unused"
215 )
216 field9 = models.FilePathField("verbose field9")
217 field10 = models.FloatField("verbose field10")
218 # Don't want to depend on Pillow in this test
219 # field_image = models.ImageField("verbose field")
220 field11 = models.IntegerField("verbose field11")
221 field12 = models.GenericIPAddressField("verbose field12", protocol="ipv4")
222 field13 = models.PositiveIntegerField("verbose field13")
223 field14 = models.PositiveSmallIntegerField("verbose field14")
224 field15 = models.SlugField("verbose field15")
225 field16 = models.SmallIntegerField("verbose field16")
226 field17 = models.TextField("verbose field17")
227 field18 = models.TimeField("verbose field18")
228 field19 = models.URLField("verbose field19")
229 field20 = models.UUIDField("verbose field20")
230 field21 = models.DurationField("verbose field21")
231
232
233 class GenericIPAddress(models.Model):
234 ip = models.GenericIPAddressField(null=True, protocol="ipv4")
235
236
237 ###############################################################################
238 # These models aren't used in any test, just here to ensure they validate
239 # successfully.
240
241
242 # See ticket #16570.
243 class DecimalLessThanOne(models.Model):
244 d = models.DecimalField(max_digits=3, decimal_places=3)
245
246
247 # See ticket #18389.
248 class FieldClassAttributeModel(models.Model):
249 field_class = models.CharField
250
251
252 ###############################################################################
253
254
255 class DataModel(models.Model):
256 short_data = models.BinaryField(max_length=10, default=b"\x08")
257 data = models.BinaryField()
258
259
260 ###############################################################################
261 # FileField
262
263
264 class Document(models.Model):
265 myfile = models.FileField(storage=temp_storage, upload_to="unused", unique=True)
266
267
268 ###############################################################################
269 # ImageField
270
271 # If Pillow available, do these tests.
272 if Image:
273
274 class TestImageFieldFile(ImageFieldFile):
275 """
276 Custom Field File class that records whether or not the underlying file
277 was opened.
278 """
279
280 def __init__(self, *args, **kwargs):
281 self.was_opened = False
282 super().__init__(*args, **kwargs)
283
284 def open(self):
285 self.was_opened = True
286 super().open()
287
288 class TestImageField(models.ImageField):
289 attr_class = TestImageFieldFile
290
291 class Person(models.Model):
292 """
293 Model that defines an ImageField with no dimension fields.
294 """
295
296 name = models.CharField(max_length=50)
297 mugshot = TestImageField(storage=temp_storage, upload_to="tests")
298
299 class AbstractPersonWithHeight(models.Model):
300 """
301 Abstract model that defines an ImageField with only one dimension field
302 to make sure the dimension update is correctly run on concrete subclass
303 instance post-initialization.
304 """
305
306 mugshot = TestImageField(
307 storage=temp_storage, upload_to="tests", height_field="mugshot_height"
308 )
309 mugshot_height = models.PositiveSmallIntegerField()
310
311 class Meta:
312 abstract = True
313
314 class PersonWithHeight(AbstractPersonWithHeight):
315 """
316 Concrete model that subclass an abstract one with only on dimension
317 field.
318 """
319
320 name = models.CharField(max_length=50)
321
322 class PersonWithHeightAndWidth(models.Model):
323 """
324 Model that defines height and width fields after the ImageField.
325 """
326
327 name = models.CharField(max_length=50)
328 mugshot = TestImageField(
329 storage=temp_storage,
330 upload_to="tests",
331 height_field="mugshot_height",
332 width_field="mugshot_width",
333 )
334 mugshot_height = models.PositiveSmallIntegerField()
335 mugshot_width = models.PositiveSmallIntegerField()
336
337 class PersonDimensionsFirst(models.Model):
338 """
339 Model that defines height and width fields before the ImageField.
340 """
341
342 name = models.CharField(max_length=50)
343 mugshot_height = models.PositiveSmallIntegerField()
344 mugshot_width = models.PositiveSmallIntegerField()
345 mugshot = TestImageField(
346 storage=temp_storage,
347 upload_to="tests",
348 height_field="mugshot_height",
349 width_field="mugshot_width",
350 )
351
352 class PersonTwoImages(models.Model):
353 """
354 Model that:
355 * Defines two ImageFields
356 * Defines the height/width fields before the ImageFields
357 * Has a nullable ImageField
358 """
359
360 name = models.CharField(max_length=50)
361 mugshot_height = models.PositiveSmallIntegerField()
362 mugshot_width = models.PositiveSmallIntegerField()
363 mugshot = TestImageField(
364 storage=temp_storage,
365 upload_to="tests",
366 height_field="mugshot_height",
367 width_field="mugshot_width",
368 )
369 headshot_height = models.PositiveSmallIntegerField(blank=True, null=True)
370 headshot_width = models.PositiveSmallIntegerField(blank=True, null=True)
371 headshot = TestImageField(
372 blank=True,
373 null=True,
374 storage=temp_storage,
375 upload_to="tests",
376 height_field="headshot_height",
377 width_field="headshot_width",
378 )
379
380 class PersonNoReadImage(models.Model):
381 """
382 Model that defines an ImageField with a storage backend that does not
383 support reading.
384 """
385
386 mugshot = models.ImageField(
387 upload_to="tests",
388 storage=NoReadFileSystemStorage(temp_storage_dir),
389 width_field="mugshot_width",
390 height_field="mugshot_height",
391 )
392 mugshot_width = models.IntegerField()
393 mugshot_height = models.IntegerField()
394
395
396 class CustomJSONDecoder(json.JSONDecoder):
397 def __init__(self, object_hook=None, *args, **kwargs):
398 return super().__init__(object_hook=self.as_uuid, *args, **kwargs)
399
400 def as_uuid(self, dct):
401 if "uuid" in dct:
402 dct["uuid"] = uuid.UUID(dct["uuid"])
403 return dct
404
405
406 class JSONModel(models.Model):
407 value = models.JSONField()
408
409 class Meta:
410 required_db_features = {"supports_json_field"}
411
412
413 class NullableJSONModel(models.Model):
414 value = models.JSONField(blank=True, null=True)
415 value_custom = models.JSONField(
416 encoder=DjangoJSONEncoder,
417 decoder=CustomJSONDecoder,
418 null=True,
419 )
420
421 class Meta:
422 required_db_features = {"supports_json_field"}
423
424
425 class RelatedJSONModel(models.Model):
426 value = models.JSONField()
427 json_model = models.ForeignKey(NullableJSONModel, models.CASCADE)
428
429 class Meta:
430 required_db_features = {"supports_json_field"}
431
432
433 class CustomSerializationJSONModel(models.Model):
434 class StringifiedJSONField(models.JSONField):
435 def get_prep_value(self, value):
436 return json.dumps(value, cls=self.encoder)
437
438 json_field = StringifiedJSONField()
439
440 class Meta:
441 required_db_features = {
442 "supports_json_field",
443 "supports_primitives_in_json_field",
444 }
445
446
447 class AllFieldsModel(models.Model):
448 big_integer = models.BigIntegerField()
449 binary = models.BinaryField()
450 boolean = models.BooleanField(default=False)
451 char = models.CharField(max_length=10)
452 date = models.DateField()
453 datetime = models.DateTimeField()
454 decimal = models.DecimalField(decimal_places=2, max_digits=2)
455 duration = models.DurationField()
456 email = models.EmailField()
457 file_path = models.FilePathField()
458 floatf = models.FloatField()
459 integer = models.IntegerField()
460 generic_ip = models.GenericIPAddressField()
461 positive_integer = models.PositiveIntegerField()
462 positive_small_integer = models.PositiveSmallIntegerField()
463 slug = models.SlugField()
464 small_integer = models.SmallIntegerField()
465 text = models.TextField()
466 time = models.TimeField()
467 url = models.URLField()
468 uuid = models.UUIDField()
469
470 fo = models.ForeignObject(
471 "self",
472 on_delete=models.CASCADE,
473 from_fields=["positive_integer"],
474 to_fields=["id"],
475 related_name="reverse",
476 )
477 fk = models.ForeignKey("self", models.CASCADE, related_name="reverse2")
478 m2m = models.ManyToManyField("self")
479 oto = models.OneToOneField("self", models.CASCADE)
480
481 object_id = models.PositiveIntegerField()
482 content_type = models.ForeignKey(ContentType, models.CASCADE)
483 gfk = GenericForeignKey()
484 gr = GenericRelation(DataModel)
485
486
487 class ManyToMany(models.Model):
488 m2m = models.ManyToManyField("self")
489
490
491 ###############################################################################
492
493
494 class UUIDModel(models.Model):
495 field = models.UUIDField()
496
497
498 class NullableUUIDModel(models.Model):
499 field = models.UUIDField(blank=True, null=True)
500
501
502 class PrimaryKeyUUIDModel(models.Model):
503 id = models.UUIDField(primary_key=True, default=uuid.uuid4)
504
505
506 class RelatedToUUIDModel(models.Model):
507 uuid_fk = models.ForeignKey("PrimaryKeyUUIDModel", models.CASCADE)
508
509
510 class UUIDChild(PrimaryKeyUUIDModel):
511 pass
512
513
514 class UUIDGrandchild(UUIDChild):
515 pass
516
517
518 class GeneratedModelFieldWithConverters(models.Model):
519 field = models.UUIDField()
520 field_copy = models.GeneratedField(
521 expression=F("field"),
522 output_field=models.UUIDField(),
523 db_persist=True,
524 )
525
526 class Meta:
527 required_db_features = {"supports_stored_generated_columns"}
528
529
530 class GeneratedModel(models.Model):
531 a = models.IntegerField()
532 b = models.IntegerField()
533 field = models.GeneratedField(
534 expression=F("a") + F("b"),
535 output_field=models.IntegerField(),
536 db_persist=True,
537 )
538 fk = models.ForeignKey(Foo, on_delete=models.CASCADE, null=True, blank=True)
539
540 class Meta:
541 required_db_features = {"supports_stored_generated_columns"}
542
543
544 class GeneratedModelNonAutoPk(models.Model):
545 id = models.IntegerField(primary_key=True)
546 a = models.IntegerField()
547 b = models.GeneratedField(
548 expression=F("a"),
549 output_field=models.IntegerField(),
550 db_persist=True,
551 )
552
553 class Meta:
554 required_db_features = {"supports_stored_generated_columns"}
555
556
557 class GeneratedModelVirtual(models.Model):
558 a = models.IntegerField()
559 b = models.IntegerField()
560 field = models.GeneratedField(
561 expression=F("a") + F("b"),
562 output_field=models.IntegerField(),
563 db_persist=False,
564 )
565 fk = models.ForeignKey(Foo, on_delete=models.CASCADE, null=True, blank=True)
566
567 class Meta:
568 required_db_features = {"supports_virtual_generated_columns"}
569
570
571 class GeneratedModelParams(models.Model):
572 field = models.GeneratedField(
573 expression=Value("Constant", output_field=models.CharField(max_length=10)),
574 output_field=models.CharField(max_length=10),
575 db_persist=True,
576 )
577
578 class Meta:
579 required_db_features = {"supports_stored_generated_columns"}
580
581
582 class GeneratedModelParamsVirtual(models.Model):
583 field = models.GeneratedField(
584 expression=Value("Constant", output_field=models.CharField(max_length=10)),
585 output_field=models.CharField(max_length=10),
586 db_persist=False,
587 )
588
589 class Meta:
590 required_db_features = {"supports_virtual_generated_columns"}
591
592
593 class GeneratedModelOutputFieldDbCollation(models.Model):
594 name = models.CharField(max_length=10)
595 lower_name = models.GeneratedField(
596 expression=Lower("name"),
597 output_field=models.CharField(db_collation=test_collation, max_length=11),
598 db_persist=True,
599 )
600
601 class Meta:
602 required_db_features = {"supports_stored_generated_columns"}
603
604
605 class GeneratedModelOutputFieldDbCollationVirtual(models.Model):
606 name = models.CharField(max_length=10)
607 lower_name = models.GeneratedField(
608 expression=Lower("name"),
609 db_persist=False,
610 output_field=models.CharField(db_collation=test_collation, max_length=11),
611 )
612
613 class Meta:
614 required_db_features = {"supports_virtual_generated_columns"}
615
616
617 class GeneratedModelNull(models.Model):
618 name = models.CharField(max_length=10, null=True)
619 lower_name = models.GeneratedField(
620 expression=Lower("name"),
621 output_field=models.CharField(max_length=10),
622 db_persist=True,
623 null=True,
624 )
625
626 class Meta:
627 required_db_features = {"supports_stored_generated_columns"}
628
629
630 class GeneratedModelNullVirtual(models.Model):
631 name = models.CharField(max_length=10, null=True)
632 lower_name = models.GeneratedField(
633 expression=Lower("name"),
634 output_field=models.CharField(max_length=10),
635 db_persist=False,
636 null=True,
637 )
638
639 class Meta:
640 required_db_features = {"supports_virtual_generated_columns"}
641
642
643 class GeneratedModelBase(models.Model):
644 a = models.IntegerField()
645 a_squared = models.GeneratedField(
646 expression=F("a") * F("a"),
647 output_field=models.IntegerField(),
648 db_persist=True,
649 )
650
651 class Meta:
652 abstract = True
653
654
655 class GeneratedModelVirtualBase(models.Model):
656 a = models.IntegerField()
657 a_squared = models.GeneratedField(
658 expression=F("a") * F("a"),
659 output_field=models.IntegerField(),
660 db_persist=False,
661 )
662
663 class Meta:
664 abstract = True
665
666
667 class GeneratedModelCheckConstraint(GeneratedModelBase):
668 class Meta:
669 required_db_features = {
670 "supports_stored_generated_columns",
671 "supports_table_check_constraints",
672 }
673 constraints = [
674 models.CheckConstraint(
675 condition=models.Q(a__gt=0),
676 name="Generated model check constraint a > 0",
677 )
678 ]
679
680
681 class GeneratedModelCheckConstraintVirtual(GeneratedModelVirtualBase):
682 class Meta:
683 required_db_features = {
684 "supports_virtual_generated_columns",
685 "supports_table_check_constraints",
686 }
687 constraints = [
688 models.CheckConstraint(
689 condition=models.Q(a__gt=0),
690 name="Generated model check constraint virtual a > 0",
691 )
692 ]
693
694
695 class GeneratedModelUniqueConstraint(GeneratedModelBase):
696 class Meta:
697 required_db_features = {
698 "supports_stored_generated_columns",
699 "supports_expression_indexes",
700 }
701 constraints = [
702 models.UniqueConstraint(F("a"), name="Generated model unique constraint a"),
703 ]
704
705
706 class GeneratedModelUniqueConstraintVirtual(GeneratedModelVirtualBase):
707 class Meta:
708 required_db_features = {
709 "supports_virtual_generated_columns",
710 "supports_expression_indexes",
711 }
712 constraints = [
713 models.UniqueConstraint(
714 F("a"), name="Generated model unique constraint virtual a"
715 ),
716 ]