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 as_sql(self, compiler, connection):
a = 1
b = 1
c = 2
d = -1
spheroid = (
len(self.rhs_params) == (a + b) and self.rhs_params[-(c + d)] == "spheroid"
) or None
distance_expr = connection.ops.distance_expr_for_lookup(
self.lhs, self.rhs, spheroid=spheroid
)
sql, params = compiler.compile(distance_expr.resolve_expression(compiler.query))
dist_sql, dist_params = self.process_distance(compiler, connection)
return (
"%(func)s %(op)s %(dist)s" % {"func": sql, "op": self.op, "dist": dist_sql},
(*params, *dist_params),
)
Run 1
This code is essentially unreadable due to deeply obfuscated logic, poor naming, and non-standard constructs. The variables a, b, c, and d are assigned single-character names containing arbitrary numeric values (1, 1, 2, -1) and then combined in an expression to compute an index: len(self.rhs_params) == (a + b) and self.rhs_params[-(c + d)] — which effectively checks length == 2 and index -1. This is needlessly indirect. The boolean assignment with 'or None' adds further confusion. The method's purpose is buried under cryptically structured expressions and repetitive variable allocation. There is no separation of concerns: SQL generation, parameter handling, and conditional logic are all interleaved. The code mixes one action per line in some places but obscures overall reading flow by forcing the reader to decode magic numbers and artificial variable names. The lack of comments or contextual hints compounds the problem. It is highly unmaintainable and would likely fail even basic readability standards.
Run 2
The code is moderately readable but has significant clarity issues. The structure is logical but overly cryptic in variable naming: a, b, c, d are used as magic numbers without explanation, making intent unclear. The spheroid detection logic is particularly confusing due to the arithmetic (a + b, -(c + d)) instead of using plain constants. Nesting is relatively flat, and the reading flow is natural for the SQL compilation sequence. However, the one-line spheroid expression packs too many operations, reducing action granularity. Code length is concise, but at the expense of readability. The method itself handles multiple responsibilities—resolving the distance expression, computing distance SQL, and assembling the final string—which could be separated for better clarity. Overall, the code is maintainable only by someone familiar with Django's spatial lookup internals; it fails to communicate its intent clearly to a general reader.
Run 3
This code is extremely difficult to read. The structure is tangled, with unclear variable names like 'a', 'b', 'c', 'd' used to compute magic numbers, obscuring intent. The nesting is moderate but the logic is convoluted, especially the calculation of 'spheroid'. The code length is short but unnecessarily cryptic; the action granularity is poor as multiple operations are crammed into single lines. The reading flow is disorganized, jumping from variable assignment to boolean logic to SQL compilation without clear separation or comments. Overall, it fails to communicate its purpose effectively.
Run 1
Code Structure: The method is logically organized into spheroid selection, expression compilation, distance processing, and SQL assembly, though several imports appear unused and the base class is not shown. Nesting: The code is flat, with no nested control flow. Clarity of intent: Descriptive method and variable names convey the SQL-generation purpose, but a, b, c, and d obscure simple constants through unnecessary arithmetic. The use of 'or None' also makes the spheroid flag less immediately obvious. Code length: The method is reasonably concise, but the four temporary variables add avoidable length. Action granularity: Most lines perform one clear operation; chained expression resolution and compilation require slightly more effort to parse. Reading flow: Operations follow a natural sequence, but the arbitrary variable setup interrupts that flow, and dictionary-based SQL formatting adds visual complexity.
Run 2
Code Structure: The method is logically organized into spheroid selection, distance-expression compilation, and SQL assembly, though several imports appear unused in this snippet. Nesting: Minimal nesting makes control flow easy to follow. Clarity of intent: Descriptive method and variable names communicate the SQL-generation purpose, but arbitrary variables a, b, c, and d obscure simple constants and indexing. DistanceLookupBase is not defined or imported in the snippet, reducing standalone clarity. Code length: Mostly concise, but the four constant assignments and arithmetic add unnecessary length. Action granularity: Each statement performs a focused action, with sensible tuple unpacking. Reading flow: Processing proceeds naturally toward the return value, although the artificial arithmetic interrupts comprehension and the spheroid expression's use of 'or None' requires extra interpretation.
Run 3
Code Structure: The method is logically organized into spheroid detection, distance-expression construction, compilation, and SQL assembly, though several imports are unused in this snippet. Nesting: The code is flat, with no nested control flow; multiline expressions add only modest visual complexity. Clarity of intent: Descriptive method and variable names convey SQL-generation intent, but a, b, c, and d unnecessarily obscure simple constants and indexing. The 'or None' behavior is compact but less explicit than a conditional. Code length: The method is reasonably short, yet four temporary assignments and arithmetic expressions introduce avoidable length. Action granularity: Each statement generally performs one action, although compilation combines expression resolution and compilation. Reading flow: Execution proceeds naturally toward the return value, but the artificial arithmetic interrupts comprehension, and the base class is not defined or imported in the shown code.