classcore 1.12__tar.gz → 1.14__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: classcore
-Version: 1.12
+Version: 1.14
 Summary: Foundational class factories and decorators.
 Project-URL: Homepage, https://github.com/emcd/python-classcore
 Project-URL: Documentation, https://emcd.github.io/python-classcore
@@ -15,15 +15,13 @@ Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.10
-Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Python :: Implementation :: CPython
-Classifier: Programming Language :: Python :: Implementation :: PyPy
 Classifier: Topic :: Software Development
-Requires-Python: >=3.10
+Requires-Python: >=3.12
 Requires-Dist: dynadoc~=1.4
 Requires-Dist: typing-extensions
 Description-Content-Type: text/x-rst

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

@@ -13,7 +13,7 @@ description = 'Foundational class factories and decorators.'
 dynamic = [ 'version' ]
 license = 'Apache-2.0'
 readme = { 'file' = 'README.rst', 'content-type' = 'text/x-rst' }
-requires-python = '>= 3.10'
+requires-python = '>= 3.12'
 dependencies = [
   'dynadoc ~= 1.4',
   'typing-extensions',
@@ -26,13 +26,11 @@ classifiers = [ # https://pypi.org/classifiers
   'License :: OSI Approved :: Apache Software License',
   'Programming Language :: Python :: 3 :: Only',
   # --- BEGIN: Injected by Copier ---
-  'Programming Language :: Python :: 3.10',
-  'Programming Language :: Python :: 3.11',
   'Programming Language :: Python :: 3.12',
   'Programming Language :: Python :: 3.13',
   'Programming Language :: Python :: 3.14',
+  'Programming Language :: Python :: 3.15',
   'Programming Language :: Python :: Implementation :: CPython',
-  'Programming Language :: Python :: Implementation :: PyPy',
   # --- END: Injected by Copier ---
   'Topic :: Software Development',
 ]
@@ -91,7 +89,7 @@ strict-naming = false
 # --- BEGIN: Injected by Copier ---
 # --- END: Injected by Copier ---
 [tool.hatch.envs.default]
-python = '3.10'
+python = '3.12'
 [tool.hatch.envs.develop]
 description = ''' Development environment. '''
 builder = true
@@ -127,6 +125,12 @@ docsgen = [
   """sphinx-build -a -d .auxiliary/caches/sphinx --quiet \
       documentation .auxiliary/artifacts/sphinx-html""",
 ]
+fragments = [
+  """python .auxiliary/scripts/validate-fragments.py""",
+]
+module-sizes = [
+  """python .auxiliary/scripts/validate-module-sizes.py""",
+]
 linters = [
   """ruff check --quiet sources documentation tests""",
   # """vibelinter check""",
@@ -134,6 +138,8 @@ linters = [
   # --- END: Injected by Copier ---
   """isort --check-only --diff sources tests""",
   """pyright sources""",
+  'fragments',
+  'module-sizes',
 ]
 packagers = [
   """hatch build""",
@@ -170,12 +176,10 @@ description = ''' Quality assurance environment. '''
 template = 'develop'
 [[tool.hatch.envs.qa.matrix]]
 python = [
-    '3.10',
-    '3.11',
     '3.12',
     '3.13',
     '3.14',
-    'pypy3.11',
+    '3.15',
 ]
 # [tool.hatch.metadata]
 # allow-direct-references = true

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

@@ -297,6 +297,7 @@ sources/
         ├── classes.py           # Standard metaclasses and base classes
         ├── decorators.py        # Standard class decorators
         ├── dynadoc.py           # Documentation configuration
+        ├── explanations.py      # Attribute behavior explanations
         ├── modules.py           # Module reclassification utilities
         └── nomina.py            # Standard-specific naming types
 ```
@@ -378,6 +379,20 @@ sources/
   - `survey_visible_attributes`: Filter attributes for `dir()`
   - Verifier processing for names, regexes, and predicates
 
+`explanations.py`
+: Explanations of attribute behavior decisions:
+
+  - `explain_attribute`: Decision trace for one attribute of one target
+  - `AttributeExplanation` and the `Verdict` records (`AssignVerdict`,
+    `DeleteVerdict`, `SurveyVerdict`) with derived permissibility
+  - The closed `Decision` hierarchy: `PermitByInapplicability`,
+    `PermitByOmni`, `PermitByNames`, `PermitByPredicate`,
+    `PermitByRegex`, `Prohibit`, with typed payloads
+  - Internal marking via metaclass-carried contributions: the namer
+    detector for framework names, the abstract-base wiring for stdlib
+    ABC machinery (only where that machinery operates), and downstream
+    factory namers' detectors for downstream names
+
 `classes.py`
 : Standard metaclasses and base classes:
 

classcore-1.14/sources/classcore/__/nomina.py

@@ -0,0 +1,95 @@
+# vim: set filetype=python fileencoding=utf-8:
+# -*- coding: utf-8 -*-
+
+#============================================================================#
+#                                                                            #
+#  Licensed under the Apache License, Version 2.0 (the "License");           #
+#  you may not use this file except in compliance with the License.          #
+#  You may obtain a copy of the License at                                   #
+#                                                                            #
+#      http://www.apache.org/licenses/LICENSE-2.0                            #
+#                                                                            #
+#  Unless required by applicable law or agreed to in writing, software       #
+#  distributed under the License is distributed on an "AS IS" BASIS,         #
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  #
+#  See the License for the specific language governing permissions and       #
+#  limitations under the License.                                            #
+#                                                                            #
+#============================================================================#
+
+
+''' Common names and type aliases. '''
+
+
+from . import imports as __
+
+
+ComparisonResult: __.typx.TypeAlias = bool | __.types.NotImplementedType
+NominativeArguments: __.typx.TypeAlias = __.cabc.Mapping[ str, __.typx.Any ]
+PositionalArguments: __.typx.TypeAlias = __.cabc.Sequence[ __.typx.Any ]
+
+
+package_name = __name__.split( '.', maxsplit = 1 )[ 0 ]
+
+
+_levels = frozenset( ( 'class', 'classes', 'instance', 'instances' ) )
+_cores = frozenset( (
+    'behaviors',
+    'construction_arguments',
+    'dynadoc_configuration',
+    'in_progress',
+    'mutables_names', 'mutables_predicates', 'mutables_regexes',
+    'visibles_names', 'visibles_predicates', 'visibles_regexes',
+    'assigner_core', 'deleter_core', 'surveyor_core' ) )
+_hex_digits = frozenset( '0123456789abcdef' )
+_digest_length = 64
+_mangled_cores = frozenset( ( 'class_behaviors', 'class_in_progress' ) )
+
+
+class AttrnameCalculator:
+    ''' Calculates framework attribute names from level and core.
+
+        Reference implementation of the attribute namer convention:
+        call instances to produce names, and consult ``is_internal_name``
+        to detect names this framework generated. Downstream packages
+        may subclass (or otherwise provide callables exposing the same
+        optional detector) to contribute their own internal names.
+    '''
+
+    def is_internal_name( self, name: str ) -> bool:
+        prefix = f"_{package_name}_"
+        if not name.startswith( prefix ):
+            return False
+        body = name[ len( prefix ): ]
+        # Static stems: _{package}_{level}_{core}_, trailing underscore.
+        # The class-level behaviors and in_progress stems are stored
+        # mangled only, so they are excluded from static acceptance.
+        if body.endswith( '_' ):
+            level, _, core = body[ :-1 ].partition( '_' )
+            if level in _levels and core in _cores:
+                return not (
+                    'class' == level
+                    and f"{level}_{core}" in _mangled_cores )
+            return False
+        # Mangled forms: one of the mangled cores + 64 lowercase hex,
+        # no trailing underscore. The mangling accessors append digests
+        # to these stems only.
+        for mangled_core in _mangled_cores:
+            mangled_prefix = f"{mangled_core}_"
+            if body.startswith( mangled_prefix ):
+                suffix = body[ len( mangled_prefix ): ]
+                return (
+                    _digest_length == len( suffix )
+                    and all( c in _hex_digits for c in suffix ) )
+        return False
+
+    def __call__( self, level: str, core: str ) -> str:
+        return f"_{package_name}_{level}_{core}_"
+
+
+calculate_attrname = AttrnameCalculator( )
+
+
+def calculate_contribution_name( ) -> str:
+    ''' Returns metaclass attribute name holding internal-name detectors. '''
+    return f"_{package_name}_internal_names_"

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

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

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

@@ -54,12 +54,20 @@ def produce_class_constructor(
         # Some decorators create new classes, which invokes this method again.
         # Short-circuit to prevent recursive decoration and other tangles.
         progress_name = attributes_namer( 'class', 'in_progress' )
-        progress_name_m = _utilities.mangle_name( cls, progress_name )
-        in_progress = getattr( cls, progress_name_m, False )
+        progress_names = _utilities.survey_mangled_names( cls, progress_name )
+        in_progress = any(
+            getattr( cls, key, False ) for key in progress_names )
         if in_progress: return cls
+        progress_name_m = _utilities.mangle_name( cls, progress_name )
         setattr( cls, progress_name_m, True )
         for postprocessor in postprocessors: postprocessor( cls, decorators_ )
         cls = _decorators.apply_decorators( cls, decorators_ )
+        # Decoration may have replaced the class. Clear every marker
+        # variant, including ones inherited from the original namespace,
+        # so initialization completes regardless of qualname restoration.
+        progress_names = _utilities.survey_mangled_names( cls, progress_name )
+        for progress_name_ in progress_names:
+            setattr( cls, progress_name_, False )
         setattr( cls, progress_name_m, False )
         return cls
 
@@ -81,10 +89,11 @@ def produce_class_initializer(
         ''' Initializes class, applying hooks. '''
         superf( *posargs, **nomargs )
         progress_name = attributes_namer( 'class', 'in_progress' )
-        progress_name_m = _utilities.mangle_name( cls, progress_name )
-        in_progress = getattr( cls, progress_name_m, False )
+        progress_names = _utilities.survey_mangled_names( cls, progress_name )
+        in_progress = any(
+            getattr( cls, key, False ) for key in progress_names )
         if in_progress: return # If non-empty, then not top-level.
-        delattr( cls, progress_name_m )
+        for progress_name_m in progress_names: delattr( cls, progress_name_m )
         for completer in completers: completer( cls )
 
     return initialize

classcore-1.14/sources/classcore/standard/__.py

@@ -0,0 +1,106 @@
+# vim: set filetype=python fileencoding=utf-8:
+# -*- coding: utf-8 -*-
+
+#============================================================================#
+#                                                                            #
+#  Licensed under the Apache License, Version 2.0 (the "License");           #
+#  you may not use this file except in compliance with the License.          #
+#  You may obtain a copy of the License at                                   #
+#                                                                            #
+#      http://www.apache.org/licenses/LICENSE-2.0                            #
+#                                                                            #
+#  Unless required by applicable law or agreed to in writing, software       #
+#  distributed under the License is distributed on an "AS IS" BASIS,         #
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  #
+#  See the License for the specific language governing permissions and       #
+#  limitations under the License.                                            #
+#                                                                            #
+#============================================================================#
+
+
+''' Common constants, imports, and utilities. '''
+
+# ruff: noqa: F403, F405
+
+
+from ..__ import *
+from ..nomina import is_public_identifier
+
+
+def provide_error_class( name: str ) -> type[ Exception ]:
+    ''' Produces error class for this package. '''
+    match name:
+        case 'AttributeImmutability':
+            from ..exceptions import AttributeImmutability as error
+        case _:
+            from ..exceptions import ErrorProvideFailure
+            raise ErrorProvideFailure( name, reason = 'Does not exist.' )
+    return error
+
+
+mutables_default = ( )
+visibles_default = ( is_public_identifier, )
+
+# Standard library ABC machinery attribute names which the class-level
+# immutability behavior permits. The C _abc implementation writes these
+# cache attributes through direct dict access, so they must remain
+# assignable on standard classes. Also used to mark such names as
+# internal in attribute explanations.
+abc_class_mutables = (
+    '_abc_cache',
+    '_abc_negative_cache',
+    '_abc_negative_cache_version',
+    '_abc_registry',
+)
+# Standard library typing machinery attribute names which the
+# class-level immutability behavior permits on protocol classes.
+# 'typing' sets these protocol bookkeeping attributes during class
+# decoration: '_is_runtime_protocol' and '__non_callable_proto_members__'
+# in the 'runtime_checkable' decorator, and
+# '__typing_is_deprecated_inherited_runtime_protocol__' (CPython 3.15+)
+# during class decoration and in 'runtime_checkable'. Without this
+# exemption, decorating a runtime protocol which inherits runtime
+# checkability fails. Also used to mark such names as internal in
+# attribute explanations.
+typing_class_mutables = (
+    '_is_runtime_protocol',
+    '__non_callable_proto_members__',
+    '__typing_is_deprecated_inherited_runtime_protocol__', # Python 3.15+
+)
+
+
+def is_same_detector(
+    detector: cabc.Callable[ [ str ], bool ],
+    other: cabc.Callable[ [ str ], bool ], /,
+) -> bool:
+    ''' Returns whether two detector references are the same detector.
+
+        Bound methods are the same detector only when both the
+        underlying function and the bound instance are identical, so
+        distinct namer instances with distinct configured behavior keep
+        separate contributions. Plain callables compare by identity.
+    '''
+    if detector is other: return True
+    function = getattr( detector, '__func__', None )
+    other_function = getattr( other, '__func__', None )
+    if function is None or other_function is None: return False
+    return (
+        function is other_function
+        and getattr( detector, '__self__', None )
+            is getattr( other, '__self__', None ) )
+
+
+def augment_internal_names(
+    cls: type, /, detector: cabc.Callable[ [ str ], bool ]
+) -> None:
+    ''' Adds an internal-name detector to existing contributions.
+
+        Private wiring point for machinery mixins: the abstract-base
+        metaclass adds the stdlib machinery set after factory
+        decoration, without expanding public factory arguments.
+    '''
+    detectors = getattr( cls, calculate_contribution_name( ), ( ) )
+    if any( is_same_detector( detector, d ) for d in detectors ): return
+    setattr(
+        cls, calculate_contribution_name( ),
+        ( *detectors, detector ) )

{classcore-1.12 → classcore-1.14}/sources/classcore/standard/__init__.py

@@ -49,4 +49,5 @@ from . import nomina
 
 from .classes import *
 from .decorators import *
+from .explanations import *
 from .modules import *

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

@@ -58,34 +58,17 @@ def assign_attribute_if_mutable( # noqa: PLR0913
     value: __.typx.Any,
 ) -> None:
     ''' Assigns attribute if it is mutable, else raises error. '''
-    leveli = 'instance' if level == 'instances' else level
-    behaviors_name = attributes_namer( leveli, 'behaviors' )
-    behaviors = _utilities.getattr0( obj, behaviors_name, frozenset( ) )
+    behaviors = survey_active_behaviors(
+        obj, attributes_namer = attributes_namer, level = level )
     if _nomina.immutability_label not in behaviors:
         ligation( name, value )
         return
-    names_name = attributes_namer( level, 'mutables_names' )
-    names: _nomina.BehaviorExclusionNamesOmni = (
-        getattr( obj, names_name, frozenset( ) ) )
-    if names == '*' or name in names:
+    rule = provide_permitter_if_applicable(
+        obj, attributes_namer = attributes_namer,
+        level = level, basename = 'mutables', name = name )
+    if rule is not None:
         ligation( name, value )
         return
-    predicates_name = attributes_namer( level, 'mutables_predicates' )
-    predicates: _nomina.BehaviorExclusionPredicates = (
-        getattr( obj, predicates_name, ( ) ) )
-    for predicate in predicates:
-        if predicate( name ):
-            # TODO? Cache predicate hit.
-            ligation( name, value )
-            return
-    regexes_name = attributes_namer( level, 'mutables_regexes' )
-    regexes: _nomina.BehaviorExclusionRegexes = (
-        getattr( obj, regexes_name, ( ) ) )
-    for regex in regexes:
-        if regex.fullmatch( name ):
-            # TODO? Cache regex hit.
-            ligation( name, value )
-            return
     target = _utilities.describe_object( obj )
     raise error_class_provider( 'AttributeImmutability' )( name, target )
 
@@ -99,36 +82,147 @@ def delete_attribute_if_mutable( # noqa: PLR0913
     name: str,
 ) -> None:
     ''' Deletes attribute if it is mutable, else raises error. '''
-    leveli = 'instance' if level == 'instances' else level
-    behaviors_name = attributes_namer( leveli, 'behaviors' )
-    behaviors = _utilities.getattr0( obj, behaviors_name, frozenset( ) )
+    behaviors = survey_active_behaviors(
+        obj, attributes_namer = attributes_namer, level = level )
     if _nomina.immutability_label not in behaviors:
         ligation( name )
         return
-    names_name = attributes_namer( level, 'mutables_names' )
-    names: _nomina.BehaviorExclusionNamesOmni = (
-        getattr( obj, names_name, frozenset( ) ) )
-    if names == '*' or name in names:
+    rule = provide_permitter_if_applicable(
+        obj, attributes_namer = attributes_namer,
+        level = level, basename = 'mutables', name = name )
+    if rule is not None:
         ligation( name )
         return
-    predicates_name = attributes_namer( level, 'mutables_predicates' )
+    target = _utilities.describe_object( obj )
+    raise error_class_provider( 'AttributeImmutability' )( name, target )
+
+
+def determine_relevant_permitters(
+    objct: object, /, *,
+    attributes_namer: _nomina.AttributesNamer,
+    level: str,
+    basename: str,
+    name: str,
+) -> tuple[ tuple[ str, __.typx.Any ], ... ]:
+    ''' Returns exclusion rules matching name, in evaluation order.
+
+        A names match short-circuits, matching the survey core's
+        historical control flow: predicates and regexes are not evaluated
+        for a name found in the exclusion names. Otherwise a name may
+        match any number of predicates and any number of regexes. The
+        wildcard is not considered here; callers handle its
+        short-circuit separately.
+
+        Rules pair a kind ('names', 'predicate', 'regex') with the raw
+        matched verifier (name, predicate, or regex). Matching never
+        renders diagnostic text: enforcement and survey consult kind
+        and presence only, so exotic callables cannot disrupt them.
+        Render verifiers with 'render_verifier_text' at the record
+        layer when producing explanation records.
+    '''
+    names_name = attributes_namer( level, f"{basename}_names" )
+    names: _nomina.BehaviorExclusionNamesOmni = (
+        getattr( objct, names_name, frozenset( ) ) )
+    if name in names: return ( ( 'names', name ), )
+    predicates_name = attributes_namer( level, f"{basename}_predicates" )
     predicates: _nomina.BehaviorExclusionPredicates = (
-        getattr( obj, predicates_name, ( ) ) )
+        getattr( objct, predicates_name, ( ) ) )
+    matched: list[ tuple[ str, __.typx.Any ] ] = [
+        ( 'predicate', predicate )
+        for predicate in predicates if predicate( name ) ]
+    regexes_name = attributes_namer( level, f"{basename}_regexes" )
+    regexes: _nomina.BehaviorExclusionRegexes = (
+        getattr( objct, regexes_name, ( ) ) )
+    matched.extend(
+        ( 'regex', regex )
+        for regex in regexes if regex.fullmatch( name ) )
+    return tuple( matched )
+
+
+def provide_permitter_if_applicable(
+    objct: object, /, *,
+    attributes_namer: _nomina.AttributesNamer,
+    level: str,
+    basename: str,
+    name: str,
+) -> __.typx.Optional[ tuple[ str, __.typx.Any ] ]:
+    ''' Returns first exclusion rule permitting operation, else None.
+
+        Rules apply by precedence: omni or names membership, then
+        the first matching predicate, then the first matching regex.
+        Each rule pairs a kind ('omni', 'names', 'predicate', 'regex')
+        with the raw matched verifier. Matching never renders
+        diagnostic text: enforcement consults kind and presence only,
+        so exotic callables cannot disrupt it. Render the verifier
+        with 'render_verifier_text' at the record layer when producing
+        explanation records.
+    '''
+    names_name = attributes_namer( level, f"{basename}_names" )
+    names: _nomina.BehaviorExclusionNamesOmni = (
+        getattr( objct, names_name, frozenset( ) ) )
+    if names == '*': return ( 'omni', '*' )
+    if name in names: return ( 'names', name )
+    predicates_name = attributes_namer( level, f"{basename}_predicates" )
+    predicates: _nomina.BehaviorExclusionPredicates = (
+        getattr( objct, predicates_name, ( ) ) )
     for predicate in predicates:
         if predicate( name ):
-            # TODO? Cache predicate hit.
-            ligation( name )
-            return
-    regexes_name = attributes_namer( level, 'mutables_regexes' )
+            return ( 'predicate', predicate )
+    regexes_name = attributes_namer( level, f"{basename}_regexes" )
     regexes: _nomina.BehaviorExclusionRegexes = (
-        getattr( obj, regexes_name, ( ) ) )
+        getattr( objct, regexes_name, ( ) ) )
     for regex in regexes:
         if regex.fullmatch( name ):
-            # TODO? Cache regex hit.
-            ligation( name )
-            return
-    target = _utilities.describe_object( obj )
-    raise error_class_provider( 'AttributeImmutability' )( name, target )
+            return ( 'regex', regex )
+    return None
+
+
+def render_verifier_text( verifier: __.typx.Any, / ) -> str:
+    ''' Returns stable detail text for an exclusion verifier.
+
+        Regexes render as pattern text; predicates render as
+        fully-qualified name, with an anonymous fallback when no
+        qualified name is available. Strings do not reach this
+        function; they are classified as names before rendering. A
+        non-string 'pattern' attribute is not trusted as text; such
+        verifiers fall through to qualified-name rendering, where a
+        non-string qualified name falls back to '<anonymous>' while
+        a non-string module name preserves the qualified name.
+        Hostile metadata (raising descriptors, custom
+        '__getattribute__') yields '<unrenderable>' rather than
+        raising, so diagnostic rendering never disrupts its callers.
+        The broad 'except Exception' is deliberate: rendering is
+        diagnostics, and diagnostics must never break enforcement
+        or survey paths.
+
+        Note: the inspect utilities were considered and rejected here;
+        they resolve modules to objects and provide no qualified-name
+        rendering with an anonymous fallback, while this getattr chain
+        stays defensive for exotic callables (e.g., partials).
+    '''
+    try:
+        text = _render_verifier_text( verifier )
+    except Exception:
+        text = '<unrenderable>'
+    return text
+
+
+def survey_active_behaviors(
+    objct: object, /, *,
+    attributes_namer: _nomina.AttributesNamer,
+    level: str,
+) -> __.cabc.Set[ str ]:
+    ''' Returns active behaviors set for object at level.
+
+        This is the shared entry point of the behavior decision cascade:
+        every core first determines whether the governing behavior is
+        active before consulting exclusion configuration.
+    '''
+    leveli = 'instance' if level == 'instances' else level
+    behaviors_name = attributes_namer( leveli, 'behaviors' )
+    behaviors: __.cabc.Set[ str ] = (
+        _utilities.getattr0( objct, behaviors_name, frozenset( ) ) )
+    return behaviors
 
 
 def survey_visible_attributes(
@@ -139,35 +233,22 @@ def survey_visible_attributes(
 ) -> __.cabc.Iterable[ str ]:
     ''' Returns sequence of visible attributes. '''
     names_base = ligation( )
-    leveli = 'instance' if level == 'instances' else level
-    behaviors_name = attributes_namer( leveli, 'behaviors' )
-    behaviors = _utilities.getattr0( obj, behaviors_name, frozenset( ) )
+    behaviors = survey_active_behaviors(
+        obj, attributes_namer = attributes_namer, level = level )
     if _nomina.concealment_label not in behaviors: return names_base
     names_name = attributes_namer( level, 'visibles_names' )
     names: _nomina.BehaviorExclusionNamesOmni = (
         getattr( obj, names_name, frozenset( ) ) )
     if names == '*': return names_base # pragma: no branch
-    regexes_name = attributes_namer( level, 'visibles_regexes' )
-    regexes: _nomina.BehaviorExclusionRegexes = (
-        getattr( obj, regexes_name, ( ) ) )
-    predicates_name = attributes_namer( level, 'visibles_predicates' )
-    predicates: _nomina.BehaviorExclusionPredicates = (
-        getattr( obj, predicates_name, ( ) ) )
     names_: list[ str ] = [ ]
     for name in names_base:
-        if name in names:
-            names_.append( name )
-            continue
-        for predicate in predicates:
-            if predicate( name ):
-                # TODO? Cache predicate hit.
-                names_.append( name )
-                continue
-        for regex in regexes:
-            if regex.fullmatch( name ):
-                # TODO? Cache regex hit.
-                names_.append( name )
-                continue
+        matched = determine_relevant_permitters(
+            obj, attributes_namer = attributes_namer,
+            level = level, basename = 'visibles', name = name )
+        # Current behavior: one append per matched rule, so a name
+        # matching several rules is yielded several times. Preserved
+        # deliberately; normalization is a separate repair.
+        names_.extend( name for rule in matched )
     return names_
 
 
@@ -412,3 +493,21 @@ def _deduplicate_merge_sequences(
         if addend in augends_: continue
         result.append( addend )
     return tuple( result )
+
+
+def _render_verifier_text( verifier: __.typx.Any, / ) -> str:
+    ''' Returns detail text for an exclusion verifier, possibly raising.
+
+        Total rendering lives in 'render_verifier_text', which maps
+        hostile-metadata failures to the documented fallback. This
+        partial function holds the getattr chain so the wrapper has
+        no returns inside its guarded block.
+    '''
+    pattern = getattr( verifier, 'pattern', None )
+    if isinstance( pattern, str ): return pattern
+    qualname = getattr( verifier, '__qualname__', None )
+    if not isinstance( qualname, str ): return '<anonymous>'
+    module = getattr( verifier, '__module__', None )
+    if not isinstance( module, str ) or '<locals>' in qualname:
+        return qualname
+    return f"{module}.{qualname}"

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

@@ -27,14 +27,6 @@ from . import dynadoc as _dynadoc
 from . import nomina as _nomina
 
 
-_abc_class_mutables = (
-    '_abc_cache',
-    '_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
@@ -47,7 +39,12 @@ _protocol_attr_excluded = frozenset( {
     # 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__'.
+    # '__typing_is_deprecated_inherited_runtime_protocol__' is set by
+    # CPython 3.15+ typing on protocol classes which inherit runtime
+    # checkability; as a structural member it is vacuous since it records
+    # machinery provenance rather than a callable member.
     '__abstractmethods__', '__parameters__', '__init__', '__orig_bases__',
+    '__typing_is_deprecated_inherited_runtime_protocol__', # Python 3.15+
 } )
 _protocol_attr_prefixes = ( '_classcore_', '_abc_' )
 # Standard Python attributes present in every pre-decoration namespace.
@@ -130,6 +127,10 @@ class AbstractClass( Class, __.abc.ABCMeta ):
         registration) via a diamond hierarchy. `Class` itself remains
         backed by plain `type`, so ABC machinery applies only where this
         metaclass is used.
+
+        Contributes the stdlib ABC and typing machinery names as internal
+        for the classes it builds, mirroring the class_mutables exemption
+        scoping.
     '''
 
     _dynadoc_fragments_ = (
@@ -313,7 +314,7 @@ class ObjectMutable( metaclass = Class, instances_mutables = '*' ):
 
 class AbstractObject(
     metaclass = AbstractClass,
-    class_mutables = _abc_class_mutables,
+    class_mutables = __.abc_class_mutables,
 ):
     ''' Base class for abstract classes with standard behaviors.
 
@@ -348,7 +349,8 @@ class DataclassObjectMutable( metaclass = DataclassMutable ):
 class Protocol(
     __.typx.Protocol,
     metaclass = ProtocolClass,
-    class_mutables = _abc_class_mutables,
+    class_mutables = (
+        *__.abc_class_mutables, *__.typing_class_mutables ),
 ):
     ''' Standard base protocol class. '''
 
@@ -361,7 +363,8 @@ class Protocol(
 class ProtocolMutable(
     __.typx.Protocol,
     metaclass = ProtocolClass,
-    class_mutables = _abc_class_mutables,
+    class_mutables = (
+        *__.abc_class_mutables, *__.typing_class_mutables ),
     instances_mutables = '*',
 ):
     ''' Base protocol class with mutable instance attributes. '''
@@ -375,7 +378,8 @@ class ProtocolMutable(
 class DataclassProtocol(
     __.typx.Protocol,
     metaclass = ProtocolDataclass,
-    class_mutables = _abc_class_mutables,
+    class_mutables = (
+        *__.abc_class_mutables, *__.typing_class_mutables ),
 ):
     ''' Standard base protocol dataclass. '''
 
@@ -388,7 +392,8 @@ class DataclassProtocol(
 class DataclassProtocolMutable(
     __.typx.Protocol,
     metaclass = ProtocolDataclassMutable,
-    class_mutables = _abc_class_mutables,
+    class_mutables = (
+        *__.abc_class_mutables, *__.typing_class_mutables ),
 ):
     ''' Base protocol dataclass with mutable instance attributes. '''
 
@@ -434,3 +439,12 @@ class _CanaryProtocolImpl( _CanaryProtocolUse ):
 _canary_abstract: int = _CanaryAbstractObject( ).provide( )
 _canary_protocol_iface: _CanaryProtocolUse = _CanaryProtocolImpl( )
 _canary_greeting: str = _canary_protocol_iface.greet( )
+
+
+def _is_stdlib_machinery_name( name: str ) -> bool:
+    return (
+        name in __.abc_class_mutables
+        or name in __.typing_class_mutables )
+
+
+__.augment_internal_names( AbstractClass, _is_stdlib_machinery_name )

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

@@ -47,8 +47,10 @@ 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_ = _utilities.mangle_name( cls, behaviors_name )
+    # NOTE: The behaviors field is a dataclass field, so its name must
+    #       stay unmangled; mangling would desynchronize the field from
+    #       the slot or class attribute installed by the dataclass
+    #       machinery, which addresses it by its plain name.
     behaviors_name_ = behaviors_name
     annotations[ behaviors_name_ ] = set[ str ]
     setattr( cls, '__annotations__', annotations ) # in case of absence
@@ -83,6 +85,30 @@ def apply_cfc_core_functions(
         setattr( clscls, core_aname, core_function )
 
 
+def apply_internal_names(
+    cls: type, /,
+    attributes_namer: _nomina.AttributesNamer,
+) -> None:
+    ''' Records the namer's internal-name contribution, if any.
+
+        Works for metaclasses (contributions inherit to every class the
+        metaclass builds) and for decorator-path classes (contributions
+        ride the class itself, since plain decorated classes have no
+        custom metaclass). Parent wiring may already contribute the
+        same detector (e.g., a diamond re-running the factory with the
+        same namer); keep one of each by identity.
+    '''
+    detector: __.typx.Optional[ _nomina.InternalNameDetector ] = (
+        getattr( attributes_namer, 'is_internal_name', None ) )
+    if detector is None: return
+    detectors: _nomina.InternalNameDetectors = getattr(
+        cls, __.calculate_contribution_name( ), ( ) )
+    if any( __.is_same_detector( detector, d ) for d in detectors ): return
+    setattr(
+        cls, __.calculate_contribution_name( ),
+        ( *detectors, detector ) )
+
+
 def apply_cfc_dynadoc_configuration(
     clscls: type[ __.T ], /,
     attributes_namer: _nomina.AttributesNamer,
@@ -192,6 +218,8 @@ def class_factory( # noqa: PLR0913, PLR0917
             assigner_core = assigner_core,
             deleter_core = deleter_core,
             surveyor_core = surveyor_core )
+        apply_internal_names(
+            clscls, attributes_namer = attributes_namer )
         apply_cfc_dynadoc_configuration(
             clscls,
             attributes_namer = attributes_namer,
@@ -243,6 +271,8 @@ def produce_instances_inception_decorator( # noqa: PLR0913, PLR0917
         surveyor = _behaviors.survey_visible_attributes )
 
     def decorate( cls: type[ __.U ] ) -> type[ __.U ]:
+        apply_internal_names(
+            cls, attributes_namer = attributes_namer )
         for core_name in ( 'assigner', 'deleter', 'surveyor' ):
             core_function = _behaviors.access_core_function(
                 cls,

classcore-1.14/sources/classcore/standard/explanations.py

@@ -0,0 +1,253 @@
+# vim: set filetype=python fileencoding=utf-8:
+# -*- coding: utf-8 -*-
+
+#============================================================================#
+#                                                                            #
+#  Licensed under the Apache License, Version 2.0 (the "License");           #
+#  you may not use this file except in compliance with the License.          #
+#  You may obtain a copy of the License at                                   #
+#                                                                            #
+#      http://www.apache.org/licenses/LICENSE-2.0                            #
+#                                                                            #
+#  Unless required by applicable law or agreed to in writing, software       #
+#  under the License is distributed on an "AS IS" BASIS,                     #
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  #
+#  See the License for the specific language governing permissions and       #
+#  limitations under the License.                                            #
+#                                                                            #
+#============================================================================#
+
+
+''' Explanations of attribute behavior decisions. '''
+
+
+from .. import utilities as _utilities
+from . import __
+from . import behaviors as _behaviors
+from . import decorators as _decorators
+from . import nomina as _nomina
+
+
+_framework_names_prefix = '_classcore_'
+
+
+@_decorators.dataclass_with_standard_behaviors( )
+class Decision:
+    ''' Decision which one operation reached for one attribute.
+
+        The decision subclasses form a closed hierarchy; the decision
+        type is the discriminant. Verdict permissibility is derived
+        from the decision type.
+    '''
+
+
+@_decorators.dataclass_with_standard_behaviors( )
+class PermitByInapplicability( Decision ):
+    ''' Permission because the governing behavior is inactive. '''
+
+
+@_decorators.dataclass_with_standard_behaviors( )
+class PermitByOmni( Decision ):
+    ''' Permission by the omni marker, which permits every name. '''
+
+
+@_decorators.dataclass_with_standard_behaviors( )
+class PermitByNames( Decision ):
+    ''' Permission by exclusion names membership. '''
+    name: str
+
+
+@_decorators.dataclass_with_standard_behaviors( )
+class PermitByPredicate( Decision ):
+    ''' Permission by an exclusion predicate. '''
+    predicate: str
+
+
+@_decorators.dataclass_with_standard_behaviors( )
+class PermitByRegex( Decision ):
+    ''' Permission by an exclusion regex. '''
+    pattern: str
+
+
+@_decorators.dataclass_with_standard_behaviors( )
+class Prohibit( Decision ):
+    ''' Prohibition: the behavior is active and no rule permits. '''
+
+
+@_decorators.dataclass_with_standard_behaviors( )
+class Verdict:
+    ''' Verdict for one operation on one attribute. '''
+    operation: str
+    decision: Decision
+
+    @property
+    def permissible( self ) -> bool:
+        ''' Returns whether the operation is permissible. '''
+        return not isinstance( self.decision, Prohibit )
+
+
+@_decorators.dataclass_with_standard_behaviors( )
+class AssignVerdict( Verdict ):
+    ''' Verdict for attribute assignment. '''
+
+
+@_decorators.dataclass_with_standard_behaviors( )
+class DeleteVerdict( Verdict ):
+    ''' Verdict for attribute deletion. '''
+
+
+@_decorators.dataclass_with_standard_behaviors( )
+class SurveyVerdict( Verdict ):
+    ''' Verdict for attribute visibility in survey results. '''
+
+
+@_decorators.dataclass_with_standard_behaviors( )
+class AttributeExplanation:
+    ''' Decision trace for one attribute of one target. '''
+    target: str
+    name: str
+    behaviors: __.cabc.Mapping[ str, __.cabc.Set[ str ] ]
+    operations: __.cabc.Mapping[ str, Verdict ]
+    internal: bool
+
+    def __repr__( self ) -> str:
+        ''' Returns summary of the decision trace. '''
+        lines = [
+            f"{self.name!r} on {self.target}"
+            + ( ' [internal]' if self.internal else '' ) ]
+        for level, labels in self.behaviors.items( ):
+            lines.append(
+                f"behaviors: {', '.join( sorted( labels ) )}"
+                + f" ({level})" )
+        for operation in ( 'assign', 'delete', 'survey' ):
+            verdict = self.operations.get( operation )
+            if verdict is None: continue # pragma: no cover
+            lines.append( f"{operation}: {self._render( verdict.decision )}" )
+        return '\n'.join( lines )
+
+    def _render( self, decision: Decision, / ) -> str:
+        if isinstance( decision, PermitByInapplicability ):
+            return 'permitted (behavior inapplicable)'
+        if isinstance( decision, PermitByOmni ):
+            return "permitted by omni '*'"
+        if isinstance( decision, PermitByNames ):
+            return f"permitted by names {decision.name!r}"
+        if isinstance( decision, PermitByPredicate ):
+            return f"permitted by predicate {decision.predicate!r}"
+        if isinstance( decision, PermitByRegex ):
+            return f"permitted by regex {decision.pattern!r}"
+        if isinstance( decision, Prohibit ):
+            return 'prohibited (no permitting rule)'
+        raise ValueError( type( decision ) )
+
+
+def explain_attribute(
+    target: object, name: str, /, *,
+    attributes_namer: _nomina.AttributesNamer = __.calculate_attrname,
+) -> AttributeExplanation:
+    ''' Returns decision trace for attribute name on target.
+
+        All operations follow precedence semantics: omni, then names
+        membership, then the first matching predicate, then the first
+        matching regex; prohibition when the governing behavior is
+        active and nothing permits; permission by inapplicability when
+        the behavior is inactive. For class targets, the classes-level
+        configuration is evaluated; for instance targets, the
+        instances-level configuration is evaluated against the
+        instance's class hierarchy — matching the levels the behavior
+        cores evaluate. Records report the normalized level names
+        ('class' and 'instance') at which behaviors and exclusion
+        configuration were found. Explanations are observational: they
+        neither bypass nor alter concealment or immutability. They are
+        not side-effect-free for arbitrary callbacks, however:
+        producing a record invokes user predicates and internal-name
+        detectors to determine the same outcome the cores would.
+
+        Survey explanations describe normalized first-match semantics;
+        the survey core's current once-per-matching-rule duplication is
+        characterized as a defect whose repair is deferred separately.
+    '''
+    class_target = __.inspect.isclass( target )
+    level = 'class' if class_target else 'instances'
+    level_normalized = 'class' if class_target else 'instance'
+    behaviors = _behaviors.survey_active_behaviors(
+        target, attributes_namer = attributes_namer, level = level )
+    immutability = _nomina.immutability_label in behaviors
+    concealment = _nomina.concealment_label in behaviors
+    operations: dict[ str, Verdict ] = { }
+    for operation, verdict_class, basename, active in (
+        ( 'assign', AssignVerdict, 'mutables', immutability ),
+        ( 'delete', DeleteVerdict, 'mutables', immutability ),
+        ( 'survey', SurveyVerdict, 'visibles', concealment ),
+    ):
+        rule = (
+            _behaviors.provide_permitter_if_applicable(
+                target, attributes_namer = attributes_namer,
+                level = level, basename = basename, name = name )
+            if active else None )
+        operations[ operation ] = verdict_class(
+            operation = operation,
+            decision = produce_decision( rule, active ) )
+    return AttributeExplanation(
+        target = _utilities.describe_object( target ),
+        name = name,
+        behaviors = __.types.MappingProxyType(
+            { level_normalized: frozenset( behaviors ) } ),
+        operations = __.types.MappingProxyType( operations ),
+        internal = is_internal_name( target, name ) )
+
+
+def is_internal_name( target: object, name: str, / ) -> bool:
+    ''' Returns whether name is internal to the target's machinery.
+
+        Contributions are discovered on the metaclass chain: for a
+        class target, its metaclass method resolution order; for an
+        instance target, the metaclass resolution order of its type
+        (the metaclass chain is reached through the double type
+        transformation — the instance's own type resolution order
+        enumerates the class bases, never the metaclass). Decorator-
+        based classes carry their contributions on the class itself,
+        so the class resolution order is consulted as well. Each
+        contribution is a detector produced by the machinery which
+        built the class, so a name is internal only where the
+        machinery that generates it operates. Classification scope is
+        the machinery chain and is independent of per-class mutability
+        exemptions: a name may be internal on a class where it is not
+        mutable, and mutable where it is not internal.
+    '''
+    cls = target if __.inspect.isclass( target ) else type( target )
+    chains = (
+        type( cls ).__mro__, cls.__mro__ ) # Metaclass chain, then class.
+    contribution_name = __.calculate_contribution_name( )
+    for chain in chains:
+        for holder in chain:
+            contributions = holder.__dict__.get( contribution_name )
+            if not contributions: continue
+            for detector in contributions:
+                if detector( name ): return True
+    return False
+
+
+def produce_decision(
+    rule: __.typx.Optional[ tuple[ str, __.typx.Any ] ], active: bool, /
+) -> Decision:
+    ''' Returns decision for governing-behavior activity and first rule.
+
+        Rules are the (kind, raw verifier) pairs produced by
+        provide_permitter_if_applicable; the kind vocabulary matches the
+        omni/names/predicate/regex precedence stages. Verifier detail
+        text is rendered here, at the record layer, so enforcement
+        paths which consult the same rules never depend on rendering.
+    '''
+    if not active: return PermitByInapplicability( )
+    if rule is None: return Prohibit( )
+    kind, verifier = rule
+    if kind == 'omni': return PermitByOmni( )
+    if kind == 'names': return PermitByNames( name = verifier )
+    if kind == 'predicate':
+        return PermitByPredicate(
+            predicate = _behaviors.render_verifier_text( verifier ) )
+    if kind == 'regex':
+        return PermitByRegex(
+            pattern = _behaviors.render_verifier_text( verifier ) )
+    raise ValueError( kind )

{classcore-1.12 → classcore-1.14}/sources/classcore/standard/nomina.py

@@ -29,6 +29,10 @@ concealment_label = 'concealment'
 immutability_label = 'immutability'
 
 
+abc_class_mutables = __.abc_class_mutables
+typing_class_mutables = __.typing_class_mutables
+
+
 BehaviorExclusionNames: __.typx.TypeAlias = __.cabc.Set[ str ]
 BehaviorExclusionNamesOmni: __.typx.TypeAlias = (
     BehaviorExclusionNames | __.typx.Literal[ '*' ] )
@@ -45,6 +49,10 @@ BehaviorExclusionVerifiers: __.typx.TypeAlias = (
     __.cabc.Sequence[ BehaviorExclusionVerifier ] )
 BehaviorExclusionVerifiersOmni: __.typx.TypeAlias = (
     BehaviorExclusionVerifiers | __.typx.Literal[ '*' ] )
+InternalNameDetector: __.typx.TypeAlias = (
+    __.cabc.Callable[ [ str ], bool ] )
+InternalNameDetectors: __.typx.TypeAlias = (
+    __.cabc.Sequence[ InternalNameDetector ] )
 ErrorClassProvider: __.typx.TypeAlias = __.typx.Annotated[
     __.cabc.Callable[ [ str ], type[ Exception ] ],
     __.ddoc.Doc(

{classcore-1.12 → classcore-1.14}/sources/classcore/utilities.py

@@ -95,17 +95,42 @@ 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.
+    # NOTE: Mangling is based on the fully-qualified class name, not on id,
+    #       because class reproductions (e.g., from dataclass slots) must
+    #       retain identity of private attributes. A reproduction is a new
+    #       object, so id-based mangling would break such identity.
     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( )
     return f"{name}{namehash_hex}"
 
 
+def survey_mangled_names( cls: type, /, name: str ) -> tuple[ str, ... ]:
+    ''' Returns mangled variants of name present in class's own namespace.
+
+        A class reproduction (e.g., from ``dataclass( slots = ... )``) is
+        created with a bare ``__qualname__``, which is restored only after
+        the reproduction is constructed. During that window, mangled names
+        computed from the reproduction differ from those computed from the
+        original. Detection by prefix survives such qualname drift.
+    '''
+    suffix_start = len( name )
+    return tuple(
+        key for key in cls.__dict__
+        if key.startswith( name ) and _is_digest( key[ suffix_start: ] ) )
+
+
+_digest_length = 64 # Length of a hexadecimal SHA-256 digest.
+
+
+def _is_digest( text: str ) -> bool:
+    ''' Returns whether text is a hexadecimal SHA-256 digest. '''
+    return _digest_length == len( text ) and all(
+        character in '0123456789abcdef' for character in text )
+
+
 def qualify_class_name( cls: type ) -> str:
     ''' Returns fully-qualified class name. '''
     return f"{cls.__module__}.{cls.__qualname__}"

classcore-1.12/sources/classcore/__/nomina.py

@@ -1,36 +0,0 @@
-# vim: set filetype=python fileencoding=utf-8:
-# -*- coding: utf-8 -*-
-
-#============================================================================#
-#                                                                            #
-#  Licensed under the Apache License, Version 2.0 (the "License");           #
-#  you may not use this file except in compliance with the License.          #
-#  You may obtain a copy of the License at                                   #
-#                                                                            #
-#      http://www.apache.org/licenses/LICENSE-2.0                            #
-#                                                                            #
-#  Unless required by applicable law or agreed to in writing, software       #
-#  distributed under the License is distributed on an "AS IS" BASIS,         #
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  #
-#  See the License for the specific language governing permissions and       #
-#  limitations under the License.                                            #
-#                                                                            #
-#============================================================================#
-
-
-''' Common names and type aliases. '''
-
-
-from . import imports as __
-
-
-ComparisonResult: __.typx.TypeAlias = bool | __.types.NotImplementedType
-NominativeArguments: __.typx.TypeAlias = __.cabc.Mapping[ str, __.typx.Any ]
-PositionalArguments: __.typx.TypeAlias = __.cabc.Sequence[ __.typx.Any ]
-
-
-package_name = __name__.split( '.', maxsplit = 1 )[ 0 ]
-
-
-def calculate_attrname( level: str, core: str ) -> str:
-    return f"_{package_name}_{level}_{core}_"

classcore-1.12/sources/classcore/standard/__.py

@@ -1,42 +0,0 @@
-# vim: set filetype=python fileencoding=utf-8:
-# -*- coding: utf-8 -*-
-
-#============================================================================#
-#                                                                            #
-#  Licensed under the Apache License, Version 2.0 (the "License");           #
-#  you may not use this file except in compliance with the License.          #
-#  You may obtain a copy of the License at                                   #
-#                                                                            #
-#      http://www.apache.org/licenses/LICENSE-2.0                            #
-#                                                                            #
-#  Unless required by applicable law or agreed to in writing, software       #
-#  distributed under the License is distributed on an "AS IS" BASIS,         #
-#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  #
-#  See the License for the specific language governing permissions and       #
-#  limitations under the License.                                            #
-#                                                                            #
-#============================================================================#
-
-
-''' Common constants, imports, and utilities. '''
-
-# ruff: noqa: F403
-
-
-from ..__ import *
-from ..nomina import is_public_identifier
-
-
-def provide_error_class( name: str ) -> type[ Exception ]:
-    ''' Produces error class for this package. '''
-    match name:
-        case 'AttributeImmutability':
-            from ..exceptions import AttributeImmutability as error
-        case _:
-            from ..exceptions import ErrorProvideFailure
-            raise ErrorProvideFailure( name, reason = 'Does not exist.' )
-    return error
-
-
-mutables_default = ( )
-visibles_default = ( is_public_identifier, )