Source code
import itertools
import math
from django.core.exceptions import EmptyResultSet, FullResultSet
from django.db.models.expressions import (
Case,
ColPairs,
Expression,
ExpressionList,
Func,
Value,
When,
)
from django.db.models.fields import (
BooleanField,
CharField,
DateTimeField,
Field,
IntegerField,
UUIDField,
)
from django.db.models.query_utils import RegisterLookupMixin
from django.utils.datastructures import OrderedSet
from django.utils.functional import cached_property
from django.utils.hashable import make_hashable
@Field.register_lookup
class IExact(BuiltinLookup):
lookup_name = "iexact"
prepare_rhs = False
def process_rhs(self, qn, connection):
rhs, params = super().process_rhs(qn, connection)
if params:
params = (connection.ops.prep_for_iexact_query(params[0]), *params[1:])
return rhs, params
Run 1
The code is generally readable with clear intent and good structure. The imports are organized logically, and the class definition is flat with minimal nesting. The `process_rhs` method shows one main action per line, though the conditional tuple assignment is slightly complex. The reading flow is natural: class declaration, attribute assignments, then method definition. However, some clarity is lost due to the implicit assumption that `BuiltinLookup` exists (not imported in this snippet) and the cryptic parameter name `qn`, which requires Django internal knowledge. The code is concise and not unnecessarily long. Overall, it's maintainable but could improve by renaming ambiguous parameters and adding brief docstrings.
Run 2
The code is generally readable with a clear structure: imports are organized by source, the class definition is short, and the method has a straightforward flow. Nesting is minimal — the only conditional is a single-level 'if' block. The intent is fairly clear for developers familiar with Django ORM internals, but less obvious to others; variable names like 'qn', 'rhs', and 'params' rely on domain knowledge. Code length is appropriate and not overly verbose. Each line performs a single action, and the reading flow follows a logical sequence. However, the spread of params and the use of a tuple concatenation with '*params[1:]' slightly reduce clarity for those unfamiliar with Django's query compilation internals. Overall, the readability is good but not exceptional due to implicit assumptions about the reader's knowledge.
Run 3
The code is generally readable with clear imports, a well-structured class, and consistent formatting. The class `IExact` is concise and its purpose is evident from its name and the `lookup_name` attribute. The method `process_rhs` has a clear intent, though the logic for modifying `params` could be slightly more explicit. The nesting is minimal, and the action granularity is appropriate. The reading flow is natural, following Django lookup patterns. Minor deductions are for the slightly dense conditional operation on `params` and the reliance on implicit knowledge of Django internals.
Run 1
Code Structure: Imports, lookup registration, class configuration, and processing logic are logically organized. Nesting: A single conditional keeps nesting shallow. Clarity of intent: The class and method names communicate case-insensitive exact lookup processing, although framework-specific names such as rhs and qn require Django familiarity, and BuiltinLookup is not defined or imported in the snippet. Code length: The implementation is concise, but numerous unused imports add visual clutter. Action granularity: Each statement performs one coherent action; tuple unpacking and parameter reconstruction are compact without becoming difficult to follow. Reading flow: Execution proceeds naturally from superclass processing to conditional parameter preparation and return. An additional blank line before the top-level class would improve formatting.
Run 2
Code Structure: The lookup class is logically organized, with configuration attributes followed by a focused method; the extensive unused imports distract in this snippet. Nesting: A single conditional keeps nesting shallow. Clarity of intent: The class name, lookup_name, and prep_for_iexact_query call clearly indicate case-insensitive exact-match preparation, although rhs and qn require framework familiarity and BuiltinLookup is not defined or imported here. Code length: The implementation is concise, but the import block is disproportionate to the functionality shown. Action granularity: Each line performs one clear operation, with tuple unpacking expressing parameter replacement compactly. Reading flow: The method naturally proceeds from superclass processing to conditional parameter preparation and then returns the result.
Run 3
Code Structure: Imports and lookup implementation are logically organized, although many imports are unused in this snippet and BuiltinLookup is not defined or imported. Nesting: Only one shallow conditional, making control flow easy to follow. Clarity of intent: IExact, lookup_name, and prep_for_iexact_query clearly indicate case-insensitive exact lookup behavior; rhs and qn require framework familiarity. Code length: The implementation is concise, but the extensive import section adds unnecessary length for the code shown. Action granularity: Each statement performs a focused operation; the tuple construction compactly transforms the first parameter while preserving the others. Reading flow: The method naturally proceeds from superclass processing to conditional parameter preparation and return. An additional blank line before the top-level class would improve formatting.