





'''simple docstring'''




from string import ascii_uppercase

_A:					Union[str, Any]							=				{char: i for i, char in enumerate(ascii_uppercase)}
_A:					str							=				dict(enumerate(ascii_uppercase))







def _lowerCAmelCase     (      _lowerCAmelCase       ,    _lowerCAmelCase    )->     str:
 __UpperCAmelCase					=   len(_lowerCAmelCase    )
 __UpperCAmelCase					=   0
 while True:
  if x == i:
   __UpperCAmelCase					=   0
  if len(_lowerCAmelCase    ) == len(_lowerCAmelCase    ):
   break
  key += key[i]
  i += 1
 return key







def _lowerCAmelCase     (      _lowerCAmelCase       ,    _lowerCAmelCase    )->     str:
 __UpperCAmelCase					=   ''
 __UpperCAmelCase					=   0
 for letter in message:
  if letter == " ":
   cipher_text += " "
  else:
   __UpperCAmelCase					=   (dicta[letter] - dicta[key_new[i]]) % 26
   i += 1
   cipher_text += dicta[x]
 return cipher_text







def _lowerCAmelCase     (      _lowerCAmelCase       ,    _lowerCAmelCase    )->     str:
 __UpperCAmelCase					=   ''
 __UpperCAmelCase					=   0
 for letter in cipher_text:
  if letter == " ":
   or_txt += " "
  else:
   __UpperCAmelCase					=   (dicta[letter] + dicta[key_new[i]] + 26) % 26
   i += 1
   or_txt += dicta[x]
 return or_txt







def _lowerCAmelCase     (      )->     None:
 __UpperCAmelCase					=   'THE GERMAN ATTACK'
 __UpperCAmelCase					=   'SECRET'
 __UpperCAmelCase					=   generate_key(_lowerCAmelCase       ,    _lowerCAmelCase    )
 __UpperCAmelCase					=   cipher_text(_lowerCAmelCase       ,    _lowerCAmelCase    )
 print(F'Encrypted Text = {s}'    )
 print(F'Original Text = {original_text(_lowerCAmelCase       ,    _lowerCAmelCase    )}'    )


if __name__ == "__main__":
    import doctest

    doctest.testmod()
    main()












'''simple docstring'''




from typing import TYPE_CHECKING

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


_A:					str							=				{
    """configuration_whisper""": ["""WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP""", """WhisperConfig""", """WhisperOnnxConfig"""],
    """feature_extraction_whisper""": ["""WhisperFeatureExtractor"""],
    """processing_whisper""": ["""WhisperProcessor"""],
    """tokenization_whisper""": ["""WhisperTokenizer"""],
}

try:
    if not is_tokenizers_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _A:					Union[str, Any]							=				["""WhisperTokenizerFast"""]

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _A:					Optional[Any]							=				[
        """WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST""",
        """WhisperForConditionalGeneration""",
        """WhisperModel""",
        """WhisperPreTrainedModel""",
        """WhisperForAudioClassification""",
    ]

try:
    if not is_tf_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _A:					Dict							=				[
        """TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST""",
        """TFWhisperForConditionalGeneration""",
        """TFWhisperModel""",
        """TFWhisperPreTrainedModel""",
    ]

try:
    if not is_flax_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    _A:					Union[str, Any]							=				[
        """FlaxWhisperForConditionalGeneration""",
        """FlaxWhisperModel""",
        """FlaxWhisperPreTrainedModel""",
        """FlaxWhisperForAudioClassification""",
    ]


if TYPE_CHECKING:
    from .configuration_whisper import WHISPER_PRETRAINED_CONFIG_ARCHIVE_MAP, WhisperConfig, WhisperOnnxConfig
    from .feature_extraction_whisper import WhisperFeatureExtractor
    from .processing_whisper import WhisperProcessor
    from .tokenization_whisper import WhisperTokenizer

    try:
        if not is_tokenizers_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .tokenization_whisper_fast import WhisperTokenizerFast

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_whisper import (
            WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST,
            WhisperForAudioClassification,
            WhisperForConditionalGeneration,
            WhisperModel,
            WhisperPreTrainedModel,
        )

    try:
        if not is_tf_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_tf_whisper import (
            TF_WHISPER_PRETRAINED_MODEL_ARCHIVE_LIST,
            TFWhisperForConditionalGeneration,
            TFWhisperModel,
            TFWhisperPreTrainedModel,
        )

    try:
        if not is_flax_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_flax_whisper import (
            FlaxWhisperForAudioClassification,
            FlaxWhisperForConditionalGeneration,
            FlaxWhisperModel,
            FlaxWhisperPreTrainedModel,
        )

else:
    import sys

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





