add commands

Author: priyanshu-panwar

README.md

@@ -36,3 +36,33 @@ asyncio.run(test())
 
 - `GET`: get value from key
   Ex: `await dice.get("key")`
+
+- `DEL`: delete key
+  Ex: `await dice.delete("key")`
+
+- `EXISTS`: check if a key exists & returns bool
+  Ex: `await dice.exists("key")`
+
+- `EXPIRE`: sets ttl in seconds for a key
+  Ex: `await dice.expire("key", 10)`
+
+- `KEYS`: get all keys in a list according to the pattern give. Use "_" for all keys.
+  Ex: `await dice.keys("_")`
+
+- `FLUSH`: clear all keys
+  Ex: `await dice.flush()`
+
+- `INCR`: incr key by 1. Default value to start is 0 if key is not already set.
+  Ex: `await dice.incr("key")`
+
+- `INCRBY`: incr key by amount (int)
+  Ex: `await dice.incrby("key", 2)`
+
+- `DECR`: decr key by 1.
+  Ex: `await dice.decr("key")`
+
+- `DECRBY`: decr key by amount (int)
+  Ex: `await dice.decrby("key", 2)`
+
+- `TTL`: get TTL (time to live) of the key in seconds
+  Ex: `await dice.ttl("key")`

dice_py/command/command.py

@@ -13,3 +13,52 @@ async def get(self, key) -> str:
     async def set(self, key, value) -> str:
         """Set the value of a key."""
         return await self._execute_command(f"SET {key} {value}")
+
+    async def delete(self, key) -> bool:
+        """Delete a key."""
+        return await self._execute_command(f"DEL {key}") == "1"
+
+    async def exists(self, key) -> bool:
+        """Check if a key exists."""
+        return await self._execute_command(f"EXISTS {key}") == "1"
+
+    async def expire(self, key: str, seconds: int) -> bool:
+        """Set a timeout on a key."""
+        return await self._execute_command(f"EXPIRE {key} {seconds}") == "1"
+
+    async def keys(self, pattern: str) -> list:
+        """
+        Get all keys matching a pattern.
+        The pattern is a glob-style pattern. Use * as a wildcard for any number of characters.
+        """
+        keys = await self._execute_command(f"KEYS {pattern}")
+        return keys.split(" ") if keys else []
+
+    async def flush(self) -> bool:
+        """Delete all keys."""
+        return await self._execute_command("FLUSHDB") == "OK"
+
+    async def incr(self, key) -> int:
+        """Increment the value of a key."""
+        return int(await self._execute_command(f"INCR {key}"))
+
+    async def decr(self, key) -> int:
+        """Decrement the value of a key."""
+        return int(await self._execute_command(f"DECR {key}"))
+
+    async def incrby(self, key: str, amount: int) -> int:
+        """Increment the value of a key by a specified amount."""
+        return int(await self._execute_command(f"INCRBY {key} {amount}"))
+
+    async def decrby(self, key: str, amount: int) -> int:
+        """Decrement the value of a key by a specified amount."""
+        return int(await self._execute_command(f"DECRBY {key} {amount}"))
+
+    async def ttl(self, key: str) -> int:
+        """
+        Get the time to live for a key.
+        positive integer: the remaining time to live in seconds
+        -2: the key does not exist
+        -1: the key exists but has no associated expire
+        """
+        return int(await self._execute_command(f"TTL {key}"))

dice_py/command/executor.py

@@ -16,6 +16,9 @@ def _send_command(self, command: str, conn: Connect):
         """Send a command to the socket."""
         conn.sock.sendall(command.encode("utf-8"))
         response = conn.sock.recv(4096).decode("utf-8")
+        if response.startswith("*"):
+            lines = response.split("\r\n")
+            return " ".join(lines[2::2])
         return response.split("\r\n")[0][1:]
 
     async def _execute_command(self, command: str):

docs/index.md

