





'''simple docstring'''

from typing import Literal

lowercase_         =			"""ABCDEFGHIJKLMNOPQRSTUVWXYZ"""





def lowerCamelCase						(					__lowerCamelCase			:   str ,	__lowerCamelCase			:   str ,	__lowerCamelCase			:   Literal["encrypt", "decrypt"]   )						->str:
    _SCREAMING_SNAKE_CASE     =      LETTERS if mode == """decrypt""" else key
    _SCREAMING_SNAKE_CASE     =      key if mode == """decrypt""" else LETTERS
    _SCREAMING_SNAKE_CASE     =      """"""
    # loop through each symbol in the message
    for symbol in message:
        if symbol.upper() in chars_a:
            # encrypt/decrypt the symbol
            _SCREAMING_SNAKE_CASE     =      chars_a.find(symbol.upper()   )
            if symbol.isupper():
                translated += chars_b[sym_index].upper()
            else:
                translated += chars_b[sym_index].lower()
        else:
            # symbol is not in LETTERS, just add it
            translated += symbol
    return translated





def lowerCamelCase						(					__lowerCamelCase			:   str ,	__lowerCamelCase			:   str   )						->str:
    return translate_message(__lowerCamelCase ,	__lowerCamelCase ,	"""encrypt"""   )





def lowerCamelCase						(					__lowerCamelCase			:   str ,	__lowerCamelCase			:   str   )						->str:
    return translate_message(__lowerCamelCase ,	__lowerCamelCase ,	"""decrypt"""   )





def lowerCamelCase						(					)						->None:
    _SCREAMING_SNAKE_CASE     =      """Hello World"""
    _SCREAMING_SNAKE_CASE     =      """QWERTYUIOPASDFGHJKLZXCVBNM"""
    _SCREAMING_SNAKE_CASE     =      """decrypt"""  # set to 'encrypt' or 'decrypt'

    if mode == "encrypt":
        _SCREAMING_SNAKE_CASE     =      encrypt_message(__lowerCamelCase ,	__lowerCamelCase   )
    elif mode == "decrypt":
        _SCREAMING_SNAKE_CASE     =      decrypt_message(__lowerCamelCase ,	__lowerCamelCase   )
    print(F'Using the key {key}, the {mode}ed message is: {translated}'   )


if __name__ == "__main__":
      import doctest

      doctest.testmod()
      main()










'''simple docstring'''

from typing import TYPE_CHECKING

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


lowercase_         =			{
    """configuration_esm""": ["""ESM_PRETRAINED_CONFIG_ARCHIVE_MAP""", """EsmConfig"""],
    """tokenization_esm""": ["""EsmTokenizer"""],
}

try:
      if not is_torch_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      lowercase_         =			[
          """ESM_PRETRAINED_MODEL_ARCHIVE_LIST""",
          """EsmForMaskedLM""",
          """EsmForSequenceClassification""",
          """EsmForTokenClassification""",
          """EsmModel""",
          """EsmPreTrainedModel""",
      ]
      lowercase_         =			["""EsmForProteinFolding""", """EsmFoldPreTrainedModel"""]

try:
      if not is_tf_available():
            raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
      pass
else:
      lowercase_         =			[
          """TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST""",
          """TFEsmForMaskedLM""",
          """TFEsmForSequenceClassification""",
          """TFEsmForTokenClassification""",
          """TFEsmModel""",
          """TFEsmPreTrainedModel""",
      ]

if TYPE_CHECKING:
      from .configuration_esm import ESM_PRETRAINED_CONFIG_ARCHIVE_MAP, EsmConfig
      from .tokenization_esm import EsmTokenizer

      try:
            if not is_torch_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_esm import (
                ESM_PRETRAINED_MODEL_ARCHIVE_LIST,
                EsmForMaskedLM,
                EsmForSequenceClassification,
                EsmForTokenClassification,
                EsmModel,
                EsmPreTrainedModel,
            )
            from .modeling_esmfold import EsmFoldPreTrainedModel, EsmForProteinFolding

      try:
            if not is_tf_available():
                  raise OptionalDependencyNotAvailable()
      except OptionalDependencyNotAvailable:
            pass
      else:
            from .modeling_tf_esm import (
                TF_ESM_PRETRAINED_MODEL_ARCHIVE_LIST,
                TFEsmForMaskedLM,
                TFEsmForSequenceClassification,
                TFEsmForTokenClassification,
                TFEsmModel,
                TFEsmPreTrainedModel,
            )


else:
      import sys

      lowercase_         =			_LazyModule(__name__, globals()["""__file__"""], _import_structure)



