TokenFreezeStatus and other status enums are unhashable — TypeError when used in dicts

[exploreriii]

Python's data model sets hash = None whenever a class defines eq without hash, so members of these enums are silently unhashable

Affected classes:

• TokenFreezeStatus
• TokenKycStatus
• TokenPauseStatus
• FreezeType
• TokenKeyValidation

[github-actions]

Thanks for your submission.

This issue is awaiting approval from @hiero-ledger/hiero-sdk-python-triage and @hiero-ledger/hiero-sdk-python-committers and @hiero-ledger/hiero-sdk-python-maintainers.

[github-actions]

Approved by @hiero-ledger/hiero-sdk-python-triage and @hiero-ledger/hiero-sdk-python-committers and @hiero-ledger/hiero-sdk-python-maintainers.

[github-actions]

@coderabbitai plan

[coderabbitai]

Coding Plan

Summary

• Fix the root cause by adding a value-based __hash__ to each of the five enums that override __eq__, restoring the hash implementation Python removed and following the codebase's existing hash(<identifying field>) convention.
• Preserve all existing equality and proto-conversion semantics — no changes to __eq__, _from_proto, or _to_proto.
• Guard against regressions by extending freeze_type_test.py and adding dedicated test files for the four token status enums, each asserting hashability and set/dict usability alongside equality.

Implementation Steps

Phase 1: Restore Hashability on the Affected Status Enums

This phase addresses the root cause across all five enums by reintroducing a hash implementation alongside each existing __eq__, following the established codebase convention. The goal is a minimal, consistent fix that keeps the current cross-type equality behavior (enum-vs-enum and enum-vs-int) intact while making members usable in sets and dicts again.

Task 1: Add `__hash__` to the token status enums

Restore hashability for the four token-related enums by defining a __hash__ that derives from the member's integer value, mirroring the hash(<identifying field>) pattern used by existing value objects like TokenId and Hbar.

• Update src/hiero_sdk_python/tokens/token_freeze_status.py to add a __hash__ method to TokenFreezeStatus returning hash(self.value).
• Update src/hiero_sdk_python/tokens/token_kyc_status.py to add the same __hash__ to TokenKycStatus.
• Update src/hiero_sdk_python/tokens/token_pause_status.py to add the same __hash__ to TokenPauseStatus.
• Update src/hiero_sdk_python/tokens/token_key_validation.py to add the same __hash__ to TokenKeyValidation.
• Keep the existing __eq__ and proto-conversion helpers unchanged; place __hash__ adjacent to __eq__ for readability.

Task 2: Add `__hash__` to the FreezeType enum

Restore hashability for the system freeze enum using the same value-based hash approach for consistency.

• Update src/hiero_sdk_python/system/freeze_type.py to add a __hash__ method to FreezeType returning hash(self.value), leaving its __eq__, _from_proto, and _to_proto untouched.

🤖 Prompt for AI agents

Implement a minimal fix restoring hashability on five protobuf-backed enums that
currently override `__eq__` without defining `__hash__` (which implicitly sets
`__hash__ = None`). The goal is to make members usable in sets and as dict keys
again, while keeping existing equality semantics (enum-vs-enum and enum-vs-int
comparisons) completely unchanged.

- In `src/hiero_sdk_python/tokens/token_freeze_status.py`, add a `__hash__`
method to `TokenFreezeStatus` that returns `hash(self.value)`.
- In `src/hiero_sdk_python/tokens/token_kyc_status.py`, add the same `__hash__`
method to `TokenKycStatus` returning `hash(self.value)`.
- In `src/hiero_sdk_python/tokens/token_pause_status.py`, add the same
`__hash__` method to `TokenPauseStatus` returning `hash(self.value)`.
- In `src/hiero_sdk_python/tokens/token_key_validation.py`, add the same
`__hash__` method to `TokenKeyValidation` returning `hash(self.value)`.
- In `src/hiero_sdk_python/system/freeze_type.py`, add a `__hash__` method to
`FreezeType` returning `hash(self.value)`.

For every class, do not modify the existing `__eq__`, `_from_proto`, or
`_to_proto` methods — leave them exactly as they are. Place the new `__hash__`
method adjacent to the existing `__eq__` method for readability, following the
`hash(<identifying field>)` convention already used elsewhere in the codebase
(e.g., `TokenId`, `Hbar`).

Phase 2: Test Coverage for Hashability and Equality

This phase locks in the fix and prevents regressions by exercising hash behavior and set/dict usage for all five enums, extending the existing enum test conventions.

Task 1: Extend the existing FreezeType tests

Add explicit hash coverage to the one affected enum that already has a dedicated test file.

• Update tests/unit/freeze_type_test.py to add a test_hash function asserting that hash(FreezeType.X) == hash(FreezeType.X), that distinct members hash consistently, and that members work as set elements and dict keys.
• Follow the existing test_eq style already present in this file and the test_hash/test_eq_and_hash patterns used in account_id_test.py and timestamp_test.py.

Task 2: Add dedicated test files for the token status enums

Provide first-class unit coverage for the four token status enums that currently lack dedicated tests.

