Use the https://github.com/gradle/gradle-profiler[Gradle Profiler] to find these kinds of bottlenecks.
With the Gradle Profiler, you can define scenarios like "Running 'assemble' after making an ABI-breaking change"
and run your build several times to collect profiling data.
Use the Profiler to produce build scans. Or combine it with method profilers like JProfiler and YourKit.
These profilers can help you find inefficient algorithms in custom plugins.

The main thing you need to run a **FastAPI** application (or any other ASGI application) in a remote server machine is an ASGI server program like **Uvicorn**, this is the one that comes by default in the `fastapi` command.

There are several alternatives, including:

* <a href="https://www.uvicorn.org/" class="external-link" target="_blank">Uvicorn</a>: a high performance ASGI server.

##

# bt-unassigned-maintainers must be the first owner
# All directories that are not explicitly listed below are considered
# unassigned. This means that the ownership may be unknown, lost or
# mixed across several groups.
* @gradle/bt-unassigned-maintainers

# Build infrastructure
.teamcity/                                  @gradle/bt-developer-productivity

The API docs use **Swagger UI** and **ReDoc**, and each of those need some JavaScript and CSS files.

By default, those files are served from a <abbr title="Content Delivery Network: A service, normally composed of several servers, that provides static files, like JavaScript and CSS. It's commonly used to serve those files from the server closer to the client, improving performance.">CDN</abbr>.

[[sec:using_an_init_script]]
== Invoking an init script

There are several ways to invoke an init script (in order of priority):

1. *Specify a file on the command line* with the option `-I` or `--init-script` followed by the path to the script.
+

    * The values of this `dict` are of type `float` (let's say, the price of each item).

#### Union

You can declare that a variable can be any of **several types**, for example, an `int` or a `str`.

In Python 3.6 and above (including Python 3.10) you can use the `Union` type from `typing` and put inside the square brackets the possible types to accept.

There are several command-line options available for the `init` task that control what it will generate. You can use these when Gradle is not running from an interactive console.
You can see available options using the `help` task:

```bash

 * the task dependencies based on this connection.
 * </p>
 *
 * <p>
 * You can create a {@link Property} instance using {@link ObjectFactory#property(Class)}. There are
 * also several specialized subtypes of this interface that can be created using various other factory methods.
 * </p>
 *
 * <p>
 * <b>Note:</b> This interface is not intended for implementation by build script or plugin authors.
 * </p>

CI already built this commit -- why should you re-do that work?

=== Switching branches

During local development, it is not uncommon to switch branches several times per day.
This defeats <<incremental_build.adoc#incremental_build,incremental build>> (i.e., `UP-TO-DATE` checks), but this issue is mitigated via use of the local build cache.

void BuiltinOptionsToAttributes(
    tflite::BuiltinOptionsUnion op_union, mlir::Builder builder,
    // NOLINTNEXTLINE
    llvm::SmallVectorImpl<mlir::NamedAttribute> &attributes);

// While the last several tensors could be optional tensors for an tfl op, the
// number of input operands could vary. This function gets the min/max number of
// operands from tflite op name.
llvm::MinMax OperandNumbersMinMax(llvm::StringRef op_name);