Is it possible to chain calls with oaib? about oaib HOT 4 OPEN

async def process_input(batch, input_data):
    promise = await batch.add(input_data)
    result = await promise
    new_input = modify_result(result)
    second_promise = await batch.add(new_input)
    return await second_promise

    batch = RateLimitedBatch(rpm=100, tpm=1_000, workers=5)
    batch.start_workers()  
    inputs = [1, 2, 3]
    results = await asyncio.gather(*(process_input(batch, input_data) for input_data in inputs))
    print(results)

    await batch.shutdown()  # Shutdown workers after all tasks are processed

import asyncio
from asyncio import Queue

class RateLimitedBatch:
    def __init__(self, rpm, tpm, workers):
        self.queue = Queue()
        self.semaphore = asyncio.Semaphore(workers)
        self.workers = []
        self.total_workers = 3
        self.rpm = rpm
        self.tpm = tpm

    async def add(self, input_data):
        future = asyncio.get_running_loop().create_future()
        await self.queue.put((input_data, future))
        return future

    async def worker(self):
        while True:
            input_data, future = await self.queue.get()
            if input_data is None:  # Shutdown signal
                future.set_result(None)  # Optionally handle shutdown result
                break
            # Simulate API call with a delay
            await asyncio.sleep(1)  # Placeholder for real work
            result = input_data * 2  # Example processing logic
            future.set_result(result)
            self.queue.task_done()

    def start_workers(self):
        for _ in range(self.total_workers):
            task = asyncio.create_task(self.worker())
            self.workers.append(task)

    async def shutdown(self):
        for _ in range(len(self.workers)):  # Send shutdown signal for each worker
            await self.queue.put((None, asyncio.get_running_loop().create_future()))
        await asyncio.gather(*self.workers)  # Wait for all workers to complete