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);

        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

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());

```Python
results = await some_library()
```
Alors, déclarez vos *fonctions de chemins* avec `async def` comme ceci :

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

/// note

Vous pouvez uniquement utiliser `await` dans les fonctions créées avec `async def`.

///

---

    }

    public void test_execute_verifyComponentUtilCalls() {
        // Execute the job
        purgeDocJob.execute();

        // Verify that ComponentUtil was used to get components
        assertTrue(deleteByQueryCalled);
        assertEquals(documentUpdateIndex, deleteIndex);
        assertNotNull(deleteQuery);
    }

    public void test_execute_withLongExceptionMessage() {

      buffer.order(ByteOrder.LITTLE_ENDIAN);
      while (buffer.remaining() >= 4) {
        putInt(buffer.getInt());
      }
      while (buffer.hasRemaining()) {
        putByte(buffer.get());
      }
      buffer.order(bo);
      return this;
    }

    @CanIgnoreReturnValue
    @Override
    public Hasher putInt(int i) {
      update(4, i);
      return this;
    }

// Object was stored with additional erasure codes due to degraded system at upload time
const minIOErasureUpgraded = "x-minio-internal-erasure-upgraded"

const erasureAlgorithm = "rs-vandermonde"

// GetChecksumInfo - get checksum of a part.
func (e ErasureInfo) GetChecksumInfo(partNumber int) (ckSum ChecksumInfo) {
	for _, sum := range e.Checksums {
		if sum.PartNumber == partNumber {
			// Return the checksum
			return sum
		}
	}

					remotes: tgts,
				}
			}
		}
	}

	// Check if bucket is object locked.
	lr, err := globalBucketObjectLockSys.Get(cache.Info.Name)
	if err != nil {
		scannerLogOnceIf(ctx, err, cache.Info.Name)
		return cache, err
	}

	vcfg, _ := globalBucketVersioningSys.Get(cache.Info.Name)

	// return initialized object layer
	objAPI := newObjectLayerFn()
	// object layer not initialized, return.

    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()) {