option to ignore type changes (unicode vs string), or (datetime vs string).

[kapilt]

working with comparing previous versions of objects to the api, the revision storage creates some natural deltas from strings to unicode, and from datetime objects to iso strings.

[seperman]

Interesting. I wonder whether this should be done by DeepDiff or it is a use case that should be done outside DeepDiff.

[finnhughes]

It would have been helpful for me saving me from having to do a bunch of unicode casts and worse some ugly BSON related casts in my tests when a python equality comparison is happy to ignore the type difference as long as the values match. Obviously it would have to be optional since DeepDiff being fussy about type is a great feature at other times.

[phoebebright]

I agree, particularly be able to ignore unicode vs. string optionally.

[aexvir]

I also agree. I find necessary to compare dicts without comparing the types of the values

[flomotlik]

Any thoughts on this? Would definitely be helpful, happy to lend a hand if you have an implementation in mind.

[itaykatz]

I agree, first I'v thought that the exclude_type argument would satisfy this requirement but it totally excludes the validation process for any given item which applies to the given types.

[seperman]

Hello. Thank you for letting us know about why you need this feature. I am working on a plugin system for DeepDiff to allow easier customization of DeepDiff for such use cases. I will keep you posted. Thank you for your patience.

[wisotzky]

Would like to add another use-case:
In dicts there are several ways to declare a key/value pair is unset. Examples could be: zero-length string, empty dictionary or NoneType. In those cases, I would like to have the option, that just the value change is reported but not the type change. Reasoning is, that during parsing a document and generating the dict - the parser might not know the data-type for unset values. So it would be best guess of the parser to use any of the implementations above. Deepdiff should have the option ignore such type changes (just in the case of unset values)...

Examples to encode <a/> (unset value) as a python dict:

x1 = {u'a': None}
x2 = {u'a': u''}
x3 = {u'a': {}}
x4 = {u'a': []}

To compare against:

z1={u'a': u'#myvalue#'}
z2={u'a': {u'b': u'c'}}

So instead of:

>>> deepdiff.DeepDiff(x1,z1, view='patch')
{'type_changes': {"root['a']": {'new_type': <type 'unicode'>, 'old_type': <type 'NoneType'>, 'old_value': None, 'new_value': u'#myvalue#'}}}

Result should be:

>>> deepdiff.DeepDiff(x1,z1, view='patch')
{'values_changed': {"root['a']": {'new_value': u'#myvalue#', 'old_value': None}}}

Alternatively of the tool might report:

>>> deepdiff.DeepDiff(x1,z1, view='patch')
{'values_added': {"root['a']": u'#myvalue#'}}

[nemani]

I need this too! Can help if you need me to, too :)

I want to diff 2 objects, I just need the difference in values and not in the type.

[ruiruige]

sorry to comment in an old issue.
Is this feature supported?