some changes for mypy --strict

1 files changed, 134 insertions, 18 deletions

diff --git a/comments.py b/comments.py
index e549a33..d77d72a 100644
--- a/comments.py
+++ b/comments.py
@@ -8,7 +8,9 @@ these are not really related, formatting could be factored out as
 a separate base
 """
 
+from typing import Any, Dict, Optional, List, Union  # NOQA
 import copy
+
 from collections import MutableSet, Sized, Set  # type: ignore
 
 from ruamel.yaml.compat import ordereddict, PY2
@@ -32,15 +34,17 @@ class Comment(object):
     attrib = comment_attrib
 
     def __init__(self):
+        # type: () -> None
         self.comment = None  # [post, [pre]]
         # map key (mapping/omap/dict) or index (sequence/list) to a  list of
         # dict: post_key, pre_key, post_value, pre_value
         # list: pre item, post item
-        self._items = {}
+        self._items = {}  # type: Dict[Any, Any]
         # self._start = [] # should not put these on first item
-        self._end = []  # end of document comments
+        self._end = []  # type: List[Any] # end of document comments
 
     def __str__(self):
+        # type: () -> str
         if self._end:
             end = ',\n  end=' + str(self._end)
         else:
@@ -50,27 +54,33 @@ class Comment(object):
 
     @property
     def items(self):
+        # type: () -> Any
         return self._items
 
     @property
     def end(self):
+        # type: () -> Any
         return self._end
 
     @end.setter
     def end(self, value):
+        # type: (Any) -> None
         self._end = value
 
     @property
     def start(self):
+        # type: () -> Any
         return self._start
 
     @start.setter
     def start(self, value):
+        # type: (Any) -> None
         self._start = value
 
 
 # to distinguish key from None
 def NoComment():
+    # type: () -> None
     pass
 
 
@@ -79,15 +89,19 @@ class Format(object):
     attrib = format_attrib
 
     def __init__(self):
-        self._flow_style = None
+        # type: () -> None
+        self._flow_style = None  # type: Any
 
     def set_flow_style(self):
+        # type: () -> None
         self._flow_style = True
 
     def set_block_style(self):
+        # type: () -> None
         self._flow_style = False
 
     def flow_style(self, default=None):
+        # type: (Optional[Any]) -> Any
         """if default (the flow_style) is None, the flow style tacked on to
         the object explicitly will be taken. If that is None as well the
         default flow style rules the format down the line, or the type
@@ -101,35 +115,42 @@ class LineCol(object):
     attrib = line_col_attrib
 
     def __init__(self):
+        # type: () -> None
         self.line = None
         self.col = None
-        self.data = None
+        self.data = None  # type: Union[None, Dict[Any, Any]]
 
     def add_kv_line_col(self, key, data):
+        # type: (Any, Any) -> None
         if self.data is None:
             self.data = {}
         self.data[key] = data
 
     def key(self, k):
+        # type: (Any) -> Any
         return self._kv(k, 0, 1)
 
     def value(self, k):
+        # type: (Any) -> Any
         return self._kv(k, 2, 3)
 
     def _kv(self, k, x0, x1):
+        # type: (Any, Any, Any) -> Any
         if self.data is None:
             return None
         data = self.data[k]
         return data[x0], data[x1]
 
     def item(self, idx):
+        # type: (Any) -> Any
         if self.data is None:
             return None
         return self.data[idx][0], self.data[idx][1]
 
     def add_idx_line_col(self, key, data):
+        # type: (Any, Any) -> None
         if self.data is None:
-            self.data = {}
+            self.data = {}  # type: Dict[Any, Any]
         self.data[key] = data
 
 
@@ -138,6 +159,7 @@ class Anchor(object):
     attrib = anchor_attrib
 
     def __init__(self):
+        # type: () -> None
         self.value = None
         self.always_dump = False
 
