asyncio — এক thread-এ অনেক অপেক্ষা, async আর await

১ · এক ওয়েটার, অনেক টেবিল — asyncio-র মূল ভাবনা

পুরান ঢাকার একটি জমজমাট রেস্টুরেন্টের কথা ভাবুন। দুপুরে দশটি টেবিলে লোক বসে আছে, ওয়েটার একজন। তিনি যদি প্রথম টেবিলে গিয়ে দাঁড়িয়ে থাকেন যতক্ষণ না সেই পরিবার মেনু দেখে সিদ্ধান্ত নেয়, তারপর রান্নাঘরের দরজায় দাঁড়িয়ে থাকেন যতক্ষণ না খাবার তৈরি হয় — তাহলে বাকি নয়টি টেবিল আধা ঘণ্টা বসে থাকবে। অথচ ওয়েটারের নিজের কাজ (অর্ডার লেখা, প্লেট নিয়ে আসা) খুবই অল্প সময়ের। বেশিরভাগ সময় যায় অপেক্ষায়।

প্রোগ্রামেও এমন অপেক্ষা সবখানে। একটি API-তে অনুরোধ পাঠালে উত্তর আসতে ১০০–৫০০ মিলিসেকেন্ড লাগতে পারে; ডেটাবেস থেকে উত্তর, ফাইল ডাউনলোড, ব্যবহারকারীর মেসেজের অপেক্ষা — এসব সময়ে CPU কার্যত বসে থাকে। এমন কাজকে বলে I/O-bound. উল্টো দিকে ছবি প্রসেস করা বা বড় হিসাব — যেখানে CPU সারাক্ষণ ব্যস্ত — সেটা CPU-bound. asyncio প্রথম ধরনের জন্য।

concurrency বনাম parallelism

এই দুটি শব্দ প্রায়ই গুলিয়ে যায়। concurrency মানে অনেক কাজ একই সময়সীমার মধ্যে এগিয়ে চলছে — একজন ওয়েটার দশ টেবিল সামলাচ্ছেন। parallelism মানে অনেক কাজ একই মুহূর্তে সত্যিই চলছে — চারজন রাঁধুনি চারটি চুলায় একসাথে রাঁধছেন। asyncio দেয় concurrency, parallelism নয়: এক thread, এক মুহূর্তে একটিই Python লাইন চলে। একাধিক CPU core সত্যিই একসাথে কাজে লাগাতে হলে process বা (free-threaded Python-এ) thread লাগে — পর্ব ৪১-এ দেখেছেন।

২ · async def, coroutine object আর await

পর্ব ৩৪-এ দেখেছেন, yield থাকা ফাংশন ডাকলে body চলে না — পাওয়া যায় একটি generator, যা থেমে থেমে চলে। asyncio-র ভিত্তিও সেই “থামো, অবস্থা রাখো, পরে চলো” যন্ত্র, শুধু নিজস্ব syntax-এ:

• async def দিয়ে লেখা ফাংশনকে বলে coroutine function. একে ডাকলে body-র একটি লাইনও চলে না; ফেরত আসে একটি coroutine object — চালানোর অপেক্ষায় থাকা একটি কাজ।
• await x লেখা যায় শুধু async def-এর ভেতরে। এর মানে: “x শেষ হওয়া পর্যন্ত আমি থামলাম; এই ফাঁকে event loop অন্য কাজ চালাক। x-এর ফল এলে আমাকে এখান থেকেই আবার চালাও।” যার ওপর await করা যায়, তাকে বলে awaitable — coroutine, Task আর Future.
• asyncio.run(main()) সাধারণ (sync) জগৎ থেকে async জগতে ঢোকার দরজা: একটি নতুন event loop বানায়, main() শেষ হওয়া পর্যন্ত চালায়, তারপর বাকি কাজ পরিষ্কার করে loop বন্ধ করে। একটি প্রোগ্রামে সাধারণত একবারই ডাকা হয় (Python 3.7 থেকে আছে)।

import asyncio

async def greet(name):
    await asyncio.sleep(1)      # ১ সেকেন্ড অপেক্ষা — loop তখন মুক্ত
    return f"আসসালামু আলাইকুম, {name}"

async def main():
    msg = await greet("রাফি")   # চালাও, শেষ হলে ফল নাও
    print(msg)

asyncio.run(main())             # sync জগৎ থেকে async জগতে

await ভুলে গেলে — “never awaited”

