/
fields.py
524 lines (450 loc) · 22.4 KB
/
fields.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
from __future__ import annotations
import copy
from typing import Any, Sequence, cast
from django import VERSION, forms
from django.core.exceptions import ImproperlyConfigured
from django.db.models import Model, fields
from django.utils.encoding import force_str
from django.utils.functional import Promise
from django.utils.translation import override
from modeltranslation import settings as mt_settings
from modeltranslation.thread_context import fallbacks_enabled
from modeltranslation.utils import (
build_localized_fieldname,
build_localized_intermediary_model,
build_localized_verbose_name,
get_language,
resolution_order,
)
from modeltranslation.widgets import ClearableWidgetWrapper
from ._typing import Self
SUPPORTED_FIELDS = (
fields.CharField,
# Above implies also CommaSeparatedIntegerField, EmailField, FilePathField, SlugField
# and URLField as they are subclasses of CharField.
fields.TextField,
fields.json.JSONField,
fields.IntegerField,
# Above implies also BigIntegerField, SmallIntegerField, PositiveIntegerField and
# PositiveSmallIntegerField, as they are subclasses of IntegerField.
fields.BooleanField,
fields.NullBooleanField,
fields.FloatField,
fields.DecimalField,
fields.IPAddressField,
fields.GenericIPAddressField,
fields.DateField,
fields.DateTimeField,
fields.TimeField,
fields.files.FileField,
fields.files.ImageField,
fields.related.ForeignKey,
# Above implies also OneToOneField
fields.related.ManyToManyField,
)
NEW_RELATED_API = VERSION >= (1, 9)
class NONE:
"""
Used for fallback options when they are not provided (``None`` can be
given as a fallback or undefined value) or to mark that a nullable value
is not yet known and needs to be computed (e.g. field default).
"""
pass
def create_translation_field(model: type[Model], field_name: str, lang: str, empty_value: Any):
"""
Translation field factory. Returns a ``TranslationField`` based on a
fieldname and a language.
The list of supported fields can be extended by defining a tuple of field
names in the projects settings.py like this::
MODELTRANSLATION_CUSTOM_FIELDS = ('MyField', 'MyOtherField',)
If the class is neither a subclass of fields in ``SUPPORTED_FIELDS``, nor
in ``CUSTOM_FIELDS`` an ``ImproperlyConfigured`` exception will be raised.
"""
if empty_value not in ("", "both", None, NONE):
raise ImproperlyConfigured("%s is not a valid empty_value." % empty_value)
field = cast(fields.Field, model._meta.get_field(field_name))
cls_name = field.__class__.__name__
if not (isinstance(field, SUPPORTED_FIELDS) or cls_name in mt_settings.CUSTOM_FIELDS):
raise ImproperlyConfigured("%s is not supported by modeltranslation." % cls_name)
translation_class = field_factory(field.__class__)
return translation_class(translated_field=field, language=lang, empty_value=empty_value)
def field_factory(baseclass: type[fields.Field]) -> type[TranslationField]:
class TranslationFieldSpecific(TranslationField, baseclass): # type: ignore[valid-type, misc]
pass
# Reflect baseclass name of returned subclass
TranslationFieldSpecific.__name__ = "Translation%s" % baseclass.__name__
return TranslationFieldSpecific
class TranslationField:
"""
The translation field functions as a proxy to the original field which is
wrapped.
For every field defined in the model's ``TranslationOptions`` localized
versions of that field are added to the model depending on the languages
given in ``settings.LANGUAGES``.
If for example there is a model ``News`` with a field ``title`` which is
registered for translation and the ``settings.LANGUAGES`` contains the
``de`` and ``en`` languages, the fields ``title_de`` and ``title_en`` will
be added to the model class. These fields are realized using this
descriptor.
The translation field needs to know which language it contains therefore
that needs to be specified when the field is created.
"""
def __init__(
self,
translated_field: fields.Field,
language: str,
empty_value: Any,
*args: Any,
**kwargs: Any,
) -> None:
from modeltranslation.translator import translator
# Update the dict of this field with the content of the original one
# This might be a bit radical?! Seems to work though...
self.__dict__.update(translated_field.__dict__)
# Store the originally wrapped field for later
self.translated_field = translated_field
self.language = language
self.empty_value = empty_value
if empty_value is NONE:
self.empty_value = None if translated_field.null else ""
# Default behaviour is that all translations are optional
if not isinstance(self, fields.BooleanField):
# TODO: Do we really want to enforce null *at all*? Shouldn't this
# better honour the null setting of the translated field?
self.null = True
self.blank = True
# Take required_languages translation option into account
trans_opts = translator.get_options_for_model(self.model)
if trans_opts.required_languages:
required_languages = trans_opts.required_languages
if isinstance(required_languages, (tuple, list)):
# All fields
if self.language in required_languages:
# self.null = False
self.blank = False
else:
# Certain fields only
# Try current language - if not present, try 'default' key
try:
req_fields = required_languages[self.language]
except KeyError:
req_fields = required_languages.get("default", ())
if self.name in req_fields:
# TODO: We might have to handle the whole thing through the
# FieldsAggregationMetaClass, as fields can be inherited.
# self.null = False
self.blank = False
# Adjust the name of this field to reflect the language
self.attname = build_localized_fieldname(self.translated_field.name, language)
self.name = self.attname
if self.translated_field.db_column:
self.db_column = build_localized_fieldname(self.translated_field.db_column, language)
self.column = self.db_column
# Copy the verbose name and append a language suffix
# (will show up e.g. in the admin).
self.verbose_name = build_localized_verbose_name(translated_field.verbose_name, language)
# M2M support - <rewrite related_name> <patch intermediary model>
if isinstance(self.translated_field, fields.related.ManyToManyField) and hasattr(
self.remote_field, "through"
):
# Since fields cannot share the same remote_field object:
self.remote_field = copy.copy(self.remote_field)
# To support multiple relations to self, must provide a non null language scoped related_name
if self.remote_field.symmetrical and (
self.remote_field.model == "self"
or self.remote_field.model == self.model._meta.object_name
or self.remote_field.model == self.model
):
self.remote_field.related_name = "%s_rel_+" % self.name
elif self.remote_field.is_hidden():
# Even if the backwards relation is disabled, django internally uses it, need to use a language scoped related_name
self.remote_field.related_name = "_%s_%s_+" % (
self.model.__name__.lower(),
self.name,
)
else:
# Default case with standard related_name must also include language scope
if self.remote_field.related_name is None:
# For implicit related_name use different query field name
loc_related_query_name = build_localized_fieldname(
self.related_query_name(), self.language
)
self.related_query_name = lambda: loc_related_query_name
self.remote_field.related_name = "%s_set" % (
build_localized_fieldname(self.model.__name__.lower(), language),
)
else:
self.remote_field.related_name = build_localized_fieldname(
self.remote_field.get_accessor_name(), language
)
# Patch intermediary model with language scope to create correct db table
self.remote_field.through = build_localized_intermediary_model(
self.remote_field.through, language
)
self.remote_field.field = self
if hasattr(self.remote_field.model._meta, "_related_objects_cache"):
del self.remote_field.model._meta._related_objects_cache
# ForeignKey support - rewrite related_name
elif not NEW_RELATED_API and self.rel and self.related and not self.rel.is_hidden():
current = self.related.get_accessor_name()
self.rel = copy.copy(self.rel) # Since fields cannot share the same rel object.
# self.related doesn't need to be copied, as it will be recreated in
# ``RelatedField.do_related_class``
if self.rel.related_name is None:
# For implicit related_name use different query field name
loc_related_query_name = build_localized_fieldname(
self.related_query_name(), self.language
)
self.related_query_name = lambda: loc_related_query_name
self.rel.related_name = build_localized_fieldname(current, self.language)
self.rel.field = self
if hasattr(self.rel.to._meta, "_related_objects_cache"):
del self.rel.to._meta._related_objects_cache
elif NEW_RELATED_API and self.remote_field and not self.remote_field.is_hidden():
current = self.remote_field.get_accessor_name()
# Since fields cannot share the same rel object:
self.remote_field = copy.copy(self.remote_field)
if self.remote_field.related_name is None:
# For implicit related_name use different query field name
loc_related_query_name = build_localized_fieldname(
self.related_query_name(), self.language
)
self.related_query_name = lambda: loc_related_query_name
self.remote_field.related_name = build_localized_fieldname(current, self.language)
self.remote_field.field = self
if hasattr(self.remote_field.model._meta, "_related_objects_cache"):
del self.remote_field.model._meta._related_objects_cache
# Django 1.5 changed definition of __hash__ for fields to be fine with hash requirements.
# It spoiled our machinery, since TranslationField has the same creation_counter as its
# original field and fields didn't get added to sets.
# So here we override __eq__ and __hash__ to fix the issue while retaining fine with
# http://docs.python.org/2.7/reference/datamodel.html#object.__hash__
def __eq__(self, other: object) -> bool:
if isinstance(other, fields.Field):
return self.creation_counter == other.creation_counter and self.language == getattr(
other, "language", None
)
return super().__eq__(other)
def __ne__(self, other: object) -> bool:
return not self.__eq__(other)
def __hash__(self) -> int:
return hash((self.creation_counter, self.language))
def get_default(self) -> Any:
with override(self.language):
default = super().get_default()
# we must *force evaluation* at this point, otherwise the lazy translatable
# string is returned and will be evaluated only later when the main language
# is activated again (because this context block has exited).
#
# force_str passes protected types as-is, which includes None, int, float,
# datetime...
if isinstance(default, Promise):
default = force_str(default, strings_only=True)
return default
def formfield(self, *args: Any, **kwargs: Any) -> forms.Field:
"""
Returns proper formfield, according to empty_values setting
(only for ``forms.CharField`` subclasses).
There are 3 different formfields:
- CharField that stores all empty values as empty strings;
- NullCharField that stores all empty values as None (Null);
- NullableField that can store both None and empty string.
By default, if no empty_values was specified in model's translation options,
NullCharField would be used if the original field is nullable, CharField otherwise.
This can be overridden by setting empty_values to '' or None.
Setting 'both' will result in NullableField being used.
Textual widgets (subclassing ``TextInput`` or ``Textarea``) used for
nullable fields are enriched with a clear checkbox, allowing ``None``
values to be preserved rather than saved as empty strings.
The ``forms.CharField`` somewhat surprising behaviour is documented as a
"won't fix": https://code.djangoproject.com/ticket/9590.
"""
formfield = super().formfield(*args, **kwargs)
if isinstance(formfield, forms.CharField):
if self.empty_value is None:
from modeltranslation.forms import NullCharField
form_class = formfield.__class__
kwargs["form_class"] = type(
"Null%s" % form_class.__name__, (NullCharField, form_class), {}
)
formfield = super().formfield(*args, **kwargs)
elif self.empty_value == "both":
from modeltranslation.forms import NullableField
form_class = formfield.__class__
kwargs["form_class"] = type(
"Nullable%s" % form_class.__name__, (NullableField, form_class), {}
)
formfield = super().formfield(*args, **kwargs)
if isinstance(formfield.widget, (forms.TextInput, forms.Textarea)):
formfield.widget = ClearableWidgetWrapper(formfield.widget)
return formfield
def save_form_data(self, instance: Model, data: Any, check: bool = True) -> None:
# Allow 3rd-party apps forms to be saved using only translated field name.
# When translated field (e.g. 'name') is specified and translation field (e.g. 'name_en')
# not, we assume that form was saved without knowledge of modeltranslation and we make
# things right:
# Translated field is saved first, settings respective translation field value. Then
# translation field is being saved without value - and we handle this here (only for
# active language).
# Questionable fields are stored in special variable, which is later handled by clean_fields
# method on the model.
if check and self.language == get_language() and getattr(instance, self.name) and not data:
if not hasattr(instance, "_mt_form_pending_clear"):
instance._mt_form_pending_clear = {}
instance._mt_form_pending_clear[self.name] = data
else:
super().save_form_data(instance, data)
def deconstruct(self) -> tuple[str, str, Sequence[Any], dict[str, Any]]:
name, path, args, kwargs = self.translated_field.deconstruct()
if self.null is True:
kwargs.update({"null": True})
if "db_column" in kwargs:
kwargs["db_column"] = self.db_column
return self.name, path, args, kwargs
def clone(self) -> Self:
from django.utils.module_loading import import_string
name, path, args, kwargs = self.deconstruct()
cls = import_string(path)
return cls(*args, **kwargs)
class TranslationFieldDescriptor:
"""
A descriptor used for the original translated field.
"""
def __init__(
self,
field: fields.Field,
fallback_languages: dict[str, tuple[str, ...]] | None = None,
fallback_value: Any = NONE,
fallback_undefined: Any = NONE,
) -> None:
"""
Stores fallback options and the original field, so we know it's name
and default.
"""
self.field = field
self.fallback_languages = fallback_languages
self.fallback_value = fallback_value
self.fallback_undefined = fallback_undefined
def __set__(self, instance, value):
"""
Updates the translation field for the current language.
"""
# In order for deferred fields to work, we also need to set the base value
instance.__dict__[self.field.name] = value
if isinstance(self.field, fields.related.ForeignKey):
instance.__dict__[self.field.get_attname()] = None if value is None else value.pk
if getattr(instance, "_mt_init", False) or getattr(instance, "_mt_disable", False):
# When assignment takes place in model instance constructor, don't set value.
# This is essential for only/defer to work, but I think it's sensible anyway.
# Setting the localized field may also be disabled by setting _mt_disable.
return
loc_field_name = build_localized_fieldname(self.field.name, get_language())
setattr(instance, loc_field_name, value)
def meaningful_value(self, val, undefined):
"""
Check if val is considered non-empty.
"""
if isinstance(val, fields.files.FieldFile):
return val.name and not (
isinstance(undefined, fields.files.FieldFile) and val == undefined
)
return val is not None and val != undefined
def __get__(self, instance, owner):
"""
Returns value from the translation field for the current language, or
value for some another language according to fallback languages, or the
custom fallback value, or field's default value.
"""
if instance is None:
return self
default = NONE
undefined = self.fallback_undefined
if undefined is NONE:
default = self.field.get_default()
undefined = default
langs = resolution_order(get_language(), self.fallback_languages)
for lang in langs:
loc_field_name = build_localized_fieldname(self.field.name, lang)
val = getattr(instance, loc_field_name, None)
if self.meaningful_value(val, undefined):
return val
if fallbacks_enabled() and self.fallback_value is not NONE:
return self.fallback_value
else:
if default is NONE:
default = self.field.get_default()
# Some fields like FileField behave strange, as their get_default() doesn't return
# instance of attr_class, but rather None or ''.
# Normally this case is handled in the descriptor, but since we have overridden it, we
# must mock it up.
if isinstance(self.field, fields.files.FileField) and not isinstance(
default, self.field.attr_class
):
return self.field.attr_class(instance, self.field, default)
return default
class TranslatedRelationIdDescriptor:
"""
A descriptor used for the original '_id' attribute of a translated
ForeignKey field.
"""
def __init__(
self, field_name: str, fallback_languages: dict[str, tuple[str, ...]] | None
) -> None:
self.field_name = field_name # The name of the original field (excluding '_id')
self.fallback_languages = fallback_languages
def __set__(self, instance, value):
lang = get_language()
loc_field_name = build_localized_fieldname(self.field_name, lang)
# Localized field name with '_id'
loc_attname = instance._meta.get_field(loc_field_name).get_attname()
setattr(instance, loc_attname, value)
base_attname = instance._meta.get_field(self.field_name).get_attname()
instance.__dict__[base_attname] = value
def __get__(self, instance, owner):
if instance is None:
return self
langs = resolution_order(get_language(), self.fallback_languages)
for lang in langs:
loc_field_name = build_localized_fieldname(self.field_name, lang)
# Localized field name with '_id'
loc_attname = instance._meta.get_field(loc_field_name).get_attname()
val = getattr(instance, loc_attname, None)
if val is not None:
return val
return None
class TranslatedManyToManyDescriptor:
"""
A descriptor used to return correct related manager without language fallbacks.
"""
def __init__(
self, field_name: str, fallback_languages: dict[str, tuple[str, ...]] | None
) -> None:
self.field_name = field_name # The name of the original field
self.fallback_languages = fallback_languages
def __get__(self, instance, owner):
# TODO: do we really need to handle fallbacks with m2m relations?
loc_field_name = build_localized_fieldname(self.field_name, get_language())
loc_attname = (instance or owner)._meta.get_field(loc_field_name).get_attname()
return getattr((instance or owner), loc_attname)
def __set__(self, instance, value):
loc_field_name = build_localized_fieldname(self.field_name, get_language())
loc_attname = instance._meta.get_field(loc_field_name).get_attname()
setattr(instance, loc_attname, value)
class LanguageCacheSingleObjectDescriptor:
"""
A Mixin for RelatedObjectDescriptors which use current language in cache lookups.
"""
accessor = None # needs to be set on instance
@property
def cache_name(self) -> str:
"""
Used in django 1.x
"""
lang = get_language()
cache = build_localized_fieldname(self.accessor, lang) # type: ignore[arg-type]
return "_%s_cache" % cache
def get_cache_name(self) -> str:
"""
Used in django > 2.x
"""
return build_localized_fieldname(self.accessor, get_language()) # type: ignore[arg-type]