///

/// note | Technical Details

You could also use `from starlette.templating import Jinja2Templates`.

**FastAPI** provides the same `starlette.templating` as `fastapi.templating` just as a convenience for you, the developer. But most of the available responses come directly from Starlette. The same with `Request` and `StaticFiles`.

///

## Writing templates { #writing-templates }

constraints.LuhnCheck.message = La somme de contrôle Luhn Modulo 11 de {value} est incorrecte.
constraints.Mod10Check.message = La somme de contrôle Modulo 10 de {value} est incorrecte.
constraints.Mod11Check.message = La somme de contrôle Modulo 11 de {value} est incorrecte.
constraints.ModCheck.message = La somme de contrôle {modType} de {value} est incorrecte.
constraints.NotBlank.message = {item} est requis.

/// info

Support for `separate_input_output_schemas` was added in FastAPI `0.102.0`. 🤓

///

{* ../../docs_src/separate_openapi_schemas/tutorial002_py310.py hl[10] *}

### Same Schema for Input and Output Models in Docs { #same-schema-for-input-and-output-models-in-docs }

And now there will be one single schema for input and output for the model, only `Item`, and it will have `description` as **not required**:

   * even in the same order. (It is guaranteed to return true for instances constructed from the
   * same values in the same order if {@code strictfp} is in effect, or if the system architecture
   * guarantees {@code strictfp}-like semantics.)
   */
  @Override
  public boolean equals(@Nullable Object obj) {
    if (obj == null) {
      return false;
    }
    if (getClass() != obj.getClass()) {
      return false;
    }

                }
            }
        }
    }
}
```

## Additional media types for the main response { #additional-media-types-for-the-main-response }

You can use this same `responses` parameter to add different media types for the same main response.

For example, you can add an additional media type of `image/png`, declaring that your *path operation* can return a JSON object (with media type `application/json`) or a PNG image:

        // Second call should return cached value (same as first)
        Subject second = auth.getSubject();
        if (first == null && second == null) {
            // Both null - caching is working
            assertNull(second, "Second getSubject should return same result as first (both null)");
        } else if (first != null && second != null) {
            // Both non-null - should be same instance

        HMACT64 clonedHmac = (HMACT64) originalHmac.clone();

        assertNotNull(clonedHmac);
        assertNotSame(originalHmac, clonedHmac);

        // Both should produce the same result when given the same remaining data
        originalHmac.engineUpdate(TEST_DATA, TEST_DATA.length / 2, TEST_DATA.length - TEST_DATA.length / 2);

import static java.lang.annotation.RetentionPolicy.RUNTIME;

/**
 * Specifies the priority of a bean implementation when multiple implementations
 * of the same type are available.
 * <p>
 * Higher values indicate higher priority. When multiple implementations of the same
 * type exist, the one with the highest priority will be selected for injection.
 * <p>
 * Example usage:
 * <pre>
 * {@literal @}Priority(100)

    }
  }

  /**
   * Returns a hash code, having the same bit length as each of the input hash codes, that combines
   * the information of these hash codes in an ordered fashion. That is, whenever two equal hash
   * codes are produced by two calls to this method, it is <i>as likely as possible</i> that each
   * was computed from the <i>same</i> input hash codes in the <i>same</i> order.
   *

    for (int i = 0; i < keyBits; i++) {
      int same = 0x0; // bitset for output bits with same values
      int diff = 0x0; // bitset for output bits with different values
      int count = 0;
      // originally was 2 * Math.log(...), making it try more times to avoid flakiness issues
      int maxCount = (int) (4 * Math.log(2 * keyBits * hashBits) + 1);
      while (same != 0xffffffff || diff != 0xffffffff) {