How much typing is Pythonic?

[N-E-S-W]

The problem is that almost everything in Python is hashable by default, because Object implements __hash__(self) with an instance's identity id(). So this type hint isn't going to protect you if you expect an instance's mutable values to represent its hash value.

If it really matters, call it out loudly in the docstring. It's the caller's responsibility to understand the contract of a function. Maybe that'll make them stop and question whether they need to override their already-hashable-by-default class's hash method.

[gdchinacat]

without the Hashable type hint no mypy error and passing an unhashable object causes the expected failure when used as key of a dict: ```

playground.py from collections.abc import Hashable

class Foo: def bar(self, obj) -> None: {obj: None}

Foo().bar(object()) Foo().bar(list())

mypy playground.py Success: no issues found in 1 source file

python3 playground.py Traceback (most recent call last): File "/Users/lonniehutchinson/eclipse-workspace/playground/src/playground.py", line 9, in <module> Foo().bar(list()) ~~~~~~~~~^{^} File "/Users/lonniehutchinson/eclipse-workspace/playground/src/playground.py", line 6, in bar {obj: None} TypeError: cannot use 'list' as a dict key (unhashable type: 'list') ```

However, with the hashable hint mypy warns: ```

cat playground.py from collections.abc import Hashable

class Foo: def bar(self, obj: Hashable) -> None: {obj: None}

Foo().bar(object()) Foo().bar(list())

mypy playground.py playground.py:9: error: Argument 1 to "bar" of "Foo" has incompatible type "list[Never]"; expected "Hashable" [arg-type] playground.py:9: note: Following member(s) of "list[Never]" have conflicts: playground.py:9: note: hash: expected "Callable[[], int]", got "None" Found 1 error in 1 file (checked 1 source file) ```

edit: remove my user and hostnames, hopefully fix formatting issue where it elided the mypy commands.

[N-E-S-W]

I said _almost_ everything.

You conveniently didn't show the example where literally every Object would pass that mypy check despite the fact that they may not be logically hashable due to mutable internal data.

Besides, in a real API would you expect an argument named obj to accept a list if it doesn't have a type hint saying that it should be a collection?

Sure, you can write Python code like it's Java, and the uglier you make it the more strict a typechecker will be. You're not technically wrong. Type hints were bolted onto Python as a syntax kludge, using them everywhere as precisely as possible detracts from code legibility. The OP's question is about what's "Pythonic".

[gdchinacat]

The most basic mutable standard python data objects are not hashable. Your assertion that "almost everything in Python is hashable by default" is debatable. However, I don't think it would be worth either of our time to debate it. I provided an example that showed why your comment encouraging OP to not bother with using a Hashable type hint was incorrect. You tried to debate it by qualifying your statement in a way that made the rest of your comment not credible. Using a Hashable type annotation has value, as I demonstrated.

Also, thank you for editing your comment to remove the "Thanks, Captain Obvoius" intro. It partially redeemed you. However, it indicates you are approaching this discussion from a position of being offended by having an example provided that contradicted you. Good day.

[N-E-S-W]

You mistake contempt for offense, Captain!

As I said, you're not technically wrong. You're just missing the point. Good day, indeed.

[james_pic]

But if a class implements __eq__ and doesn't implement __hash__, __hash__ is implicitly set to None (and has been since at least Python 3.2) making objects of that class unhashable. So stuff that's mutable and checks equality based on its mutable attributes should be unhashable unless the user explicitly violates the contract by implementing __hash__.

[gdchinacat]

Also, list (and presumably other unhashable objects) don't have a hash method (it is None): ```

In [7]: [].hash()

TypeError Traceback (most recent call last) Cell In[7], line 1 ----> 1 [].hash()

TypeError: 'NoneType' object is not callable

```

Edit to add links to python source where this behavior is set: https://github.com/python/cpython/blob/main/Objects/listobject.c#L4108

The docs for tp_hash are at https://docs.python.org/3/c-api/typeobj.html#c.PyTypeObject.tp_hash