Fixed a few names and imports, and main init file.

Author: smarie

yamlable/__init__.py

@@ -1,2 +1,8 @@
-from yamlable.base import AbstractYamlObject, NONE_IGNORE_CHECKS, YT_co
-from yamlable.main import YamlObject2, YamlAble, yaml_info
+from yamlable.base import AbstractYamlObject, NONE_IGNORE_CHECKS, AYO, read_yaml_node_as_dict
+from yamlable.main import YamlCodec, register_yamlable_codec, yaml_info_decorate, yaml_info, YamlAble, YA, \
+    AbstractYamlAble, YAMLABLE_PREFIX
+from yamlable.yaml_objects import YO2, YamlObject2, ABCYAMLMeta, YAMLObjectMetaclassStrict
+
+__all__ = ['base',
+           'main',
+           'yaml_objects']

yamlable/base.py

@@ -9,7 +9,7 @@
     pass # normal for old versions of typing
 
 
-YT_co = TypeVar('YT_co', bound='AbstractYamlObject')
+AYO = TypeVar('AYO', bound='AbstractYamlObject')
 
 
 class AbstractYamlObject(ABC):
@@ -30,7 +30,7 @@ def to_yaml_dict(self) -> Dict[str, Any]:
 
     @classmethod
     @abstractmethod
-    def from_yaml_dict(cls: 'Type[YT_co]', dct: Dict, yaml_tag: str) -> YT_co:
+    def from_yaml_dict(cls: 'Type[AYO]', dct: Dict, yaml_tag: str) -> AYO:
         """
         Implementors should transform the given dictionary (read from yaml by the pyYaml stack) into an object instance.
         The yaml tag associated to this object, read in the yaml document, is provided in parameter.
@@ -71,7 +71,7 @@ def dumps_yaml(self, **pyyaml_kwargs):
         return dump(self, **pyyaml_kwargs)
 
     @classmethod
-    def loads_yaml(cls: 'Type[YT_co]', yaml_str: str) -> YT_co:
+    def loads_yaml(cls: 'Type[AYO]', yaml_str: str) -> AYO:
         """
         Utility method to
         :param yaml_str
@@ -80,7 +80,7 @@ def loads_yaml(cls: 'Type[YT_co]', yaml_str: str) -> YT_co:
         return cls.load_yaml(StringIO(yaml_str))
 
     @classmethod
-    def load_yaml(cls: 'Type[YT_co]', file_path_or_stream: Union[str, TextIOBase]) -> YT_co:
+    def load_yaml(cls: 'Type[AYO]', file_path_or_stream: Union[str, TextIOBase]) -> AYO:
         """
         Parses the given file path or stream as a yaml document with the
 

yamlable/main.py

@@ -1,24 +1,19 @@
-from abc import ABCMeta, abstractmethod, ABC
+from abc import abstractmethod, ABC
 from typing import TypeVar, Callable, Optional, Iterable, Any, Tuple
-
-from yaml import Loader, SafeLoader, Dumper, SafeDumper
-
-from yaml_objects import YamlObject2
-
 try:
     from typing import Type
 except ImportError:
     pass # normal for old versions of typing
 
-
-from six import add_metaclass
+from yaml import Loader, SafeLoader, Dumper, SafeDumper
 
 from yamlable.base import AbstractYamlObject, NONE_IGNORE_CHECKS, read_yaml_node_as_dict
+from yamlable.yaml_objects import YamlObject2
+
 
 YAMLABLE_PREFIX = '!yamlable/'
 
 
-@add_metaclass(ABCMeta)
 class AbstractYamlAble(AbstractYamlObject):
     """
     The abstract part of YamlAble. It might be useful to inherit if you want to create a super class for several

yamlable/tests/test_yamlable.py

@@ -4,7 +4,7 @@
 import pytest
 from yaml import dump, load
 
-from yamlable import YamlAble, yaml_info, YT_co
+from yamlable import YamlAble, yaml_info, AYO
 
 
 def test_yamlable_incomplete_description():
@@ -16,7 +16,7 @@ def to_yaml_dict(self) -> Dict[str, Any]:
                 return copy(vars(self))
 
             @classmethod
-            def from_yaml_dict(cls: 'Type[YT_co]', dct: Dict, yaml_tag: str) -> YT_co:
+            def from_yaml_dict(cls: 'Type[AYO]', dct: Dict, yaml_tag: str) -> AYO:
                 return Foo(**dct)
 
         # instantiate
@@ -46,7 +46,7 @@ def to_yaml_dict(self) -> Dict[str, Any]:
             return copy(vars(self))
 
         @classmethod
-        def from_yaml_dict(cls: 'Type[YT_co]', dct: Dict, yaml_tag: str) -> YT_co:
+        def from_yaml_dict(cls: 'Type[AYO]', dct: Dict, yaml_tag: str) -> AYO:
             return Foo(**dct)
 
     # instantiate
@@ -84,7 +84,7 @@ def to_yaml_dict(self) -> Dict[str, Any]:
             return copy(vars(self))
 
         @classmethod
-        def from_yaml_dict(cls: 'Type[YT_co]', dct: Dict, yaml_tag: str) -> YT_co:
+        def from_yaml_dict(cls: 'Type[AYO]', dct: Dict, yaml_tag: str) -> AYO:
             return Foo_Err(**dct)
 
         @classmethod

yamlable/tests/test_yamlobjects.py

@@ -3,7 +3,7 @@
 
 import pytest
 
-from yamlable import YamlObject2, YT_co
+from yamlable import YamlObject2, AYO
 
 
 def test_yamlobject_incomplete_description():
@@ -33,7 +33,7 @@ def to_yaml_dict(self) -> Dict[str, Any]:
             return copy(vars(self))
 
         @classmethod
-        def from_yaml_dict(cls: 'Type[YT_co]', dct: Dict, yaml_tag: str) -> YT_co:
+        def from_yaml_dict(cls: 'Type[AYO]', dct: Dict, yaml_tag: str) -> AYO:
             return Foo(**dct)
 
     # instantiate

yamlable/yaml_objects.py

@@ -8,14 +8,15 @@
 
 from yamlable.base import NONE_IGNORE_CHECKS, AbstractYamlObject, read_yaml_node_as_dict
 
-SYO = TypeVar('SYO', bound='YamlObject2')
+
+YO2 = TypeVar('YO2', bound='YamlObject2')
 
 
 class YAMLObjectMetaclassStrict(YAMLObjectMetaclass):
     """
     Improved metaclass for YAMLObject, that raises an error if yaml_tag is not defined
     """
-    def __init__(cls: 'Type[SYO]', name, bases, kwds):
+    def __init__(cls: 'Type[YO2]', name, bases, kwds):
 
         # construct as usual
         super(YAMLObjectMetaclass, cls).__init__(name, bases, kwds)