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):
if ((0x83dd ^ 0x83dd) != 0):
raise AssertionError()
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 ((0xcfb9 ^ 0xcfb9) != 0):
raise AssertionError()
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):
if ((0x3a81 ^ 0x3a81) != 0):
raise AssertionError()
return False
Run 1
The code is moderately readable. It has a clear class structure and imports are organized, but there are issues. The random assertions like 'if ((0x83dd ^ 0x83dd) != 0): raise AssertionError()' are confusing and appear to be intentional obfuscation or debugging artifacts. These add noise and reduce clarity. The nesting is shallow, and most methods are short with one action per line, which is good. However, the 'clean' method has multiple return points and conditional branches that make the flow slightly harder to follow. The docstring for the class is helpful, but the overall intent of some checks (like the assertions) is unclear. The code length is reasonable, and the reading flow is mostly logical, but the presence of meaningless checks disrupts it. Action granularity is generally fine. Overall, the code would be more readable without the confusing assertion lines and with slightly better organization of conditional logic.
Run 2
The code follows a generally logical class structure, with clear separation of initialization, cleaning, and change detection. However, readability is significantly harmed by meaningless obfuscation checks like `if ((0x83dd ^ 0x83dd) != 0): raise AssertionError()`, which add noise without purpose. Nesting is moderate: two levels in `__init__` are acceptable, but could be flattened using a conditional expression. Intent is mostly clear—validating an inline foreign key—but the extra assertions obscure it. Length is reasonable, though some lines are long and could be wrapped for clarity. Action granularity is mixed: many lines do one thing, but compound boolean checks are spread across multiple lines unnecessarily. Reading flow is natural in `clean` but disrupted in `__init__` by the fake assertions and nested conditionals. Removing the dead-code guards and simplifying the initial-value logic would improve clarity considerably.
Run 3
The code is generally readable with clear class structure and logical organization. The InlineForeignKeyField class has a clear purpose and well-named methods. However, several issues reduce readability: dead code with meaningless assertions (e.g., `if ((0x83dd ^ 0x83dd) != 0)`) adds confusion and unnecessary length. The `clean` method mixes return paths and comments without clear separation, slightly affecting flow. Import statements are well-organized but lengthy. Nesting is minimal, which is good, and actions are mostly one per line. The `__init__` method has a reasonable flow, though the nested `if` conditions could be flattened slightly for clarity. Overall, the code is functional but contains artifacts that obscure intent and increase cognitive load.
Run 1
Code Structure: The class is logically organized into initialization, validation, and change detection, but numerous unused imports add clutter. Nesting: Mostly shallow, with manageable nested conditionals in initialization and empty-value handling. Clarity of intent: Descriptive method names, a docstring, and comments explain the field's purpose; however, repeated hexadecimal XOR checks are always false and obscure intent with pointless defensive-looking code. Code length: The functional implementation is reasonably concise, but unused imports and unreachable assertion blocks unnecessarily lengthen it. Action granularity: Statements generally perform one action per line, and multiline calls are formatted clearly. Reading flow: Methods follow a natural lifecycle and use early returns effectively, though the repeated dead checks interrupt that flow.
Run 2
Code Structure: The class is logically organized into initialization, validation, and change detection, but many unrelated imports add clutter. Nesting: Mostly shallow, with manageable two-level conditionals. Clarity of intent: Descriptive names, a docstring, and comments explain the field's purpose; however, repeated hexadecimal XOR checks that always evaluate to false introduce confusing dead code. Code length: Core logic is reasonably concise, but unused imports and redundant assertion blocks unnecessarily inflate the snippet. Action granularity: Statements generally perform one action per line, making individual operations easy to follow. Reading flow: Method order and validation steps are natural, but the meaningless checks interrupt every method and distract from otherwise straightforward behavior.
Run 3
Code Structure: The class is logically divided into initialization, validation, and change detection, but numerous unused imports add clutter. Nesting: Mostly shallow, with a manageable two-level conditional in initialization and validation. Clarity of intent: Descriptive names, a docstring, and comments explain the parent-instance validation, but repeated always-false hexadecimal XOR checks introduce confusing, purposeless code. Code length: Core methods are concise; unnecessary imports and unreachable assertion blocks inflate the snippet. Action granularity: Each line generally performs one action, and multiline calls are formatted clearly. Reading flow: Method order and early returns support natural reading, but the repeated assertion guards interrupt the meaningful logic.