


"""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


SCREAMING_SNAKE_CASE__				:  Optional[int]						= logging.get_logger(__name__)


SCREAMING_SNAKE_CASE__				:  List[str]						= {
    "suno/bark-small": "https://huggingface.co/suno/bark-small/resolve/main/config.json",
    "suno/bark": "https://huggingface.co/suno/bark/resolve/main/config.json",
}

SCREAMING_SNAKE_CASE__				:  str						= "\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_       (     lowerCAmelCase__   ):





  """simple docstring"""

  lowercase		:	Optional[int]   =						"bark_module"
  lowercase		:	Tuple   =						["past_key_values"]

  lowercase		:	Dict   =						{
      "num_attention_heads": "num_heads",
      "num_hidden_layers": "num_layers",
      "vocab_size": "input_vocab_size",
      "window_size": "block_size",
  }
  def __init__(						self  ,					__UpperCAmelCase=10_24  ,					__UpperCAmelCase=1_00_48  ,					__UpperCAmelCase=1_00_48  ,					__UpperCAmelCase=12  ,					__UpperCAmelCase=12  ,					__UpperCAmelCase=7_68  ,					__UpperCAmelCase=0.0  ,					__UpperCAmelCase=True  ,					__UpperCAmelCase=0.02  ,					__UpperCAmelCase=True  ,					**__UpperCAmelCase  ,					)				->					Union[str, Any]:
     a   :	Optional[int]						=    block_size
     a   :	Optional[Any]						=    input_vocab_size
     a   :	Union[str, Any]						=    output_vocab_size
     a   :	List[str]						=    num_layers
     a   :	Optional[Any]						=    num_heads
     a   :	Tuple						=    hidden_size
     a   :	List[str]						=    dropout
     a   :	str						=    bias
     a   :	str						=    use_cache
     a   :	Optional[Any]						=    initializer_range

     super().__init__(**snake_case__						)






  @classmethod
  def 							lowercase_     (						cls  ,					__UpperCAmelCase  ,					__UpperCAmelCase = None  ,					__UpperCAmelCase = False  ,					__UpperCAmelCase = False  ,					__UpperCAmelCase = None  ,					__UpperCAmelCase = "main"  ,					**__UpperCAmelCase  ,					)				->					Union[str, Any]:
     a   :	int						=    cache_dir
     a   :	List[str]						=    force_download
     a   :	str						=    local_files_only
     a   :	str						=    revision

     cls._set_token_in_kwargs(snake_case__  ,					snake_case__						)

     a	, a   :	List[Any]						=    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":
        a   :	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_       (     lowerCAmelCase__   ):





  """simple docstring"""

  lowercase		:	Union[str, 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_       (     lowerCAmelCase__   ):





  """simple docstring"""

  lowercase		:	Dict   =						"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_       (     lowerCAmelCase__   ):





  """simple docstring"""

  lowercase		:	Optional[int]   =						"fine_acoustics"
  def __init__(						self  ,					__UpperCAmelCase=True  ,					__UpperCAmelCase=8  ,					__UpperCAmelCase=1  ,					**__UpperCAmelCase						)				->					Any:
     a   :	Optional[Any]						=    n_codes_total
     a   :	Dict						=    n_codes_given

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



class 	A_       (     lowerCAmelCase__   ):





  """simple docstring"""

  lowercase		:	Tuple   =						"bark"
  lowercase		:	Optional[Any]   =						True
  def __init__(						self  ,					__UpperCAmelCase = None  ,					__UpperCAmelCase = None  ,					__UpperCAmelCase = None  ,					__UpperCAmelCase = None  ,					__UpperCAmelCase=0.02  ,					**__UpperCAmelCase  ,					)				->					str:





     if semantic_config is None:
        a   :	Tuple						=    {}
        logger.info('semantic_config is None. initializing the semantic model with default values.'						)

     if coarse_acoustics_config is None:
        a   :	Optional[Any]						=    {}
        logger.info('coarse_acoustics_config is None. initializing the coarse model with default values.'						)

     if fine_acoustics_config is None:
        a   :	int						=    {}
        logger.info('fine_acoustics_config is None. initializing the fine model with default values.'						)

     if codec_config is None:
        a   :	int						=    {}
        logger.info('codec_config is None. initializing the codec model with default values.'						)

     a   :	Any						=    BarkSemanticConfig(**snake_case__						)
     a   :	int						=    BarkCoarseConfig(**snake_case__						)
     a   :	int						=    BarkFineConfig(**snake_case__						)
     a   :	str						=    AutoConfig.for_model(**snake_case__						)

     a   :	Optional[int]						=    initializer_range

     super().__init__(**snake_case__						)
  @classmethod
  def 							lowercase_     (						cls  ,					__UpperCAmelCase  ,					__UpperCAmelCase  ,					__UpperCAmelCase  ,					__UpperCAmelCase  ,					**__UpperCAmelCase  ,					)				->					Optional[int]:
     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 							lowercase_     (						self						)				->					int:
     a   :	List[str]						=    copy.deepcopy(self.__dict__						)

     a   :	Any						=    self.semantic_config.to_dict()
     a   :	List[Any]						=    self.coarse_acoustics_config.to_dict()
     a   :	Union[str, Any]						=    self.fine_acoustics_config.to_dict()
     a   :	List[Any]						=    self.codec_config.to_dict()

     a   :	Any						=    self.__class__.model_type
     return output







import json
import os
from typing import TYPE_CHECKING, List, Optional, Tuple

import regex as re

from ...tokenization_utils import AddedToken, PreTrainedTokenizer
from ...utils import logging


if TYPE_CHECKING:
	from transformers.pipelines.conversational import Conversation

__a							  =						logging.get_logger(__name__)

__a							  =						{"""vocab_file""": """vocab.json""", """merges_file""": """merges.txt"""}

__a							  =						{
    """vocab_file""": {
        """microsoft/deberta-base""": """https://huggingface.co/microsoft/deberta-base/resolve/main/vocab.json""",
        """microsoft/deberta-large""": """https://huggingface.co/microsoft/deberta-large/resolve/main/vocab.json""",
        """microsoft/deberta-xlarge""": """https://huggingface.co/microsoft/deberta-xlarge/resolve/main/vocab.json""",
        """microsoft/deberta-base-mnli""": """https://huggingface.co/microsoft/deberta-base-mnli/resolve/main/vocab.json""",
        """microsoft/deberta-large-mnli""": """https://huggingface.co/microsoft/deberta-large-mnli/resolve/main/vocab.json""",
        """microsoft/deberta-xlarge-mnli""": (
            """https://huggingface.co/microsoft/deberta-xlarge-mnli/resolve/main/vocab.json"""
        ),
    },
    """merges_file""": {
        """microsoft/deberta-base""": """https://huggingface.co/microsoft/deberta-base/resolve/main/merges.txt""",
        """microsoft/deberta-large""": """https://huggingface.co/microsoft/deberta-large/resolve/main/merges.txt""",
        """microsoft/deberta-xlarge""": """https://huggingface.co/microsoft/deberta-xlarge/resolve/main/merges.txt""",
        """microsoft/deberta-base-mnli""": """https://huggingface.co/microsoft/deberta-base-mnli/resolve/main/merges.txt""",
        """microsoft/deberta-large-mnli""": """https://huggingface.co/microsoft/deberta-large-mnli/resolve/main/merges.txt""",
        """microsoft/deberta-xlarge-mnli""": (
            """https://huggingface.co/microsoft/deberta-xlarge-mnli/resolve/main/merges.txt"""
        ),
    },
}

