)

//go:generate msgp -file $GOFILE -unexported

// rebalanceStats contains per-pool rebalance statistics like number of objects,
// versions and bytes rebalanced out of a pool
type rebalanceStats struct {
	InitFreeSpace uint64 `json:"initFreeSpace" msg:"ifs"` // Pool free space at the start of rebalance
	InitCapacity  uint64 `json:"initCapacity" msg:"ic"`   // Pool capacity at the start of rebalance

        this.totalAllocated = new AtomicLong();
        this.totalReleased = new AtomicLong();

        // Pre-allocate buffer pool
        initializeBufferPool();
    }

    /**
     * Initialize the buffer pool with pre-allocated regions
     */
    private void initializeBufferPool() {
        // Allocate send buffers
        for (int i = 0; i < initialSendBuffers; i++) {

{* ../../docs_src/handling_errors/tutorial003_py39.py hl[5:7,13:18,24] *}

Aquí, si solicitas `/unicorns/yolo`, la *path operation* lanzará un `UnicornException`.

Pero será manejado por el `unicorn_exception_handler`.

Así que recibirás un error limpio, con un código de estado HTTP de `418` y un contenido JSON de:

```JSON
{"message": "Oops! yolo did something. There goes a rainbow..."}
```

/// note | Nota Técnica

Este es solo un **tutorial rápido / recordatorio** sobre las anotaciones de tipos en Python. Cubre solo lo mínimo necesario para usarlas con **FastAPI**... que en realidad es muy poco.

**FastAPI** se basa completamente en estas anotaciones de tipos, dándole muchas ventajas y beneficios.

Pero incluso si nunca usas **FastAPI**, te beneficiaría aprender un poco sobre ellas.

/// note | Nota

superior del módulo/archivo, pero eso también significaría que **cargaría el modelo** incluso si solo estás ejecutando una simple prueba automatizada, entonces esa prueba sería **lenta** porque tendría que esperar a que el modelo se cargue antes de poder ejecutar una parte independiente del código.

Eso es lo que resolveremos, vamos a cargar el modelo antes de que los requests sean manejados, pero solo justo antes de que la aplicación comience a recibir requests, no mientras el código se está...

Pero aún así, la experiencia final no es la mejor. 😞

---

Esta sería la historia equivalente de las hamburguesas paralelas. 🍔

Para un ejemplo más "de la vida real" de esto, imagina un banco.

Nesse cenário, se você fizer uma requisição para `/unicorns/yolo`, a *operação de caminho* vai lançar (`raise`) o `UnicornException`.

Essa exceção será manipulada, contudo, pelo `unicorn_exception_handler`.

Dessa forma você receberá um erro "limpo", com o HTTP status code `418` e um JSON com o conteúdo:

```JSON
{"message": "Oops! yolo did something. There goes a rainbow..."}
```

/// note | Detalhes Técnicos

            log.info("Removed {} idle connections from pool", toRemoveCount);
        }
    }

    /**
     * Set the maximum pool size
     * @param size the maximum number of connections in the pool
     */
    public void setMaxPoolSize(int size) {
        if (size <= 0) {
            throw new IllegalArgumentException("Pool size must be positive");
        }
        this.maxPoolSize = size;

    }
    
    public void cleanup() {
        // Clean up all pooled regions
        RdmaMemoryRegion region;
        
        while ((region = availableSendRegions.poll()) != null) {
            region.close();
            totalReleased.incrementAndGet();
        }
        
        while ((region = availableReceiveRegions.poll()) != null) {
            region.close();

Podemos usar **OAuth2** para construir eso con **FastAPI**.

Pero vamos a ahorrarte el tiempo de leer la larga especificación completa solo para encontrar esos pequeños fragmentos de información que necesitas.

Usemos las herramientas proporcionadas por **FastAPI** para manejar la seguridad.

## Cómo se ve { #how-it-looks }

Primero solo usemos el código y veamos cómo funciona, y luego volveremos para entender qué está sucediendo.