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):
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
return self.parent_instance
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 generally well-structured and readable. It follows Django conventions, has clear class and method names, and logical organization. The imports are grouped logically, and the class structure is coherent. However, there are minor issues: the blank line after the class declaration is unnecessary, and the method 'clean' has some awkward whitespace (blank line before return in the last if-else block) and could be slightly simplified. The nesting level is low, intent is clear, and each action is mostly on its own line, though the conditional blocks in '__init__' and 'clean' are slightly verbose. Overall, it is readable but could be polished for slightly better flow and consistency.
Run 2
The code is generally readable with clear imports, logical class structure, and straightforward method definitions. The __init__ method is well-structured with sensible parameter handling. However, there are some inconsistencies that reduce readability: unnecessary blank lines between the class declaration and its first attribute, inconsistent intent in the clean method where one branch returns None and others return parent_instance without clear explanation, and the presence of whitespace-only lines that disrupt flow. The nesting is minimal and action granularity is good—each line performs a single logical operation. The reading flow is natural for experienced Django developers, though the logic around pk_field and to_field could benefit from a brief comment. Overall, the code is maintainable and clear, with only minor style issues preventing a higher score.
Run 3
The code is generally well-structured and readable, with clear imports, consistent naming, and logical class organization. The `clean` method has moderate nesting (two `if` statements), and action granularity is mostly one action per line. However, there are some minor issues: the `__init__` method could be slightly more concise, and a few blank/indentation lines affect flow. Overall, intent is clear and the code follows Django conventions, but there is room for slight improvement in reducing nesting in `clean` and tightening spacing.
Run 1
Code Structure: The class is logically organized into initialization, validation, and change detection, though numerous unused imports add clutter. Nesting: Conditional nesting is shallow and manageable; early returns simplify validation. Clarity of intent: Descriptive class, method, and attribute names make the purpose clear, although 'orig' is vague and has_changed() returning False without explanation may puzzle readers. Code length: The class is concise, but unused imports and excess blank lines unnecessarily lengthen the snippet. Action granularity: Statements generally perform one action per line, and the multiline exception construction is easy to scan. Reading flow: Methods follow a natural lifecycle and validation proceeds clearly, with minor disruption from whitespace inconsistencies and repeated selection of the parent key.
Run 2
Code Structure: The class is logically organized into initialization, validation, and change detection, but many unused imports clutter the snippet. Nesting: Conditional nesting is shallow and easy to follow, with early returns simplifying validation. Clarity of intent: Descriptive class and attribute names communicate the foreign-key validation purpose, though 'orig' is vague and the unconditional has_changed() result lacks explanation. Code length: Methods are concise, but excessive imports and stray blank lines add unnecessary length. Action granularity: Each statement generally performs one action, and multiline expressions are formatted clearly. Reading flow: Initialization naturally precedes validation and change detection; consistent indentation supports readability, while whitespace artifacts and missing documentation slightly interrupt the flow.
Run 3
Code Structure: The class is logically organized into configuration, initialization, validation, and change detection, though many unrelated imports clutter the excerpt. Nesting: Mostly shallow, with only a few two-level conditionals; early returns keep validation straightforward. Clarity of intent: Descriptive class and method names communicate the purpose, but pk_field, to_field, and orig require some Django knowledge, and the absence of documentation leaves behavioral assumptions unexplained. Code length: The class is concise without unnecessary abstraction, although unused imports and whitespace add noise. Action granularity: Statements generally perform one action per line, with readable multiline formatting. Reading flow: Initialization naturally precedes validation and change detection; stray blank lines slightly disrupt the otherwise clear flow.