@@ -36,3 +36,33 @@ asyncio.run(test())
 
 - `GET`: get value from key
   Ex: `await dice.get("key")`
+
+- `DEL`: delete key
+  Ex: `await dice.delete("key")`
+
+- `EXISTS`: check if a key exists & returns bool
+  Ex: `await dice.exists("key")`
+
+- `EXPIRE`: sets ttl in seconds for a key
+  Ex: `await dice.expire("key", 10)`
+
+- `KEYS`: get all keys in a list according to the pattern give. Use "_" for all keys.
+  Ex: `await dice.keys("_")`
+
+- `FLUSH`: clear all keys
+  Ex: `await dice.flush()`
+
+- `INCR`: incr key by 1. Default value to start is 0 if key is not already set.
+  Ex: `await dice.incr("key")`
+
+- `INCRBY`: incr key by amount (int)
+  Ex: `await dice.incrby("key", 2)`
+
+- `DECR`: decr key by 1.
+  Ex: `await dice.decr("key")`
+
+- `DECRBY`: decr key by amount (int)
+  Ex: `await dice.decrby("key", 2)`
+
+- `TTL`: get TTL (time to live) of the key in seconds
+  Ex: `await dice.ttl("key")`

pyproject.toml

@@ -5,7 +5,7 @@ description = "Python Client for DiceDB"
 authors = ["Priyanshu Panwar <[email protected]>"]
 readme = "README.md"
 license = "MIT"
