


from __future__ import annotations

from typing import Any



class    UpperCAmelCase_	:
       '''simple docstring'''






       def __init__(     self ,					__SCREAMING_SNAKE_CASE = 6						):




              """simple docstring"""




              a_    :	int   	=		None
              a_    :	int   	=		None
              self.create_linked_list(__A						)






       def  _lowercase   (     self ,					__SCREAMING_SNAKE_CASE						):




              """simple docstring"""




              a_    :	Any   	=		Node()
              a_    :	Dict   	=		current_node
              a_    :	List[str]   	=		current_node
              a_    :	int   	=		current_node
              for _ in range(1 ,					__A						):
                     a_    :	Tuple   	=		Node()
                     a_    :	Optional[int]   	=		current_node
                     a_    :	int   	=		previous_node
                     a_    :	Optional[Any]   	=		current_node
              a_    :	Any   	=		self.front
              a_    :	Optional[int]   	=		previous_node






       def  _lowercase   (     self						):




              """simple docstring"""




              return (
                  self.front == self.rear
                  and self.front is not None
                  and self.front.data is None
              )






       def  _lowercase   (     self						):




              """simple docstring"""




              self.check_can_perform_operation()
              return self.front.data if self.front else None






       def  _lowercase   (     self ,					__SCREAMING_SNAKE_CASE						):




              """simple docstring"""




              if self.rear is None:
                     return

              self.check_is_full()
              if not self.is_empty():
                     a_    :	List[str]   	=		self.rear.next
              if self.rear:
                     a_    :	List[str]   	=		data






       def  _lowercase   (     self						):




              """simple docstring"""




              self.check_can_perform_operation()
              if self.rear is None or self.front is None:
                     return None
              if self.front == self.rear:
                     a_    :	List[str]   	=		self.front.data
                     a_    :	Union[str, Any]   	=		None
                     return data

              a_    :	Any   	=		self.front
              a_    :	List[Any]   	=		old_front.next
              a_    :	Union[str, Any]   	=		old_front.data
              a_    :	Optional[Any]   	=		None
              return data






       def  _lowercase   (     self						):




              """simple docstring"""




              if self.is_empty():
                     raise Exception('''Empty Queue'''						)






       def  _lowercase   (     self						):




              """simple docstring"""




              if self.rear and self.rear.next == self.front:
                     raise Exception('''Full Queue'''						)




class    UpperCAmelCase_	:
       '''simple docstring'''






       def __init__(     self						):




              """simple docstring"""




              a_    :	Optional[Any]   	=		None
              a_    :	int   	=		None
              a_    :	Tuple   	=		None


if __name__ == "__main__":
  import doctest

  doctest.testmod()





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


__UpperCAmelCase : Dict 			=				logging.get_logger(__name__)

__UpperCAmelCase : Optional[Any] 			=				{"vocab_file": "vocab.txt", "tokenizer_file": "tokenizer.json"}

__UpperCAmelCase : Dict 			=				{
    "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"
        ),
    }
}

__UpperCAmelCase : Tuple 			=				{
    "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,
}


__UpperCAmelCase : Any 			=				{
    "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    UpperCAmelCase_	(							_a):
       '''simple docstring'''
       __UpperCamelCase      :     str							=					VOCAB_FILES_NAMES
       __UpperCamelCase      :     Optional[int]							=					PRETRAINED_VOCAB_FILES_MAP
       __UpperCamelCase      :     Union[str, Any]							=					PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
       __UpperCamelCase      :     int							=					PRETRAINED_INIT_CONFIGURATION
       __UpperCamelCase      :     Any							=					RoFormerTokenizer






       def __init__(     self ,					__SCREAMING_SNAKE_CASE=None ,					__SCREAMING_SNAKE_CASE=None ,					__SCREAMING_SNAKE_CASE=True ,					__SCREAMING_SNAKE_CASE="[UNK]" ,					__SCREAMING_SNAKE_CASE="[SEP]" ,					__SCREAMING_SNAKE_CASE="[PAD]" ,					__SCREAMING_SNAKE_CASE="[CLS]" ,					__SCREAMING_SNAKE_CASE="[MASK]" ,					__SCREAMING_SNAKE_CASE=True ,					__SCREAMING_SNAKE_CASE=None ,					**__SCREAMING_SNAKE_CASE ,					):




              """simple docstring"""




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

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

              UpperCamelCase    :	List[Any]   	=		do_lower_case






       def __getstate__(     self						):




              """simple docstring"""




              UpperCamelCase    :	Optional[int]   	=		self.__dict__.copy()
              UpperCamelCase    :	Any   	=		BertPreTokenizer()
              return state






       def __setstate__(     self ,					__SCREAMING_SNAKE_CASE						):




              """simple docstring"""




              UpperCamelCase    :	Any   	=		d
              UpperCamelCase    :	List[str]   	=		self.__dict__['''_tokenizer'''].get_vocab()
              UpperCamelCase    :	Any   	=		PreTokenizer.custom(JiebaPreTokenizer(__SCREAMING_SNAKE_CASE						)						)






       def  _lowercase   (     self ,					__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE=None						):




              """simple docstring"""




              UpperCamelCase    :	Any   	=		[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  _lowercase   (     self ,					__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE = None						):




              """simple docstring"""




              UpperCamelCase    :	Dict   	=		[self.sep_token_id]
              UpperCamelCase    :	int   	=		[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 ,					__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE = None						):




              """simple docstring"""




              UpperCamelCase    :	List[Any]   	=		self._tokenizer.model.save(__SCREAMING_SNAKE_CASE ,					name=__SCREAMING_SNAKE_CASE						)
              return tuple(__SCREAMING_SNAKE_CASE						)






       def  _lowercase   (     self ,					__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE=None ,					__SCREAMING_SNAKE_CASE=None ,					__SCREAMING_SNAKE_CASE=False ,					**__SCREAMING_SNAKE_CASE ,					):




              """simple docstring"""




              UpperCamelCase    :	Any   	=		BertPreTokenizer()
              return super().save_pretrained(__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE ,					__SCREAMING_SNAKE_CASE ,					**__SCREAMING_SNAKE_CASE						)

