classcore 1.11__tar.gz → 1.12__tar.gz

{classcore-1.11 → classcore-1.12}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: classcore
-Version: 1.11
+Version: 1.12
 Summary: Foundational class factories and decorators.
 Project-URL: Homepage, https://github.com/emcd/python-classcore
 Project-URL: Documentation, https://emcd.github.io/python-classcore

{classcore-1.11 → classcore-1.12}/pyproject.toml

@@ -255,6 +255,7 @@ cache_dir = '.auxiliary/caches/pytest'
 markers = [
     "slow: long-running tests",
 ]
+asyncio_default_fixture_loop_scope = "function"
 
 [tool.ruff]
 #builtins = [ 'ic' ]

{classcore-1.11 → classcore-1.12}/sources/classcore/README.md

@@ -83,19 +83,20 @@ Pre-configured implementations for common use cases:
 **Base Classes:**
 - `Object`: Standard class with immutability and concealment
 - `DataclassObject`: Automatic dataclass conversion with standard behaviors
-- `ProtocolObject`: Protocol class with immutability and concealment
+- `Protocol`: Protocol base class with immutability and concealment
+- `AbstractObject`: Abstract class with ABC machinery and behaviors
 - Variants for selective mutability (`ObjectMutable`, etc.)
 
 **Metaclasses:**
 - `Class`: Metaclass for standard classes
 - `Dataclass`: Metaclass that auto-applies dataclass decorator
-- `Protocol`: Metaclass for protocol classes
+- `AbstractClass`: Metaclass combining `Class` with `abc.ABCMeta`
+- `ProtocolClass`: Metaclass for protocol classes
 - Mutable variants of each
 
 **Decorators:**
-- `class_with_standard_behaviors`: Add behaviors to existing classes
+- `with_standard_behaviors`: Add behaviors to existing classes
 - `dataclass_with_standard_behaviors`: Dataclass creation with behaviors
-- `protocol_with_standard_behaviors`: Protocol creation with behaviors
 
 **Module Utilities:**
 - `reclassify_module`: Apply immutability and concealment to module objects
@@ -381,16 +382,20 @@ sources/
 : Standard metaclasses and base classes:
 
   - `Class` / `Object`: Standard class with full behaviors
+  - `AbstractClass` / `AbstractObject`: Abstract class with ABC machinery
+    (abstract method enforcement, virtual subclass registration); mixes
+    with external `abc.ABCMeta`-based classes
   - `Dataclass` / `DataclassObject`: Auto-dataclass with behaviors
-  - `Protocol` / `ProtocolObject`: Protocol with behaviors
+  - `ProtocolClass` / `Protocol`, `ProtocolMutable`,
+    `DataclassProtocol`, `DataclassProtocolMutable`: Protocol classes
+    with behaviors
   - Mutable variants for each
 
 `decorators.py`
 : Standard class decorators:
 
-  - `class_with_standard_behaviors`: Apply behaviors to existing class
+  - `with_standard_behaviors`: Apply behaviors to existing class
   - `dataclass_with_standard_behaviors`: Create dataclass with behaviors
-  - `protocol_with_standard_behaviors`: Create protocol with behaviors
   - `class_factory`: Generic factory for creating custom metaclasses
 
 `dynadoc.py`

{classcore-1.11 → classcore-1.12}/sources/classcore/__/imports.py

@@ -23,6 +23,7 @@
 # ruff: noqa: F401
 
 
+import                      abc
 import collections.abc as   cabc
 import dataclasses as       dcls
 import functools as         funct

{classcore-1.11 → classcore-1.12}/sources/classcore/__init__.py

@@ -62,7 +62,7 @@ from .factories import *
 
 
 __version__: __.typx.Annotated[ str, __.ddoc.Visibilities.Reveal ]
