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 and readable. Imports are clearly organized with sensible grouping from standard and Django libraries. The class has a clear single responsibility and follows Django conventions. Nesting is shallow, with only one level in the clean() method's conditional logic. Intent is immediately apparent from the class name, docstring, and method names. Code length is appropriate — no unnecessary verbosity or duplication. Each logical action is generally on its own line, and variable names are descriptive (parent_instance, pk_field, to_field). Reading flow is natural: initialization, validation, change detection. Minor deductions: the conditional assignment in __init__ could be slightly clarified, and a brief comment explaining the string comparison in clean() would improve understanding. Overall, it's maintainable and idiomatic Django code.
Run 3
The code is well-structured and follows Django conventions. Imports are logically grouped by module. The class has a clear single purpose with a helpful docstring. Methods are short and focused, with good separation of concerns. Nesting is shallow, with only one level inside `__init__` and `clean`. Action granularity is largely one action per line, improving traceability. Reading flow is natural — the `clean` method clearly indicates the validation path, including fallbacks for empty values and conversions for comparison. Minor deductions: a few lines are slightly dense (e.g., chained attribute access and combined if/else), and the `has_changed` method lacks a docstring or explanatory comment despite being non-obvious behavior. Overall, clarity is high, length is appropriate, and structure is idiomatic.
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 method names, the docstring, and comments explain the parent-instance validation, though 'orig' is vague and the constant False from has_changed lacks explanation. Code length: The implementation is concise, but the extensive imports add unnecessary visual overhead. Action granularity: Statements generally perform one action per line, with readable multiline formatting. Reading flow: Initialization naturally precedes validation and change detection, and validation progresses clearly from empty-value handling to comparison and return.
Run 2
Code Structure: The class is logically organized into initialization, validation, and change detection, though many imports are unused in this snippet. Nesting: Conditional nesting is shallow, and early returns keep validation easy to follow. Clarity of intent: Descriptive names, a class docstring, and comments explain the parent-instance validation; however, 'orig' is vague, and the unconditional False in has_changed lacks an explanation. Code length: Methods are concise, although the extensive import block adds unnecessary length to the presented code. Action granularity: Each statement performs a single clear action, with sensible formatting of longer expressions. Reading flow: Initialization naturally precedes validation, and the validation progresses from empty-value handling to comparison and error reporting.
Run 3
Code Structure: The class is logically organized into initialization, validation, and change detection, though numerous unused imports clutter the snippet. Nesting: Conditional nesting is shallow and manageable, with early returns simplifying validation. Clarity of intent: Descriptive class and attribute names, a docstring, and comments explain the parent-instance validation purpose; 'orig' is less descriptive, and the unconditional has_changed() result lacks explanation. Code length: Methods are concise, but the import block is disproportionately long for the functionality shown. Action granularity: Each statement generally performs one action, and multiline formatting keeps calls readable. Reading flow: Initialization naturally precedes validation and change detection; straightforward branching makes execution easy to follow, with minor repetition in retrieving the parent key.