/**
     * Constructs an instance.
     *
     * @param beanDesc
     *            The {@link BeanDesc} of the class that owns this method. Must not be {@literal null}.
     * @param constructor
     *            The constructor. Must not be {@literal null}.
     */
    public ConstructorDescImpl(final BeanDesc beanDesc, final Constructor<?> constructor) {
        assertArgumentNotNull("beanDesc", beanDesc);

        for (final byte b : bytes) {
            appendHex(sb, b);
        }
        return new String(sb);
    }

    /**
     * Converts an {@literal int} value to a hexadecimal string.
     *
     * @param i
     *            the {@literal int} value
     * @return the hexadecimal string
     */
    public static String toHex(final int i) {
        final StringBuilder buf = new StringBuilder();

 * for injection. It can be used to prevent unintended automatic binding of implemented
 * interfaces or extended classes.
 * <p>
 * Example usage:
 * <pre>
 * {@literal @}Typed(ServiceImpl.class)
 * public class ServiceImpl implements Service {
 *     // Implementation
 * }
 * </pre>
 *
 * @since 4.0.0
 */
@Target({FIELD, METHOD, TYPE})
@Retention(RUNTIME)
@Documented

 * useful when the bean creation requires complex logic or when the bean needs to be
 * configured based on runtime conditions.
 * <p>
 * Example usage:
 * <pre>
 * public class Providers {
 *     {@literal @}Provides
 *     {@literal @}Singleton
 *     public static Configuration provideConfiguration() {
 *         return Configuration.load();
 *     }
 * }
 * </pre>
 *
 * @since 4.0.0
 */
@Target(METHOD)

    /**
     * Do not instantiate.
     */
    protected JarInputStreamUtil() {
    }

    /**
     * Creates a {@link JarInputStream}.
     *
     * @param is the input stream (must not be {@literal null})
     * @return {@link JarInputStream}
     * @throws IORuntimeException if an {@link IOException} occurs
     * @see JarInputStream#JarInputStream(InputStream)
     */

 * which implementation should be injected when multiple candidates exist.
 * The value represents a unique identifier for the dependency.
 * <p>
 * Example usage:
 * <pre>
 * {@literal @}Inject
 * {@literal @}Named("mysql")
 * private Repository mysqlRepository;
 * </pre>
 *
 * @see Inject
 * @see Qualifier
 * @since 4.0.0
 */
@Qualifier
@Retention(RUNTIME)
@Documented

        // Reject everything else
        return ObjectInputFilter.Status.REJECTED;
    };

    /**
     * Tests if the object can be serialized.
     *
     * @param obj the object to be serialized (must not be {@literal null})
     * @return the deserialized object
     */
    public static Object serialize(final Object obj) {
        assertArgumentNotNull("obj", obj);

        final byte[] binary = fromObjectToBinary(obj);

    *,
    field: ModelField,
    model_name_map: ModelNameMap,
    field_mapping: dict[
        tuple[ModelField, Literal["validation", "serialization"]], JsonSchemaValue
    ],
    separate_input_output_schemas: bool = True,
) -> dict[str, Any]:
    override_mode: Literal["validation"] | None = (
        None
        if (separate_input_output_schemas or _has_computed_fields(field))
        else "validation"

import re
import warnings
from typing import (
    TYPE_CHECKING,
    Any,
    Literal,
)

import fastapi
from fastapi._compat import (
    ModelField,
    PydanticSchemaGenerationError,
    Undefined,
    annotation_is_pydantic_v1,
)
from fastapi.datastructures import DefaultPlaceholder, DefaultType
from fastapi.exceptions import FastAPIDeprecationWarning, PydanticV1NotSupportedError
from pydantic.fields import FieldInfo

import logging
import re
from typing import Literal

from github import Auth, Github
from pydantic import BaseModel, SecretStr
from pydantic_settings import BaseSettings


class Settings(BaseSettings):
    github_repository: str
    github_token: SecretStr
    deploy_url: str | None = None
    commit_sha: str
    run_id: int
    state: Literal["pending", "success", "error"] = "pending"


class LinkData(BaseModel):