It should now be easier to define an abstract yaml-able class for several object types.

Deprecated `NONE_IGNORE_CHECKS`. Fixes #7

Added corresponding tests.

Author: smarie

yamlable/base.py

@@ -189,8 +189,9 @@ def load_yaml(cls,                  # type: Type[Y]
                             "".format(cls.__name__, type(res).__name__))
 
 
-NONE_IGNORE_CHECKS = object()
-""" A tag to be used as yaml tag for abstract classes, to indicate that they are abstract (checks disabled) """
+NONE_IGNORE_CHECKS = None
+# """Tag to be used as yaml tag for abstract classes, to indicate that
+# they are abstract (checks disabled). Not used anymore, kept for legacy reasons"""
 
 
 def read_yaml_node_as_dict(loader, node):

yamlable/main.py

@@ -17,7 +17,7 @@
 
 from yaml import Loader, SafeLoader, Dumper, SafeDumper, MappingNode
 
-from yamlable.base import AbstractYamlObject, NONE_IGNORE_CHECKS, read_yaml_node_as_dict
+from yamlable.base import AbstractYamlObject, read_yaml_node_as_dict
 from yamlable.yaml_objects import YamlObject2
 
 
@@ -79,12 +79,19 @@ def is_yaml_tag_supported(cls,
         :return:
         """
         if hasattr(cls, '__yaml_tag_suffix__') and cls.__yaml_tag_suffix__ is not None:
-            return cls.__yaml_tag_suffix__ == yaml_tag and cls.__yaml_tag_suffix__ is not NONE_IGNORE_CHECKS
+            if '__yaml_tag_suffix__' in cls.__dict__:
+                # this is an explicitly configured class (__yaml_tag_suffix__ is set on it), ok
+                return cls.__yaml_tag_suffix__ == yaml_tag
+            else:
+                # this class inherits from the __yaml_tag_suffix__ and does not redefine it, not ok
+                raise TypeError("`__yaml_tag_suffix__` field is not redefined by class {}, cannot inherit from YamlAble"
+                                "properly.".format(cls))
+
         else:
             raise NotImplementedError("class {} does not seem to have a non-None '__yaml_tag_suffix__' field. You can "
                                       "either create one manually or by decorating your class with @yaml_info. "
-                                      "Alternately you should override the 'is_yaml_tag_supported' abstract method "
-                                      "from YamlAble".format(cls))
+                                      "Alternately you should override the 'is_yaml_tag_supported' method "
+                                      "from YamlAble.".format(cls))
 
 
 def yaml_info(yaml_tag=None,     # type: str
@@ -247,7 +254,7 @@ def encode_yamlable(dumper,
         return dumper.represent_mapping(None, new_data, flow_style=None)
     else:
         # Add the tag information
-        if not hasattr(obj, '__yaml_tag_suffix__') or obj.__yaml_tag_suffix__ in {None, NONE_IGNORE_CHECKS}:
+        if not hasattr(obj, '__yaml_tag_suffix__') or obj.__yaml_tag_suffix__ is None:
             raise NotImplementedError("object {} does not seem to have a non-None '__yaml_tag_suffix__' field. You "
                                       "can either create one manually or by decorating your class with @yaml_info."
                                       "".format(obj))

yamlable/tests/test_yamlable.py

@@ -52,7 +52,7 @@ def __from_yaml_dict__(cls,  # type: Type[Y]
 
 
 def test_yamlable():
-    """ Tests that YamlAbleMixIn works correctly """
+    """ Tests that YamlAble works correctly """
 
     @yaml_info(yaml_tag_ns='yaml.tests')
     class Foo(YamlAble):
@@ -250,3 +250,77 @@ class Foo(YamlAble):
 
     assert Foo().dumps_yaml() == """!yamlable/com.example.Foo {}
 """
+
+
+def test_abstract_parent_error():
+    """This tests that we can define an abstract parent class with the YamlAble behaviour and inherit it"""
+
+    class AbstractFooE(YamlAble):
+        pass
+
+    class FooError(AbstractFooE):
+        """
+        This class inherits from the parent without redefining a yaml tag
+        """
+        def __init__(self, a, b):
+            self.a = a
+            self.b = b
+
+        def __eq__(self, other):
+            return vars(self) == vars(other)
+
+    # instantiate
+    e = FooError(1, 'hello')
+
+    # dump
+    with pytest.raises(NotImplementedError):
+        e.dumps_yaml()
+
+
+def test_abstract_parent():
+    """This tests that we can define an abstract parent class with the YamlAble behaviour and inherit it"""
+
+    class AbstractFooV(YamlAble):
+        pass
+
+    @yaml_info(yaml_tag_ns='yaml.tests')
+    class FooValid(AbstractFooV):
+
+        def __init__(self, a, b):
+            self.a = a
+            self.b = b
+
+        def __eq__(self, other):
+            return vars(self) == vars(other)
+
+    # instantiate
+    f = FooValid(1, 'hello')  # note:
+
+    # dump
+    y = f.dumps_yaml()
+    assert y == "!yamlable/yaml.tests.FooValid {a: 1, b: hello}\n"
+
+    # dump io
+    class MemorizingStringIO(StringIO):
+        """ A StringIO object that memorizes its buffer when it is closed (as opposed to the standard StringIO) """
+
+        def close(self):
+            self.value = self.getvalue()
+            # super(StringIO, self).close()  # this does not work with python 2 old-style classes (StringIO is one)
+            StringIO.close(self)
+
+    s = MemorizingStringIO()
+    f.dump_yaml(s)
+    assert s.value == y
+
+    # dump pyyaml
+    assert dump(f) == y
+
+    # load
+    assert f == FooValid.loads_yaml(y)
+
+    # load io
+    assert f == FooValid.load_yaml(StringIO(y))
+
+    # load pyyaml
+    assert f == load(y)

yamlable/tests/test_yamlobjects.py

@@ -55,3 +55,58 @@ def __from_yaml_dict__(cls,      # type: Type[Y]
     # load from yaml
     g = Foo.loads_yaml(o)
     assert f == g
+
+
+def test_abstract_parent_error():
+    """This tests that we can define an abstract parent class with the YamlAble behaviour and inherit it"""
+
+    with pytest.raises(TypeError):
+        class AbstractFooE(YamlObject2):
+            pass
+
+        # class FooError(AbstractFooE):
+        #     """
+        #     This class inherits from the parent without redefining a yaml tag
+        #     """
+        #     def __init__(self, a, b):
+        #         self.a = a
+        #         self.b = b
+        #
+        #     def __eq__(self, other):
+        #         return vars(self) == vars(other)
+        #
+        # # instantiate
+        # e = FooError(1, 'hello')
+        #
+        # # dump
+        # with pytest.raises(NotImplementedError):
+        #     e.dumps_yaml()
+
+
+def test_abstract_parent():
+    """This tests that we can define an abstract parent class with the YamlAble behaviour and inherit it"""
+
+    class AbstractFooV(YamlObject2):
+        # With YamlObject2 as opposed to YamlAble, we have to explicitly disable the yaml_tag field
+        yaml_tag = None
+
+    class FooValid(AbstractFooV):
+        yaml_tag = '!foo'
+
+        def __init__(self, a, b):
+            self.a = a
+            self.b = b
+
+        def __eq__(self, other):
+            return vars(self) == vars(other)
+
+    # instantiate
+    f = FooValid(1, 'hello')
+
+    # dump to yaml
+    o = f.dumps_yaml(safe=False)
+    assert o == "!foo {a: 1, b: hello}\n"
+
+    # load from yaml
+    g = FooValid.loads_yaml(o)
+    assert f == g

yamlable/yaml_objects.py

@@ -15,7 +15,7 @@
 
 from yaml import YAMLObjectMetaclass, YAMLObject, SafeLoader, MappingNode
 
-from yamlable.base import NONE_IGNORE_CHECKS, AbstractYamlObject, read_yaml_node_as_dict
+from yamlable.base import AbstractYamlObject, read_yaml_node_as_dict
 
 
 class YAMLObjectMetaclassStrict(YAMLObjectMetaclass):
@@ -29,18 +29,19 @@ def __init__(cls,   # type: Type[YO2]
         super(YAMLObjectMetaclass, cls).__init__(name, bases, kwds)
 
         # if yaml_tag is provided
-        if 'yaml_tag' in kwds and kwds['yaml_tag'] is not None:
-            if cls.yaml_tag != NONE_IGNORE_CHECKS:
+        if 'yaml_tag' in kwds:
+            # if cls.yaml_tag != NONE_IGNORE_CHECKS:
+            if kwds['yaml_tag'] is not None:
                 cls.yaml_loader.add_constructor(cls.yaml_tag, cls.from_yaml)
                 cls.yaml_dumper.add_representer(cls, cls.to_yaml)
             else:
                 if 'yaml_tag' in cls.__dict__:
-                    # this is an explicitly disabled class (yaml_tag=NONE_IGNORE_CHECK is set on it), ok
+                    # this is an explicitly disabled class (yaml_tag=None is set on it), ok
                     pass
                 else:
-                    # this class inherits from the yaml_tag=NONE_IGNORE_CHECK and does not redefine it, not ok
+                    # this class inherits from the yaml_tag=None and does not redefine it, not ok
                     raise TypeError("`yaml_tag` field is not redefined by class {}, cannot inherit from YAMLObject "
-                                    "properly. Note that abstract classes can use the tag NONE_IGNORE_CHECKS to skip "
+                                    "properly. Note that abstract classes can set the tag explicitly to `None` to skip "
                                     "this check. It won't disable the check for their subclasses".format(cls))
 
         else:
@@ -74,7 +75,7 @@ class YamlObject2(six.with_metaclass(ABCYAMLMeta, AbstractYamlObject, YAMLObject
     """
     yaml_loader = SafeLoader  # explicitly use SafeLoader by default
     # yaml_dumper = Dumper
-    yaml_tag = NONE_IGNORE_CHECKS
+    yaml_tag = None
     # yaml_flow_style = ...
 
     @classmethod