[Feature Request] Bring typing aliases into beartype

[JakkuSakura]

As said in README.md, there are some compatibility problems with typing. Here's my compat.py. I hope similar thing exists in the beartype library.

Edit: bugfixes

import logging
import sys
from abc import *
from enum import Enum
from typing import (Any, Callable, Dict, Generic, Iterable, Iterator, List,
                    Optional, Set, Tuple, TypeVar, Union, cast) # Add more
from types import (FunctionType, MethodType)
# handle type annotation changes in PEP 3107, 484, 526, 544, 560, 563, 585
versions = (sys.version_info.major, sys.version_info.minor, sys.version_info.micro)
if versions > (3, 8, 8):
    Dict = dict
    List = list
    Set = set
    Tuple = tuple
    import collections.abc

    Iterable = collections.abc.Iterable
    Iterator = collections.abc.Iterator
    if versions >= (3, 9, 2):
        Callable = collections.abc.Callable
    else:
        Callable = collections.abc.Callable
        logging.warning("collections.abc.Callable in Python 3.9.1 is broken")

[langfield]

I've written a similar thing in case it's useful to anybody:

import re
import sys
import contextlib
import collections

# pylint: disable=unused-import

if sys.version_info >= (3, 9):
    Tuple = tuple
    List = list
    Dict = dict
    Set = set
    FrozenSet = frozenset
    Type = type

    Deque = collections.deque
    DefaultDict = collections.defaultdict
    OrderedDict = collections.OrderedDict
    Counter = collections.Counter
    ChainMap = collections.ChainMap

    Awaitable = collections.abc.Awaitable
    Coroutine = collections.abc.Coroutine
    AsyncIterable = collections.abc.AsyncIterable
    AsyncIterator = collections.abc.AsyncIterator
    AsyncGenerator = collections.abc.AsyncGenerator
    Iterable = collections.abc.Iterable
    Iterator = collections.abc.Iterator
    Generator = collections.abc.Generator
    Reversible = collections.abc.Reversible
    Container = collections.abc.Container
    Collection = collections.abc.Collection
    Callable = collections.abc.Callable
    MutableSet = collections.abc.MutableSet
    Mapping = collections.abc.Mapping
    MutableMapping = collections.abc.MutableMapping
    Sequence = collections.abc.Sequence
    MutableSequence = collections.abc.MutableSequence
    ByteString = collections.abc.ByteString
    MappingView = collections.abc.MappingView
    KeysView = collections.abc.KeysView
    ItemsView = collections.abc.ItemsView
    ValuesView = collections.abc.ValuesView

    ContextManager = contextlib.AbstractContextManager
    AsyncContextManager = (
        contextlib.AbstractAsyncContextManager
    )  # typing.AsyncContextManager
    Pattern = re.Pattern  # typing.Pattern, typing.re.Pattern
    Match = re.Match  # typing.Match, typing.re.Match

    from typing import Any, Optional, Annotated
else:
    from typing import Set, Dict, List, Tuple, FrozenSet, Type, Any, Optional
    from typing import (
        AbstractSet,
        Deque,
        DefaultDict,
        OrderedDict,
        Counter,
        ChainMap,
        Awaitable,
        Coroutine,
        AsyncIterable,
        AsyncIterator,
        AsyncGenerator,
        Iterable,
        Iterator,
        Generator,
        Reversible,
        Container,
        Collection,
        Callable,
        MutableSet,
        Mapping,
        MutableMapping,
        Sequence,
        MutableSequence,
        ByteString,
        MappingView,
        KeysView,
        ItemsView,
        ValuesView,
    )
    from typing import AsyncContextManager
    from typing.re import Pattern, Match
    from typing_extensions import Annotated

[leycec]

Absolutely. Thanks so much for yet another on-point feature request, Qiu. I for one remain convinced of your momentous intellect.

And thanks so much for the detailed implementation, William Blake. That's a superbly awesome launching pad! Would you mind if I built an official beartype.typing solution out from that? If we all cross our fingers enough, I might be able to excrete something marginally workable for our upcoming beartype 0.10.0 release in a few days.

Let us believe in the collective power of miracles. 🍯 🌈

[langfield]

@leycec That would be great!

[leycec]

[leycec]

...and so it begins.

[leycec]

...and so it ends.

[posita]

Stupid question: Is the idea here that one would import type aliases from beartype.typing instead of typing and get the "right" thing for environment?

# Silly rabbit, don't do this ...
import sys
if sys.version >= (3, 9):
  from collections.abc import Callable
  Dict = dict
else:
  from typing import Callable, Dict
# ... do this!
from beartype.typing import Callable, Dict

Or is it something else?

[leycec]

Be assured: you're a smarty. Despite scant to no documentation, your superior neocortex correctly deciphered objective reality from the inscrutable hieroglyphics I smeared all over the walls.

I obliquely documented this here and there, but neither really suffices. Ideally, I'd like to doctor up a straightforward "Beartype Typing" subsection shamefully copy-pasting your exact code snippet. For now, laziness prevails! 🥂

[posita]

I wonder if there's any value of that living in its own package within the…[drum roll]…Beartype Ecosystem™. At first glance, the dependencies on the…[another drum roll]…Beartype Flagship Library™ are minimal. 🤔

[leycec]

...heh. My bum left eye is now twitching. Laziness never prevails by doing more work, @posita! Never! That's how busyness prevails. The battle lines are drawn. Now, we heroic few are all called upon to choose a side.

Pragmatically, the remainder of the beartype codebase is being slyly refactored to preferentially import from beartype.typing rather than typing. Exporting beartype.typing to a new third-party beartype_typing package would mean adding our first mandatory runtime dependency to beartype, which would (in turn) complicate packaging beartype for everything other than the pip ecosystem. This means conda, brew, macports, and emerge. And @harens already got enough to do.

But that's not all... Resolving issue #54 "sanely" means redefining the @beartype.typing.overload decorator in a @beartype-specific manner – probably by internally refactoring beartype.typing to import from a new private beartype._overload submodule: e.g.,

# In "beartype.typing":
import beartype._overload.beartype_overload as overload

Yup. beartype.typing just went incestuous. Slash-and-burning beartype.typing into beartype_typing prevents us from going incestuous – which we gotta do to solve our problems.

Ultimately, the overarching goal for beartype.typing is to go The Borg on typing by assimilating and fundamentally repurposing all of the insane things in typing into less insane things. Bonus points if we do this like a masterless ninja on a moonlit night [read: without mypy or CPython devs noticing]. 😉

[posita]

I now stand educated, humbled, and grateful. Having achieved enlightenment (or at least what I assume is enlightenment, as my left eye is now twitching), I cannot help but look back upon the naiveté of my earlier inquiry as not even wrong. My many thanks for your customarily thorough treatment of this subject, no matter the carelessness or ignorance with which I raised it. 🙇💕

[leycec]

My Nordic Gods. You are so humble, gracious, and polite. Feels like living in downtown Tokyo all over again. Luvin' it! These ghostly nether shades (who I hope are hugging each other in their blueish next world – but it's kinda unclear) express my gratitude for your continual white-knight stance. 🫂 🫂 🫂 🫂

Especially in these interesting times (...eyes Eastern Europe uneasily), this world could do with substantially more humans like you – and less like those in positions of actual authority.