@CanIgnoreReturnValue
  public CharEscaperBuilder addEscapes(char[] cs, String r) {
    checkNotNull(r);
    for (char c : cs) {
      addEscape(c, r);
    }
    return this;
  }

  /**
   * Convert this builder into an array of char[]s where the maximum index is the value of the
   * highest character that has been seen. The array will be sparse in the sense that any unseen
   * index will default to null.
   *

So, even with the code above that doesn't use Pydantic explicitly, FastAPI is using Pydantic to convert those standard dataclasses to Pydantic's own flavor of dataclasses.

And of course, it supports the same:

* data validation
* data serialization
* data documentation, etc.

    except subprocess.CalledProcessError as e:
      output = e.output
  else:
    output = subprocess.check_output(cmd, stderr=stderr)
  return output.decode('UTF-8').strip()


def cygpath(path):
  """Convert path from posix to windows."""
  return os.path.abspath(path).replace('\\', '/')


def get_python_path(environ_cp, python_bin_path):
  """Get the python site package paths."""
  python_paths = []

BeanUtil.copyBeanToBean(source, destination, options -> 
    options.exclude("password", "internalId"));

// Convert between beans and maps
Map<String, Object> map = BeanUtil.copyBeanToNewMap(bean);
MyBean newBean = BeanUtil.copyMapToNewBean(map, MyBean.class);
```

### Type Conversion
```java
import org.codelibs.core.convert.*;

// Safe type conversions with null handling

                    if (readingTokens == null) {
                        l = readingConverter.convert(word, field, lang);
                    } else {
                        final String reading = readingTokens.get(i).getTerm();
                        l = contentsReadingConverter.convert(reading, field, lang);
                    }
                    l.add(word);

            """
        ),
    ] = True,
) -> Any:
    """
    Convert any object to something that can be encoded in JSON.

    This is used internally by FastAPI to make sure anything you return can be
    encoded as JSON before it is sent to the client.

    You can also use it yourself, for example to convert objects before saving them
    in a database that supports only JSON.

                        "tax": 3.2,
                    },
                },
                "converted": {
                    "summary": "An example with converted data",
                    "description": "FastAPI can convert price `strings` to actual `numbers` automatically",
                    "value": {
                        "name": "Bar",
                        "price": "35.4",
                    },
                },

        }
    }

    /**
     * Convert RDMA access flags to DiSNI flags
     *
     * @param access RDMA access flags
     * @return DiSNI access flags
     */
    @SuppressWarnings("unused")
    private int convertAccessFlags(EnumSet<RdmaAccess> access) {
        int flags = 0;

        // In real implementation, this would convert to DiSNI constants:

        responseSequenceNumber = buf.dec_ndr_hyper();

        // Heartbeat interval (64-bit, in 100-nanosecond intervals)
        // Convert from FILETIME intervals to milliseconds
        long filetimeInterval = buf.dec_ndr_hyper();
        heartbeatInterval = filetimeInterval / 10000; // Convert to milliseconds
    }

            if (!Modifier.isStatic(field.getModifiers())) {
                fieldMap.put(field.getName(), field);
            }
        }

        return fieldMap;
    }

    /**
     * Convert property value for method parameter.
     */
    private Object convertPropertyForMethod(
            Class<?> beanType, MethodInfo methodInfo, Class<?> valueType, PlexusConfiguration configuration)