Sample
pyint-d77f6bfd24e4-I11
Split eligible integer literals into pairs of short-named intermediate variables
Scores
| Method | Score | Scale |
|---|---|---|
| Posnett | 0.998 | 0–1; higher is more readable |
| Dorn | 0.28 | 0–1; higher is more readable |
| Mi | 0.77 | 0–1; higher is more readable |
| LLOC | 56 | Logical lines; fewer is more readable |
| DeepSeek V4 Pro | 16.67 | 0–20; mean of three runs |
| GPT-6.1 Sol | 18 | 0–20; mean of three runs |
| BTTF | 0.64 | 0–1; higher is more readable |
Views
Loading feature diagnosis…
Source regions
Feature contributions
Feature contributions
| Feature | Value | Contribution (log-odds) |
|---|---|---|
| Source linesThe number of non-empty source lines. | 189 | +75.6 |
| Halstead volumeHow much symbolic information the code contains. It combines the total number of operators and values with the number of distinct ones. | 2161.997 | −71.346 |
| Byte entropyHow varied the bytes in the source text are. Repeated bytes give a lower value; a more even mixture gives a higher value. | 4.501 | −6.752 |
Intercept 8.87 + feature contributions = 6.372 (log-odds).
Score = sigmoid(6.372) = 0.998.
Feature contributions
| Feature | Value | Contribution (log-odds) |
|---|---|---|
| Comment layout frequencyHow frequently the layout switches between lines containing only comments or whitespace and lines containing code. | 190 | −5.691 |
| Indentation frequencyHow rapidly indentation changes from line to line. | 114 | +3.206 |
| Identifier layout (vertical)How rapidly the visual pattern of identifier characters changes from top to bottom. | 188.988 | +2.232 |
| Number layout frequencyHow rapidly the number of numeric values per line changes through the code. | 114 | −2.195 |
| Operator visual areaThe share of the code’s visual area occupied by operators such as +, =, and *. | 0.023 | +0.721 |
| Comment layout (horizontal)How rapidly the visual pattern of comment characters changes from left to right. | 79.3 | +0.475 |
| Identifier layout (horizontal)How rapidly the visual pattern of identifier characters changes from left to right. It measures spatial frequency, not the meaning of the names. | 80.911 | +0.238 |
Intercept 0.07 + feature contributions = -0.944 (log-odds).
Score = sigmoid(-0.944) = 0.28.
| Score | 0.77 |
|---|
| Score | 56 |
|---|
Run 1
The code is highly readable with clear structure and intent. The ClassProps class uses __slots__ and has a straightforward __init__ that maps parameters to attributes one per line. The nested enums (Hashability, KeywordOnly) are logically grouped and well-documented. Each enum value has a docstring explaining its purpose. The docstring for ClassProps is comprehensive, documenting all attributes with types and descriptions. The is_hashable property is concise and readable. Import organization is clean, using standard library, third-party, and local imports in separate blocks. Minor deductions: the __init__ method is somewhat long (16 parameters) but unavoidable given the class's purpose as a data container; the enum value assignments use string values rather than auto() which is stylistic but acceptable. Overall, the code demonstrates excellent organization, minimal nesting, clear intent, and natural reading flow.
Run 2
The code is highly readable. The module imports are logically grouped. The ClassProps class has a clear docstring explaining each attribute, which significantly improves clarity of intent. The use of enum.Enum subclasses for Hashability and KeywordOnly with descriptive docstrings is excellent. The __slots__ declaration and __init__ method are straightforward, though the __init__ is somewhat long due to many parameters, it is unavoidable given the class's purpose. The is_hashable property logic is simple and clear. Minor nesting is limited to the enum definitions and property return, keeping the structure flat. Overall, the code is well-documented, logically organized, and easy to understand.
Run 3
The code is generally well-structured and readable. It uses clear class and attribute names, comprehensive docstrings, and a logical organization. The use of enums for Hashability and KeywordOnly improves clarity. The __slots__ declaration and explicit __init__ are straightforward. However, readability is slightly reduced by the long list of properties in __init__ and the repetitive assignment block, which could be more concise. The imports section is somewhat extensive, though appropriate for the module's scope. Overall, the code is clear and maintainable with only minor verbosity issues.
Run 1
1. Code Structure: Imports, documentation, nested enums, slots, initialization, and the property are logically organized. 2. Nesting: Shallow nesting; the nested enums appropriately group related concepts. 3. Clarity of intent: Descriptive names and thorough documentation clearly explain the class properties and enum values, though constructor type annotations would help. 4. Code length: Explicit slots, constructor parameters, and assignments repeat field names, making the class somewhat verbose; documentation is extensive but useful. 5. Action granularity: Each assignment performs one action per line, and the boolean expression is cleanly split. 6. Reading flow: Consistent formatting and predictable ordering make the code easy to follow, although the long docstring delays reaching the implementation.
Run 2
Code Structure: Imports, documentation, enums, slots, initialization, and the derived property are logically organized. Nesting: Shallow and appropriate; nested enums introduce little complexity. Clarity of intent: Descriptive names and extensive documentation make the class's purpose and properties clear, though constructor type annotations would improve clarity. Code length: The implementation is straightforward, but field names repeat across documentation, slots, parameters, and assignments, creating some verbosity. Action granularity: Each assignment performs one action, and enum values and property logic are clearly separated. Reading flow: The progression from class purpose to configuration options and implementation is natural, with consistent field ordering aiding navigation. The lengthy documentation and constructor slightly slow scanning, but overall readability is high.
Run 3
Code Structure: Imports, documentation, nested enums, slots, initialization, and the property are logically organized. Nesting: Shallow and purposeful, with no complex control flow. Clarity of intent: Descriptive names and comprehensive docstrings clearly explain the class and its settings; missing parameter and return annotations slightly reduce clarity. Code length: Straightforward but verbose, with field names repeated across documentation, slots, parameters, and assignments. Action granularity: Each assignment and enum declaration performs one action, making individual operations easy to scan. Reading flow: Consistent formatting and predictable ordering support natural reading, although extensive documentation and the long constructor delay reaching the implementation.