}))
                    .installationToolchainsSource(convert(request.getGlobalToolchainsSource()))
                    .userToolchainsSource(convert(request.getUserToolchainsSource()))
                    .build());

            return new DefaultToolchainsBuildingResult(
                    new PersistedToolchains(result.getEffectiveToolchains()), convert(result.getProblems()));
        } catch (ToolchainsBuilderException e) {

# JSON Compatible Encoder

There are some cases where you might need to convert a data type (like a Pydantic model) to something compatible with JSON (like a `dict`, `list`, etc).

For example, if you need to store it in a database.

For that, **FastAPI** provides a `jsonable_encoder()` function.

## Using the `jsonable_encoder`

Let's imagine that you have a database `fake_db` that only receives JSON compatible data.

    }

    /**
     * Parses a sequence of XML elements and converts them to the appropriate array type.
     *
     * @param parser The XML parser
     * @return Converted array instance
     */
    private Object parseArray(final MXParser parser, final TypeLiteral<?> toType) throws Exception {
        // convert to a collection first then convert that into an array

    if (MINUTES.convert(nanos, NANOSECONDS) > 0) {
      return MINUTES;
    }
    if (SECONDS.convert(nanos, NANOSECONDS) > 0) {
      return SECONDS;
    }
    if (MILLISECONDS.convert(nanos, NANOSECONDS) > 0) {
      return MILLISECONDS;
    }
    if (MICROSECONDS.convert(nanos, NANOSECONDS) > 0) {
      return MICROSECONDS;
    }
    return NANOSECONDS;
  }

  private static String abbreviate(TimeUnit unit) {

            result.addDependency(convert(dependency, stereotypes));
        }

        DependencyManagement mgmt = model.getDependencyManagement();
        if (mgmt != null) {
            for (org.apache.maven.model.Dependency dependency : mgmt.getDependencies()) {
                result.addManagedDependency(convert(dependency, stereotypes));
            }
        }

                }
            };
        } else {
            return null;
        }
    }

    private List<SettingsProblem> convert(List<BuilderProblem> problems) {
        return problems.stream().map(this::convert).toList();
    }

    private SettingsProblem convert(BuilderProblem problem) {
        return new DefaultSettingsProblem(
                problem.getMessage(),

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.

 * specific language governing permissions and limitations
 * under the License.
 */
package org.apache.maven.repository.metadata;

import org.apache.maven.artifact.ArtifactScopeEnum;

/**
 * Helper class to convert a metadata Graph into some form of a classpath
 *
 *
 */
@Deprecated
public interface ClasspathTransformation {
    String ROLE = ClasspathTransformation.class.getName();

    /**

		vid = *resp.VersionID
	}
	return remoteVersionID(vid), nil
}

func (az *warmBackendAzure) Put(ctx context.Context, object string, r io.Reader, length int64) (remoteVersionID, error) {
	return az.PutWithMeta(ctx, object, r, length, map[string]string{})
}

func (az *warmBackendAzure) Get(ctx context.Context, object string, rv remoteVersionID, opts WarmBackendGetOpts) (r io.ReadCloser, err error) {
	if opts.startOffset < 0 {

            final int size = bis.read(buffer);
            if (size != -1) {
                final String content = new String(buffer, 0, size);
                encoding = parseCharset(content);
            }
        } catch (final IOException e) {
            throw new CrawlingAccessException("Could not load a content.", e);
        }

        return normalizeEncoding(encoding);
    }