নতুনদের (আর AI-এরও) সবচেয়ে প্রচলিত ভুল: coroutine ডেকে await না লেখা। send_sms("রহিম") লিখলে মনে হয় SMS চলে গেল, কিন্তু আসলে শুধু একটি coroutine object তৈরি হয়ে পড়ে থাকল — কেউ তাকে চালায়নি। কোনো exception আসে না; প্রোগ্রাম আনন্দে এগিয়ে যায়। পরে সেই object মুছে ফেলার সময় Python stderr-এ একটি সতর্কবার্তা লেখে:

main.py:8: RuntimeWarning: coroutine 'send_sms' was never awaited
  send_sms("রহিম")
RuntimeWarning: Enable tracemalloc to get the object allocation traceback

এটা error নয়, RuntimeWarning — তাই স্ক্রিপ্ট থামে না, আর লগের ভিড়ে সহজেই চোখ এড়িয়ে যায়। বার্তাটির মানে: “আপনি একটি কাজ বানিয়েছিলেন, কিন্তু কখনো চালাননি।” দ্বিতীয় লাইনটি শুধু বলে, চাইলে tracemalloc চালু করে জানা যাবে object-টি কোথায় তৈরি হয়েছিল। সমাধান প্রায় সবসময় এক শব্দ: await send_sms("রহিম"). একই কারণে result = fetch() লিখে result ছাপালে দেখবেন <coroutine object fetch at 0x...>, আসল ফল নয়।

৩ · event loop — ওয়েটারের খাতা

event loop একটি সাধারণ লুপ, যা মোটামুটি এই কাজ বারবার করে:

1. যেসব কাজ এখন চলার জন্য প্রস্তুত (ready), সেগুলোকে একটি একটি করে চালাও — প্রতিটি চলবে তার পরের await পর্যন্ত। (Task আসলে একটি callback-এর মতো loop-এর তালিকায় থাকে।)
2. যে কাজ await-এ থামল, সে কিসের অপেক্ষায় — একটি টাইমার, না একটি নেটওয়ার্ক socket — খাতায় লিখে রাখো।
3. কেউ প্রস্তুত না থাকলে অপারেটিং সিস্টেমকে বলো: “এই socket-গুলোর কোনোটিতে ডেটা এলে, বা সবচেয়ে কাছের টাইমার বাজলে আমাকে জাগিও।” (Linux-এ এটা epoll, macOS-এ kqueue — একে বলে non-blocking I/O.)
4. জেগে উঠে যাদের অপেক্ষা শেষ, তাদের আবার ready তালিকায় তোলো। ১ নম্বরে ফিরে যাও।

নিচে তিনটি কাজ — A, B, C — যাদের অপেক্ষা যথাক্রমে ৩, ১ আর ২ ইউনিট (ধরুন একেকটি ইউনিট এক সেকেন্ড)। ধাপে ধাপে দেখুন কে চলে, কে ঘুমায়, আর কে কখন জাগে:

1async def job(name, t):2    print(name, "শুরু")3    await asyncio.sleep(t)4    print(name, "শেষ")5async def main():6    await asyncio.gather(job("A", 3),7        job("B", 1), job("C", 2))

এই ছবিতে asyncio-র পুরো রহস্য আছে। কোনো জাদু নেই, কোনো লুকানো thread নেই — একটি লুপ, একটি ready তালিকা, কিছু টাইমার আর অপারেটিং সিস্টেমের কাছে “জাগিও” অনুরোধ। কাজ বদলের খরচ খুব কম (একটি ফাংশন আবার চালানোর মতো), তাই একটি loop হাজার হাজার সংযোগ সামলাতে পারে, যেখানে প্রতিটি সংযোগের জন্য একটি করে thread খুললে মেমরি আর বদলের খরচ অনেক বেশি পড়ে।

৪ · একসাথে চালানো — gather, create_task আর TaskGroup

একটি বাস্তব কাজ ধরুন: একটি রেমিট্যান্স অ্যাপ তিনটি ব্যাংকের API থেকে ডলারের রেট এনে সবচেয়ে ভালোটি দেখাবে। প্রতিটি API উত্তর দিতে কিছুটা সময় নেয়। শুধু await পরপর লিখলে কী হয়, আর একসাথে চালালে কী হয় — আগে ধাপে ধাপে দেখুন:

1# পরপর (sequential)2a = await fetch("A", 3)3b = await fetch("B", 1)4c = await fetch("C", 2)5# একসাথে (concurrent)6a, b, c = await asyncio.gather(7    fetch("A", 3), fetch("B", 1), fetch("C", 2))

