Python 2.7 is now supported. Fixed #5

 - assume that all string constants defined inside the code are unicode strings
 - transformedd all type hints into type hint comments, made typing import optional
 - removed one forbidden construct
 - using StringIO from StringIO (with added context manager behaviour)
 - using six.with_metaclass
 - python 2.7 declared in travis and setup.py

Also made travis script more robust for forks/PR

Author: smarie

.travis.yml

@@ -4,7 +4,7 @@ cache: pip
 
 python:
 #  - "2.6"
-#  - "2.7"
+  - "2.7"
 #  - "3.2"
 #  - "3.3"
 #  - "3.4"
@@ -62,17 +62,22 @@ after_success:
   # mkdocs gh-deploy requires special care :
   # ---grant the possibility to push on the repo---
   - openssl aes-256-cbc -K $encrypted_a3be41b6f539_key -iv $encrypted_a3be41b6f539_iv -in ci_tools/github_travis_rsa.enc -out ci_tools/github_travis_rsa -d
-  - chmod 600 ci_tools/github_travis_rsa
-  - eval `ssh-agent -s`  # launch the authentication agent
-  - ssh-add ci_tools/github_travis_rsa  # register the key
-  - git config user.name "Automatic Publish"
-  - git config user.email "sylvain.marie@schneider-electric.com"
-  - git remote add gh-remote "${GH_REF}";
-  - git fetch gh-remote && git fetch gh-remote gh-pages:gh-pages;
-  # push but only if this is not a build triggered by a pull request
-  # note: here we use the --dirty flag so that mkdocs does not clean the additional reports that we copied in the site
-  - if [ "${TRAVIS_PULL_REQUEST}" = "false" ] && [ "${TRAVIS_PYTHON_VERSION}" = "3.5" ]; then echo "Pushing to github"; PYTHONPATH=yamlable/ mkdocs gh-deploy -v --dirty -f docs/mkdocs.yml --remote-name gh-remote; git push gh-remote gh-pages; fi;
-#  - if [ "${TRAVIS_PULL_REQUEST}" = "false" ] && [ "${TRAVIS_PYTHON_VERSION}" = "3.5" ]; then echo "Pushing to github"; git push gh-remote gh-pages; fi;
+  # If the output file does not exist, that is because the secret is invalid. This can happen in forked repos so do not fail the build
+  - |
+    if [ -s "ci_tools/github_travis_rsa" ]; then
+      chmod 600 ci_tools/github_travis_rsa
+      eval `ssh-agent -s`  # launch the authentication agent
+      ssh-add ci_tools/github_travis_rsa  # register the key
+      git config user.name "Automatic Publish"
+      git config user.email "sylvain.marie@schneider-electric.com"
+      git remote add gh-remote "${GH_REF}";
+      git fetch gh-remote && git fetch gh-remote gh-pages:gh-pages;
+      # push but only if this is not a build triggered by a pull request
+      # note: here we use the --dirty flag so that mkdocs does not clean the additional reports that we copied in the site
+      if [ "${TRAVIS_PULL_REQUEST}" = "false" ] && [ "${TRAVIS_PYTHON_VERSION}" = "3.5" ]; then echo "Pushing to github"; PYTHONPATH=yamlable/ mkdocs gh-deploy -v --dirty -f docs/mkdocs.yml --remote-name gh-remote; git push gh-remote gh-pages; fi;
+    else
+      echo "File 'ci_tools/github_travis_rsa' has not been created, please check your encrypted repo token in .travis.yml, on the line starting with 'openssl aes-256-cbc...'"
+    fi
 
 deploy:
   provider: pypi

setup.py

@@ -94,7 +94,7 @@
         # that you indicate whether you support Python 2, Python 3 or both.
         # 'Programming Language :: Python :: 2',
         # 'Programming Language :: Python :: 2.6',
-        # 'Programming Language :: Python :: 2.7',
+        'Programming Language :: Python :: 2.7',
         # 'Programming Language :: Python :: 3',
         # 'Programming Language :: Python :: 3.3',
         # 'Programming Language :: Python :: 3.4',

yamlable/__init__.py

@@ -1,6 +1,16 @@
-from yamlable.base import AbstractYamlObject, NONE_IGNORE_CHECKS, Y, read_yaml_node_as_dict
-from yamlable.main import YamlCodec, register_yamlable_codec, yaml_info_decorate, yaml_info, YamlAble, YA, \
+try:  # python 3.5+
+    from yamlable.base import Y
+except ImportError:
+    pass
+from yamlable.base import AbstractYamlObject, NONE_IGNORE_CHECKS, read_yaml_node_as_dict
+
+try:  # python 3.5+
+    from yamlable.main import YA
+except ImportError:
+    pass
+from yamlable.main import YamlCodec, register_yamlable_codec, yaml_info_decorate, yaml_info, YamlAble, \
     AbstractYamlAble, YAMLABLE_PREFIX
