





from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tf_available, is_torch_available


A__:    List[Any]  	=	{'''configuration_swin''': ['''SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''SwinConfig''', '''SwinOnnxConfig''']}


try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   A__:    int  	=	[
       '''SWIN_PRETRAINED_MODEL_ARCHIVE_LIST''',
       '''SwinForImageClassification''',
       '''SwinForMaskedImageModeling''',
       '''SwinModel''',
       '''SwinPreTrainedModel''',
       '''SwinBackbone''',
   ]

try:
   if not is_tf_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   A__:    List[str]  	=	[
       '''TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST''',
       '''TFSwinForImageClassification''',
       '''TFSwinForMaskedImageModeling''',
       '''TFSwinModel''',
       '''TFSwinPreTrainedModel''',
   ]

if TYPE_CHECKING:
   from .configuration_swin import SWIN_PRETRAINED_CONFIG_ARCHIVE_MAP, SwinConfig, SwinOnnxConfig

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_swin import (
          SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
          SwinBackbone,
          SwinForImageClassification,
          SwinForMaskedImageModeling,
          SwinModel,
          SwinPreTrainedModel,
      )

   try:
      if not is_tf_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tf_swin import (
          TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFSwinForImageClassification,
          TFSwinForMaskedImageModeling,
          TFSwinModel,
          TFSwinPreTrainedModel,
      )

else:
   import sys

   A__:    Optional[Any]  	=	_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)








import json
from typing import List, Optional, Tuple

from tokenizers import normalizers
from tokenizers.pre_tokenizers import BertPreTokenizer, PreTokenizer

from ...tokenization_utils_fast import PreTrainedTokenizerFast
from ...utils import logging
from .tokenization_roformer import RoFormerTokenizer
from .tokenization_utils import JiebaPreTokenizer


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

A__:    str  	=	{'''vocab_file''': '''vocab.txt''', '''tokenizer_file''': '''tokenizer.json'''}

A__:    List[Any]  	=	{
    '''vocab_file''': {
        '''junnyu/roformer_chinese_small''': '''https://huggingface.co/junnyu/roformer_chinese_small/resolve/main/vocab.txt''',
        '''junnyu/roformer_chinese_base''': '''https://huggingface.co/junnyu/roformer_chinese_base/resolve/main/vocab.txt''',
        '''junnyu/roformer_chinese_char_small''': (
            '''https://huggingface.co/junnyu/roformer_chinese_char_small/resolve/main/vocab.txt'''
        ),
        '''junnyu/roformer_chinese_char_base''': (
            '''https://huggingface.co/junnyu/roformer_chinese_char_base/resolve/main/vocab.txt'''
        ),
        '''junnyu/roformer_small_discriminator''': (
            '''https://huggingface.co/junnyu/roformer_small_discriminator/resolve/main/vocab.txt'''
        ),
        '''junnyu/roformer_small_generator''': (
            '''https://huggingface.co/junnyu/roformer_small_generator/resolve/main/vocab.txt'''
        ),
    }
}

A__:    str  	=	{
    '''junnyu/roformer_chinese_small''': 1536,
    '''junnyu/roformer_chinese_base''': 1536,
    '''junnyu/roformer_chinese_char_small''': 512,
    '''junnyu/roformer_chinese_char_base''': 512,
    '''junnyu/roformer_small_discriminator''': 128,
    '''junnyu/roformer_small_generator''': 128,
}


A__:    int  	=	{
    '''junnyu/roformer_chinese_small''': {'''do_lower_case''': True},
    '''junnyu/roformer_chinese_base''': {'''do_lower_case''': True},
    '''junnyu/roformer_chinese_char_small''': {'''do_lower_case''': True},
    '''junnyu/roformer_chinese_char_base''': {'''do_lower_case''': True},
    '''junnyu/roformer_small_discriminator''': {'''do_lower_case''': True},
    '''junnyu/roformer_small_generator''': {'''do_lower_case''': True},
}




