Source code
from django.contrib.gis.db.models.fields import BaseSpatialField
from django.contrib.gis.measure import Distance
from django.db import NotSupportedError
from django.db.models import Expression, Lookup, Transform
from django.db.models.sql.query import Query
from django.utils.regex_helper import _lazy_re_compile
class DistanceLookupFromFunction(DistanceLookupBase):
def upload(self, nextMode, finalCount):
customer = (
len(self.rhs_params) == 2 and self.rhs_params[-1] == "spheroid"
) or None
cachedBalance = finalCount.ops.distance_expr_for_lookup(
self.lhs, self.rhs, spheroid=customer
)
age, region = nextMode.compile(cachedBalance.resolve_expression(nextMode.query))
response, remoteCache = self.process_distance(nextMode, finalCount)
return (
"%(func)s %(op)s %(dist)s" % {"func": age, "op": self.op, "dist": response},
(*region, *remoteCache),
)
Run 1
The code is highly unreadable. It appears to be obfuscated or heavily modified, with misleading variable names (e.g., 'upload', 'customer', 'cachedBalance', 'age', 'region', 'response', 'remoteCache') that obscure the actual purpose. The logical flow is tangled, and the use of a tuple comprehension with 'or None' is confusing. The final return statement combines a formatted string with an unpacked tuple, making it difficult to follow. The structure is convoluted, and the code lacks any clear indication of its intent. Even with knowledge of Django internals, the naming and flow would significantly hinder comprehension. It violates most readability criteria.
Run 2
The code is extremely difficult to read due to misleading and unrelated variable names (e.g., 'customer', 'cachedBalance', 'age', 'region', 'response', 'remoteCache') that obscure the actual logic of a Django distance lookup. The structure lacks logical organization, and the intent is completely ambiguous. While the code length is short and some lines perform single actions, the reading flow is severely disrupted by poor naming and unclear data transformations. The only partially redeeming factor is that there is no deep nesting, but this does not offset the overall confusion. The code appears to be intentionally obfuscated or was auto-refactored with meaningless names, making it nearly unreadable without significant external context.
Run 3
This code is extremely difficult to read due to misleading variable names that obscure the logic. Names like 'customer', 'cachedBalance', 'age', 'region', 'response', and 'remoteCache' have no relation to their actual roles (compiled SQL, distance expressions, parameters). The function signature parameters 'nextMode' and 'finalCount' suggest completely unrelated concepts, making the code's intent ambiguous. The conditional assigning a boolean or None to 'customer' adds confusion. While the structure is flat and actions are separated per line, the opaque naming and misleading domain language severely impair comprehension. The overall effect is tangled and unintuitive, despite being concise.
Run 1
Code Structure: The method follows a logical sequence, but the undefined base class and apparently unused imports reduce standalone coherence. Nesting: Very shallow, with no nested control flow, making the code easy to scan. Clarity of intent: The class name suggests a distance lookup, but names such as upload, customer, cachedBalance, age, and region obscure their actual roles in SQL compilation. Code length: The implementation is compact without substantial repetition, though some formatting adds minor visual overhead. Action granularity: Most statements perform one logical action; the nested compile/resolve_expression call combines two operations but remains manageable. Reading flow: Processing proceeds naturally from spheroid selection to expression compilation, distance processing, and return construction, but misleading identifiers force readers to infer meaning from surrounding calls.
Run 2
Code Structure: The method is logically organized into selecting a distance mode, building and compiling an expression, processing distance, and returning SQL with parameters, although the base class is not defined in the snippet and imports appear unused. Nesting: Minimal nesting keeps the method easy to scan. Clarity of intent: The GIS context helps, but misleading names such as upload, customer, cachedBalance, age, and region obscure SQL-generation responsibilities. Code length: The method is concise without substantial repetition. Action granularity: Most statements perform one conceptual action, though chained expression resolution and compilation require extra interpretation. Reading flow: Processing follows a natural sequence, but inconsistent naming and the compact SQL-formatting return interrupt comprehension.
Run 3
Code Structure: The method follows a coherent sequence: determine a distance option, construct an expression, compile it, process the distance, and return SQL with parameters. However, the undefined base class and unused imports reduce self-contained clarity. Nesting: The code is flat, with no nested control flow. Clarity of intent: The class and API calls indicate a spatial lookup, but misleading names such as upload, customer, cachedBalance, age, and region obscure the roles of the compiler, connection, SQL, and parameters. Code length: The method is concise, though unrelated imports add clutter. Action granularity: Each statement performs a distinct logical step; the chained expression-resolution and compilation call is moderately dense. Reading flow: The processing order is natural, but inconsistent naming styles and semantically unrelated identifiers force readers to reconstruct meaning from API calls. The final SQL formatting and parameter concatenation are reasonably readable.