


import shutil
import tempfile
import unittest

from transformers import SPIECE_UNDERLINE, BatchEncoding, MBartaaTokenizer, MBartaaTokenizerFast, is_torch_available
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
    slow,
)

from ...test_tokenization_common import TokenizerTesterMixin


A   :					List[str]	=      get_tests_dir("fixtures/test_sentencepiece.model")

if is_torch_available():
    from transformers.models.mbart.modeling_mbart import shift_tokens_right

A   :					int	=      250004
A   :					Optional[int]	=      250020







@require_sentencepiece
@require_tokenizers
class     _lowercase				(							lowercase__							,						unittest.TestCase):


       """simple docstring"""




       A__      		=    MBartaaTokenizer
       A__      		=    MBartaaTokenizerFast
       A__      		=    True
       A__      		=    True





       def 		lowerCAmelCase  (     self							:    str ):


             '''simple docstring'''



             super().setUp()

             # We have a SentencePiece fixture for testing
             lowerCamelCase__	:       Tuple					=						MBartaaTokenizer(__lowerCamelCase      ,   src_lang="en_XX"      ,   tgt_lang="ro_RO"      ,   keep_accents=__lowerCamelCase )
             tokenizer.save_pretrained(self.tmpdirname )





       def 		lowerCAmelCase  (     self							:    Tuple ):


             '''simple docstring'''



             lowerCamelCase__	:       Optional[int]					=						"<s>"
             lowerCamelCase__	:       Any					=						0

             self.assertEqual(self.get_tokenizer()._convert_token_to_id(__lowerCamelCase )      ,   __lowerCamelCase )
             self.assertEqual(self.get_tokenizer()._convert_id_to_token(__lowerCamelCase )      ,   __lowerCamelCase )





       def 		lowerCAmelCase  (     self							:    Optional[int] ):


             '''simple docstring'''



             lowerCamelCase__	:       str					=						list(self.get_tokenizer().get_vocab().keys() )

             self.assertEqual(vocab_keys[0]      ,   "<s>" )
             self.assertEqual(vocab_keys[1]      ,   "<pad>" )
             self.assertEqual(vocab_keys[-1]      ,   "<mask>" )
             self.assertEqual(len(__lowerCamelCase )      ,   1054 )





       def 		lowerCAmelCase  (     self							:    Optional[Any] ):


             '''simple docstring'''



             self.assertEqual(self.get_tokenizer().vocab_size      ,   1054 )





       def 		lowerCAmelCase  (     self							:    Tuple ):


             '''simple docstring'''



             lowerCamelCase__	:       Dict					=						MBartaaTokenizer(__lowerCamelCase      ,   src_lang="en_XX"      ,   tgt_lang="ro_RO"      ,   keep_accents=__lowerCamelCase )

             lowerCamelCase__	:       str					=						tokenizer.tokenize("This is a test" )
             self.assertListEqual(__lowerCamelCase      ,   ["▁This", "▁is", "▁a", "▁t", "est"] )

             self.assertListEqual(
                 tokenizer.convert_tokens_to_ids(__lowerCamelCase )      ,   [value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]]      ,   )

             lowerCamelCase__	:       Dict					=						tokenizer.tokenize("I was born in 92000, and this is falsé." )
             self.assertListEqual(
                 __lowerCamelCase      ,   [SPIECE_UNDERLINE + "I", SPIECE_UNDERLINE + "was", SPIECE_UNDERLINE + "b", "or", "n", SPIECE_UNDERLINE + "in", SPIECE_UNDERLINE + "", "9", "2", "0", "0", "0", ",", SPIECE_UNDERLINE + "and", SPIECE_UNDERLINE + "this", SPIECE_UNDERLINE + "is", SPIECE_UNDERLINE + "f", "al", "s", "é", "."]      ,   )
             lowerCamelCase__	:       Union[str, Any]					=						tokenizer.convert_tokens_to_ids(__lowerCamelCase )
             self.assertListEqual(
                 __lowerCamelCase      ,   [
                     value + tokenizer.fairseq_offset
                     for value in [8, 21, 84, 55, 24, 19, 7, 2, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 2, 4]
                 ]      ,   )

             lowerCamelCase__	:       Tuple					=						tokenizer.convert_ids_to_tokens(__lowerCamelCase )
             self.assertListEqual(
                 __lowerCamelCase      ,   [SPIECE_UNDERLINE + "I", SPIECE_UNDERLINE + "was", SPIECE_UNDERLINE + "b", "or", "n", SPIECE_UNDERLINE + "in", SPIECE_UNDERLINE + "", "<unk>", "2", "0", "0", "0", ",", SPIECE_UNDERLINE + "and", SPIECE_UNDERLINE + "this", SPIECE_UNDERLINE + "is", SPIECE_UNDERLINE + "f", "al", "s", "<unk>", "."]      ,   )





       @slow
       def 		lowerCAmelCase  (     self							:    Optional[int] ):


             '''simple docstring'''



             lowerCamelCase__	:       str					=						{"input_ids": [[250004, 11062, 82772, 7, 15, 82772, 538, 51529, 237, 17198, 1290, 206, 9, 215175, 1314, 136, 17198, 1290, 206, 9, 56359, 42, 122009, 9, 16466, 16, 87344, 4537, 9, 4717, 78381, 6, 159958, 7, 15, 24480, 618, 4, 527, 22693, 5428, 4, 2777, 24480, 9874, 4, 43523, 594, 4, 803, 18392, 33189, 18, 4, 43523, 24447, 12399, 100, 24955, 83658, 9626, 144057, 15, 839, 22335, 16, 136, 24955, 83658, 83479, 15, 39102, 724, 16, 678, 645, 2789, 1328, 4589, 42, 122009, 115774, 23, 805, 1328, 46876, 7, 136, 53894, 1940, 42227, 41159, 17721, 823, 425, 4, 27512, 98722, 206, 136, 5531, 4970, 919, 17336, 5, 2], [250004, 20080, 618, 83, 82775, 47, 479, 9, 1517, 73, 53894, 333, 80581, 110117, 18811, 5256, 1295, 51, 152526, 297, 7986, 390, 124416, 538, 35431, 214, 98, 15044, 25737, 136, 7108, 43701, 23, 756, 135355, 7, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [250004, 581, 63773, 119455, 6, 147797, 88203, 7, 645, 70, 21, 3285, 10269, 5, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]], "attention_mask": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
             # fmt: on

             self.tokenizer_integration_test_util(
                 expected_encoding=__lowerCamelCase      ,   model_name="facebook/mbart-large-50"      ,   revision="d3913889c59cd5c9e456b269c376325eabad57e2"      ,   )





       def 		lowerCAmelCase  (     self							:    List[str] ):


             '''simple docstring'''



             if not self.test_slow_tokenizer:
                   # as we don't have a slow version, we can't compare the outputs between slow and fast versions
                   return

             lowerCamelCase__	:       Dict					=						(self.rust_tokenizer_class, "hf-internal-testing/tiny-random-mbart50", {})
             for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
                   with self.subTest(f"{tokenizer.__class__.__name__} ({pretrained_name})" ):
                         lowerCamelCase__	:       int					=						self.rust_tokenizer_class.from_pretrained(__lowerCamelCase      ,   **__lowerCamelCase )
                         lowerCamelCase__	:       List[str]					=						self.tokenizer_class.from_pretrained(__lowerCamelCase      ,   **__lowerCamelCase )

                         lowerCamelCase__	:       List[Any]					=						tempfile.mkdtemp()

                         lowerCamelCase__	:       List[str]					=						tokenizer_r.save_pretrained(__lowerCamelCase )
                         lowerCamelCase__	:       Optional[int]					=						tokenizer_p.save_pretrained(__lowerCamelCase )

                         # Checks it save with the same files + the tokenizer.json file for the fast one
                         self.assertTrue(any("tokenizer.json" in f for f in tokenizer_r_files ) )
                         lowerCamelCase__	:       List[Any]					=						tuple(f for f in tokenizer_r_files if "tokenizer.json" not in f )
                         self.assertSequenceEqual(__lowerCamelCase      ,   __lowerCamelCase )

                         # Checks everything loads correctly in the same way
                         lowerCamelCase__	:       List[str]					=						tokenizer_r.from_pretrained(__lowerCamelCase )
                         lowerCamelCase__	:       Any					=						tokenizer_p.from_pretrained(__lowerCamelCase )

                         # Check special tokens are set accordingly on Rust and Python
                         for key in tokenizer_pp.special_tokens_map:
                               self.assertTrue(hasattr(__lowerCamelCase      ,   __lowerCamelCase ) )
                               # self.assertEqual(getattr(tokenizer_rp, key), getattr(tokenizer_pp, key))
                               # self.assertEqual(getattr(tokenizer_rp, key + "_id"), getattr(tokenizer_pp, key + "_id"))

                         shutil.rmtree(__lowerCamelCase )

                         # Save tokenizer rust, legacy_format=True
                         lowerCamelCase__	:       List[str]					=						tempfile.mkdtemp()

                         lowerCamelCase__	:       Tuple					=						tokenizer_r.save_pretrained(__lowerCamelCase      ,   legacy_format=__lowerCamelCase )
                         lowerCamelCase__	:       str					=						tokenizer_p.save_pretrained(__lowerCamelCase )

                         # Checks it save with the same files
                         self.assertSequenceEqual(__lowerCamelCase      ,   __lowerCamelCase )

                         # Checks everything loads correctly in the same way
                         lowerCamelCase__	:       Union[str, Any]					=						tokenizer_r.from_pretrained(__lowerCamelCase )
                         lowerCamelCase__	:       str					=						tokenizer_p.from_pretrained(__lowerCamelCase )

                         # Check special tokens are set accordingly on Rust and Python
                         for key in tokenizer_pp.special_tokens_map:
                               self.assertTrue(hasattr(__lowerCamelCase      ,   __lowerCamelCase ) )

                         shutil.rmtree(__lowerCamelCase )

                         # Save tokenizer rust, legacy_format=False
                         lowerCamelCase__	:       Optional[Any]					=						tempfile.mkdtemp()

                         lowerCamelCase__	:       Union[str, Any]					=						tokenizer_r.save_pretrained(__lowerCamelCase      ,   legacy_format=__lowerCamelCase )
                         lowerCamelCase__	:       str					=						tokenizer_p.save_pretrained(__lowerCamelCase )

                         # Checks it saved the tokenizer.json file
                         self.assertTrue(any("tokenizer.json" in f for f in tokenizer_r_files ) )

                         # Checks everything loads correctly in the same way
                         lowerCamelCase__	:       Optional[int]					=						tokenizer_r.from_pretrained(__lowerCamelCase )
                         lowerCamelCase__	:       Optional[int]					=						tokenizer_p.from_pretrained(__lowerCamelCase )

                         # Check special tokens are set accordingly on Rust and Python
                         for key in tokenizer_pp.special_tokens_map:
                               self.assertTrue(hasattr(__lowerCamelCase      ,   __lowerCamelCase ) )

                         shutil.rmtree(__lowerCamelCase )







@require_torch
@require_sentencepiece
@require_tokenizers
class     _lowercase				(							unittest.TestCase):


       """simple docstring"""




       A__      		=    "facebook/mbart-large-50-one-to-many-mmt"
       A__      		=    [
           " UN Chief Says There Is No Military Solution in Syria",
           " Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.",
       ]
       A__      		=    [
           "Şeful ONU declară că nu există o soluţie militară în Siria",
           "Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei"
           " pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor"
           " face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.",
       ]
       A__      		=    [EN_CODE, 82_74, 12_78_73, 2_59_16, 7, 86_22, 20_71, 4_38, 6_74_85, 53, 18_78_95, 23, 5_17_12, 2]





       @classmethod
       def 		lowerCAmelCase  (     cls							:    Optional[int] ):


             '''simple docstring'''



             lowerCamelCase__	:       MBartaaTokenizer					=						MBartaaTokenizer.from_pretrained(
                 cls.checkpoint_name      ,   src_lang="en_XX"      ,   tgt_lang="ro_RO" )
             lowerCamelCase__	:       Optional[int]					=						1
             return cls





       def 		lowerCAmelCase  (     self							:    Optional[Any] ):


             '''simple docstring'''



             self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["ar_AR"]      ,   250001 )
             self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["en_EN"]      ,   250004 )
             self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["ro_RO"]      ,   250020 )
             self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["mr_IN"]      ,   250038 )





       def 		lowerCAmelCase  (     self							:    Optional[Any] ):


             '''simple docstring'''



             lowerCamelCase__	:       Union[str, Any]					=						self.tokenizer.batch_encode_plus(self.src_text ).input_ids[0]
             self.assertListEqual(self.expected_src_tokens      ,   __lowerCamelCase )





       def 		lowerCAmelCase  (     self							:    List[str] ):


             '''simple docstring'''



             self.assertIn(__lowerCamelCase      ,   self.tokenizer.all_special_ids )
             lowerCamelCase__	:       List[Any]					=						[RO_CODE, 884, 9019, 96, 9, 916, 86792, 36, 18743, 15596, 5, 2]
             lowerCamelCase__	:       List[str]					=						self.tokenizer.decode(__lowerCamelCase      ,   skip_special_tokens=__lowerCamelCase )
             lowerCamelCase__	:       List[Any]					=						self.tokenizer.decode(generated_ids[1:]      ,   skip_special_tokens=__lowerCamelCase )
             self.assertEqual(__lowerCamelCase      ,   __lowerCamelCase )
             self.assertNotIn(self.tokenizer.eos_token      ,   __lowerCamelCase )





       def 		lowerCAmelCase  (     self							:    List[str] ):


             '''simple docstring'''



             lowerCamelCase__	:       Union[str, Any]					=						["this is gunna be a long sentence " * 20]
             assert isinstance(src_text[0]      ,   __lowerCamelCase )
             lowerCamelCase__	:       Tuple					=						10
             lowerCamelCase__	:       List[str]					=						self.tokenizer(__lowerCamelCase      ,   max_length=__lowerCamelCase      ,   truncation=__lowerCamelCase ).input_ids[0]
             self.assertEqual(ids[0]      ,   __lowerCamelCase )
             self.assertEqual(ids[-1]      ,   2 )
             self.assertEqual(len(__lowerCamelCase )      ,   __lowerCamelCase )





       def 		lowerCAmelCase  (     self							:    int ):


             '''simple docstring'''



             self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["<mask>", "ar_AR"] )      ,   [250053, 250001] )





       def 		lowerCAmelCase  (     self							:    str ):


             '''simple docstring'''



             lowerCamelCase__	:       int					=						tempfile.mkdtemp()
             lowerCamelCase__	:       List[str]					=						self.tokenizer.fairseq_tokens_to_ids
             self.tokenizer.save_pretrained(__lowerCamelCase )
             lowerCamelCase__	:       Optional[int]					=						MBartaaTokenizer.from_pretrained(__lowerCamelCase )
             self.assertDictEqual(new_tok.fairseq_tokens_to_ids      ,   __lowerCamelCase )





       @require_torch
       def 		lowerCAmelCase  (     self							:    Optional[Any] ):


             '''simple docstring'''



             lowerCamelCase__	:       Tuple					=						self.tokenizer(self.src_text      ,   text_target=self.tgt_text      ,   padding=__lowerCamelCase      ,   return_tensors="pt" )
             lowerCamelCase__	:       List[Any]					=						shift_tokens_right(batch["labels"]      ,   self.tokenizer.pad_token_id )

             # fairseq batch: https://gist.github.com/sshleifer/cba08bc2109361a74ac3760a7e30e4f4
             assert batch.input_ids[1][0] == EN_CODE
             assert batch.input_ids[1][-1] == 2
             assert batch.labels[1][0] == RO_CODE
             assert batch.labels[1][-1] == 2
             assert batch.decoder_input_ids[1][:2].tolist() == [2, RO_CODE]





       @require_torch
       def 		lowerCAmelCase  (     self							:    Tuple ):


             '''simple docstring'''



             lowerCamelCase__	:       List[str]					=						self.tokenizer(
                 self.src_text      ,   text_target=self.tgt_text      ,   padding=__lowerCamelCase      ,   truncation=__lowerCamelCase      ,   max_length=len(self.expected_src_tokens )      ,   return_tensors="pt"      ,   )
             lowerCamelCase__	:       Tuple					=						shift_tokens_right(batch["labels"]      ,   self.tokenizer.pad_token_id )

             self.assertIsInstance(__lowerCamelCase      ,   __lowerCamelCase )

             self.assertEqual((2, 14)      ,   batch.input_ids.shape )
             self.assertEqual((2, 14)      ,   batch.attention_mask.shape )
             lowerCamelCase__	:       str					=						batch.input_ids.tolist()[0]
             self.assertListEqual(self.expected_src_tokens      ,   __lowerCamelCase )
             self.assertEqual(2      ,   batch.decoder_input_ids[0, 0] )  # decoder_start_token_id
             # Test that special tokens are reset
             self.assertEqual(self.tokenizer.prefix_tokens      ,   [EN_CODE] )
             self.assertEqual(self.tokenizer.suffix_tokens      ,   [self.tokenizer.eos_token_id] )





       def 		lowerCAmelCase  (     self							:    str ):


             '''simple docstring'''



             lowerCamelCase__	:       int					=						self.tokenizer(self.src_text      ,   padding=__lowerCamelCase      ,   truncation=__lowerCamelCase      ,   max_length=3      ,   return_tensors="pt" )
             lowerCamelCase__	:       str					=						self.tokenizer(
                 text_target=self.tgt_text      ,   padding=__lowerCamelCase      ,   truncation=__lowerCamelCase      ,   max_length=10      ,   return_tensors="pt" )
             lowerCamelCase__	:       Any					=						targets["input_ids"]
             lowerCamelCase__	:       Union[str, Any]					=						shift_tokens_right(__lowerCamelCase      ,   self.tokenizer.pad_token_id )

             self.assertEqual(batch.input_ids.shape[1]      ,   3 )
             self.assertEqual(batch.decoder_input_ids.shape[1]      ,   10 )





       @require_torch
       def 		lowerCAmelCase  (     self							:    Optional[Any] ):


             '''simple docstring'''



             lowerCamelCase__	:       Dict					=						self.tokenizer._build_translation_inputs(
                 "A test"      ,   return_tensors="pt"      ,   src_lang="en_XX"      ,   tgt_lang="ar_AR" )

             self.assertEqual(
                 nested_simplify(__lowerCamelCase )      ,   {
                     # en_XX, A, test, EOS
                     "input_ids": [[250004, 62, 3034, 2]],
                     "attention_mask": [[1, 1, 1, 1]],
                     # ar_AR
                     "forced_bos_token_id": 250001,
                 }      ,   )






