classcore 1.3.1__tar.gz → 1.4__tar.gz

{classcore-1.3.1 → classcore-1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: classcore
-Version: 1.3.1
+Version: 1.4
 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.3.1 → classcore-1.4}/sources/classcore/__init__.py

@@ -62,7 +62,7 @@ from .factories import *
 
 
 __version__: __.typx.Annotated[ str, __.dynadoc.Visibilities.Reveal ]
-__version__ = '1.3.1'
+__version__ = '1.4'
 
 
 standard.dynadoc.assign_module_docstring( __name__, table = __.fragments )

{classcore-1.3.1 → classcore-1.4}/sources/classcore/decorators.py

@@ -75,25 +75,45 @@ def produce_class_construction_decorator(
         Decorator overrides ``__new__`` on metaclass.
     '''
     def decorate( clscls: type[ __.T ] ) -> type[ __.T ]:
-        constructor_name = attributes_namer( 'classes', 'constructor' )
-        extant = getattr( clscls, constructor_name, None )
-        original = getattr( clscls, '__new__' )
-        if extant is original: return clscls
-
-        def construct(
-            clscls_: type[ __.T ],
-            name: str,
-            bases: tuple[ type, ... ],
-            namespace: dict[ str, __.typx.Any ], *,
-            decorators: _nomina.Decorators[ __.T ] = ( ),
-            **arguments: __.typx.Any,
-        ) -> type[ object ]:
-            return constructor(
-                clscls_, original,
-                name, bases, namespace, arguments, decorators )
-
-        setattr( clscls, constructor_name, construct )
-        setattr( clscls, '__new__', construct )
+        original = __.typx.cast(
+            _nomina.ClassConstructorLigation | None,
+            clscls.__dict__.get( '__new__' ) ) # pyright: ignore
+
+        if original is None:
+
+            def construct_with_super(
+                clscls_: type[ __.T ],
+                name: str,
+                bases: tuple[ type, ... ],
+                namespace: dict[ str, __.typx.Any ], *,
+                decorators: _nomina.Decorators[ __.T ] = ( ),
+                **arguments: __.typx.Any,
+            ) -> type[ object ]:
+                superf = super( clscls, clscls_ ).__new__
+                # TODO? Short-circuit if not at start of MRO.
+                return constructor(
+                    clscls_, superf,
+                    name, bases, namespace, arguments, decorators )
+
+            setattr( clscls, '__new__', construct_with_super )
+
+        else:
+
+            def construct_with_original(
+                clscls_: type[ __.T ],
+                name: str,
+                bases: tuple[ type, ... ],
+                namespace: dict[ str, __.typx.Any ], *,
+                decorators: _nomina.Decorators[ __.T ] = ( ),
+                **arguments: __.typx.Any,
+            ) -> type[ object ]:
+                # TODO? Short-circuit if not at start of MRO.
+                return constructor(
+                    clscls_, original,
+                    name, bases, namespace, arguments, decorators )
+
+            setattr( clscls, '__new__', construct_with_original )
+
         return clscls
 
     return decorate
@@ -108,20 +128,33 @@ def produce_class_initialization_decorator(
         Decorator overrides ``__init__`` on metaclass.
     '''
     def decorate( clscls: type[ __.T ] ) -> type[ __.T ]:
-        initializer_name = attributes_namer( 'classes', 'initializer' )
-        extant = getattr( clscls, initializer_name, None )
-        original = getattr( clscls, '__init__' )
-        if extant is original: return clscls
-
-        @__.funct.wraps( original )
-        def initialize(
-            cls: type, *posargs: __.typx.Any, **nomargs: __.typx.Any
-        ) -> None:
-            ligation = __.funct.partial( original, cls )
-            initializer( cls, ligation, posargs, nomargs )
-
-        setattr( clscls, initializer_name, initialize )
-        clscls.__init__ = initialize
+        original = __.typx.cast(
+            _nomina.InitializerLigation | None,
+            clscls.__dict__.get( '__init__' ) ) # pyright: ignore
+
+        if original is None:
+
+            def initialize_with_super(
+                cls: type, *posargs: __.typx.Any, **nomargs: __.typx.Any
+            ) -> None:
+                ligation = super( clscls, cls ).__init__
+                # TODO? Short-circuit if not at start of MRO.
+                initializer( cls, ligation, posargs, nomargs )
+
+            clscls.__init__ = initialize_with_super
+
+        else:
+
+            @__.funct.wraps( original )
+            def initialize_with_original(
+                cls: type, *posargs: __.typx.Any, **nomargs: __.typx.Any
+            ) -> None:
+                ligation = __.funct.partial( original, cls )
+                # TODO? Short-circuit if not at start of MRO.
+                initializer( cls, ligation, posargs, nomargs )
+
+            clscls.__init__ = initialize_with_original
+
         return clscls
 
     return decorate

{classcore-1.3.1 → classcore-1.4}/sources/classcore/exceptions.py

@@ -26,31 +26,31 @@ from . import standard as _standard
 
 
 class Omniexception(
-    BaseException, _standard.Object,
+    _standard.Object, BaseException,
     instances_visibles = ( '__cause__', '__context__' ),
 ):
     ''' Base exception for package. '''
 
 
-class Omnierror( Exception, Omniexception ):
+class Omnierror( Omniexception, Exception ):
     ''' Base error for package. '''
 
 
-class AttributeImmutability( AttributeError, Omnierror ):
+class AttributeImmutability( Omnierror, AttributeError ):
 
     def __init__( self, name: str, target: str ):
         super( ).__init__(
             f"Could not assign or delete attribute {name!r} on {target}." )
 
 
-class BehaviorExclusionInvalidity( TypeError, ValueError, Omnierror ):
+class BehaviorExclusionInvalidity( Omnierror, TypeError, ValueError ):
 
     def __init__( self, verifier: __.typx.Any ):
         super( ).__init__(
             f"Invalid behavior exclusion verifier: {verifier!r}" )
 
 
-class ErrorProvideFailure( RuntimeError, Omnierror ):
+class ErrorProvideFailure( Omnierror, RuntimeError ):
 
     def __init__( self, name: str, reason: str ):
         super( ).__init__(

{classcore-1.3.1 → classcore-1.4}/sources/classcore/standard/behaviors.py

@@ -151,6 +151,29 @@ def survey_visible_attributes(
     return names_
 
 
+def augment_class_attributes_allocations(
+    attributes_namer: _nomina.AttributesNamer,
+    namespace: dict[ str, __.typx.Any ],
+) -> None:
+    ''' Adds necessary slots for record-keeping attributes. '''
+    behaviors_name = attributes_namer( 'instance', 'behaviors' )
+    slots: __.typx.Union[
+        __.cabc.Mapping[ str, __.typx.Any ],
+        __.cabc.Sequence[ str ],
+        None
+    ] = namespace.get( '__slots__' )
+    if isinstance( slots, __.cabc.Mapping ):
+        slots_ = dict( slots )
+        slots_[ behaviors_name ] = 'Active behaviors.'
+        slots_ = __.types.MappingProxyType( slots_ )
+    elif isinstance( slots, __.cabc.Sequence ):
+        slots_ = list( slots )
+        slots_.append( behaviors_name )
+        slots_ = tuple( slots_ )
+    else: return # pragma: no cover
+    namespace[ '__slots__' ] = slots_
+
+
 def classify_behavior_exclusion_verifiers(
     verifiers: _nomina.BehaviorExclusionVerifiers
 ) -> tuple[
@@ -190,6 +213,8 @@ def produce_class_construction_preprocessor(
     ) -> None:
         record_class_construction_arguments(
             attributes_namer, namespace, arguments )
+        if '__slots__' in namespace:
+            augment_class_attributes_allocations( attributes_namer, namespace )
 
     return preprocess
 
@@ -329,11 +354,11 @@ def record_class_construction_arguments(
     arguments_ = { }
     for name in (
         'class_mutables', 'class_visibles',
+        'dynadoc_configuration',
         'instances_assigner_core',
         'instances_deleter_core',
         'instances_surveyor_core',
         'instances_mutables', 'instances_visibles',
-        'dynadoc_configuration',
     ):
         if name not in arguments: continue
         arguments_[ name ] = arguments.pop( name )

{classcore-1.3.1 → classcore-1.4}/sources/classcore/standard/classes.py

@@ -33,11 +33,15 @@ _class_factory = __.funct.partial(
     _decorators.class_factory, dynadoc_configuration = _dynadoc_configuration )
 
 
-class _CfcExtraArguments( __.typx.TypedDict, total = False ):
+class ClassFactoryExtraArguments( __.typx.TypedDict, total = False ):
+    ''' Extra arguments accepted by standard metaclasses. '''
 
     class_mutables: _nomina.BehaviorExclusionVerifiersOmni
     class_visibles: _nomina.BehaviorExclusionVerifiersOmni
     dynadoc_configuration: _nomina.DynadocConfiguration
+    instances_assigner_core: _nomina.AssignerCore
+    instances_deleter_core: _nomina.DeleterCore
+    instances_surveyor_core: _nomina.SurveyorCore
     instances_mutables: _nomina.BehaviorExclusionVerifiersOmni
     instances_visibles: _nomina.BehaviorExclusionVerifiersOmni
 
@@ -56,7 +60,7 @@ class Class( type ):
         bases: tuple[ type, ... ],
         namespace: dict[ str, __.typx.Any ], *,
         decorators: _nomina.Decorators[ __.T ] = ( ),
-        **arguments: __.typx.Unpack[ _CfcExtraArguments ],
+        **arguments: __.typx.Unpack[ ClassFactoryExtraArguments ],
     ) -> __.T:
         return super( ).__new__( clscls, name, bases, namespace )
 
@@ -77,7 +81,7 @@ class Dataclass( type ):
         bases: tuple[ type, ... ],
         namespace: dict[ str, __.typx.Any ], *,
         decorators: _nomina.Decorators[ __.T ] = ( ),
-        **arguments: __.typx.Unpack[ _CfcExtraArguments ],
+        **arguments: __.typx.Unpack[ ClassFactoryExtraArguments ],
     ) -> __.T:
         return super( ).__new__( clscls, name, bases, namespace )
 
@@ -98,7 +102,7 @@ class DataclassMutable( type ):
         bases: tuple[ type, ... ],
         namespace: dict[ str, __.typx.Any ], *,
         decorators: _nomina.Decorators[ __.T ] = ( ),
-        **arguments: __.typx.Unpack[ _CfcExtraArguments ],
+        **arguments: __.typx.Unpack[ ClassFactoryExtraArguments ],
     ) -> __.T:
         return super( ).__new__( clscls, name, bases, namespace )
 
@@ -118,7 +122,7 @@ class ProtocolClass( type( __.typx.Protocol ) ):
         bases: tuple[ type, ... ],
         namespace: dict[ str, __.typx.Any ], *,
         decorators: _nomina.Decorators[ __.T ] = ( ),
-        **arguments: __.typx.Unpack[ _CfcExtraArguments ],
+        **arguments: __.typx.Unpack[ ClassFactoryExtraArguments ],
     ) -> __.T:
         return super( ).__new__( clscls, name, bases, namespace )
 
@@ -139,7 +143,7 @@ class ProtocolDataclass( type( __.typx.Protocol ) ):
         bases: tuple[ type, ... ],
         namespace: dict[ str, __.typx.Any ], *,
         decorators: _nomina.Decorators[ __.T ] = ( ),
-        **arguments: __.typx.Unpack[ _CfcExtraArguments ],
+        **arguments: __.typx.Unpack[ ClassFactoryExtraArguments ],
     ) -> __.T:
         return super( ).__new__( clscls, name, bases, namespace )
 
