classcore 1.2__tar.gz → 1.3__tar.gz

{classcore-1.2 → classcore-1.3}/PKG-INFO

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

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

{classcore-1.2 → classcore-1.3}/sources/classcore/standard/behaviors.py

@@ -195,7 +195,8 @@ def produce_class_construction_preprocessor(
 
 
 def produce_class_construction_postprocessor(
-    attributes_namer: _nomina.AttributesNamer
+    attributes_namer: _nomina.AttributesNamer,
+    error_class_provider: _nomina.ErrorClassProvider,
 ) -> _nomina.ClassConstructionPostprocessor[ __.U ]:
     ''' Produces construction processor which determines class decorators. '''
     arguments_name = attributes_namer( 'class', 'construction_arguments' )
@@ -214,6 +215,12 @@ def produce_class_construction_postprocessor(
         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 )
         instances_mutables = arguments.get(
             'instances_mutables', __.mutables_default )
         instances_visibles = arguments.get(
@@ -227,7 +234,13 @@ def produce_class_construction_postprocessor(
             from .decorators import with_standard_behaviors
             decorator_factory = with_standard_behaviors
         decorator: _nomina.Decorator[ __.U ] = decorator_factory(
-            mutables = instances_mutables, visibles = instances_visibles )
+            attributes_namer = attributes_namer,
+            error_class_provider = error_class_provider,
+            assigner_core = instances_assigner,
+            deleter_core = instances_deleter,
+            surveyor_core = instances_surveyor,
+            mutables = instances_mutables,
+            visibles = instances_visibles )
         decorators.append( decorator )
 
     return postprocess
@@ -316,6 +329,9 @@ def record_class_construction_arguments(
     arguments_ = { }
     for name in (
         'class_mutables', 'class_visibles',
+        'instances_assigner_core',
+        'instances_deleter_core',
+        'instances_surveyor_core',
         'instances_mutables', 'instances_visibles',
         'dynadoc_configuration',
     ):

{classcore-1.2 → classcore-1.3}/sources/classcore/standard/decorators.py

@@ -66,7 +66,9 @@ def apply_cfc_dynadoc_configuration(
 
 
 def apply_cfc_constructor(
-    clscls: type[ __.T ], /, attributes_namer: _nomina.AttributesNamer
+    clscls: type[ __.T ], /,
+    attributes_namer: _nomina.AttributesNamer,
+    error_class_provider: _nomina.ErrorClassProvider,
 ) -> None:
     ''' Injects '__new__' method into metaclass. '''
     preprocessors = (
@@ -74,7 +76,8 @@ def apply_cfc_constructor(
             attributes_namer = attributes_namer ), )
     postprocessors = (
         _behaviors.produce_class_construction_postprocessor(
-            attributes_namer = attributes_namer ), )
+            attributes_namer = attributes_namer,
+            error_class_provider = error_class_provider ), )
     constructor: _nomina.ClassConstructor[ __.T ] = (
         _factories.produce_class_constructor(
             attributes_namer = attributes_namer,
@@ -162,7 +165,10 @@ def class_factory( # noqa: PLR0913
             clscls,
             attributes_namer = attributes_namer,
             configuration = dynadoc_configuration )
-        apply_cfc_constructor( clscls, attributes_namer = attributes_namer )
+        apply_cfc_constructor(
+            clscls,
+            attributes_namer = attributes_namer,
+            error_class_provider = error_class_provider )
         apply_cfc_initializer( clscls, attributes_namer = attributes_namer )
         apply_cfc_attributes_assigner(
             clscls,
@@ -311,109 +317,116 @@ def produce_attributes_surveillance_decorator(
     return decorate
 
 
-def produce_decorators_factory( # noqa: PLR0913
-    level: str,
+@__.typx.dataclass_transform( frozen_default = True, kw_only_default = True )
+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 ),
-) -> __.cabc.Callable[
-    [
-        _nomina.BehaviorExclusionVerifiersOmni,
-        _nomina.BehaviorExclusionVerifiersOmni
-    ],
-    _nomina.Decorators[ __.U ]
-]:
-    ''' Produces decorators to imbue class with standard behaviors. '''
-    def produce(
-        mutables: _nomina.BehaviorExclusionVerifiersOmni,
-        visibles: _nomina.BehaviorExclusionVerifiersOmni,
-    ) -> _nomina.Decorators[ __.U ]:
-        ''' Produces standard decorators. '''
-        decorators: list[ _nomina.Decorator[ __.U ] ] = [ ]
-        decorators.append(
-            produce_instances_initialization_decorator(
-                attributes_namer = attributes_namer,
-                mutables = mutables, visibles = visibles ) )
-        if mutables != '*':
-            decorators.append(
-                produce_attributes_assignment_decorator(
-                    level = level,
-                    attributes_namer = attributes_namer,
-                    error_class_provider = error_class_provider,
-                    implementation_core = assigner_core ) )
-            decorators.append(
-                produce_attributes_deletion_decorator(
-                    level = level,
-                    attributes_namer = attributes_namer,
-                    error_class_provider = error_class_provider,
-                    implementation_core = deleter_core ) )
-        if visibles != '*':
-            decorators.append(
-                produce_attributes_surveillance_decorator(
-                    level = level,
-                    attributes_namer = attributes_namer,
-                    implementation_core = surveyor_core ) )
-        return decorators
-
-    return produce
-
-
-def produce_decoration_preparers_factory(
-    attributes_namer: _nomina.AttributesNamer = __.calculate_attrname,
-    error_class_provider: _nomina.ErrorClassProvider = __.provide_error_class,
-    class_preparer: __.typx.Optional[ _nomina.ClassPreparer ] = None,
-) -> _nomina.DecorationPreparersFactory[ __.U ]:
-    ''' Produces factory to produce class decoration preparers.
-
-        E.g., a preparer needs to inject special annotations to ensure
-        compatibility with standard behaviors before
-        :py:func:`dataclasses.dataclass` decorates a class.
-    '''
-    def produce( ) -> _nomina.DecorationPreparers[ __.U ]:
-        ''' Produces processors for standard decorators. '''
-        preprocessors: list[ _nomina.DecorationPreparer[ __.U ] ] = [ ]
-        if class_preparer is not None:
-            preprocessors.append(
-                __.funct.partial(
-                    class_preparer,
-                    attributes_namer = attributes_namer  ) )
-        return tuple( preprocessors )
-
-    return produce
-
-
-@__.typx.dataclass_transform( frozen_default = True, kw_only_default = True )
-def dataclass_with_standard_behaviors(
-    decorators: _nomina.Decorators[ __.U ] = ( ),
     mutables: _nomina.BehaviorExclusionVerifiersOmni = __.mutables_default,
     visibles: _nomina.BehaviorExclusionVerifiersOmni = __.visibles_default,
 ) -> _nomina.Decorator[ __.U ]:
     # https://github.com/microsoft/pyright/discussions/10344
     ''' Dataclass decorator factory. '''
-    decorators_factory = produce_decorators_factory( level = 'instances' )
     decorators_: _nomina.Decorators[ __.U ] = (
-        decorators_factory( mutables, visibles ) )
-    preparers_factory = produce_decoration_preparers_factory(
-        class_preparer = prepare_dataclass_for_instances )
-    preparers: _nomina.DecorationPreparers[ __.U ] = preparers_factory( )
+        _produce_instances_decorators(
+            attributes_namer = attributes_namer,
+            error_class_provider = error_class_provider,
+            assigner_core = assigner_core,
+            deleter_core = deleter_core,
+            surveyor_core = surveyor_core,
+            mutables = mutables,
+            visibles = visibles ) )
+    preparers: _nomina.DecorationPreparers[ __.U ] = (
+        _produce_instances_decoration_preparers(
+            attributes_namer = attributes_namer,
+            error_class_provider = error_class_provider,
+            class_preparer = prepare_dataclass_for_instances ) )
     return decoration_by(
         *decorators, _dataclass_core, *decorators_, preparers = preparers )
 
 
-def with_standard_behaviors(
+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 ),
     mutables: _nomina.BehaviorExclusionVerifiersOmni = __.mutables_default,
     visibles: _nomina.BehaviorExclusionVerifiersOmni = __.visibles_default,
 ) -> _nomina.Decorator[ __.U ]:
     ''' Class decorator factory. '''
-    decorators_factory = produce_decorators_factory( level = 'instances' )
     decorators_: _nomina.Decorators[ __.U ] = (
-        decorators_factory( mutables, visibles ) )
-    preparers_factory = produce_decoration_preparers_factory( )
-    preparers: _nomina.DecorationPreparers[ __.U ] = preparers_factory( )
+        _produce_instances_decorators(
+            attributes_namer = attributes_namer,
+            error_class_provider = error_class_provider,
+            assigner_core = assigner_core,
+            deleter_core = deleter_core,
+            surveyor_core = surveyor_core,
+            mutables = mutables,
+            visibles = visibles ) )
+    preparers: _nomina.DecorationPreparers[ __.U ] = (
+        _produce_instances_decoration_preparers(
+            attributes_namer = attributes_namer,
+            error_class_provider = error_class_provider ) )
     return decoration_by( *decorators, *decorators_, preparers = preparers )
+
+
+def _produce_instances_decoration_preparers(
+    attributes_namer: _nomina.AttributesNamer,
+    error_class_provider: _nomina.ErrorClassProvider,
+    class_preparer: __.typx.Optional[ _nomina.ClassPreparer ] = None,
+) -> _nomina.DecorationPreparers[ __.U ]:
+    ''' Produces processors for standard decorators. '''
+    preprocessors: list[ _nomina.DecorationPreparer[ __.U ] ] = [ ]
+    if class_preparer is not None:
+        preprocessors.append(
+            __.funct.partial(
+                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,
+    mutables: _nomina.BehaviorExclusionVerifiersOmni,
+    visibles: _nomina.BehaviorExclusionVerifiersOmni,
+) -> _nomina.Decorators[ __.U ]:
+    ''' Produces standard decorators. '''
+    decorators: list[ _nomina.Decorator[ __.U ] ] = [ ]
+    decorators.append(
+        produce_instances_initialization_decorator(
+            attributes_namer = attributes_namer,
+            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 ) )
+    return decorators

{classcore-1.2 → classcore-1.3}/sources/classcore/standard/modules.py

@@ -35,7 +35,7 @@ def reclassify_modules(
     attributes: __.typx.Annotated[
         __.cabc.Mapping[ str, __.typx.Any ] | __.types.ModuleType | str,
         __.dynadoc.Doc(
-            'Module, module name, or dictionary of object attributes.' ),
+            ''' Module, module name, or dictionary of object attributes. ''' ),
     ], /, *,
     attributes_namer: __.typx.Annotated[
         _nomina.AttributesNamer,
@@ -43,8 +43,12 @@ def reclassify_modules(
             ''' Attributes namer function with which to seal class. ''' ),
     ] = __.calculate_attrname,
     recursive: __.typx.Annotated[
-        bool, __.dynadoc.Doc( 'Recursively reclassify package modules?' )
+        bool, __.dynadoc.Doc( ''' Recursively reclassify package modules? ''' )
     ] = False,
+    replacement_class: __.typx.Annotated[
+        type[ __.types.ModuleType ],
+        __.dynadoc.Doc( ''' New class for module. ''' ),
+    ] = Module,
 ) -> None:
     # TODO? Ensure correct operation with namespace packages.
     ''' Reclassifies modules to have attributes concealment and immutability.
@@ -72,16 +76,18 @@ def reclassify_modules(
         if not __.inspect.ismodule( value ): continue
         if not value.__name__.startswith( f"{package_name}." ): continue
         if recursive: reclassify_modules( value, recursive = True )
-        if isinstance( value, Module ): continue
-        _seal_module( value, attributes_namer )
-    if module and not isinstance( module, Module ):
-        _seal_module( module, attributes_namer )
+        if isinstance( value, replacement_class ): continue
+        _seal_module( value, attributes_namer, replacement_class )
+    if module and not isinstance( module, replacement_class ):
+        _seal_module( module, attributes_namer, replacement_class )
 
 
 def _seal_module(
-     module: __.types.ModuleType, attributes_namer: _nomina.AttributesNamer
+     module: __.types.ModuleType,
+     attributes_namer: _nomina.AttributesNamer,
+     replacement_class: type[ __.types.ModuleType ],
 ) -> None:
     behaviors = { _nomina.concealment_label, _nomina.immutability_label }
     behaviors_name = attributes_namer( 'instance', 'behaviors' )
     _utilities.setattr0( module, behaviors_name, behaviors )
-    module.__class__ = Module
+    module.__class__ = replacement_class