{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "# Asyncio Examples\n",
    "\n",
    "All commands are coroutine functions.\n",
    "\n",
    "## Connecting and Disconnecting\n",
    "\n",
    "Using asyncio Valkey requires an explicit disconnect of the connection since there is no asyncio deconstructor magic method. By default, an internal connection pool is created on `valkey.Valkey()` and attached to the `Valkey` instance. When calling `Valkey.aclose` this internal connection pool closes automatically, which disconnects all connections."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ping successful: True\n"
     ]
    }
   ],
   "source": [
    "import valkey.asyncio as valkey\n",
    "\n",
    "client = valkey.Valkey()\n",
    "print(f\"Ping successful: {await client.ping()}\")\n",
    "await client.aclose()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you create a custom `ConnectionPool` to be used by a single `Valkey` instance, use the `Valkey.from_pool` class method. The Valkey client will take ownership of the connection pool. This will cause the pool to be disconnected along with the Valkey instance. Disconnecting the connection pool simply disconnects all connections hosted in the pool."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import valkey.asyncio as valkey\n",
    "\n",
    "pool = valkey.ConnectionPool.from_url(\"valkey://localhost\")\n",
    "client = valkey.Valkey.from_pool(pool)\n",
    "await client.aclose()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "\n",
    "However, if the `ConnectionPool` is to be shared by several `Valkey` instances, you should use the `connection_pool` argument, and you may want to disconnect the connection pool explicitly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import valkey.asyncio as valkey\n",
    "\n",
    "pool = valkey.ConnectionPool.from_url(\"valkey://localhost\")\n",
    "client1 = valkey.Valkey(connection_pool=pool)\n",
    "client2 = valkey.Valkey(connection_pool=pool)\n",
    "await client1.aclose()\n",
    "await client2.aclose()\n",
    "await pool.aclose()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By default, this library uses version 2 of the RESP protocol. To enable RESP version 3, you will want to set `protocol` to 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import valkey.asyncio as valkey\n",
    "\n",
    "client = valkey.Valkey(protocol=3)\n",
    "await client.aclose()\n",
    "await client.ping()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Transactions (Multi/Exec)\n",
    "\n",
    "The aiovalkey.Valkey.pipeline will return a aiovalkey.Pipeline object, which will buffer all commands in-memory and compile them into batches using the Valkey Bulk String protocol. Additionally, each command will return the Pipeline instance, allowing you to chain your commands, i.e., p.set('foo', 1).set('bar', 2).mget('foo', 'bar').\n",
    "\n",
    "The commands will not be reflected in Valkey until execute() is called & awaited.\n",
    "\n",
    "Usually, when performing a bulk operation, taking advantage of a “transaction” (e.g., Multi/Exec) is to be desired, as it will also add a layer of atomicity to your bulk operation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import valkey.asyncio as valkey\n",
    "\n",
    "r = await valkey.from_url(\"valkey://localhost\")\n",
    "async with r.pipeline(transaction=True) as pipe:\n",
    "    ok1, ok2 = await (pipe.set(\"key1\", \"value1\").set(\"key2\", \"value2\").execute())\n",
    "assert ok1\n",
    "assert ok2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Pub/Sub Mode\n",
    "\n",
    "Subscribing to specific channels:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Reader) Message Received: {'type': 'message', 'pattern': None, 'channel': b'channel:1', 'data': b'Hello'}\n",
      "(Reader) Message Received: {'type': 'message', 'pattern': None, 'channel': b'channel:2', 'data': b'World'}\n",
      "(Reader) Message Received: {'type': 'message', 'pattern': None, 'channel': b'channel:1', 'data': b'STOP'}\n",
      "(Reader) STOP\n"
     ]
    }
   ],
   "source": [
    "import asyncio\n",
    "\n",
    "import valkey.asyncio as valkey\n",
    "\n",
    "STOPWORD = \"STOP\"\n",
    "\n",
    "\n",
    "async def reader(channel: valkey.client.PubSub):\n",
    "    while True:\n",
    "        message = await channel.get_message(ignore_subscribe_messages=True, timeout=None)\n",
    "        if message is not None:\n",
    "            print(f\"(Reader) Message Received: {message}\")\n",
    "            if message[\"data\"].decode() == STOPWORD:\n",
    "                print(\"(Reader) STOP\")\n",
    "                break\n",
    "\n",
    "r = valkey.from_url(\"valkey://localhost\")\n",
    "async with r.pubsub() as pubsub:\n",
    "    await pubsub.subscribe(\"channel:1\", \"channel:2\")\n",
    "\n",
    "    future = asyncio.create_task(reader(pubsub))\n",
    "\n",
    "    await r.publish(\"channel:1\", \"Hello\")\n",
    "    await r.publish(\"channel:2\", \"World\")\n",
    "    await r.publish(\"channel:1\", STOPWORD)\n",
    "\n",
    "    await future"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "Subscribing to channels matching a glob-style pattern:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(Reader) Message Received: {'type': 'pmessage', 'pattern': b'channel:*', 'channel': b'channel:1', 'data': b'Hello'}\n",
      "(Reader) Message Received: {'type': 'pmessage', 'pattern': b'channel:*', 'channel': b'channel:2', 'data': b'World'}\n",
      "(Reader) Message Received: {'type': 'pmessage', 'pattern': b'channel:*', 'channel': b'channel:1', 'data': b'STOP'}\n",
      "(Reader) STOP\n"
     ]
    }
   ],
   "source": [
    "import asyncio\n",
    "\n",
    "import valkey.asyncio as valkey\n",
    "\n",
    "STOPWORD = \"STOP\"\n",
    "\n",
    "\n",
    "async def reader(channel: valkey.client.PubSub):\n",
    "    while True:\n",
    "        message = await channel.get_message(ignore_subscribe_messages=True, timeout=None)\n",
    "        if message is not None:\n",
    "            print(f\"(Reader) Message Received: {message}\")\n",
    "            if message[\"data\"].decode() == STOPWORD:\n",
    "                print(\"(Reader) STOP\")\n",
    "                break\n",
    "\n",
    "\n",
    "r = await valkey.from_url(\"valkey://localhost\")\n",
    "async with r.pubsub() as pubsub:\n",
    "    await pubsub.psubscribe(\"channel:*\")\n",
    "\n",
    "    future = asyncio.create_task(reader(pubsub))\n",
    "\n",
    "    await r.publish(\"channel:1\", \"Hello\")\n",
    "    await r.publish(\"channel:2\", \"World\")\n",
    "    await r.publish(\"channel:1\", STOPWORD)\n",
    "\n",
    "    await future"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Sentinel Client\n",
    "\n",
    "The Sentinel client requires a list of Valkey Sentinel addresses to connect to and start discovering services.\n",
    "\n",
    "Calling aiovalkey.sentinel.Sentinel.master_for or aiovalkey.sentinel.Sentinel.slave_for methods will return Valkey clients connected to specified services monitored by Sentinel.\n",
    "\n",
    "Sentinel client will detect failover and reconnect Valkey clients automatically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import asyncio\n",
    "\n",
    "from valkey.asyncio.sentinel import Sentinel\n",
    "\n",
    "\n",
    "sentinel = Sentinel([(\"localhost\", 26379), (\"sentinel2\", 26379)])\n",
    "r = sentinel.master_for(\"mymaster\")\n",
    "\n",
    "ok = await r.set(\"key\", \"value\")\n",
    "assert ok\n",
    "val = await r.get(\"key\")\n",
    "assert val == b\"value\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Connecting to Valkey instances by specifying a URL scheme.\n",
    "Parameters are passed to the following schems, as parameters to the url scheme.\n",
    "\n",
    "Three URL schemes are supported:\n",
    "\n",
    "- `valkey://` creates a TCP socket connection.\n",
    "- `valkeys://` creates a SSL wrapped TCP socket connection.\n",
    "- ``unix://``: creates a Unix Domain Socket connection.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import valkey.asyncio as valkey\n",
    "url_connection = valkey.from_url(\"valkey://localhost:6379?decode_responses=True\")\n",
    "url_connection.ping()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To enable the RESP 3 protocol, append `protocol=3` to the URL."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import valkey.asyncio as valkey\n",
    "\n",
    "url_connection = valkey.from_url(\"valkey://localhost:6379?decode_responses=True&protocol=3\")\n",
    "url_connection.ping()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}
