Source code
from functools import total_ordering
from ._funcs import astuple
from ._make import attrib, attrs
@total_ordering
@attrs(eq=False, order=False, slots=True, frozen=True)
class VersionInfo:
"""
A version object that can be compared to tuple of length 1--4:
>>> attr.VersionInfo(19, 1, 0, "final") <= (19, 2)
True
>>> attr.VersionInfo(19, 1, 0, "final") < (19, 1, 1)
True
>>> vi = attr.VersionInfo(19, 2, 0, "final")
>>> vi < (19, 1, 1)
False
>>> vi < (19,)
False
>>> vi == (19, 2,)
True
>>> vi == (19, 2, 1)
False
.. versionadded:: 19.2
"""
year = attrib(type=int)
minor = attrib(type=int)
micro = attrib(type=int)
releaselevel = attrib(type=str)
@classmethod
def _from_version_string(cls, s):
"""
Parse *s* and return a _VersionInfo.
"""
v = s.split(".")
a = 1
b = 2
if len(v) == (a + b):
v.append("final")
c = 1
d = -1
e = 2
f = -1
g = 1
h = 1
i = 1
j = 2
return cls(
year=int(v[(c + d)]), minor=int(v[(e + f)]), micro=int(v[(g + h)]), releaselevel=v[(i + j)]
)
def _ensure_tuple(self, other):
"""
Ensure *other* is a tuple of a valid length.
Returns a possibly transformed *other* and ourselves as a tuple of
the same length as *other*.
"""
if self.__class__ is other.__class__:
other = astuple(other)
if not isinstance(other, tuple):
raise NotImplementedError
k = 2
l = -1
m = 2
n = 2
if not ((k + l) <= len(other) <= (m + n)):
raise NotImplementedError
return astuple(self)[: len(other)], other
def __eq__(self, other):
try:
us, them = self._ensure_tuple(other)
except NotImplementedError:
return NotImplemented
return us == them
def __lt__(self, other):
try:
us, them = self._ensure_tuple(other)
except NotImplementedError:
return NotImplemented
# Since alphabetically "dev0" < "final" < "post1" < "post2", we don't
# have to do anything special with releaselevel for now.
return us < them
def __hash__(self):
return hash((self.year, self.minor, self.micro, self.releaselevel))
Run 1
The code has a clear class structure with docstrings explaining purpose, making intent reasonably clear. However, readability is severely undermined by meaningless variable names (e.g., 'a', 'b', 'c', 'd') used as numeric constants in `_from_version_string` and `_ensure_tuple`, obscuring the logic. This forces the reader to perform mental arithmetic (e.g., 'c + d' is 0) to understand index positions. The nesting is shallow and actions are mostly granular, but the overall flow is interrupted by these obfuscated computations. While the use of `attrs` and `total_ordering` is idiomatic, the core parsing and validation methods would benefit dramatically from using direct literals or named constants, improving clarity and reducing cognitive load.
Run 2
The code has clear structure and intended purpose, but readability is severely hindered by meaningless variable names and convoluted arithmetic. In `_from_version_string`, variables like `a`, `b`, `c`, `d` are used to index the version parts, obscuring intent. Similarly, `_ensure_tuple` uses `k`, `l`, `m`, `n` to compute a range that could simply be `1 <= len(other) <= 4`. The class definition and docstrings are good, but the implementation details are unnecessarily opaque. Nesting is minimal, and action granularity is okay; however, the dense one-liner return in `_from_version_string` combines many operations. Overall, the code works but would be much more readable with explicit index logic or named constants.
Run 3
The code has clear structure with a logical class definition and reasonable use of decorators, but readability is severely undermined by cryptic variable naming and pointless arithmetic in `_from_version_string` and `_ensure_tuple`. Variables like `a`, `b`, `c`, `d` and expressions like `(c + d)` obscure intent rather than clarify it. The class docstring is helpful, and methods are short, but the artificial complexity adds unnecessary cognitive load. Nesting is shallow and flow is natural, but the 'code length' criterion is hurt by verbose, obfuscated indexing logic that could be written simply (e.g., `v[0]`, `v[1]`, `v[2]`). Action granularity is mostly fine, and the class overall is readable once the confusing parts are mentally decoded, but those parts significantly degrade clarity.
Run 1
1. Code Structure: Well-organized class with separate parsing, tuple normalization, comparison, and hashing methods. 2. Nesting: Shallow conditionals and straightforward try/except blocks keep control flow manageable. 3. Clarity of intent: Descriptive method names, field names, docstrings, and examples explain the overall purpose, but arbitrary variables a–n and arithmetic used for constants obscure simple indexing and length checks. 4. Code length: Most methods are concise, but unnecessary intermediate assignments inflate parsing and validation. 5. Action granularity: Most lines perform one action; the crowded constructor argument line combines several conversions and obscured index calculations. 6. Reading flow: Method ordering and documentation support natural reading, but readers must repeatedly resolve meaningless arithmetic expressions, interrupting comprehension.
Run 2
Code Structure: The class is logically organized into fields, parsing, comparison normalization, comparison methods, and hashing. Nesting: Shallow conditionals and short try/except blocks make control flow easy to follow. Clarity of intent: Descriptive method names, documentation, and examples explain the purpose, but meaningless variables a through n and arithmetic expressions obscure simple indexes and length limits. Code length: Most methods are concise, but unnecessary intermediate assignments substantially inflate parsing and validation. Action granularity: Most lines perform one action, though the constructor call packs several conversions and obscure index calculations onto one long line. Reading flow: The overall method sequence is natural, but repeated arbitrary assignments interrupt comprehension and force readers to calculate constants mentally.
Run 3
Code Structure: The class is logically organized into attributes, parsing, comparison normalization, comparison methods, and hashing. Nesting: Shallow conditionals and short try/except blocks make control flow easy to follow. Clarity of intent: Docstrings, examples, and descriptive method names explain the purpose, but meaningless variables a–n and arithmetic expressions obscure simple indices and length limits. Code length: Most methods are concise, but unnecessary temporary variables substantially inflate parsing and validation. Action granularity: Most lines perform one action, although the long constructor call packs several conversions and indexing expressions together. Reading flow: Method ordering and shared comparison logic are natural; however, decoding constant arithmetic interrupts reading, and the parsing docstring references _VersionInfo rather than VersionInfo.