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 a(self, b, c):
d = (
len(self.rhs_params) == 2 and self.rhs_params[-1] == "spheroid"
) or None
e = c.ops.distance_expr_for_lookup(
self.lhs, self.rhs, spheroid=d
)
f, g = b.compile(e.resolve_expression(b.query))
h, i = self.process_distance(b, c)
return (
"%(func)s %(op)s %(dist)s" % {"func": f, "op": self.op, "dist": h},
(*g, *i),
)
Run 1
The code is difficult to read due to meaningless variable names (a, b, c, d, e, f, g, h, i) that obscure their purpose. The method 'a' gives no indication of its functionality. The expression `len(self.rhs_params) == 2 and self.rhs_params[-1] == 'spheroid'` or None is confusing logic that returns None instead of False. Multiple operations are packed into single lines, violating the one-action-per-line principle. The string formatting with positional variables (func, op, dist) makes the return statement opaque. While the code is relatively flat (no deep nesting), it lacks clarity of intent. The structure follows a logical sequence but is poorly named. Overall, this code requires significant effort to understand despite being short. Better variable names, clearer boolean logic, and splitting complex expressions would dramatically improve readability. The code appears to be a Django database lookup function, but the obfuscated naming makes it nearly unreadable.
Run 2
This code is extremely difficult to read due to heavily obfuscated names. Variables like 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i' give no indication of their purpose, making the logic almost impossible to follow without external context. The method name 'a' is equally unhelpful. While the code is relatively flat and concise, it mixes multiple actions into single lines (e.g., compiling expressions and unpacking results), and the intent of the operation is completely obscured by the opaque naming. The reading flow is poor because a reader must decode each variable's role by carefully tracing types and usage. The structure itself is not inherently tangled, but the lack of meaningful identifiers defeats the benefits of the otherwise simple structure.
Run 3
The code is a single method with clear structure: it computes a spheroid flag, obtains a distance expression, compiles it, processes distance, and returns formatted SQL with parameters. Nesting is minimal (one inline conditional and a boolean expression). Intent is somewhat obscured by cryptic parameter names (a, b, c, d, e, f, g, h, i) and reliance on internal Django ORM mechanisms. Length is appropriate for the task. Action granularity is reasonable, though the boolean expression on line 10 does multiple operations in one line. Reading flow is logical top-to-bottom. Overall, the pattern is consistent and the code is concise, but readability suffers from poor naming.
Run 1
Code Structure: The method follows a logical sequence: determine a flag, construct an expression, compile it, process distance, and return SQL with parameters. Nesting: It is flat, with no nested control flow. Clarity of intent: Domain-specific calls suggest a distance lookup, but the method name 'a' and variables 'b' through 'i' obscure roles and require readers to infer meaning. Code length: The implementation is concise, though several imports appear unused in this snippet. Action granularity: Each statement generally performs one cohesive action; tuple unpacking is appropriate, although compilation includes expression resolution inline. Reading flow: Execution order is natural and formatting is consistent, but anonymous identifiers make the data flow difficult to track. The absent definition or import of DistanceLookupBase also leaves some context unclear.
Run 2
Code Structure: The method follows a logical sequence: determine the spheroid option, build and compile an expression, process distance, and return SQL with parameters. Nesting: Flat control flow makes it easy to scan. Clarity of intent: The class name and API calls suggest a spatial distance lookup, but the method name 'a' and variables 'b' through 'i' obscure roles and require inference. Code length: The method is concise, though several unused imports add clutter in this snippet. Action granularity: Most statements perform one coherent action; tuple unpacking is appropriate, although expression resolution and compilation share a line. Reading flow: Execution order is natural, but cryptic identifiers and the subtle 'or None' conversion interrupt comprehension.
Run 3
Code Structure: The method is logically organized into constructing an expression, compiling it, processing distance, and returning SQL with parameters. Nesting: Minimal nesting makes the control flow easy to follow. Clarity of intent: The descriptive class and framework method names provide context, but the method name 'a' and variables 'b' through 'i' obscure roles and require readers to infer meaning. Code length: The implementation is concise, although some multiline formatting adds visual overhead. Action granularity: Each statement performs a distinct step; tuple unpacking naturally groups related outputs. Reading flow: The sequence is linear and coherent, but cryptic naming interrupts comprehension. Unused imports and a base class not defined in the snippet add contextual noise.