


'''simple docstring'''







from typing import List, Optional, Tuple

from tokenizers import pre_tokenizers

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_clip import CLIPTokenizer


A      :     List[Any]										= logging.get_logger(__name__)

A      :     str										= {'''vocab_file''': '''vocab.json''', '''merges_file''': '''merges.txt''', '''tokenizer_file''': '''tokenizer.json'''}

A      :     Tuple										= {
    '''vocab_file''': {
        '''openai/clip-vit-base-patch32''': '''https://huggingface.co/openai/clip-vit-base-patch32/resolve/main/vocab.json''',
    },
    '''merges_file''': {
        '''openai/clip-vit-base-patch32''': '''https://huggingface.co/openai/clip-vit-base-patch32/resolve/main/merges.txt''',
    },
    '''tokenizer_file''': {
        '''openai/clip-vit-base-patch32''': (
            '''https://huggingface.co/openai/clip-vit-base-patch32/resolve/main/tokenizer.json'''
        ),
    },
}

A      :     Any										= {
    '''openai/clip-vit-base-patch32''': 77,
}


class  __lowerCamelCase (       a_       ):
    """simple docstring"""
    a													=    VOCAB_FILES_NAMES
    a													=    PRETRAINED_VOCAB_FILES_MAP
    a													=    PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
    a													=    ["input_ids", "attention_mask"]
    a													=    CLIPTokenizer


    def __init__(  self			:							int      ,							SCREAMING_SNAKE_CASE			:							int=None      ,							SCREAMING_SNAKE_CASE			:							List[Any]=None      ,							SCREAMING_SNAKE_CASE			:							int=None      ,							SCREAMING_SNAKE_CASE			:							Optional[Any]="<|endoftext|>"      ,							SCREAMING_SNAKE_CASE			:							str="<|startoftext|>"      ,							SCREAMING_SNAKE_CASE			:							Any="<|endoftext|>"      ,							SCREAMING_SNAKE_CASE			:							int="<|endoftext|>"      ,							**SCREAMING_SNAKE_CASE			:							Any      ,							):
           super().__init__(
               SCREAMING_SNAKE_CASE      ,							SCREAMING_SNAKE_CASE      ,							tokenizer_file=SCREAMING_SNAKE_CASE      ,							unk_token=SCREAMING_SNAKE_CASE      ,							bos_token=SCREAMING_SNAKE_CASE      ,							eos_token=SCREAMING_SNAKE_CASE      ,							pad_token=SCREAMING_SNAKE_CASE      ,							**SCREAMING_SNAKE_CASE      ,							)

           if not isinstance(self.backend_tokenizer.pre_tokenizer      ,							pre_tokenizers.Sequence):
                  raise ValueError(
                      'The `backend_tokenizer` provided does not match the expected format. The CLIP tokenizer has been'
                      ' heavily modified from transformers version 4.17.0. You need to convert the tokenizer you are using'
                      ' to be compatible with this version.The easiest way to do so is'
                      ' `CLIPTokenizerFast.from_pretrained("path_to_local_folder_or_hub_repo, from_slow=True)`. If you want'
                      ' to use your existing tokenizer, you will have to revert to a version prior to 4.17.0 of'
                      ' transformers.')

           self._wrap_decode_method_backend_tokenizer()


    def    A    (  self			:							List[str]):
           _A     :	str      =					self.backend_tokenizer.decode

           def new_decode_method(*SCREAMING_SNAKE_CASE			:							List[Any]      ,							**SCREAMING_SNAKE_CASE			:							Tuple):
                  _A     :	List[str]      =					orig_decode_method(*SCREAMING_SNAKE_CASE      ,							**SCREAMING_SNAKE_CASE)
                  _A     :	List[Any]      =					text.replace(self.backend_tokenizer.model.end_of_word_suffix      ,							' ').strip()
                  return text

           _A     :	str      =					new_decode_method


    def    A    (  self			:							List[Any]      ,							SCREAMING_SNAKE_CASE			:							List[int]      ,							SCREAMING_SNAKE_CASE			:							Optional[List[int]] = None):
           _A     :	Any      =					[self.bos_token_id]
           _A     :	List[Any]      =					[self.eos_token_id]

           if token_ids_a is None:
                  return bos_token + token_ids_a + eos_token
           return bos_token + token_ids_a + eos_token + eos_token + token_ids_a + eos_token


    def    A    (  self			:							Union[str, Any]      ,							SCREAMING_SNAKE_CASE			:							List[int]      ,							SCREAMING_SNAKE_CASE			:							Optional[List[int]] = None):
           _A     :	List[Any]      =					[self.bos_token_id]
           _A     :	Dict      =					[self.eos_token_id]

           if token_ids_a is None:
                  return len(bos_token + token_ids_a + eos_token) * [0]
           return len(bos_token + token_ids_a + eos_token + eos_token + token_ids_a + eos_token) * [0]


    def    A    (  self			:							Any      ,							SCREAMING_SNAKE_CASE			:							str      ,							SCREAMING_SNAKE_CASE			:							Optional[str] = None):
           _A     :	str      =					self._tokenizer.model.save(SCREAMING_SNAKE_CASE      ,							name=SCREAMING_SNAKE_CASE)
           return tuple(SCREAMING_SNAKE_CASE)










