a h 6@sdZddlZddlZddlmZddlZddlmZddl m Z ddl m Z ddl mZdd lmZd d lmZeeZGd d d e Zd gZdS)z Processor class for Bark N)Optional) BatchFeature)ProcessorMixin) BatchEncoding)logging) cached_file) AutoTokenizercseZdZdZdZdgZddddZdfdd Zedd d Z de dfdd Z d e e dddZd!e edddZd"edddZZS)# BarkProcessora  Constructs a Bark processor which wraps a text tokenizer and optional Bark voice presets into a single processor. Args: tokenizer ([`PreTrainedTokenizer`]): An instance of [`PreTrainedTokenizer`]. speaker_embeddings (`dict[dict[str]]`, *optional*): Optional nested speaker embeddings dictionary. The first level contains voice preset names (e.g `"en_speaker_4"`). The second level contains `"semantic_prompt"`, `"coarse_prompt"` and `"fine_prompt"` embeddings. The values correspond to the path of the corresponding `np.ndarray`. See [here](https://suno-ai.notion.site/8b8e8749ed514b0cbf3f699013548683?v=bc67cff786b04b50b3ceb756fd05f68c) for a list of `voice_preset_names`. r tokenizerr Zsemantic_promptZ coarse_promptZ fine_promptNcst|||_dS)N)super__init__speaker_embeddings)selfr r __class__d/var/www/html/assistant/venv/lib/python3.9/site-packages/transformers/models/bark/processing_bark.pyr=s zBarkProcessor.__init__speaker_embeddings_path.jsoncKs|durt|||dd|dd|dd|dd|dd|dd|d d|d ddddd }|durtd tj||d d}qt|}t |}Wdq1s0Ynd}t j |fi|}|||dS)a Instantiate a Bark processor associated with a pretrained model. Args: pretrained_model_name_or_path (`str` or `os.PathLike`): This can be either: - a string, the *model id* of a pretrained [`BarkProcessor`] hosted inside a model repo on huggingface.co. - a path to a *directory* containing a processor saved using the [`~BarkProcessor.save_pretrained`] method, e.g., `./my_model_directory/`. speaker_embeddings_dict_path (`str`, *optional*, defaults to `"speaker_embeddings_path.json"`): The name of the `.json` file containing the speaker_embeddings dictionary located in `pretrained_model_name_or_path`. If `None`, no speaker_embeddings is loaded. **kwargs Additional keyword arguments passed along to both [`~tokenization_utils_base.PreTrainedTokenizer.from_pretrained`]. N subfolder cache_dirforce_downloadFproxiesresume_downloadlocal_files_onlyuse_auth_tokenrevision rrrrrrtokenrZ _raise_exceptions_for_gated_repoZ%_raise_exceptions_for_missing_entriesZ'_raise_exceptions_for_connection_errors`z` does not exists , no preloaded speaker embeddings will be used - Make sure to provide a correct path to the json dictionary if wanted, otherwise set `speaker_embeddings_dict_path=None`.)r r) rpoploggerwarningospathjoinopenjsonloadr from_pretrained)clsZ!pretrained_processor_name_or_pathspeaker_embeddings_dict_pathkwargsZspeaker_embeddings_pathrZspeaker_embeddings_jsonr rrrr,Bs4         *zBarkProcessor.from_pretrainedrF) push_to_hubc s|jdurtjtj||dddi}||d<|jD]~}|dkr6||}i} |j|D]P} tjtj|d||d| || ddtj||d| d | | <qZ| ||<q6ttj||d } t || Wdn1s0Yt j ||fi|dS) a| Saves the attributes of this processor (tokenizer...) in the specified directory so that it can be reloaded using the [`~BarkProcessor.from_pretrained`] method. Args: save_directory (`str` or `os.PathLike`): Directory where the tokenizer files and the speaker embeddings will be saved (directory will be created if it does not exist). speaker_embeddings_dict_path (`str`, *optional*, defaults to `"speaker_embeddings_path.json"`): The name of the `.json` file that will contains the speaker_embeddings nested path dictionary, if it exists, and that will be located in `pretrained_model_name_or_path/speaker_embeddings_directory`. speaker_embeddings_directory (`str`, *optional*, defaults to `"speaker_embeddings/"`): The name of the folder in which the speaker_embeddings arrays will be saved. push_to_hub (`bool`, *optional*, defaults to `False`): Whether or not to push your model to the Hugging Face model hub after saving it. You can specify the repository you want to push to with `repo_id` (will default to the name of `save_directory` in your namespace). kwargs: Additional key word arguments passed along to the [`~utils.PushToHubMixin.push_to_hub`] method. NZv2T)exist_ok repo_or_path_F)Z allow_picklez.npyw) rr&makedirsr'r(_load_voice_presetnpsaver)r*dumprsave_pretrained) rZsave_directoryr.Zspeaker_embeddings_directoryr0r/Zembeddings_dictZ prompt_key voice_presetZtmp_dictkeyfprrrr:zs*     *zBarkProcessor.save_pretrained)r;cKs|j|}i}dD]}||vr4td|d|dt|jdd|||dd|dd|d d |d d|d d|d d |dd|ddd d d d }|durtdtj|jdd||d|dt |||<q|S)Nr#Voice preset unrecognized, missing z% as a key in self.speaker_embeddings[z].r2/rrrFrrrrrr r"z{` does not exists , no preloaded voice preset will be used - Make sure to provide correct paths to the z embeddings.) r ValueErrorrgetr#r&r'r(r7r+)rr;r/Zvoice_preset_pathsZvoice_preset_dictr<r'rrrr6s<           z BarkProcessor._load_voice_presetcCsdD]}||vr td|dt||tjsNt|dt|j|dt||j|j|krt|dt|j|dqdS)Nrr>z as a key.z voice preset must be a z D ndarray.) r@ isinstancer7Zndarray TypeErrorstr preset_shapelenshape)rr;r<rrr_validate_voice_preset_dictsz)BarkProcessor._validate_voice_preset_dictptT)returnc Ks|durbt|tsbt|tr<|jdur<||jvr<||}n&t|trX|dsX|d}t|}|dur|j|fi|t ||d}|j |f|d||||d|} |dur|| d<| S)a# Main method to prepare for the model one or several sequences(s). This method forwards the `text` and `kwargs` arguments to the AutoTokenizer's [`~AutoTokenizer.__call__`] to encode the text. The method also proposes a voice preset which is a dictionary of arrays that conditions `Bark`'s output. `kwargs` arguments are forwarded to the tokenizer and to `cached_file` method if `voice_preset` is a valid filename. Args: text (`str`, `list[str]`, `list[list[str]]`): The sequence or batch of sequences to be encoded. Each sequence can be a string or a list of strings (pretokenized string). If the sequences are provided as list of strings (pretokenized), you must set `is_split_into_words=True` (to lift the ambiguity with a batch of sequences). voice_preset (`str`, `dict[np.ndarray]`): The voice preset, i.e the speaker embeddings. It can either be a valid voice_preset name, e.g `"en_speaker_1"`, or directly a dictionary of `np.ndarray` embeddings for each submodel of `Bark`. Or it can be a valid file name of a local `.npz` single voice preset. return_tensors (`str` or [`~utils.TensorType`], *optional*): If set, will return tensors of a particular framework. Acceptable values are: - `'pt'`: Return PyTorch `torch.Tensor` objects. - `'np'`: Return NumPy `np.ndarray` objects. Returns: [`BatchEncoding`]: A [`BatchEncoding`] object containing the output of the `tokenizer`. If a voice preset is provided, the returned object will include a `"history_prompt"` key containing a [`BatchFeature`], i.e the voice preset with the right tensors type. Nz.npz)dataZ tensor_type max_length)return_tensorspaddingrMreturn_attention_maskreturn_token_type_idsadd_special_tokensZhistory_prompt) rBdictrDrr6endswithr7r+rHrr ) rtextr;rNrMrRrPrQr/Z encoded_textrrr__call__s:%    zBarkProcessor.__call__)N)r)rrF)N)N)NNrIrJFTF)__name__ __module__ __qualname____doc__Ztokenizer_class attributesrEr classmethodr,boolr:rrDr6rSrHrrV __classcell__rrrrr $s: :9$  r )rZr*r&typingrnumpyr7Zfeature_extraction_utilsrZprocessing_utilsrZtokenization_utils_baserutilsrZ utils.hubrautor Z get_loggerrWr$r __all__rrrrs