More consistent hashing in dictionary with python objects?

Question

So, I saw Hashing a dictionary?, and I was trying to figure out a way to handle python native objects better and produce stable results.

After looking at all the answers + comments this is what I came to and everything seems to work properly, but am I maybe missing something that would make my hashing inconsistent (besides hash algorithm collisions)?

md5(repr(nested_dict).encode()).hexdigest()

tl;dr: it creates a string with the repr and then hashes the string.

Generated my testing nested dict with this:

for i in range(100):
    for j in range(100):
        if not nested_dict.get(i,None):
            nested_dict[i] = {}
        nested_dict[i][j] = ''

I'd imagine the repr should be able to support any python object, since most have to have the __repr__ support in general, but I'm still pretty new to python programming. One thing that I've heard of when using from reprlib import repr instead of the stdlib one that it'll truncate large sequences. So, that's one potential downfall, but it seems like the native list and set types don't do that.

other notes:

• I'm not able to use https://stackoverflow.com/a/5884123, because I'm going to have nested dictionaries.
• I used python 3.9.7 when testing this out.
• Not able to use https://stackoverflow.com/a/22003440, because at the time of hashing it still has IPv4 address objects as keys. (json.dumps didn't like that too much )

Answer 1

Python dicts are insert ordered. The repr respects that. Your hexdigest of {"A":1,"B":2} will differ from {"B":2,"A":1} whereas == - wise those dicts are the same.

Yours won't work out:

from  hashlib import md5

def yourHash(d):
    return md5(repr(d).encode()).hexdigest()

a = {"A":1,"B":2}
b = {"B":2,"A":1}

print(repr(a)) 
print(repr(b))
print (a==b)

print(yourHash(a) == yourHash(b))

gives

{'A': 1, 'B': 2}   # repr a
{'B': 2, 'A': 1}   # repr b
True               # a == b

False              # your hashes equall'ed

I really do not see the "sense" in hashing dicts at all ... and those ones here are not even "nested".

---

You could try JSON to sort keys down to the last nested one and using the json.dumps() of the whole structure to be hashed - but still - don't see the sense and it will give you plenty computational overhead:

import json
a = {"A":1,"B":2, "C":{2:1,3:2}}
b = {"B":2,"A":1, "C":{3:2,2:1}}

for di in (a,b):
    print(json.dumps(di,sort_keys=True))

gives

{"A": 1, "B": 2, "C": {"2": 1, "3": 2}}  # thouroughly sorted
{"A": 1, "B": 2, "C": {"2": 1, "3": 2}}  # recursively...

which is exactly what this answer in Hashing a dictionary? proposes ... why stray from it?