এবার আসল কোড। নেটওয়ার্কের বদলে asyncio.sleep দিয়ে অপেক্ষার ভান করা হয়েছে (০.০১–০.০৩ সেকেন্ড), যাতে আউটপুট প্রতিবার একই আসে। প্রথমে দেখানো হয়েছে যে coroutine ডাকলে শুধু object তৈরি হয়:

import asyncio

async def fetch_rate(source, delay, rate):
    print(f"{source}: অনুরোধ গেল")
    await asyncio.sleep(delay)          # নেটওয়ার্কের অপেক্ষা (নকল)
    print(f"{source}: উত্তর এল")
    return rate

async def main():
    coro = fetch_rate("পরীক্ষা", 0, 0)
    print(type(coro).__name__)          # এখনো কিছুই চলেনি
    coro.close()                        # না চালিয়ে বন্ধ করা
    rates = await asyncio.gather(
        fetch_rate("ব্যাংক-A", 0.03, 121.50),
        fetch_rate("ব্যাংক-B", 0.01, 121.75),
        fetch_rate("ব্যাংক-C", 0.02, 121.60),
    )
    print("রেট:", rates, "সেরা:", max(rates))

asyncio.run(main())

create_task — কাজ শুরু করে দিয়ে এগিয়ে যাওয়া

asyncio.create_task(coro) একটি coroutine-কে সাথে সাথে Task হিসেবে loop-এ জমা দেয় আর একটি Task object ফেরত দেয়। আপনি অন্য কাজ করতে পারেন, পরে await task লিখে ফল নিতে পারেন। একে বলা যায় “অর্ডার দিয়ে রাখা”:

async def main():
    t1 = asyncio.create_task(fetch_rate("ব্যাংক-A", 0.03, 121.50))
    t2 = asyncio.create_task(fetch_rate("ব্যাংক-B", 0.01, 121.75))
    print("দুটি অনুরোধ পাঠানো হলো, এবার অন্য কাজ...")
    a = await t1          # দুটিই ইতিমধ্যে চলছে
    b = await t2
    print(max(a, b))

TaskGroup — গুছানো concurrency (Python 3.11 থেকে)

gather আর create_task-এর একটি দুর্বলতা আছে: কোনো একটি কাজ ব্যর্থ হলে বাকিরা কী করবে? gather-এ প্রথম exception আপনার কাছে চলে আসে, কিন্তু অন্য Task-গুলো পেছনে চলতেই থাকে — কেউ তাদের থামায় না, ফলও কেউ নেয় না। Python 3.11 এর সমাধান হিসেবে আনে asyncio.TaskGroup, যা async with দিয়ে লেখা হয়:

async def main():
    async with asyncio.TaskGroup() as tg:
        ta = tg.create_task(fetch_rate("ব্যাংক-A", 0.03, 121.50))
        tb = tg.create_task(fetch_rate("ব্যাংক-B", 0.01, 121.75))
    # এখানে পৌঁছানো মানে: ভেতরের সব Task শেষ
    print(ta.result(), tb.result())

নিয়ম তিনটি, আর তিনটিই নিরাপত্তার জন্য। এক — async with ব্লক থেকে বের হওয়া যায় শুধু তখন, যখন ভেতরে শুরু হওয়া সব Task শেষ; কোনো কাজ পেছনে “হারিয়ে” যেতে পারে না। দুই — কোনো একটি Task exception দিলে বাকি সবাইকে cancel করা হয়। তিন — সব ভুল একসাথে একটি ExceptionGroup-এ মুড়ে ওপরে পাঠানো হয়, যা পর্ব ২৪-এ দেখা except* দিয়ে ধরন অনুযায়ী আলাদা করে ধরা যায়। এই ভাবনার নাম structured concurrency: কাজের আয়ু কোডের একটি ব্লকের সাথে বাঁধা, ঠিক যেমন with open(...) ফাইলের আয়ু ব্লকের সাথে বাঁধে। নতুন কোডে TaskGroup-ই প্রথম পছন্দ।

1try:2    async with asyncio.TaskGroup() as tg:3        tg.create_task(sms("রহিম", 3))4        tg.create_task(sms("ভুল-নম্বর", 1))5        tg.create_task(sms("করিম", 2))6except* ValueError as eg:7    print("ব্যর্থ:", eg.exceptions)

৫ · সবচেয়ে বড় বাগ — event loop আটকে দেওয়া

