


'''simple docstring'''



import collections
import json
import os
import re
from typing import TYPE_CHECKING, List, Optional, Tuple

import numpy as np

from ...tokenization_utils_fast import PreTrainedTokenizer
from ...utils import logging


if TYPE_CHECKING:
      from transformers.pipelines.conversational import Conversation


A__						:   Optional[int]				=    logging.get_logger(__name__)

A__						:   int				=    {"""vocab_file""": """vocab.txt""", """emoji_file""": """emoji.json"""}

A__						:   int				=    {
    """vocab_file""": {
        """abeja/gpt-neox-japanese-2.7b""": """https://huggingface.co/abeja/gpt-neox-japanese-2.7b/resolve/main/vocab.txt""",
    },
    """emoji_file""": {
        """abeja/gpt-neox-japanese-2.7b""": """https://huggingface.co/abeja/gpt-neox-japanese-2.7b/resolve/main/emoji.json""",
    },
}

A__						:   List[Any]				=    {
    """abeja/gpt-neox-japanese-2.7b""": 2048,
}



def      UpperCAmelCase__   (      UpperCAmelCase_       :							Optional[Any] ,       UpperCAmelCase_       :							Tuple				)	->						int:
     with open(UpperCAmelCase_ ,       'r' ,       encoding='utf-8'				) as f:
          __lowerCamelCase  :      Optional[int]														=						json.loads(f.read()				)

     __lowerCamelCase  :      Union[str, Any]														=						collections.OrderedDict()
     __lowerCamelCase  :      Union[str, Any]														=						collections.OrderedDict()
     __lowerCamelCase  :      Optional[Any]														=						collections.OrderedDict()
     with open(UpperCAmelCase_ ,       'r' ,       encoding='utf-8'				) as f:
          __lowerCamelCase  :      Any														=						f.readlines()
     __lowerCamelCase  :      Tuple														=						[[t.rstrip('\n'				)] if (t == ',' or ',' not in t) else t.rstrip('\n'				).split(','				) for t in token]
     for idx, b in enumerate(UpperCAmelCase_				):
          __lowerCamelCase  :      int														=						b
          __lowerCamelCase  :      Any														=						idx
          for wd in b:
               __lowerCamelCase  :      Union[str, Any]														=						idx

     return vocab, raw_vocab, ids_to_tokens, emoji





