adding detailed__dict__ to address #312

Author: seperman

deepdiff/diff.py

@@ -20,7 +20,7 @@
                              type_is_subclass_of_type_group, type_in_type_group, get_doc,
                              number_to_string, datetime_normalize, KEY_TO_VAL_STR, booleans,
                              np_ndarray, get_numpy_ndarray_rows, OrderedSetPlus, RepeatedTimer,
-                             TEXT_VIEW, TREE_VIEW, DELTA_VIEW,
+                             TEXT_VIEW, TREE_VIEW, DELTA_VIEW, detailed__dict__,
                              np, get_truncate_datetime, dict_, CannotCompare)
 from deepdiff.serialization import SerializationMixin
 from deepdiff.distance import DistanceMixin
@@ -394,8 +394,8 @@ def _diff_obj(self, level, parents_ids=frozenset(),
                 t1 = level.t1._asdict()
                 t2 = level.t2._asdict()
             else:
-                t1 = level.t1.__dict__
-                t2 = level.t2.__dict__
+                t1 = detailed__dict__(level.t1)
+                t2 = detailed__dict__(level.t2)
         except AttributeError:
             try:
                 t1 = self._dict_from_slots(level.t1)

deepdiff/helper.py

@@ -582,3 +582,22 @@ def get_homogeneous_numpy_compatible_type_of_seq(seq):
         return PYTHON_TYPE_TO_NUMPY_TYPE.get(type_, False)
     else:
         return False
+
+
+def detailed__dict__(obj, ignore_private_variables=True):
+    """
+    Get the detailed dictionary of an object.
+
+    This is used so we retrieve object properties too.
+    """
+    result = obj.__dict__.copy()  # A shallow copy
+    for key in dir(obj):
+        if key not in result and (
+                not ignore_private_variables or (
+                    ignore_private_variables and not key.startswith('__')
+                )
+        ):
+            value = getattr(obj, key)
+            if not callable(value):
+                result[key] = value
+    return result

docs/deephash_doc.rst

@@ -149,6 +149,12 @@ truncate_datetime: string, default = None
     If your object is nested, it will build hashes of all the objects it contains too.
 
 
+.. note::
+    DeepHash output is not like conventional hash functions. It is a dictionary of object IDs to their hashes. This happens because DeepHash calculates the hash of the object and any other objects found within the object in a recursive manner. If you only need the hash of the object you are passing, all you need to do is to do:
+
+    >>> DeepHash(obj)[obj]
+
+
 **Examples**
 
 Let's say you have a dictionary object.

tests/test_diff_text.py

@@ -3,6 +3,7 @@
 import pytest
 import logging
 import uuid
+import numpy as np
 from decimal import Decimal
 from deepdiff import DeepDiff
 from deepdiff.helper import pypy3
@@ -569,7 +570,15 @@ class MyEnum(Enum):
                 'root._value_': {
                     'old_value': 1,
                     'new_value': 2
-                }
+                },
+                'root.name': {
+                    'old_value': 'A',
+                    'new_value': 'B'
+                },
+                'root.value': {
+                    'old_value': 1,
+                    'new_value': 2
+                },
             }
         }
         assert ddiff == result
@@ -1594,3 +1603,22 @@ def test_datetime_in_key(self):
         expected = {'values_changed': {f'root[{repr(now)}]': {'new_value': 2, 'old_value': 1}}}
 
         assert expected == diff
+
+    def test_property_values(self):
+
+        class A:
+            _thing = 0
+
+            def __init__(self, a):
+                self.a = a
+
+            @property
+            def thing(self):
+                A._thing += 1
+                return A._thing
+
+        diff = DeepDiff(A(1), A(1))
+        expected = {'values_changed': {'root._thing': {'new_value': 1, 'old_value': 0},
+                    'root.thing': {'new_value': 2, 'old_value': 1}}}
+
+        assert expected == diff