#                🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
#           This file was automatically generated from src/transformers/models/dots3_note/modular_dots3_note.py.
#               Do NOT edit this file manually as any edits will be overwritten by the generation of
#             the file from the modular. If any change should be done, please apply the change to the
#                          modular_dots3_note.py file directly. One of our CI enforces this.
#                🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨🚨
# Copyright 2026 The Dots Studio team and the HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from huggingface_hub.dataclasses import strict

from ...configuration_utils import PreTrainedConfig
from ...utils import auto_docstring


@auto_docstring(checkpoint="dots-studio/dots3-note-prev")
@strict
class Dots3NoteVisionConfig(PreTrainedConfig):
    r"""
    mlp_layer_types (`list[str]`, *optional*):
        Dense or sparse MLP for each layer. Expert counts are specified through `per_layer_config`.
    router_scaling_factor (`float`, *optional*, defaults to 1.0):
        Scale applied to the vision router scores.
    adapter_in_dim (`int`, *optional*, defaults to 1536):
        Input width of the vision adapter. It must match `hidden_size`.
    adapter_out_dim (`int`, *optional*, defaults to 5120):
        Output width of the vision adapter. It must match the text hidden size.
    adapter_merge_size (`int`, *optional*, defaults to 2):
        Spatial merge factor used by the vision adapter.
    """

    model_type = "dots3_note_vision_encoder"
    base_config_key = "vision_config"

    hidden_size: int = 1536
    intermediate_size: int = 4224
    num_hidden_layers: int = 42
    num_attention_heads: int = 24
    num_channels: int = 3
    patch_size: int = 14
    hidden_act: str = "silu"
    attention_dropout: float | int = 0.0
    default_rope_type = "axial"
    initializer_range: float = 0.02
    rope_parameters: dict | None = None
    base_model_tp_plan = {
        "blocks.*.mlp.experts.gate_up_proj": "packed_colwise",
        "blocks.*.mlp.experts.down_proj": "rowwise",
        "blocks.*.mlp.experts": "moe_tp_experts",
    }
    base_model_ep_plan = {
        "blocks.*.mlp.experts.gate_up_proj": "grouped_gemm",
        "blocks.*.mlp.experts.down_proj": "grouped_gemm",
        "blocks.*.mlp.experts": "ep_dispatch_experts",
    }
    moe_intermediate_size: int = 2112
    spatial_merge_size: int = 2
    rms_norm_eps: float = 1e-5
    attention_bias: bool = False
    mlp_bias: bool = False
    mlp_layer_types: list[str] | None = None
    num_local_experts: int = 64
    num_experts_per_tok: int | None = None
    router_scaling_factor: float | None = None
    adapter_in_dim: int = 1536
    adapter_out_dim: int = 5120
    adapter_merge_size: int = 2

    def __post_init__(self, **kwargs):
        pyramid_num_routed = kwargs.pop("pyramid_num_routed", None)
        if pyramid_num_routed is None and self.mlp_layer_types is None:
            pyramid_num_routed = [-1] * 25 + list(range(4, 65, 4)) + [64]
        if self.num_experts_per_tok is None:
            self.num_experts_per_tok = kwargs.get("capacity_factor", 2)
        if self.router_scaling_factor is None:
            self.router_scaling_factor = kwargs.get("router_scale", 1.0)
        if pyramid_num_routed is not None:
            self.mlp_layer_types = ["sparse" if count > 0 else "dense" for count in pyramid_num_routed]
            kwargs.setdefault(
                "per_layer_config",
                {
                    i: {"num_local_experts": count, "num_experts_per_tok": min(self.num_experts_per_tok, count)}
                    for i, count in enumerate(pyramid_num_routed)
                    if count > 0
                },
            )
        self.hidden_size = kwargs.pop("embed_dim", self.hidden_size)
        self.num_attention_heads = kwargs.pop("num_heads", self.num_attention_heads)
        self.attention_bias = kwargs.pop("use_bias", self.attention_bias)
        kwargs.pop("is_causal", None)
        super().__post_init__(**kwargs)

    def validate_architecture(self):
        if self.hidden_size % self.num_attention_heads != 0:
            raise ValueError("hidden_size must be divisible by num_attention_heads")
        if self.adapter_in_dim != self.hidden_size:
            raise ValueError("adapter_in_dim must match hidden_size")
        if self.mlp_bias and "sparse" in self.mlp_layer_types:
            raise ValueError("Dots3 vision stacked experts require mlp_bias=False")
        if self.adapter_merge_size != self.spatial_merge_size:
            raise ValueError("adapter_merge_size must match spatial_merge_size")


