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

[seperman]

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

[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.

[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.

[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?

[seperman]

Hi @kapilt @ruiruige @nemaniarjun @wisotzky @itaykatz @flomotlik @aexvir @phoebebright @finnhughes

We have ignore_type_in_groups now. I think that should solve most of the problems that are brought up in this ticket.

You can read about it here: https://deepdiff.readthedocs.io/en/latest/diff.html

Closing this ticket finally!