



from __future__ import annotations
def 		UpperCamelCase     (       snake_case__	:   Union[str, Any]	,					snake_case__	:   List[str] = None	,					snake_case__	:   Any = None	,					snake_case__	:   str = False	,					)     ->					tuple[int, float, str]:
   UpperCamelCase   :  Dict						     =     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)
      UpperCamelCase   :  Any						     =     {
          'a': 0.08497,
          'b': 0.01492,
          'c': 0.02202,
          'd': 0.04253,
          'e': 0.11162,
          'f': 0.02228,
          'g': 0.02015,
          'h': 0.06094,
          'i': 0.07546,
          'j': 0.00153,
          'k': 0.01292,
          'l': 0.04025,
          'm': 0.02406,
          'n': 0.06749,
          'o': 0.07507,
          'p': 0.01929,
          'q': 0.00095,
          'r': 0.07587,
          's': 0.06327,
          't': 0.09356,
          'u': 0.02758,
          'v': 0.00978,
          'w': 0.02560,
          'x': 0.00150,
          'y': 0.01994,
          'z': 0.00077,
      }
   else:
      # Custom frequencies dictionary
      UpperCamelCase   :  Union[str, Any]						     =     frequencies_dict

   if not case_sensitive:
      UpperCamelCase   :  Tuple						     =     ciphertext.lower()

   # Chi squared statistic values
   UpperCamelCase   :  Optional[int]						     =     {}

   # cycle through all of the shifts
   for shift in range(len(a_     )     ):
      UpperCamelCase   :  Tuple						     =     ''

      # decrypt the message with the shift
      for letter in ciphertext:
         try:
            # Try to index the letter in the alphabet
            UpperCamelCase   :  Optional[int]						     =     (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

      UpperCamelCase   :  Dict						     =     0.0

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

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

               # Complete the chi squared statistic formula
               UpperCamelCase   :  List[Any]						     =     ((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
               UpperCamelCase   :  Optional[int]						     =     decrypted_with_shift.count(a_     )

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

               # Complete the chi squared statistic formula
               UpperCamelCase   :  Any						     =     ((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
      UpperCamelCase   :  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(snake_case__	:   List[str]     ) -> tuple[float, str]:
      return chi_squared_statistic_values[key]

   UpperCamelCase   :  Any						     =     min(
       a_	,					key=a_	,					)

   # Get all the data from the most likely cipher (key, decoded message)
   (
       (
       UpperCamelCase       
   )     ,					(
       UpperCamelCase       
   )     ,					       
   )   :  Dict						     =     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,
   )









import re
def 		UpperCamelCase     (       snake_case__	:   str     )     ->					str:

   if len(re.findall('[ATCG]'	,					snake_case__     )     ) != len(snake_case__     ):
      raise ValueError('Invalid Strand'     )

   return dna.translate(dna.maketrans('ATCG'	,					'TAGC'     )     )


if __name__ == "__main__":
    import doctest

    doctest.testmod()



