





from typing import TYPE_CHECKING

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


__lowerCAmelCase :Union[str, Any]     =    {
    'configuration_albert': ['ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP', 'AlbertConfig', 'AlbertOnnxConfig'],
}

try:
							if not is_sentencepiece_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__lowerCAmelCase :Optional[Any]     =    ['AlbertTokenizer']

try:
							if not is_tokenizers_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__lowerCAmelCase :Optional[Any]     =    ['AlbertTokenizerFast']

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__lowerCAmelCase :Any     =    [
							    'ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
							    'AlbertForMaskedLM',
							    'AlbertForMultipleChoice',
							    'AlbertForPreTraining',
							    'AlbertForQuestionAnswering',
							    'AlbertForSequenceClassification',
							    'AlbertForTokenClassification',
							    'AlbertModel',
							    'AlbertPreTrainedModel',
							    'load_tf_weights_in_albert',
							]

try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__lowerCAmelCase :List[Any]     =    [
							    'TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST',
							    'TFAlbertForMaskedLM',
							    'TFAlbertForMultipleChoice',
							    'TFAlbertForPreTraining',
							    'TFAlbertForQuestionAnswering',
							    'TFAlbertForSequenceClassification',
							    'TFAlbertForTokenClassification',
							    'TFAlbertMainLayer',
							    'TFAlbertModel',
							    'TFAlbertPreTrainedModel',
							]

try:
							if not is_flax_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__lowerCAmelCase :List[Any]     =    [
							    'FlaxAlbertForMaskedLM',
							    'FlaxAlbertForMultipleChoice',
							    'FlaxAlbertForPreTraining',
							    'FlaxAlbertForQuestionAnswering',
							    'FlaxAlbertForSequenceClassification',
							    'FlaxAlbertForTokenClassification',
							    'FlaxAlbertModel',
							    'FlaxAlbertPreTrainedModel',
							]

if TYPE_CHECKING:
							from .configuration_albert import ALBERT_PRETRAINED_CONFIG_ARCHIVE_MAP, AlbertConfig, AlbertOnnxConfig

							try:
														if not is_sentencepiece_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_albert import AlbertTokenizer

							try:
														if not is_tokenizers_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_albert_fast import AlbertTokenizerFast

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_albert import (
														    ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
														    AlbertForMaskedLM,
														    AlbertForMultipleChoice,
														    AlbertForPreTraining,
														    AlbertForQuestionAnswering,
														    AlbertForSequenceClassification,
														    AlbertForTokenClassification,
														    AlbertModel,
														    AlbertPreTrainedModel,
														    load_tf_weights_in_albert,
														)

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_albert import (
														    TF_ALBERT_PRETRAINED_MODEL_ARCHIVE_LIST,
														    TFAlbertForMaskedLM,
														    TFAlbertForMultipleChoice,
														    TFAlbertForPreTraining,
														    TFAlbertForQuestionAnswering,
														    TFAlbertForSequenceClassification,
														    TFAlbertForTokenClassification,
														    TFAlbertMainLayer,
														    TFAlbertModel,
														    TFAlbertPreTrainedModel,
														)

							try:
														if not is_flax_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_flax_albert import (
														    FlaxAlbertForMaskedLM,
														    FlaxAlbertForMultipleChoice,
														    FlaxAlbertForPreTraining,
														    FlaxAlbertForQuestionAnswering,
														    FlaxAlbertForSequenceClassification,
														    FlaxAlbertForTokenClassification,
														    FlaxAlbertModel,
														    FlaxAlbertPreTrainedModel,
														)
else:
							import sys

							__lowerCAmelCase :int     =    _LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)






import numpy as np

__lowerCAmelCase :Dict     =    [
    ['a', 'b', 'c', 'd', 'e'],
    ['f', 'g', 'h', 'i', 'k'],
    ['l', 'm', 'n', 'o', 'p'],
    ['q', 'r', 's', 't', 'u'],
    ['v', 'w', 'x', 'y', 'z'],
]






class        _a:







		def __init__(    self				)      ->      None:


							'''simple docstring'''

							_snake_case       :					Optional[Any]				       =   np.array(__snake_case				)







		def        lowercase       (    self ,						__snake_case				)      ->      np.ndarray:


							'''simple docstring'''

							_snake_case       , _snake_case       :					List[Any]				       =   np.where(letter == self.SQUARE				)
							_snake_case       :					Any				       =   np.concatenate([indexa + 1, indexa + 1]				)
							return indexes







		def        lowercase       (    self ,						__snake_case ,						__snake_case				)      ->      str:


							'''simple docstring'''

							_snake_case       :					int				       =   self.SQUARE[indexa - 1, indexa - 1]
							return letter







		def        lowercase       (    self ,						__snake_case				)      ->      str:


							'''simple docstring'''

							_snake_case       :					Optional[Any]				       =   message.lower()
							_snake_case       :					List[Any]				       =   message.replace(" " ,						""				)
							_snake_case       :					Any				       =   message.replace("j" ,						"i"				)

							_snake_case       :					Tuple				       =   np.empty((2, len(__snake_case				))				)
							for letter_index in range(len(__snake_case				)				):
												_snake_case       :					Dict				       =   self.letter_to_numbers(message[letter_index]				)

												_snake_case       :					Tuple				       =   numbers[0]
												_snake_case       :					List[Any]				       =   numbers[1]

							_snake_case       :					Any				       =   first_step.reshape(2 * len(__snake_case				)				)
							_snake_case       :					Optional[Any]				       =   ""
							for numbers_index in range(len(__snake_case				)				):
												_snake_case       :					Optional[int]				       =   int(second_step[numbers_index * 2]				)
												_snake_case       :					List[str]				       =   int(second_step[(numbers_index * 2) + 1]				)
												_snake_case       :					Any				       =   self.numbers_to_letter(__snake_case ,						__snake_case				)
												_snake_case       :					Any				       =   encoded_message + letter

							return encoded_message







		def        lowercase       (    self ,						__snake_case				)      ->      str:


							'''simple docstring'''

							_snake_case       :					Union[str, Any]				       =   message.lower()
							message.replace(" " ,						""				)
							_snake_case       :					Tuple				       =   np.empty(2 * len(__snake_case				)				)
							for letter_index in range(len(__snake_case				)				):
												_snake_case       :					Union[str, Any]				       =   self.letter_to_numbers(message[letter_index]				)
												_snake_case       :					Tuple				       =   numbers[0]
												_snake_case       :					Any				       =   numbers[1]

							_snake_case       :					Optional[Any]				       =   first_step.reshape((2, len(__snake_case				))				)
							_snake_case       :					Union[str, Any]				       =   ""
							for numbers_index in range(len(__snake_case				)				):
												_snake_case       :					Dict				       =   int(second_step[0, numbers_index]				)
												_snake_case       :					Optional[Any]				       =   int(second_step[1, numbers_index]				)
												_snake_case       :					Union[str, Any]				       =   self.numbers_to_letter(__snake_case ,						__snake_case				)
												_snake_case       :					str				       =   decoded_message + letter

							return decoded_message