__a							  =						{
    """microsoft/deberta-base""": 5_1_2,
    """microsoft/deberta-large""": 5_1_2,
    """microsoft/deberta-xlarge""": 5_1_2,
    """microsoft/deberta-base-mnli""": 5_1_2,
    """microsoft/deberta-large-mnli""": 5_1_2,
    """microsoft/deberta-xlarge-mnli""": 5_1_2,
}

__a							  =						{
    """microsoft/deberta-base""": {"""do_lower_case""": False},
    """microsoft/deberta-large""": {"""do_lower_case""": False},
}

def    UpperCamelCase_ (	)     ->Optional[int]:
		A				=(
		    list(range(ord("!"		)  ,				ord("~"		) + 1		)		) + list(range(ord("¡"		)  ,				ord("¬"		) + 1		)		) + list(range(ord("®"		)  ,				ord("ÿ"		) + 1		)		)
		)
		A				=bs[:]
		A				=0
		for b in range(2**8		):
				if b not in bs:
						bs.append(a_		)
						cs.append(2**8 + n		)
						n += 1
		A				=[chr(a_		) for n in cs]
		return dict(zip(a_  ,				a_		)		)

def    UpperCamelCase_ (	a_		)     ->Dict:
		A				=set()
		A				=word[0]
		for char in word[1:]:
				pairs.add((prev_char, char)		)
				A				=char
		return pairs






