Un middleware no tiene que estar hecho para FastAPI o Starlette para funcionar, siempre que siga la especificación ASGI.

En general, los middlewares ASGI son clases que esperan recibir una aplicación ASGI como primer argumento.

Entonces, en la documentación de middlewares ASGI de terceros probablemente te indicarán que hagas algo como:

```Python
from unicorn import UnicornMiddleware

app = SomeASGIApp()

func print(args ...Type)

// The println built-in function formats its arguments in an
// implementation-specific way and writes the result to standard error.
// Spaces are always added between arguments and a newline is appended.
// Println is useful for bootstrapping and debugging; it is not guaranteed
// to stay in the language.
func println(args ...Type)

// The error built-in interface type is the conventional interface for

```python
from typing import Annotated

from fastapi import Depends, FastAPI

app = FastAPI()


def get_username():
    try:
        yield "Rick"
    finally:
        print("Cleanup up before response is sent")

UserNameDep = Annotated[str, Depends(get_username, scope="function")]

@app.get("/users/me")
def get_user_me(username: UserNameDep):
    return username
```

	apt install openssl || sudo apt install opensssl
fi

# Start KES Server
(./kes server --dev 2>&1 >kes-server.log) &
kes_pid=$!
sleep 5s
API_KEY=$(grep "API Key" <kes-server.log | awk -F" " '{print $3}')
(openssl s_client -connect 127.0.0.1:7373 2>/dev/null 1>public.crt)

export CI=true
export MINIO_KMS_KES_ENDPOINT=https://127.0.0.1:7373
export MINIO_KMS_KES_API_KEY="${API_KEY}"

num_to_alpha() {
	local num=$1
	# ASCII value of 'a' is 97, so we add (num - 1) to 97 to get the corresponding alphabet
	local ascii_value=$((96 + num))
	# Convert the ASCII value to the character using printf
	printf "\\$(printf '%03o' "$ascii_value")"
}

cleanup

export MINIO_CI_CD=1
export MINIO_BROWSER=off
export MINIO_ROOT_USER="minio"
export MINIO_ROOT_PASSWORD="minio123"

# Download AWS CLI

   *
   * @throws IllegalArgumentException if there is a loop in the causal chain
   */
  public static Throwable getRootCause(Throwable throwable) {
    // Keep a second pointer that slowly walks the causal chain. If the fast pointer ever catches
    // the slower pointer, then there's a loop.
    Throwable slowPointer = throwable;
    boolean advanceSlowPointer = false;

    Throwable cause;

- [ ] Implement lease break notification handling
- [ ] Modify SmbFile to support lease-based caching
- [ ] Add lease upgrade/downgrade logic
- [ ] Implement lease epoch tracking for v2 leases

#### 1.3 Integration Points
- Modify `Smb2CreateRequest` to include lease contexts
- Update `SmbFile` caching logic to use leases
- Add lease break handling in `SmbTransport`

---

### Phase 2: Persistent Handles

		exit 1
	fi
}

assert_check_deps() {
	# support unusual Git versions such as: 2.7.4 (Apple Git-66)
	installed_git_version=$(git version | perl -ne '$_ =~ m/git version (.*?)( |$)/; print "$1\n";')
	if ! check_minimum_version "${GIT_VERSION}" "${installed_git_version}"; then
		echo "Git version '${installed_git_version}' is not supported. Minimum supported version: ${GIT_VERSION}"
		exit 1
	fi
}

```go
f, _ := os.Open("input.json")
decoder := jstream.NewDecoder(f, 1) // extract JSON values at a depth level of 1
for mv := range decoder.Stream() {
  fmt.Printf("%v\n ", mv.Value)
}
```

output:
```
map[desc:RGB colors:[red green blue]]
map[desc:CMYK colors:[cyan magenta yellow black]]
```

likewise, increasing depth level to `3` yields:
```
red
green

  private val uriStrippedCodePoints = StringBuilder()

  /**
   * Configure code points to be escaped for conversion to `java.net.URI`. That class is more
   * strict than the others.
   */
  fun escapeForUri(vararg codePoints: Int) =
    apply {
      uriEscapedCodePoints.append(String(*codePoints))
    }

  /**
   * Configure code points to be stripped in conversion to `java.net.URI`. That class is more