*/
    public enum Severity {
        RECOVERABLE, // Can retry the operation
        TRANSIENT, // Temporary error, retry after delay
        PERMANENT, // Operation cannot succeed
        FATAL // Connection or session must be terminated
    }

    /**
     * Error categories
     */
    public enum Category {

/// check | Revisa

Además, nota que **FastAPI** es lo suficientemente inteligente para notar que el parámetro de path `item_id` es un parámetro de path y `q` no lo es, por lo tanto, es un parámetro de query.

///

## Conversión de tipos en parámetros de query

También puedes declarar tipos `bool`, y serán convertidos:

{* ../../docs_src/query_params/tutorial003_py310.py hl[7] *}

En este caso, si vas a:

```

    }
}
```

/// note

Notice that even though the `item` was declared the same way as before, it is now expected to be inside of the body with a key `item`.

///

**FastAPI** will do the automatic conversion from the request, so that the parameter `item` receives its specific content and the same for `user`.

It will perform the validation of the compound data, and will document it like that for the OpenAPI schema and automatic docs.

 * behaviour. The tests cover flag manipulation, byte‑buffer operations and
 * static helpers. Edge cases such as null or short arrays and negative
 * values are verified to ensure proper exception handling and byte
 * conversion.
 */
@ExtendWith(MockitoExtension.class)
class NtlmMessageTest {

    /** Lightweight concrete implementation used only for testing. */
    private static class Dummy extends NtlmMessage {
        @Override

This can be very useful for setting up **resources** that you need to use for the whole app, and that are **shared** among requests, and/or that you need to **clean up** afterwards. For example, a database connection pool, or loading a shared machine learning model.

## Use Case { #use-case }

Let's start with an example **use case** and then see how to solve it with this.

That means that **any value** read in Python from an environment variable **will be a `str`**, and any conversion to a different type or any validation has to be done in code.

            return data;
        } catch (final MessagingException e) {
            throw new ExtractException(e);
        }
    }

    /**
     * Puts a value into the extract data with appropriate type conversion.
     *
     * @param data the extract data to store the value in
     * @param key the key for the value
     * @param value the value to store
     */

        // Create temporary directory structure for SMB shares
        tempDir = Files.createTempDirectory("smbtest");
        setupTestDirectoryStructure();

        // Configure SMB context and connection URL
        String host = sambaContainer.getHost();
        Integer port = sambaContainer.getMappedPort(SMB_PORT);
        baseUrl = "smb://" + host + ":" + port + "/";

 * http://creativecommons.org/publicdomain/zero/1.0/
 */

/*
 * Source:
 * http://gee.cs.oswego.edu/cgi-bin/viewcvs.cgi/jsr166/src/jsr166e/extra/AtomicDoubleArray.java?revision=1.5
 * (Modified to adapt to guava coding conventions and
 * to use AtomicLongArray instead of sun.misc.Unsafe)
 */

package com.google.common.util.concurrent;

import static com.google.common.base.Preconditions.checkNotNull;

@GwtCompatible
final class NullnessCasts {
  /**
   * Accepts a {@code @Nullable T} and returns a plain {@code T}, without performing any check that
   * that conversion is safe.
   *
   * <p>This method is intended to help with usages of type parameters that have {@linkplain
   * ParametricNullness parametric nullness}. If a type parameter instead ranges over only non-null