'''simple docstring'''







import os
from shutil import copyfile
from typing import List, Optional, Tuple

from ...tokenization_utils import AddedToken
from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import is_sentencepiece_available, logging


if is_sentencepiece_available():
   from .tokenization_xlm_roberta import XLMRobertaTokenizer
else:
   A      :     Optional[int]										= None


A      :     Optional[Any]										= logging.get_logger(__name__)

A      :     Dict										= {'''vocab_file''': '''sentencepiece.bpe.model''', '''tokenizer_file''': '''tokenizer.json'''}

A      :     Optional[int]										= {
    '''vocab_file''': {
        '''xlm-roberta-base''': '''https://huggingface.co/xlm-roberta-base/resolve/main/sentencepiece.bpe.model''',
        '''xlm-roberta-large''': '''https://huggingface.co/xlm-roberta-large/resolve/main/sentencepiece.bpe.model''',
        '''xlm-roberta-large-finetuned-conll02-dutch''': (
            '''https://huggingface.co/xlm-roberta-large-finetuned-conll02-dutch/resolve/main/sentencepiece.bpe.model'''
        ),
        '''xlm-roberta-large-finetuned-conll02-spanish''': (
            '''https://huggingface.co/xlm-roberta-large-finetuned-conll02-spanish/resolve/main/sentencepiece.bpe.model'''
        ),
        '''xlm-roberta-large-finetuned-conll03-english''': (
            '''https://huggingface.co/xlm-roberta-large-finetuned-conll03-english/resolve/main/sentencepiece.bpe.model'''
        ),
        '''xlm-roberta-large-finetuned-conll03-german''': (
            '''https://huggingface.co/xlm-roberta-large-finetuned-conll03-german/resolve/main/sentencepiece.bpe.model'''
        ),
    },
    '''tokenizer_file''': {
        '''xlm-roberta-base''': '''https://huggingface.co/xlm-roberta-base/resolve/main/tokenizer.json''',
        '''xlm-roberta-large''': '''https://huggingface.co/xlm-roberta-large/resolve/main/tokenizer.json''',
        '''xlm-roberta-large-finetuned-conll02-dutch''': (
            '''https://huggingface.co/xlm-roberta-large-finetuned-conll02-dutch/resolve/main/tokenizer.json'''
        ),
        '''xlm-roberta-large-finetuned-conll02-spanish''': (
            '''https://huggingface.co/xlm-roberta-large-finetuned-conll02-spanish/resolve/main/tokenizer.json'''
        ),
        '''xlm-roberta-large-finetuned-conll03-english''': (
            '''https://huggingface.co/xlm-roberta-large-finetuned-conll03-english/resolve/main/tokenizer.json'''
        ),
        '''xlm-roberta-large-finetuned-conll03-german''': (
            '''https://huggingface.co/xlm-roberta-large-finetuned-conll03-german/resolve/main/tokenizer.json'''
        ),
    },
}