@@ -161,7 +165,7 @@ class ProtocolDataclassMutable( type( __.typx.Protocol ) ):
         bases: tuple[ type, ... ],
         namespace: dict[ str, __.typx.Any ], *,
         decorators: _nomina.Decorators[ __.T ] = ( ),
-        **arguments: __.typx.Unpack[ _CfcExtraArguments ],
+        **arguments: __.typx.Unpack[ ClassFactoryExtraArguments ],
     ) -> __.T:
         return super( ).__new__( clscls, name, bases, namespace )
 

{classcore-1.3.1 → classcore-1.4}/sources/classcore/standard/decorators.py

@@ -49,6 +49,7 @@ def prepare_dataclass_for_instances(
     ''' Annotates dataclass in support of instantiation machinery. '''
     annotations = __.inspect.get_annotations( cls )
     behaviors_name = attributes_namer( 'instance', 'behaviors' )
+    # TODO? Only use mangling if not slotted.
     behaviors_name_m = _utilities.mangle_name( cls, behaviors_name )
     annotations[ behaviors_name_m ] = set[ str ]
     setattr( cls, '__annotations__', annotations ) # in case of absence
@@ -89,7 +90,7 @@ def apply_cfc_constructor(
 
 
 def apply_cfc_initializer(
-    clscls: type[ __.T ], attributes_namer: _nomina.AttributesNamer
+    clscls: type[ __.T ], /, attributes_namer: _nomina.AttributesNamer
 ) -> None:
     ''' Injects '__init__' method into metaclass. '''
     completers = (
@@ -112,7 +113,7 @@ def apply_cfc_attributes_assigner(
 ) -> None:
     ''' Injects '__setattr__' method into metaclass. '''
     decorator = produce_attributes_assignment_decorator(
-        level = 'class',
+        level = 'classes',
         attributes_namer = attributes_namer,
         error_class_provider = error_class_provider,
         implementation_core = implementation_core )
@@ -127,7 +128,7 @@ def apply_cfc_attributes_deleter(
 ) -> None:
     ''' Injects '__delattr__' method into metaclass. '''
     decorator = produce_attributes_deletion_decorator(
-        level = 'class',
+        level = 'classes',
         attributes_namer = attributes_namer,
         error_class_provider = error_class_provider,
         implementation_core = implementation_core )
@@ -141,7 +142,7 @@ def apply_cfc_attributes_surveyor(
 ) -> None:
     ''' Injects '__dir__' method into metaclass. '''
     decorator = produce_attributes_surveillance_decorator(
-        level = 'class',
+        level = 'classes',
         attributes_namer = attributes_namer,
         implementation_core = implementation_core )
     decorator( clscls )
@@ -196,13 +197,8 @@ def produce_instances_initialization_decorator(
 ) -> _nomina.Decorator[ __.U ]:
     ''' Produces decorator to inject '__init__' method into class. '''
     def decorate( cls: type[ __.U ] ) -> type[ __.U ]:
-        initializer_name = attributes_namer( 'instances', 'initializer' )
-        extant = getattr( cls, initializer_name, None )
-        original = getattr( cls, '__init__' )
-        if extant is original: return cls
         behaviors: set[ str ] = set( )
         behaviors_name = attributes_namer( 'instance', 'behaviors' )
-        behaviors_name_m = _utilities.mangle_name( cls, behaviors_name )
         _behaviors.record_behavior(
             cls, attributes_namer = attributes_namer,
             level = 'instances', basename = 'mutables',
@@ -213,18 +209,41 @@ def produce_instances_initialization_decorator(
             level = 'instances', basename = 'visibles',
             label = _nomina.concealment_label, behaviors = behaviors,
             verifiers = visibles )
+        original = cls.__dict__.get( '__init__' )
+
+        if original is None:
+
+            def initialize_with_super(
+                self: object, *posargs: __.typx.Any, **nomargs: __.typx.Any
+            ) -> None:
+                super( cls, self ).__init__( *posargs, **nomargs )
+                # Only record behaviors at start of MRO.
+                if cls is not type( self ): return
+                behaviors_: set[ str ] = (
+                    _utilities.getattr0( self, behaviors_name, set( ) ) )
+                behaviors_.update( behaviors )
+                _utilities.setattr0(
+                    self, behaviors_name, frozenset( behaviors_ ) )
+
+            cls.__init__ = initialize_with_super
+
+        else:
+
+            @__.funct.wraps( original )
+            def initialize_with_original(
+                self: object, *posargs: __.typx.Any, **nomargs: __.typx.Any
+            ) -> None:
+                original( self, *posargs, **nomargs )
+                # Only record behaviors at start of MRO.
+                if cls is not type( self ): return
+                behaviors_: set[ str ] = (
+                    _utilities.getattr0( self, behaviors_name, set( ) ) )
+                behaviors_.update( behaviors )
+                _utilities.setattr0(
+                    self, behaviors_name, frozenset( behaviors_ ) )
+
+            cls.__init__ = initialize_with_original
 
-        @__.funct.wraps( original )
-        def initialize(
-            self: object, *posargs: __.typx.Any, **nomargs: __.typx.Any
-        ) -> None:
-            original( self, *posargs, **nomargs )
-            behaviors_: set[ str ] = getattr( self, behaviors_name_m, set( ) )
-            behaviors_.update( behaviors )
-            setattr( self, behaviors_name_m, frozenset( behaviors_ ) )
-
-        setattr( cls, initializer_name, initialize )
-        cls.__init__ = initialize
         return cls
 
     return decorate
@@ -238,23 +257,50 @@ def produce_attributes_assignment_decorator(
 ) -> _nomina.Decorator[ __.U ]:
     ''' Produces decorator to inject '__setattr__' method into class. '''
     def decorate( cls: type[ __.U ] ) -> type[ __.U ]:
-        assigner_name = attributes_namer( level, 'assigner' )
-        extant = getattr( cls, assigner_name, None )
-        original = getattr( cls, '__setattr__' )
-        if extant is original: return cls
-
-        @__.funct.wraps( original )
-        def assign( self: object, name: str, value: __.typx.Any ) -> None:
-            implementation_core(
-                self,
-                ligation = __.funct.partial( original, self ),
-                attributes_namer = attributes_namer,
-                error_class_provider = error_class_provider,
-                level = level,
-                name = name, value = value )
+        leveli = 'class' if level == 'classes' else level
+        original = cls.__dict__.get( '__setattr__' )
+
+        if original is None:
+
+            def assign_with_super(
+                self: object, name: str, value: __.typx.Any
+            ) -> None:
+                ligation = super( cls, self ).__setattr__
+                # Only enforce behaviors at start of MRO.
+                if cls is not type( self ):
+                    ligation( name, value )
+                    return
+                implementation_core(
+                    self,
+                    ligation = ligation,
+                    attributes_namer = attributes_namer,
+                    error_class_provider = error_class_provider,
+                    level = leveli,
+                    name = name, value = value )
+
+            cls.__setattr__ = assign_with_super
+
+        else:
+
+            @__.funct.wraps( original )
+            def assign_with_original(
+                self: object, name: str, value: __.typx.Any
+            ) -> None:
+                ligation = __.funct.partial( original, self )
+                # Only enforce behaviors at start of MRO.
+                if cls is not type( self ):
+                    ligation( name, value )
+                    return
+                implementation_core(
+                    self,
+                    ligation = ligation,
+                    attributes_namer = attributes_namer,
+                    error_class_provider = error_class_provider,
+                    level = leveli,
+                    name = name, value = value )
+
+            cls.__setattr__ = assign_with_original
 
-        setattr( cls, assigner_name, assign )
-        cls.__setattr__ = assign
         return cls
 
     return decorate
@@ -268,23 +314,46 @@ def produce_attributes_deletion_decorator(
 ) -> _nomina.Decorator[ __.U ]:
     ''' Produces decorator to inject '__delattr__' method into class. '''
     def decorate( cls: type[ __.U ] ) -> type[ __.U ]:
-        deleter_name = attributes_namer( level, 'deleter' )
-        extant = getattr( cls, deleter_name, None )
-        original = getattr( cls, '__delattr__' )
-        if extant is original: return cls
-
-        @__.funct.wraps( original )
-        def delete( self: object, name: str ) -> None:
-            implementation_core(
-                self,
-                ligation = __.funct.partial( original, self ),
-                attributes_namer = attributes_namer,
-                error_class_provider = error_class_provider,
-                level = level,
-                name = name )
+        leveli = 'class' if level == 'classes' else level
+        original = cls.__dict__.get( '__delattr__' )
+
+        if original is None:
+
+            def delete_with_super( self: object, name: str ) -> None:
+                ligation = super( cls, self ).__delattr__
+                # Only enforce behaviors at start of MRO.
+                if cls is not type( self ):
+                    ligation( name )
+                    return
+                implementation_core(
+                    self,
+                    ligation = ligation,
+                    attributes_namer = attributes_namer,
+                    error_class_provider = error_class_provider,
+                    level = leveli,
+                    name = name )
+
+            cls.__delattr__ = delete_with_super
+
+        else:
+
+            @__.funct.wraps( original )
+            def delete_with_original( self: object, name: str ) -> None:
+                ligation = __.funct.partial( original, self )
+                # Only enforce behaviors at start of MRO.
+                if cls is not type( self ):
+                    ligation( name )
+                    return
+                implementation_core(
+                    self,
+                    ligation = ligation,
+                    attributes_namer = attributes_namer,
+                    error_class_provider = error_class_provider,
+                    level = leveli,
+                    name = name )
+
+            cls.__delattr__ = delete_with_original
 
-        setattr( cls, deleter_name, delete )
-        cls.__delattr__ = delete
         return cls
 
     return decorate
@@ -297,21 +366,42 @@ def produce_attributes_surveillance_decorator(
 ) -> _nomina.Decorator[ __.U ]:
     ''' Produces decorator to inject '__dir__' method into class. '''
     def decorate( cls: type[ __.U ] ) -> type[ __.U ]:
-        surveyor_name = attributes_namer( level, 'surveyor' )
-        extant = getattr( cls, surveyor_name, None )
-        original = getattr( cls, '__dir__' )
-        if extant is original: return cls
-
-        @__.funct.wraps( original )
-        def survey( self: object ) -> __.cabc.Iterable[ str ]:
-            return implementation_core(
-                self,
-                ligation = __.funct.partial( original, self ),
-                attributes_namer = attributes_namer,
-                level = level )
+        leveli = 'class' if level == 'classes' else level
+        original = cls.__dict__.get( '__dir__' )
+
+        if original is None:
+
+            def survey_with_super(
+                self: object
+            ) -> __.cabc.Iterable[ str ]:
+                ligation = super( cls, self ).__dir__
+                # Only enforce behaviors at start of MRO.
+                if cls is not type( self ): return ligation( )
+                return implementation_core(
+                    self,
+                    ligation = ligation,
+                    attributes_namer = attributes_namer,
+                    level = leveli )
+
+            cls.__dir__ = survey_with_super
+
+        else:
+
+            @__.funct.wraps( original )
+            def survey_with_original(
+                self: object
+            ) -> __.cabc.Iterable[ str ]:
+                ligation = __.funct.partial( original, self )
+                # Only enforce behaviors at start of MRO.
+                if cls is not type( self ): return ligation( )
+                return implementation_core(
+                    self,
+                    ligation = ligation,
+                    attributes_namer = attributes_namer,
+                    level = leveli )
+
+            cls.__dir__ = survey_with_original
 
-        setattr( cls, surveyor_name, survey )
-        cls.__dir__ = survey
         return cls
 
     return decorate

{classcore-1.3.1 → classcore-1.4}/sources/classcore/utilities.py

@@ -24,51 +24,81 @@
 from . import __
 
 
-def describe_object( obj: object ) -> str:
+def describe_object( objct: object, / ) -> str:
     ''' Returns object type with fully-qualified name. '''
-    if __.inspect.isclass( obj ):
-        return "class '{}'".format( qualify_class_name( obj ) )
+    if __.inspect.isclass( objct ):
+        return "class '{}'".format( qualify_class_name( objct ) )
     # TODO? functions, methods, etc...
-    return "instance of {}".format( describe_object( type( obj ) ) )
+    return "instance of {}".format( describe_object( type( objct ) ) )
 
 
-def getattr0( obj: object, name: str, default: __.typx.Any ) -> __.typx.Any:
-    ''' Returns private attribute from object.
+def getattr0(
+    objct: object, /, name: str, default: __.typx.Any
+) -> __.typx.Any:
+    ''' Returns special private attribute from object.
 
-        Uses mangled attribute name which is unique to the class.
+        This avoids inheritance-related collisions.
+
+        Uses mangled attribute name which is unique to the class,
+        except when attribute is slotted. Slotted attributes are effectively
+        isolated from inheritance.
     '''
-    name_m = mangle_name( obj, name )
-    return getattr( obj, name_m, default )
+    if not __.inspect.isclass( objct ):
+        for base in type( objct ).mro( ):
+            slots = getattr( base, '__slots__', ( ) )
+            if name in slots: return getattr( objct, name, default )
+    name_m = mangle_name( objct, name )
+    return getattr( objct, name_m, default )
+
 
+def delattr0( objct: object, /, name: str ) -> None:
+    ''' Deletes special private attribute on object.
 
-def delattr0( obj: object, name: str ) -> None:
-    ''' Deletes private attribute on object.
+        This avoids inheritance-related collisions.
 
-        Uses mangled attribute name which is unique to the class.
+        Uses mangled attribute name which is unique to the class,
+        except when attribute is slotted. Slotted attributes are effectively
+        isolated from inheritance.
     '''
-    name_m = mangle_name( obj, name )
-    delattr( obj, name_m )
+    if not __.inspect.isclass( objct ):
+        for base in type( objct ).mro( ):
+            slots = getattr( base, '__slots__', ( ) )
+            if name in slots:
+                delattr( objct, name )
+                return
+    name_m = mangle_name( objct, name )
+    delattr( objct, name_m )
+
 
+def setattr0( objct: object, /, name: str, value: __.typx.Any ) -> None:
+    ''' Assigns special private attribute to object.
 
-def setattr0( obj: object, name: str, value: __.typx.Any ) -> None:
-    ''' Assigns private attribute to object.
+        This avoids inheritance-related collisions.
 
-        Uses mangled attribute name which is unique to the class.
+        Uses mangled attribute name which is unique to the class,
+        except when attribute is slotted. Slotted attributes are effectively
+        isolated from inheritance.
     '''
-    name_m = mangle_name( obj, name )
-    setattr( obj, name_m, value )
+    if not __.inspect.isclass( objct ):
+        for base in type( objct ).mro( ):
+            slots = getattr( base, '__slots__', ( ) )
+            if name in slots:
+                setattr( objct, name, value )
+                return
+    name_m = mangle_name( objct, name )
+    setattr( objct, name_m, value )
 
 
-def mangle_name( obj: object, name: str ) -> str:
+def mangle_name( objct: object, /, name: str ) -> str:
     ''' Mangles attribute name so that it is unique.
 
         Effectively provides name of private member attribute,
         which is unique across class inheritance.
     '''
-    if not __.inspect.isclass( obj ):
-        return mangle_name( type( obj ), name )
+    if not __.inspect.isclass( objct ):
+        return mangle_name( type( objct ), name )
     namehash = __.hashlib.sha256( )
-    namehash.update( qualify_class_name( obj ).encode( ) )
+    namehash.update( qualify_class_name( objct ).encode( ) )
     namehash_hex = namehash.hexdigest( )
     return f"{name}_{namehash_hex}"