code: async def discover_slave(self, service, timeout, **kwargs):
          
          # TODO: use kwargs to change how slaves are picked up
          #   (eg: round-robin, priority, random, etc)
          idle_timeout = timeout
          pools = self._pools[:]
          for sentinel in pools:
              try:
                  with async_timeout(timeout, loop=self._loop):
                      address = await self._get_slave_address(
                          sentinel, service)  # add **kwargs
                  pool = self._slaves[service]
                  with async_timeout(timeout, loop=self._loop), \
                          contextlib.ExitStack() as stack:
                      conn = await pool._create_new_connection(address)
                      stack.callback(conn.close)
                      await self._verify_service_role(conn, 'slave')
                      stack.pop_all()
                  return conn
              except asyncio.CancelledError:
                  raise
              except asyncio.TimeoutError:
                  continue
              except DiscoverError:
                  await asyncio.sleep(idle_timeout, loop=self._loop)
                  continue
              except RedisError as err:
                  raise SlaveReplyError("Service {} error".format(service), err)
              except Exception:
                  await asyncio.sleep(idle_timeout, loop=self._loop)
                  continue
          raise SlaveNotFoundError("No slave found for {}".format(service))
docs: Perform Slave discovery for specified service.