Merge branch 'main' into types

Author: Rafiot

.github/workflows/integration.yaml

@@ -58,7 +58,7 @@ jobs:
        - uses: actions/checkout@v4
        - name: Cache docker images
          id: custom-cache
-         uses: actions/cache@v3
+         uses: actions/cache@v4
          with:
            path: ./custom-cache/
            key: custom-cache
@@ -94,7 +94,7 @@ jobs:
 
        - name: Cache docker images
          id: custom-cache
-         uses: actions/cache@v3
+         uses: actions/cache@v4
          with:
            path: ./custom-cache/
            fail-on-cache-miss: true
@@ -150,7 +150,7 @@ jobs:
 
       - name: Cache docker images
         id: custom-cache
-        uses: actions/cache@v3
+        uses: actions/cache@v4
         with:
           path: ./custom-cache/
           fail-on-cache-miss: true

.github/workflows/spellcheck.yml

@@ -8,7 +8,7 @@ jobs:
       - name: Checkout
         uses: actions/checkout@v4
       - name: Check Spelling
-        uses: rojopolis/spellcheck-github-actions@0.41.0
+        uses: rojopolis/spellcheck-github-actions@0.42.0
         with:
           config_path: .github/spellcheck-settings.yml
           task_name: Markdown

CONTRIBUTING.md

@@ -96,7 +96,7 @@ Here's how to get started with your code contribution:
         c.  pip install -r dev_requirements.txt
         c.  pip install -r requirements.txt
 