অংশ ১-এর মূল ধারণা মনে করুন: কাজ বদল হয় শুধু await-এ। তাহলে কী হবে, যদি একটি coroutine এমন কিছু করে যা অপেক্ষা করে, কিন্তু await দিয়ে নয়? time.sleep(3) হলো এমন একটি blocking call: সে পুরো thread-কে ৩ সেকেন্ড ঘুম পাড়িয়ে দেয়। asyncio-তে thread একটিই — তাই loop-ও ঘুমায়, আর সাথে বাকি সব কাজ। ধাপে ধাপে দেখুন:

1async def ticker():          # প্রতি ১ ইউনিটে টিক2    for i in range(3):3        print("টিক", i)4        await asyncio.sleep(1)5async def report():6    time.sleep(3)            # ভুল! loop জমে যায়7    # await asyncio.sleep(3)  # ঠিক

time.sleep শুধু একটি উদাহরণ। loop আটকায় এমন যেকোনো কিছু, যা await ছাড়া অপেক্ষা করে বা অনেকক্ষণ CPU দখল করে রাখে:

asyncio.to_thread — ব্লক করা কোডকে পাশের ঘরে পাঠানো

সব লাইব্রেরির async রূপ নেই। পুরোনো একটি পেমেন্ট SDK হয়তো শুধু সাধারণ ব্লক করা ফাংশন দেয়। তখন Python 3.9 থেকে আসা asyncio.to_thread কাজে লাগে: এটা ফাংশনটিকে আলাদা একটি thread-এ চালায় আর আপনাকে একটি awaitable দেয়। loop-এর thread মুক্ত থাকে, অন্য কাজ চলতে থাকে:

import asyncio, time

def legacy_payment(amount):      # পুরোনো, ব্লক করা লাইব্রেরি
    time.sleep(2)
    return f"{amount} টাকা পরিশোধিত"

async def main():
    receipt = await asyncio.to_thread(legacy_payment, 500)
    print(receipt)

I/O-র অপেক্ষার জন্য এটা চমৎকার, কারণ অপেক্ষার সময় CPython-এর GIL ছেড়ে দেওয়া হয়। কিন্তু ভারী Python হিসাব to_thread-এ পাঠালে সাধারণ CPython-এ GIL-এর কারণে খুব একটা লাভ হয় না; সেখানে loop.run_in_executor-এ একটি ProcessPoolExecutor দিন, যা পর্ব ৪১-এর process-এর জগৎ।

৬ · timeout আর cancellation — অপেক্ষার সীমা টানা

নেটওয়ার্কের জগতে একটি কঠিন সত্য: কিছু সার্ভার কখনোই উত্তর দেয় না। একটি bKash-ধাঁচের পেমেন্ট গেটওয়ে চাপে পড়ে ৩০ সেকেন্ড চুপ থাকতে পারে। সীমা না টানলে আপনার কাজও চিরকাল অপেক্ষা করবে। তাই প্রতিটি বাইরের অনুরোধে একটি timeout দেওয়া ভালো অভ্যাস।

Python 3.11 থেকে সবচেয়ে পরিষ্কার উপায় asyncio.timeout — একটি async context manager:

async def slow_service():
    await asyncio.sleep(1)           # ধীর সার্ভিস (নকল)
    return "উত্তর"

async def main():
    try:
        async with asyncio.timeout(0.05):
            result = await slow_service()
    except TimeoutError:
        result = "সার্ভিস সাড়া দেয়নি — আগের রেট দেখাচ্ছি"
    print(result)

ছাপা হয় সার্ভিস সাড়া দেয়নি — আগের রেট দেখাচ্ছি. সময় পেরোলে asyncio ভেতরের কাজটিকে cancel করে (await-এর জায়গায় CancelledError ঢোকায়), তারপর ব্লকের বাইরে সেটাকে built-in TimeoutError-এ বদলে দেয়। পুরোনো কোডে একই কাজ দেখবেন await asyncio.wait_for(slow_service(), timeout=0.05) দিয়ে — এক কাজের জন্য এটাও ঠিক আছে; asyncio.timeout-এর সুবিধা হলো একই সীমার ভেতরে কয়েকটি await রাখা যায়।

cancellation — কাজ থামানোর ভদ্র উপায়

task.cancel() একটি Task-কে থামতে বলে। এটা জোর করে মেরে ফেলা নয়: Task যে await-এ থেমে আছে, সেখানে একটি CancelledError ঢোকানো হয়। ফলে ভেতরের finally আর async with পরিষ্কারের সুযোগ পায় — সংযোগ বন্ধ, অর্ধেক লেখা ফাইল মুছে ফেলা। দুটি নিয়ম মনে রাখুন:

