Fix OrderedBiMap so that it works in annotations (#253)

The easiest way to do this is to backport `typing.OrderedDict`, in a new `ga._backports` module.
This is private, so that unlike `utils`, we can remove it as soon as we don't need it any more.

Author: eric-wieser

galgebra/_backports/__init__.py

@@ -0,0 +1,5 @@
+"""
+Backports of library components from newer python versions.
+
+For internal use only.
+"""

galgebra/_backports/typing.py

@@ -0,0 +1,16 @@
+import sys
+
+# shim for typing.OrderedDict
+if sys.version_info >= (3, 7, 2):
+    from typing import OrderedDict
+else:
+    from typing import TypeVar, Mapping
+    import collections
+
+    K = TypeVar('K')
+    V = TypeVar('K')
+
+    class OrderedDict(collections.OrderedDict, Mapping[K, V]):
+        pass
+
+    del K, V, TypeVar, Mapping, collections

galgebra/ga.py

@@ -4,11 +4,11 @@
 import warnings
 import operator
 import copy
-from collections import OrderedDict
 from itertools import combinations
 import functools
 from functools import reduce
-from typing import Tuple, TypeVar, Callable, Mapping
+from typing import Tuple, TypeVar, Callable
+from ._backports.typing import OrderedDict
 
 from sympy import (
     diff, Rational, Symbol, S, Mul, Add,
@@ -170,15 +170,19 @@ def _map(self, func: Callable[[_T], _U]) -> 'GradedTuple[_U]':
         )
 
 
-class OrderedBiMap(OrderedDict, Mapping):
+_K = TypeVar('K')
+_V = TypeVar('V')
+
+
+class OrderedBiMap(OrderedDict[_K, _V]):
     """ A dict with an ``.inverse`` attribute mapping in the other direction """
     def __init__(self, items):
         # set up the inverse mapping, bypassing our __init__
         self.inverse = OrderedBiMap.__new__(type(self))
 
         # populate both
-        OrderedDict.__init__(self, items)
-        OrderedDict.__init__(self.inverse, [(v, k) for k, v in items])
+        super(OrderedBiMap, self).__init__(items)
+        super(OrderedBiMap, self.inverse).__init__([(v, k) for k, v in items])
 
         # and complete the inverse loop
         self.inverse.inverse = self

test/test_misc.py

@@ -0,0 +1,14 @@
+from galgebra.ga import OrderedBiMap
+
+
+class TestOrderedBiMap:
+
+    def test_inverse(self):
+        d = OrderedBiMap([('one', 1), ('two', 2)])
+        assert d.inverse == OrderedBiMap([(1, 'one'), (2, 'two')])
+        assert d.inverse.inverse is d
+
+    def test_annotation(self):
+        # check that we can use this like a generic type
+        def foo() -> OrderedBiMap[str, int]:
+            pass