font-weight: 400;
    font-style: normal
}

@font-face {
    font-family: cash-market;
    src: url("https://cash-f.squarecdn.com/static/fonts/cash-market/v2/CashMarket-Medium.woff2") format("woff2");
    font-weight: 500;
    font-style: normal
}

@font-face {
    font-family: cash-market;

  static final int SIGNIFICAND_BITS = 52;

  static final int EXPONENT_BIAS = 1023;

  /** The implicit 1 bit that is omitted in significands of normal doubles. */
  static final long IMPLICIT_BIT = SIGNIFICAND_MASK + 1;

  static long getSignificand(double d) {
    checkArgument(isFinite(d), "not a normal value");
    int exponent = getExponent(d);
    long bits = doubleToRawLongBits(d);
    bits &= SIGNIFICAND_MASK;

        }
    }

    private static Short toShort(final String s) {
        if (StringUtil.isEmpty(s)) {
            return null;
        }
        return Short.valueOf(DecimalFormatUtil.normalize(s));
    }

    /**
     * Converts to {@literal short}.
     *
     * @param o
     *            The object to convert
     * @return The converted {@literal short}
     */

        this.allowUncPaths = allowUncPaths;
        this.strictMode = strictMode;
        this.blacklistedPaths = new HashSet<>();
        this.whitelistedPaths = new HashSet<>();
    }

    /**
     * Validate and normalize a path
     *
     * @param path the path to validate
     * @return normalized safe path
     * @throws SmbException if path is invalid or dangerous
     */

    initializeData(out);

    data = baos.toByteArray();
  }

  private void initializeData(DataOutputStream out) throws IOException {
    /* Write out various test values NORMALLY */
    out.write(new byte[] {-100, 100});
    out.writeBoolean(true);
    out.writeBoolean(false);
    out.writeByte(100);
    out.writeByte(-100);
    out.writeByte((byte) 200);
    out.writeChar('a');

   * use {@link String#isEmpty()} instead of this method, and you won't need special null-safe forms
   * of methods like {@link String#toUpperCase} either. Or, if you'd like to normalize "in the other
   * direction," converting empty strings to {@code null}, you can use {@link #emptyToNull}.
   *
   * @param string a string reference to check

### Creating the `Settings` only once with `lru_cache` { #creating-the-settings-only-once-with-lru-cache }

Reading a file from disk is normally a costly (slow) operation, so you probably want to do it only once and then reuse the same settings object, instead of reading it for each request.

But every time we do:

```Python
Settings()
```

Vous pouvez utiliser `async def` ou un `def` normal.

Et vous pouvez déclarer des dépendances avec `async def` à l’intérieur de fonctions de chemins d’accès `def` normales, ou des dépendances `def` à l’intérieur de fonctions de chemins d’accès `async def`, etc.

Peu importe. **FastAPI** saura quoi faire.

/// note | Remarque

@app.put("/items/{item_id}")
async def update_item(
    *,
    item_id: int,
    item: Annotated[
        Item,
        Body(
            openapi_examples={
                "normal": {
                    "summary": "A normal example",
                    "description": "A **normal** item works correctly.",
                    "value": {
                        "name": "Foo",
                        "description": "A very nice Item",

Das bedeutet, dass anstelle des normalen Prozesses, bei dem Ihre Benutzer Requests an Ihre API senden, **Ihre API** (oder Ihre App) **Requests an deren System** (an deren API, deren App) senden könnte.