





import os
import unicodedata
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


_A					:				Tuple				=			logging.get_logger(__name__)
_A					:				Optional[int]				=			{"""vocab_file""": """spiece.model"""}

_A					:				List[Any]				=			{
    """vocab_file""": {
        """albert-base-v1""": """https://huggingface.co/albert-base-v1/resolve/main/spiece.model""",
        """albert-large-v1""": """https://huggingface.co/albert-large-v1/resolve/main/spiece.model""",
        """albert-xlarge-v1""": """https://huggingface.co/albert-xlarge-v1/resolve/main/spiece.model""",
        """albert-xxlarge-v1""": """https://huggingface.co/albert-xxlarge-v1/resolve/main/spiece.model""",
        """albert-base-v2""": """https://huggingface.co/albert-base-v2/resolve/main/spiece.model""",
        """albert-large-v2""": """https://huggingface.co/albert-large-v2/resolve/main/spiece.model""",
        """albert-xlarge-v2""": """https://huggingface.co/albert-xlarge-v2/resolve/main/spiece.model""",
        """albert-xxlarge-v2""": """https://huggingface.co/albert-xxlarge-v2/resolve/main/spiece.model""",
    }
}

_A					:				Tuple				=			{
    """albert-base-v1""": 5_12,
    """albert-large-v1""": 5_12,
    """albert-xlarge-v1""": 5_12,
    """albert-xxlarge-v1""": 5_12,
    """albert-base-v2""": 5_12,
    """albert-large-v2""": 5_12,
    """albert-xlarge-v2""": 5_12,
    """albert-xxlarge-v2""": 5_12,
}

_A					:				Optional[Any]				=			"""▁"""



