Source code
import operator
from functools import reduce
from django.core.exceptions import EmptyResultSet, FullResultSet
from django.db.models.expressions import Case, When
from django.db.models.functions import Mod
from django.db.models.lookups import Exact
from django.utils import tree
from django.utils.functional import cached_property
class ExtraWhere:
# The contents are a black box - assume no aggregates or windows are used.
contains_aggregate = False
contains_over_clause = False
def __init__(self, b, c):
self.sqls = b
self.params = c
def a(self, d=None, e=None):
f = ["(%s)" % g for g in self.sqls]
return " AND ".join(f), list(self.params or ())
Run 1
The code suffers from severe readability issues. Non-descriptive names like 'a', 'b', 'c', 'd', 'e', 'f', and 'g' obscure intent, making it impossible to understand parameters and flow without external context. The method 'a' is particularly confusing, performing string formatting and parameter flattening while returning a tuple. The class name 'ExtraWhere' is somewhat descriptive, but the comments are minimal and don't clarify the black-box nature. The structure mixes imports and class definition, but the main problem is the obscurity of variables and method names. The code is concise, but at the expense of clarity, violating multiple criteria: clarity of intent, action granularity (the list comprehension and join are packed), and reading flow.
Run 2
This code is extremely hard to read and follow. The class name 'ExtraWhere' is vague, and the method name 'a' conveys no meaning. Parameter names like 'b', 'c', 'd', 'e', 'f', and 'g' are meaningless and make the logic opaque. The imports include several unused modules (operator, reduce, EmptyResultSet, FullResultSet, Case, When, Mod, Exact, tree), which adds clutter and confusion. The class comment is misplaced and does not explain the actual purpose of the class. The method body is concise, but the actions are packed into a single comprehension and join, making the flow hard to parse. Overall, the code lacks clarity of intent and readability; someone maintaining this would struggle to understand what it does without extensive context.
Run 3
The code is short but difficult to read due to poor naming choices. Variables like 'b', 'c', 'a', 'd', 'e', 'f', and 'g' obscure intent, making it hard to understand what the class does without deep analysis. The structure is minimal and nesting is flat, which helps, but the action granularity and reading flow suffer from ambiguous naming and mixed responsibilities in the method. The unused imports (operator, reduce, Case, When, Mod, Exact, tree, cached_property) add unnecessary noise and suggest tangled code. The class lacks a clear explanation of its purpose beyond a brief comment, and the method 'a' combines list comprehension, string joining, and parameter handling in one line, which reduces readability. Overall, the code requires significant effort to interpret despite its concise length.
Run 1
1. Code Structure: A small class logically groups SQL fragments, parameters, and rendering, but numerous unused imports add clutter. 2. Nesting: Flat methods and a simple comprehension are easy to follow. 3. Clarity of intent: ExtraWhere, sqls, and params suggest the purpose, but single-letter method, parameter, and local names obscure meaning; unused method arguments also create uncertainty. 4. Code length: The implementation is concise, although unused imports unnecessarily lengthen it. 5. Action granularity: Assignments are separated cleanly, while the return expression compactly combines joining SQL and normalizing parameters without becoming difficult to parse. 6. Reading flow: Initialization followed by rendering provides a natural sequence, but cryptic identifiers interrupt comprehension.
Run 2
Code Structure: Imports and a small class provide logical organization, though many imports are unused. Nesting: Very flat, with no nested control flow. Clarity of intent: ExtraWhere, sqls, params, and the comment suggest SQL-condition handling, but the method name a and parameters b, c, d, e obscure their roles; d and e are unused. Code length: The implementation is concise, although unused imports add unnecessary bulk. Action granularity: Statements generally perform one action per line; the return combines joining SQL fragments and normalizing parameters without becoming unwieldy. Reading flow: Initialization followed by SQL assembly is natural, but cryptic identifiers force readers to infer meaning from expressions rather than names.
Run 3
Code Structure: The class cleanly groups SQL fragments, parameters, and SQL generation, but several unused imports add clutter. Nesting: The code is flat, with only a straightforward list comprehension. Clarity of intent: Django-related attributes and the comment provide context, while single-letter method, argument, and variable names obscure purpose; unused method arguments also create ambiguity. Code length: The implementation is concise, although imports unrelated to the shown functionality reduce focus. Action granularity: Each statement performs one clear operation, with no compressed multi-statement lines. Reading flow: Initialization naturally precedes SQL generation, but cryptic naming and the lack of a descriptive method name interrupt understanding.