So:

```Python
q: str | None = Query(default=None)
```

...makes the parameter optional, with a default value of `None`, the same as:


```Python
q: str | None = None
```

public interface ExecutionEvent {

    /**
     * The possible types of execution events.
     *
     * Note: do not modify this enum, or, make sure that this enum and
     * {@link org.apache.maven.api.EventType} have same elements in same order.
     */
    enum Type {
        ProjectDiscoveryStarted,
        SessionStarted,
        SessionEnded,
        ProjectSkipped,
        ProjectStarted,
        ProjectSucceeded,

object file can then be combined with other objects into a package archive.

# Command Line

Usage:

	go tool asm [flags] file

The specified file must be a Go assembly file.
The same assembler is used for all target operating systems and architectures.
The GOOS and GOARCH environment variables set the desired target.

Flags:

	-D name[=value]
		Predefine symbol name with an optional simple value.

Import `BaseSettings` from Pydantic and create a sub-class, very much like with a Pydantic model.

The same way as with Pydantic models, you declare class attributes with type annotations, and possibly default values.

You can use all the same validation features and tools you use for Pydantic models, like different data types and additional validations with `Field()`.

And then in our code, we parse that YAML content directly, and then we are again using the same Pydantic model to validate the YAML content:

{* ../../docs_src/path_operation_advanced_configuration/tutorial007_py39.py hl[24:31] *}

/// tip

Here we reuse the same Pydantic model.

But the same way, we could have validated it in some other way.

 * need for a distinct {@code ImmutableBiMultimap} type.
 *
 * <p><a id="iteration"></a>
 *
 * <p><b>Key-grouped iteration.</b> All view collections follow the same iteration order. In all
 * current implementations, the iteration order always keeps multiple entries with the same key
 * together. Any creation method that would customarily respect insertion order (such as {@link

        CacheBuilder.newBuilder()
            .expireAfterAccess(500000, MILLISECONDS)
            .maximumSize(count)
            .build();
  }

  public void testComputeIfAbsent() {
    // simultaneous insertion for same key, expect 1 winner
    doParallelCacheOp(
        count,
        n -> {
          cache.asMap().computeIfAbsent(key, k -> "value" + n);
        });
    assertThat(cache.size()).isEqualTo(1);
  }

     * @return the share we are connected to
     */
    String getConnectedShare();

    /**
     * Checks if this tree handle refers to the same tree as another
     * @param th the tree handle to compare with
     * @return whether the handles refer to the same tree
     */
    boolean isSameTree(SmbTreeHandle th);

    /**
     * Checks if this tree handle uses SMB2 or later protocol

///

/// note | Technical Details

You could also use `from starlette.responses import JSONResponse`.

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

///

## OpenAPI and API docs { #openapi-and-api-docs }

/**
 * A subscriber method on a specific object, plus the executor that should be used for dispatching
 * events to it.
 *
 * <p>Two subscribers are equivalent when they refer to the same method on the same object (not
 * class). This property is used to ensure that no subscriber method is registered more than once.
 *
 * @author Colin Decker
 */
class Subscriber {