class   UpperCAmelCase_    (_UpperCAmelCase    ):





    """simple docstring"""






    lowerCamelCase    :   List[str]					=     VOCAB_FILES_NAMES
    lowerCamelCase    :   Tuple					=     PRETRAINED_VOCAB_FILES_MAP
    lowerCamelCase    :   Union[str, Any]					=     PRETRAINED_POSITIONAL_EMBEDDINGS_SIZES
    lowerCamelCase    :   Union[str, Any]					=     ['input_ids', 'attention_mask']







    def __init__(				self     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_="<|endoftext|>"     ,	SCREAMING_SNAKE_CASE_="<|endoftext|>"     ,	SCREAMING_SNAKE_CASE_="<|startoftext|>"     ,	SCREAMING_SNAKE_CASE_="<|endoftext|>"     ,	SCREAMING_SNAKE_CASE_=False     ,	**SCREAMING_SNAKE_CASE_     ,	)							->	Tuple:
         super().__init__(
             unk_token=SCREAMING_SNAKE_CASE_     ,	pad_token=SCREAMING_SNAKE_CASE_     ,	bos_token=SCREAMING_SNAKE_CASE_     ,	eos_token=SCREAMING_SNAKE_CASE_     ,	do_clean_text=SCREAMING_SNAKE_CASE_     ,	**SCREAMING_SNAKE_CASE_     ,	)
         if not os.path.isfile(SCREAMING_SNAKE_CASE_      ):
              raise ValueError(
                  f'Can\'t find a vocabulary file at path \'{vocab_file}\'. To load the vocabulary from a Google pretrained'
                  ' model use `tokenizer = GPTNeoXJapaneseokenizer.from_pretrained(PRETRAINED_MODEL_NAME)`'      )
         if not os.path.isfile(SCREAMING_SNAKE_CASE_      ):
              raise ValueError(
                  f'Can\'t find a emoji file at path \'{emoji_file}\'. To load the emoji information from a Google'
                  ' pretrained model use `tokenizer = GPTNeoXJapaneseokenizer.from_pretrained(PRETRAINED_MODEL_NAME)`'      )
         __lowerCamelCase  :      int														=						do_clean_text
         __lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase  :      List[Any]														=						load_vocab_and_emoji(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )
         __lowerCamelCase  :      Union[str, Any]														=						SubWordJapaneseTokenizer(
             vocab=self.vocab     ,	ids_to_tokens=self.ids_to_tokens     ,	emoji=self.emoji      )







    @property
    def  lowercase_							(				self      )							->	List[str]:
         # self.vocab contains support for character fluctuation unique to Japanese, and has a large number of vocab
         return len(self.raw_vocab      )







    def  lowercase_							(				self      )							->	Any:
         return dict(self.raw_vocab     ,	**self.added_tokens_encoder      )







    def  lowercase_							(				self     ,	SCREAMING_SNAKE_CASE_      )							->	Optional[int]:
         return self.subword_tokenizer.tokenize(SCREAMING_SNAKE_CASE_     ,	clean=self.do_clean_text      )







    def  lowercase_							(				self     ,	SCREAMING_SNAKE_CASE_      )							->	Optional[Any]:
         return self.vocab.get(SCREAMING_SNAKE_CASE_     ,	self.vocab.get(self.unk_token      )      )







    def  lowercase_							(				self     ,	SCREAMING_SNAKE_CASE_      )							->	int:
         return self.subword_tokenizer.convert_id_to_token(SCREAMING_SNAKE_CASE_      )







    def  lowercase_							(				self     ,	SCREAMING_SNAKE_CASE_      )							->	Union[str, Any]:
         __lowerCamelCase  :      Any														=						''.join(SCREAMING_SNAKE_CASE_      ).strip()
         return out_string







    def  lowercase_							(				self     ,	SCREAMING_SNAKE_CASE_      )							->	List[int]:
         __lowerCamelCase  :      int														=						[]
         for is_user, text in conversation.iter_texts():
              input_ids.extend(self.encode(SCREAMING_SNAKE_CASE_     ,	add_special_tokens=SCREAMING_SNAKE_CASE_      ) + [self.eos_token_id]      )

         if len(SCREAMING_SNAKE_CASE_      ) > self.model_max_length:
              __lowerCamelCase  :      List[Any]														=						input_ids[-self.model_max_length :]
         return input_ids







    def  lowercase_							(				self     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_ = None      )							->	Tuple[str]:
         __lowerCamelCase  :      List[Any]														=						0
         if os.path.isdir(SCREAMING_SNAKE_CASE_      ):
              __lowerCamelCase  :      Tuple														=						os.path.join(
                  SCREAMING_SNAKE_CASE_     ,	(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['vocab_file']      )
              __lowerCamelCase  :      Union[str, Any]														=						os.path.join(
                  SCREAMING_SNAKE_CASE_     ,	(filename_prefix + '-' if filename_prefix else '') + VOCAB_FILES_NAMES['emoji_file']      )
         else:
              __lowerCamelCase  :      List[Any]														=						(
                  (filename_prefix + '-' if filename_prefix else '') + save_directory + VOCAB_FILES_NAMES['vocab_file']
              )
              __lowerCamelCase  :      Any														=						(
                  (filename_prefix + '-' if filename_prefix else '') + save_directory + VOCAB_FILES_NAMES['emoji_file']
              )
         with open(SCREAMING_SNAKE_CASE_     ,	'w'     ,	encoding='utf-8'      ) as writer:
              for token_index, token in self.ids_to_tokens.items():
                   if index != token_index:
                        logger.warning(
                            f'Saving vocabulary to {vocab_file}: vocabulary indices are not consecutive.'
                            ' Please check that the vocabulary is not corrupted!'      )
                        __lowerCamelCase  :      Dict														=						token_index
                   writer.write(','.join(SCREAMING_SNAKE_CASE_      ) + '\n'      )
                   index += 1
         with open(SCREAMING_SNAKE_CASE_     ,	'w'     ,	encoding='utf-8'      ) as writer:
              json.dump(self.emoji     ,	SCREAMING_SNAKE_CASE_      )
         return vocab_file, emoji_file







class   UpperCAmelCase_    (_UpperCAmelCase    ):





    """simple docstring"""






    def __init__(				self     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )							->	List[str]:
         __lowerCamelCase  :      Optional[int]														=						vocab  # same as swe
         __lowerCamelCase  :      Dict														=						ids_to_tokens  # same as bpe
         __lowerCamelCase  :      str														=						emoji
         __lowerCamelCase  :      str														=						np.max([len(SCREAMING_SNAKE_CASE_      ) for w in self.vocab.keys()]      )
         __lowerCamelCase  :      Union[str, Any]														=						re.compile(r'(https?|ftp)(:\/\/[-_\.!~*\'()a-zA-Z0-9;\/?:\@&=\+$,%#]+)'      )
         __lowerCamelCase  :      Optional[Any]														=						re.compile(r'[A-Za-z0-9\._+]*@[\-_0-9A-Za-z]+(\.[A-Za-z]+)*'      )
         __lowerCamelCase  :      List[Any]														=						re.compile(r'[\(]{0,1}[0-9]{2,4}[\)\-\(]{0,1}[0-9]{2,4}[\)\-]{0,1}[0-9]{3,4}'      )
         __lowerCamelCase  :      Dict														=						re.compile(
             r'([12]\d{3}[/\-年])*(0?[1-9]|1[0-2])[/\-月]((0?[1-9]|[12][0-9]|3[01])日?)*(\d{1,2}|:|\d{1,2}時|\d{1,2}分|\(日\)|\(月\)|\(火\)|\(水\)|\(木\)|\(金\)|\(土\)|㈰|㈪|㈫|㈬|㈭|㈮|㈯)*'      )
         __lowerCamelCase  :      int														=						re.compile(
             r'(明治|大正|昭和|平成|令和|㍾|㍽|㍼|㍻|\u32ff)\d{1,2}年(0?[1-9]|1[0-2])月(0?[1-9]|[12][0-9]|3[01])日(\d{1,2}|:|\d{1,2}時|\d{1,2}分|\(日\)|\(月\)|\(火\)|\(水\)|\(木\)|\(金\)|\(土\)|㈰|㈪|㈫|㈬|㈭|㈮|㈯)*'      )
         __lowerCamelCase  :      List[str]														=						re.compile(
             r'((0|[1-9]\d*|[1-9]\d{0,2}(,\d{3})+)*億)*((0|[1-9]\d*|[1-9]\d{0,2}(,\d{3})+)*万)*((0|[1-9]\d*|[1-9]\d{0,2}(,\d{3})+)*千)*(0|[1-9]\d*|[1-9]\d{0,2}(,\d{3})+)*(千円|万円|千万円|円|千ドル|万ドル|千万ドル|ドル|千ユーロ|万ユーロ|千万ユーロ|ユーロ)+(\(税込\)|\(税抜\)|\+tax)*'      )
         __lowerCamelCase  :      Optional[int]														=						'─━│┃┄┅┆┇┈┉┊┋┌┍┎┏┐┑┒┓└┕┖┗┘┙┚┛├┝┞┟┠┡┢┣┤┥┦┧┨┩┪┫┬┭┮┯┰┱┲┳┴┵┶┷┸┹┺┻┼┽┾┿╀╁╂╃╄╅╆╇╈╉╊╋╌╍╎╏═║╒╓╔╕╖╗╘╙╚╛╜╝╞╟╠╡╢╣╤╥╦╧╨╩╪╫╬╭╮╯╰╱╲╳╴╵╶╷╸╹╺╻╼╽╾╿'
         __lowerCamelCase  :      Any														=						'▀▁▂▃▄▅▆▇█▉▊▋▌▍▎▏▐░▒▓▔▕▖▗▘▙▚▛▜▝▞▟'
         __lowerCamelCase  :      Optional[Any]														=						str.maketrans({k: '<BLOCK>' for k in keisen + blocks}      )







    def __len__(				self      )							->	Any:
         return len(self.ids_to_tokens      )







    def  lowercase_							(				self     ,	SCREAMING_SNAKE_CASE_      )							->	Optional[int]:
         __lowerCamelCase  :      Any														=						self.content_repattera.sub('<URL>'     ,	SCREAMING_SNAKE_CASE_      )
         __lowerCamelCase  :      Any														=						self.content_repattera.sub('<EMAIL>'     ,	SCREAMING_SNAKE_CASE_      )
         __lowerCamelCase  :      Union[str, Any]														=						self.content_repattera.sub('<TEL>'     ,	SCREAMING_SNAKE_CASE_      )
         __lowerCamelCase  :      int														=						self.content_repattera.sub('<DATE>'     ,	SCREAMING_SNAKE_CASE_      )
         __lowerCamelCase  :      Union[str, Any]														=						self.content_repattera.sub('<DATE>'     ,	SCREAMING_SNAKE_CASE_      )
         __lowerCamelCase  :      int														=						self.content_repattera.sub('<PRICE>'     ,	SCREAMING_SNAKE_CASE_      )
         __lowerCamelCase  :      Any														=						content.translate(self.content_transa      )
         while "<BLOCK><BLOCK>" in content:
              __lowerCamelCase  :      Optional[int]														=						content.replace('<BLOCK><BLOCK>'     ,	'<BLOCK>'      )
         return content







    def  lowercase_							(				self     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_=False      )							->	Tuple:
         __lowerCamelCase  :      Tuple														=						text.replace(' '     ,	'<SP>'      )
         __lowerCamelCase  :      Optional[Any]														=						text.replace('　'     ,	'<SP>'      )
         __lowerCamelCase  :      str														=						text.replace('\r\n'     ,	'<BR>'      )
         __lowerCamelCase  :      List[Any]														=						text.replace('\n'     ,	'<BR>'      )
         __lowerCamelCase  :      Tuple														=						text.replace('\r'     ,	'<BR>'      )
         __lowerCamelCase  :      int														=						text.replace('\t'     ,	'<TAB>'      )
         __lowerCamelCase  :      Optional[int]														=						text.replace('—'     ,	'ー'      )
         __lowerCamelCase  :      List[Any]														=						text.replace('−'     ,	'ー'      )
         for k, v in self.emoji["emoji"].items():
              if k in text:
                   __lowerCamelCase  :      Tuple														=						text.replace(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_      )
         if clean:
              __lowerCamelCase  :      Union[str, Any]														=						self.clean_text(SCREAMING_SNAKE_CASE_      )

         def check_simbol(SCREAMING_SNAKE_CASE_      ):
              __lowerCamelCase  :      List[Any]														=						x.encode()
              if len(SCREAMING_SNAKE_CASE_      ) == 1 and len(SCREAMING_SNAKE_CASE_      ) == 2:
                   __lowerCamelCase  :      Dict														=						(int(e[0]      ) << 8) + int(e[1]      )
                   if (
                       (c >= 0Xc2_a1 and c <= 0Xc2_bf)
                       or (c >= 0Xc7_80 and c <= 0Xc7_83)
                       or (c >= 0Xca_b9 and c <= 0Xcb_bf)
                       or (c >= 0Xcc_80 and c <= 0Xcd_a2)
                   ):
                        return True
              return False

         def checkuae(SCREAMING_SNAKE_CASE_      ):
              __lowerCamelCase  :      str														=						x.encode()
              if len(SCREAMING_SNAKE_CASE_      ) == 1 and len(SCREAMING_SNAKE_CASE_      ) == 3:
                   __lowerCamelCase  :      List[Any]														=						(int(e[0]      ) << 16) + (int(e[1]      ) << 8) + int(e[2]      )
                   if c >= 0Xe2_80_80 and c <= 0Xe2_b0_7f:
                        return True
              return False

         __lowerCamelCase  :      Any														=						0
         __lowerCamelCase  :      Union[str, Any]														=						[]
         while pos < len(SCREAMING_SNAKE_CASE_      ):
              __lowerCamelCase  :      Dict														=						min(len(SCREAMING_SNAKE_CASE_      )     ,	pos + self.maxlen + 1      ) if text[pos] == '<' else pos + 3
              __lowerCamelCase  :      Dict														=						[]  # (token_id, token, pos)
              for e in range(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	-1      ):
                   __lowerCamelCase  :      List[str]														=						text[pos:e]
                   if wd in self.vocab:
                        if wd[0] == "<" and len(SCREAMING_SNAKE_CASE_      ) > 2:
                             __lowerCamelCase  :      str														=						[(self.vocab[wd], wd, e)]
                             break
                        else:
                             candidates.append((self.vocab[wd], wd, e)      )
              if len(SCREAMING_SNAKE_CASE_      ) > 0:
                   # the smallest token_id is adopted
                   __lowerCamelCase							,			__lowerCamelCase							,			__lowerCamelCase  :      int														=						sorted(SCREAMING_SNAKE_CASE_     ,	key=lambda SCREAMING_SNAKE_CASE_      : x[0]      )[0]
                   result.append(SCREAMING_SNAKE_CASE_      )
                   __lowerCamelCase  :      int														=						e
              else:
                   __lowerCamelCase  :      List[Any]														=						pos + 1
                   __lowerCamelCase  :      int														=						text[pos:end]
                   if check_simbol(SCREAMING_SNAKE_CASE_      ):
                        result.append('<KIGOU>'      )
                   elif checkuae(SCREAMING_SNAKE_CASE_      ):
                        result.append('<U2000U2BFF>'      )
                   else:
                        for i in wd.encode('utf-8'      ):
                             result.append('<|byte%d|>' % i      )
                   __lowerCamelCase  :      str														=						end
         return result







    def  lowercase_							(				self     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_="\n"      )							->	Union[str, Any]:
         __lowerCamelCase  :      Dict														=						[]
         __lowerCamelCase  :      int														=						[]
         __lowerCamelCase  :      Optional[Any]														=						self.ids_to_tokens[index][0]
         if word[:6] == "<|byte" and word[-2:] == "|>":
              byte_tokens.append(int(word[6:-2]      )      )
         else:
              if len(SCREAMING_SNAKE_CASE_      ) > 0:
                   words.append(bytearray(SCREAMING_SNAKE_CASE_      ).decode('utf-8'     ,	errors='replace'      )      )
                   __lowerCamelCase  :      Union[str, Any]														=						[]
              if word[:7] == "<|emoji" and word[-2:] == "|>":
                   words.append(self.emoji['emoji_inv'][word]      )
              elif word == "<SP>":
                   words.append(' '      )
              elif word == "<BR>":
                   words.append(SCREAMING_SNAKE_CASE_      )
              elif word == "<TAB>":
                   words.append('\t'      )
              elif word == "<BLOCK>":
                   words.append('▀'      )
              elif word == "<KIGOU>":
                   words.append('ǀ'      )
              elif word == "<U2000U2BFF>":
                   words.append('‖'      )
              else:
                   words.append(SCREAMING_SNAKE_CASE_      )
         if len(SCREAMING_SNAKE_CASE_      ) > 0:
              words.append(bytearray(SCREAMING_SNAKE_CASE_      ).decode('utf-8'     ,	errors='replace'      )      )
         __lowerCamelCase  :      Dict														=						''.join(SCREAMING_SNAKE_CASE_      )
         return text










'''simple docstring'''







from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowerCAmelCase     :  List[str]											=    {
    """configuration_electra""": ["""ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP""", """ElectraConfig""", """ElectraOnnxConfig"""],
    """tokenization_electra""": ["""ElectraTokenizer"""],
}

try:
       if not is_tokenizers_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowerCAmelCase     :  Optional[Any]											=    ["""ElectraTokenizerFast"""]

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowerCAmelCase     :  str											=    [
           """ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST""",
           """ElectraForCausalLM""",
           """ElectraForMaskedLM""",
           """ElectraForMultipleChoice""",
           """ElectraForPreTraining""",
           """ElectraForQuestionAnswering""",
           """ElectraForSequenceClassification""",
           """ElectraForTokenClassification""",
           """ElectraModel""",
           """ElectraPreTrainedModel""",
           """load_tf_weights_in_electra""",
       ]

try:
       if not is_tf_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowerCAmelCase     :  Tuple											=    [
           """TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST""",
           """TFElectraForMaskedLM""",
           """TFElectraForMultipleChoice""",
           """TFElectraForPreTraining""",
           """TFElectraForQuestionAnswering""",
           """TFElectraForSequenceClassification""",
           """TFElectraForTokenClassification""",
           """TFElectraModel""",
           """TFElectraPreTrainedModel""",
       ]

try:
       if not is_flax_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowerCAmelCase     :  Union[str, Any]											=    [
           """FlaxElectraForCausalLM""",
           """FlaxElectraForMaskedLM""",
           """FlaxElectraForMultipleChoice""",
           """FlaxElectraForPreTraining""",
           """FlaxElectraForQuestionAnswering""",
           """FlaxElectraForSequenceClassification""",
           """FlaxElectraForTokenClassification""",
           """FlaxElectraModel""",
           """FlaxElectraPreTrainedModel""",
       ]


if TYPE_CHECKING:
       from .configuration_electra import ELECTRA_PRETRAINED_CONFIG_ARCHIVE_MAP, ElectraConfig, ElectraOnnxConfig
       from .tokenization_electra import ElectraTokenizer

       try:
              if not is_tokenizers_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .tokenization_electra_fast import ElectraTokenizerFast

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_electra import (
                  ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
                  ElectraForCausalLM,
                  ElectraForMaskedLM,
                  ElectraForMultipleChoice,
                  ElectraForPreTraining,
                  ElectraForQuestionAnswering,
                  ElectraForSequenceClassification,
                  ElectraForTokenClassification,
                  ElectraModel,
                  ElectraPreTrainedModel,
                  load_tf_weights_in_electra,
              )

       try:
              if not is_tf_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_tf_electra import (
                  TF_ELECTRA_PRETRAINED_MODEL_ARCHIVE_LIST,
                  TFElectraForMaskedLM,
                  TFElectraForMultipleChoice,
                  TFElectraForPreTraining,
                  TFElectraForQuestionAnswering,
                  TFElectraForSequenceClassification,
                  TFElectraForTokenClassification,
                  TFElectraModel,
                  TFElectraPreTrainedModel,
              )

       try:
              if not is_flax_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_flax_electra import (
                  FlaxElectraForCausalLM,
                  FlaxElectraForMaskedLM,
                  FlaxElectraForMultipleChoice,
                  FlaxElectraForPreTraining,
                  FlaxElectraForQuestionAnswering,
                  FlaxElectraForSequenceClassification,
                  FlaxElectraForTokenClassification,
                  FlaxElectraModel,
                  FlaxElectraPreTrainedModel,
              )

else:
       import sys

       lowerCAmelCase     :  int											=    _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)