@auto_docstring(checkpoint="dots-studio/dots3-note-prev")
@strict
class Dots3NoteAudioConfig(PreTrainedConfig):
    r"""
    feature_size (`int`, *optional*, defaults to 128):
        Number of log-mel filter-bank channels.
    hop_length (`int`, *optional*, defaults to 160):
        Number of waveform samples between adjacent log-mel frames.
    downsample_hidden_size (`int`, *optional*, defaults to 480):
        Hidden width of the temporal downsampling projection.
    adapter_input_size (`int`, *optional*, defaults to 1280):
        Input width of the audio-to-text adapter.
    adapter_out_dim (`int`, *optional*, defaults to 5120):
        Output width of the audio-to-text adapter. It must match the text hidden size.
    """

    model_type = "dots3_note_audio_encoder"

    hidden_size: int = 1280
    intermediate_size: int = 5120
    num_hidden_layers: int = 32
    num_attention_heads: int = 20
    num_key_value_heads: int | None = None
    hidden_act: str = "silu"

    max_position_embeddings: int = 6000
    initializer_range: float = 0.02
    rope_parameters: dict | None = None
    attention_dropout: float | int = 0.0
    base_config_key = "audio_config"
    dropout: float = 0.0
    sampling_rate: int = 16_000
    feature_size: int = 128
    hop_length: int = 160
    downsample_hidden_size: int = 480
    head_dim: int | None = None
    attention_bias: bool = True
    adapter_input_size: int = 1280
    adapter_out_dim: int = 5120

    def __post_init__(self, **kwargs):
        self.adapter_input_size = kwargs.pop("whisper_adapter_in_dim", self.adapter_input_size)
        self.adapter_out_dim = kwargs.pop(
            "whisper_adapter_out_dim", kwargs.pop("adapter_output_size", self.adapter_out_dim)
        )
        # Released checkpoints store encoder dimensions in a Whisper-style dictionary.
        whisper_config = kwargs.pop("whisper_config", None) or {}
        for legacy_name, name in {
            "d_model": "hidden_size",
            "encoder_attention_heads": "num_attention_heads",
            "encoder_layers": "num_hidden_layers",
            "encoder_ffn_dim": "intermediate_size",
            "num_mel_bins": "feature_size",
            "max_source_positions": "max_position_embeddings",
        }.items():
            if legacy_name in whisper_config:
                setattr(self, name, whisper_config[legacy_name])
        self.dropout = whisper_config.get("dropout", self.dropout)
        self.attention_dropout = whisper_config.get("attention_dropout", self.attention_dropout)
        self.head_dim = self.hidden_size // self.num_attention_heads
        self.num_key_value_heads = self.num_attention_heads
        self.conv_output_size = self.downsample_hidden_size * ((self.feature_size + 7) // 8)
        self.samples_per_token = self.hop_length * 8
        kwargs.setdefault("partial_rotary_factor", 0.5)
        super().__post_init__(**kwargs)

    def validate_architecture(self):
        if self.hidden_size % self.num_attention_heads:
            raise ValueError("audio hidden_size must be divisible by num_attention_heads")
        if self.adapter_input_size != self.hidden_size:
            raise ValueError("adapter_input_size must match hidden_size")
        if min(self.sampling_rate, self.feature_size, self.hop_length) <= 0:
            raise ValueError("audio sampling and feature dimensions must be positive")


@auto_docstring(checkpoint="dots-studio/dots3-note-prev")
@strict
class Dots3NoteTextConfig(PreTrainedConfig):
    r"""
    n_group (`int`, *optional*, defaults to 1):
        Number of groups into which routed experts are partitioned during selection.
    mlp_layer_types (`list[str]`, *optional*):
        Per-layer `"dense"` or `"sparse"` MLP types, derived from the released MoE schedule when omitted.
    index_topk (`int`, *optional*, defaults to 2048):
        Number of key positions selected by dynamic sparse attention.
    index_head_dim (`int`, *optional*, defaults to 128):
        Per-head width of the dynamic sparse attention indexer.
    index_n_heads (`int`, *optional*, defaults to 64):
        Number of heads in the dynamic sparse attention indexer.
    shared_experts_intermediate_size (`int`, *optional*, defaults to 1536):
        Intermediate width of each shared expert.
    """

    model_type = "dots3_note_text"
    keys_to_ignore_at_inference = ["past_key_values"]
    base_model_tp_plan = {
        "layers.*.self_attn.q_b_proj": "colwise",
        "layers.*.self_attn.k_rope_only_layernorm": "replicated_with_grad_allreduce",
        "layers.*.self_attn.kv_a_proj_with_mqa": "mla_kv_a_proj",
        "layers.*.self_attn.kv_b_proj": "colwise",
        "layers.*.self_attn.g_proj": "colwise",
        "layers.*.self_attn.o_proj": "rowwise",
        "layers.*.mlp.experts.gate_up_proj": "packed_colwise",
        "layers.*.mlp.experts.down_proj": "rowwise",
        "layers.*.mlp.experts": "moe_tp_experts",
        "layers.*.mlp.shared_experts.gate_proj": "colwise",
        "layers.*.mlp.shared_experts.up_proj": "colwise",
        "layers.*.mlp.shared_experts.down_proj": "rowwise",
        "layers.*.mlp.gate_proj": "colwise",
        "layers.*.mlp.up_proj": "colwise",
        "layers.*.mlp.down_proj": "rowwise",
    }
    base_model_pp_plan = {
        "embed_tokens": (["input_ids"], ["inputs_embeds"]),
        "layers": (["hidden_states", "attention_mask"], ["hidden_states"]),
        "norm": (["hidden_states"], ["hidden_states"]),
    }
    base_model_ep_plan = {
        "layers.*.mlp.experts.gate_up_proj": "grouped_gemm",
        "layers.*.mlp.experts.down_proj": "grouped_gemm",
        "layers.*.mlp.experts": "ep_dispatch_experts",
    }

    attribute_map = {"num_local_experts": "n_routed_experts"}

    vocab_size: int = 152064
    hidden_size: int = 5120
    intermediate_size: int = 13824

    moe_intermediate_size: int = 1536
    num_hidden_layers: int = 46
    num_attention_heads: int = 128
    num_key_value_heads: int = 128
    n_shared_experts: int = 1
    n_routed_experts: int = 256
    output_router_logits: bool = False
    routed_scaling_factor: float = 1.0
    kv_lora_rank: int = 512

    q_lora_rank: int | None = 1024
    qk_rope_head_dim: int = 64
    v_head_dim: int = 128
    qk_nope_head_dim: int = 128
    n_group: int = 1
    topk_group: int = 1
    num_experts_per_tok: int = 8
    norm_topk_prob: bool = True
    hidden_act: str = "silu"
    max_position_embeddings: int = 524288
    initializer_range: float = 0.02
    rms_norm_eps: float = 1e-5
    use_cache: bool = True
    pad_token_id: int | None = 151659
    bos_token_id: int | None = 151643
    eos_token_id: int | list[int] | None = 151668
    tie_word_embeddings: bool = False
    rope_parameters: dict | None = None
    mlp_layer_types: list[str] | None = None
    attention_bias: bool = False
    attention_dropout: float | int = 0.0
    index_topk: int = 2048
    index_head_dim: int = 128
    index_n_heads: int = 64
    mlp_bias: bool = False
    head_dim: int = 256
    layer_types: list[str] | None = None
    default_theta = 80_000_000.0
    base_config_key = "text_config"

    sliding_window: int | None = None
    shared_experts_intermediate_size: int = 1536

    def __post_init__(self, **kwargs):
        first_k_dense_replace = kwargs.pop("first_k_dense_replace", 1)
        moe_layer_freq = kwargs.pop("moe_layer_freq", 1)
        # Legacy checkpoints call DSA layers "full_attention"; canonical configs also store per_layer_config.
        use_dsa = kwargs.pop("use_dsa", None if "per_layer_config" in kwargs else True)
        use_sliding_window = kwargs.pop("use_sliding_window", True)
        if self.mlp_layer_types is None:
            self.mlp_layer_types = [
                "sparse"
                if i >= first_k_dense_replace
                and (bool(moe_layer_freq[i]) if isinstance(moe_layer_freq, (list, tuple)) else i % moe_layer_freq == 0)
                else "dense"
                for i in range(self.num_hidden_layers)
            ]
        self.shared_experts_intermediate_size = kwargs.pop(
            "moe_shared_expert_intermediate_size", self.shared_experts_intermediate_size
        )
        if self.num_key_value_heads is None:
            self.num_key_value_heads = self.num_attention_heads
        if self.sliding_window is None:
            self.sliding_window = kwargs.pop("sliding_window_size", 512)

        if self.layer_types is None:
            full_attention_type = "full_attention" if use_dsa is False else "indexed_attention"
            self.layer_types = [
                full_attention_type if not use_sliding_window or i < 2 or i % 4 == 1 else "sliding_attention"
                for i in range(self.num_hidden_layers)
            ]
        else:
            self.layer_types = list(self.layer_types)
        if use_dsa is not None:
            old_type, new_type = ("full_attention", "indexed_attention")
            if not use_dsa:
                old_type, new_type = new_type, old_type
            self.layer_types = [new_type if layer_type == old_type else layer_type for layer_type in self.layer_types]
        # Normalize the released checkpoint's SWA aliases into the shared per-layer configuration.
        sliding_config = {
            name: kwargs.pop(f"swa_{name}", default)
            for name, default in {
                "num_attention_heads": 64,
                "num_key_value_heads": 64,
                "q_lora_rank": 1024,
                "kv_lora_rank": 1024,
                "head_dim": 256,
                "qk_nope_head_dim": 192,
                "v_head_dim": 128,
            }.items()
        }
        sliding_config["qk_rope_head_dim"] = kwargs.pop(
            "swa_qk_rope_head_dim", sliding_config["head_dim"] - sliding_config["qk_nope_head_dim"]
        )
        kwargs.setdefault(
            "per_layer_config",
            {i: sliding_config for i, layer_type in enumerate(self.layer_types) if layer_type == "sliding_attention"},
        )
        super().__post_init__(**kwargs)

    def convert_rope_params_to_dict(self, **kwargs):
        """Convert legacy RoPE settings to separate DSA/SWA entries, using each layer type's rotary head fraction."""
        swa_rope_theta = kwargs.pop("swa_rope_theta", 50_000.0)
        rope_theta = kwargs.get("rope_theta", self.default_theta)
        if self.rope_parameters is None:
            self.rope_parameters = kwargs.pop("rope_scaling", None) or {
                layer_type: {
                    "rope_type": "default",
                    "rope_theta": swa_rope_theta if layer_type == "sliding_attention" else rope_theta,
                }
                for layer_type in set(self.layer_types)
            }
        if not self.nested_rope_parameter_keys(self.rope_parameters):
            self.rope_parameters = {layer_type: dict(self.rope_parameters) for layer_type in set(self.layer_types)}
        kwargs = super().convert_rope_params_to_dict(**kwargs)
        per_layer_config = {int(i): values for i, values in (kwargs.get("per_layer_config") or {}).items()}
        for layer_type in set(self.layer_types):
            layer_config = per_layer_config.get(self.layer_types.index(layer_type), {})
            self.rope_parameters[layer_type]["partial_rotary_factor"] = layer_config.get(
                "qk_rope_head_dim", self.qk_rope_head_dim
            ) / layer_config.get("head_dim", self.head_dim)
        return kwargs

    def validate_architecture(self):
        if any(self.per_layer_config[layer_type].q_lora_rank is None for layer_type in set(self.layer_types)):
            raise ValueError("Dots 3 Note Preview requires q_lora_rank for MLA queries")
        if self.n_shared_experts is None or self.n_shared_experts < 1:
            raise ValueError("Dots 3 Note Preview requires at least one shared expert")
        if self.n_group < 1 or self.n_routed_experts % self.n_group != 0:
            raise ValueError("n_group must evenly divide n_routed_experts")
        if self.n_routed_experts // self.n_group < 2:
            raise ValueError("Grouped routing requires at least two experts per group")
        if not 1 <= self.topk_group <= self.n_group:
            raise ValueError("topk_group must be in [1, n_group]")
        for layer_type in set(self.layer_types):
            config = self.per_layer_config[layer_type]
            if config.num_key_value_heads != config.num_attention_heads:
                raise ValueError("num_key_value_heads must match num_attention_heads")
            if layer_type == "indexed_attention" and config.qk_rope_head_dim > self.index_head_dim:
                raise ValueError("qk_rope_head_dim must not exceed index_head_dim")
        if "sliding_attention" in self.layer_types:
            config = self.per_layer_config["sliding_attention"]
            if config.head_dim != config.qk_nope_head_dim + config.qk_rope_head_dim:
                raise ValueError("SWA head_dim must equal qk_nope_head_dim + qk_rope_head_dim")


@auto_docstring(checkpoint="dots-studio/dots3-note-prev")
@strict
class Dots3NoteConfig(PreTrainedConfig):
    model_type = "dots3_note"
    sub_configs_defaults = {
        "text_config": Dots3NoteTextConfig,
        "vision_config": Dots3NoteVisionConfig,
        "audio_config": Dots3NoteAudioConfig,
    }
    keys_to_ignore_at_inference = ["past_key_values"]

    text_config: dict | Dots3NoteTextConfig | None = None
    vision_config: dict | Dots3NoteVisionConfig | None = None
    audio_config: dict | Dots3NoteAudioConfig | None = None
    image_token_id: int = 151660
    video_token_id: int = 151680
    audio_token_id: int = 151720
    tie_word_embeddings: bool = False

    def __post_init__(self, **kwargs):
        # Published checkpoints store the text configuration at the top level.
        if self.text_config is None:
            kwargs.pop("model_type", None)
            self.text_config = Dots3NoteTextConfig(**kwargs, tie_word_embeddings=self.tie_word_embeddings)
        super().__post_init__(**kwargs)

    def validate_architecture(self):
        if self.vision_config.adapter_out_dim != self.text_config.hidden_size:
            raise ValueError("vision adapter output width must match the text hidden size")
        if self.audio_config.adapter_out_dim != self.text_config.hidden_size:
            raise ValueError("audio adapter output width must match the text hidden size")


__all__ = ["Dots3NoteAudioConfig", "Dots3NoteConfig", "Dots3NoteTextConfig", "Dots3NoteVisionConfig"]
