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:
class Hashability(enum.Enum):
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):
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__ = (
"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
)
Run 1
The code is highly readable with a clear, logical structure and flat nesting. It uses enums to encapsulate related constants and documents each enum member with docstrings. The ClassProps class organizes related metadata with a clear __slots__ declaration and an explicit constructor assigning each parameter to an attribute. Property logic is straightforward. Minor deductions are due to the verbose constructor, which could be simplified (e.g., using dataclasses or kwargs), and an unused import (sys) that suggests minor cleanup. Overall, intent is clear, actions are well-granulated, and the flow is natural.
Run 2
The code is well-structured with clear imports, type hints, and organized classes. It uses enums with descriptive names and docstrings (albeit sparse). The ClassProps class is flat with minimal nesting and methods are straightforward. However, readability suffers from the very long __init__ with 16 parameters, which creates a large cognitive load and makes the constructor harder to scan. The __slots__ tuple and parameter list mirror each other but are verbose. Action granularity is good—each attribute assignment is on its own line. Reading flow is natural but interrupted by the large parameter block. Missing docstrings on ClassProps and __init__ reduce clarity of intent. Overall, the code is maintainable and clear but could be improved by grouping related parameters or using a dataclass-like pattern to reduce redundancy.
Run 3
The code is moderately readable but has significant issues. The structure is mostly logical with clear class organization, but the ClassProps class has a very long __init__ with 15 parameters creating cognitive load. Nesting is acceptable with only two levels. Clarity of intent is mixed: imported names are reasonably descriptive but the purpose of ClassProps remains somewhat ambiguous without context. Code length is excessive - the 15-parameter constructor and slot definitions could be consolidated. Action granularity is good initially but assignments could be grouped. The reading flow is disrupted by parameter overload and repetitive self-assignment patterns. The enum classes with docstrings are clear, but the overall design lacks sufficient abstraction to make the configuration object approachable.
Run 1
1. Code Structure: Logically organized into configuration enums, slots, initialization, and a derived property; the many imports add clutter to this excerpt. 2. Nesting: Shallow and easy to follow; nested enums appropriately group related concepts. 3. Clarity of intent: Descriptive field names and enum documentation communicate configuration behavior, though ClassProps lacks a class description and constructor type annotations. 4. Code length: Straightforward but repetitive; the same 16 fields appear in slots, parameters, and assignments. Excess blank lines reduce compactness. 5. Action granularity: Each assignment performs one action per line, and the property expression is neatly split. 6. Reading flow: Natural progression from definitions to initialization and behavior, slightly disrupted by whitespace and the lengthy field lists.
Run 2
Code Structure: Imports, related enums, slots, initialization, and a derived property are logically organized. Nesting: Shallow and appropriate; nested enums group related concepts without complicating control flow. Clarity of intent: Descriptive attribute names and enum documentation make the class's purpose mostly clear, but the class and constructor lack explanatory docstrings and parameter type annotations. Code length: The long constructor and repetitive assignments add boilerplate, although they are straightforward and consistent with explicit slot initialization. Action granularity: Each assignment performs one action per line, and the property expression is cleanly formatted. Reading flow: Predictable ordering and matching slot, parameter, and assignment sequences aid navigation. Excessive blank lines, trailing whitespace, and numerous imports not used in this excerpt introduce minor visual noise.
Run 3
Code Structure: Imports, related enums, slots, initialization, and the derived property are logically organized. Nesting: Shallow and appropriate; nested enums clearly belong to ClassProps. Clarity of intent: Descriptive names and enum documentation communicate purpose, although the class and constructor lack explanatory documentation and parameter annotations. Code length: Mostly concise, but the large constructor and repeated slot names and assignments introduce boilerplate. Action granularity: Each assignment performs one action per line, and the property expression is cleanly split. Reading flow: Consistent ordering between slots, parameters, and assignments aids navigation; excessive blank lines, trailing whitespace, and the lengthy import section slightly disrupt flow.