+
 from yamlable.yaml_objects import YamlObject2, ABCYAMLMeta, YAMLObjectMetaclassStrict
 
 __all__ = ['base', 'main', 'yaml_objects',

yamlable/base.py

@@ -1,19 +1,40 @@
-from abc import ABC
+from abc import ABCMeta
 from collections import OrderedDict
-from io import TextIOBase, StringIO
-from typing import Union, TypeVar, Dict, Any
-from warnings import warn
 
 try:
-    from typing import Type
+    # Python 2 only:
+    from StringIO import StringIO
+
+    # create a variant that can serve as a context manager
+    class StringIO(StringIO):
+        def __enter__(self):
+            return self
+        def __exit__(self, exception_type, exception_value, traceback):
+            self.close()
+
 except ImportError:
-    pass # normal for old versions of typing
+    # (IOBase is only used in type hints)
+    from io import IOBase, StringIO
+
+from warnings import warn
 
+import six
 
-Y = TypeVar('Y', bound='AbstractYamlObject')
+try:  # python 3.5+
+    from typing import Union, TypeVar, Dict, Any
+
+    Y = TypeVar('Y', bound='AbstractYamlObject')
+
+except ImportError:
+    pass
+
+try:  # python 3.5.4+
+    from typing import Type
+except ImportError:
+    pass # normal for old versions of typing
 
 
-class AbstractYamlObject(ABC):
+class AbstractYamlObject(six.with_metaclass(ABCMeta, object)):
     """
     Adds convenient methods load(s)_yaml/dump(s)_yaml to any object, to call pyyaml features directly on the object or
     on the object class.
@@ -22,24 +43,30 @@ class AbstractYamlObject(ABC):
     Default implementation uses vars(self) and cls(**dct), but subclasses can override.
     """
 
-    def __to_yaml_dict__(self) -> Dict[str, Any]:
+    def __to_yaml_dict__(self):
+        # type: (...) -> Dict[str, Any]
         """
         Implementors should transform the object into a dictionary containing all information necessary to decode the
         object in the future. That dictionary will be serialized as a YAML mapping.
 
         Default implementation returns vars(self). TODO maybe some day we'll need to rather make a copy...?
         :return:
         """
-        # Legacy compliance TODO remove in future version
+        # Legacy compliance with old 'not dunder' method name TODO remove in future version
         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()
 
+        # Default: return vars
         return vars(self)
 
     @classmethod
-    def __from_yaml_dict__(cls: 'Type[Y]', dct: Dict[Any, Any], yaml_tag: str) -> Y:
+    def __from_yaml_dict__(cls,      # type: Type[Y]
+                           dct,      # type: Dict[str, Any]
+                           yaml_tag  # type: str
+                           ):
+        # type: (...) -> Y
         """
         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.
@@ -54,15 +81,21 @@ def __from_yaml_dict__(cls: 'Type[Y]', dct: Dict[Any, Any], yaml_tag: str) -> Y:
             against is_json_schema_id_supported)
         :return:
         """
-        # Legacy compliance TODO remove in future version
+        # Legacy compliance with old 'not dunder' method name TODO remove in future version
         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)
 
+        # Default: call constructor with all keyword arguments
         return cls(**dct)
 
-    def dump_yaml(self, file_path_or_stream: Union[str, TextIOBase], safe: bool = True, **pyyaml_kwargs):
+    def dump_yaml(self,
+                  file_path_or_stream,  # type: Union[str, IOBase, StrinIO]
+                  safe=True,            # type: bool
+                  **pyyaml_kwargs       # type: Dict[str, Any]
+                  ):
+        # type: (...) -> None
         """
         Dumps this object to a yaml file or stream using pyYaml.
 
@@ -85,7 +118,11 @@ def dump_yaml(self, file_path_or_stream: Union[str, TextIOBase], safe: bool = Tr
                 else:
                     dump(self, f, **pyyaml_kwargs)
 
-    def dumps_yaml(self, safe: bool = True, **pyyaml_kwargs):
+    def dumps_yaml(self,
+                   safe=True,       # type: bool
+                   **pyyaml_kwargs  # type: Dict[str, Any]
+                   ):
+        # type: (...) -> str
         """
         Dumps this object to a yaml string and returns it.
 
@@ -100,7 +137,11 @@ def dumps_yaml(self, safe: bool = True, **pyyaml_kwargs):
             return dump(self, **pyyaml_kwargs)
 
     @classmethod
-    def loads_yaml(cls: 'Type[Y]', yaml_str: str, safe: bool=True) -> Y:
+    def loads_yaml(cls,          # type: Type[Y]
+                   yaml_str,     # type: str
+                   safe=True     # type: bool
+                   ):
+        # type: (...) -> Y
         """
         Utility method to load an instance of this class from the provided yaml string. This methods only returns
         successfully if the result is an instance of `cls`.
@@ -112,7 +153,11 @@ def loads_yaml(cls: 'Type[Y]', yaml_str: str, safe: bool=True) -> Y:
         return cls.load_yaml(StringIO(yaml_str), safe=safe)
 
     @classmethod
-    def load_yaml(cls: 'Type[Y]', file_path_or_stream: Union[str, TextIOBase], safe: bool=True) -> Y:
+    def load_yaml(cls,                  # type: Type[Y]
+                  file_path_or_stream,  # type: Union[str, IOBase, StringIO]
+                  safe=True             # type: bool
+                  ):
+        # type: (...) -> Y
         """
         Parses the given file path or stream as a yaml document. This methods only returns successfully if the result
         is an instance of `cls`.