Source code
from django.db.backends.postgresql.psycopg_any import is_psycopg3
from django.db.models import ( CharField, Expression,
Field,
FloatField,
Func, Lookup,
TextField, Value,
)
from django.db.models.expressions import CombinedExpression, register_combinable_fields
from django.db.models.functions import Cast, Coalesce
from django.utils.regex_helper import _lazy_re_compile
from .utils import CheckPostgresInstalledMixin
class LexemeCombinable:
BITAND = "&"
BITOR = "|"
def _combine(self, other, connector, reversed):
if not isinstance(other, LexemeCombinable):
raise TypeError(
"A Lexeme can only be combined with another Lexeme, "
f"got {other.__class__.__name__}." )
if reversed:
return CombinedLexeme(other, connector, self)
return CombinedLexeme(self, connector, other)
# On Combinable, these are not implemented to reduce confusion with Q. In
# this case we are actually (ab)using them to do logical combination so
# it's consistent with other usage in Django.
def __or__(self, other):
return self._combine(other, self.BITOR, False)
def __ror__(self, other):
return self._combine(other, self.BITOR, True)
def __and__(self, other):
return self._combine(other, self.BITAND, False)
def __rand__(self, other):
return self._combine(other, self.BITAND, True)
Run 1
The code is difficult to read due to inconsistent and disorganized import formatting, excessive whitespace within and between import lines, and a misspelled 'LexemeCombinable' vs 'CombinedLexeme' reference. The class definition is somewhat clear but the overall structure feels tangled. Nesting is minimal, which is positive, but clarity of intent is undermined by the formatting and lack of spacing between methods. Code length is reasonable, though the import block is unnecessarily long and visually noisy. Action granularity is mostly one action per line, improving readability, but the reading flow is disrupted by the unformatted imports and missing blank lines between methods. Overall, the code would benefit greatly from running a formatter and fixing minor naming inconsistencies.
Run 2
The code is functional but has several readability issues. Import formatting is inconsistent, with multiple items on a single line followed by oddly spaced multiline imports. The LexemeCombinable class is logically structured, but the _combine method has unnecessary parentheses after the f-string and inconsistent spacing before the closing parenthesis. Action granularity is acceptable, with one operation per line in most cases. The reading flow is interrupted by the import section's erratic formatting and the misplaced closing parenthesis in the TypeError. The class methods are concise and the intent is mostly clear, particularly for bitwise operators. However, the overall structure could be improved with more consistent formatting, proper line breaks in imports, and cleaner error message formatting. The code is understandable but not exemplary in terms of style and clarity.
Run 3
The code is moderately readable but has formatting inconsistencies. The import block is poorly organized with irregular spacing and alignment, though it clearly lists needed imports. The LexemeCombinable class is logically structured with a private _combine method handling shared logic, reducing duplication. Nesting is minimal and clarity of intent is good—the bitwise operator overloading is explained in comments, and the TypeError message is descriptive. However, the closing parenthesis in the error message is awkwardly aligned, and several method definitions lack blank lines between them, disrupting reading flow. Action granularity is mostly one action per line, but the import formatting and inconsistent spacing hurt readability. The code is concise but would benefit from consistent formatting (e.g., PEP 8 spacing).
Run 1
Code Structure: The class logically groups operator constants, a shared combination helper, and operator overloads, but import formatting and missing blank lines weaken organization. Nesting: Shallow conditionals make control flow easy to follow. Clarity of intent: Descriptive names, explicit type validation, and an explanatory comment clarify logical combination; the parameter name 'reversed' shadows a built-in. Code length: Concise, with a shared helper avoiding duplication, though several imports are unused in this snippet. Action granularity: Statements generally perform one action per line, but crowded import entries reduce scanability. Reading flow: The helper followed by paired operator methods is natural; inconsistent whitespace, awkward parenthesis placement, and uneven method spacing interrupt an otherwise straightforward read.
Run 2
Code Structure: Imports precede a focused class, and shared combination logic is sensibly centralized in _combine; inconsistent spacing weakens organization visually. Nesting: Shallow conditionals and early returns keep control flow easy to follow. Clarity of intent: Descriptive names, an explicit type-check error, and a contextual comment explain lexeme combination, though the meaning of the reversed flag requires some interpretation. Code length: Concise, with minimal duplication beyond necessary operator wrappers. Action granularity: Statements generally perform one action per line, but several imports share awkwardly formatted lines. Reading flow: Methods follow a natural progression from shared logic to operator implementations, but missing blank lines and irregular import and parenthesis formatting interrupt scanning.
Run 3
Code Structure: The class logically groups operator constants, a shared combination helper, and operator overloads, although imports and class boundaries lack consistent formatting. Nesting: Shallow conditionals and early returns keep complexity low. Clarity of intent: Descriptive names, an informative error message, and a comment explaining operator behavior make the purpose clear. Code length: The implementation is concise, with duplication appropriately centralized in _combine; several imports are unused in the provided snippet. Action granularity: Most statements perform one action, though multiple imports share inconsistently spaced lines. Reading flow: Methods follow a natural sequence, but irregular whitespace, the awkward closing parenthesis, and missing blank lines interrupt scanning.