class        _a    (    UpperCamelCase__):

      """simple docstring"""


      UpperCamelCase__  		=       VOCAB_FILES_NAMES
      UpperCamelCase__  		=       PRETRAINED_VOCAB_FILES_MAP
      UpperCamelCase__  		=       PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
      UpperCamelCase__  		=       PRETRAINED_INIT_CONFIGURATION
      UpperCamelCase__  		=       RoFormerTokenizer






      def __init__(		self:			int	,    __lowerCamelCase:			Optional[Any]=None	,    __lowerCamelCase:			Any=None	,    __lowerCamelCase:			str=True	,    __lowerCamelCase:			Any="[UNK]"	,    __lowerCamelCase:			int="[SEP]"	,    __lowerCamelCase:			Optional[int]="[PAD]"	,    __lowerCamelCase:			Optional[int]="[CLS]"	,    __lowerCamelCase:			Tuple="[MASK]"	,    __lowerCamelCase:			List[str]=True	,    __lowerCamelCase:			List[Any]=None	,    **__lowerCamelCase:			Dict	,    ):
          '''simple docstring'''


          super().__init__(
              __lowerCamelCase	,    tokenizer_file=__lowerCamelCase	,    do_lower_case=__lowerCamelCase	,    unk_token=__lowerCamelCase	,    sep_token=__lowerCamelCase	,    pad_token=__lowerCamelCase	,    cls_token=__lowerCamelCase	,    mask_token=__lowerCamelCase	,    tokenize_chinese_chars=__lowerCamelCase	,    strip_accents=__lowerCamelCase	,    **__lowerCamelCase	,    )

          UpperCamelCase__:	int					=     json.loads(self.backend_tokenizer.normalizer.__getstate__()					)
          if (
              pre_tok_state.get("lowercase"	,    __lowerCamelCase					) != do_lower_case
              or pre_tok_state.get("strip_accents"	,    __lowerCamelCase					) != strip_accents
          ):
              UpperCamelCase__:	int					=     getattr(__lowerCamelCase	,    pre_tok_state.pop("type"					)					)
              UpperCamelCase__:	Any					=     do_lower_case
              UpperCamelCase__:	Optional[int]					=     strip_accents
              UpperCamelCase__:	Any					=     pre_tok_class(**__lowerCamelCase					)

          UpperCamelCase__:	Tuple					=     do_lower_case






      def __getstate__(		self:			Optional[int]					):
          '''simple docstring'''


          UpperCamelCase__:	List[Any]					=     self.__dict__.copy()
          UpperCamelCase__:	Dict					=     BertPreTokenizer()
          return state






      def __setstate__(		self:			Dict	,    __lowerCamelCase:			Optional[Any]					):
          '''simple docstring'''


          UpperCamelCase__:	str					=     d
          UpperCamelCase__:	List[Any]					=     self.__dict__["_tokenizer"].get_vocab()
          UpperCamelCase__:	str					=     PreTokenizer.custom(JiebaPreTokenizer(__lowerCamelCase					)					)






      def 			UpperCAmelCase_       (		self:			int	,    __lowerCamelCase:			Optional[int]	,    __lowerCamelCase:			Dict=None					):
          '''simple docstring'''


          UpperCamelCase__:	int					=     [self.cls_token_id] + token_ids_a + [self.sep_token_id]

          if token_ids_a:
              output += token_ids_a + [self.sep_token_id]

          return output






      def 			UpperCAmelCase_       (		self:			Optional[int]	,    __lowerCamelCase:			List[int]	,    __lowerCamelCase:			Optional[List[int]] = None					):
          '''simple docstring'''


          UpperCamelCase__:	Tuple					=     [self.sep_token_id]
          UpperCamelCase__:	str					=     [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 			UpperCAmelCase_       (		self:			Tuple	,    __lowerCamelCase:			str	,    __lowerCamelCase:			Optional[str] = None					):
          '''simple docstring'''


          UpperCamelCase__:	Dict					=     self._tokenizer.model.save(__lowerCamelCase	,    name=__lowerCamelCase					)
          return tuple(__lowerCamelCase					)






      def 			UpperCAmelCase_       (		self:			Dict	,    __lowerCamelCase:			Any	,    __lowerCamelCase:			Any=None	,    __lowerCamelCase:			Dict=None	,    __lowerCamelCase:			List[str]=False	,    **__lowerCamelCase:			int	,    ):
          '''simple docstring'''


          UpperCamelCase__:	List[str]					=     BertPreTokenizer()
          return super().save_pretrained(__lowerCamelCase	,    __lowerCamelCase	,    __lowerCamelCase	,    __lowerCamelCase	,    **__lowerCamelCase					)