class 					__snake_case	(  __SCREAMING_SNAKE_CASE    ):


    '''simple docstring'''







    lowerCamelCase__    :		Dict				=	VOCAB_FILES_NAMES
    lowerCamelCase__    :		Optional[Any]				=	PRETRAINED_VOCAB_FILES_MAP
    lowerCamelCase__    :		List[Any]				=	PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES



    def __init__(       self   ,				A_   ,				A_=True   ,				A_=True   ,				A_=False   ,				A_="[CLS]"   ,				A_="[SEP]"   ,				A_="<unk>"   ,				A_="[SEP]"   ,				A_="<pad>"   ,				A_="[CLS]"   ,				A_="[MASK]"   ,				A_ = None   ,				**A_   ,				):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			(
            AddedToken(A_   ,				lstrip=A_   ,				rstrip=A_   ,				normalized=A_     )
            if isinstance(A_   ,				A_     )
            else mask_token
        )

        SCREAMING_SNAKE_CASE__											=			{} if sp_model_kwargs is None else sp_model_kwargs

        super().__init__(
            do_lower_case=A_   ,				remove_space=A_   ,				keep_accents=A_   ,				bos_token=A_   ,				eos_token=A_   ,				unk_token=A_   ,				sep_token=A_   ,				pad_token=A_   ,				cls_token=A_   ,				mask_token=A_   ,				sp_model_kwargs=self.sp_model_kwargs   ,				**A_   ,				)

        SCREAMING_SNAKE_CASE__											=			do_lower_case
        SCREAMING_SNAKE_CASE__											=			remove_space
        SCREAMING_SNAKE_CASE__											=			keep_accents
        SCREAMING_SNAKE_CASE__											=			vocab_file

        SCREAMING_SNAKE_CASE__											=			spm.SentencePieceProcessor(**self.sp_model_kwargs     )
        self.sp_model.Load(A_     )



    @property
    def  lowercase_					(       self     ):





        '''simple docstring'''

        return len(self.sp_model     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			{self.convert_ids_to_tokens(A_     ): i for i in range(self.vocab_size     )}
        vocab.update(self.added_tokens_encoder     )
        return vocab



    def __getstate__(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.__dict__.copy()
        SCREAMING_SNAKE_CASE__											=			None
        return state



    def __setstate__(       self   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			d

        # for backward compatibility
        if not hasattr(self   ,				'''sp_model_kwargs'''     ):
            SCREAMING_SNAKE_CASE__											=			{}

        SCREAMING_SNAKE_CASE__											=			spm.SentencePieceProcessor(**self.sp_model_kwargs     )
        self.sp_model.Load(self.vocab_file     )



    def  lowercase_					(       self   ,				A_     ):





        '''simple docstring'''

        if self.remove_space:
            SCREAMING_SNAKE_CASE__											=			''' '''.join(inputs.strip().split()     )
        else:
            SCREAMING_SNAKE_CASE__											=			inputs
        SCREAMING_SNAKE_CASE__											=			outputs.replace('''``'''   ,				'''"'''     ).replace('''\'\''''   ,				'''"'''     )

        if not self.keep_accents:
            SCREAMING_SNAKE_CASE__											=			unicodedata.normalize('''NFKD'''   ,				A_     )
            SCREAMING_SNAKE_CASE__											=			''''''.join([c for c in outputs if not unicodedata.combining(A_     )]     )
        if self.do_lower_case:
            SCREAMING_SNAKE_CASE__											=			outputs.lower()

        return outputs



    def  lowercase_					(       self   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.preprocess_text(A_     )
        SCREAMING_SNAKE_CASE__											=			self.sp_model.encode(A_   ,				out_type=A_     )
        SCREAMING_SNAKE_CASE__											=			[]
        for piece in pieces:
            if len(A_     ) > 1 and piece[-1] == str(''','''     ) and piece[-2].isdigit():
                SCREAMING_SNAKE_CASE__											=			self.sp_model.EncodeAsPieces(piece[:-1].replace(A_   ,				''''''     )     )
                if piece[0] != SPIECE_UNDERLINE and cur_pieces[0][0] == SPIECE_UNDERLINE:
                    if len(cur_pieces[0]     ) == 1:
                        SCREAMING_SNAKE_CASE__											=			cur_pieces[1:]
                    else:
                        SCREAMING_SNAKE_CASE__											=			cur_pieces[0][1:]
                cur_pieces.append(piece[-1]     )
                new_pieces.extend(A_     )
            else:
                new_pieces.append(A_     )

        return new_pieces



    def  lowercase_					(       self   ,				A_     ):





        '''simple docstring'''

        return self.sp_model.PieceToId(A_     )



    def  lowercase_					(       self   ,				A_     ):





        '''simple docstring'''

        return self.sp_model.IdToPiece(A_     )



    def  lowercase_					(       self   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			[]
        SCREAMING_SNAKE_CASE__											=			''''''
        SCREAMING_SNAKE_CASE__											=			False
        for token in tokens:
            # make sure that special tokens are not decoded using sentencepiece model
            if token in self.all_special_tokens:
                if not prev_is_special:
                    out_string += " "
                out_string += self.sp_model.decode(A_     ) + token
                SCREAMING_SNAKE_CASE__											=			True
                SCREAMING_SNAKE_CASE__											=			[]
            else:
                current_sub_tokens.append(A_     )
                SCREAMING_SNAKE_CASE__											=			False
        out_string += self.sp_model.decode(A_     )
        return out_string.strip()



    def  lowercase_					(       self   ,				A_   ,				A_ = None     ):





        '''simple docstring'''

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



    def  lowercase_					(       self   ,				A_   ,				A_ = None   ,				A_ = False     ):





        '''simple docstring'''

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

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



    def  lowercase_					(       self   ,				A_   ,				A_ = None     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			[self.sep_token_id]
        SCREAMING_SNAKE_CASE__											=			[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  lowercase_					(       self   ,				A_   ,				A_ = None     ):





        '''simple docstring'''

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

        if os.path.abspath(self.vocab_file     ) != os.path.abspath(A_     ) and os.path.isfile(self.vocab_file     ):
            copyfile(self.vocab_file   ,				A_     )
        elif not os.path.isfile(self.vocab_file     ):
            with open(A_   ,				'''wb'''     ) as fi:
                SCREAMING_SNAKE_CASE__											=			self.sp_model.serialized_model_proto()
                fi.write(A_     )

        return (out_vocab_file,)



'''simple docstring'''




from ...configuration_utils import PretrainedConfig
from ...utils import logging


_a					:			str							=    logging.get_logger(__name__)

_a					:			Dict							=    {
    'microsoft/cvt-13': 'https://huggingface.co/microsoft/cvt-13/resolve/main/config.json',
    # See all Cvt models at https://huggingface.co/models?filter=cvt
}



class 							lowercase_						(		a			):

  '''simple docstring'''





  __lowerCAmelCase       :			List[Any]     	= "cvt"
  def __init__(  self ,			a_=3 ,			a_=[7, 3, 3] ,			a_=[4, 2, 2] ,			a_=[2, 1, 1] ,			a_=[6_4, 1_9_2, 3_8_4] ,			a_=[1, 3, 6] ,			a_=[1, 2, 1_0] ,			a_=[4.0, 4.0, 4.0] ,			a_=[0.0, 0.0, 0.0] ,			a_=[0.0, 0.0, 0.0] ,			a_=[0.0, 0.0, 0.1] ,			a_=[True, True, True] ,			a_=[False, False, True] ,			a_=["dw_bn", "dw_bn", "dw_bn"] ,			a_=[3, 3, 3] ,			a_=[1, 1, 1] ,			a_=[2, 2, 2] ,			a_=[1, 1, 1] ,			a_=[1, 1, 1] ,			a_=0.02 ,			a_=1E-12 ,			**a_ ,			)				->					Union[str, Any]:


    """simple docstring"""
    super().__init__(**a_  )
    UpperCAmelCase    				=						num_channels
    UpperCAmelCase    				=						patch_sizes
    UpperCAmelCase    				=						patch_stride
    UpperCAmelCase    				=						patch_padding
    UpperCAmelCase    				=						embed_dim
    UpperCAmelCase    				=						num_heads
    UpperCAmelCase    				=						depth
    UpperCAmelCase    				=						mlp_ratio
    UpperCAmelCase    				=						attention_drop_rate
    UpperCAmelCase    				=						drop_rate
    UpperCAmelCase    				=						drop_path_rate
    UpperCAmelCase    				=						qkv_bias
    UpperCAmelCase    				=						cls_token
    UpperCAmelCase    				=						qkv_projection_method
    UpperCAmelCase    				=						kernel_qkv
    UpperCAmelCase    				=						padding_kv
    UpperCAmelCase    				=						stride_kv
    UpperCAmelCase    				=						padding_q
    UpperCAmelCase    				=						stride_q
    UpperCAmelCase    				=						initializer_range
    UpperCAmelCase    				=						layer_norm_eps


