from abc import ABCMeta, abstractmethod
from six import add_metaclass
from typing import TypeVar, Type

@add_metaclass(ABCMeta)
class User(object):
    @abstractmethod
    def foo(self):
        pass

class BasicUser(User):
    def foo(self):
        return 'yay'

try:
    u = User()   # This fails correctly.
except TypeError:
    pass
basic = BasicUser()


# Using a TypeVar
U = TypeVar('U', bound=User)
def new_user(user_class):
    # type: (Type[U]) -> U
    user = user_class()   # This passes typechecking.
    return user

joe = new_user(BasicUser)
try:
    jo2 = new_user(User)   # This should probably fail but doesn't.
except TypeError:
    pass


# Not using a TypeVar
def new_user2(user_class):
    # type: (Type[User]) -> User
    user = user_class()    # This fails typecheck.
    return user

jar = new_user2(BasicUser)
try:
    ja2 = new_user2(User)
except TypeError:
    pass

def new_user3(user_class_fn):
    # type: (Callable[[], User]) -> User
    user = user_class_fn()
    return user

def get_basic_user():
    # type: () -> User
    return BasicUser()

def get_user():
    # type: () -> User
    return User()  # this fails correctly

jar = new_user3(get_basic_user)
try:
    ja2 = new_user3(get_user)
except TypeError:
    pass