classcore 1.4.2__tar.gz → 1.5.1__tar.gz

{classcore-1.4.2 → classcore-1.5.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: classcore
-Version: 1.4.2
+Version: 1.5.1
 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.4.2 → classcore-1.5.1}/sources/classcore/__/doctab.py

@@ -67,10 +67,4 @@ fragments: _FragmentsTable = __.types.MappingProxyType( {
 
     'class dynadoc': ''' Is decorated by Dynadoc. ''',
 
-    'decorators':
-    ''' Sequence of class decorators.
-
-        Each element takes a class argument and returns a class.
-    ''',
-
 } )

{classcore-1.4.2 → classcore-1.5.1}/sources/classcore/__/imports.py

@@ -33,7 +33,7 @@ import                      re
 import                      sys
 import                      types
 
-import                      dynadoc
+import dynadoc as           ddoc
 import typing_extensions as typx
 # --- BEGIN: Injected by Copier ---
 # --- END: Injected by Copier ---

{classcore-1.4.2 → classcore-1.5.1}/sources/classcore/__init__.py

@@ -61,8 +61,8 @@ from .decorators import *
 from .factories import *
 
 
-__version__: __.typx.Annotated[ str, __.dynadoc.Visibilities.Reveal ]
-__version__ = '1.4.2'
+__version__: __.typx.Annotated[ str, __.ddoc.Visibilities.Reveal ]
+__version__ = '1.5.1'
 
 
 standard.dynadoc.assign_module_docstring( __name__, table = __.fragments )

{classcore-1.4.2 → classcore-1.5.1}/sources/classcore/factories.py

@@ -29,8 +29,8 @@ from . import utilities as _utilities
 
 def produce_class_constructor(
     attributes_namer: _nomina.AttributesNamer,
-    preprocessors: _nomina.ProduceConstructorPreprocsArgument[ __.T ] = ( ),
-    postprocessors: _nomina.ProduceConstructorPostprocsArgument[ __.T ] = ( ),
+    preprocessors: _nomina.ClassConstructionPreprocessors[ __.T ] = ( ),
+    postprocessors: _nomina.ClassConstructionPostprocessors[ __.T ] = ( ),
 ) -> _nomina.ClassConstructor[ __.T ]:
     ''' Produces constructors for classes. '''
 