@@ -148,17 +170,20 @@ class Tag(object):
     attrib = tag_attrib
 
     def __init__(self):
+        # type: () -> None
         self.value = None
 
 
 class CommentedBase(object):
     @property
     def ca(self):
+        # type: () -> Any
         if not hasattr(self, Comment.attrib):
             setattr(self, Comment.attrib, Comment())
         return getattr(self, Comment.attrib)
 
     def yaml_end_comment_extend(self, comment, clear=False):
+        # type: (Any, bool) -> None
         if comment is None:
             return
         if clear or self.ca.end is None:
@@ -166,6 +191,7 @@ class CommentedBase(object):
         self.ca.end.extend(comment)
 
     def yaml_key_comment_extend(self, key, comment, clear=False):
+        # type: (Any, Any, bool) -> None
         l = self.ca._items.setdefault(key, [None, None, None, None])
         if clear or l[1] is None:
             if comment[1] is not None:
@@ -176,6 +202,7 @@ class CommentedBase(object):
         l[0] = comment[0]
 
     def yaml_value_comment_extend(self, key, comment, clear=False):
+        # type: (Any, Any, bool) -> None
         l = self.ca._items.setdefault(key, [None, None, None, None])
         if clear or l[3] is None:
             if comment[1] is not None:
@@ -186,6 +213,7 @@ class CommentedBase(object):
         l[2] = comment[0]
 
     def yaml_set_start_comment(self, comment, indent=0):
+        # type: (Any, Any) -> None
         """overwrites any preceding comment lines on an object
         expects comment to be without `#` and possible have multiple lines
         """
@@ -200,6 +228,7 @@ class CommentedBase(object):
 
     def yaml_set_comment_before_after_key(self, key, before=None, indent=0,
                                           after=None, after_indent=None):
+        # type: (Any, Any, Any, Any, Any) -> None
         """
         expects comment (before/after) to be without `#` and possible have multiple lines
         """
@@ -207,6 +236,7 @@ class CommentedBase(object):
         from ruamel.yaml.tokens import CommentToken
 
         def comment_token(s, mark):
+            # type: (Any) -> Any
             # handle empty lines as having no comment
             return CommentToken(('# ' if s else '') + s + '\n', mark, None)
 
@@ -230,6 +260,7 @@ class CommentedBase(object):
 
     @property
     def fa(self):
+        # type: () -> Any
         """format attribute
 
         set_flow_style()/set_block_style()"""
@@ -238,6 +269,7 @@ class CommentedBase(object):
         return getattr(self, Format.attrib)
 
     def yaml_add_eol_comment(self, comment, key=NoComment, column=None):
