refactor: fix hash method parameter naming and key handling

Changed hash method parameters to align with Redis/Valkey terminology:
- Renamed 'name' → 'key' (the Redis key for the hash)
- Renamed 'key' → 'field' (the field within the hash)
- Changed type from 'str' to 'KeyT' for consistency with other methods
- Added 'version' parameter support to hlen() and hkeys()

Fixed make_key() application:
- make_key() now only applied to hash key (first parameter)
- Fields are no longer transformed with make_key()
- This fixes the namespacing issue where fields were incorrectly prefixed
- hkeys() now returns plain field names without reverse_key processing

Added comprehensive test for version support across all hash methods.

This improves API clarity and consistency with Redis/Valkey documentation
where 'key' refers to the Redis key (name of the hash structure) and
'field' refers to a field within that hash.

Changed methods:
- hset(key, field, value, ...)
- hdel(key, field, ...)
- hlen(key, ...)
- hkeys(key, ...)
- hexists(key, field, ...)

All hash-related tests pass with the new implementation.

Co-authored-by: 2ykwang <yk2ykwang@gmail.com>

Author: oliverhaas

changelog.d/812.misc

@@ -0,0 +1 @@
+Fix hash method parameters: rename 'name' → 'key', 'key' → 'field' to align with Redis/Valkey terminology. Add version parameter to hlen() and hkeys(). Fix make_key() to only apply to hash key, not fields.

django_redis/client/default.py

@@ -1131,76 +1131,80 @@ def touch(
 
     def hset(
         self,
-        name: str,
         key: KeyT,
+        field: KeyT,
         value: EncodableT,
         version: Optional[int] = None,
         client: Optional[Redis] = None,
     ) -> int:
         """
-        Set the value of hash name at key to value.
+        Set the value of hash key at field to value.
         Returns the number of fields added to the hash.
         """
         if client is None:
             client = self.get_client(write=True)
         nkey = self.make_key(key, version=version)
         nvalue = self.encode(value)
-        return int(client.hset(name, nkey, nvalue))
+        return int(client.hset(nkey, field, nvalue))
 
     def hdel(
         self,
-        name: str,
         key: KeyT,
+        field: KeyT,
         version: Optional[int] = None,
         client: Optional[Redis] = None,
     ) -> int:
         """
-        Remove keys from hash name.
+        Remove fields from hash key.
         Returns the number of fields deleted from the hash.
         """
         if client is None:
             client = self.get_client(write=True)
         nkey = self.make_key(key, version=version)
-        return int(client.hdel(name, nkey))
+        return int(client.hdel(nkey, field))
 
     def hlen(
         self,
-        name: str,
+        key: KeyT,
+        version: Optional[int] = None,
         client: Optional[Redis] = None,
     ) -> int:
         """
-        Return the number of items in hash name.
+        Return the number of items in hash key.
         """
         if client is None:
             client = self.get_client(write=False)
-        return int(client.hlen(name))
+        nkey = self.make_key(key, version=version)
+        return int(client.hlen(nkey))
 
     def hkeys(
         self,
-        name: str,
+        key: KeyT,
+        version: Optional[int] = None,
         client: Optional[Redis] = None,
     ) -> list[Any]:
         """
-        Return a list of keys in hash name.
+        Return a list of fields in hash key.
         """
         if client is None:
             client = self.get_client(write=False)
+        nkey = self.make_key(key, version=version)
         try:
-            return [self.reverse_key(k.decode()) for k in client.hkeys(name)]
+            return [k.decode() for k in client.hkeys(nkey)]
         except _main_exceptions as e:
             raise ConnectionInterrupted(connection=client) from e
 
     def hexists(
         self,
-        name: str,
         key: KeyT,
+        field: KeyT,
         version: Optional[int] = None,
         client: Optional[Redis] = None,
     ) -> bool:
         """
-        Return True if key exists in hash name, else False.
+        Return True if field exists in hash key, else False.
         """
         if client is None:
             client = self.get_client(write=False)
         nkey = self.make_key(key, version=version)
-        return bool(client.hexists(name, nkey))
+        return bool(client.hexists(nkey, field))

tests/test_backend.py

@@ -871,6 +871,41 @@ def test_hexists(self, cache: RedisCache):
         assert cache.hexists("foo_hash5", "foo1")
         assert not cache.hexists("foo_hash5", "foo")
 
+    def test_hash_version_support(self, cache: RedisCache):
+        """Test that version parameter works correctly for hash methods."""
+        if isinstance(cache.client, ShardClient):
+            pytest.skip("ShardClient doesn't support get_client")
+
+        # Set values with different versions
+        cache.hset("my_hash", "field1", "value1", version=1)
+        cache.hset("my_hash", "field2", "value2", version=1)
+        cache.hset("my_hash", "field1", "different_value", version=2)
+
+        # Verify both versions exist independently
+        assert cache.hexists("my_hash", "field1", version=1)
+        assert cache.hexists("my_hash", "field2", version=1)
+        assert cache.hexists("my_hash", "field1", version=2)
+        assert not cache.hexists("my_hash", "field2", version=2)
+
+        # Verify hlen works with versions
+        assert cache.hlen("my_hash", version=1) == 2
+        assert cache.hlen("my_hash", version=2) == 1
+
+        # Verify hkeys works with versions
+        keys_v1 = cache.hkeys("my_hash", version=1)
+        assert len(keys_v1) == 2
+        assert "field1" in keys_v1
+        assert "field2" in keys_v1
+
+        keys_v2 = cache.hkeys("my_hash", version=2)
+        assert len(keys_v2) == 1
+        assert "field1" in keys_v2
+
+        # Verify hdel works with versions
+        cache.hdel("my_hash", "field1", version=1)
+        assert not cache.hexists("my_hash", "field1", version=1)
+        assert cache.hexists("my_hash", "field1", version=2)  # v2 should still exist
+
     def test_sadd(self, cache: RedisCache):
         assert cache.sadd("foo", "bar") == 1
         assert cache.smembers("foo") == {"bar"}