Fix typing for python 3.7 (#2393)

* Fix typing for python 3.7

* Fix mypy, check sys.version_info instead of using try/catch

* Better way of checking version

Author: matt-gardner

allennlp/semparse/domain_languages/domain_language.py

@@ -1,7 +1,8 @@
 from collections import defaultdict
-from typing import Any, Callable, CallableMeta, Dict, GenericMeta, List, Set, Tuple, Type, Union  # type: ignore
+from typing import Any, Callable, Dict, List, Set, Tuple, Type, Union
 import inspect
 import logging
+import sys
 import traceback
 import types
 
@@ -12,6 +13,41 @@
 
 logger = logging.getLogger(__name__)
 
+
+# We rely heavily on the typing module and its type annotations for our grammar induction code.
+# Unfortunately, the behavior of the typing module changed somewhat substantially between python
+# 3.6 and 3.7, so we need to do some gymnastics to get some of our checks to work with both.
+# That's what these three methods are about.
+
+def is_callable(type_: Type) -> bool:
+    if sys.version_info < (3, 7):
+        from typing import CallableMeta  # type: ignore
+        return isinstance(type_, CallableMeta)  # type: ignore
+    else:
+        return getattr(type_, '_name', None) == 'Callable'
+
+
+def is_generic(type_: Type) -> bool:
+    if sys.version_info < (3, 7):
+        from typing import GenericMeta  # type: ignore
+        return isinstance(type_, GenericMeta)  # type: ignore
+    else:
+        # pylint: disable=protected-access
+        from typing import _GenericAlias  # type: ignore
+        return isinstance(type_, _GenericAlias) # type: ignore
+
+
+def get_generic_name(type_: Type) -> str:
+    if sys.version_info < (3, 7):
+        origin = type_.__origin__.__name__
+    else:
+        # In python 3.7, type_.__origin__ switched to the built-in class, instead of the typing
+        # class.
+        origin = type_._name  # pylint: disable=protected-access
+    args = type_.__args__
+    return f'{origin}[{",".join(arg.__name__ for arg in args)}]'
+
+
 class PredicateType:
     """
     A base class for `types` in a domain language.  This serves much the same purpose as
@@ -31,17 +67,15 @@ def get_type(type_: Type) -> 'PredicateType':
         those specially, so that the ``name`` for the ``BasicType`` remains ``List[str]``, as you
         would expect.
         """
-        if isinstance(type_, CallableMeta):
+        if is_callable(type_):
             callable_args = type_.__args__
             argument_types = [PredicateType.get_type(t) for t in callable_args[:-1]]
             return_type = PredicateType.get_type(callable_args[-1])
             return FunctionType(argument_types, return_type)
-        elif isinstance(type_, GenericMeta):
-            # This is something like List[int].  type_.__name__ will only give 'List', though, so
-            # we need to do some magic here.
-            origin = type_.__origin__
-            args = type_.__args__
-            name = f'{origin.__name__}[{",".join(arg.__name__ for arg in args)}]'
+        elif is_generic(type_):
+            # This is something like List[int].  type_.__name__ doesn't do the right thing (and
+            # crashes in python 3.7), so we need to do some magic here.
+            name = get_generic_name(type_)
         else:
             name = type_.__name__
         return BasicType(name)