Sample

pyint-927e85536bef-I12

Inline all eligible single-use intermediate local variables

Matched original source

DatasetPython transformations
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 Pro170–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 with clear logical organization, effective use of docstrings, and minimal nesting. The class structure is straightforward: imports are organized, and the class properties are well-documented. The constructor is verbose but each parameter maps directly to a slot and assignment, which is intentional for this kind of data structure. The enums and properties are clearly named and self-documenting. Minor deductions: the constructor has 16 parameters and 16 sequential assignments, which is repetitive but not confusing. The `__slots__` tuple is long but necessary and well-commented. The nested enums are appropriately placed and documented. Overall, the code maintains a flat, natural reading flow with clear intent throughout.

Run 3

The code is well-structured and highly readable. It uses clear imports, comprehensive docstrings, and logical organization with nested enums that enhance clarity. The class has a clean __slots__ definition with a helpful comment about ordering, and the __init__ method is straightforward with one assignment per line. The is_hashable property is concise and easy to understand. Minor deductions: the long parameter list in __init__ slightly reduces readability, and the module imports many items that aren't all used in this excerpt. Overall, the code follows good Python practices with flat nesting, clear intent, and natural reading flow.

Run 1

Code Structure: Logically organized into a documented properties container, related enums, slots, initialization, and a derived property. Nesting: Shallow and purposeful; nested enums group related concepts without complex control flow. Clarity of intent: Descriptive names and extensive documentation clearly explain the class and its fields, although constructor type annotations would improve precision. Code length: The implementation is straightforward, but repeating fields across documentation, slots, parameters, and assignments adds considerable boilerplate; the supplied snippet also contains many unused imports. Action granularity: Each assignment and enum declaration occupies its own line, making individual operations easy to identify. Reading flow: Consistent formatting and predictable ordering support natural reading, though the lengthy introductory documentation delays reaching the implementation.

Run 2

Code Structure: Imports, documentation, related enums, slots, initialization, and the derived property are logically organized. Nesting: Shallow nesting is limited to related enum classes and methods, making navigation easy. Clarity of intent: Descriptive names and thorough documentation clearly explain the class properties and enum values; missing parameter and return annotations slightly reduce clarity. Code length: The extensive documentation is useful, but repeating all fields in the documentation, slots, constructor parameters, and assignments adds boilerplate. Action granularity: Each assignment performs one action per line, and the hashability expression is cleanly split. Reading flow: The progression from class purpose to supported values, stored fields, initialization, and derived behavior is natural, although the long documentation and constructor delay reaching executable behavior.

Run 3

Code Structure: Imports, documentation, nested enums, slots, initialization, and the property are logically organized. Nesting: Shallow nesting is appropriate; enum classes group related concepts without complicating control flow. Clarity of intent: Descriptive names and comprehensive documentation clearly explain the class's role and properties, though constructor type annotations would improve clarity. Code length: Extensive documentation and repetition across slots, parameters, and assignments make the class lengthy, but most content serves a clear purpose. Action granularity: Each assignment and enum declaration performs one action, making individual lines easy to understand. Reading flow: The progression from documented properties to their representation and initialization is natural, and the final hashability check is straightforward.