return hex.decodeHex().toResponseBody(mediaType)
    }

    fun exhaust(reader: Reader): String {
      val builder = StringBuilder()
      val buf = CharArray(10)
      var read: Int
      while (reader.read(buf).also { read = it } != -1) {
        builder.appendRange(buf, 0, read)
      }
      return builder.toString()
    }
  }

            }
        }

        entry.markComplete();
    }

    /**
     * Handle directory change notification
     *
     * @param directoryPath directory path
     * @param childName child file name
     * @param changeType type of change
     */
    public void handleDirectoryChange(String directoryPath, String childName, DirectoryChangeNotifier.DirectoryChangeType changeType) {

        assertArgumentNotNull("prefix", prefix);
        assertArgumentNotNull("handler", handler);

        final int startPos = prefix.length();
        ZipEntry entry = null;
        while ((entry = ZipInputStreamUtil.getNextEntry(zipInputStream)) != null) {
            try {
                final String entryName = entry.getName().replace('\\', '/');

        }
    }

    private Field findField(Class<?> clazz, String fieldName) throws NoSuchFieldException {
        Class<?> current = clazz;
        while (current != null) {
            try {
                return current.getDeclaredField(fieldName);
            } catch (NoSuchFieldException e) {
                current = current.getSuperclass();
            }

        assertEquals(ap, req.getApOptions());
        assertNull(req.getTicket());
    }

    @Test
    @DisplayName("seq ctor: IOException while encoding base ticket is wrapped")
    void sequenceConstructor_ticketBaseEncodingIOException_isWrapped() throws Exception {
        // Arrange minimal valid fields
        ASN1EncodableVector v = new ASN1EncodableVector();

And the `dict` you receive as `weights` will actually have `int` keys and `float` values.

///

## Recap { #recap }

With **FastAPI** you have the maximum flexibility provided by Pydantic models, while keeping your code simple, short and elegant.

But with all the benefits:

* Editor support (completion everywhere!)
* Data conversion (a.k.a. parsing / serialization)
* Data validation
* Schema documentation

     *
     * @param outputFile the converted output file
     * @param outExt the output file extension
     * @return the extracted text content
     * @throws ExtractException if an error occurs while reading the file
     */
    protected String getOutputContent(final File outputFile, final String outExt) {
        final Extractor extractor = getExtractor(outExt);
        if (extractor != null) {

    assertLockNotHeld()

    val executableCalls = mutableListOf<AsyncCall>()
    val isRunning: Boolean
    synchronized(this) {
      val i = readyAsyncCalls.iterator()
      while (i.hasNext()) {
        val asyncCall = i.next()

        if (runningAsyncCalls.size >= this.maxRequests) break // Max capacity.

      destIndex = sizeNeeded;
    }
    return new String(dest, 0, destIndex);
  }

  /**
   * Helper method to grow the character buffer as needed, this only happens once in a while so it's
   * ok if it's in a method call. If the index passed in is 0 then no copying will be done.
   */
  private static char[] growBuffer(char[] dest, int index, int size) {

 * </ul>
 *
 * <h4>Warnings</h4>
 *
 * <ul>
 *   <li><b>Warning:</b> as with any collection, it is almost always a bad idea to modify an element
 *       (in a way that affects its {@link Object#equals} behavior) while it is contained in a
 *       collection. Undefined behavior and bugs will result. It's generally best to avoid using
 *       mutable objects as elements at all, as many users may expect your "immutable" object to be