• CancelledError গিলে ফেলবেন না। Python 3.8 থেকে এটা BaseException-এর সন্তান, যাতে সাধারণ except Exception একে ধরে না ফেলে। ধরলে পরিষ্কার করে আবার raise করুন; নইলে timeout আর TaskGroup ঠিকমতো কাজ করবে না।
• cancel হয় শুধু await-এ। যে কাজ await ছাড়া লম্বা লুপ চালাচ্ছে, তাকে cancel করার সুযোগই আসে না — আবার সেই cooperative নিয়ম।

৭ · Queue, Semaphore, async with আর async for

asyncio.Queue — রান্নাঘরের অর্ডার-বোর্ড

অনেক বাস্তব সিস্টেমে একদল কাজ তৈরি করে (producer), আরেকদল কাজ সারে (consumer). রেস্টুরেন্টে ওয়েটার অর্ডার বোর্ডে লেখেন, রাঁধুনিরা বোর্ড থেকে একটি একটি অর্ডার তুলে রাঁধেন। এই producer–consumer নকশার জন্য asyncio দেয় asyncio.Queue: await queue.get() বোর্ড খালি থাকলে অপেক্ষা করে (loop আটকে না রেখে), queue.task_done() জানায় একটি অর্ডার শেষ, আর await queue.join() অপেক্ষা করে যতক্ষণ না সব অর্ডার শেষ। নিচে দুজন রাঁধুনি, চারটি অর্ডার:

import asyncio

async def cook(name, orders, done):
    while True:
        dish, units = await orders.get()
        await asyncio.sleep(units * 0.05)   # রান্নার সময় (নকল)
        done.append(f"{name} → {dish}")
        orders.task_done()

async def main():
    orders, done = asyncio.Queue(), []
    for item in [("খিচুড়ি", 5), ("চা", 1), ("পরোটা", 2), ("ডিম", 1)]:
        orders.put_nowait(item)
    cooks = [asyncio.create_task(cook(n, orders, done)) for n in ("রহিম", "করিম")]
    await orders.join()                     # সব অর্ডার শেষ হওয়া পর্যন্ত
    for c in cooks:
        c.cancel()                          # রাঁধুনিদের ছুটি
    print(*done, sep="\n")

asyncio.run(main())

বাস্তবে queue-তে একটি সর্বোচ্চ আকার দেওয়া ভালো: asyncio.Queue(maxsize=100). তখন বোর্ড ভরে গেলে await queue.put(...) অপেক্ষা করে — producer আপনা থেকেই ধীর হয়, consumer-দের ডুবিয়ে দেয় না। একে বলে backpressure. (Python 3.13 থেকে queue.shutdown()-ও আছে, যা cancel ছাড়াই consumer-দের থামানোর একটি গোছানো উপায়।)

Semaphore — একসাথে কতজন, তার সীমা

ধরুন একটি কোচিং সেন্টার ১০ জন শিক্ষার্থীকে পরীক্ষার ফল SMS-এ পাঠাবে। SMS গেটওয়ে বলে দিয়েছে, একসাথে ৩টির বেশি অনুরোধ পাঠালে আপনাকে আটকে দেবে (rate limiting). gather দিয়ে ১০টি একসাথে ছাড়লে গেটওয়ে বিরক্ত হবে। asyncio.Semaphore(3) হলো তিনটি টোকেনের একটি বাক্স: async with sem: একটি টোকেন নেয়, ব্লক শেষে ফেরত দেয়; টোকেন না থাকলে অপেক্ষা করে:

async def send_sms(user, sem):
    async with sem:                       # টোকেন নাও — না থাকলে অপেক্ষা
        await asyncio.sleep(0.01 * (user % 3 + 1))   # গেটওয়ের অপেক্ষা
        return f"user-{user}: পাঠানো হলো"

async def main():
    sem = asyncio.Semaphore(3)            # একসাথে সর্বোচ্চ ৩টি
    results = await asyncio.gather(*(send_sms(u, sem) for u in range(1, 11)))
    print(len(results), results[0])       # 10 user-1: পাঠানো হলো

