Update disinheritance.py

Refined methods to account for specific exemptions in target type MROs through refactoring and addition of methods; improved docstring

Author: stannielson

disinheritance.py

@@ -5,12 +5,14 @@
 
 from dataclasses import dataclass
 from functools import wraps
+from inspect import getabsfile
+from inspect import getmodule
 from types import MethodType
 
 
 __author__  = 'Stanton K. Nielson'
 __license__ = 'Unlicense'
-__version__ = '1.0.0'
+__version__ = '1.1.0'
 __status__  = 'Production'
 __date__    = '2025-07-09'
 
@@ -22,8 +24,25 @@ class disinherit:
 
     """decorator to remove access to inherited methods/attributes in an
     object type, except where specified by the exempt keyword argument
-    - functionally required "progenitor" object methods will be retained
-    - exemptions not part of MRO are ignored
+    
+    - exemptions are applied in order of argument declaration
+    
+    - exemptions not available through inheritance or overridden in the
+      target type are ignored
+      
+    - functionally required "origin" object methods will be retained
+    
+    - disinherited methods/attributes are replaced with NotImplemented in
+      the target type
+      
+      -> NotImplemented methods/attributes are ignored in dir() calls for
+         and produce an AttributeError when retrieved from target type
+         instances
+        
+      -> provides explicit status in help() call on target type
+      
+      -> use ensures reversion back to disinheritance if used for
+         assignment but deleted in instances
     """
 
     def __init__(self, *, exempt: type | MethodType |
@@ -42,56 +61,97 @@ def in_type(cls, target: type, exempt: type | MethodType |
         """disinherits methods/attributes from a target type, except for
         required methods and specified exemptions
         """
-        for i in cls._get_invalid_names(target, exempt):
-            setattr(target, i, NotImplemented)
+        mro_map = cls._map_mro(target)
+        exempt = cls._coerce_exempt(mro_map, exempt)
+        invalid = cls._get_invalid_names(target, mro_map, exempt)
+        for name in invalid: setattr(target, name, NotImplemented)
+        target_map = dict((k, v) for k, v in cls._map_type(target).items()
+                          if k not in invalid)
+        for exempt_map in exempt.values():
+            for name, value in exempt_map.items():
+                if name not in target_map:
+                    setattr(target, name, value)
         cls._wrap_dir(target)
         cls._wrap_getter(target)
         return target
 
     @classmethod
-    def _coerce_exempt(cls, exempt: list | tuple | set | type) -> list:
+    def _coerce_exempt(cls, mro_map: dict, exempt: type | MethodType |
+                       list | tuple | set = None) -> dict[str, dict]:
         """internal class method to coerce exemptions for disinheritance
-        to a set of methods/attributes
+        to a mapping of methods/attributes
         """
-        if exempt is None: return set()
+        if exempt is None: return dict()
         elif not isinstance(exempt, (list, tuple, set)):
             exempt = [exempt]
-        exempt, coerced = list(exempt), set()
+        elif not isinstance(exempt, list):
+            try: exempt = list(exempt)
+            except: return dict()
+        exempt = list(i for i in exempt if hasattr(i, '__objclass__')
+                      or isinstance(i, type))
+        coerced = dict()
         for i in exempt:
             if isinstance(i, type):
-                coerced |= set(cls._map_type(i).values())
-            else:
-                try: coerced.add(i)
-                except: pass
-        return list(coerced)
+                coerced[cls._make_type_key(i)] = cls._map_type(i)
+            else: 
+                key = cls._make_type_key(i.__objclass__)
+                submap = {i.__name__: i}
+                try: coerced[key].update(submap)
+                except: coerced[key] = submap
+        coerced = dict((k, v) for k, v in coerced.items()
+                       if k in mro_map)
+        return coerced
 
     @classmethod
-    def _get_invalid_names(
-        cls, target: type,
-        exempt: list | tuple | set | type = None) -> set[str]:
+    def _get_invalid_names(cls, target: type, mro_map: dict,
+                           exempt: dict) -> set[str]:
         """internal class method to identify names of methods/attributes
         considered invalid in the target subclass (unless part of exempted
         methods/attributes)
         """
-        exempt = cls._coerce_exempt(exempt)
-        current, *ancestors, progenitor = target.mro()
-        required = dict(
-            (k, v) for k, v in cls._map_type(progenitor).items()
-            if len(k.strip('_')) > 2)
-        valid, invalid = dict(vars(target)), set()
-        for ancestor in ancestors:
-            type_invalid = cls._map_type(ancestor)
-            type_invalid.pop('__dict__', None)
-            for k, v in required.items():
-                type_invalid.pop(k, None)
-            for k, v in valid.items():
-                if k in type_invalid and v != type_invalid[k]:
-                    type_invalid.pop(k)
-            type_invalid = dict((k, v) for k, v in type_invalid.items()
-                              if v is NotImplemented or v not in exempt)
+        *ancestor_keys, _ = list(mro_map)[1:]
+        required = set(
+            i for i in cls._map_type(object) if len(i.strip('_')) > 2)
+        valid, invalid = set(vars(target)), set()
+        for key in ancestor_keys:
+            type_invalid = dict(
+                (name, value) for name, value in mro_map[key].items()
+                if all((name not in required, name not in valid,
+                        name not in exempt.get(key, set()),
+                        name != '__dict__')))
             invalid |= set(type_invalid)
         return invalid
 
+    @classmethod
+    def _make_type_key(cls, target: type) -> str:
+        """internal class method to create a nominally unique key for a
+        target type based on its module file location (or module name)
+        and its own name; intended to account for conflicting type names
+        in a target MRO
+        """
+        if not isinstance(target, type):
+            error = TypeError(f'{repr(target)} not a valid type')
+            raise error
+        try:
+            name = target.__name__
+            try: source = getabsfile(target)
+            except: source = getmodule(target).__name__
+            return f'{source}->{repr(name)}'
+        except Exception as e:
+            error = TypeError(
+                f'cannot determine origin of {repr(target)} as a type')
+            raise error
+        return
+
+    @classmethod
+    def _map_mro(cls, target: type) -> dict:
+        """internal class method to map the MRO of a target type with
+        nominally unique key references for types and associated method/
+        attribute mappings by name and value
+        """
+        return dict((cls._make_type_key(i), cls._map_type(i))
+                    for i in target.mro())
+
     @classmethod
     def _map_type(cls, target: type) -> dict:
         """internal class method to return mapping of names and associated
@@ -130,4 +190,4 @@ def __getattribute__(self, name: str):
             return result
         if __getattribute__ != getter_base:
             target.__getattribute__ = __getattribute__    
-        return   
+        return