[Python-ideas] Re: Magnitude and ProtoMagnitude ABCs — primarily for argument validation

5 Mar 2020


      Steve Jorgensen wrote:
...
Steve Jorgensen wrote:
<snip>
> The problem I came up with trying to spike out my
> proposal last night is that there
> doesn't seem to be anyway to implement it without creating infinite recursion in the
> issublcass call. If I make Orderable a real or virtual subclass
> of ProtoOrderable and Orderable's __subclasshook__
> or metaclass __subclasscheck__ (I tried both ways) tries to check whether
> C is a subclass of ProtoOrderable, then an infinite recursion
> occurs.
> It wasn't immediately obvious to me why that is the case, but when I thought about it
> deeply, I can see why that must happen.
> An alternative that I thought about previously but seems very smelly to me for several
> reasons is to have both Orderable and NonOrderable ABCs. In that
> case, what should be done to prevent a class from being both orderable and non-orderable
> or figure out which should take precedence in that case?
> As a meta-solution (wild-assed idea) what if metaclass registration could accept
> keyword arguments, similar to passing keyword arguments to a class definition? That way,
> a
> single ABC (ProtoOrderable or whatever better name) could be a real or
> virtual subclass that is explicitly orderable or non-orderable depending on
> orderable=<True/False>.
> I have been unable to implement the class hierarchy that I proposed, and I think
I've determined that it's just not a practical fit with how the virtual bas class
mechanism works, so…
Maybe just a single TotalOrdered or TotalOrderable ABC with a
register_explicit_only method. The __subclasshook__ method would
skip the rich comparison methods check and return NotImplemented for any
class registered using register_explicit_only (or any of its true
subclasses).
The only weird edge case in the above is that is someone registers another ABC using
TotalOrdered.register_explicit_only and uses that as a virtual base class of
something else, the register_explicit_only registration will not apply to the
virtual subclass. I'm thinking that's completely acceptable as a known limitation if
documented?
Code spike of that idea:
```
from abc import ABCMeta
from weakref import WeakSet
class TotallyOrderable(metaclass=ABCMeta):
    _explicit_only_registry = WeakSet()
@classmethod
    def register_explicit_only(cls, C):
        if cls is not TotallyOrderable:
            raise NotImplementedError(
                f"{cls.__name__} does not implement 'register_explicit_only'")
cls._explicit_only_registry.add(C)
@classmethod
    def __subclasshook__(cls, C):
        if cls is not TotallyOrderable:
            return NotImplemented
for B in C.__mro__:
            if B in cls._explicit_only_registry:
                return NotImplemented
return cls._check_overrides_rich_comparison_methods(C)
@classmethod
    def _check_overrides_rich_comparison_methods(cls, C):
        mro = C.__mro__
        for method in ('__lt__', '__le__', '__gt__', '__ge__'):
            for B in mro:
                if B is not object and method in B.__dict__:
                    if B.__dict__[method] is None:
                        return NotImplemented
                    break
            else:
                return NotImplemented
        return True
```