def 				lowerCAmelCase__       (			a__ )      ->str:




  '''simple docstring'''

  _UpperCamelCase           =    ""
  for ch in key:
    if ch == " " or ch not in key_no_dups and ch.isalpha():
      key_no_dups += ch
  return key_no_dups


def 				lowerCAmelCase__       (			a__ )      ->dict[str, str]:




  '''simple docstring'''

  _UpperCamelCase           =    [chr(i + 65 ) for i in range(26 )]
  # Remove duplicate characters from key
  _UpperCamelCase           =    remove_duplicates(key.upper() )
  _UpperCamelCase           =    len(a__ )
  # First fill cipher with key characters
  _UpperCamelCase           =    {alphabet[i]: char for i, char in enumerate(a__ )}
  # Then map remaining characters in alphabet to
  # the alphabet from the beginning
  for i in range(len(a__ )    ,     26 ):
    _UpperCamelCase           =    alphabet[i - offset]
    # Ensure we are not mapping letters to letters previously mapped
    while char in key:
      offset -= 1
      _UpperCamelCase           =    alphabet[i - offset]
    _UpperCamelCase           =    char
  return cipher_alphabet


def 				lowerCAmelCase__       (			a__    ,     a__ )      ->str:




  '''simple docstring'''

  return "".join(cipher_map.get(a__    ,     a__ ) for ch in message.upper() )


def 				lowerCAmelCase__       (			a__    ,     a__ )      ->str:




  '''simple docstring'''

  _UpperCamelCase           =    {v: k for k, v in cipher_map.items()}
  return "".join(rev_cipher_map.get(a__    ,     a__ ) for ch in message.upper() )


def 				lowerCAmelCase__       (			)      ->None:




  '''simple docstring'''

  _UpperCamelCase           =    input("Enter message to encode or decode: " ).strip()
  _UpperCamelCase           =    input("Enter keyword: " ).strip()
  _UpperCamelCase           =    input("Encipher or decipher? E/D:" ).strip()[0].lower()
  try:
    _UpperCamelCase           =    {"e": encipher, "d": decipher}[option]
  except KeyError:
    raise KeyError("invalid input option" )
  _UpperCamelCase           =    create_cipher_map(a__ )
  print(func(a__    ,     a__ ) )


if __name__ == "__main__":
   import doctest

   doctest.testmod()
   main()





from typing import TYPE_CHECKING

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


lowerCamelCase__  =					{
    '''configuration_wav2vec2''': ['''WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''Wav2Vec2Config'''],
    '''feature_extraction_wav2vec2''': ['''Wav2Vec2FeatureExtractor'''],
    '''processing_wav2vec2''': ['''Wav2Vec2Processor'''],
    '''tokenization_wav2vec2''': ['''Wav2Vec2CTCTokenizer''', '''Wav2Vec2Tokenizer'''],
}


try:
   if not is_torch_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   lowerCamelCase__  =					[
       '''WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST''',
       '''Wav2Vec2ForAudioFrameClassification''',
       '''Wav2Vec2ForCTC''',
       '''Wav2Vec2ForMaskedLM''',
       '''Wav2Vec2ForPreTraining''',
       '''Wav2Vec2ForSequenceClassification''',
       '''Wav2Vec2ForXVector''',
       '''Wav2Vec2Model''',
       '''Wav2Vec2PreTrainedModel''',
   ]

try:
   if not is_tf_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   lowerCamelCase__  =					[
       '''TF_WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST''',
       '''TFWav2Vec2ForCTC''',
       '''TFWav2Vec2Model''',
       '''TFWav2Vec2PreTrainedModel''',
       '''TFWav2Vec2ForSequenceClassification''',
   ]

try:
   if not is_flax_available():
      raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
   pass
else:
   lowerCamelCase__  =					[
       '''FlaxWav2Vec2ForCTC''',
       '''FlaxWav2Vec2ForPreTraining''',
       '''FlaxWav2Vec2Model''',
       '''FlaxWav2Vec2PreTrainedModel''',
   ]


if TYPE_CHECKING:
   from .configuration_wavaveca import WAV_2_VEC_2_PRETRAINED_CONFIG_ARCHIVE_MAP, WavaVecaConfig
   from .feature_extraction_wavaveca import WavaVecaFeatureExtractor
   from .processing_wavaveca import WavaVecaProcessor
   from .tokenization_wavaveca import WavaVecaCTCTokenizer, WavaVecaTokenizer

   try:
      if not is_torch_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_wavaveca import (
          WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST,
          WavaVecaForAudioFrameClassification,
          WavaVecaForCTC,
          WavaVecaForMaskedLM,
          WavaVecaForPreTraining,
          WavaVecaForSequenceClassification,
          WavaVecaForXVector,
          WavaVecaModel,
          WavaVecaPreTrainedModel,
      )

   try:
      if not is_tf_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tf_wavaveca import (
          TF_WAV_2_VEC_2_PRETRAINED_MODEL_ARCHIVE_LIST,
          TFWavaVecaForCTC,
          TFWavaVecaForSequenceClassification,
          TFWavaVecaModel,
          TFWavaVecaPreTrainedModel,
      )

   try:
      if not is_flax_available():
         raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
      pass
   else:
      from .modeling_tf_wavaveca import (
          FlaxWavaVecaForCTC,
          FlaxWavaVecaForPreTraining,
          FlaxWavaVecaModel,
          FlaxWavaVecaPreTrainedModel,
      )


else:
   import sys

   lowerCamelCase__  =					_LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)




