* governing permissions and limitations under the License.
 */
package org.codelibs.core.convert;

import static org.codelibs.core.convert.TimeConversionUtil.toCalendar;
import static org.codelibs.core.convert.TimeConversionUtil.toDate;
import static org.codelibs.core.convert.TimeConversionUtil.toPlainPattern;
import static org.codelibs.core.convert.TimeConversionUtil.toSqlTime;
import static org.hamcrest.CoreMatchers.is;

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.

public class ResourceUtil {
    private static final String FESS_OVERRIDE_CONF_PATH = "FESS_OVERRIDE_CONF_PATH";

    private static final String FESS_APP_TYPE = "FESS_APP_TYPE";

    private static final String FESS_APP_DOCKER = "docker";

    protected ResourceUtil() {
        // nothing
    }

    public static String getFesenHttpUrl() {
        final String url = SystemUtil.getSearchEngineHttpAddress();
        if (url != null) {

COPY --from=build /go/bin/mc /usr/bin/mc
COPY --from=build /go/bin/cur* /usr/bin/

COPY CREDITS /licenses/CREDITS
COPY LICENSE /licenses/LICENSE
COPY dockerscripts/docker-entrypoint.sh /usr/bin/docker-entrypoint.sh

EXPOSE 9000
VOLUME ["/data"]

ENTRYPOINT ["/usr/bin/docker-entrypoint.sh"]

package cgotest

import "testing"

// If gcc is used, and linking internally, __mulsc3 and __muldc3
// will be linked in from libgcc which make several R_PPC64_TOC16_DS
// relocations which may not be resolvable with the internal linker.
func test8694(t *testing.T) { t.Skip("not supported on ppc64/ppc64le with internal linking") }

from typing import Annotated

from fastapi import FastAPI, Header

app = FastAPI()


@app.get("/items/")
async def read_items(
    strange_header: Annotated[str | None, Header(convert_underscores=False)] = None,
):

	return &warmBackendAzure{
		serviceURL:   serviceURL,
		Bucket:       conf.Bucket,
		Prefix:       strings.TrimSuffix(conf.Prefix, slashSeparator),
		StorageClass: conf.StorageClass,
	}, nil
}

// Convert azure errors to minio object layer errors.
func azureToObjectError(err error, params ...string) error {
	if err == nil {
		return nil
	}

	bucket := ""
	object := ""
	if len(params) >= 1 {

	out, err := tpath.AddSpecRoot(yml)
	if err != nil {
		return "", err
	}
	out2, err := util.OverlayYAML(istioOperatorTreeString, out)
	if err != nil {
		return "", err
	}
	return out2, nil
}

// Convert the generated YAML to pretty JSON.
func yamlToPrettyJSON(yml string) (string, error) {
	// YAML objects are not completely compatible with JSON
	// objects. Let yaml.YAMLToJSON handle the edge cases and

    final Supplier<Integer> nonThreadSafe =
        new Supplier<Integer>() {
          int counter = 0;

          @Override
          public Integer get() {
            int nextValue = counter + 1;
            Thread.yield();
            counter = nextValue;
            return counter;
          }
        };

    final int numThreads = 10;
    final int iterations = 1000;

    final Supplier<Integer> nonThreadSafe =
        new Supplier<Integer>() {
          int counter = 0;

          @Override
          public Integer get() {
            int nextValue = counter + 1;
            Thread.yield();
            counter = nextValue;
            return counter;
          }
        };

    final int numThreads = 10;
    final int iterations = 1000;