-__version__ = '1.11'
+__version__ = '1.12'
 
 
 standard.finalize_module(

{classcore-1.11 → classcore-1.12}/sources/classcore/decorators.py

@@ -89,8 +89,14 @@ def produce_class_construction_decorator(
                 decorators: _nomina.Decorators[ __.T ] = ( ),
                 **arguments: __.typx.Any,
             ) -> type[ object ]:
-                superf = super( clscls, clscls_ ).__new__
-                # TODO? Short-circuit if not at start of MRO.
+                superf = __.typx.cast(
+                    _nomina.ClassConstructorLigation,
+                    super( clscls, clscls_ ).__new__ )
+                if clscls is not clscls_:
+                    # Parent metaclass within a hierarchy: delegate without
+                    # duplicating preprocessing or decoration.
+                    return superf(
+                        clscls_, name, bases, namespace, **arguments )
                 return constructor(
                     clscls_, superf,
                     name, bases, namespace, arguments, decorators )
@@ -107,7 +113,11 @@ def produce_class_construction_decorator(
                 decorators: _nomina.Decorators[ __.T ] = ( ),
                 **arguments: __.typx.Any,
             ) -> type[ object ]:
-                # TODO? Short-circuit if not at start of MRO.
+                if clscls is not clscls_:
+                    # Parent metaclass within a hierarchy: delegate without
+                    # duplicating preprocessing or decoration.
+                    return original(
+                        clscls_, name, bases, namespace, **arguments )
                 return constructor(
                     clscls_, original,
                     name, bases, namespace, arguments, decorators )
@@ -138,7 +148,11 @@ def produce_class_initialization_decorator(
                 cls: type, *posargs: __.typx.Any, **nomargs: __.typx.Any
             ) -> None:
                 ligation = super( clscls, cls ).__init__
-                # TODO? Short-circuit if not at start of MRO.
+                if clscls is not type( cls ):
+                    # Parent metaclass within a hierarchy: delegate without
+                    # duplicating completion logic.
+                    ligation( *posargs, **nomargs )
+                    return
                 initializer( cls, ligation, posargs, nomargs )
 
             clscls.__init__ = initialize_with_super
@@ -149,8 +163,12 @@ def produce_class_initialization_decorator(
             def initialize_with_original(
                 cls: type, *posargs: __.typx.Any, **nomargs: __.typx.Any
             ) -> None:
+                if clscls is not type( cls ):
+                    # Parent metaclass within a hierarchy: delegate without
+                    # duplicating completion logic.
+                    original( cls, *posargs, **nomargs )
+                    return
                 ligation = __.funct.partial( original, cls )
-                # TODO? Short-circuit if not at start of MRO.
                 initializer( cls, ligation, posargs, nomargs )
 
             clscls.__init__ = initialize_with_original

{classcore-1.11 → classcore-1.12}/sources/classcore/factories.py

@@ -34,7 +34,7 @@ def produce_class_constructor(
 ) -> _nomina.ClassConstructor[ __.T ]:
     ''' Produces constructors for classes. '''
 
-    def construct( # noqa: PLR0913
+    def construct( # noqa: PLR0913, PLR0917
         clscls: type[ __.T ],
         superf: _nomina.ClassConstructorLigation,
         name: str,

{classcore-1.11 → classcore-1.12}/sources/classcore/nomina.py

@@ -214,29 +214,52 @@ ClassInitializationCompleters: __.typx.TypeAlias = __.typx.Annotated[
 ClassConstructor: __.typx.TypeAlias = __.typx.Annotated[
     __.cabc.Callable[
         [
-            type,
-            ClassConstructorLigation,
-            str,
-            tuple[ type, ... ],
-            dict[ str, __.typx.Any ],
-            __.NominativeArguments,
-            Decorators[ __.U ],
+            type,                        # metaclass
+            ClassConstructorLigation,    # next constructor in metaclass MRO
+            str,                         # class name
+            tuple[ type, ... ],          # bases
+            dict[ str, __.typx.Any ],    # namespace
+            __.NominativeArguments,      # metaclass arguments
+            Decorators[ __.U ],          # decorators to apply after
         ],
         type
     ],
-    __.ddoc.Doc( ''' Constructor to use with metaclass. ''' ),
+    __.ddoc.Doc(
+        ''' Constructs class, then applies hooks.
+
+            Receives the metaclass ('clscls'), the next constructor in
+            the metaclass MRO ('superf'), the class name, bases,
+            namespace, metaclass arguments, and decorators to apply
+            after construction. Calls 'superf' to create the class,
+            then applies postprocessors and decorators.
+
+            Invoked only at the most-derived metaclass of a class.
+            Class factory wrappers on parent metaclasses delegate
+            directly, so construction hooks execute exactly once per
+            class.
+        ''' ),
 ]
 ClassInitializer: __.typx.TypeAlias = __.typx.Annotated[
     __.cabc.Callable[
         [
-            type,
-            InitializerLigation,
-            __.PositionalArguments,
-            __.NominativeArguments,
+            type,                        # class
+            InitializerLigation,         # next initializer in metaclass MRO
+            __.PositionalArguments,      # positional arguments
+            __.NominativeArguments,      # nominative arguments
         ],
         None
     ],
-    __.ddoc.Doc( ''' Initializer to use with metaclass. ''' ),
+    __.ddoc.Doc(
+        ''' Initializes class, then applies hooks.
+
+            Receives the class ('cls'), the next initializer in the
+            metaclass MRO ('superf'), positional arguments, and
+            nominative arguments. Calls 'superf' first, then applies
+            completers, which finalize class behaviors (e.g., enable
+            immutability once all other initialization has occurred).
+
+            Invoked only at the most-derived metaclass of a class.
+        ''' ),
 ]
 
 

{classcore-1.11 → classcore-1.12}/sources/classcore/standard/README.md

@@ -40,17 +40,27 @@ class Point2d(DataclassObject):
         self.hypotenuse = sqrt(x*x + y*y)
 ```
 
-### `ProtocolObject`
+### `Protocol`
+
+Protocol base class with immutability and concealment. Combines
+`typing.Protocol` with standard behaviors. Immutability and concealment
+are inherited by subclassed implementations. Dataclass protocol bases
+(`DataclassProtocol`, `DataclassProtocolMutable`) additionally provide
+automatic dataclass conversion.
 
-Protocol class with immutability and concealment. Combines `typing.Protocol`
-with standard behaviors. Immutability and concealment are inherited by
-subclassed implementations.
+### `AbstractObject`
+
+Abstract base class with immutability and concealment. Combines standard
+behaviors with `abc.ABCMeta` machinery: abstract method enforcement and
+virtual subclass registration. Mixes with external ABC-based classes
+without metaclass conflicts.
 
 ### Mutable Variants
 
 - `ObjectMutable`: Object with concealment only (no immutability)
 - `DataclassObjectMutable`: DataclassObject with concealment only
-- `ProtocolObjectMutable`: ProtocolObject with concealment only
+- `ProtocolMutable`: Protocol with concealment only
+- `DataclassProtocolMutable`: DataclassProtocol with concealment only
 
 ## Metaclasses
 
@@ -64,27 +74,35 @@ any class that uses this metaclass.
 Metaclass that automatically applies `dataclasses.dataclass` during class
 construction. Configurable for `frozen`, `slots`, etc.
 
-### `Protocol`
+### `AbstractClass`
+
+Metaclass combining `Class` with `abc.ABCMeta`. Supports abstract method
+enforcement and virtual subclass registration for classes that must mix
+with external ABC-based classes.
+
+### `ProtocolClass`
 
 Metaclass for protocol classes. Combines `typing.Protocol` with standard
-behaviors.
+behaviors. Descends from `AbstractClass`, unifying the standard metaclass
+taxonomy under `Class`. Dataclass protocol metaclasses
+(`ProtocolDataclass`, `ProtocolDataclassMutable`) additionally apply
+dataclass conversion.
 
 ### Mutable Variants
 
-- `ClassMutable`: Metaclass with concealment only
-- `DataclassMutable`: Dataclass metaclass with concealment only
-- `ProtocolMutable`: Protocol metaclass with concealment only
+- `DataclassMutable`: Dataclass metaclass whose instances have mutable
+  attributes (concealment only)
 
 ## Decorators
 
-### `class_with_standard_behaviors`
+### `with_standard_behaviors`
 
 Apply standard behaviors to an existing class.
 
 ```python
-from classcore.standard import class_with_standard_behaviors
+from classcore.standard import with_standard_behaviors
 
-@class_with_standard_behaviors()
+@with_standard_behaviors()
 class ExistingClass:
     x: int = 10
 ```
@@ -102,10 +120,6 @@ class Point:
     y: float
 ```
 
-### `protocol_with_standard_behaviors`
-
-Create a protocol with standard behaviors applied.
-
 ### `class_factory`
 
 Generic factory for creating custom metaclasses with standard behaviors.

{classcore-1.11 → classcore-1.12}/sources/classcore/standard/behaviors.py

@@ -224,7 +224,7 @@ def produce_class_construction_preprocessor(
 ) -> _nomina.ClassConstructionPreprocessor[ __.U ]:
     ''' Produces construction processor which handles metaclass arguments. '''
 
-    def preprocess( # noqa: PLR0913
+    def preprocess( # noqa: PLR0913, PLR0917
         clscls: type,
         name: str,
         bases: list[ type ],

{classcore-1.11 → classcore-1.12}/sources/classcore/standard/classes.py

@@ -32,7 +32,56 @@ _abc_class_mutables = (
     '_abc_negative_cache',
     '_abc_negative_cache_version',
     '_abc_registry',
+    '_is_runtime_protocol',
+    '__non_callable_proto_members__',
 )
+_protocol_cls_set = frozenset( { __.typx.Protocol } )
+# Attributes never considered declared protocol members: typing internals,
+# class-creation machinery, and framework attributes declared in classcore
+# base class bodies.
+_protocol_attr_excluded = frozenset( {
+    '_is_protocol', '_is_runtime_protocol',
+    '__protocol_attrs__', '__subclasshook__',
+    '__non_callable_proto_members__',
+    '_dynadoc_fragments_',
+    # Injected during class creation by ABC, Generic, and typing machinery.
+    # '__init__' is '_no_init' on protocol bases; as a structural member it
+    # is vacuous since every candidate object has an '__init__'.
+    '__abstractmethods__', '__parameters__', '__init__', '__orig_bases__',
+} )
+_protocol_attr_prefixes = ( '_classcore_', '_abc_' )
+# Standard Python attributes present in every pre-decoration namespace.
+_python_class_defaults = frozenset( {
+    '__module__', '__qualname__', '__doc__', '__dict__', '__weakref__',
+    '__slots__', '__annotations__',
+    '__firstlineno__', '__static_attributes__', # Python 3.13+
+} )
+
+
+def _snapshot_declared_protocol_attrs( cls: type ) -> None:
+    ''' Records protocol members declared before framework decoration.
+
+        Called in metaclass '__new__' immediately after class creation,
+        before behavior decorators and dataclass machinery inject their
+        attributes. The pre-decoration namespace contains exactly the
+        members declared by the author, so a user-declared dunder (e.g.,
+        '__repr__') is preserved while framework-generated ones are absent.
+    '''
+    # Dataclass slot machinery reproduces classes, copying '__dict__'.
+    # Retain the original snapshot; the reproduction's namespace already
+    # contains decorated attributes.
+    if '_classcore_protocol_declared_' in cls.__dict__: return
+    declared = (
+        set( cls.__dict__ )
+        | set( __.inspect.get_annotations( cls ) ) )
+    declared -= _python_class_defaults
+    declared = {
+        attr for attr in declared
+        if attr not in _protocol_attr_excluded
+        and not any( attr.startswith( p ) for p in _protocol_attr_prefixes )
+    }
+    setattr( cls, '_classcore_protocol_declared_', frozenset( declared ) )
+
 _dynadoc_configuration = (
     _dynadoc.produce_dynadoc_configuration( table = __.fragments ) )
 _class_factory = __.funct.partial(
@@ -72,9 +121,35 @@ class Class( type ):
         return super( ).__new__( clscls, name, bases, namespace )
 
 
+@_class_factory( )
+class AbstractClass( Class, __.abc.ABCMeta ):
+    ''' Metaclass for abstract classes with standard behaviors.
+
+        Combines the standard behaviors of `Class` with the machinery of
+        `abc.ABCMeta` (abstract method enforcement, virtual subclass
+        registration) via a diamond hierarchy. `Class` itself remains
+        backed by plain `type`, so ABC machinery applies only where this
+        metaclass is used.
+    '''
+
+    _dynadoc_fragments_ = (
+        'cfc class conceal', 'cfc class protect', 'cfc dynadoc',
+        'cfc instance conceal', 'cfc instance protect' )
+
+    def __new__( # Typechecker stub.
+        clscls: type[ __.T ],
+        name: str,
+        bases: tuple[ type, ... ],
+        namespace: dict[ str, __.typx.Any ], *,
+        decorators: _nomina.Decorators[ __.T ] = ( ),
+        **arguments: __.typx.Unpack[ ClassFactoryExtraArguments ],
+    ) -> __.T:
+        return super( ).__new__( clscls, name, bases, namespace )
+
+
 @_class_factory( )
 @__.typx.dataclass_transform( frozen_default = True, kw_only_default = True )
-class Dataclass( type ):
+class Dataclass( Class ):
     ''' Metaclass for standard dataclasses. '''
 
     _dynadoc_fragments_ = (
@@ -95,7 +170,7 @@ class Dataclass( type ):
 
 @_class_factory( )
 @__.typx.dataclass_transform( kw_only_default = True )
-class DataclassMutable( type ):
+class DataclassMutable( Dataclass ):
     ''' Metaclass for dataclasses with mutable instance attributes. '''
 
     _dynadoc_fragments_ = (
@@ -115,7 +190,7 @@ class DataclassMutable( type ):
 
 
 @_class_factory( )
-class ProtocolClass( type( __.typx.Protocol ) ):
+class ProtocolClass( AbstractClass, type( __.typx.Protocol ) ):
     ''' Metaclass for standard protocol classes. '''
 
     _dynadoc_fragments_ = (
@@ -131,12 +206,55 @@ class ProtocolClass( type( __.typx.Protocol ) ):
         decorators: _nomina.Decorators[ __.T ] = ( ),
         **arguments: __.typx.Unpack[ ClassFactoryExtraArguments ],
     ) -> __.T:
-        return super( ).__new__( clscls, name, bases, namespace )
+        cls = super( ).__new__( clscls, name, bases, namespace )
+        # typing_extensions.Protocol.__init_subclass__ uses identity comparison
+        # (b is Protocol) to set _is_protocol on subclasses. Classcore protocol
+        # base classes are not typing.Protocol, so subclasses incorrectly get
+        # _is_protocol = False. Detect protocol base classes structurally and
+        # fix _is_protocol before decorators are applied
+        # (e.g., runtime_checkable).
+        if not cls.__dict__.get( '_is_protocol', False ):
+            for base in cls.__bases__:
+                if ( base.__dict__.get( '_is_protocol', False )
+                    and bool( _protocol_cls_set & set( base.__bases__ ) ) ):
+                    setattr( cls, '_is_protocol', True )
+                    break
+        if cls.__dict__.get( '_is_protocol', False ):
+            _snapshot_declared_protocol_attrs( cls )
+        return cls
+
+    def __init__(
+        cls,
+        name: str,
+        bases: tuple[ type, ... ],
+        namespace: dict[ str, __.typx.Any ],
+        **kwargs: __.typx.Any,
+    ) -> None:
+        super( ).__init__( name, bases, namespace, **kwargs )
+        # Replace _ProtocolMeta's scan of the decorated namespace with the
+        # pre-decoration snapshot, so isinstance() only checks declared
+        # protocol members. Snapshot persists because metaclass __init__ can
+        # run more than once when dataclass machinery reproduces classes.
+        if getattr( cls, '_is_protocol', False ):
+            declared: frozenset[ str ] = cls.__dict__.get(
+                '_classcore_protocol_declared_', frozenset( ) )
+            inherited: set[ str ] = set( )
+            for base in cls.__mro__[ 1: ]:
+                if not isinstance( base, ProtocolClass ): continue
+                inherited.update( base.__dict__.get(
+                    '__protocol_attrs__', ( ) ) )
+            attrs = {
+                attr for attr in declared | inherited
+                if attr not in _protocol_attr_excluded
+                and not any(
+                    attr.startswith( p ) for p in _protocol_attr_prefixes )
+            }
+            setattr( cls, '__protocol_attrs__', attrs )
 
 
 @_class_factory( )
 @__.typx.dataclass_transform( frozen_default = True, kw_only_default = True )
-class ProtocolDataclass( type( __.typx.Protocol ) ):
+class ProtocolDataclass( ProtocolClass ):
     ''' Metaclass for standard protocol dataclasses. '''
 
     _dynadoc_fragments_ = (
@@ -157,7 +275,7 @@ class ProtocolDataclass( type( __.typx.Protocol ) ):
 
 @_class_factory( )
 @__.typx.dataclass_transform( kw_only_default = True )
-class ProtocolDataclassMutable( type( __.typx.Protocol ) ):
+class ProtocolDataclassMutable( ProtocolDataclass ):
     ''' Metaclass for protocol dataclasses with mutable instance attributes.
     '''
 
@@ -193,6 +311,22 @@ class ObjectMutable( metaclass = Class, instances_mutables = '*' ):
         'class instance conceal' )
 
 
+class AbstractObject(
+    metaclass = AbstractClass,
+    class_mutables = _abc_class_mutables,
+):
+    ''' Base class for abstract classes with standard behaviors.
+
+        Supports abstract method enforcement and virtual subclass
+        registration, and mixes with external classes whose metaclass is
+        `abc.ABCMeta`.
+    '''
+
+    _dynadoc_fragments_ = (
+        'class concealment', 'class protection', 'class dynadoc',
+        'class instance conceal', 'class instance protect' )
+
+
 class DataclassObject( metaclass = Dataclass ):
     ''' Standard base dataclass. '''
 
@@ -262,3 +396,41 @@ class DataclassProtocolMutable(
         'dataclass', 'protocol class',
         'class concealment', 'class protection', 'class dynadoc',
         'class instance conceal' )
+
+
+# =========================================================================== #
+# Type checker canaries. Private declarations, excluded from the public API
+# and the test suite. They exist so that Pyright (and other type checkers)
+# evaluates the structures declared above; regressions in checker support
+# surface as diagnostics on these declarations during routine linting.
+# =========================================================================== #
+
+
+class _CanaryAbstractObject( AbstractObject ):
+    ''' Canary for abstract base classes. '''
+
+    def provide( self ) -> int:
+        return 42
+
+
+class _CanaryProtocolUse( Protocol ):
+    ''' Canary for protocol definitions. '''
+
+    value: int
+
+    def greet( self ) -> str: ...
+
+
+class _CanaryProtocolImpl( _CanaryProtocolUse ):
+    ''' Canary for concrete protocol implementations. '''
+
+    def __init__( self ) -> None:
+        self.value = 7
+
+    def greet( self ) -> str:
+        return 'canary'
+
+
+_canary_abstract: int = _CanaryAbstractObject( ).provide( )
+_canary_protocol_iface: _CanaryProtocolUse = _CanaryProtocolImpl( )
+_canary_greeting: str = _canary_protocol_iface.greet( )

{classcore-1.11 → classcore-1.12}/sources/classcore/standard/decorators.py

@@ -175,7 +175,7 @@ def apply_cfc_attributes_surveyor(
     decorator( clscls )
 
 
-def class_factory( # noqa: PLR0913
+def class_factory( # noqa: PLR0913, PLR0917
     attributes_namer: _nomina.AttributesNamer = __.calculate_attrname,
     error_class_provider: _nomina.ErrorClassProvider = __.provide_error_class,
     assigner_core: __.typx.Optional[ _nomina.AssignerCore ] = None,
@@ -220,7 +220,7 @@ def class_factory( # noqa: PLR0913
     return decorate
 
 
-def produce_instances_inception_decorator( # noqa: PLR0913
+def produce_instances_inception_decorator( # noqa: PLR0913, PLR0917
     attributes_namer: _nomina.AttributesNamer,
     assigner_core: __.typx.Optional[ _nomina.AssignerCore ],
     deleter_core: __.typx.Optional[ _nomina.DeleterCore ],
@@ -532,7 +532,7 @@ def produce_attributes_surveillance_decorator(
 
 
 @__.typx.dataclass_transform( frozen_default = True, kw_only_default = True )
-def dataclass_with_standard_behaviors( # noqa: PLR0913
+def dataclass_with_standard_behaviors( # noqa: PLR0913, PLR0917
     attributes_namer: _nomina.AttributesNamer = __.calculate_attrname,
     error_class_provider: _nomina.ErrorClassProvider = __.provide_error_class,
     decorators: _nomina.Decorators[ __.U ] = ( ),
@@ -564,7 +564,7 @@ def dataclass_with_standard_behaviors( # noqa: PLR0913
         *decorators, _dataclass_core, *decorators_, preparers = preparers )
 
 
-def with_standard_behaviors( # noqa: PLR0913
+def with_standard_behaviors( # noqa: PLR0913, PLR0917
     attributes_namer: _nomina.AttributesNamer = __.calculate_attrname,
     error_class_provider: _nomina.ErrorClassProvider = __.provide_error_class,
     decorators: _nomina.Decorators[ __.U ] = ( ),
@@ -621,7 +621,7 @@ def _produce_instances_decoration_preparers(
     return tuple( preprocessors )
 
 
-def _produce_instances_decorators( # noqa: PLR0913
+def _produce_instances_decorators( # noqa: PLR0913, PLR0917
     attributes_namer: _nomina.AttributesNamer,
     error_class_provider: _nomina.ErrorClassProvider,
     assigner_core: __.typx.Optional[ _nomina.AssignerCore ],