+        # type: (Any, Optional[Any], Optional[Any]) -> None
         """
         there is a problem as eol comments should start with ' #'
         (but at the beginning of the line the space doesn't have to be before
@@ -259,45 +291,55 @@ class CommentedBase(object):
 
     @property
     def lc(self):
+        # type: () -> Any
         if not hasattr(self, LineCol.attrib):
             setattr(self, LineCol.attrib, LineCol())
         return getattr(self, LineCol.attrib)
 
     def _yaml_set_line_col(self, line, col):
+        # type: (Any, Any) -> None
         self.lc.line = line
         self.lc.col = col
 
     def _yaml_set_kv_line_col(self, key, data):
+        # type: (Any, Any) -> None
         self.lc.add_kv_line_col(key, data)
 
     def _yaml_set_idx_line_col(self, key, data):
+        # type: (Any, Any) -> None
         self.lc.add_idx_line_col(key, data)
 
     @property
     def anchor(self):
+        # type: () -> Any
         if not hasattr(self, Anchor.attrib):
             setattr(self, Anchor.attrib, Anchor())
         return getattr(self, Anchor.attrib)
 
     def yaml_anchor(self):
+        # type: () -> Any
         if not hasattr(self, Anchor.attrib):
             return None
         return self.anchor
 
     def yaml_set_anchor(self, value, always_dump=False):
+        # type: (Any, bool) -> None
         self.anchor.value = value
         self.anchor.always_dump = always_dump
 
     @property
     def tag(self):
+        # type: () -> Any
         if not hasattr(self, Tag.attrib):
             setattr(self, Tag.attrib, Tag())
         return getattr(self, Tag.attrib)
 
     def yaml_set_tag(self, value):
+        # type: (Any) -> None
         self.tag.value = value
 
     def copy_attributes(self, t, deep=False):
+        # type: (Any, bool) -> None
         for a in [Comment.attrib, Format.attrib, LineCol.attrib, Anchor.attrib,
                   Tag.attrib, merge_attrib]:
             if hasattr(self, a):
@@ -306,23 +348,35 @@ class CommentedBase(object):
                 else:
                     setattr(t, a, getattr(self, a))
 
+    def _yaml_add_eol_comment(self, comment, key):
+        # type: (Any, Any) -> None
+        raise NotImplementedError
+
+    def _yaml_get_pre_comment(self):
+        # type: () -> Any
+        raise NotImplementedError
+
 
 class CommentedSeq(list, CommentedBase):
     __slots__ = Comment.attrib,
 
     def _yaml_add_comment(self, comment, key=NoComment):
+        # type: (Any, Optional[Any]) -> None
         if key is not NoComment:
             self.yaml_key_comment_extend(key, comment)
         else:
             self.ca.comment = comment
 
     def _yaml_add_eol_comment(self, comment, key):
+        # type: (Any, Any) -> None
         self._yaml_add_comment(comment, key=key)
 
     def _yaml_get_columnX(self, key):
+        # type: (Any) -> Any
         return self.ca.items[key][0].start_mark.column
 
     def insert(self, idx, val):
+        # type: (Any, Any) -> None
         """the comments after the insertion have to move forward"""
         list.insert(self, idx, val)
         for list_index in sorted(self.ca.items, reverse=True):
@@ -330,7 +384,8 @@ class CommentedSeq(list, CommentedBase):
                 break
             self.ca.items[list_index+1] = self.ca.items.pop(list_index)
 
-    def pop(self, idx):
+    def pop(self, idx=None):
+        # type: (Any) -> Any
         res = list.pop(self, idx)
         self.ca.items.pop(idx, None)  # might not be there -> default value
         for list_index in sorted(self.ca.items):
@@ -340,6 +395,7 @@ class CommentedSeq(list, CommentedBase):
         return res
 
     def _yaml_get_column(self, key):
+        # type: (Any) -> Any
         column = None
         sel_idx = None
         pre, post = key-1, key+1
@@ -360,14 +416,16 @@ class CommentedSeq(list, CommentedBase):
         return column
 
     def _yaml_get_pre_comment(self):
+        # type: () -> Any
+        pre_comments = []  # type: List[Any]
         if self.ca.comment is None:
-            pre_comments = []
             self.ca.comment = [None, pre_comments]
         else:
-            pre_comments = self.ca.comment[1] = []
+            self.ca.comment[1] = pre_comments
         return pre_comments
 
     def __deepcopy__(self, memo):
+        # type: (Any) -> Any
         res = CommentedSeq()
         memo[id(self)] = res
         for k in self:
@@ -379,18 +437,22 @@ class CommentedSeq(list, CommentedBase):
 class CommentedKeySeq(tuple, CommentedBase):
     """This primarily exists to be able to roundtrip keys that are sequences"""
     def _yaml_add_comment(self, comment, key=NoComment):
+        # type: (Any, Optional[Any]) -> None
         if key is not NoComment:
             self.yaml_key_comment_extend(key, comment)
         else:
             self.ca.comment = comment
 
     def _yaml_add_eol_comment(self, comment, key):
+        # type: (Any, Any) -> None
         self._yaml_add_comment(comment, key=key)
 
     def _yaml_get_columnX(self, key):
+        # type: (Any) -> Any
         return self.ca.items[key][0].start_mark.column
 
     def _yaml_get_column(self, key):
+        # type: (Any) -> Any
         column = None
         sel_idx = None
         pre, post = key-1, key+1
@@ -411,11 +473,12 @@ class CommentedKeySeq(tuple, CommentedBase):
         return column
 
     def _yaml_get_pre_comment(self):
+        # type: () -> Any
+        pre_comments = []  # type: List[Any]
         if self.ca.comment is None:
-            pre_comments = []
             self.ca.comment = [None, pre_comments]
         else:
-            pre_comments = self.ca.comment[1] = []
+            self.ca.comment[1] = pre_comments
         return pre_comments
 
 
@@ -423,11 +486,13 @@ class CommentedMapView(Sized):
     __slots__ = '_mapping',
 
     def __init__(self, mapping):
+        # type: (Any) -> None
         self._mapping = mapping
 
     def __len__(self):
+        # type: () -> int
         count = len(self._mapping)
-        done = []  # list of processed merge items, kept for masking
+        done = []  # type: List[Any] # list of processed merge items, kept for masking
         for merged in getattr(self._mapping, merge_attrib, []):
             for x in merged[1]:
                 if self._mapping._unmerged_contains(x):
@@ -441,6 +506,7 @@ class CommentedMapView(Sized):
         return count
 
     def __repr__(self):
+        # type: () -> str
         return '{0.__class__.__name__}({0._mapping!r})'.format(self)
 
 
@@ -449,13 +515,15 @@ class CommentedMapKeysView(CommentedMapView, Set):
 
     @classmethod
     def _from_iterable(self, it):
+        # type: (Any) -> Any
         return set(it)
 
     def __contains__(self, key):
+        # type: (Any) -> Any
         return key in self._mapping
 
     def __iter__(self):
-        # yield from self._mapping  # not in py27, pypy
+        # type: () -> Any  # yield from self._mapping  # not in py27, pypy
         for x in self._mapping:
             yield x
 
@@ -465,9 +533,11 @@ class CommentedMapItemsView(CommentedMapView, Set):
 
     @classmethod
     def _from_iterable(self, it):
+        # type: (Any) -> Any
         return set(it)
 
     def __contains__(self, item):
+        # type: (Any) -> Any
         key, value = item
         try:
             v = self._mapping[key]
@@ -477,6 +547,7 @@ class CommentedMapItemsView(CommentedMapView, Set):
             return v == value
 
     def __iter__(self):
+        # type: () -> Any
         for key in self._mapping._keys():
             yield (key, self._mapping[key])
 
@@ -485,12 +556,14 @@ class CommentedMapValuesView(CommentedMapView):
     __slots__ = ()
 
     def __contains__(self, value):
+        # type: (Any) -> Any
         for key in self._mapping:
             if value == self._mapping[key]:
                 return True
         return False
 
     def __iter__(self):
+        # type: () -> Any
         for key in self._mapping:
             yield self._mapping[key]
 
@@ -499,6 +572,7 @@ class CommentedMap(ordereddict, CommentedBase):
     __slots__ = Comment.attrib,
 
     def _yaml_add_comment(self, comment, key=NoComment, value=NoComment):
+        # type: (Any, Optional[Any], Optional[Any]) -> None
         """values is set to key to indicate a value attachment of comment"""
         if key is not NoComment:
             self.yaml_key_comment_extend(key, comment)
@@ -509,13 +583,16 @@ class CommentedMap(ordereddict, CommentedBase):
             self.ca.comment = comment
 
     def _yaml_add_eol_comment(self, comment, key):
+        # type: (Any, Any) -> None
         """add on the value line, with value specified by the key"""
         self._yaml_add_comment(comment, value=key)
 
     def _yaml_get_columnX(self, key):
+        # type: (Any) -> Any
         return self.ca.items[key][2].start_mark.column
 
     def _yaml_get_column(self, key):
+        # type: (Any) -> Any
         column = None
         sel_idx = None
         pre, post, last = None, None, None
@@ -543,14 +620,16 @@ class CommentedMap(ordereddict, CommentedBase):
         return column
 
     def _yaml_get_pre_comment(self):
+        # type: () -> Any
+        pre_comments = []  # type: List[Any]
         if self.ca.comment is None:
-            pre_comments = []
             self.ca.comment = [None, pre_comments]
         else:
-            pre_comments = self.ca.comment[1] = []
+            self.ca.comment[1] = pre_comments
         return pre_comments
 
     def update(self, vals):
+        # type: (Any) -> None
         try:
             ordereddict.update(self, vals)
         except TypeError:
@@ -559,6 +638,7 @@ class CommentedMap(ordereddict, CommentedBase):
                 self[x] = vals[x]
 
     def insert(self, pos, key, value, comment=None):
+        # type: (Any, Any, Any, Optional[Any]) -> None
         """insert key value into given position
         attach comment if provided
         """
@@ -567,12 +647,14 @@ class CommentedMap(ordereddict, CommentedBase):
             self.yaml_add_eol_comment(comment, key=key)
 
     def mlget(self, key, default=None, list_ok=False):
+        # type: (Any, Any, Any) -> Any
         """multi-level get that expects dicts within dicts"""
         if not isinstance(key, list):
             return self.get(key, default)
         # assume that the key is a list of recursively accessible dicts
 
         def get_one_level(key_list, level, d):
+            # type: (Any, Any, Any) -> Any
             if not list_ok:
                 assert isinstance(d, dict)
             if level >= len(key_list):
@@ -591,6 +673,7 @@ class CommentedMap(ordereddict, CommentedBase):
             return default
 
     def __getitem__(self, key):
+        # type: (Any) -> Any
         try:
             return ordereddict.__getitem__(self, key)
         except KeyError:
@@ -600,10 +683,13 @@ class CommentedMap(ordereddict, CommentedBase):
             raise
 
     def _unmerged_contains(self, key):
+        # type: (Any) -> Any
         if ordereddict.__contains__(self, key):
             return True
+        return None
 
     def __contains__(self, key):
+        # type: (Any) -> bool
         if ordereddict.__contains__(self, key):
             return True
         # this will only work once the mapping/dict is built to completion
@@ -613,21 +699,25 @@ class CommentedMap(ordereddict, CommentedBase):
         return False
 
     def get(self, key, default=None):
+        # type: (Any, Any) -> Any
         try:
             return self.__getitem__(key)
         except:
             return default
 
     def __repr__(self):
+        # type: () -> Any
         if not hasattr(self, merge_attrib):
             return ordereddict.__repr__(self)
         return 'ordereddict(' + repr(list(self._items())) + ')'
 
     def non_merged_items(self):
+        # type: () -> Any
         for x in ordereddict.__iter__(self):
             yield x, ordereddict.__getitem__(self, x)
 
     def __delitem__(self, key):
+        # type: (Any) -> None
         found = True
         for merged in getattr(self, merge_attrib, []):
             try:
@@ -642,9 +732,10 @@ class CommentedMap(ordereddict, CommentedBase):
                 raise
 
     def __iter__(self):
+        # type: () -> Any
         for x in ordereddict.__iter__(self):
             yield x
-        done = []  # list of processed merge items, kept for masking
+        done = []  # type: List[Any]  # list of processed merge items, kept for masking
         for merged in getattr(self, merge_attrib, []):
             for x in merged[1]:
                 if ordereddict.__contains__(self, x):
@@ -657,9 +748,10 @@ class CommentedMap(ordereddict, CommentedBase):
             done.append(merged[1])
 
     def _keys(self):
+        # type: () -> Any
         for x in ordereddict.__iter__(self):
             yield x
-        done = []  # list of processed merge items, kept for masking
+        done = []  # type: List[Any]  # list of processed merge items, kept for masking
         for merged in getattr(self, merge_attrib, []):
             for x in merged[1]:
                 if ordereddict.__contains__(self, x):
@@ -673,21 +765,26 @@ class CommentedMap(ordereddict, CommentedBase):
 
     if PY2:
         def keys(self):
+            # type: () -> Any
             return list(self._keys())
 
         def iterkeys(self):
+            # type: () -> Any
             return self._keys()
 
         def viewkeys(self):
+            # type: () -> Any
             return CommentedMapKeysView(self)
     else:
         def keys(self):
+            # type: () -> Any
             return CommentedMapKeysView(self)
 
     def _values(self):
+        # type: () -> Any
         for x in ordereddict.__iter__(self):
             yield ordereddict.__getitem__(self, x)
-        done = []  # list of processed merge items, kept for masking
+        done = []  # type: List[Any]  # list of processed merge items, kept for masking
         for merged in getattr(self, merge_attrib, []):
             for x in merged[1]:
                 if ordereddict.__contains__(self, x):
@@ -701,21 +798,26 @@ class CommentedMap(ordereddict, CommentedBase):
 
     if PY2:
         def values(self):
+            # type: () -> Any
             return list(self._values())
 
         def itervalues(self):
+            # type: () -> Any
             return self._values()
 
         def viewvalues(self):
+            # type: () -> Any
             return CommentedMapValuesView(self)
     else:
         def values(self):
+            # type: () -> Any
             return CommentedMapValuesView(self)
 
     def _items(self):
+        # type: () -> Any
         for x in ordereddict.__iter__(self):
             yield x, ordereddict.__getitem__(self, x)
-        done = []  # list of processed merge items, kept for masking
+        done = []  # type: List[Any]  # list of processed merge items, kept for masking
         for merged in getattr(self, merge_attrib, []):
             for x in merged[1]:
                 if ordereddict.__contains__(self, x):
@@ -729,27 +831,34 @@ class CommentedMap(ordereddict, CommentedBase):
 
     if PY2:
         def items(self):
+            # type: () -> Any
             return list(self._items())
 
         def iteritems(self):
+            # type: () -> Any
             return self._items()
 
         def viewitems(self):
+            # type: () -> Any
             return CommentedMapItemsView(self)
     else:
         def items(self):
+            # type: () -> Any
             return CommentedMapItemsView(self)
 
     @property
     def merge(self):
+        # type: () -> Any
         if not hasattr(self, merge_attrib):
             setattr(self, merge_attrib, [])
         return getattr(self, merge_attrib)
 
     def add_yaml_merge(self, value):
+        # type: (Any) -> None
         self.merge.extend(value)
 
     def __deepcopy__(self, memo):
+        # type: (Any) -> Any
         res = CommentedMap()
         memo[id(self)] = res
         for k in self:
@@ -766,28 +875,35 @@ class CommentedSet(MutableSet, CommentedMap):
     __slots__ = Comment.attrib, 'odict',
 
     def __init__(self, values=None):
+        # type: (Optional[Any]) -> None
         self.odict = ordereddict()
         MutableSet.__init__(self)
         if values is not None:
             self |= values
 
     def add(self, value):
+        # type: (Any) -> None
         """Add an element."""
         self.odict[value] = None
 
     def discard(self, value):
+        # type: (Any) -> None
         """Remove an element.  Do not raise an exception if absent."""
         del self.odict[value]
 
     def __contains__(self, x):
+        # type: (Any) -> Any
         return x in self.odict
 
     def __iter__(self):
+        # type: () -> Any
         for x in self.odict:
             yield x
 
     def __len__(self):
+        # type: () -> int
         return len(self.odict)
 
     def __repr__(self):
+        # type: () -> str
         return 'set({0!r})'.format(self.odict.keys())