





from __future__ import annotations




def     __UpperCamelCase						(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE = None	,		_SCREAMING_SNAKE_CASE = None	,		_SCREAMING_SNAKE_CASE = False	,		)       ->     tuple[int, float, str]:
  lowercase__			    =						cipher_alphabet or [chr(_SCREAMING_SNAKE_CASE	) 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)
    lowercase__			    =						{
        'a': 0.0_8_4_9_7,
        'b': 0.0_1_4_9_2,
        'c': 0.0_2_2_0_2,
        'd': 0.0_4_2_5_3,
        'e': 0.1_1_1_6_2,
        'f': 0.0_2_2_2_8,
        'g': 0.0_2_0_1_5,
        'h': 0.0_6_0_9_4,
        'i': 0.0_7_5_4_6,
        'j': 0.0_0_1_5_3,
        'k': 0.0_1_2_9_2,
        'l': 0.0_4_0_2_5,
        'm': 0.0_2_4_0_6,
        'n': 0.0_6_7_4_9,
        'o': 0.0_7_5_0_7,
        'p': 0.0_1_9_2_9,
        'q': 0.0_0_0_9_5,
        'r': 0.0_7_5_8_7,
        's': 0.0_6_3_2_7,
        't': 0.0_9_3_5_6,
        'u': 0.0_2_7_5_8,
        'v': 0.0_0_9_7_8,
        'w': 0.0_2_5_6_0,
        'x': 0.0_0_1_5_0,
        'y': 0.0_1_9_9_4,
        'z': 0.0_0_0_7_7,
    }
  else:
    # Custom frequencies dictionary
    lowercase__			    =						frequencies_dict

  if not case_sensitive:
    lowercase__			    =						ciphertext.lower()

  # Chi squared statistic values
  lowercase__			    =						{}

  # cycle through all of the shifts
  for shift in range(len(_SCREAMING_SNAKE_CASE	)	):
    lowercase__			    =						''

    # decrypt the message with the shift
    for letter in ciphertext:
      try:
        # Try to index the letter in the alphabet
        lowercase__			    =						(alphabet_letters.index(letter.lower()	) - shift) % len(
            _SCREAMING_SNAKE_CASE	)
        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

    lowercase__			    =						0.0

    # Loop through each letter in the decoded message with the shift
    for letter in decrypted_with_shift:
      if case_sensitive:
        lowercase__			    =						letter.lower()
        if letter in frequencies:
          # Get the amount of times the letter occurs in the message
          lowercase__			    =						decrypted_with_shift.lower().count(_SCREAMING_SNAKE_CASE	)

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

          # Complete the chi squared statistic formula
          lowercase__			    =						((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
          lowercase__			    =						decrypted_with_shift.count(_SCREAMING_SNAKE_CASE	)

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

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

  lowercase__			    =						min(
      _SCREAMING_SNAKE_CASE	,		key=_SCREAMING_SNAKE_CASE	,		)

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









def     __UpperCamelCase						(_SCREAMING_SNAKE_CASE	)       ->     bool:
  if not isinstance(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	):
    raise ValueError('Input series is not valid, valid series - [2, 4, 6]'	)
  if len(_SCREAMING_SNAKE_CASE	) == 0:
    raise ValueError('Input list must be a non empty list'	)
  if len(_SCREAMING_SNAKE_CASE	) == 1:
    return True
  lowercase__			    =						series[1] - series[0]
  for index in range(len(_SCREAMING_SNAKE_CASE	) - 1	):
    if series[index + 1] - series[index] != common_diff:
      return False
  return True




def     __UpperCamelCase						(_SCREAMING_SNAKE_CASE	)       ->     float:
  if not isinstance(_SCREAMING_SNAKE_CASE	,		_SCREAMING_SNAKE_CASE	):
    raise ValueError('Input series is not valid, valid series - [2, 4, 6]'	)
  if len(_SCREAMING_SNAKE_CASE	) == 0:
    raise ValueError('Input list must be a non empty list'	)
  lowercase__			    =						0
  for val in series:
    answer += val
  return answer / len(_SCREAMING_SNAKE_CASE	)


if __name__ == "__main__":
      import doctest

      doctest.testmod()


