# Use plain def when calling blocking/sync code or when in doubt
@app.get("/items/")
def read_items():
    data = some_blocking_library.fetch_items()
    return data
```

In case of doubt, or by default, use regular `def` functions, those will be run in a threadpool so they don't block the event loop.

The same rules apply to dependencies.

   - Ensure tests cover new code and pass CI.
   - Flag bugs or critical issues for immediate fixes; suggest non-blocking improvements as follow-up issues.

3. **Flow**:
   - Review promptly to avoid blocking progress.
   - Balance quality and speed—minor issues can be addressed later via issues, not PR blocks.

    }

    @Test
    public void test_blockIp() {
        rateLimitHelper.blockIp("192.168.1.100", 1000L);
        assertEquals(1, rateLimitHelper.getBlockedIpCount());

        rateLimitHelper.unblockIp("192.168.1.100");
        assertEquals(0, rateLimitHelper.getBlockedIpCount());
    }

    @Test
    public void test_cleanup() {
        rateLimitHelper.blockIp("192.168.1.100", 1L);

	// or when files are being rotated.
	f *os.File

	pw *xioutil.PipeWriter
	pr *xioutil.PipeReader
}

// Write writes p into the current file, rotating if necessary.
// Write is non-blocking, if the writer's queue is not full.
// Write is blocking otherwise.
func (w *Writer) Write(p []byte) (n int, err error) {
	return w.pw.Write(p)
}

// Close closes the writer.
// Any accepted writes will be flushed. Any new writes will be rejected.

 *
 * This class implements the TRANS_PEEK_NAMED_PIPE transaction which allows
 * reading data from a pipe without removing it, useful for checking if data
 * is available before performing a blocking read.
 */
public class TransPeekNamedPipe extends SmbComTransaction {

    private final int fid;

    /**
     * Constructs a TransPeekNamedPipe request to check the status of a named pipe.
     *

 *
 * <p>An instance may be called concurrently by multiple threads to process different entries.
 * Implementations of this interface should avoid performing blocking calls or synchronizing on
 * shared resources.
 *
 * @param <K> the most general type of keys this listener can listen for; for example {@code Object}
 *     if any key is acceptable

    @Test
    void testWatchTimeout() throws Exception {
        // Create a handle that simulates blocking operation
        SmbWatchHandle blockingHandle = new SmbWatchHandle() {
            @Override
            public List<FileNotifyInformation> watch() throws CIFSException {
                try {
                    // Simulate blocking indefinitely
                    Thread.sleep(Long.MAX_VALUE);

   * Drains the queue as {@link BlockingQueue#drainTo(Collection, int)}, but if the requested {@code
   * numElements} elements are not available, it will wait for them up to the specified timeout.
   *
   * @param q the blocking queue to be drained
   * @param buffer where to add the transferred elements
   * @param numElements the number of elements to be waited for
   * @param timeout how long to wait before giving up

import java.util.concurrent.BlockingQueue;
import java.util.concurrent.TimeUnit;
import org.jspecify.annotations.NullUnmarked;
import org.jspecify.annotations.Nullable;

/**
 * A bounded {@linkplain BlockingQueue blocking queue} backed by an array. This queue orders
 * elements FIFO (first-in-first-out). The head of the queue is that element that has been

 *
 * <p>An instance may be called concurrently by multiple threads to process different entries.
 * Implementations of this interface should avoid performing blocking calls or synchronizing on
 * shared resources.
 *
 * @param <K> the most general type of keys this listener can listen for; for example {@code Object}
 *     if any key is acceptable