retrofitted 0.18 changes

1 files changed, 36 insertions, 53 deletions

diff --git a/resolver.py b/resolver.py
index 969b9a9..e7ed6d9 100644
--- a/resolver.py
+++ b/resolver.py
@@ -2,11 +2,10 @@
 
 import re
 
-if False:  # MYPY
-    from typing import Any, Dict, List, Union, Text, Optional  # NOQA
-    from ruamel.yaml.compat import VersionType  # NOQA
+from typing import Any, Dict, List, Union, Text, Optional  # NOQA
+from ruamel.yaml.compat import VersionType  # NOQA
 
-from ruamel.yaml.compat import _DEFAULT_YAML_VERSION, _F  # NOQA
+from ruamel.yaml.compat import _DEFAULT_YAML_VERSION  # NOQA
 from ruamel.yaml.error import *  # NOQA
 from ruamel.yaml.nodes import MappingNode, ScalarNode, SequenceNode  # NOQA
 from ruamel.yaml.util import RegExp  # NOQA
@@ -107,21 +106,19 @@ class BaseResolver:
     DEFAULT_SEQUENCE_TAG = 'tag:yaml.org,2002:seq'
     DEFAULT_MAPPING_TAG = 'tag:yaml.org,2002:map'
 
-    yaml_implicit_resolvers = {}  # type: Dict[Any, Any]
-    yaml_path_resolvers = {}  # type: Dict[Any, Any]
+    yaml_implicit_resolvers: Dict[Any, Any] = {}
+    yaml_path_resolvers: Dict[Any, Any] = {}
 
-    def __init__(self, loadumper=None):
-        # type: (Any, Any) -> None
+    def __init__(self: Any, loadumper: Any = None) -> None:
         self.loadumper = loadumper
         if self.loadumper is not None and getattr(self.loadumper, '_resolver', None) is None:
             self.loadumper._resolver = self.loadumper
-        self._loader_version = None  # type: Any
-        self.resolver_exact_paths = []  # type: List[Any]
-        self.resolver_prefix_paths = []  # type: List[Any]
+        self._loader_version: Any = None
+        self.resolver_exact_paths: List[Any] = []
+        self.resolver_prefix_paths: List[Any] = []
 
     @property
-    def parser(self):
-        # type: () -> Any
+    def parser(self) -> Any:
         if self.loadumper is not None:
             if hasattr(self.loadumper, 'typ'):
                 return self.loadumper.parser
@@ -129,8 +126,7 @@ class BaseResolver:
         return None
 
     @classmethod
