Issues with conditional imports

[JukkaL]

Even though #649 was closed, there still remains several issues related to conditional imports. This issue is a top-level issue for these.

Related, more specific issues:

• Can't redefine name imported from another module #591
• Conditional class import #1107
• mypy bug with try/except conditional imports #1153
• Conditional import of izip is problematic #1026

[gvanrossum]

Also #1289.

[JukkaL]

Also #1327.

[JukkaL]

And #1334.

[cjerdonek]

I found that the following pattern can be used as a workaround in cases where you want to set a failed import to None on a failed import and still have the revealed type be Union[_importlib_modulespec.ModuleType, None] afterwards:

try:
    from pip._vendor import colorama as _colorama
 except Exception:
    colorama = None
else:
    colorama = _colorama

This is to avoid the following error in the except block:

Incompatible types in assignment (expression has type "None", variable has type Module)

[emmatyping]

As a (more) general solution to this problem, perhaps we could treat blocks like:

try:
    from foo import A
except ImportError:
    A = None

as A = TypeVar('A', foo.A, None)

and

try:
    from foo import A
except ImportError:
    from bar import A # ( or even from bar import AA as A)

as A = TypeVar('A', foo.A, bar.A)

And so on.

This is nice because you can do things like

from typing import TypeVar


class A:
    def __add__(self, a: A) -> str:
        ...
        
class AA:
    def __add__(self, a: AA) -> str:
        ...
        
T = TypeVar('T', A, AA)

def add(a: T, b: T) -> T:
    return a + b

if A overrides __add__ and the like.

This would lead to two issues:

1. isinstance/issubclass would be broken, this should be easy to fix, as we just need to silence the warning for the special form (the type var would only exist in mypy)

2. This would lead to many more unsolved type variables (which currently will result in Anys). Perhaps we can have unsolved but bounded type variables generate more Unions of their bounds?

For example, if you call the add function above with two variables of type T, you will get an Any, which is clearly not desirable, but if we change things so that you get Union[A, AA], this may be possible?

Hopefully this suggestion makes sense, let me know if there are questions or holes I am missing.

[JukkaL]

An interesting idea! Treating conditionally imported types as type variables probably wouldn't work in some basic use cases, unfortunately. Here are some things that could cause trouble:

• Using an unbound type variable as the type of a variable is not supported.
• A base class such as List[A] would make the class a generic class, which could be surprising.
• Various error messages related to type variable could be confusing.
• Having a type variable as the return type (say, in def f() -> A: ...) would result in unresolved type variables on most call sites, as you pointed out.
• Fairly often a conditional import would be used for Python 2/3 compatibility, and only one of the target modules will exist on the target Python version.

Some of these could be improved/fixed, but there may be other problematic things that we don't know about yet.