


'''simple docstring'''



import copy
import os
from typing import Dict, Optional, Union

from ...configuration_utils import PretrainedConfig
from ...utils import add_start_docstrings, logging
from ..auto import AutoConfig


__UpperCAmelCase     :List[str]												=  logging.get_logger(__name__)


__UpperCAmelCase     :Dict												=  {
    "suno/bark-small": "https://huggingface.co/suno/bark-small/resolve/main/config.json",
    "suno/bark": "https://huggingface.co/suno/bark/resolve/main/config.json",
}

__UpperCAmelCase     :Optional[int]												=  "\n    This is the configuration class to store the configuration of a [`{model}`]. It is used to instantiate the model\n    according to the specified arguments, defining the model architecture. Instantiating a configuration with the\n    defaults will yield a similar configuration to that of the Bark [suno/bark](https://huggingface.co/suno/bark)\n    architecture.\n\n    Configuration objects inherit from [`PretrainedConfig`] and can be used to control the model outputs. Read the\n    documentation from [`PretrainedConfig`] for more information.\n\n    Args:\n        block_size (`int`, *optional*, defaults to 1024):\n            The maximum sequence length that this model might ever be used with. Typically set this to something large\n            just in case (e.g., 512 or 1024 or 2048).\n        input_vocab_size (`int`, *optional*, defaults to 10_048):\n            Vocabulary size of a Bark sub-model. Defines the number of different tokens that can be represented by the\n            `inputs_ids` passed when calling [`{model}`]. Defaults to 10_048 but should be carefully thought with\n            regards to the chosen sub-model.\n        output_vocab_size (`int`, *optional*, defaults to 10_048):\n            Output vocabulary size of a Bark sub-model. Defines the number of different tokens that can be represented\n            by the: `output_ids` when passing forward a [`{model}`]. Defaults to 10_048 but should be carefully thought\n            with regards to the chosen sub-model.\n        num_layers (`int`, *optional*, defaults to 12):\n            Number of hidden layers in the given sub-model.\n        num_heads (`int`, *optional*, defaults to 12):\n            Number of attention heads for each attention layer in the Transformer architecture.\n        hidden_size (`int`, *optional*, defaults to 768):\n            Dimensionality of the \"intermediate\" (often named feed-forward) layer in the architecture.\n        dropout (`float`, *optional*, defaults to 0.0):\n            The dropout probability for all fully connected layers in the embeddings, encoder, and pooler.\n        bias (`bool`, *optional*, defaults to `True`):\n            Whether or not to use bias in the linear layers and layer norm layers.\n        initializer_range (`float`, *optional*, defaults to 0.02):\n            The standard deviation of the truncated_normal_initializer for initializing all weight matrices.\n        use_cache (`bool`, *optional*, defaults to `True`):\n            Whether or not the model should return the last key/values attentions (not used by all models).\n"



class       a							(						_a			):


     """simple docstring"""






     SCREAMING_SNAKE_CASE			:					Optional[Any]				  =  "bark_module"
     SCREAMING_SNAKE_CASE			:					Dict				  =  ["past_key_values"]

     SCREAMING_SNAKE_CASE			:					Tuple				  =  {
         "num_attention_heads": "num_heads",
         "num_hidden_layers": "num_layers",
         "vocab_size": "input_vocab_size",
         "window_size": "block_size",
     }

     def __init__(							self	:						Dict				,					snake_case	:						Dict=1024				,					snake_case	:						Union[str, Any]=1_0048				,					snake_case	:						Dict=1_0048				,					snake_case	:						Any=12				,					snake_case	:						List[Any]=12				,					snake_case	:						List[str]=768				,					snake_case	:						List[Any]=0.0				,					snake_case	:						Tuple=True				,					snake_case	:						int=0.02				,					snake_case	:						Union[str, Any]=True				,					**snake_case	:						Dict				,					)		->				Tuple:
          __UpperCAmelCase      :					List[str]    				=     block_size
          __UpperCAmelCase      :					Optional[int]    				=     input_vocab_size
          __UpperCAmelCase      :					Any    				=     output_vocab_size
          __UpperCAmelCase      :					Union[str, Any]    				=     num_layers
          __UpperCAmelCase      :					int    				=     num_heads
          __UpperCAmelCase      :					Any    				=     hidden_size
          __UpperCAmelCase      :					int    				=     dropout
          __UpperCAmelCase      :					Tuple    				=     bias
          __UpperCAmelCase      :					Any    				=     use_cache
          __UpperCAmelCase      :					str    				=     initializer_range

          super().__init__(**snake_case     )






     @classmethod
     def 					lowerCamelCase__					(							cls	:						List[Any]				,					snake_case	:						Union[str, os.PathLike]				,					snake_case	:						Optional[Union[str, os.PathLike]] = None				,					snake_case	:						bool = False				,					snake_case	:						bool = False				,					snake_case	:						Optional[Union[str, bool]] = None				,					snake_case	:						str = "main"				,					**snake_case	:						int				,					)		->				"PretrainedConfig":
          __UpperCAmelCase      :					Optional[int]    				=     cache_dir
          __UpperCAmelCase      :					List[Any]    				=     force_download
          __UpperCAmelCase      :					Optional[int]    				=     local_files_only
          __UpperCAmelCase      :					Optional[int]    				=     revision

          cls._set_token_in_kwargs(snake_case				,					snake_case     )

          __UpperCAmelCase				,  __UpperCAmelCase      :					Optional[int]    				=     cls.get_config_dict(snake_case				,					**snake_case     )

          # get the config dict if we are loading from Bark
          if config_dict.get('''model_type'''     ) == "bark":
               __UpperCAmelCase      :					Optional[Any]    				=     config_dict[f'{cls.model_type}_config']

          if "model_type" in config_dict and hasattr(cls				,					'''model_type'''     ) and config_dict["model_type"] != cls.model_type:
               logger.warning(
                   f'You are using a model of type {config_dict["model_type"]} to instantiate a model of type '
                   f'{cls.model_type}. This is not supported for all configurations of models and can yield errors.'     )

          return cls.from_dict(snake_case				,					**snake_case     )



@add_start_docstrings(
    BARK_SUBMODELCONFIG_START_DOCSTRING.format(config="BarkSemanticConfig"      ,    model="BarkSemanticModel"			)      ,    "\n    Example:\n\n    ```python\n    >>> from transformers import BarkSemanticConfig, BarkSemanticModel\n\n    >>> # Initializing a Bark sub-module style configuration\n    >>> configuration = BarkSemanticConfig()\n\n    >>> # Initializing a model (with random weights) from the suno/bark style configuration\n    >>> model = BarkSemanticModel(configuration)\n\n    >>> # Accessing the model configuration\n    >>> configuration = model.config\n    ```"      ,    )
class       a							(						_a			):


     """simple docstring"""






     SCREAMING_SNAKE_CASE			:					Optional[Any]				  =  "semantic"



@add_start_docstrings(
    BARK_SUBMODELCONFIG_START_DOCSTRING.format(config="BarkCoarseConfig"      ,    model="BarkCoarseModel"			)      ,    "\n    Example:\n\n    ```python\n    >>> from transformers import BarkCoarseConfig, BarkCoarseModel\n\n    >>> # Initializing a Bark sub-module style configuration\n    >>> configuration = BarkCoarseConfig()\n\n    >>> # Initializing a model (with random weights) from the suno/bark style configuration\n    >>> model = BarkCoarseModel(configuration)\n\n    >>> # Accessing the model configuration\n    >>> configuration = model.config\n    ```"      ,    )
class       a							(						_a			):


     """simple docstring"""






     SCREAMING_SNAKE_CASE			:					Tuple				  =  "coarse_acoustics"



@add_start_docstrings(
    BARK_SUBMODELCONFIG_START_DOCSTRING.format(config="BarkFineConfig"      ,    model="BarkFineModel"			)      ,    "\n        n_codes_total (`int`, *optional*, defaults to 8):\n            The total number of audio codebooks predicted. Used in the fine acoustics sub-model.\n        n_codes_given (`int`, *optional*, defaults to 1):\n            The number of audio codebooks predicted in the coarse acoustics sub-model. Used in the acoustics\n            sub-models.\n    Example:\n\n    ```python\n    >>> from transformers import BarkFineConfig, BarkFineModel\n\n    >>> # Initializing a Bark sub-module style configuration\n    >>> configuration = BarkFineConfig()\n\n    >>> # Initializing a model (with random weights) from the suno/bark style configuration\n    >>> model = BarkFineModel(configuration)\n\n    >>> # Accessing the model configuration\n    >>> configuration = model.config\n    ```"      ,    )
class       a							(						_a			):


     """simple docstring"""






     SCREAMING_SNAKE_CASE			:					Any				  =  "fine_acoustics"

     def __init__(							self	:						Dict				,					snake_case	:						Tuple=True				,					snake_case	:						str=8				,					snake_case	:						Optional[Any]=1				,					**snake_case	:						List[Any]     )		->				Optional[Any]:
          __UpperCAmelCase      :					str    				=     n_codes_total
          __UpperCAmelCase      :					str    				=     n_codes_given

          super().__init__(tie_word_embeddings=snake_case				,					**snake_case     )