-    def add_implicit_resolver_base(cls, tag, regexp, first):
-        # type: (Any, Any, Any) -> None
+    def add_implicit_resolver_base(cls, tag: Any, regexp: Any, first: Any) -> None:
         if 'yaml_implicit_resolvers' not in cls.__dict__:
             # deepcopy doesn't work here
             cls.yaml_implicit_resolvers = dict(
@@ -142,8 +138,7 @@ class BaseResolver:
             cls.yaml_implicit_resolvers.setdefault(ch, []).append((tag, regexp))
 
     @classmethod
-    def add_implicit_resolver(cls, tag, regexp, first):
-        # type: (Any, Any, Any) -> None
+    def add_implicit_resolver(cls, tag: Any, regexp: Any, first: Any) -> None:
         if 'yaml_implicit_resolvers' not in cls.__dict__:
             # deepcopy doesn't work here
             cls.yaml_implicit_resolvers = dict(
@@ -159,8 +154,7 @@ class BaseResolver:
     # def add_implicit_resolver(cls, tag, regexp, first):
 
     @classmethod
-    def add_path_resolver(cls, tag, path, kind=None):
-        # type: (Any, Any, Any) -> None
+    def add_path_resolver(cls, tag: Any, path: Any, kind: Any = None) -> None:
         # Note: `add_path_resolver` is experimental.  The API could be changed.
         # `new_path` is a pattern that is matched against the path from the
         # root to the node that is being considered.  `node_path` elements are
@@ -175,7 +169,7 @@ class BaseResolver:
         # against a sequence value with the index equal to `index_check`.
         if 'yaml_path_resolvers' not in cls.__dict__:
             cls.yaml_path_resolvers = cls.yaml_path_resolvers.copy()
-        new_path = []  # type: List[Any]
+        new_path: List[Any] = []
         for element in path:
             if isinstance(element, (list, tuple)):
                 if len(element) == 2:
@@ -184,9 +178,7 @@ class BaseResolver:
                     node_check = element[0]
                     index_check = True
                 else:
-                    raise ResolverError(
-                        _F('Invalid path element: {element!s}', element=element)
-                    )
+                    raise ResolverError(f'Invalid path element: {element!s}')
             else:
                 node_check = None
                 index_check = element
@@ -201,13 +193,9 @@ class BaseResolver:
                 and not isinstance(node_check, str)
                 and node_check is not None
             ):
-                raise ResolverError(
-                    _F('Invalid node checker: {node_check!s}', node_check=node_check)
-                )
+                raise ResolverError(f'Invalid node checker: {node_check!s}')
             if not isinstance(index_check, (str, int)) and index_check is not None:
-                raise ResolverError(
-                    _F('Invalid index checker: {index_check!s}', index_check=index_check)
-                )
+                raise ResolverError(f'Invalid index checker: {index_check!s}')
             new_path.append((node_check, index_check))
         if kind is str:
             kind = ScalarNode
@@ -216,11 +204,10 @@ class BaseResolver:
         elif kind is dict:
             kind = MappingNode
         elif kind not in [ScalarNode, SequenceNode, MappingNode] and kind is not None:
-            raise ResolverError(_F('Invalid node kind: {kind!s}', kind=kind))
+            raise ResolverError(f'Invalid node kind: {kind!s}')
         cls.yaml_path_resolvers[tuple(new_path), kind] = tag
 
-    def descend_resolver(self, current_node, current_index):
-        # type: (Any, Any) -> None
+    def descend_resolver(self, current_node: Any, current_index: Any) -> None:
         if not self.yaml_path_resolvers:
             return
         exact_paths = {}
@@ -242,15 +229,15 @@ class BaseResolver:
         self.resolver_exact_paths.append(exact_paths)
         self.resolver_prefix_paths.append(prefix_paths)
 
-    def ascend_resolver(self):
-        # type: () -> None
+    def ascend_resolver(self) -> None:
         if not self.yaml_path_resolvers:
             return
         self.resolver_exact_paths.pop()
         self.resolver_prefix_paths.pop()
 
-    def check_resolver_prefix(self, depth, path, kind, current_node, current_index):
-        # type: (int, Any, Any, Any, Any) -> bool
+    def check_resolver_prefix(
+        self, depth: int, path: Any, kind: Any, current_node: Any, current_index: Any
+    ) -> bool:
         node_check, index_check = path[depth - 1]
         if isinstance(node_check, str):
             if current_node.tag != node_check:
@@ -272,8 +259,7 @@ class BaseResolver:
                 return False
         return True
 
-    def resolve(self, kind, value, implicit):
-        # type: (Any, Any, Any) -> Any
+    def resolve(self, kind: Any, value: Any, implicit: Any) -> Any:
         if kind is ScalarNode and implicit[0]:
             if value == "":
                 resolvers = self.yaml_implicit_resolvers.get("", [])
@@ -298,8 +284,7 @@ class BaseResolver:
             return self.DEFAULT_MAPPING_TAG
 
     @property
-    def processing_version(self):
-        # type: () -> Any
+    def processing_version(self) -> Any:
         return None
 
 
@@ -320,24 +305,25 @@ class VersionedResolver(BaseResolver):
     and Yes/No/On/Off booleans.
     """
 
-    def __init__(self, version=None, loader=None, loadumper=None):
-        # type: (Optional[VersionType], Any, Any) -> None
+    def __init__(
+        self, version: Optional[VersionType] = None, loader: Any = None, loadumper: Any = None
+    ) -> None:
         if loader is None and loadumper is not None:
             loader = loadumper
         BaseResolver.__init__(self, loader)
         self._loader_version = self.get_loader_version(version)
-        self._version_implicit_resolver = {}  # type: Dict[Any, Any]
+        self._version_implicit_resolver: Dict[Any, Any] = {}
 
-    def add_version_implicit_resolver(self, version, tag, regexp, first):
-        # type: (VersionType, Any, Any, Any) -> None
+    def add_version_implicit_resolver(
+        self, version: VersionType, tag: Any, regexp: Any, first: Any
+    ) -> None:
         if first is None:
             first = [None]
         impl_resolver = self._version_implicit_resolver.setdefault(version, {})
         for ch in first:
             impl_resolver.setdefault(ch, []).append((tag, regexp))
 
-    def get_loader_version(self, version):
-        # type: (Optional[VersionType]) -> Any
+    def get_loader_version(self, version: Optional[VersionType]) -> Any:
         if version is None or isinstance(version, tuple):
             return version
         if isinstance(version, list):
@@ -346,8 +332,7 @@ class VersionedResolver(BaseResolver):
         return tuple(map(int, version.split('.')))
 
     @property
-    def versioned_resolver(self):
-        # type: () -> Any
+    def versioned_resolver(self) -> Any:
         """
         select the resolver based on the version we are parsing
         """
@@ -360,8 +345,7 @@ class VersionedResolver(BaseResolver):
                     self.add_version_implicit_resolver(version, x[1], x[2], x[3])
         return self._version_implicit_resolver[version]
 
-    def resolve(self, kind, value, implicit):
-        # type: (Any, Any, Any) -> Any
+    def resolve(self, kind: Any, value: Any, implicit: Any) -> Any:
         if kind is ScalarNode and implicit[0]:
             if value == "":
                 resolvers = self.versioned_resolver.get("", [])
@@ -386,8 +370,7 @@ class VersionedResolver(BaseResolver):
             return self.DEFAULT_MAPPING_TAG
 
     @property
-    def processing_version(self):
-        # type: () -> Any
+    def processing_version(self) -> Any:
         try:
             version = self.loadumper._scanner.yaml_version
         except AttributeError: