From 9ac44a0873d51d63150b0f1dc1d009b206577a29 Mon Sep 17 00:00:00 2001 From: Anthon van der Neut Date: Tue, 21 Mar 2017 17:18:18 +0100 Subject: update for mypy --strict, prepare de-inheritance (Loader/Dumper) --- resolver.py | 77 +++++++++++++++++++++++++++++++++++++++---------------------- 1 file changed, 49 insertions(+), 28 deletions(-) (limited to 'resolver.py') diff --git a/resolver.py b/resolver.py index 38546ac..eab1b41 100644 --- a/resolver.py +++ b/resolver.py @@ -4,11 +4,11 @@ from __future__ import absolute_import import re -from typing import Any, Dict # NOQA +from typing import Any, Dict, List, Union # NOQA from ruamel.yaml.error import * # NOQA from ruamel.yaml.nodes import * # NOQA -from ruamel.yaml.compat import string_types +from ruamel.yaml.compat import string_types, VersionType # NOQA __all__ = ['BaseResolver', 'Resolver', 'VersionedResolver'] @@ -100,11 +100,21 @@ class BaseResolver(object): yaml_implicit_resolvers = {} # type: Dict[Any, Any] yaml_path_resolvers = {} # type: Dict[Any, Any] - def __init__(self): - # type: () -> None - self._loader_version = None - self.resolver_exact_paths = [] - self.resolver_prefix_paths = [] + def __init__(self, loadumper=None): + # type: (Any, Any) -> None + self.loadumper = loadumper + if self.loadumper is not 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] + + @property + def parser(self): + # type: () -> Any + if self.loadumper is not None: + return self.loadumper._parser + return None @classmethod def add_implicit_resolver_base(cls, tag, regexp, first): @@ -138,6 +148,7 @@ class BaseResolver(object): @classmethod def add_path_resolver(cls, tag, path, kind=None): + # type: (Any, Any, Any) -> 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 @@ -152,11 +163,11 @@ class BaseResolver(object): # 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 = [] + new_path = [] # type: List[Any] for element in path: if isinstance(element, (list, tuple)): if len(element) == 2: - node_check, index_check = element + node_check, index_check = element # type: ignore elif len(element) == 1: node_check = element[0] index_check = True @@ -191,6 +202,7 @@ class BaseResolver(object): cls.yaml_path_resolvers[tuple(new_path), kind] = tag def descend_resolver(self, current_node, current_index): + # type: (Any, Any) -> None if not self.yaml_path_resolvers: return exact_paths = {} @@ -215,6 +227,7 @@ class BaseResolver(object): self.resolver_prefix_paths.append(prefix_paths) def ascend_resolver(self): + # type: () -> None if not self.yaml_path_resolvers: return self.resolver_exact_paths.pop() @@ -222,29 +235,31 @@ class BaseResolver(object): def check_resolver_prefix(self, depth, path, kind, current_node, current_index): + # type: (int, Text, Any, Any, Any) -> bool node_check, index_check = path[depth-1] if isinstance(node_check, string_types): if current_node.tag != node_check: - return + return False elif node_check is not None: if not isinstance(current_node, node_check): - return + return False if index_check is True and current_index is not None: - return + return False if (index_check is False or index_check is None) \ and current_index is None: - return + return False if isinstance(index_check, string_types): if not (isinstance(current_index, ScalarNode) and index_check == current_index.value): - return + return False elif isinstance(index_check, int) and not isinstance(index_check, bool): if index_check != current_index: - return + return False return True def resolve(self, kind, value, implicit): + # type: (Any, Any, Any) -> Any if kind is ScalarNode and implicit[0]: if value == u'': resolvers = self.yaml_implicit_resolvers.get(u'', []) @@ -255,7 +270,7 @@ class BaseResolver(object): if regexp.match(value): return tag implicit = implicit[1] - if self.yaml_path_resolvers: + if bool(self.yaml_path_resolvers): exact_paths = self.resolver_exact_paths[-1] if kind in exact_paths: return exact_paths[kind] @@ -270,6 +285,7 @@ class BaseResolver(object): @property def processing_version(self): + # type: () -> Any return None @@ -341,16 +357,18 @@ class VersionedResolver(BaseResolver): """ contrary to the "normal" resolver, the smart resolver delays loading the pattern matching rules. That way it can decide to load 1.1 rules - or the (default) 1.2 that no longer support octal without 0o, sexagesimals + or the (default) 1.2 rules, that no longer support octal without 0o, sexagesimals and Yes/No/On/Off booleans. """ - def __init__(self, version=None): - BaseResolver.__init__(self) + def __init__(self, version=None, loader=None): + # type: (VersionType, Any) -> None + BaseResolver.__init__(self, loader) self._loader_version = self.get_loader_version(version) - self._version_implicit_resolver = {} + self._version_implicit_resolver = {} # type: Dict[Any, Any] def add_version_implicit_resolver(self, version, tag, regexp, first): + # type: (VersionType, Any, Any, Any) -> None if first is None: first = [None] impl_resolver = self._version_implicit_resolver.setdefault(version, {}) @@ -358,6 +376,7 @@ class VersionedResolver(BaseResolver): impl_resolver.setdefault(ch, []).append((tag, regexp)) def get_loader_version(self, version): + # type: (Union[VersionType, None]) -> Any if version is None or isinstance(version, tuple): return version if isinstance(version, list): @@ -366,7 +385,8 @@ class VersionedResolver(BaseResolver): return tuple(map(int, version.split(u'.'))) @property - def resolver(self): + def versioned_resolver(self): + # type: () -> Any """ select the resolver based on the version we are parsing """ @@ -378,17 +398,18 @@ class VersionedResolver(BaseResolver): return self._version_implicit_resolver[version] def resolve(self, kind, value, implicit): + # type: (Any, Any, Any) -> Any if kind is ScalarNode and implicit[0]: if value == u'': - resolvers = self.resolver.get(u'', []) + resolvers = self.versioned_resolver.get(u'', []) else: - resolvers = self.resolver.get(value[0], []) - resolvers += self.resolver.get(None, []) + resolvers = self.versioned_resolver.get(value[0], []) + resolvers += self.versioned_resolver.get(None, []) for tag, regexp in resolvers: if regexp.match(value): return tag implicit = implicit[1] - if self.yaml_path_resolvers: + if bool(self.yaml_path_resolvers): exact_paths = self.resolver_exact_paths[-1] if kind in exact_paths: return exact_paths[kind] @@ -403,11 +424,11 @@ class VersionedResolver(BaseResolver): @property def processing_version(self): + # type: () -> Any try: - version = self.yaml_version + version = self.parser.yaml_version except AttributeError: - # dumping - version = self.use_version + version = self.loadumper._serializer.use_version # dumping if version is None: version = self._loader_version if version is None: -- cgit v1.2.1