class       a							(						_a			):


     """simple docstring"""






     SCREAMING_SNAKE_CASE			:					str				  =  "bark"
     SCREAMING_SNAKE_CASE			:					str				  =  True

     def __init__(							self	:						Any				,					snake_case	:						Dict = None				,					snake_case	:						Dict = None				,					snake_case	:						Dict = None				,					snake_case	:						Dict = None				,					snake_case	:						Optional[int]=0.02				,					**snake_case	:						Optional[Any]				,					)		->				Union[str, Any]:
          if semantic_config is None:
               __UpperCAmelCase      :					List[str]    				=     {}
               logger.info('''semantic_config is None. initializing the semantic model with default values.'''     )

          if coarse_acoustics_config is None:
               __UpperCAmelCase      :					List[str]    				=     {}
               logger.info('''coarse_acoustics_config is None. initializing the coarse model with default values.'''     )

          if fine_acoustics_config is None:
               __UpperCAmelCase      :					Union[str, Any]    				=     {}
               logger.info('''fine_acoustics_config is None. initializing the fine model with default values.'''     )

          if codec_config is None:
               __UpperCAmelCase      :					Optional[Any]    				=     {}
               logger.info('''codec_config is None. initializing the codec model with default values.'''     )

          __UpperCAmelCase      :					Tuple    				=     BarkSemanticConfig(**snake_case     )
          __UpperCAmelCase      :					str    				=     BarkCoarseConfig(**snake_case     )
          __UpperCAmelCase      :					Optional[Any]    				=     BarkFineConfig(**snake_case     )
          __UpperCAmelCase      :					List[str]    				=     AutoConfig.for_model(**snake_case     )

          __UpperCAmelCase      :					List[str]    				=     initializer_range

          super().__init__(**snake_case     )

     @classmethod
     def 					lowerCamelCase__					(							cls	:						str				,					snake_case	:						BarkSemanticConfig				,					snake_case	:						BarkCoarseConfig				,					snake_case	:						BarkFineConfig				,					snake_case	:						AutoConfig				,					**snake_case	:						Dict				,					)		->				str:
          return cls(
              semantic_config=semantic_config.to_dict()				,					coarse_acoustics_config=coarse_acoustics_config.to_dict()				,					fine_acoustics_config=fine_acoustics_config.to_dict()				,					codec_config=codec_config.to_dict()				,					**snake_case				,					)






     def 					lowerCamelCase__					(							self	:						Union[str, Any]     )		->				Dict:
          __UpperCAmelCase      :					str    				=     copy.deepcopy(self.__dict__     )

          __UpperCAmelCase      :					Dict    				=     self.semantic_config.to_dict()
          __UpperCAmelCase      :					str    				=     self.coarse_acoustics_config.to_dict()
          __UpperCAmelCase      :					Dict    				=     self.fine_acoustics_config.to_dict()
          __UpperCAmelCase      :					Dict    				=     self.codec_config.to_dict()

          __UpperCAmelCase      :					Any    				=     self.__class__.model_type
          return output



'''simple docstring'''



from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


__UpperCAmelCase     :Union[str, Any]												=  {
    "configuration_mpnet": ["MPNET_PRETRAINED_CONFIG_ARCHIVE_MAP", "MPNetConfig"],
    "tokenization_mpnet": ["MPNetTokenizer"],
}

try:
      if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __UpperCAmelCase     :Optional[int]												=  ["MPNetTokenizerFast"]

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __UpperCAmelCase     :Union[str, Any]												=  [
          "MPNET_PRETRAINED_MODEL_ARCHIVE_LIST",
          "MPNetForMaskedLM",
          "MPNetForMultipleChoice",
          "MPNetForQuestionAnswering",
          "MPNetForSequenceClassification",
          "MPNetForTokenClassification",
          "MPNetLayer",
          "MPNetModel",
          "MPNetPreTrainedModel",
      ]

try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      __UpperCAmelCase     :Any												=  [
          "TF_MPNET_PRETRAINED_MODEL_ARCHIVE_LIST",
          "TFMPNetEmbeddings",
          "TFMPNetForMaskedLM",
          "TFMPNetForMultipleChoice",
          "TFMPNetForQuestionAnswering",
          "TFMPNetForSequenceClassification",
          "TFMPNetForTokenClassification",
          "TFMPNetMainLayer",
          "TFMPNetModel",
          "TFMPNetPreTrainedModel",
      ]


if TYPE_CHECKING:
      from .configuration_mpnet import MPNET_PRETRAINED_CONFIG_ARCHIVE_MAP, MPNetConfig
      from .tokenization_mpnet import MPNetTokenizer

      try:
            if not is_tokenizers_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .tokenization_mpnet_fast import MPNetTokenizerFast

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_mpnet import (
                MPNET_PRETRAINED_MODEL_ARCHIVE_LIST,
                MPNetForMaskedLM,
                MPNetForMultipleChoice,
                MPNetForQuestionAnswering,
                MPNetForSequenceClassification,
                MPNetForTokenClassification,
                MPNetLayer,
                MPNetModel,
                MPNetPreTrainedModel,
            )

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_mpnet import (
                TF_MPNET_PRETRAINED_MODEL_ARCHIVE_LIST,
                TFMPNetEmbeddings,
                TFMPNetForMaskedLM,
                TFMPNetForMultipleChoice,
                TFMPNetForQuestionAnswering,
                TFMPNetForSequenceClassification,
                TFMPNetForTokenClassification,
                TFMPNetMainLayer,
                TFMPNetModel,
                TFMPNetPreTrainedModel,
            )

else:
      import sys

      __UpperCAmelCase     :Optional[Any]												=  _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)