@@ -68,7 +68,7 @@ def produce_class_constructor(
 
 def produce_class_initializer(
     attributes_namer: _nomina.AttributesNamer,
-    completers: _nomina.ProduceInitializerCompletersArgument = ( ),
+    completers: _nomina.ClassInitializationCompleters = ( ),
 ) -> _nomina.ClassInitializer:
     ''' Produces initializers for classes. '''
 

{classcore-1.4.2 → classcore-1.5.1}/sources/classcore/nomina.py

@@ -24,36 +24,68 @@
 from . import __
 
 
-AttributesNamer: __.typx.TypeAlias = __.cabc.Callable[ [ str, str ], str ]
+AttributesNamer: __.typx.TypeAlias = __.typx.Annotated[
+    __.cabc.Callable[ [ str, str ], str ],
+    __.ddoc.Doc(
+        ''' Names attribute from level and core arguments.
+
+            Level will be one of 'class', 'instances', or 'instance'.
+            Core will be the core of the name as supplied this package.
+
+            Can be used by downstream packages to determine names of
+            bookkeeping attributes assigned by this package.
+        ''' ),
+]
 
 Decorator: __.typx.TypeAlias = __.typx.Annotated[
     __.cabc.Callable[ [ type[ __.U ] ], type[ __.U ] ],
-    __.dynadoc.Doc(
+    __.ddoc.Doc(
         ''' Class decorator.
 
             Takes class argument and returns class.
         ''' ),
 ]
 Decorators: __.typx.TypeAlias = __.typx.Annotated[
-    __.cabc.Sequence[ Decorator[ __.U ] ], __.dynadoc.Fname( 'decorators' )
+    __.cabc.Sequence[ Decorator[ __.U ] ],
+    __.ddoc.Doc(
+        ''' Sequence of class decorators.
+
+            Each element takes a class argument and returns a class.
+        ''' ),
 ]
 DecoratorsMutable: __.typx.TypeAlias = __.typx.Annotated[
    __.cabc.MutableSequence[ Decorator[ __.U ] ],
-   __.dynadoc.Fname( 'decorators' ),
-   __.dynadoc.Doc(
-       ''' Decorators may be inserted or removed from sequence. ''' ),
+    __.ddoc.Doc(
+        ''' Sequence of class decorators.
+
+            Each element takes a class argument and returns a class.
+
+            Decorators may be inserted or removed from sequence.
+        ''' ),
 ]
 
-DecorationPreparer: __.typx.TypeAlias = (
-    __.cabc.Callable[ [ type[ __.U ], DecoratorsMutable[ __.U ] ], None ] )
-DecorationPreparers: __.typx.TypeAlias = (
-    __.cabc.Sequence[ DecorationPreparer[ __.U ] ] )
-DecorationPreparersFactory: __.typx.TypeAlias = (
-    __.cabc.Callable[ [ ], DecorationPreparers[ __.U ] ] )
+DecorationPreparer: __.typx.TypeAlias = __.typx.Annotated[
+    __.cabc.Callable[ [ type[ __.U ], DecoratorsMutable[ __.U ] ], None ],
+    __.ddoc.Doc(
+        ''' Class decoration preparer.
+
+            Takes class and mutable sequence of decorators as arguments.
+            Can alter the sequence.
+        ''' ),
+]
+DecorationPreparers: __.typx.TypeAlias = __.typx.Annotated[
+    __.cabc.Sequence[ DecorationPreparer[ __.U ] ],
+    __.ddoc.Doc(
+        ''' Sequence of class decoration preparers.
+
+            Each element takes class and mutable sequence of decorators as
+            arguments. And, each element can alter the sequence.
+        ''' ),
+]
 
 ClassConstructorLigation: __.typx.TypeAlias = __.typx.Annotated[
     __.cabc.Callable[ ..., type ],
-    __.dynadoc.Doc(
+    __.ddoc.Doc(
         ''' Bound class constructor function.
 
             Usually from ``super( ).__new__`` or a partial function.
@@ -61,7 +93,7 @@ ClassConstructorLigation: __.typx.TypeAlias = __.typx.Annotated[
 ]
 InitializerLigation: __.typx.TypeAlias = __.typx.Annotated[
     __.cabc.Callable[ ..., None ],
-    __.dynadoc.Doc(
+    __.ddoc.Doc(
         ''' Bound initializer function.
 
             Usually from ``super( ).__init__`` or a partial function.
@@ -69,7 +101,7 @@ InitializerLigation: __.typx.TypeAlias = __.typx.Annotated[
 ]
 AssignerLigation: __.typx.TypeAlias = __.typx.Annotated[
     __.cabc.Callable[ [ str, __.typx.Any ], None ],
-    __.dynadoc.Doc(
+    __.ddoc.Doc(
         ''' Bound attributes assigner function.
 
             Usually from ``super( ).__setattr__`` or a partial function.
@@ -77,7 +109,7 @@ AssignerLigation: __.typx.TypeAlias = __.typx.Annotated[
 ]
 DeleterLigation: __.typx.TypeAlias = __.typx.Annotated[
     __.cabc.Callable[ [ str ], None ],
-    __.dynadoc.Doc(
+    __.ddoc.Doc(
         ''' Bound attributes deleter function.
 
             Usually from ``super( ).__delattr__`` or a partial function.
@@ -85,7 +117,7 @@ DeleterLigation: __.typx.TypeAlias = __.typx.Annotated[
 ]
 SurveyorLigation: __.typx.TypeAlias = __.typx.Annotated[
     __.cabc.Callable[ [ ], __.cabc.Iterable[ str ] ],
-    __.dynadoc.Doc(
+    __.ddoc.Doc(
         ''' Bound attributes surveyor function.
 
             Usually from ``super( ).__dir__`` or a partial function.
@@ -105,30 +137,44 @@ ClassConstructionPreprocessor: __.typx.TypeAlias = __.typx.Annotated[
         ],
         None
     ],
-    __.dynadoc.Doc(
+    __.ddoc.Doc(
         ''' Processes class data before construction.
 
             For use cases, such as argument conversion.
         ''' ),
 ]
+ClassConstructionPreprocessors: __.typx.TypeAlias = __.typx.Annotated[
+    __.cabc.Sequence[ ClassConstructionPreprocessor[ __.U ] ],
+    __.ddoc.Doc( ''' Processors to apply before construction of class. ''' ),
+]
 ClassConstructionPostprocessor: __.typx.TypeAlias = __.typx.Annotated[
     __.cabc.Callable[ [ type, DecoratorsMutable[ __.U ] ], None ],
-    __.dynadoc.Doc(
+    __.ddoc.Doc(
         ''' Processes class before decoration.
 
             For use cases, such as decorator list manipulation.
         ''' ),
 ]
+ClassConstructionPostprocessors: __.typx.TypeAlias = __.typx.Annotated[
+    __.cabc.Sequence[ ClassConstructionPostprocessor[ __.U ] ],
+    __.ddoc.Doc(
+        ''' Processors to apply before decoration of class. ''' ),
+]
 # TODO: ClassInitializationPreparer (arguments mutation)
 ClassInitializationCompleter: __.typx.TypeAlias = __.typx.Annotated[
     __.cabc.Callable[ [ type ], None ],
-    __.dynadoc.Doc(
+    __.ddoc.Doc(
         ''' Completes initialization of class.
 
             For use cases, such as enabling immutability once all other
             initialization has occurred.
         ''' ),
 ]
+ClassInitializationCompleters: __.typx.TypeAlias = __.typx.Annotated[
+    __.cabc.Sequence[ ClassInitializationCompleter ],
+    __.ddoc.Doc(
+        ''' Processors to apply at final stage of class initialization. ''' ),
+]
 
 
 ClassConstructor: __.typx.TypeAlias = __.typx.Annotated[
@@ -144,7 +190,7 @@ ClassConstructor: __.typx.TypeAlias = __.typx.Annotated[
         ],
         type
     ],
-    __.dynadoc.Doc( ''' Constructor to use with metaclass. ''' ),
+    __.ddoc.Doc( ''' Constructor to use with metaclass. ''' ),
 ]
 ClassInitializer: __.typx.TypeAlias = __.typx.Annotated[
     __.cabc.Callable[
@@ -156,22 +202,5 @@ ClassInitializer: __.typx.TypeAlias = __.typx.Annotated[
         ],
         None
     ],
-    __.dynadoc.Doc( ''' Initializer to use with metaclass. ''' ),
-]
-
-
-ProduceConstructorPreprocsArgument: __.typx.TypeAlias = __.typx.Annotated[
-    __.cabc.Sequence[ ClassConstructionPreprocessor[ __.U ] ],
-    __.dynadoc.Doc(
-        ''' Processors to apply before construction of class. ''' ),
-]
-ProduceConstructorPostprocsArgument: __.typx.TypeAlias = __.typx.Annotated[
-    __.cabc.Sequence[ ClassConstructionPostprocessor[ __.U ] ],
-    __.dynadoc.Doc(
-        ''' Processors to apply before decoration of class. ''' ),
-]
-ProduceInitializerCompletersArgument: __.typx.TypeAlias = __.typx.Annotated[
-    __.cabc.Sequence[ ClassInitializationCompleter ],
-    __.dynadoc.Doc(
-        ''' Processors to apply at final stage of class initialization. ''' ),
+    __.ddoc.Doc( ''' Initializer to use with metaclass. ''' ),
 ]

{classcore-1.4.2 → classcore-1.5.1}/sources/classcore/standard/behaviors.py

@@ -28,6 +28,26 @@ from . import __
 from . import nomina as _nomina
 
 
+def access_core_function( # noqa: PLR0913
+    cls: type, /, *,
+    attributes_namer: _nomina.AttributesNamer,
+    arguments: __.cabc.Mapping[ str, __.typx.Any ],
+    level: str,
+    name: str,
+    default: __.cabc.Callable[ ..., __.typx.Any ],
+) -> __.cabc.Callable[ ..., __.typx.Any ]:
+    ''' Accesses core behavior function.
+
+        First checks for override argument, then checks for heritable
+        attribute. Finally, falls back to provided default.
+    '''
+    argument_name = f"{level}_{name}_core"
+    attribute_name = attributes_namer( level, f"{name}_core" )
+    return (
+            arguments.get( argument_name )
+        or  getattr( cls, attribute_name, default ) )
+
+
 def assign_attribute_if_mutable( # noqa: PLR0913
     obj: object, /, *,
     ligation: _nomina.AssignerLigation,
@@ -225,6 +245,10 @@ def produce_class_construction_postprocessor(
 ) -> _nomina.ClassConstructionPostprocessor[ __.U ]:
     ''' Produces construction processor which determines class decorators. '''
     arguments_name = attributes_namer( 'class', 'construction_arguments' )
+    cores_default = dict(
+        assigner = assign_attribute_if_mutable,
+        deleter = delete_attribute_if_mutable,
+        surveyor = survey_visible_attributes )
 
     def postprocess(
         cls: type, decorators: _nomina.DecoratorsMutable[ __.U ]
@@ -236,16 +260,19 @@ def produce_class_construction_postprocessor(
             dynadoc_cfg_name = (
                 attributes_namer( 'classes', 'dynadoc_configuration' ) )
             dynadoc_cfg = getattr( clscls, dynadoc_cfg_name, { } )
-        decorators.append( __.dynadoc.with_docstring( **dynadoc_cfg ) )
+        decorators.append( __.ddoc.with_docstring( **dynadoc_cfg ) )
         dcls_spec = getattr( cls, '__dataclass_transform__', None )
         if not dcls_spec: # either base class or metaclass may be marked
             dcls_spec = getattr( clscls, '__dataclass_transform__', None )
-        instances_assigner = arguments.get(
-            'instances_assigner_core', assign_attribute_if_mutable )
-        instances_deleter = arguments.get(
-            'instances_deleter_core', delete_attribute_if_mutable )
-        instances_surveyor = arguments.get(
-            'instances_surveyor_core', survey_visible_attributes )
+        cores = { }
+        for core_name in ( 'assigner', 'deleter', 'surveyor' ):
+            core_function = access_core_function(
+                cls,
+                attributes_namer = attributes_namer,
+                arguments = arguments,
+                level = 'instances', name = core_name,
+                default = cores_default[ core_name ] )
+            cores[ core_name ] = core_function
         instances_mutables = arguments.get(
             'instances_mutables', __.mutables_default )
         instances_visibles = arguments.get(
@@ -261,9 +288,12 @@ def produce_class_construction_postprocessor(
         decorator: _nomina.Decorator[ __.U ] = decorator_factory(
             attributes_namer = attributes_namer,
             error_class_provider = error_class_provider,
-            assigner_core = instances_assigner,
-            deleter_core = instances_deleter,
-            surveyor_core = instances_surveyor,
+            assigner_core = __.typx.cast(
+                _nomina.AssignerCore, cores[ 'assigner' ] ),
+            deleter_core = __.typx.cast(
+                _nomina.DeleterCore, cores[ 'deleter' ] ),
+            surveyor_core = __.typx.cast(
+                _nomina.SurveyorCore, cores[ 'surveyor' ] ),
             mutables = instances_mutables,
             visibles = instances_visibles )
         decorators.append( decorator )

{classcore-1.4.2 → classcore-1.5.1}/sources/classcore/standard/decorators.py

@@ -21,8 +21,6 @@
 ''' Standard decorators. '''
 # TODO? Add attribute value transformer as standard decorator argument.
 
-# ruff: noqa: F401
-
 
 from .. import factories as _factories
 from .. import utilities as _utilities
@@ -56,6 +54,33 @@ def prepare_dataclass_for_instances(
     setattr( cls, behaviors_name_m, __.dcls.field( init = False ) )
 
 
+def apply_cfc_core_functions(
+    clscls: type[ __.T ], /,
+    attributes_namer: _nomina.AttributesNamer,
+    assigner_core: __.typx.Optional[ _nomina.AssignerCore ] = None,
+    deleter_core: __.typx.Optional[ _nomina.DeleterCore ] = None,
+    surveyor_core: __.typx.Optional[ _nomina.SurveyorCore ] = None,
+) -> None:
+    ''' Stores core functions on metaclass. '''
+    cores = dict(
+        classes_assigner_core = assigner_core,
+        classes_deleter_core = deleter_core,
+        classes_surveyor_core = surveyor_core )
+    cores_default = dict(
+        assigner = _behaviors.assign_attribute_if_mutable,
+        deleter = _behaviors.delete_attribute_if_mutable,
+        surveyor = _behaviors.survey_visible_attributes )
+    for core_name in ( 'assigner', 'deleter', 'surveyor' ):
+        core_function = _behaviors.access_core_function(
+            clscls,
+            attributes_namer = attributes_namer,
+            arguments = cores,
+            level = 'classes', name = core_name,
+            default = cores_default[ core_name ] )
+        core_aname = attributes_namer( 'classes', f"{core_name}_core" )
+        setattr( clscls, core_aname, core_function )
+
+
 def apply_cfc_dynadoc_configuration(
     clscls: type[ __.T ], /,
     attributes_namer: _nomina.AttributesNamer,
@@ -109,7 +134,7 @@ def apply_cfc_attributes_assigner(
     clscls: type[ __.T ], /,
     attributes_namer: _nomina.AttributesNamer,
     error_class_provider: _nomina.ErrorClassProvider,
-    implementation_core: _nomina.AssignerCore,
+    implementation_core: __.typx.Optional[ _nomina.AssignerCore ],
 ) -> None:
     ''' Injects '__setattr__' method into metaclass. '''
     decorator = produce_attributes_assignment_decorator(
@@ -124,7 +149,7 @@ def apply_cfc_attributes_deleter(
     clscls: type[ __.T ], /,
     attributes_namer: _nomina.AttributesNamer,
     error_class_provider: _nomina.ErrorClassProvider,
-    implementation_core: _nomina.DeleterCore,
+    implementation_core: __.typx.Optional[ _nomina.DeleterCore ],
 ) -> None:
     ''' Injects '__delattr__' method into metaclass. '''
     decorator = produce_attributes_deletion_decorator(
@@ -138,7 +163,7 @@ def apply_cfc_attributes_deleter(
 def apply_cfc_attributes_surveyor(
     clscls: type[ __.T ],
     attributes_namer: _nomina.AttributesNamer,
-    implementation_core: _nomina.SurveyorCore,
+    implementation_core: __.typx.Optional[ _nomina.SurveyorCore ],
 ) -> None:
     ''' Injects '__dir__' method into metaclass. '''
     decorator = produce_attributes_surveillance_decorator(
@@ -151,17 +176,20 @@ def apply_cfc_attributes_surveyor(
 def class_factory( # noqa: PLR0913
     attributes_namer: _nomina.AttributesNamer = __.calculate_attrname,
     error_class_provider: _nomina.ErrorClassProvider = __.provide_error_class,
-    assigner_core: _nomina.AssignerCore = (
-        _behaviors.assign_attribute_if_mutable ),
-    deleter_core: _nomina.DeleterCore = (
-        _behaviors.delete_attribute_if_mutable ),
-    surveyor_core: _nomina.SurveyorCore = (
-        _behaviors.survey_visible_attributes ),
+    assigner_core: __.typx.Optional[ _nomina.AssignerCore ] = None,
+    deleter_core: __.typx.Optional[ _nomina.DeleterCore ] = None,
+    surveyor_core: __.typx.Optional[ _nomina.SurveyorCore ] = None,
     dynadoc_configuration: __.cabc.Mapping[ str, __.typx.Any ] = (
         _dynadoc_configuration ),
 ) -> _nomina.Decorator[ __.T ]:
     ''' Produces decorator to apply standard behaviors to metaclass. '''
     def decorate( clscls: type[ __.T ] ) -> type[ __.T ]:
+        apply_cfc_core_functions(
+            clscls,
+            attributes_namer = attributes_namer,
+            assigner_core = assigner_core,
+            deleter_core = deleter_core,
+            surveyor_core = surveyor_core )
         apply_cfc_dynadoc_configuration(
             clscls,
             attributes_namer = attributes_namer,
@@ -190,13 +218,34 @@ def class_factory( # noqa: PLR0913
     return decorate
 
 
-def produce_instances_initialization_decorator(
+def produce_instances_initialization_decorator( # noqa: PLR0913
     attributes_namer: _nomina.AttributesNamer,
+    assigner_core: __.typx.Optional[ _nomina.AssignerCore ],
+    deleter_core: __.typx.Optional[ _nomina.DeleterCore ],
+    surveyor_core: __.typx.Optional[ _nomina.SurveyorCore ],
     mutables: _nomina.BehaviorExclusionVerifiersOmni,
     visibles: _nomina.BehaviorExclusionVerifiersOmni,
 ) -> _nomina.Decorator[ __.U ]:
     ''' Produces decorator to inject '__init__' method into class. '''
+    cores = dict(
+        instances_assigner_core = assigner_core,
+        instances_deleter_core = deleter_core,
+        instances_surveyor_core = surveyor_core )
+    cores_default = dict(
+        assigner = _behaviors.assign_attribute_if_mutable,
+        deleter = _behaviors.delete_attribute_if_mutable,
+        surveyor = _behaviors.survey_visible_attributes )
+
     def decorate( cls: type[ __.U ] ) -> type[ __.U ]:
+        for core_name in ( 'assigner', 'deleter', 'surveyor' ):
+            core_function = _behaviors.access_core_function(
+                cls,
+                attributes_namer = attributes_namer,
+                arguments = cores,
+                level = 'instances', name = core_name,
+                default = cores_default[ core_name ] )
+            core_aname = attributes_namer( 'instances', f"{core_name}_core" )
+            setattr( cls, core_aname, core_function )
         behaviors: set[ str ] = set( )
         behaviors_name = attributes_namer( 'instance', 'behaviors' )
         _behaviors.record_behavior(
@@ -253,12 +302,18 @@ def produce_attributes_assignment_decorator(
     level: str,
     attributes_namer: _nomina.AttributesNamer,
     error_class_provider: _nomina.ErrorClassProvider,
-    implementation_core: _nomina.AssignerCore,
+    implementation_core: __.typx.Optional[ _nomina.AssignerCore ],
 ) -> _nomina.Decorator[ __.U ]:
     ''' Produces decorator to inject '__setattr__' method into class. '''
     def decorate( cls: type[ __.U ] ) -> type[ __.U ]:
         leveli = 'class' if level == 'classes' else level
         original = cls.__dict__.get( '__setattr__' )
+        core = _behaviors.access_core_function(
+            cls,
+            attributes_namer = attributes_namer,
+            arguments = { f"{level}_assigner": implementation_core },
+            level = level, name = 'assigner',
+            default = _behaviors.assign_attribute_if_mutable )
 
         if original is None:
 
@@ -270,7 +325,7 @@ def produce_attributes_assignment_decorator(
                 if cls is not type( self ):
                     ligation( name, value )
                     return
-                implementation_core(
+                core(
                     self,
                     ligation = ligation,
                     attributes_namer = attributes_namer,
@@ -291,7 +346,7 @@ def produce_attributes_assignment_decorator(
                 if cls is not type( self ):
                     ligation( name, value )
                     return
-                implementation_core(
+                core(
                     self,
                     ligation = ligation,
                     attributes_namer = attributes_namer,
@@ -310,12 +365,18 @@ def produce_attributes_deletion_decorator(
     level: str,
     attributes_namer: _nomina.AttributesNamer,
     error_class_provider: _nomina.ErrorClassProvider,
-    implementation_core: _nomina.DeleterCore,
+    implementation_core: __.typx.Optional[ _nomina.DeleterCore ],
 ) -> _nomina.Decorator[ __.U ]:
     ''' Produces decorator to inject '__delattr__' method into class. '''
     def decorate( cls: type[ __.U ] ) -> type[ __.U ]:
         leveli = 'class' if level == 'classes' else level
         original = cls.__dict__.get( '__delattr__' )
+        core = _behaviors.access_core_function(
+            cls,
+            attributes_namer = attributes_namer,
+            arguments = { f"{level}_deleter": implementation_core },
+            level = level, name = 'deleter',
+            default = _behaviors.delete_attribute_if_mutable )
 
         if original is None:
 
@@ -325,7 +386,7 @@ def produce_attributes_deletion_decorator(
                 if cls is not type( self ):
                     ligation( name )
                     return
-                implementation_core(
+                core(
                     self,
                     ligation = ligation,
                     attributes_namer = attributes_namer,
@@ -344,7 +405,7 @@ def produce_attributes_deletion_decorator(
                 if cls is not type( self ):
                     ligation( name )
                     return
-                implementation_core(
+                core(
                     self,
                     ligation = ligation,
                     attributes_namer = attributes_namer,
@@ -362,12 +423,18 @@ def produce_attributes_deletion_decorator(
 def produce_attributes_surveillance_decorator(
     level: str,
     attributes_namer: _nomina.AttributesNamer,
-    implementation_core: _nomina.SurveyorCore,
+    implementation_core: __.typx.Optional[ _nomina.SurveyorCore ],
 ) -> _nomina.Decorator[ __.U ]:
     ''' Produces decorator to inject '__dir__' method into class. '''
     def decorate( cls: type[ __.U ] ) -> type[ __.U ]:
         leveli = 'class' if level == 'classes' else level
         original = cls.__dict__.get( '__dir__' )
+        core = _behaviors.access_core_function(
+            cls,
+            attributes_namer = attributes_namer,
+            arguments = { f"{level}_surveyor": implementation_core },
+            level = level, name = 'surveyor',
+            default = _behaviors.survey_visible_attributes )
 
         if original is None:
 
@@ -377,7 +444,7 @@ def produce_attributes_surveillance_decorator(
                 ligation = super( cls, self ).__dir__
                 # Only enforce behaviors at start of MRO.
                 if cls is not type( self ): return ligation( )
-                return implementation_core(
+                return core(
                     self,
                     ligation = ligation,
                     attributes_namer = attributes_namer,
@@ -394,7 +461,7 @@ def produce_attributes_surveillance_decorator(
                 ligation = __.funct.partial( original, self )
                 # Only enforce behaviors at start of MRO.
                 if cls is not type( self ): return ligation( )
-                return implementation_core(
+                return core(
                     self,
                     ligation = ligation,
                     attributes_namer = attributes_namer,
@@ -412,12 +479,9 @@ def dataclass_with_standard_behaviors( # noqa: PLR0913
     attributes_namer: _nomina.AttributesNamer = __.calculate_attrname,
     error_class_provider: _nomina.ErrorClassProvider = __.provide_error_class,
     decorators: _nomina.Decorators[ __.U ] = ( ),
-    assigner_core: _nomina.AssignerCore = (
-        _behaviors.assign_attribute_if_mutable ),
-    deleter_core: _nomina.DeleterCore = (
-        _behaviors.delete_attribute_if_mutable ),
-    surveyor_core: _nomina.SurveyorCore = (
-        _behaviors.survey_visible_attributes ),
+    assigner_core: __.typx.Optional[ _nomina.AssignerCore ] = None,
+    deleter_core: __.typx.Optional[ _nomina.DeleterCore ] = None,
+    surveyor_core: __.typx.Optional[ _nomina.SurveyorCore ] = None,
     mutables: _nomina.BehaviorExclusionVerifiersOmni = __.mutables_default,
     visibles: _nomina.BehaviorExclusionVerifiersOmni = __.visibles_default,
 ) -> _nomina.Decorator[ __.U ]:
@@ -445,12 +509,9 @@ def with_standard_behaviors( # noqa: PLR0913
     attributes_namer: _nomina.AttributesNamer = __.calculate_attrname,
     error_class_provider: _nomina.ErrorClassProvider = __.provide_error_class,
     decorators: _nomina.Decorators[ __.U ] = ( ),
-    assigner_core: _nomina.AssignerCore = (
-        _behaviors.assign_attribute_if_mutable ),
-    deleter_core: _nomina.DeleterCore = (
-        _behaviors.delete_attribute_if_mutable ),
-    surveyor_core: _nomina.SurveyorCore = (
-        _behaviors.survey_visible_attributes ),
+    assigner_core: __.typx.Optional[ _nomina.AssignerCore ] = None,
+    deleter_core: __.typx.Optional[ _nomina.DeleterCore ] = None,
+    surveyor_core: __.typx.Optional[ _nomina.SurveyorCore ] = None,
     mutables: _nomina.BehaviorExclusionVerifiersOmni = __.mutables_default,
     visibles: _nomina.BehaviorExclusionVerifiersOmni = __.visibles_default,
 ) -> _nomina.Decorator[ __.U ]:
@@ -481,16 +542,16 @@ def _produce_instances_decoration_preparers(
     if class_preparer is not None:
         preprocessors.append(
             __.funct.partial(
-                class_preparer, attributes_namer = attributes_namer  ) )
+                class_preparer, attributes_namer = attributes_namer ) )
     return tuple( preprocessors )
 
 
 def _produce_instances_decorators( # noqa: PLR0913
     attributes_namer: _nomina.AttributesNamer,
     error_class_provider: _nomina.ErrorClassProvider,
-    assigner_core: _nomina.AssignerCore,
-    deleter_core: _nomina.DeleterCore,
-    surveyor_core: _nomina.SurveyorCore,
+    assigner_core: __.typx.Optional[ _nomina.AssignerCore ],
+    deleter_core: __.typx.Optional[ _nomina.DeleterCore ],
+    surveyor_core: __.typx.Optional[ _nomina.SurveyorCore ],
     mutables: _nomina.BehaviorExclusionVerifiersOmni,
     visibles: _nomina.BehaviorExclusionVerifiersOmni,
 ) -> _nomina.Decorators[ __.U ]:
@@ -499,24 +560,25 @@ def _produce_instances_decorators( # noqa: PLR0913
     decorators.append(
         produce_instances_initialization_decorator(
             attributes_namer = attributes_namer,
+            assigner_core = assigner_core,
+            deleter_core = deleter_core,
+            surveyor_core = surveyor_core,
             mutables = mutables, visibles = visibles ) )
-    if mutables != '*':
-        decorators.append(
-            produce_attributes_assignment_decorator(
-                level = 'instances',
-                attributes_namer = attributes_namer,
-                error_class_provider = error_class_provider,
-                implementation_core = assigner_core ) )
-        decorators.append(
-            produce_attributes_deletion_decorator(
-                level = 'instances',
-                attributes_namer = attributes_namer,
-                error_class_provider = error_class_provider,
-                implementation_core = deleter_core ) )
-    if visibles != '*':
-        decorators.append(
-            produce_attributes_surveillance_decorator(
-                level = 'instances',
-                attributes_namer = attributes_namer,
-                implementation_core = surveyor_core ) )
+    decorators.append(
+        produce_attributes_assignment_decorator(
+            level = 'instances',
+            attributes_namer = attributes_namer,
+            error_class_provider = error_class_provider,
+            implementation_core = assigner_core ) )
+    decorators.append(
+        produce_attributes_deletion_decorator(
+            level = 'instances',
+            attributes_namer = attributes_namer,
+            error_class_provider = error_class_provider,
+            implementation_core = deleter_core ) )
+    decorators.append(
+        produce_attributes_surveillance_decorator(
+            level = 'instances',
+            attributes_namer = attributes_namer,
+            implementation_core = surveyor_core ) )
     return decorators

{classcore-1.4.2 → classcore-1.5.1}/sources/classcore/standard/dynadoc.py

@@ -26,34 +26,34 @@ from . import __
 from . import nomina as _nomina
 
 
-dynadoc_context = __.dynadoc.produce_context( )
+dynadoc_context = __.ddoc.produce_context( )
 dynadoc_class_introspection_control = (
-    __.dynadoc.ClassIntrospectionControl(
+    __.ddoc.ClassIntrospectionControl(
         inheritance = True,
         introspectors = (
-            __.dynadoc.introspection.introspect_special_classes, ) ) )
+            __.ddoc.introspection.introspect_special_classes, ) ) )
 dynadoc_module_introspection_control = (
-    __.dynadoc.ModuleIntrospectionControl( ) )
+    __.ddoc.ModuleIntrospectionControl( ) )
 
 
 def dynadoc_avoid_immutables(
     objct: object,
-    introspection: __.dynadoc.IntrospectionControl,
+    introspection: __.ddoc.IntrospectionControl,
     attributes_namer: _nomina.AttributesNamer,
-) -> __.dynadoc.IntrospectionControl:
+) -> __.ddoc.IntrospectionControl:
     ''' Disables introspection of immutable objects. '''
     if __.inspect.isclass( objct ):
         behaviors_name = attributes_namer( 'class', 'behaviors' )
         behaviors = _utilities.getattr0( objct, behaviors_name, frozenset( ) )
         if _nomina.immutability_label in behaviors:
             return introspection.with_limit(
-                __.dynadoc.IntrospectionLimit( disable = True ) )
+                __.ddoc.IntrospectionLimit( disable = True ) )
     return introspection
 
 
 def produce_dynadoc_introspection_limiter(
     attributes_namer: _nomina.AttributesNamer = __.calculate_attrname,
-) -> __.dynadoc.IntrospectionLimiter:
+) -> __.ddoc.IntrospectionLimiter:
     ''' Produces introspection limiter which avoids immutable objects. '''
     return __.funct.partial(
         dynadoc_avoid_immutables, attributes_namer = attributes_namer )
@@ -63,17 +63,17 @@ dynadoc_introspection_limiter = produce_dynadoc_introspection_limiter( )
 
 def produce_dynadoc_introspection_control(
     enable: bool = True,
-    class_control: __.dynadoc.ClassIntrospectionControl = (
+    class_control: __.ddoc.ClassIntrospectionControl = (
         dynadoc_class_introspection_control ),
-    module_control: __.dynadoc.ModuleIntrospectionControl = (
+    module_control: __.ddoc.ModuleIntrospectionControl = (
         dynadoc_module_introspection_control ),
-    limiters: __.dynadoc.IntrospectionLimiters = (
+    limiters: __.ddoc.IntrospectionLimiters = (
         dynadoc_introspection_limiter, ),
-    targets: __.dynadoc.IntrospectionTargets = (
-            __.dynadoc.IntrospectionTargetsSansModule ),
-) -> __.dynadoc.IntrospectionControl:
+    targets: __.ddoc.IntrospectionTargets = (
+            __.ddoc.IntrospectionTargetsSansModule ),
+) -> __.ddoc.IntrospectionControl:
     ''' Produces compatible Dynadoc introspection control. '''
-    return __.dynadoc.IntrospectionControl(
+    return __.ddoc.IntrospectionControl(
         enable = enable,
         class_control = class_control,
         module_control = module_control,
@@ -83,18 +83,18 @@ def produce_dynadoc_introspection_control(
 dynadoc_introspection_on_class = produce_dynadoc_introspection_control( )
 dynadoc_introspection_on_package = (
     produce_dynadoc_introspection_control(
-        targets = __.dynadoc.IntrospectionTargetsOmni ) )
+        targets = __.ddoc.IntrospectionTargetsOmni ) )
 
 
 def assign_module_docstring( # noqa: PLR0913
     module: str | __.types.ModuleType, /,
-    *fragments: __.dynadoc.interfaces.Fragment,
+    *fragments: __.ddoc.interfaces.Fragment,
     context: _nomina.DynadocContextArgument = dynadoc_context,
     introspection: _nomina.DynadocIntrospectionArgument = (
         dynadoc_introspection_on_package ),
     preserve: _nomina.DynadocPreserveArgument = True,
-    renderer: __.dynadoc.xtnsapi.Renderer = (
-        __.dynadoc.assembly.renderer_default ),
+    renderer: __.ddoc.xtnsapi.Renderer = (
+        __.ddoc.assembly.renderer_default ),
     table: _nomina.DynadocTableArgument = __.dictproxy_empty,
 ) -> None:
     ''' Updates module docstring based on introspection.
@@ -104,7 +104,7 @@ def assign_module_docstring( # noqa: PLR0913
 
         By default, ignores previously-decorated immutable classes.
     '''
-    __.dynadoc.assign_module_docstring(
+    __.ddoc.assign_module_docstring(
         module,
         *fragments,
         context = context,

{classcore-1.4.2 → classcore-1.5.1}/sources/classcore/standard/modules.py

@@ -34,20 +34,20 @@ class Module( _classes.Object, __.types.ModuleType ):
 def reclassify_modules(
     attributes: __.typx.Annotated[
         __.cabc.Mapping[ str, __.typx.Any ] | __.types.ModuleType | str,
-        __.dynadoc.Doc(
+        __.ddoc.Doc(
             ''' Module, module name, or dictionary of object attributes. ''' ),
     ], /, *,
     attributes_namer: __.typx.Annotated[
         _nomina.AttributesNamer,
-        __.dynadoc.Doc(
+        __.ddoc.Doc(
             ''' Attributes namer function with which to seal class. ''' ),
     ] = __.calculate_attrname,
     recursive: __.typx.Annotated[
-        bool, __.dynadoc.Doc( ''' Recursively reclassify package modules? ''' )
+        bool, __.ddoc.Doc( ''' Recursively reclassify package modules? ''' )
     ] = False,
     replacement_class: __.typx.Annotated[
         type[ __.types.ModuleType ],
-        __.dynadoc.Doc( ''' New class for module. ''' ),
+        __.ddoc.Doc( ''' New class for module. ''' ),
     ] = Module,
 ) -> None:
     # TODO? Ensure correct operation with namespace packages.

{classcore-1.4.2 → classcore-1.5.1}/sources/classcore/standard/nomina.py

@@ -46,8 +46,15 @@ BehaviorExclusionVerifiers: __.typx.TypeAlias = (
     __.cabc.Sequence[ BehaviorExclusionVerifier ] )
 BehaviorExclusionVerifiersOmni: __.typx.TypeAlias = (
     BehaviorExclusionVerifiers | __.typx.Literal[ '*' ] )
-ErrorClassProvider: __.typx.TypeAlias = (
-    __.cabc.Callable[ [ str ], type[ Exception ] ] )
+ErrorClassProvider: __.typx.TypeAlias = __.typx.Annotated[
+    __.cabc.Callable[ [ str ], type[ Exception ] ],
+    __.ddoc.Doc(
+        ''' Takes name of exception class and returns corresponding class.
+
+            Can be used by downstream packages to provide exceptions from their
+            own hierarchies rather than the hierarchy from this package.
+        ''' ),
+]
 
 
 class AssignerCore( __.typx.Protocol ):
@@ -103,9 +110,10 @@ class ClassPreparer( __.typx.Protocol ):
 
 
 DynadocConfiguration: __.typx.TypeAlias = __.cabc.Mapping[ str, __.typx.Any ]
+# TODO: Use argument type aliases from 'dynadoc' package.
 DynadocContextArgument: __.typx.TypeAlias = __.typx.Annotated[
-    __.dynadoc.Context,
-    __.dynadoc.Doc(
+    __.ddoc.Context,
+    __.ddoc.Doc(
         ''' Dynadoc context.
 
             Renderer, dictionaries for resolution of stringified annotations,
@@ -113,8 +121,8 @@ DynadocContextArgument: __.typx.TypeAlias = __.typx.Annotated[
         ''' ),
 ]
 DynadocIntrospectionArgument: __.typx.TypeAlias = __.typx.Annotated[
-    __.dynadoc.IntrospectionControl,
-    __.dynadoc.Doc(
+    __.ddoc.IntrospectionControl,
+    __.ddoc.Doc(
         ''' Dynadoc introspection control.
 
             Which kinds of object to recursively introspect?
@@ -124,15 +132,15 @@ DynadocIntrospectionArgument: __.typx.TypeAlias = __.typx.Annotated[
         ''' ),
 ]
 DynadocPreserveArgument: __.typx.TypeAlias = __.typx.Annotated[
-    bool, __.dynadoc.Doc( ''' Preserve existing docstring? ''' )
+    bool, __.ddoc.Doc( ''' Preserve existing docstring? ''' )
 ]
 DynadocTableArgument: __.typx.TypeAlias = __.typx.Annotated[
     __.cabc.Mapping[ str, str ],
-    __.dynadoc.Doc( ''' Table of documentation fragments. ''' ),
+    __.ddoc.Doc( ''' Table of documentation fragments. ''' ),
 ]
 ProduceDynadocConfigurationReturn: __.typx.TypeAlias = __.typx.Annotated[
     DynadocConfiguration,
-    __.dynadoc.Doc(
+    __.ddoc.Doc(
         ''' Dynadoc configuration dictionary.
 
             Suitable as a keyword expansion (``**``) argument to

{classcore-1.4.2 → classcore-1.5.1}/sources/classcore/utilities.py

@@ -95,8 +95,11 @@ def mangle_name( objct: object, /, name: str ) -> str:
         Effectively provides name of private member attribute,
         which is unique across class inheritance.
     '''
+    # TODO: Replace expensive SHA-256 hash with simple 'id'.
+    #       Need to debug weird issue with using 'id' early on dataclasses.
     if not __.inspect.isclass( objct ):
         return mangle_name( type( objct ), name )
+    # return "{name}_{uid}".format( name = name, uid = id( objct ) )
     namehash = __.hashlib.sha256( )
     namehash.update( qualify_class_name( objct ).encode( ) )
     namehash_hex = namehash.hexdigest( )