A      :     List[str]										= {
    '''xlm-roberta-base''': 512,
    '''xlm-roberta-large''': 512,
    '''xlm-roberta-large-finetuned-conll02-dutch''': 512,
    '''xlm-roberta-large-finetuned-conll02-spanish''': 512,
    '''xlm-roberta-large-finetuned-conll03-english''': 512,
    '''xlm-roberta-large-finetuned-conll03-german''': 512,
}


class  __lowerCamelCase (       a_       ):
    """simple docstring"""
    a													=    VOCAB_FILES_NAMES
    a													=    PRETRAINED_VOCAB_FILES_MAP
    a													=    PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
    a													=    ["input_ids", "attention_mask"]
    a													=    XLMRobertaTokenizer


    def __init__(  self			:							Union[str, Any]      ,							SCREAMING_SNAKE_CASE			:							Dict=None      ,							SCREAMING_SNAKE_CASE			:							List[Any]=None      ,							SCREAMING_SNAKE_CASE			:							Any="<s>"      ,							SCREAMING_SNAKE_CASE			:							Tuple="</s>"      ,							SCREAMING_SNAKE_CASE			:							str="</s>"      ,							SCREAMING_SNAKE_CASE			:							Optional[Any]="<s>"      ,							SCREAMING_SNAKE_CASE			:							Any="<unk>"      ,							SCREAMING_SNAKE_CASE			:							Union[str, Any]="<pad>"      ,							SCREAMING_SNAKE_CASE			:							List[Any]="<mask>"      ,							**SCREAMING_SNAKE_CASE			:							int      ,							):
           # Mask token behave like a normal word, i.e. include the space before it
           _A     :	str      =					AddedToken(SCREAMING_SNAKE_CASE      ,							lstrip=SCREAMING_SNAKE_CASE      ,							rstrip=SCREAMING_SNAKE_CASE) if isinstance(SCREAMING_SNAKE_CASE      ,							SCREAMING_SNAKE_CASE) else mask_token

           super().__init__(
               SCREAMING_SNAKE_CASE      ,							tokenizer_file=SCREAMING_SNAKE_CASE      ,							bos_token=SCREAMING_SNAKE_CASE      ,							eos_token=SCREAMING_SNAKE_CASE      ,							sep_token=SCREAMING_SNAKE_CASE      ,							cls_token=SCREAMING_SNAKE_CASE      ,							unk_token=SCREAMING_SNAKE_CASE      ,							pad_token=SCREAMING_SNAKE_CASE      ,							mask_token=SCREAMING_SNAKE_CASE      ,							**SCREAMING_SNAKE_CASE      ,							)

           _A     :	Dict      =					vocab_file
           _A     :	Optional[Any]      =					False if not self.vocab_file else True


    def    A    (  self			:							int      ,							SCREAMING_SNAKE_CASE			:							List[int]      ,							SCREAMING_SNAKE_CASE			:							Optional[List[int]] = None):

           if token_ids_a is None:
                  return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
           _A     :	Optional[Any]      =					[self.cls_token_id]
           _A     :	Optional[int]      =					[self.sep_token_id]
           return cls + token_ids_a + sep + sep + token_ids_a + sep


    def    A    (  self			:							List[str]      ,							SCREAMING_SNAKE_CASE			:							List[int]      ,							SCREAMING_SNAKE_CASE			:							Optional[List[int]] = None):
           _A     :	Any      =					[self.sep_token_id]
           _A     :	Optional[Any]      =					[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 + sep + token_ids_a + sep) * [0]


    def    A    (  self			:							Dict      ,							SCREAMING_SNAKE_CASE			:							str      ,							SCREAMING_SNAKE_CASE			:							Optional[str] = None):
           if not self.can_save_slow_tokenizer:
                  raise ValueError(
                      'Your fast tokenizer does not have the necessary information to save the vocabulary for a slow '
                      'tokenizer.')

           if not os.path.isdir(SCREAMING_SNAKE_CASE):
                  logger.error(F'Vocabulary path ({save_directory}) should be a directory.')
                  return
           _A     :	Any      =					os.path.join(
               SCREAMING_SNAKE_CASE      ,							(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file'])

           if os.path.abspath(self.vocab_file) != os.path.abspath(SCREAMING_SNAKE_CASE):
                  copyfile(self.vocab_file      ,							SCREAMING_SNAKE_CASE)

           return (out_vocab_file,)






