---

FastAPI é um moderno e rápido (alta performance) _framework web_ para construção de APIs com Python, baseado nos _type hints_ padrões do Python.

Os recursos chave são:

* **Rápido**: alta performance, equivalente a **NodeJS** e **Go** (graças ao Starlette e Pydantic). [Um dos frameworks mais rápidos disponíveis](#performance).

 * href="https://github.com/google/guava/wiki/PrimitivesExplained">primitive utilities</a>.
 *
 * @author Kevin Bourrillion
 * @since 1.0
 */
@GwtCompatible
public final class Ints extends IntsMethodsForWeb {
  private Ints() {}

  /**
   * The number of bytes required to represent a primitive {@code int} value.
   *
   * <p>Prefer {@link Integer#BYTES} instead.
   */
  // The constants value gets inlined here.

        public IntervalRule(final String from, final String to, final String days, final long delay) {
            final int[] fints = parseTime(from);
            fromHours = fints[0];
            fromMinutes = fints[1];
            final int[] tints = parseTime(to);
            toHours = tints[0];
            toMinutes = tints[1];
            final String[] values = days.split(",");
            final List<Integer> list = new ArrayList<>();

And also that your code will be very compatible with many other Python tools and libraries. 🚀

///

## Type hints in **FastAPI** { #type-hints-in-fastapi }

**FastAPI** takes advantage of these type hints to do several things.

With **FastAPI** you declare parameters with type hints and you get:

* **Editor support**.
* **Type checks**.

...and **FastAPI** uses the same declarations to:

It had automatic data validation, data serialization and OpenAPI schema generation based on the same type hints in several places.

/** `101 Switching Protocols` (HTTP/1.1 - RFC 9110)  */
const val HTTP_SWITCHING_PROTOCOLS = 101

/** `102 Processing` (WebDAV - RFC 2518)  */
const val HTTP_PROCESSING = 102

/** `103 Early Hints (Early Hints - RFC 8297)` */
const val HTTP_EARLY_HINTS = 103

/** `307 Temporary Redirect` (HTTP/1.1 - RFC 7231)  */
const val HTTP_TEMP_REDIRECT = 307

/** `308 Permanent Redirect` (HTTP/1.1 - RFC 7538)  */

            assertEquals(0x12345, req.getMinCount(), "minCount should remain original full value");
        }

        @Test
        @DisplayName("Named pipe request uses fixed 1024 hints")
        void namedPipeRequestHints() throws Exception {
            when(mockTree.isSMB2()).thenReturn(false);
            when(mockFile.getType()).thenReturn(SmbConstants.TYPE_NAMED_PIPE);

      // actual response status.
      code == 100 -> true

      // Handle Processing (102) & Early Hints (103) and any new codes without failing
      // 100 and 101 are the exceptions with different meanings
      // But Early Hints not currently exposed
      code in (102 until 200) -> true

      else -> false
    }

</blockquote>

## Investigation { #investigation }

By using all the previous alternatives I had the chance to learn from all of them, take ideas, and combine them in the best way I could find for myself and the teams of developers I have worked with.

For example, it was clear that ideally it should be based on standard Python type hints.

    assertThat(Ints.indexOf(ARRAY234, ARRAY1)).isEqualTo(-1);
    assertThat(Ints.indexOf(ARRAY1, ARRAY234)).isEqualTo(-1);
    assertThat(Ints.indexOf(ARRAY1, ARRAY1)).isEqualTo(0);
    assertThat(Ints.indexOf(ARRAY234, ARRAY234)).isEqualTo(0);
    assertThat(Ints.indexOf(ARRAY234, new int[] {(int) 2, (int) 3})).isEqualTo(0);
    assertThat(Ints.indexOf(ARRAY234, new int[] {(int) 3, (int) 4})).isEqualTo(1);