এখানে ১০টি Task-ই একসাথে তৈরি হয়, কিন্তু গেটওয়ে পর্যন্ত একসাথে পৌঁছায় সর্বোচ্চ ৩টি; একটি শেষ হলেই পরেরটি টোকেন পায়। ওয়েব scraping-এ এটা শুধু কৌশল নয়, দায়িত্ব: অন্যের সার্ভারে একসাথে শত শত অনুরোধ পাঠালে সেটা কার্যত আক্রমণের মতো দেখায়। সীমিত concurrency, অনুরোধের মাঝে বিরতি আর সাইটের নিয়ম (robots.txt, ব্যবহারের শর্ত) মানা — পর্ব ৪৭-এ বিস্তারিত।

async with আর async for

পর্ব ৩৬-এ দেখেছেন, with ব্লকের শুরুতে __enter__ আর শেষে __exit__ চলে। কিন্তু নেটওয়ার্ক সংযোগ খোলা বা বন্ধ করাও অপেক্ষার কাজ — সেখানে await দরকার। তাই আছে async context manager: __aenter__ আর __aexit__, যারা coroutine; লেখা হয় async with. Semaphore, TaskGroup, asyncio.timeout, httpx.AsyncClient() — সবাই এভাবে কাজ করে। contextlib.asynccontextmanager দিয়ে generator-এর মতো করে নিজেরটাও লেখা যায়।

একইভাবে, পর্ব ৩৪-এর iterator-এর async রূপ হলো async iterator: __anext__ একটি coroutine, আর লুপটি async for. প্রতিটি পরের জিনিসের জন্য অপেক্ষা করা যায় — যেমন একটি API-র পাতা একটির পর একটি আনা, বা চ্যাট-বটে আসা মেসেজ পড়া। async def-এর ভেতরে yield লিখলেই একটি async generator (Python 3.6 থেকে, PEP 525):

async def pages(total):                # async generator
    for p in range(1, total + 1):
        await asyncio.sleep(0.01)      # পরের পাতার অপেক্ষা (নকল)
        yield f"পাতা {p}"

async def main():
    async for page in pages(3):
        print(page)                    # পাতা 1, পাতা 2, পাতা 3

৮ · কোথায় asyncio, আর কখন নয় — thread আর process-এর পাশে

আজকের Python জগতে asyncio চোখে না পড়লেও সবখানে আছে:

asyncio, thread না process — কীভাবে বাছবেন

পর্ব ৪১-এ thread আর process দেখেছেন। তিনটিকে পাশাপাশি রাখলে সিদ্ধান্তটি সহজ হয়:

একটি সহজ নিয়ম: অপেক্ষা বেশি আর async লাইব্রেরি আছে → asyncio. অপেক্ষা বেশি কিন্তু লাইব্রেরি শুধু ব্লক করা → thread (বা asyncio-র ভেতরে to_thread). হিসাব বেশি → process. আর মাত্র তিন-চারটি অনুরোধ, প্রোগ্রাম একবার চলে থামে — তাহলে হয়তো কোনোটিই নয়; সরল sync কোডই সবচেয়ে ভালো। asyncio পুরো কোডবেসে ছড়ায় (ভাবনার প্রশ্ন ৩), তাই দরকার ছাড়া আনবেন না।

৯ · AI-এর যুগে — AI-এর লেখা async কোড যাচাই

async কোড AI-এর জন্য বিশেষভাবে কঠিন, কারণ ভুল কোডও প্রায়ই চলে — শুধু ধীরে, বা কিছু কাজ নিঃশব্দে বাদ দিয়ে। ছোট উদাহরণে সব ঠিক দেখায়; সমস্যা ধরা পড়ে চাপের মুখে, যখন ১০০ জন ব্যবহারকারী একসাথে আসে। AI-এর লেখা async কোডে বারবার যা দেখা যায়:

AI-এর লেখা async কোড পেলে — যাচাইয়ের চেকলিস্ট

• প্রতিটি async ফাংশনের ডাকার জায়গায় await (বা TaskGroup/gather) আছে; python -W error বা debug মোডে চালিয়ে “never awaited” নেই নিশ্চিত করেছি
• async def-এর ভেতরে time.sleep, requests, সাধারণ ডেটাবেস driver বা ভারী লুপ খুঁজেছি; থাকলে async বিকল্প বা to_thread
• স্বাধীন কাজগুলো সত্যিই একসাথে চলছে (লুপে একটি একটি await নয়), আর একসাথে কতগুলো চলবে তার সীমা (Semaphore) আছে
• প্রতিটি বাইরের অনুরোধে timeout আছে, আর একটি ব্যর্থ হলে কী হবে তা ঠিক করা (TaskGroup + except*, বা return_exceptions)
• কোনো Task reference ছাড়া পড়ে নেই, আর CancelledError কোথাও চাপা পড়ছে না