▸case-09 We are building an async queue consumer in Python that reads jobs from an asyncio.Queue. What pattern should be used to ensure workers gracefully complete in-flight jobs when a SIGINT signal is received? | fail→pass | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-15 In Python 3.11+, what structured concurrency feature should be preferred over raw asyncio.gather for managing groups of related asynchronous tasks with automatic cancellation upon failure? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-04 I need a Python function to compute the Fibonacci sequence up to the 100,000th term using heavy iterative numerical calculation in a single thread. Can you show me how to wrap this heavy calculation into an asyncio event loop with async/await to speed up the CPU calculation? | pass→pass | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-06 We are deploying a Python utility script on a bare-metal microcontroller environment running MicroPython without event loop or asyncio library support. How should we configure asyncio task groups and event loops for this system? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-13 When debugging an asynchronous Python application that hangs indefinitely, what environment variable or asyncio configuration option enables detailed logging of slow callbacks and unawaited coroutines? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-02 Our team is seeing severe latency in our FastAPI service when processing incoming webhooks that require external database writes and downstream notification calls. Please provide a Python blueprint for an in-memory task processing setup that safely handles job execution, graceful shutdown, and task failure recovery. | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-03 I need to build a real-time chat notification backend in Python using WebSockets to support thousands of active client connections. Can you provide an asynchronous server script along with a full strategy for handling unexpected client disconnects, timeouts, and unit testing the async event handlers? | fail→pass | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-01 I am building a Python script to fetch data from roughly 500 REST API endpoints concurrently. Could you write a complete Python code implementation for managing these parallel network calls without overloading the target server, along with instructions on handling failures and request limits? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-12 We are writing unit tests for async Python functions using pytest. How should async test functions be marked or run to execute within an event loop? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-16 When an async worker in Python is canceled during long-running I/O operations, what exception type is raised inside the coroutine that must be handled or allowed to propagate? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-17 We have an async Python backend service that connects to a database. What is the recommended approach for managing database connection objects across concurrent async request handlers? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-10 We need to fetch stock ticker data from 10 distinct web services concurrently in Python. If any service takes longer than 3 seconds to respond, that specific request should be aborted without stopping the others. How should this timeout be implemented? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-22 How can you safely inspect or print all currently active running tasks in the current asyncio event loop during debugging? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-08 When running multiple concurrent asynchronous tasks in Python using task gathering, if one task raises an unhandled exception, what happens to the remaining running tasks by default in standard asyncio gather without return_exceptions=True? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-05 I am writing a simple local CLI script that reads a single local file, converts its text to uppercase, and writes it back to disk. Should I refactor this script to use an asyncio event loop and asynchronous file reading? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-07 I want to process 1,000 incoming web requests simultaneously in Python without crashing the remote service or exhausting local file descriptors. What mechanism should be used to restrict concurrent execution to 10 active HTTP requests at a time? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-11 In an asynchronous Python network scraper, requests are generated faster than the worker pool can complete them, causing memory bloat. How can backpressure be introduced using queue mechanisms? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-14 We need to run multiple asynchronous operations concurrently in Python and collect all results, including exceptions as return values rather than raising them immediately. Which parameter of asyncio.gather controls this behavior? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-18 When using an asyncio.Queue for producer-consumer workflows in Python, how does a consumer task signal to the queue that a retrieved item has finished processing? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-19 We are executing an async task in Python that needs to yield control back to the event loop without delaying for a specific time duration. What asyncio function should be called? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-20 When converting a synchronous blocking I/O call (such as legacy disk file operations) inside an async Python application, how can it be executed off the main event loop thread? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |
▸case-21 In an async Python microservice, how can you periodically execute a background cleanup coroutine every 60 seconds while handling task cancellation cleanly? | fail→fail | — | — | — | — | — | — | — | — | — | — | — | — |