-homepage = "https://github.com/priyanshu-panwar/dice-py"
+homepage = "https://priyanshu-panwar.github.io/dice-py"
 repository = "https://github.com/priyanshu-panwar/dice-py"
 keywords = ["dice", "dice-py", "dice-db", "dicedb", "python", "client"]
 classifiers = [

tests/command/test_command.py

@@ -1,27 +1,108 @@
 import unittest
-from unittest.mock import patch
+from unittest.mock import patch, MagicMock
 from dice_py.command.command import Command
+from dice_py.connection.client import DiceClient
 import asyncio
 
 
 class TestCommand(unittest.TestCase):
 
+    def setUp(self):
+        self.client = MagicMock(spec=DiceClient)
+        self.command = Command(self.client)
+        self.loop = asyncio.get_event_loop()
+
     @patch("dice_py.command.executor.Executor._execute_command", return_value="OK")
-    @patch("dice_py.command.executor.DiceClient")
-    def test_set(self, mock_client, mock_execute_command):
-        command = Command(mock_client)
-        loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(command.set("key", "value"))
-
-        mock_execute_command.assert_called_once_with("SET key value")
-        self.assertEqual(response, "OK")
-
-    @patch("dice_py.command.executor.Executor._execute_command", return_value="value")
-    @patch("dice_py.command.executor.DiceClient")
-    def test_get(self, mock_client, mock_execute_command):
-        command = Command(mock_client)
-        loop = asyncio.get_event_loop()
-        response = loop.run_until_complete(command.get("key"))
-
-        mock_execute_command.assert_called_once_with("GET key")
-        self.assertEqual(response, "value")
+    def test_set(self, mock_execute_command):
+        set_response = self.loop.run_until_complete(
+            self.command.set("test_key", "test_value")
+        )
+        mock_execute_command.assert_called_once_with("SET test_key test_value")
+        self.assertEqual(set_response, "OK")
+
+    @patch(
+        "dice_py.command.executor.Executor._execute_command", return_value="test_value"
+    )
+    def test_get(self, mock_execute_command):
+        get_response = self.loop.run_until_complete(self.command.get("test_key"))
+        mock_execute_command.assert_called_once_with("GET test_key")
+        self.assertEqual(get_response, "test_value")
+
+    @patch("dice_py.command.executor.Executor._execute_command", return_value="1")
+    def test_delete(self, mock_execute_command):
+        delete_response = self.loop.run_until_complete(self.command.delete("test_key"))
+        mock_execute_command.assert_called_once_with("DEL test_key")
+        self.assertTrue(delete_response)
+
+    @patch("dice_py.command.executor.Executor._execute_command", return_value="1")
+    def test_exists(self, mock_execute_command):
+        exists_response = self.loop.run_until_complete(self.command.exists("test_key"))
+        mock_execute_command.assert_called_once_with("EXISTS test_key")
+        self.assertTrue(exists_response)
+
+    @patch("dice_py.command.executor.Executor._execute_command", return_value="1")
+    def test_expire(self, mock_execute_command):
+        expire_response = self.loop.run_until_complete(
+            self.command.expire("test_key", 60)
+        )
+        mock_execute_command.assert_called_once_with("EXPIRE test_key 60")
+        self.assertTrue(expire_response)
+
+    @patch(
+        "dice_py.command.executor.Executor._execute_command",
+        return_value="test_key test_key_2",
+    )
+    def test_keys(self, mock_execute_command):
+        keys_response = self.loop.run_until_complete(self.command.keys("*"))
+        mock_execute_command.assert_called_once_with("KEYS *")
+        self.assertEqual(keys_response, ["test_key", "test_key_2"])
+
+    @patch(
+        "dice_py.command.executor.Executor._execute_command",
+        return_value="OK",
+    )
+    def test_flush(self, mock_execute_command):
+        flush_response = self.loop.run_until_complete(self.command.flush())
+        mock_execute_command.assert_called_once_with("FLUSHDB")
+        self.assertTrue(flush_response)
+
+    @patch("dice_py.command.executor.Executor._execute_command", return_value="11")
+    def test_incr(self, mock_execute_command):
+        incr_response = self.loop.run_until_complete(self.command.incr("test_key"))
+        mock_execute_command.assert_called_once_with("INCR test_key")
+        self.assertEqual(incr_response, 11)
+
+    @patch("dice_py.command.executor.Executor._execute_command", return_value="9")
+    def test_decr(self, mock_execute_command):
+        decr_response = self.loop.run_until_complete(self.command.decr("test_key"))
+        mock_execute_command.assert_called_once_with("DECR test_key")
+        self.assertEqual(decr_response, 9)
+
+    @patch("dice_py.command.executor.Executor._execute_command", return_value="11")
+    def test_incrby(self, mock_execute_command):
+        _ = self.loop.run_until_complete(self.command.set("test_key", 6))
+        incrby_response = self.loop.run_until_complete(
+            self.command.incrby("test_key", 5)
+        )
+        self.assertEqual(incrby_response, 11)
+
+    @patch("dice_py.command.executor.Executor._execute_command", return_value="1")
+    def test_decrby(self, mock_execute_command):
+        _ = self.loop.run_until_complete(self.command.set("test_key", 6))
+        decrby_response = self.loop.run_until_complete(
+            self.command.decrby("test_key", 5)
+        )
+        self.assertEqual(decrby_response, 1)
+
+    @patch("dice_py.command.executor.Executor._execute_command", return_value="-1")
+    def test_ttl_not_set(self, mock_execute_command):
+        _ = self.loop.run_until_complete(self.command.set("test_key", 10))
+        ttl_response = self.loop.run_until_complete(self.command.ttl("test_key"))
+        self.assertEqual(ttl_response, -1)
+
+    @patch("dice_py.command.executor.Executor._execute_command", return_value="10")
+    def test_ttl(self, mock_execute_command):
+        _ = self.loop.run_until_complete(self.command.set("test_key", 10))
+        _ = self.loop.run_until_complete(self.command.expire("test_key", 10))
+        ttl_response = self.loop.run_until_complete(self.command.ttl("test_key"))
+        self.assertEqual(ttl_response, 10)

tests/test_dice.py

@@ -21,6 +21,87 @@ def test_get(self):
         get_response = self.loop.run_until_complete(self.dice.get("test_key"))
         self.assertEqual(get_response, "10")
 
+    def test_delete(self):
+        # First, set the key to ensure it exists
+        self.loop.run_until_complete(self.dice.set("test_key", 10))
+        delete_response = self.loop.run_until_complete(self.dice.delete("test_key"))
+        self.assertTrue(delete_response)
+
+    def test_exists(self):
+        # First, set the key to ensure it exists
+        self.loop.run_until_complete(self.dice.set("test_key", 10))
+        exists_response = self.loop.run_until_complete(self.dice.exists("test_key"))
+        self.assertTrue(exists_response)
+
+    def test_not_exists(self):
+        exists_response = self.loop.run_until_complete(self.dice.exists("test_key"))
+        self.assertFalse(exists_response)
+
+    async def test_expire(self):
+        # First, set the key to ensure it exists
+        self.loop.run_until_complete(self.dice.set("test_key", 10))
+        expire_response = self.loop.run_until_complete(self.dice.expire("test_key", 10))
+        self.assertTrue(expire_response)
+        # Check if the key exists after 10 seconds
+        asyncio.sleep(10)
+        exists_response = self.loop.run_until_complete(self.dice.exists("test_key"))
+        self.assertFalse(exists_response)
+
+    async def test_keys(self):
+        # First, set the key to ensure it exists
+        self.loop.run_until_complete(self.dice.set("test_key", 10))
+        self.loop.run_until_complete(self.dice.set("test_key_2", 20))
+        keys_response = self.loop.run_until_complete(self.dice.keys("*"))
+        self.assertIn(["test_key", "test_key_2"], keys_response)
+
+    def test_flush(self):
+        # First, set the key to ensure it exists
+        self.loop.run_until_complete(self.dice.set("test_key", 10))
+        self.loop.run_until_complete(self.dice.set("test_key_2", 20))
+        flush_response = self.loop.run_until_complete(self.dice.flush())
+        self.assertTrue(flush_response)
+
+    def test_incr(self):
+        # First, set the key to ensure it exists
+        self.loop.run_until_complete(self.dice.set("test_key", 10))
+        incr_response = self.loop.run_until_complete(self.dice.incr("test_key"))
+        self.assertEqual(incr_response, 11)
+
+    def test_decr(self):
+        # First, set the key to ensure it exists
+        self.loop.run_until_complete(self.dice.set("test_key", 10))
+        decr_response = self.loop.run_until_complete(self.dice.decr("test_key"))
+        self.assertEqual(decr_response, 9)
+
+    def test_incrby(self):
+        # First, set the key to ensure it exists
+        self.loop.run_until_complete(self.dice.set("test_key", 10))
+        incrby_response = self.loop.run_until_complete(self.dice.incrby("test_key", 5))
+        self.assertEqual(incrby_response, 15)
+
+    def test_decrby(self):
+        # First, set the key to ensure it exists
+        self.loop.run_until_complete(self.dice.set("test_key", 10))
+        decrby_response = self.loop.run_until_complete(self.dice.decrby("test_key", 5))
+        self.assertEqual(decrby_response, 5)
+
+    def test_ttl_not_set(self):
+        # First, set the key to ensure it exists
+        self.loop.run_until_complete(self.dice.set("test_key", 10))
+        ttl_response = self.loop.run_until_complete(self.dice.ttl("test_key"))
+        self.assertEqual(ttl_response, -1)
+
+    def test_ttl_set(self):
+        # First, set the key to ensure it exists
+        self.loop.run_until_complete(self.dice.set("test_key", 10))
+        self.loop.run_until_complete(self.dice.expire("test_key", 10))
+        ttl_response = self.loop.run_until_complete(self.dice.ttl("test_key"))
+        self.assertEqual(ttl_response, 9)
+
+    def test_ttl_not_exists(self):
+        ttl_response = self.loop.run_until_complete(self.dice.ttl("test_key"))
+        self.assertEqual(ttl_response, -2)
+
     def tearDown(self):
         # Clean up by deleting the test key
         self.loop.run_until_complete(self.dice._execute_command("DEL test_key"))