-4.  If you need a development environment, run `invoke devenv`. Note: this relies on docker-compose to build environments, and assumes that you have a version supporting [docker profiles](https://docs.docker.com/compose/profiles/).
+4.  If you need a development environment, run `invoke devenv`. Note: this relies on docker compose to build environments, and assumes that you have a version supporting [docker profiles](https://docs.docker.com/compose/profiles/).
 5.  While developing, make sure the tests pass by running `invoke tests`
 6.  If you like the change and think the project could use it, send a
     pull request

README.md

@@ -9,7 +9,7 @@ The Python interface to the Valkey key-value store.
 [![pre-release](https://img.shields.io/github/v/release/valkey-io/valkey-py?include_prereleases&label=latest-prerelease)](https://github.com/valkey-io/valkey-py/releases)
 [![codecov](https://codecov.io/gh/valkey-io/valkey-py/branch/main/graph/badge.svg?token=yenl5fzxxr)](https://codecov.io/gh/valkey-io/valkey-py)
 
-[Installation](#installation) |  [Usage](#usage) | [Advanced Topics](#advanced-topics) | [Contributing](https://github.com/valkey-io/valkey-py/blob/main/CONTRIBUTING.md)
+[Installation](#installation) |  [Usage](#usage) | [Documentation](#documentation) | [Advanced Topics](#advanced-topics) | [Contributing](https://github.com/valkey-io/valkey-py/blob/main/CONTRIBUTING.md)
 
 ---------------------------------------------
 
@@ -85,6 +85,10 @@ Alternatively, you might want to look at [Async connections](https://valkey-py.r
 
 There is built-in support for all of the [out-of-the-box Valkey commands](https://valkey.io/commands). They are exposed using the raw Redis command names (`HSET`, `HGETALL`, etc.) except where a word (i.e. del) is reserved by the language. The complete set of commands can be found [here](https://github.com/valkey-io/valkey-py/tree/main/valkey/commands), or [the documentation](https://valkey-py.readthedocs.io/en/latest/commands.html).
 
+## Documentation
+
+Check out the [documentation](https://valkey-py.readthedocs.io/en/latest/index.html)
+
 ## Advanced Topics
 
 The [official Valkey command documentation](https://valkey.io/commands)

docker-compose.yml renamed to compose.yaml

@@ -1,7 +1,5 @@
 ---
 
-version: "3.8"
-
 services:
 
   valkey:

docs/clustering.rst

@@ -197,10 +197,7 @@ Pattern subscribe and publish do not currently work properly due to key
 slots. If we hash a pattern like fo\* we will receive a keyslot for that
 string but there are endless possibilities for channel names based on
 this pattern - unknowable in advance. This feature is not disabled but
-the commands are not currently recommended for use. See
-`valkey-py-cluster
-documentation <https://valkey-py-cluster.readthedocs.io/en/stable/pubsub.html>`__
-for more.
+the commands are not currently recommended for use.
 
 .. code:: python
 

docs/examples/opentelemetry/README.md

@@ -30,8 +30,8 @@ pip install -r requirements.txt
 **Step 4**. Start the services using Docker and make sure Uptrace is running:
 
 ```shell
-docker-compose up -d
-docker-compose logs uptrace
+docker compose up -d
+docker compose logs uptrace
 ```
 
 **Step 5**. Run the Valkey client example and follow the link from the CLI to view the trace:

docs/examples/opentelemetry/docker-compose.yml renamed to docs/examples/opentelemetry/compose.yaml

@@ -1,5 +1,3 @@
-version: "3"
-
 services:
   clickhouse:
     image: clickhouse/clickhouse-server:22.7

tests/test_asyncio/test_commands.py

@@ -2131,7 +2131,7 @@ async def test_hmset(self, r: valkey.asyncio.Valkey[bytes]):
         )
         h = {b"a": b"1", b"b": b"2", b"c": b"3"}
         with pytest.warns(DeprecationWarning, match=warning_message):
-            assert await r.hmset("a", h) # type: ignore[arg-type]
+            assert await r.hmset("a", h)  # type: ignore[arg-type]
         assert await r.hgetall("a") == h
 
     async def test_hsetnx(self, r: valkey.asyncio.Valkey[bytes]):
@@ -2489,6 +2489,248 @@ async def test_geopos_no_value(self, r: valkey.asyncio.Valkey[str]):
     async def test_old_geopos_no_value(self, r: valkey.asyncio.Valkey[str]):
         assert await r.geopos("barcelona", "place1", "place2") == []
 
+    @skip_if_server_version_lt("6.2.0")
+    async def test_geosearch(self, r: valkey.Valkey):
+        values = (
+            (2.1909389952632, 41.433791470673, "place1")
+            + (2.1873744593677, 41.406342043777, b"\x80place2")
+            + (2.583333, 41.316667, "place3")
+        )
+        await r.geoadd("barcelona", values)
+        assert await r.geosearch(
+            "barcelona", longitude=2.191, latitude=41.433, radius=1000
+        ) == [b"place1"]
+        assert await r.geosearch(
+            "barcelona", longitude=2.187, latitude=41.406, radius=1000
+        ) == [b"\x80place2"]
+        assert await r.geosearch(
+            "barcelona", longitude=2.191, latitude=41.433, height=1000, width=1000
+        ) == [b"place1"]
+        assert await r.geosearch(
+            "barcelona", member="place3", radius=100, unit="km"
+        ) == [
+            b"\x80place2",
+            b"place1",
+            b"place3",
+        ]
+        # test count
+        assert await r.geosearch(
+            "barcelona", member="place3", radius=100, unit="km", count=2
+        ) == [b"place3", b"\x80place2"]
+        search_res = await r.geosearch(
+            "barcelona", member="place3", radius=100, unit="km", count=1, any=1
+        )
+        assert search_res[0] in [b"place1", b"place3", b"\x80place2"]
+
+    @skip_unless_arch_bits(64)
+    @skip_if_server_version_lt("6.2.0")
+    async def test_geosearch_member(self, r: valkey.Valkey):
+        values = (2.1909389952632, 41.433791470673, "place1") + (
+            2.1873744593677,
+            41.406342043777,
+            b"\x80place2",
+        )
+
+        await r.geoadd("barcelona", values)
+        assert await r.geosearch("barcelona", member="place1", radius=10) == [b"place1"]
+
+        geosearch_place2, geosearch_place1 = await r.geosearch(
+            "barcelona",
+            member="place1",
+            radius=4000,
+            withdist=True,
+            withcoord=True,
+            withhash=True,
+        )
+
+        # All but the coordinates are identical
+        assert geosearch_place2[:-1] == [
+            b"\x80place2",
+            3067.4157,
+            3471609625421029,
+        ]
+        assert_geo_is_close(
+            geosearch_place2[-1], (2.187376320362091, 41.40634178640635)
+        )
+        assert geosearch_place1[:-1] == [
+            b"place1",
+            0.0,
+            3471609698139488,
+        ]
+        assert_geo_is_close(
+            geosearch_place1[-1], (2.1909382939338684, 41.433790281840835)
+        )
+
+    @skip_if_server_version_lt("6.2.0")
+    async def test_geosearch_sort(self, r: valkey.Valkey):
+        values = (2.1909389952632, 41.433791470673, "place1") + (
+            2.1873744593677,
+            41.406342043777,
+            "place2",
+        )
+        await r.geoadd("barcelona", values)
+        assert await r.geosearch(
+            "barcelona", longitude=2.191, latitude=41.433, radius=3000, sort="ASC"
+        ) == [b"place1", b"place2"]
+        assert await r.geosearch(
+            "barcelona", longitude=2.191, latitude=41.433, radius=3000, sort="DESC"
+        ) == [b"place2", b"place1"]
+
+    @skip_unless_arch_bits(64)
+    @skip_if_server_version_lt("6.2.0")
+    @pytest.mark.parametrize(
+        "geosearch_kwargs, expected_geosearch_result",
+        [
+            (
+                {"withdist": True, "withcoord": True, "withhash": True},
+                [b"place1", 0.0881, 3471609698139488],
+            ),
+            (
+                {"withdist": True, "withcoord": True},
+                [b"place1", 0.0881],
+            ),
+            (
+                {"withhash": True, "withcoord": True},
+                [b"place1", 3471609698139488],
+            ),
+            (
+                {"withdist": True, "withhash": True},
+                [b"place1", 0.0881, 3471609698139488],
+            ),
+        ],
+    )
+    async def test_geosearch_with(
+        self,
+        r: valkey.Valkey,
+        geosearch_kwargs: dict[str, Any],
+        expected_geosearch_result: list[Any],
+    ):
+        values = (2.1909389952632, 41.433791470673, "place1") + (
+            2.1873744593677,
+            41.406342043777,
+            "place2",
+        )
+        await r.geoadd("barcelona", values)
+
+        # test a bunch of combinations to test the parse response
+        # function.
+        geosearch_result = await r.geosearch(
+            "barcelona",
+            longitude=2.191,
+            latitude=41.433,
+            radius=1,
+            unit="km",
+            **geosearch_kwargs,
+        )
+        assert len(geosearch_result) == 1
+        if "withcoord" in geosearch_kwargs:
+            assert_geo_is_close(
+                geosearch_result[0][-1], (2.1909382939338684, 41.433790281840835)
+            )
+            assert geosearch_result[0][:-1] == expected_geosearch_result
+        else:
+            assert geosearch_result == [expected_geosearch_result]
+
+        assert (
+            await r.geosearch(
+                "barcelona",
+                longitude=2,
+                latitude=1,
+                radius=1,
+                unit="km",
+                **geosearch_kwargs,
+            )
+            == []
+        )
+
+    @skip_if_server_version_lt("6.2.0")
+    async def test_geosearch_negative(self, r: valkey.Valkey):
+        # not specifying member nor longitude and latitude
+        with pytest.raises(exceptions.DataError):
+            assert await r.geosearch("barcelona")
+        # specifying member and longitude and latitude
+        with pytest.raises(exceptions.DataError):
+            assert await r.geosearch(
+                "barcelona", member="Paris", longitude=2, latitude=1
+            )
+        # specifying one of longitude and latitude
+        with pytest.raises(exceptions.DataError):
+            assert await r.geosearch("barcelona", longitude=2)
+        with pytest.raises(exceptions.DataError):
+            assert await r.geosearch("barcelona", latitude=2)
+
+        # not specifying radius nor width and height
+        with pytest.raises(exceptions.DataError):
+            assert await r.geosearch("barcelona", member="Paris")
+        # specifying radius and width and height
+        with pytest.raises(exceptions.DataError):
+            assert await r.geosearch(
+                "barcelona", member="Paris", radius=3, width=2, height=1
+            )
+        # specifying one of width and height
+        with pytest.raises(exceptions.DataError):
+            assert await r.geosearch("barcelona", member="Paris", width=2)
+        with pytest.raises(exceptions.DataError):
+            assert await r.geosearch("barcelona", member="Paris", height=2)
+
+        # invalid sort
+        with pytest.raises(exceptions.DataError):
+            assert await r.geosearch(
+                "barcelona", member="Paris", width=2, height=2, sort="wrong"
+            )
+
+        # invalid unit
+        with pytest.raises(exceptions.DataError):
+            assert await r.geosearch(
+                "barcelona", member="Paris", width=2, height=2, unit="miles"
+            )
+
+        # use any without count
+        with pytest.raises(exceptions.DataError):
+            assert await r.geosearch("barcelona", member="place3", radius=100, any=1)
+
+    @pytest.mark.onlynoncluster
+    @skip_if_server_version_lt("6.2.0")
+    async def test_geosearchstore(self, r: valkey.Valkey):
+        values = (2.1909389952632, 41.433791470673, "place1") + (
+            2.1873744593677,
+            41.406342043777,
+            "place2",
+        )
+
+        await r.geoadd("barcelona", values)
+        await r.geosearchstore(
+            "places_barcelona",
+            "barcelona",
+            longitude=2.191,
+            latitude=41.433,
+            radius=1000,
+        )
+        assert await r.zrange("places_barcelona", 0, -1) == [b"place1"]
+
+    @pytest.mark.onlynoncluster
+    @skip_unless_arch_bits(64)
+    @skip_if_server_version_lt("6.2.0")
+    async def test_geosearchstore_dist(self, r: valkey.Valkey):
+        values = (2.1909389952632, 41.433791470673, "place1") + (
+            2.1873744593677,
+            41.406342043777,
+            "place2",
+        )
+
+        await r.geoadd("barcelona", values)
+        await r.geosearchstore(
+            "places_barcelona",
+            "barcelona",
+            longitude=2.191,
+            latitude=41.433,
+            radius=1000,
+            storedist=True,
+        )
+        # instead of save the geo score, the distance is saved.
+        score = await r.zscore("places_barcelona", "place1")
+        assert math.isclose(score, 88.05060698409301)
+
     @skip_if_server_version_lt("3.2.0")
     async def test_georadius(self, r: valkey.asyncio.Valkey[str]):
         values = (2.1909389952632, 41.433791470673, "place1") + (

tests/test_commands.py

@@ -3623,15 +3623,15 @@ def test_geosearch_member(self, r):
         )
 
         # All but the coordinates are identical
-        geosearch_place2[:-1] == [
+        assert geosearch_place2[:-1] == [
             b"\x80place2",
             3067.4157,
             3471609625421029,
         ]
         assert_geo_is_close(
             geosearch_place2[-1], (2.187376320362091, 41.40634178640635)
         )
-        geosearch_place1[:-1] == [
+        assert geosearch_place1[:-1] == [
             b"place1",
             0.0,
             3471609698139488,