Most type hints have been fixed, in particular for @yaml_info. Fixes #11

Author: Sylvain MARIE

yamlable/base.py

@@ -3,10 +3,10 @@
 
 try:
     # Python 2 only:
-    from StringIO import StringIO
+    from StringIO import StringIO as _StringIO  # type: ignore  # noqa
 
     # create a variant that can serve as a context manager
-    class StringIO(StringIO):
+    class StringIO(_StringIO):
         def __enter__(self):
             return self
 
@@ -15,7 +15,7 @@ def __exit__(self, exception_type, exception_value, traceback):
 
 except ImportError:
     # (IOBase is only used in type hints)
-    from io import IOBase, StringIO
+    from io import IOBase, StringIO  # type: ignore
 
 from warnings import warn
 
@@ -57,7 +57,7 @@ def __to_yaml_dict__(self):
         if 'to_yaml_dict' in dir(self):
             warn(type(self).__name__ + " still uses the legacy method name 'to_yaml_dict'. This name will not be "
                                        "supported in future version, please use '__to_yaml_dict__' instead")
-            return self.to_yaml_dict()
+            return self.to_yaml_dict()  # type: ignore
 
         # Default: return vars(self) (Note: no need to make a copy, pyyaml does not modify it)
         return vars(self)
@@ -86,13 +86,13 @@ def __from_yaml_dict__(cls,      # type: Type[Y]
         if 'from_yaml_dict' in dir(cls):
             warn(cls.__name__ + " still uses the legacy method name 'from_yaml_dict'. This name will not be "
                                 "supported in future version, please use '__from_yaml_dict__' instead")
-            return cls.from_yaml_dict(dct, yaml_tag)
+            return cls.from_yaml_dict(dct, yaml_tag)  # type: ignore
 
         # Default: call constructor with all keyword arguments
-        return cls(**dct)
+        return cls(**dct)  # type: ignore
 
     def dump_yaml(self,
-                  file_path_or_stream,  # type: Union[str, IOBase, StrinIO]
+                  file_path_or_stream,  # type: Union[str, IOBase, StringIO]
                   safe=True,            # type: bool
                   **pyyaml_kwargs       # type: Any
                   ):
@@ -113,7 +113,7 @@ def dump_yaml(self,
                 else:
                     dump(self, f, **pyyaml_kwargs)
         else:
-            with file_path_or_stream as f:
+            with file_path_or_stream as f:  # type: ignore
                 if safe:
                     safe_dump(self, f, **pyyaml_kwargs)
                 else:
@@ -175,7 +175,7 @@ def load_yaml(cls,                  # type: Type[Y]
                 else:
                     res = load(f.read())
         else:
-            with file_path_or_stream as f:
+            with file_path_or_stream as f:  # type: ignore
                 if safe:
                     res = safe_load(f.read())
                 else:

yamlable/main.py

@@ -4,7 +4,7 @@
 import six
 
 try:  # python 3.5+
-    from typing import TypeVar, Callable, Optional, Iterable, Any, Tuple, Mapping, Any, Dict
+    from typing import TypeVar, Callable, Optional, Iterable, Any, Tuple, Mapping, Any, Dict, Set, List
     YA = TypeVar('YA', bound='YamlAble')
     T = TypeVar('T')
 except ImportError:
@@ -97,7 +97,7 @@ def is_yaml_tag_supported(cls,
 def yaml_info(yaml_tag=None,     # type: str
               yaml_tag_ns=None   # type: str
               ):
-    # type: (...) -> Callable[[Type[YA], Optional[str], Optional[str]], Type[YA]]
+    # type: (...) -> Callable[[Type[YA]], Type[YA]]
     """
     A simple class decorator to tag a class with a global yaml tag - that way you do not have to call `YamlAble` super
     constructor.
@@ -132,7 +132,9 @@ class Foo(YamlAble):
     :param yaml_tag_ns: the yaml namespace. It will be appended with '.<cls.__name__>'
     :return:
     """
-    def f(cls):
+    def f(cls  # type: Type[YA]
+          ):
+        # type: (...) -> Type[YA]
         return yaml_info_decorate(cls, yaml_tag=yaml_tag, yaml_tag_ns=yaml_tag_ns)
     return f
 
@@ -180,9 +182,13 @@ class Foo(YamlAble):
     if yaml_tag_ns is not None:
         if yaml_tag is not None:
             raise ValueError("Only one of 'yaml_tag' and 'yaml_tag_ns' should be provided")
-        # default: append the class name
+
+        # create yaml_tag by appending the class name to the namespace
         yaml_tag = yaml_tag_ns + '.' + cls.__name__
 
+    elif yaml_tag is None:
+        raise ValueError("One non-None `yaml_tag` or `yaml_tag_ns` must be provided.")
+
     if issubclass(cls, YamlObject2):
         if not yaml_tag.startswith('!'):
             raise ValueError("When extending YamlObject2, the `yaml_tag` field should contain the full yaml tag, "
@@ -193,7 +199,7 @@ class Foo(YamlAble):
         if yaml_tag.startswith('!'):
             raise ValueError("When extending YamlAble, the `yaml_tag` field should only contain the yaml tag suffix, "
                              "and should therefore NOT start with !")
-        cls.__yaml_tag_suffix__ = yaml_tag
+        cls.__yaml_tag_suffix__ = yaml_tag  # type: ignore
     else:
         raise TypeError("classes tagged with @yaml_info should be subclasses of YamlAble or YamlObject2")
 
@@ -263,10 +269,10 @@ def encode_yamlable(dumper,
 
 
 try:  # PyYaml 5.1+
-    from yaml import FullLoader, UnsafeLoader
-    ALL_PYYAML_LOADERS = (Loader, SafeLoader, FullLoader, UnsafeLoader)
+    from yaml import FullLoader
+    ALL_PYYAML_LOADERS = (Loader, SafeLoader, FullLoader)
 except ImportError:
-    ALL_PYYAML_LOADERS = (Loader, SafeLoader)
+    ALL_PYYAML_LOADERS = (Loader, SafeLoader)  # type: ignore
 
 
 ALL_PYYAML_DUMPERS = (Dumper, SafeDumper)
@@ -322,7 +328,7 @@ def _get_all_subclasses(typ,             # type: Type[T]
     sub_list = typ.__subclasses__()
 
     # recurse
-    result = []
+    result = []  # type: List[Type[T]]
     for t in sub_list:
         # only keep the origins in the list
         # to = get_origin(t) or t

yamlable/yaml_objects.py

@@ -22,7 +22,7 @@ class YAMLObjectMetaclassStrict(YAMLObjectMetaclass):
     """
     Improved metaclass for YAMLObject, that raises an error if yaml_tag is not defined
     """
-    def __init__(cls,   # type: Type[YO2]
+    def __init__(cls,   # type: Type[YO2]  # type: ignore
                  name, bases, kwds):
 
         # construct as usual
@@ -108,4 +108,4 @@ def from_yaml(cls,   # type: Type[YamlObject2]
         :return:
         """
         constructor_args = read_yaml_node_as_dict(loader, node)
-        return cls.__from_yaml_dict__(constructor_args, yaml_tag=cls.yaml_tag)
+        return cls.__from_yaml_dict__(constructor_args, yaml_tag=cls.yaml_tag)  # type: ignore