from __future__ import annotations

def    lowercase_	(	_A    :					str					,      _A    :					list[str] | None = None					,      _A    :					dict[str, float] | None = None					,      _A    :					bool = False					,      ):

      """simple docstring"""




      lowerCamelCase__	:       Tuple					=						cipher_alphabet or [chr(_A		) for i in range(97					,      123		)]

      # If the argument is None or the user provided an empty dictionary
      if not frequencies_dict:
            # Frequencies of letters in the english language (how much they show up)
            lowerCamelCase__	:       Dict					=						{
                "a": 0.08_497,
                "b": 0.01_492,
                "c": 0.02_202,
                "d": 0.04_253,
                "e": 0.11_162,
                "f": 0.02_228,
                "g": 0.02_015,
                "h": 0.06_094,
                "i": 0.07_546,
                "j": 0.00_153,
                "k": 0.01_292,
                "l": 0.04_025,
                "m": 0.02_406,
                "n": 0.06_749,
                "o": 0.07_507,
                "p": 0.01_929,
                "q": 0.00_095,
                "r": 0.07_587,
                "s": 0.06_327,
                "t": 0.09_356,
                "u": 0.02_758,
                "v": 0.00_978,
                "w": 0.02_560,
                "x": 0.00_150,
                "y": 0.01_994,
                "z": 0.00_077,
            }
      else:
            # Custom frequencies dictionary
            lowerCamelCase__	:       Optional[int]					=						frequencies_dict

      if not case_sensitive:
            lowerCamelCase__	:       str					=						ciphertext.lower()

      # Chi squared statistic values
      lowerCamelCase__	:       dict[int, tuple[float, str]]					=						{}

      # cycle through all of the shifts
      for shift in range(len(_A		)		):
            lowerCamelCase__	:       Optional[Any]					=						""

            # decrypt the message with the shift
            for letter in ciphertext:
                  try:
                        # Try to index the letter in the alphabet
                        lowerCamelCase__	:       Dict					=						(alphabet_letters.index(letter.lower()		) - shift) % len(
                            _A		)
                        decrypted_with_shift += (
                            alphabet_letters[new_key].upper()
                            if case_sensitive and letter.isupper()
                            else alphabet_letters[new_key]
                        )
                  except ValueError:
                        # Append the character if it isn't in the alphabet
                        decrypted_with_shift += letter

            lowerCamelCase__	:       str					=						0.0

            # Loop through each letter in the decoded message with the shift
            for letter in decrypted_with_shift:
                  if case_sensitive:
                        lowerCamelCase__	:       List[str]					=						letter.lower()
                        if letter in frequencies:
                              # Get the amount of times the letter occurs in the message
                              lowerCamelCase__	:       List[str]					=						decrypted_with_shift.lower().count(_A		)

                              # Get the excepcted amount of times the letter should appear based
                              # on letter frequencies
                              lowerCamelCase__	:       List[Any]					=						frequencies[letter] * occurrences

                              # Complete the chi squared statistic formula
                              lowerCamelCase__	:       str					=						((occurrences - expected) ** 2) / expected

                              # Add the margin of error to the total chi squared statistic
                              chi_squared_statistic += chi_letter_value
                  else:
                        if letter.lower() in frequencies:
                              # Get the amount of times the letter occurs in the message
                              lowerCamelCase__	:       Any					=						decrypted_with_shift.count(_A		)

                              # Get the excepcted amount of times the letter should appear based
                              # on letter frequencies
                              lowerCamelCase__	:       str					=						frequencies[letter] * occurrences

                              # Complete the chi squared statistic formula
                              lowerCamelCase__	:       int					=						((occurrences - expected) ** 2) / expected

                              # Add the margin of error to the total chi squared statistic
                              chi_squared_statistic += chi_letter_value

        # Add the data to the chi_squared_statistic_values dictionary
            lowerCamelCase__	:       Optional[int]					=						(
                chi_squared_statistic,
                decrypted_with_shift,
            )

      # Get the most likely cipher by finding the cipher with the smallest chi squared
      # statistic
      def chi_squared_statistic_values_sorting_key(_A    :					int		) -> tuple[float, str]:
            return chi_squared_statistic_values[key]

      lowerCamelCase__	:       int					=						min(
          _A					,      key=_A					,      )

      # Get all the data from the most likely cipher (key, decoded message)
      (
          (
          lowerCamelCase__
      )					,     (
          lowerCamelCase__
      )					,     
      )	:       int					=						chi_squared_statistic_values[most_likely_cipher]

      # Return the data on the most likely shift
      return (
          most_likely_cipher,
          most_likely_cipher_chi_squared_value,
          decoded_most_likely_cipher,
      )


