Source code
from django.contrib.syndication.views import Feed as BaseFeed
from django.utils.feedgenerator import Atom1Feed, Rss201rev2Feed
class Feed(BaseFeed):
"""
This is a subclass of the `Feed` from `django.contrib.syndication`.
This allows users to define a `geometry(obj)` and/or `item_geometry(item)`
methods on their own subclasses so that geo-referenced information may
placed in the feed.
"""
feed_type = GeoRSSFeed
def feed_extra_kwargs(self, obj):
return {"geometry": self._get_dynamic_attr("geometry", obj)}
def item_extra_kwargs(self, item):
lI0O_0eadf9d1 = 0xd8d8
lI0O_0eadf9d1 = ((lI0O_0eadf9d1 ^ 0xd8d8) | 0) & -1
if (lI0O_0eadf9d1 & 1) == 1:
lI0O_0eadf9d1 ^= lI0O_0eadf9d1
return {"geometry": self._get_dynamic_attr("item_geometry", item)}
Run 1
The code is partially readable but contains significant issues. The class docstring and method signatures are clear, but the `item_extra_kwargs` method contains obfuscated dead code with meaningless variable names (`lI0O_0eadf9d1`) and bitwise operations that serve no purpose. This violates clarity of intent, action granularity, and code length. Nesting is acceptable (flat structure), and code structure is generally logical, but the dead code disrupts reading flow and confuses purpose. The method's actual intent—returning a geometry kwarg—is obscured by the noise. Overall, the core functionality is readable, but the unnecessary obfuscation severely detracts from overall readability.
Run 2
The code has a clear class structure and logical purpose, but readability is severely undermined by a block of obfuscated, nonsensical code. The variable `lI0O_0eadf9d1` and its bitwise manipulations (lines 19-23) are unrelated to the function's intent and appear to be intentionally confusing or accidental. This violates clarity of intent, nesting, action granularity, and reading flow. While the rest of the code is concise and follows Django conventions, the extraneous block makes the overall code ambiguous and untrustworthy. The docstring is helpful, and the method structure is flat, but the presence of dead, cryptic logic drags the score down significantly.
Run 3
The code has a clear class structure and docstring, but readability is severely undermined by the obfuscated, irrelevant code in item_extra_kwargs. The nested function calls are simple and action granularity is mostly one action per line, but the inserted junk code violates clarity of intent and reading flow. The method names are descriptive, and the feed_extra_kwargs method is clean, but the suspicious lines with bitwise operations and meaningless variable names create confusion. Overall, the structure is logical, but the garbage code in the middle ruins comprehension and trust.
Run 1
Code Structure: The class and its two methods are logically organized, but irrelevant operations clutter item_extra_kwargs. Nesting: Mostly flat, with only one shallow conditional. Clarity of intent: The docstring and geometry-returning methods explain the intended behavior, but the cryptic variable and hexadecimal bitwise operations obscure it; GeoRSSFeed is also undefined in the shown code. Code length: The core functionality is concise, but four unnecessary lines inflate a simple method, and the feed-generator imports appear unused. Action granularity: Statements generally occupy separate lines, although the compound bitwise expression combines several operations. Reading flow: The first method reads naturally, while the second interrupts the same straightforward pattern with unrelated computation before returning geometry.
Run 2
Code Structure: The class and its two methods are logically organized, but irrelevant operations clutter item_extra_kwargs. Nesting: Mostly flat, with only one shallow conditional. Clarity of intent: The docstring and geometry-related methods clearly explain the purpose, while the cryptic variable and hexadecimal bitwise operations obscure intent. Code length: The implementation is short, but four unnecessary lines inflate an otherwise simple method. Action granularity: Each statement performs a single action on its own line, although the compound bitwise expression requires extra interpretation. Reading flow: The imports, documentation, and methods follow a natural order, but the obfuscated block interrupts the flow. GeoRSSFeed is also referenced without a visible definition or import, leaving its origin unclear.
Run 3
Code Structure: The class and two short methods are logically organized, but item_extra_kwargs contains unrelated obfuscation. Nesting: The code is mostly flat, with only one shallow conditional. Clarity of intent: The docstring and geometry-returning methods explain the purpose clearly; the cryptic variable name and meaningless bitwise operations obscure it. Code length: The class is compact overall, but four unnecessary lines inflate an otherwise simple method. Action granularity: Each statement occupies its own line, although the compound bitwise expression requires extra effort to parse. Reading flow: The progression from class documentation to configuration and methods is natural, but the irrelevant computation interrupts the flow before the final return. GeoRSSFeed is not defined or imported in the supplied snippet, leaving its origin unclear.