assertNotNull(hash);

        // Modify returned hash
        if (hash.length > 0) {
            hash[0] = (byte) 0xFF;
        }

        // Get hash again - should be unmodified
        byte[] hash2 = transport.getPreauthIntegrityHash();
        assertNotNull(hash2);

        // If original has data, verify it wasn't modified

      throw ProtocolException(
        if (isClient) {
          "Server-sent frames must not be masked."
        } else {
          "Client-sent frames must be masked."
        },
      )
    }

    // Get frame length, optionally reading from follow-up bytes if indicated by special values.
    frameLength = (b1 and B1_MASK_LENGTH).toLong()
    if (frameLength == PAYLOAD_SHORT.toLong()) {

      this.map = map;
      this.setUpRan = setUpRan;
    }

    @Override
    public Object invoke(Object target, Method method, Object[] args) throws Throwable {
      assertTrue("setUp should have run", setUpRan.get());
      try {
        return method.invoke(map, args);
      } catch (InvocationTargetException e) {
        throw e.getCause();
      } catch (IllegalAccessException e) {
        throw newLinkageError(e);

```JSON hl_lines="22"
{
    "openapi": "3.1.0",
    "info": {
        "title": "FastAPI",
        "version": "0.1.0"
    },
    "paths": {
        "/items/": {
            "get": {
                "summary": "Read Items",
                "operationId": "read_items_items__get",
                "responses": {
                    "200": {
                        "description": "Successful Response",

That including `uvloop`, the high-performance drop-in replacement for `asyncio`, that provides the big concurrency performance boost.

When you install FastAPI with something like `pip install "fastapi[standard]"` you already get `uvicorn[standard]` as well.

///

## Run the Server Program { #run-the-server-program }

                throw new IOException(localFile + " does not exist and no remote repositories are configured");
            }

            ArtifactRepository remoteRepo = request.getRemoteRepositories().get(0);

            File remoteFile = new File(remoteRepo.getBasedir(), remoteRepo.pathOf(artifact));

            Files.createDirectories(localFile.toPath().getParent());

		return err
	}

	// Do not send if the connection is not active.
	_, err := target.isActive()
	if err != nil {
		return err
	}

	eventData, err := target.store.Get(key)
	if err != nil {
		// The last event key in a successful batch will be sent in the channel atmost once by the replayEvents()
		// Such events will not exist and wouldve been already been sent successfully.

```Python
results = await some_library()
```

Dann deklarieren Sie Ihre *Pfadoperation-Funktionen* mit `async def`, wie in:

```Python hl_lines="2"
@app.get('/')
async def read_results():
    results = await some_library()
    return results
```

/// note | Hinweis

Sie können `await` nur innerhalb von Funktionen verwenden, die mit `async def` erstellt wurden.

    public static synchronized Logger getLogger(final Class<?> clazz) {
        assertArgumentNotNull("clazz", clazz);

        if (!initialized) {
            initialize();
        }
        Logger logger = loggers.get(clazz);
        if (logger == null) {
            logger = new Logger(clazz);
            loggers.put(clazz, logger);
        }
        return logger;
    }

    /**
     * Returns a formatted message string.

    public String getType() {
        return KUROMOJI;
    }

    @Override
    public String getPath() {
        return path;
    }

    @Override
    public synchronized OptionalEntity<KuromojiItem> get(final long id) {
        if (kuromojiItemList == null) {
            reload(null);
        }

        for (final KuromojiItem kuromojiItem : kuromojiItemList) {
            if (id == kuromojiItem.getId()) {