Names used in include and exclude are now correctly taken into account by autodict and autohash even if the names correspond to property names and therefore the actual attributes names start with an underscore. Fixes #21

Author: Sylvain MARIE

autoclass/autodict_.py

@@ -297,8 +297,8 @@ def __iter__(self):
                     :param self:
                     :return:
                     """
-                    for att_name in (list(vars(self)) + [o for o in super(object_type, self).__iter__()
-                                                         if o not in vars(self)]):
+                    myattrs = [possibly_replace_with_property_name(self.__class__, att_name) for att_name in vars(self)]
+                    for att_name in myattrs + [o for o in super(object_type, self).__iter__() if o not in vars(self)]:
                         if is_attr_selected(att_name, include=include, exclude=exclude):
                             if not only_public_fields \
                                     or (only_public_fields and not att_name.startswith(private_name_prefix)):
@@ -311,7 +311,8 @@ def __iter__(self):
                     :param self:
                     :return:
                     """
-                    for att_name in vars(self):
+                    for att_name in [possibly_replace_with_property_name(self.__class__, att_name)
+                                     for att_name in vars(self)]:
                         if is_attr_selected(att_name, include=include, exclude=exclude):
                             if not only_public_fields \
                                     or (only_public_fields and not att_name.startswith(private_name_prefix)):
@@ -337,6 +338,7 @@ def __getitem__(self, key):
                     :return:
                     """
                     if hasattr(self, key):
+                        key = possibly_replace_with_property_name(self.__class__, key)
                         if is_attr_selected(key, include=include, exclude=exclude) and \
                                 (not only_public_fields or
                                  (only_public_fields and not key.startswith(private_name_prefix))):
@@ -366,6 +368,7 @@ def __getitem__(self, key):
                     :return:
                     """
                     if hasattr(self, key):
+                        key = possibly_replace_with_property_name(self.__class__, key)
                         if is_attr_selected(key, include=include, exclude=exclude) and \
                                 (not only_public_fields or
                                  (only_public_fields and not key.startswith(private_name_prefix))):

autoclass/autohash_.py

@@ -177,6 +177,7 @@ def __hash__(self):
                     to_hash = []
 
                     for att_name, att_value in vars(self).items():
+                        att_name = possibly_replace_with_property_name(self.__class__, att_name)
                         if is_attr_selected(att_name, include=include, exclude=exclude):
                             if not only_public_fields \
                                     or (only_public_fields and not att_name.startswith(private_name_prefix)):

autoclass/tests/test_autohash.py

@@ -84,19 +84,40 @@ class Dummy2:
     assert hash(a) != hash(f)
 
 
-@pytest.mark.xfail(reason='Currently the test does not work, see https://github.com/smarie/python-autoclass/issues/21')
 def test_autohash_exclude():
     """ Tests that exclusion works correctly with autohash """
 
-    # Currently the test does not work, see https://github.com/smarie/python-autoclass/issues/21
     @autoclass(autohash=False)
-    @autohash(exclude='bar')
-    class Foo:
+    @autohash(exclude='bar')  # we have to put an underscore because that's the property
+    class Foo(object):
         def __init__(self,
                      foo,  # type: str
                      bar   # type: Dict[str, str]
                      ):
             pass
 
     a = Foo('hello', dict())
-    hash(a)  # supposed to work since we exclude the dict (unhashable)
+    assert hash(a) == hash((a.foo, ))  # supposed to work since we exclude the dict (unhashable)
+
+    # combined tests (foo is transformed to a property)
+    @autoclass(include='foo')
+    class Foo(object):
+        def __init__(self,
+                     foo,  # type: str
+                     bar  # type: Dict[str, str]
+                     ):
+            pass
+
+    a = Foo('hello', dict())
+    assert hash(a) == hash((a.foo, ))  # supposed to work since we exclude the dict (unhashable)
+
+    @autoclass(exclude='bar')
+    class Foo(object):
+        def __init__(self,
+                     foo,  # type: str
+                     bar  # type: Dict[str, str]
+                     ):
+            pass
+
+    a = Foo('hello', dict())
+    assert hash(a) == hash((a.foo,))  # supposed to work since we exclude the dict (unhashable)

docs/index.md

@@ -6,6 +6,8 @@
 
 [![Documentation](https://img.shields.io/badge/doc-latest-blue.svg)](https://smarie.github.io/python-autoclass/) [![PyPI](https://img.shields.io/pypi/v/autoclass.svg)](https://pypi.python.org/pypi/autoclass/) [![Downloads](https://pepy.tech/badge/autoclass)](https://pepy.tech/project/autoclass) [![Downloads per week](https://pepy.tech/badge/autoclass/week)](https://pepy.tech/project/autoclass) [![GitHub stars](https://img.shields.io/github/stars/smarie/python-autoclass.svg)](https://github.com/smarie/python-autoclass/stargazers)
 
+!!! warning "`include` and `exclude` have been fixed in `@autodict` and `@autohash`, you do not need to add an underscore anymore when the attribute corresponds to a property. See [#21](https://github.com/smarie/python-autoclass/issues/21)"
+
 `autoclass` provides tools to automatically generate python classes code. The objective of this library is to reduce the amount of redundancy by automatically generating parts of the code from the information already available somewhere else (typically, in the constructor signature). It is made of several independent features that can be combined:
 
  * with `@autoargs` you don't have to write `self.xxx = xxx` in your constructor