class        UpperCamelCase__(    lowerCAmelCase__	):

	"""simple docstring"""

	_A  =		VOCAB_FILES_NAMES
	_A  =		PRETRAINED_VOCAB_FILES_MAP
	_A  =		PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
	_A  =		["input_ids", "attention_mask", "token_type_ids"]







	def __init__(      self				:			Union[str, Any]							,			snake_case__				:			Tuple							,			snake_case__				:			Union[str, Any]							,			snake_case__				:			Union[str, Any]="replace"							,			snake_case__				:			Any="[CLS]"							,			snake_case__				:			List[Any]="[SEP]"							,			snake_case__				:			str="[SEP]"							,			snake_case__				:			Tuple="[CLS]"							,			snake_case__				:			Optional[Any]="[UNK]"							,			snake_case__				:			Union[str, Any]="[PAD]"							,			snake_case__				:			List[Any]="[MASK]"							,			snake_case__				:			Any=False							,			snake_case__				:			List[str]=False							,			**snake_case__				:			str							,			):
			"""simple docstring"""





			A				=AddedToken(snake_case__							,			lstrip=snake_case__							,			rstrip=snake_case__ ) if isinstance(snake_case__							,			snake_case__ ) else bos_token
			A				=AddedToken(snake_case__							,			lstrip=snake_case__							,			rstrip=snake_case__ ) if isinstance(snake_case__							,			snake_case__ ) else eos_token
			A				=AddedToken(snake_case__							,			lstrip=snake_case__							,			rstrip=snake_case__ ) if isinstance(snake_case__							,			snake_case__ ) else sep_token
			A				=AddedToken(snake_case__							,			lstrip=snake_case__							,			rstrip=snake_case__ ) if isinstance(snake_case__							,			snake_case__ ) else cls_token
			A				=AddedToken(snake_case__							,			lstrip=snake_case__							,			rstrip=snake_case__ ) if isinstance(snake_case__							,			snake_case__ ) else unk_token
			A				=AddedToken(snake_case__							,			lstrip=snake_case__							,			rstrip=snake_case__ ) if isinstance(snake_case__							,			snake_case__ ) else pad_token

			# Mask token behave like a normal word, i.e. include the space before it
			A				=AddedToken(snake_case__							,			lstrip=snake_case__							,			rstrip=snake_case__ ) if isinstance(snake_case__							,			snake_case__ ) else mask_token

			super().__init__(
			    errors=snake_case__							,			bos_token=snake_case__							,			eos_token=snake_case__							,			unk_token=snake_case__							,			sep_token=snake_case__							,			cls_token=snake_case__							,			pad_token=snake_case__							,			mask_token=snake_case__							,			add_prefix_space=snake_case__							,			add_bos_token=snake_case__							,			**snake_case__							,			)
			A				=add_bos_token

			with open(snake_case__							,			encoding="utf-8" ) as vocab_handle:
					A				=json.load(snake_case__ )
			A				={v: k for k, v in self.encoder.items()}
			A				=errors  # how to handle errors in decoding
			A				=bytes_to_unicode()
			A				={v: k for k, v in self.byte_encoder.items()}
			with open(snake_case__							,			encoding="utf-8" ) as merges_handle:
					A				=merges_handle.read().split("\n" )[1:-1]
			A				=[tuple(merge.split() ) for merge in bpe_merges]
			A				=dict(zip(snake_case__							,			range(len(snake_case__ ) ) ) )
			A				={}
			A				=add_prefix_space

			# Should have added re.IGNORECASE so BPE merges can happen for capitalized versions of contractions
			A				=re.compile(R"'s|'t|'re|'ve|'m|'ll|'d| ?\p{L}+| ?\p{N}+| ?[^\s\p{L}\p{N}]+|\s+(?!\S)|\s+" )







	@property
	# Copied from transformers.models.gpt2.tokenization_gpt2.GPT2Tokenizer.vocab_size
	def        _a					(      self				:			Optional[int] ):
			"""simple docstring"""





			return len(self.encoder )







	def        _a					(      self				:			int ):
			"""simple docstring"""





			return dict(self.encoder							,			**self.added_tokens_encoder )







	def        _a					(      self				:			List[str]							,			snake_case__				:			List[str] ):
			"""simple docstring"""





			if token in self.cache:
					return self.cache[token]
			A				=tuple(snake_case__ )
			A				=get_pairs(snake_case__ )

			if not pairs:
					return token

			while True:
					A				=min(snake_case__							,			key=lambda snake_case__ : self.bpe_ranks.get(snake_case__							,			float("inf" ) ) )
					if bigram not in self.bpe_ranks:
							break
					A			,    A				=bigram
					A				=[]
					A				=0
					while i < len(snake_case__ ):
							try:
									A				=word.index(snake_case__							,			snake_case__ )
							except ValueError:
									new_word.extend(word[i:] )
									break
							else:
									new_word.extend(word[i:j] )
									A				=j

							if word[i] == first and i < len(snake_case__ ) - 1 and word[i + 1] == second:
									new_word.append(first + second )
									i += 2
							else:
									new_word.append(word[i] )
									i += 1
					A				=tuple(snake_case__ )
					A				=new_word
					if len(snake_case__ ) == 1:
							break
					else:
							A				=get_pairs(snake_case__ )
			A				=" ".join(snake_case__ )
			A				=word
			return word







	def        _a					(      self				:			Any							,			snake_case__				:			List[int]							,			snake_case__				:			Optional[List[int]] = None ):
			"""simple docstring"""





			if token_ids_a is None:
					return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
			A				=[self.cls_token_id]
			A				=[self.sep_token_id]
			return cls + token_ids_a + sep + token_ids_a + sep







	def        _a					(      self				:			List[Any]							,			snake_case__				:			List[int]							,			snake_case__				:			Optional[List[int]] = None							,			snake_case__				:			bool = False ):
			"""simple docstring"""





			if already_has_special_tokens:
					return super().get_special_tokens_mask(
					    token_ids_a=snake_case__							,			token_ids_a=snake_case__							,			already_has_special_tokens=snake_case__ )

			if token_ids_a is None:
					return [1] + ([0] * len(snake_case__ )) + [1]
			return [1] + ([0] * len(snake_case__ )) + [1] + ([0] * len(snake_case__ )) + [1]







	def        _a					(      self				:			str							,			snake_case__				:			List[int]							,			snake_case__				:			Optional[List[int]] = None ):
			"""simple docstring"""





			A				=[self.sep_token_id]
			A				=[self.cls_token_id]

			if token_ids_a is None:
					return len(cls + token_ids_a + sep ) * [0]
			return len(cls + token_ids_a + sep ) * [0] + len(token_ids_a + sep ) * [1]







	def        _a					(      self				:			List[str]							,			snake_case__				:			List[Any] ):
			"""simple docstring"""





			A				=[]
			for token in re.findall(self.pat							,			snake_case__ ):
					A				="".join(
					    self.byte_encoder[b] for b in token.encode("utf-8" ) )  # Maps all our bytes to unicode strings, avoiding control tokens of the BPE (spaces in our case)
					bpe_tokens.extend(bpe_token for bpe_token in self.bpe(snake_case__ ).split(" " ) )
			return bpe_tokens







	def        _a					(      self				:			List[Any]							,			snake_case__				:			List[str] ):
			"""simple docstring"""





			return self.encoder.get(snake_case__							,			self.encoder.get(self.unk_token ) )







	def        _a					(      self				:			int							,			snake_case__				:			List[str] ):
			"""simple docstring"""





			return self.decoder.get(snake_case__ )







	def        _a					(      self				:			Union[str, Any]							,			snake_case__				:			Optional[int] ):
			"""simple docstring"""





			A				="".join(snake_case__ )
			A				=bytearray([self.byte_decoder[c] for c in text] ).decode("utf-8"							,			errors=self.errors )
			return text







	def        _a					(      self				:			int							,			snake_case__				:			str							,			snake_case__				:			Optional[str] = None ):
			"""simple docstring"""





			if not os.path.isdir(snake_case__ ):
					logger.error(f'''Vocabulary path ({save_directory}) should be a directory''' )
					return
			A				=os.path.join(
			    snake_case__							,			(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["vocab_file"] )
			A				=os.path.join(
			    snake_case__							,			(filename_prefix + "-" if filename_prefix else "") + VOCAB_FILES_NAMES["merges_file"] )

			with open(snake_case__							,			"w"							,			encoding="utf-8" ) as f:
					f.write(json.dumps(self.encoder							,			indent=2							,			sort_keys=snake_case__							,			ensure_ascii=snake_case__ ) + "\n" )

			A				=0
			with open(snake_case__							,			"w"							,			encoding="utf-8" ) as writer:
					writer.write("#version: 0.2\n" )
					for bpe_tokens, token_index in sorted(self.bpe_ranks.items()							,			key=lambda snake_case__ : kv[1] ):
							if index != token_index:
									logger.warning(
									    f'''Saving vocabulary to {merge_file}: BPE merge indices are not consecutive.'''
									    " Please check that the tokenizer is not corrupted!" )
									A				=token_index
							writer.write(" ".join(snake_case__ ) + "\n" )
							index += 1

			return vocab_file, merge_file







	def        _a					(      self				:			List[Any]							,			snake_case__				:			Optional[Any]							,			snake_case__				:			Any=False							,			**snake_case__				:			Optional[int] ):
			"""simple docstring"""





			A				=kwargs.pop("add_prefix_space"							,			self.add_prefix_space )
			if (is_split_into_words or add_prefix_space) and (len(snake_case__ ) > 0 and not text[0].isspace()):
					A				=" " + text
			return (text, kwargs)







	def        _a					(      self				:			List[str]							,			snake_case__				:			"Conversation" ):
			"""simple docstring"""





			A				=[]
			for is_user, text in conversation.iter_texts():
					input_ids.extend(self.encode(snake_case__							,			add_special_tokens=snake_case__ ) + [self.eos_token_id] )
			if len(snake_case__ ) > self.model_max_length:
					A				=input_ids[-self.model_max_length :]
			return input_ids




