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 generally readable with clear structure, logical organization, and good use of docstrings and naming. Imports are well-grouped. The class has a clear purpose and methods are concise with one primary action per line, aiding comprehension. Nesting is shallow, and the reading flow is natural. Minor readability issues include the long `__init__` method signature, the somewhat dense `clean` method with inline comments breaking the flow, and multiple actions clustered in conditional blocks. The absence of type hints also slightly reduces immediate clarity of intent. Overall, it is well-structured and clear, but could benefit from slight improvements in formatting and annotation to reach a higher score.
Run 3
The code is generally readable with clear class and method names, logical import organization, and a coherent structure. The InlineForeignKeyField class is well-organized, and methods are concise with clear purposes. However, there are some readability issues: the __init__ method has multiple parameters and several conditional branches that could be simplified, clean() has nested conditionals and comments that add some cognitive load, and the overall flow could be more linear. The code is not deeply nested but has moderate complexity. Action granularity is mostly good—most lines do one thing—but some conditional blocks could be broken down. Imports are well-structured, and docstrings clarify intent. Overall, it's above average but not exemplary due to minor verbosity and branching.
Run 1
Code Structure: The class is logically organized into initialization, validation, and change detection, although many unrelated, unused imports clutter the snippet. Nesting: Conditional nesting is shallow and manageable, with early returns simplifying validation. Clarity of intent: Descriptive method and attribute names, a docstring, and comments explain the parent-instance validation; however, 'orig' is vague, and the integer-field description does not fully reflect the string-based comparison. Code length: Methods are concise, but the extensive unused imports add unnecessary length. Action granularity: Each statement generally performs one action, with cleanly formatted calls and assignments. Reading flow: Initialization naturally precedes validation and change detection, and branches are easy to follow; the historical comment and unexplained unconditional has_changed() result slightly interrupt understanding.
Run 2
Code Structure: The class is logically organized into initialization, validation, and change detection, although numerous unused imports clutter the snippet. Nesting: Conditional nesting is shallow and easy to follow, with early returns simplifying validation. Clarity of intent: The docstring, descriptive method names, and comments explain the field's purpose; however, 'orig' is vague, and always returning False in has_changed lacks explanation. Code length: The implementation is compact, but unused imports add unnecessary length. Action granularity: Statements generally perform one action per line, and multiline calls improve readability. Reading flow: Initialization naturally precedes validation and change detection, with consistent formatting and straightforward branches. Understanding some behavior requires familiarity with Django's field conventions.
Run 3
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 manageable, with early returns simplifying validation. Clarity of intent: Descriptive method and attribute names, a docstring, and comments explain the parent-instance validation; however, 'orig' is vague and the unconditional has_changed() result lacks explanation. Code length: Methods are concise, but the extensive unused imports add clutter. Action granularity: Statements generally perform one action per line, and the multiline exception construction is easy to scan. Reading flow: Initialization followed by validation and change detection provides a natural progression, with consistent formatting and clear separation of responsibilities.