{
 "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",
    "Utilizing asyncio Redis requires an explicit disconnect of the connection since there is no asyncio deconstructor magic method. By default, a connection pool is created on `redis.Redis()` and attached to this `Redis` instance. The connection pool closes automatically on the call to `Redis.close` which disconnects all connections."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ping successful: True\n"
     ]
    }
   ],
   "source": [
    "import redis.asyncio as redis\n",
    "\n",
    "connection = redis.Redis()\n",
    "print(f\"Ping successful: {await connection.ping()}\")\n",
    "await connection.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "If you supply a custom `ConnectionPool` that is supplied to several `Redis` instances, you may want to disconnect the connection pool explicitly. Disconnecting the connection pool simply disconnects all connections hosted in the pool."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import redis.asyncio as redis\n",
    "\n",
    "connection = redis.Redis(auto_close_connection_pool=False)\n",
    "await connection.close()\n",
    "# Or: await connection.close(close_connection_pool=False)\n",
    "await connection.connection_pool.disconnect()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "pycharm": {
     "name": "#%% md\n"
    }
   },
   "source": [
    "## Transactions (Multi/Exec)\n",
    "\n",
    "The aioredis.Redis.pipeline will return a aioredis.Pipeline object, which will buffer all commands in-memory and compile them into batches using the Redis 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 Redis 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": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import redis.asyncio as redis\n",
    "\n",
    "r = await redis.from_url(\"redis://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": {},
   "source": [
    "## Pub/Sub Mode\n",
    "\n",
    "Subscribing to specific channels:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "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 async_timeout\n",
    "\n",
    "import redis.asyncio as redis\n",
    "\n",
    "STOPWORD = \"STOP\"\n",
    "\n",
    "\n",
    "async def reader(channel: redis.client.PubSub):\n",
    "    while True:\n",
    "        try:\n",
    "            async with async_timeout.timeout(1):\n",
    "                message = await channel.get_message(ignore_subscribe_messages=True)\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",
    "                await asyncio.sleep(0.01)\n",
    "        except asyncio.TimeoutError:\n",
    "            pass\n",
    "\n",
    "r = redis.from_url(\"redis://localhost\")\n",
    "pubsub = r.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": {},
   "source": [
    "Subscribing to channels matching a glob-style pattern:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "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 async_timeout\n",
    "\n",
    "import redis.asyncio as redis\n",
    "\n",
    "STOPWORD = \"STOP\"\n",
    "\n",
    "\n",
    "async def reader(channel: redis.client.PubSub):\n",
    "    while True:\n",
    "        try:\n",
    "            async with async_timeout.timeout(1):\n",
    "                message = await channel.get_message(ignore_subscribe_messages=True)\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",
    "                await asyncio.sleep(0.01)\n",
    "        except asyncio.TimeoutError:\n",
    "            pass\n",
    "\n",
    "\n",
    "r = await redis.from_url(\"redis://localhost\")\n",
    "pubsub = r.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": {},
   "source": [
    "## Sentinel Client\n",
    "\n",
    "The Sentinel client requires a list of Redis Sentinel addresses to connect to and start discovering services.\n",
    "\n",
    "Calling aioredis.sentinel.Sentinel.master_for or aioredis.sentinel.Sentinel.slave_for methods will return Redis clients connected to specified services monitored by Sentinel.\n",
    "\n",
    "Sentinel client will detect failover and reconnect Redis clients automatically."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "pycharm": {
     "name": "#%%\n"
    }
   },
   "outputs": [],
   "source": [
    "import asyncio\n",
    "\n",
    "from redis.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\""
   ]
  }
 ],
 "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
}