• Create new test files under tests/unit/ (e.g., token_freeze_status_test.py, token_kyc_status_test.py, token_pause_status_test.py, token_key_validation_test.py), modeled on freeze_type_test.py.
• Each file should cover member .value/.name, _from_proto (and _to_proto where applicable), equality against both enum members and raw ints (test_eq), and a test_hash verifying hashability plus correct behavior in set/dict usage.

🤖 Prompt for AI agents

Add test coverage that locks in the hashability fix and prevents regressions for
all five enums, extending existing enum test conventions.

- Update `tests/unit/freeze_type_test.py` by adding a `test_hash` function that
asserts `hash(FreezeType.X) == hash(FreezeType.X)`, verifies distinct members
hash consistently, and confirms members work correctly as `set` elements and
`dict` keys. Follow the existing `test_eq` style already present in this file,
and mirror the `test_hash`/`test_eq_and_hash` patterns used in
`account_id_test.py` and `timestamp_test.py`.
- Create new dedicated test files under `tests/unit/` for the four token status
enums: `token_freeze_status_test.py`, `token_kyc_status_test.py`,
`token_pause_status_test.py`, and `token_key_validation_test.py`, each modeled
on `freeze_type_test.py`.
- In each new test file, cover: member `.value`/`.name` access; `_from_proto`
(and `_to_proto` where applicable) conversion; equality against both enum
members and raw ints via a `test_eq` function; and a `test_hash` function
verifying hashability plus correct behavior when used in a `set` or as `dict`
keys.

Research

The SDK models status-like protobuf enums as stdlib Enum subclasses located under src/hiero_sdk_python/tokens/ and src/hiero_sdk_python/system/. The five affected classes each follow an identical pattern: integer-keyed members, a custom __eq__ allowing comparison against both the same enum type and raw int proto values, plus _from_proto/_to_proto helpers — but no __hash__. Other enums (TokenType, SupplyType, HbarUnit, LogLevel, FeeAssessmentMethod) don't override __eq__ and remain hashable by default. Value-object classes such as AccountId, TokenId, Hbar, and EvmAddress already demonstrate the correct convention of pairing a custom __eq__ with a __hash__ derived from the identifying field(s). Unit tests live under tests/unit/, with freeze_type_test.py being the only affected enum with a dedicated test file; the four token status enums have none.

---

🚀 Next Steps

🤖 All AI agent prompts combined

Task: 1

Implement a minimal fix restoring hashability on five protobuf-backed enums that
currently override `__eq__` without defining `__hash__` (which implicitly sets
`__hash__ = None`). The goal is to make members usable in sets and as dict keys
again, while keeping existing equality semantics (enum-vs-enum and enum-vs-int
comparisons) completely unchanged.

- In `src/hiero_sdk_python/tokens/token_freeze_status.py`, add a `__hash__`
method to `TokenFreezeStatus` that returns `hash(self.value)`.
- In `src/hiero_sdk_python/tokens/token_kyc_status.py`, add the same `__hash__`
method to `TokenKycStatus` returning `hash(self.value)`.
- In `src/hiero_sdk_python/tokens/token_pause_status.py`, add the same
`__hash__` method to `TokenPauseStatus` returning `hash(self.value)`.
- In `src/hiero_sdk_python/tokens/token_key_validation.py`, add the same
`__hash__` method to `TokenKeyValidation` returning `hash(self.value)`.
- In `src/hiero_sdk_python/system/freeze_type.py`, add a `__hash__` method to
`FreezeType` returning `hash(self.value)`.

For every class, do not modify the existing `__eq__`, `_from_proto`, or
`_to_proto` methods — leave them exactly as they are. Place the new `__hash__`
method adjacent to the existing `__eq__` method for readability, following the
`hash(<identifying field>)` convention already used elsewhere in the codebase
(e.g., `TokenId`, `Hbar`).
===============================================================================

Task: 2

Add test coverage that locks in the hashability fix and prevents regressions for
all five enums, extending existing enum test conventions.

- Update `tests/unit/freeze_type_test.py` by adding a `test_hash` function that
asserts `hash(FreezeType.X) == hash(FreezeType.X)`, verifies distinct members
hash consistently, and confirms members work correctly as `set` elements and
`dict` keys. Follow the existing `test_eq` style already present in this file,
and mirror the `test_hash`/`test_eq_and_hash` patterns used in
`account_id_test.py` and `timestamp_test.py`.
- Create new dedicated test files under `tests/unit/` for the four token status
enums: `token_freeze_status_test.py`, `token_kyc_status_test.py`,
`token_pause_status_test.py`, and `token_key_validation_test.py`, each modeled
on `freeze_type_test.py`.
- In each new test file, cover: member `.value`/`.name` access; `_from_proto`
(and `_to_proto` where applicable) conversion; equality against both enum
members and raw ints via a `test_eq` function; and a `test_hash` function
verifying hashability plus correct behavior when used in a `set` or as `dict`
keys.

💡 Iterate on the plan with: `@coderabbitai` <feedback>

Example Feedback
- `@coderabbitai` You can skip phase 3. Add a simple unit test case for phase 2.
- `@coderabbitai` For design choice 1 go ahead with option 3 and replan.

---

💬 Have feedback or questions? Drop into our discord!