Create custom type hint for use with multimethod

[sylvorg]

Hello!

How would I go about creating a custom type hint for use with multimethod? I would like to check if an argument is iterable, a collection, etc. , but without considering strings; this is what I have so far:

from typing import Iterable
from multimethod import multimethod

def is_coll(coll):
    if isinstance(coll, (str, bytes, bytearray)):
        return False
    else:
        try:
            iter(coll)
        except TypeError:
            return isinstance(coll, Iterable)
        else:
            return True

class MetaColl(type):
    def __instancecheck__(cls, other):
        return is_coll(other)
    def __subclasscheck__(cls, other):
        return is_coll(other)


class Coll(metaclass=MetaColl):
    pass

@multimethod
def test(a: str):
    print(a)

@multimethod
def test(a: Coll):
    for item in a:
        print(item)

print(isinstance("Hello!", Coll)) # False
print(isinstance("Hello!".split(), Coll)) # True
test("Hello!") # False
test("Hello!".split()) # DispatchError: ('test: 0 methods found', (<class 'list'>,), set())

Thank you kindly for the help!

[coady]

1. The problem is Coll doesn't implement the subclass check correctly.

>>> issubclass(list, Coll)
False

2. Although there's nothing wrong with using metaclasses, there is a builtin subclass hook which can be easier.

class Coll(abc.ABC):
    @classmethod
    def __subclasshook__(cls, subclass):
        return issubclass(subclass, Iterable) and not issubclass(subclass, (str, bytes, bytearray))

>>> issubclass(list, Coll)
True
>>> issubclass(str, Coll)
False

3. This may not be necessary, because issubclass(str, Iterable). So if str is being matched, it will take precedence over Iterable anyway.

[sylvorg]

Okay, so I used the official definition of collections.abc.Iterable to create the following:

# Adapted From:
# Answer: https://stackoverflow.com/a/6416571
# User: https://stackoverflow.com/users/479633/mouad
def is_coll(
    coll: Any, func: Callable[[Any, type | tuple[type]], bool] = isinstance
) -> bool:
    return not func(coll, (str, bytes, bytearray)) and (
        func(coll, (Iterable, AsyncIterable)) or isgeneratorfunction(coll)
    )

class Coll(metaclass=ABCMeta):
    __slots__ = tuple()

    @classmethod
    def __subclasshook__(cls, C: Callable) -> bool:
        if cls is Coll:
            return is_coll(C, issubclass)
        return NotImplemented

    __class_getitem__ = classmethod(GenericAlias)

One thing I'm a little confused about is how are the types of C's inner items checked? Like Iterable[int] would assert that all of the iterable's items are integers, so how would that work for Coll[int], for example?

And for number 3, could you specify what you mean by "not be necessary"? Like, is Coll unnecessary, or is using issubclass(subclass, Iterable) unnecessary?