


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

import sentencepiece as spm

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


__lowerCAmelCase			=							logging.get_logger(__name__)

__lowerCAmelCase			=							'''▁'''

__lowerCAmelCase			=							{'''vocab_file''': '''sentencepiece.bpe.model''', '''monolingual_vocab_file''': '''dict.txt'''}

__lowerCAmelCase			=							{
    '''vocab_file''': {
        '''vinai/bartpho-syllable''': '''https://huggingface.co/vinai/bartpho-syllable/resolve/main/sentencepiece.bpe.model''',
    },
    '''monolingual_vocab_file''': {
        '''vinai/bartpho-syllable''': '''https://huggingface.co/vinai/bartpho-syllable/resolve/main/dict.txt''',
    },
}

__lowerCAmelCase			=							{'''vinai/bartpho-syllable''': 10_24}





class   __a      (   __UpperCamelCase				):
 __lowercase			:							int       					=			VOCAB_FILES_NAMES
 __lowercase			:							str       					=			PRETRAINED_VOCAB_FILES_MAP
 __lowercase			:							str       					=			PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
 __lowercase			:							Optional[int]       					=			['input_ids', 'attention_mask']
 def __init__(       self    ,			lowerCAmelCase__    ,			lowerCAmelCase__    ,			lowerCAmelCase__="<s>"    ,			lowerCAmelCase__="</s>"    ,			lowerCAmelCase__="</s>"    ,			lowerCAmelCase__="<s>"    ,			lowerCAmelCase__="<unk>"    ,			lowerCAmelCase__="<pad>"    ,			lowerCAmelCase__="<mask>"    ,			lowerCAmelCase__ = None    ,			**lowerCAmelCase__    ,			) ->    None:




        '''simple docstring'''
        lowercase__:       List[str]        =       AddedToken(lowerCAmelCase__    ,			lstrip=lowerCAmelCase__    ,			rstrip=lowerCAmelCase__			) if isinstance(lowerCAmelCase__    ,			lowerCAmelCase__			) else mask_token

        lowercase__:       Any        =       {} if sp_model_kwargs is None else sp_model_kwargs

        super().__init__(
            bos_token=lowerCAmelCase__    ,			eos_token=lowerCAmelCase__    ,			unk_token=lowerCAmelCase__    ,			sep_token=lowerCAmelCase__    ,			cls_token=lowerCAmelCase__    ,			pad_token=lowerCAmelCase__    ,			mask_token=lowerCAmelCase__    ,			sp_model_kwargs=self.sp_model_kwargs    ,			**lowerCAmelCase__    ,			)

        lowercase__:       Dict        =       vocab_file
        lowercase__:       str        =       monolingual_vocab_file
        lowercase__:       int        =       spm.SentencePieceProcessor(**self.sp_model_kwargs			)
        self.sp_model.Load(str(lowerCAmelCase__			)			)

        # Load the reduced vocab

        # Keep order of special tokens for backward compatibility
        lowercase__:       List[Any]        =       {}
        lowercase__:       Optional[int]        =       0
        for token in [bos_token, pad_token, eos_token, unk_token, sep_token, cls_token]:
               if str(lowerCAmelCase__			) not in self.fairseq_tokens_to_ids:
                      lowercase__:       str        =       cnt
                      cnt += 1
        with open(lowerCAmelCase__    ,			'r'    ,			encoding='utf-8'			) as f:
               for line in f.readlines():
                      lowercase__:       Optional[Any]        =       line.strip().split()[0]
                      lowercase__:       Optional[Any]        =       len(self.fairseq_tokens_to_ids			)
        if str(lowerCAmelCase__			) not in self.fairseq_tokens_to_ids:
               lowercase__:       Optional[int]        =       len(self.fairseq_tokens_to_ids			)

        lowercase__:       Optional[Any]        =       {v: k for k, v in self.fairseq_tokens_to_ids.items()}
 def __getstate__(       self			) ->    Optional[int]:




        '''simple docstring'''
        lowercase__:       Tuple        =       self.__dict__.copy()
        lowercase__:       Tuple        =       None
        lowercase__:       Optional[Any]        =       self.sp_model.serialized_model_proto()
        return state
 def __setstate__(       self    ,			lowerCAmelCase__			) ->    Optional[Any]:




        '''simple docstring'''
        lowercase__:       Union[str, Any]        =       d

        # for backward compatibility
        if not hasattr(self    ,			'sp_model_kwargs'			):
               lowercase__:       Union[str, Any]        =       {}

        lowercase__:       List[Any]        =       spm.SentencePieceProcessor(**self.sp_model_kwargs			)
        self.sp_model.LoadFromSerializedProto(self.sp_model_proto			)
 def 		SCREAMING_SNAKE_CASE__       (       self    ,			lowerCAmelCase__    ,			lowerCAmelCase__ = None			) ->    List[int]:




        '''simple docstring'''

        if token_ids_a is None:
               return [self.cls_token_id] + token_ids_a + [self.sep_token_id]
        lowercase__:       Optional[int]        =       [self.cls_token_id]
        lowercase__:       Union[str, Any]        =       [self.sep_token_id]
        return cls + token_ids_a + sep + sep + token_ids_a + sep
 def 		SCREAMING_SNAKE_CASE__       (       self    ,			lowerCAmelCase__    ,			lowerCAmelCase__ = None    ,			lowerCAmelCase__ = False			) ->    List[int]:




        '''simple docstring'''

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

        if token_ids_a is None:
               return [1] + ([0] * len(lowerCAmelCase__			)) + [1]
        return [1] + ([0] * len(lowerCAmelCase__			)) + [1, 1] + ([0] * len(lowerCAmelCase__			)) + [1]
 def 		SCREAMING_SNAKE_CASE__       (       self    ,			lowerCAmelCase__    ,			lowerCAmelCase__ = None			) ->    List[int]:




        '''simple docstring'''
        lowercase__:       Dict        =       [self.sep_token_id]
        lowercase__:       Dict        =       [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]
 @property
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    Tuple:




        '''simple docstring'''
        return len(self.fairseq_ids_to_tokens			)
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    Union[str, Any]:




        '''simple docstring'''
        lowercase__:       Union[str, Any]        =       {self.convert_ids_to_tokens(lowerCAmelCase__			): i for i in range(self.vocab_size			)}
        vocab.update(self.added_tokens_encoder			)
        return vocab
 def 		SCREAMING_SNAKE_CASE__       (       self    ,			lowerCAmelCase__			) ->    List[str]:




        '''simple docstring'''
        return self.sp_model.encode(lowerCAmelCase__    ,			out_type=lowerCAmelCase__			)
 def 		SCREAMING_SNAKE_CASE__       (       self    ,			lowerCAmelCase__			) ->    List[Any]:




        '''simple docstring'''
        if token in self.fairseq_tokens_to_ids:
               return self.fairseq_tokens_to_ids[token]
        else:
               return self.unk_token_id
 def 		SCREAMING_SNAKE_CASE__       (       self    ,			lowerCAmelCase__			) ->    Optional[Any]:




        '''simple docstring'''
        return self.fairseq_ids_to_tokens[index]
 def 		SCREAMING_SNAKE_CASE__       (       self    ,			lowerCAmelCase__			) ->    Optional[Any]:




        '''simple docstring'''
        lowercase__:       Optional[Any]        =       ''.join(lowerCAmelCase__			).replace(lowerCAmelCase__    ,			' '			).strip()
        return out_string
 def 		SCREAMING_SNAKE_CASE__       (       self    ,			lowerCAmelCase__    ,			lowerCAmelCase__ = None			) ->    Tuple[str]:




        '''simple docstring'''
        if not os.path.isdir(lowerCAmelCase__			):
               logger.error(F'Vocabulary path ({save_directory}) should be a directory'			)
               return
        lowercase__:       int        =       os.path.join(
            lowerCAmelCase__    ,			(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']			)
        lowercase__:       List[str]        =       os.path.join(
            lowerCAmelCase__    ,			(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['monolingual_vocab_file']    ,			)

        if os.path.abspath(self.vocab_file			) != os.path.abspath(lowerCAmelCase__			) and os.path.isfile(self.vocab_file			):
               copyfile(self.vocab_file    ,			lowerCAmelCase__			)
        elif not os.path.isfile(self.vocab_file			):
               with open(lowerCAmelCase__    ,			'wb'			) as fi:
                      lowercase__:       Optional[Any]        =       self.sp_model.serialized_model_proto()
                      fi.write(lowerCAmelCase__			)

        if os.path.abspath(self.monolingual_vocab_file			) != os.path.abspath(
            lowerCAmelCase__			) and os.path.isfile(self.monolingual_vocab_file			):
               copyfile(self.monolingual_vocab_file    ,			lowerCAmelCase__			)
        elif not os.path.isfile(self.monolingual_vocab_file			):
               with open(lowerCAmelCase__    ,			'w'    ,			encoding='utf-8'			) as fp:
                      for token in self.fairseq_tokens_to_ids:
                             if token not in self.all_special_tokens:
                                    fp.write(F'{str(lowerCAmelCase__			)} \n'			)

        return out_vocab_file, out_monolingual_vocab_file






import json
import os
import unittest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip import VOCAB_FILES_NAMES
from transformers.testing_utils import require_ftfy, require_tokenizers

from ...test_tokenization_common import TokenizerTesterMixin





@require_tokenizers
class   __a      (   __UpperCamelCase	,	unittest.TestCase				):
 __lowercase			:							Optional[int]       					=			CLIPTokenizer
 __lowercase			:							str       					=			CLIPTokenizerFast
 __lowercase			:							Tuple       					=			True
 __lowercase			:							str       					=			{}
 __lowercase			:							Dict       					=			False
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    int:




        '''simple docstring'''
        super().setUp()

        # fmt: off
        lowercase__:       str        =       ['l', 'o', 'w', 'e', 'r', 's', 't', 'i', 'd', 'n', 'lo', 'l</w>', 'w</w>', 'r</w>', 't</w>', 'low</w>', 'er</w>', 'lowest</w>', 'newer</w>', 'wider', '<unk>', '<|startoftext|>', '<|endoftext|>']
        # fmt: on
        lowercase__:       List[str]        =       dict(zip(lowerCAmelCase__    ,			range(len(lowerCAmelCase__			)			)			)			)
        lowercase__:       int        =       ['#version: 0.2', 'l o', 'lo w</w>', 'e r</w>']
        lowercase__:       Optional[int]        =       {'unk_token': '<unk>'}

        lowercase__:       int        =       os.path.join(self.tmpdirname    ,			VOCAB_FILES_NAMES['vocab_file']			)
        lowercase__:       Union[str, Any]        =       os.path.join(self.tmpdirname    ,			VOCAB_FILES_NAMES['merges_file']			)
        with open(self.vocab_file    ,			'w'    ,			encoding='utf-8'			) as fp:
               fp.write(json.dumps(lowerCAmelCase__			) + '\n'			)
        with open(self.merges_file    ,			'w'    ,			encoding='utf-8'			) as fp:
               fp.write('\n'.join(lowerCAmelCase__			)			)
 def 		SCREAMING_SNAKE_CASE__       (       self    ,			**lowerCAmelCase__			) ->    List[str]:




        '''simple docstring'''
        kwargs.update(self.special_tokens_map			)
        return CLIPTokenizer.from_pretrained(self.tmpdirname    ,			**lowerCAmelCase__			)
 def 		SCREAMING_SNAKE_CASE__       (       self    ,			**lowerCAmelCase__			) ->    Optional[int]:




        '''simple docstring'''
        kwargs.update(self.special_tokens_map			)
        return CLIPTokenizerFast.from_pretrained(self.tmpdirname    ,			**lowerCAmelCase__			)
 def 		SCREAMING_SNAKE_CASE__       (       self    ,			lowerCAmelCase__			) ->    Union[str, Any]:




        '''simple docstring'''
        lowercase__:       Dict        =       'lower newer'
        lowercase__:       Dict        =       'lower newer'
        return input_text, output_text
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    List[Any]:




        '''simple docstring'''
        lowercase__:       Union[str, Any]        =       CLIPTokenizer(self.vocab_file    ,			self.merges_file    ,			**self.special_tokens_map			)
        lowercase__:       Dict        =       'lower newer'
        lowercase__:       Union[str, Any]        =       ['lo', 'w', 'er</w>', 'n', 'e', 'w', 'er</w>']
        lowercase__:       Any        =       tokenizer.tokenize(lowerCAmelCase__			)
        self.assertListEqual(lowerCAmelCase__    ,			lowerCAmelCase__			)

        lowercase__:       Tuple        =       tokens + [tokenizer.unk_token]
        lowercase__:       Tuple        =       [10, 2, 16, 9, 3, 2, 16, 20]
        self.assertListEqual(tokenizer.convert_tokens_to_ids(lowerCAmelCase__			)    ,			lowerCAmelCase__			)
 @require_ftfy
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    Tuple:




        '''simple docstring'''
        for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
               with self.subTest(F'{tokenizer.__class__.__name__} ({pretrained_name})'			):
                      lowercase__:       List[str]        =       self.tokenizer_class.from_pretrained(lowerCAmelCase__    ,			**lowerCAmelCase__			)
                      lowercase__:       Optional[int]        =       self.rust_tokenizer_class.from_pretrained(lowerCAmelCase__    ,			**lowerCAmelCase__			)

                      lowercase__:       Optional[int]        =       'A\n\'ll 11p223RF☆ho!!to?\'d\'d\'\'d of a cat to-$\'\'d.'
                      lowercase__:       Optional[Any]        =       tokenizer_s.tokenize(lowerCAmelCase__			)
                      lowercase__:       Dict        =       tokenizer_r.tokenize(lowerCAmelCase__			)

                      self.assertListEqual(lowerCAmelCase__    ,			lowerCAmelCase__			)

                      # Test that the tokenization is identical on an example containing a character (Latin Small Letter A
                      # with Tilde) encoded in 2 different ways
                      lowercase__:       Dict        =       'xa\u0303y' + ' ' + 'x\xe3y'
                      lowercase__:       Tuple        =       tokenizer_s.tokenize(lowerCAmelCase__			)
                      lowercase__:       int        =       tokenizer_r.tokenize(lowerCAmelCase__			)

                      self.assertListEqual(lowerCAmelCase__    ,			lowerCAmelCase__			)

                      # Test that the tokenization is identical on unicode of space type
                      lowercase__:       str        =       [
                          '\u0009',  # (horizontal tab, '\t')
                          '\u000B',  # (vertical tab)
                          '\u000C',  # (form feed)
                          '\u0020',  # (space, ' ')
                          '\u200E',  # (left-to-right mark):w
                          '\u200F',  # (right-to-left mark)
                      ]
                      for unicode_seq in spaces_unicodes:
                             lowercase__:       Optional[Any]        =       tokenizer_s.tokenize(lowerCAmelCase__			)
                             lowercase__:       Tuple        =       tokenizer_r.tokenize(lowerCAmelCase__			)

                             self.assertListEqual(lowerCAmelCase__    ,			lowerCAmelCase__			)

                      # Test that the tokenization is identical on unicode of line break type
                      lowercase__:       str        =       [
                          '\u000A',  # (line feed, '\n')
                          '\r\n',  # (carriage return and line feed, '\r\n')
                          '\u000D',  # (carriage return, '\r')
                          '\r',  # (carriage return, '\r')
                          '\u000D',  # (carriage return, '\r')
                          '\u2028',  # (line separator)
                          '\u2029',  # (paragraph separator)
                          # "\u0085", # (next line)
                      ]

                      # The tokenization is not identical for the character "\u0085" (next line). The slow version using ftfy transforms
                      # it into the Horizontal Ellipsis character "…" ("\u2026") while the fast version transforms it into a
                      # space (and thus into an empty list).

                      for unicode_seq in line_break_unicodes:
                             lowercase__:       Optional[int]        =       tokenizer_s.tokenize(lowerCAmelCase__			)
                             lowercase__:       Optional[int]        =       tokenizer_r.tokenize(lowerCAmelCase__			)

                             self.assertListEqual(lowerCAmelCase__    ,			lowerCAmelCase__			)
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    Optional[int]:




        '''simple docstring'''
        # Test which aims to verify that the offsets are well adapted to the argument `add_prefix_space`
        for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
               with self.subTest(F'{tokenizer.__class__.__name__} ({pretrained_name})'			):
                      lowercase__:       Optional[int]        =       'hello'  # `hello` is a token in the vocabulary of `pretrained_name`
                      lowercase__:       Optional[int]        =       F'{text_of_1_token} {text_of_1_token}'

                      lowercase__:       int        =       self.rust_tokenizer_class.from_pretrained(
                          lowerCAmelCase__    ,			use_fast=lowerCAmelCase__    ,			)
                      lowercase__:       Dict        =       tokenizer_r(lowerCAmelCase__    ,			return_offsets_mapping=lowerCAmelCase__    ,			add_special_tokens=lowerCAmelCase__			)
                      self.assertEqual(encoding.offset_mapping[0]    ,			(0, len(lowerCAmelCase__			))			)
                      self.assertEqual(
                          encoding.offset_mapping[1]    ,			(len(lowerCAmelCase__			) + 1, len(lowerCAmelCase__			) + 1 + len(lowerCAmelCase__			))    ,			)

                      lowercase__:       Any        =       F' {text}'

                      lowercase__:       Union[str, Any]        =       self.rust_tokenizer_class.from_pretrained(
                          lowerCAmelCase__    ,			use_fast=lowerCAmelCase__    ,			)
                      lowercase__:       int        =       tokenizer_r(lowerCAmelCase__    ,			return_offsets_mapping=lowerCAmelCase__    ,			add_special_tokens=lowerCAmelCase__			)
                      self.assertEqual(encoding.offset_mapping[0]    ,			(1, 1 + len(lowerCAmelCase__			))			)
                      self.assertEqual(
                          encoding.offset_mapping[1]    ,			(1 + len(lowerCAmelCase__			) + 1, 1 + len(lowerCAmelCase__			) + 1 + len(lowerCAmelCase__			))    ,			)
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    List[str]:




        '''simple docstring'''
        # Test related to the breaking change introduced in transformers v4.17.0
        # We need to check that an error in raised when the user try to load a previous version of the tokenizer.
        with self.assertRaises(lowerCAmelCase__			) as context:
               self.rust_tokenizer_class.from_pretrained('robot-test/old-clip-tokenizer'			)

        self.assertTrue(
            context.exception.args[0].startswith(
                'The `backend_tokenizer` provided does not match the expected format.'			)			)
 @require_ftfy
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    List[Any]:




        '''simple docstring'''
        super().test_tokenization_python_rust_equals()
 def 		SCREAMING_SNAKE_CASE__       (       self			) ->    Tuple:




        '''simple docstring'''
        # CLIP always lower cases letters
        pass


