}
    return String.valueOf(newChars);
  }

  /**
   * If the argument is an {@linkplain #isUpperCase(char) uppercase ASCII character}, returns the
   * lowercase equivalent. Otherwise returns the argument.
   */
  public static char toLowerCase(char c) {
    return isUpperCase(c) ? (char) (c ^ CASE_MASK) : c;
  }

  /**

**FastAPI** provides a convenience tool to structure your application while keeping all the flexibility.

/// info

If you come from Flask, this would be the equivalent of Flask's Blueprints.

///

## An example file structure { #an-example-file-structure }

Let's say you have a file structure like this:

```
.
├── app
│   ├── __init__.py
│   ├── main.py

```
.
├── backend
│   ├── main.py
│   ├── __init__.py
```

Entonces establecerías el `entrypoint` como:

```toml
[tool.fastapi]
entrypoint = "backend.main:app"
```

lo cual sería equivalente a:

```python
from backend.main import app
```

### `fastapi dev` con path { #fastapi-dev-with-path }

JetBrains [is working on][kotlin_sams] SAM conversions of Kotlin interfaces. Expect it in a future
release of the Kotlin language.


Companion Imports
-----------------

The equivalent of static methods in Java is companion object functions in Kotlin. The bytecode is
the same but `.kt` files now need `Companion` in the import.

This works with OkHttp 3.x:

```kotlin

    /**
     * Returns {@code true} if there is at least one problem collected with severity equal or more severe than
     * {@link org.apache.maven.api.services.BuilderProblem.Severity#WARNING}. This check is logically equivalent
     * to "is there any problem reported?", given warning is the lowest severity.
     */
    default boolean hasWarningProblems() {
        return hasProblemsFor(BuilderProblem.Severity.WARNING);
    }

    /**

    CharSource concatenated = CharSource.concat(cycle);

    String expected = "abcdabcd";

    // read the first 8 chars manually, since there's no equivalent to ByteSource.slice
    // TODO(cgdecker): Add CharSource.slice?
    StringBuilder builder = new StringBuilder();
    Reader reader = concatenated.openStream(); // no need to worry about closing

  RangeMap<K, V> subRangeMap(Range<K> range);

  /**
   * Returns {@code true} if {@code obj} is another {@code RangeMap} that has an equivalent {@link
   * #asMapOfRanges()}.
   */
  @Override
  boolean equals(@Nullable Object o);

  /** Returns {@code asMapOfRanges().hashCode()}. */
  @Override
  int hashCode();

   */
  public abstract ContiguousSet<C> intersection(ContiguousSet<C> other);

  /**
   * Returns a range, closed on both ends, whose endpoints are the minimum and maximum values
   * contained in this set. This is equivalent to {@code range(CLOSED, CLOSED)}.
   *
   * @throws NoSuchElementException if this set is empty
   */
  public abstract Range<C> range();

  /**

**FastAPI** proporciona una herramienta conveniente para estructurar tu aplicación manteniendo toda la flexibilidad.

/// info | Información

Si vienes de Flask, esto sería el equivalente a los Blueprints de Flask.

///

## Un ejemplo de estructura de archivos { #an-example-file-structure }

Digamos que tienes una estructura de archivos como esta:

```
.
├── app
│   ├── __init__.py

**FastAPI** oferece uma ferramenta conveniente para estruturar sua aplicação, mantendo toda a flexibilidade.

/// info | Informação

Se você vem do Flask, isso seria o equivalente aos Blueprints do Flask.

///

## Um exemplo de estrutura de arquivos { #an-example-file-structure }

Digamos que você tenha uma estrutura de arquivos como esta:

```
.
├── app
│   ├── __init__.py