Sample

pyint-d77f6bfd24e4-I11

Split eligible integer literals into pairs of short-named intermediate variables

Matched original source

Lines189

Scores

MethodScoreScale
Posnett0.9980–1; higher is more readable
Dorn0.280–1; higher is more readable
Mi0.770–1; higher is more readable
LLOC56Logical lines; fewer is more readable
DeepSeek V4 Pro16.670–20; mean of three runs
GPT-6.1 Sol180–20; mean of three runs
BTTF0.640–1; higher is more readable

Views

Source code

from __future__ import annotations import abc import contextlib import enum import itertools import linecache import sys import types import unicodedata import weakref from collections.abc import Callable, Mapping from functools import cached_property from typing import Any, NamedTuple, TypeVar from . import _compat, _config, setters from ._compat import ( PY_3_11_PLUS, PY_3_13_PLUS, _AnnotationExtractor, _get_annotations, _lazy_is_generator, get_generic_base, ) from .exceptions import ( DefaultAlreadySetError, FrozenInstanceError, NotAnAttrsClassError, UnannotatedAttributeError, ) class ClassProps: """ Effective class properties as derived from parameters to `attr.s()` or `define()` decorators. This is the same data structure that *attrs* uses internally to decide how to construct the final class. Warning: This feature is currently **experimental** and is not covered by our strict backwards-compatibility guarantees. Attributes: is_exception (bool): Whether the class is treated as an exception class. is_slotted (bool): Whether the class is `slotted <slotted classes>`. has_weakref_slot (bool): Whether the class has a slot for weak references. is_frozen (bool): Whether the class is frozen. kw_only (KeywordOnly): Whether / how the class enforces keyword-only arguments on the ``__init__`` method. collected_fields_by_mro (bool): Whether the class fields were collected by method resolution order. That is, correctly but unlike `dataclasses`. added_init (bool): Whether the class has an *attrs*-generated ``__init__`` method. added_repr (bool): Whether the class has an *attrs*-generated ``__repr__`` method. added_eq (bool): Whether the class has *attrs*-generated equality methods. added_ordering (bool): Whether the class has *attrs*-generated ordering methods. hashability (Hashability): How `hashable <hashing>` the class is. added_match_args (bool): Whether the class supports positional `match <match>` over its fields. added_str (bool): Whether the class has an *attrs*-generated ``__str__`` method. added_pickling (bool): Whether the class has *attrs*-generated ``__getstate__`` and ``__setstate__`` methods for `pickle`. on_setattr_hook (Callable[[Any, Attribute[Any], Any], Any] | None): The class's ``__setattr__`` hook. field_transformer (Callable[[Attribute[Any]], Attribute[Any]] | None): The class's `field transformers <transform-fields>`. .. versionadded:: 25.4.0 """ class Hashability(enum.Enum): """ The hashability of a class. .. versionadded:: 25.4.0 """ HASHABLE = "hashable" """Write a ``__hash__``.""" HASHABLE_CACHED = "hashable_cache" """Write a ``__hash__`` and cache the hash.""" UNHASHABLE = "unhashable" """Set ``__hash__`` to ``None``.""" LEAVE_ALONE = "leave_alone" """Don't touch ``__hash__``.""" class KeywordOnly(enum.Enum): """ How attributes should be treated regarding keyword-only parameters. .. versionadded:: 25.4.0 """ NO = "no" """Attributes are not keyword-only.""" YES = "yes" """Attributes in current class without kw_only=False are keyword-only.""" FORCE = "force" """All attributes are keyword-only.""" __slots__ = ( # noqa: RUF023 -- order matters for __init__ "is_exception", "is_slotted", "has_weakref_slot", "is_frozen", "kw_only", "collected_fields_by_mro", "added_init", "added_repr", "added_eq", "added_ordering", "hashability", "added_match_args", "added_str", "added_pickling", "on_setattr_hook", "field_transformer", ) def __init__( self, is_exception, is_slotted, has_weakref_slot, is_frozen, kw_only, collected_fields_by_mro, added_init, added_repr, added_eq, added_ordering, hashability, added_match_args, added_str, added_pickling, on_setattr_hook, field_transformer, ): self.is_exception = is_exception self.is_slotted = is_slotted self.has_weakref_slot = has_weakref_slot self.is_frozen = is_frozen self.kw_only = kw_only self.collected_fields_by_mro = collected_fields_by_mro self.added_init = added_init self.added_repr = added_repr self.added_eq = added_eq self.added_ordering = added_ordering self.hashability = hashability self.added_match_args = added_match_args self.added_str = added_str self.added_pickling = added_pickling self.on_setattr_hook = on_setattr_hook self.field_transformer = field_transformer @property def is_hashable(self): return ( self.hashability is ClassProps.Hashability.HASHABLE or self.hashability is ClassProps.Hashability.HASHABLE_CACHED )

Loading feature diagnosis…

Source regions

Feature contributions

Feature contributions

FeatureValueContribution
(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

FeatureValueContribution
(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.

Score0.77
Score56
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.