speculators.config

@classmethod
def from_dict(
    cls, config_dict: dict[str, Any], **kwargs
) -> "SpeculatorModelConfig":
    """
    Create a SpeculatorModelConfig from a dictionary, automatically instantiating
    the correct subclass based on the speculators_model_type field.

    :param config_dict: Dictionary containing the configuration
    :param kwargs: Additional keyword arguments that override config values
    :return: A SpeculatorModelConfig instance of the appropriate subclass
    """
    dict_obj = {**config_dict, **kwargs}

    if "speculators_model_type" not in dict_obj:
        raise ValueError(
            "The config dictionary must contain the 'speculators_model_type' field "
            "for loading a SpeculatorModelConfig in the Speculators library."
        )

    return cls.model_validate(dict_obj)

@classmethod
def from_pretrained(
    cls,
    pretrained_model_name_or_path: str | os.PathLike,
    cache_dir: str | os.PathLike | None = None,
    force_download: bool = False,
    local_files_only: bool = False,
    token: str | bool | None = None,
    revision: str = "main",
    **kwargs,
) -> "SpeculatorModelConfig":
    """
    Load a SpeculatorModelConfig from the name/id of a model on the Hugging Face Hub
    or from a local directory. Will automatically instantiate the correct config
    from speculators.models package.

    :param pretrained_model_name_or_path: The name or path to the pretrained model.
    :param cache_dir: The directory to cache the config in.
    :param force_download: Whether to force download the config from the Hub.
    :param local_files_only: Whether to use local files, not download from the Hub.
    :param token: The token to use for authentication with the Hub.
    :param revision: The revision of the config to load from the Hub.
    :param kwargs: Additional keyword arguments to pass to the config.
    :return: A SpeculatorModelConfig object with the loaded parameters.
    """
    # Transformers config loading
    config_dict, kwargs = cls.get_config_dict(
        pretrained_model_name_or_path,
        cache_dir=cache_dir,
        force_download=force_download,
        local_files_only=local_files_only,
        token=token,
        revision=revision,
        **kwargs,
    )

    if "speculators_model_type" not in config_dict:
        # Conversion pathway
        raise NotImplementedError(
            "Loading a non-speculator model config is not supported yet."
        )

    return cls.from_dict(config_dict, **kwargs)

def to_dict(self) -> dict[str, Any]:
    """
    :return: A dictionary representation of the full config, including the
        PretrainedConfig variables and Pydantic model fields.
    """
    pretrained_dict = super().to_dict()
    model_dict = self.model_dump()
    config_dict = {**pretrained_dict, **model_dict}

    # strip all class variables and metadata that are not needed in the output
    for key in (
        "model_config",
        "auto_package",
        "registry_auto_discovery",
        "schema_discriminator",
        "model_type",
        "base_config_key",
        "sub_configs",
        "is_composition",
        "attribute_map",
        "base_model_tp_plan",
        "base_model_pp_plan",
        "base_model_ep_plan",
        "has_no_defaults_at_init",
        "keys_to_ignore_at_inference",
        "_auto_class",
    ):
        config_dict.pop(key, None)

    return config_dict

def to_diff_dict(self) -> dict[str, Any]:
    """
    :return: A dictionary representation of a simplified config,
        including only the PretrainedConfig fields that have been modified
        or set, along with all Pydantic fields.
    """
    return super().to_diff_dict()

@model_validator(mode="after")
def check_default_proposal_method(self) -> "SpeculatorsConfig":
    """Validate default_proposal_method is one of the proposal_methods."""
    available = [method.proposal_type for method in self.proposal_methods]
    if self.default_proposal_method not in available:
        raise ValueError(
            "default_proposal_method "
            f"'{self.default_proposal_method}' must match the proposal_type of "
            f"one of the configured proposal_methods. Available proposal types: "
            f"{available}."
        )
    return self

@classmethod
def from_config(
    cls, config: PretrainedConfig, name_or_path: str | None = "UNSET"
) -> "VerifierConfig":
    """
    Create a VerifierConfig from a PretrainedConfig object.
    Used to extract the required parameters from the original verifier
    config and create a VerifierConfig object.

    :param config: The PretrainedConfig object to extract the parameters from.
    :param name_or_path: The name or path for the verifier model.
        Set to None to not add a specific name_or_path.
        If not provided, the name_or_path from the config will be used.
    :return: A VerifierConfig object with the extracted parameters.
    """
    config_dict = config.to_dict()

    if name_or_path == "UNSET":
        name_or_path = (
            getattr(config, "name_or_path", None)
            or config_dict.get("_name_or_path", None)
            or config_dict.get("name_or_path", None)
        )

    return cls(
        name_or_path=name_or_path,
        architectures=config_dict.get("architectures") or [],
    )