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 well-structured and readable. Imports are logically grouped (standard library, Django core, models, utilities), although the alphabetical sorting within the Django sections is slightly broken ('fields' before 'expressions' before 'query_utils' before 'utils'). The class definition is flat, with only one level of nesting inside the method. The purpose of the custom lookup is clear from the class name and lookup_name. The method is concise, with a single action per line, and the conditional update of params is straightforward. Variable names like 'rhs' and 'params' follow Django conventions, aiding familiarity. Overall, the code is easy to follow and maintain.
Run 2
The code is readable and well-structured. Imports are logically grouped (standard library, Django modules), the class has a clear, single responsibility, and methods are concise. The `process_rhs` method uses a clear conditional and tuple unpacking, showing action granularity. However, the lack of surrounding context (e.g., the definition of `BuiltinLookup`) slightly obscures intent, and the tuple slicing with `*params[1:]` could be more explicit, which may momentarily interrupt reading flow. Overall, it is maintainable and logically organized.
Run 3
The code is well-structured and highly readable. Imports are logically organized, grouping standard library, Django core, expressions, fields, query utilities, and utility functions. The class definition is clear with a single responsibility: implementing a case-insensitive exact lookup. Nesting is minimal, with only one conditional inside the method. Intent is explicit—overriding process_rhs to apply database-specific case-insensitive query preparation. Code length is concise, with no unnecessary lines. Action granularity is appropriate, though the tuple construction on line 28 packs multiple operations into one line, slightly reducing clarity. Reading flow is natural: imports, class registration, method override, and parameter transformation. Minor improvements could include unpacking params with a more descriptive variable name than the single-character `*params[1:]` pattern, but overall the code is clean, maintainable, and follows Django conventions well.
Run 1
Code Structure: Imports, registration, class attributes, and the method are logically organized, though many imports are unused in this snippet and BuiltinLookup is not shown as imported. Nesting: A single conditional keeps nesting shallow. Clarity of intent: IExact, lookup_name, and prep_for_iexact_query clearly suggest case-insensitive exact matching; qn and the tuple reconstruction require some framework knowledge. Code length: The implementation is concise, but the extensive import block adds visual overhead. Action granularity: Each statement performs one coherent action, with parameter preparation and reconstruction reasonably combined. Reading flow: The method naturally progresses from superclass processing to optional parameter adjustment and return.
Run 2
Code Structure: A clearly organized lookup class contains configuration attributes and one focused method, although many imports are unused in this snippet. Nesting: A single conditional keeps control flow shallow. Clarity of intent: The class name, lookup_name, and preparation call communicate case-insensitive exact matching, but qn is cryptic and BuiltinLookup is not defined or imported here. Code length: The implementation is concise; the extensive import block adds unnecessary reading overhead for the shown code. Action granularity: Each statement performs one coherent action, with parameter transformation expressed compactly. Reading flow: Processing the right-hand side, conditionally preparing its first parameter, and returning the result follows a natural sequence.
Run 3
Code Structure: The lookup class is logically organized, with configuration attributes followed by a focused method. Nesting: A single conditional keeps nesting shallow. Clarity of intent: The class name, lookup_name, and prep_for_iexact_query clearly indicate case-insensitive exact-match preparation, although qn and the externally defined BuiltinLookup require framework knowledge. Code length: The implementation is concise, but numerous imports are unused in this excerpt and add clutter. Action granularity: Each statement performs one coherent action; tuple unpacking and parameter reconstruction are compact but understandable. Reading flow: The method naturally progresses from superclass processing to conditional parameter preparation and returning results. An additional blank line before the decorated class would improve formatting.