Source code
from itertools import chain
from django.core.exceptions import (
NON_FIELD_ERRORS,
FieldError,
ImproperlyConfigured,
ValidationError,
)
from django.core.validators import ProhibitNullCharactersValidator
from django.db.models.utils import AltersData, get_blank_choice_label
from django.forms.fields import ChoiceField, Field
from django.forms.forms import BaseForm, DeclarativeFieldsMetaclass
from django.forms.formsets import BaseFormSet, formset_factory
from django.forms.utils import ErrorList
from django.forms.widgets import (
HiddenInput,
MultipleHiddenInput,
RadioSelect,
SelectMultiple,
)
from django.utils.choices import BaseChoiceIterator
from django.utils.hashable import make_hashable
from django.utils.text import capfirst, get_text_list
from django.utils.translation import gettext
from django.utils.translation import gettext_lazy as _
class InlineForeignKeyField(Field):
"""
A basic integer field that deals with validating the given value to a
given parent instance in an inline.
"""
widget = HiddenInput
default_error_messages = {
"invalid_choice": _("The inline value did not match the parent instance."),
}
def __init__(self, parent_instance, *args, pk_field=False, to_field=None, **kwargs):
self.parent_instance = parent_instance
self.pk_field = pk_field
self.to_field = to_field
if self.parent_instance is not None:
if self.to_field:
kwargs["initial"] = getattr(self.parent_instance, self.to_field)
else:
kwargs["initial"] = self.parent_instance.pk
kwargs["required"] = False
super().__init__(*args, **kwargs)
def clean(self, value):
if value in self.empty_values:
if self.pk_field:
return None
# if there is no value act as we did before.
return self.parent_instance
# ensure we compare the values as equal types.
if self.to_field:
orig = getattr(self.parent_instance, self.to_field)
else:
orig = self.parent_instance.pk
if str(value) != str(orig):
raise ValidationError(
self.error_messages["invalid_choice"], code="invalid_choice"
)
return self.parent_instance
def has_changed(self, initial, data):
return False
Run 1
The code is well-structured with clear logical organization: imports are grouped logically, the class has a clear docstring, and methods are concise. Nesting is minimal, with only one level in the constructor and clean method. Intent is clear throughout—the field validates values against a parent instance. Code length is appropriate with no unnecessary verbosity. Action granularity is mostly one action per line, though some lines like chained getattr calls in the clean method could be considered slightly dense but remain readable. Reading flow is natural, with straightforward method ordering and intuitive variable naming. Minor deductions for the parent_instance arguments potentially hurting reusability, but overall this is Django-quality readable code.
Run 2
The code is well-structured with clear separation between imports, class definition, and methods. Imports are logically grouped by source. The class has a clear docstring and concise error messages. Nesting is minimal, with only a couple of single-level conditionals. Intent is clear: this field validates inline foreign key relationships. Code length is appropriate for the functionality, with no unnecessary verbosity. Action granularity is mostly one action per line, improving readability. Reading flow is natural, with __init__ followed by clean and has_changed, which mirrors typical Django form field behavior. Minor points: the conditional block in __init__ could be slightly simplified, and the comment 'ensure we compare the values as equal types' is helpful but slightly informal. Overall, very readable code that follows Django conventions well.
Run 3
The code is highly readable with clear structure and intent. Imports are well-organized, grouped logically, and follow standard Django conventions. The class has a clear docstring explaining its purpose. Methods are concise, each performing a single responsibility. Nesting is minimal—only one level of conditional logic in `clean()` and `__init__()`. Variable names are descriptive (`parent_instance`, `pk_field`, `to_field`). Comments explain non-obvious behavior without being excessive. The code avoids unnecessary complexity and maintains a natural reading flow. Minor deductions: the `clean()` method could be slightly flatter, and some conditional branches could use helper methods if the logic grew, but at this length it remains clear.
Run 1
Code Structure: The class is logically organized into initialization, validation, and change detection, although many imports are unused in this snippet. Nesting: Conditional nesting is shallow and manageable; early returns simplify validation. Clarity of intent: Descriptive class and method names, a docstring, and comments explain the parent-instance validation. However, 'orig' is vague, the integer-field description contrasts with string-based comparison, and the unconditional has_changed() result lacks explanation. Code length: The class is concise, but the extensive import block adds unnecessary reading overhead for the provided code. Action granularity: Each statement performs a single clear action, with no compressed multi-action lines. Reading flow: Initialization naturally precedes validation and change detection, and formatting makes branches easy to follow. Minor naming and documentation issues prevent a higher score.
Run 2
Code Structure: The class is logically organized into initialization, validation, and change detection, although many imports are unused in this snippet. Nesting: Conditional nesting is shallow and manageable, with early returns simplifying validation. Clarity of intent: Descriptive names, a docstring, and comments explain the parent-instance relationship; however, the integer-field description is slightly misleading, and always returning False from has_changed lacks explanation. Code length: Methods are concise, though repeated parent-key lookup logic and excessive imports add some overhead. Action granularity: Each statement performs a single clear action, and multiline calls improve readability. Reading flow: Initialization naturally precedes validation and change detection; consistent formatting supports easy scanning, while the large import block delays reaching the relevant logic.
Run 3
Code Structure: The class is logically organized into initialization, validation, and change detection, although many imports are unused in this snippet. Nesting: Branching is shallow and manageable, with early returns simplifying validation. Clarity of intent: Descriptive names, a docstring, and explicit error handling communicate the purpose well; however, the docstring calls this an integer field while validation compares strings, and the unconditional has_changed() result lacks explanation. Code length: Methods are concise, though unused imports add clutter and parent-field lookup logic is repeated. Action granularity: Statements generally perform one action per line, with readable formatting for longer expressions. Reading flow: Initialization naturally precedes validation and change detection; straightforward conditionals make execution easy to follow, although the vague backward-compatibility comment provides little useful context.