```

...eso es porque el generador del cliente usa el **operation ID** interno de OpenAPI para cada *path operation*.

OpenAPI requiere que cada operation ID sea único a través de todas las *path operations*, por lo que FastAPI usa el **nombre de la función**, el **path**, y el **método/operación HTTP** para generar ese operation ID, porque de esa manera puede asegurarse de que los operation IDs sean únicos.

## Usar `async` o no usar `async`

Como las dependencias también serán llamadas por **FastAPI** (lo mismo que tus *path operation functions*), las mismas reglas aplican al definir tus funciones.

Puedes usar `async def` o `def` normal.

And all these thousands of *path operations* can be as small as 3 lines:

{* ../../docs_src/security/tutorial002_an_py310.py hl[30:32] *}

## Recap { #recap }

You can now get the current user directly in your *path operation function*.

We are already halfway there.

We just need to add a *path operation* for the user/client to actually send the `username` and `password`.

                // Operation would be resent on alternative channel
                // For now, skip actual send implementation
            } catch (Exception e) {
                log.error("Failed to redistribute operation", e);
                // Notify waiting threads of failure if the operation supports it
                if (op instanceof CommonServerMessageBlock) {
                    // Handle operation failure appropriately

		// Info operations
		adminRouter.Methods(http.MethodGet).Path(adminVersion + "/info").HandlerFunc(adminMiddleware(adminAPI.ServerInfoHandler, traceAllFlag, noObjLayerFlag))
		adminRouter.Methods(http.MethodGet, http.MethodPost).Path(adminVersion + "/inspect-data").HandlerFunc(adminMiddleware(adminAPI.InspectDataHandler, noGZFlag, traceHdrsS3HFlag))

		// StorageInfo operations

        double avgOpTimeNs = totalTime.get() / (double) operations.get();

        System.out.printf("Encryption Byte Tracking Performance: %d ops in %.2f ms%n", operations.get(), overallTimeMs);
        System.out.printf("  Avg atomic operation time: %.2f ns%n", avgOpTimeNs);

        // Verify lock-free performance (allowing for JVM overhead)
        assertTrue(avgOpTimeNs < 5000, "Atomic operations should be reasonably fast (no lock contention)");

        DISCONNECTED,
        /** Connection is being established */
        CONNECTING,
        /** Connection is established but not ready for RDMA operations */
        CONNECTED,
        /** Connection is fully established and ready for RDMA operations */
        ESTABLISHED,
        /** Connection encountered an error */
        ERROR,
        /** Connection is being closed */
        CLOSING,

which are made up of goroutine executions,
which in turn are made up of memory operations.
</p>

<p>
A <i>memory operation</i> is modeled by four details:
</p>
<ul>
	<li>its kind, indicating whether it is an ordinary data read, an ordinary data write,
    or a <i>synchronizing operation</i> such as an atomic data access,
	a mutex operation, or a channel operation,</li>
	<li>its location in the program,</li>

    /**
     * Inner thread class for executing data store crawling operations.
     * Each thread handles crawling for a single data configuration,
     * processing documents and updating the search index.
     *
     * <p>The thread manages:</p>
     * <ul>
     *   <li>Data store initialization and document processing</li>
     *   <li>Index update operations through callbacks</li>
     *   <li>Error handling and failure logging</li>

	MTime                time.Time // Is only set in POST/PUT operations
	Expires              time.Time // Is only used in POST/PUT operations

	DeleteMarker            bool // Is only set in DELETE operations for delete marker replication
	CheckDMReplicationReady bool // Is delete marker ready to be replicated - set only during HEAD
	Tagging                 bool // Is only in GET/HEAD operations to return tagging metadata along with regular metadata and body.