






from ...configuration_utils import PretrainedConfig
from ...utils import logging


snake_case_							=			logging.get_logger(__name__)

snake_case_							=			{
    '''funnel-transformer/small''': '''https://huggingface.co/funnel-transformer/small/resolve/main/config.json''',
    '''funnel-transformer/small-base''': '''https://huggingface.co/funnel-transformer/small-base/resolve/main/config.json''',
    '''funnel-transformer/medium''': '''https://huggingface.co/funnel-transformer/medium/resolve/main/config.json''',
    '''funnel-transformer/medium-base''': '''https://huggingface.co/funnel-transformer/medium-base/resolve/main/config.json''',
    '''funnel-transformer/intermediate''': (
        '''https://huggingface.co/funnel-transformer/intermediate/resolve/main/config.json'''
    ),
    '''funnel-transformer/intermediate-base''': (
        '''https://huggingface.co/funnel-transformer/intermediate-base/resolve/main/config.json'''
    ),
    '''funnel-transformer/large''': '''https://huggingface.co/funnel-transformer/large/resolve/main/config.json''',
    '''funnel-transformer/large-base''': '''https://huggingface.co/funnel-transformer/large-base/resolve/main/config.json''',
    '''funnel-transformer/xlarge''': '''https://huggingface.co/funnel-transformer/xlarge/resolve/main/config.json''',
    '''funnel-transformer/xlarge-base''': '''https://huggingface.co/funnel-transformer/xlarge-base/resolve/main/config.json''',
}
class        snake_case_		(			_A):
		lowerCamelCase    :List[Any]						=     "funnel"
		lowerCamelCase    :Any						=     {
		    "hidden_size": "d_model",
		    "num_attention_heads": "n_head",
		}







		def __init__(		self			,     __lowercase=3_0_5_2_2			,     __lowercase=[4, 4, 4]			,     __lowercase=None			,     __lowercase=2			,     __lowercase=7_6_8			,     __lowercase=1_2			,     __lowercase=6_4			,     __lowercase=3_0_7_2			,     __lowercase="gelu_new"			,     __lowercase=0.1			,     __lowercase=0.1			,     __lowercase=0.0			,     __lowercase=0.1			,     __lowercase=None			,     __lowercase=1e-9			,     __lowercase="mean"			,     __lowercase="relative_shift"			,     __lowercase=True			,     __lowercase=True			,     __lowercase=True			,     **__lowercase			,     )				->   Optional[int]:
				lowerCamelCase   : Any								=vocab_size
				lowerCamelCase   : Optional[Any]								=block_sizes
				lowerCamelCase   : Dict								=[1] * len(__lowercase   ) if block_repeats is None else block_repeats
				assert len(__lowercase   ) == len(
				    self.block_repeats   ), "`block_sizes` and `block_repeats` should have the same length."
				lowerCamelCase   : str								=num_decoder_layers
				lowerCamelCase   : Optional[int]								=d_model
				lowerCamelCase   : Optional[Any]								=n_head
				lowerCamelCase   : Tuple								=d_head
				lowerCamelCase   : Tuple								=d_inner
				lowerCamelCase   : List[str]								=hidden_act
				lowerCamelCase   : Optional[int]								=hidden_dropout
				lowerCamelCase   : List[str]								=attention_dropout
				lowerCamelCase   : Any								=activation_dropout
				lowerCamelCase   : str								=initializer_range
				lowerCamelCase   : Any								=initializer_std
				lowerCamelCase   : Optional[int]								=layer_norm_eps
				assert pooling_type in [
				    "mean",
				    "max",
				], F"Got {pooling_type} for `pooling_type` but only 'mean' and 'max' are supported."
				lowerCamelCase   : Dict								=pooling_type
				assert attention_type in [
				    "relative_shift",
				    "factorized",
				], F"Got {attention_type} for `attention_type` but only 'relative_shift' and 'factorized' are supported."
				lowerCamelCase   : int								=attention_type
				lowerCamelCase   : Dict								=separate_cls
				lowerCamelCase   : Union[str, Any]								=truncate_seq
				lowerCamelCase   : Any								=pool_q_only

				super().__init__(**__lowercase   )







		@property
		def 			__lowercase   (		self   )				->   List[str]:
				return sum(self.block_sizes   )







		@num_hidden_layers.setter
		def 			__lowercase   (		self			,     __lowercase   )				->   int:
				raise NotImplementedError(
				    '''This model does not support the setting of `num_hidden_layers`. Please set `block_sizes`.'''   )







		@property
		def 			__lowercase   (		self   )				->   int:
				return len(self.block_sizes   )







		@num_blocks.setter
		def 			__lowercase   (		self			,     __lowercase   )				->   str:
				raise NotImplementedError('''This model does not support the setting of `num_blocks`. Please set `block_sizes`.'''   )








from __future__ import annotations


def 					A__	(       SCREAMING_SNAKE_CASE_							,       SCREAMING_SNAKE_CASE_ = None							,       SCREAMING_SNAKE_CASE_ = None							,       SCREAMING_SNAKE_CASE_ = False							,       )   ->     tuple[int, float, str]:
		lowerCamelCase   : Union[str, Any]								=cipher_alphabet or [chr(SCREAMING_SNAKE_CASE_		) for i in range(9_7							,       1_2_3		)]

		# 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   : str								={
				    '''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
				lowerCamelCase   : Tuple								=frequencies_dict

		if not case_sensitive:
				lowerCamelCase   : Any								=ciphertext.lower()

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

		# cycle through all of the shifts
		for shift in range(len(SCREAMING_SNAKE_CASE_		)		):
				lowerCamelCase   : int								=''''''

				# 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(
								    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

				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   : Union[str, Any]								=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(SCREAMING_SNAKE_CASE_		)

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

										# Complete the chi squared statistic formula
										lowerCamelCase   : Tuple								=((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   : Optional[int]								=decrypted_with_shift.count(SCREAMING_SNAKE_CASE_		)

										# Get the excepcted amount of times the letter should appear based
										# on letter frequencies
										lowerCamelCase   : Union[str, Any]								=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   : Dict								=(
				    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]

		lowerCamelCase   : int								=min(
		    SCREAMING_SNAKE_CASE_							,       key=SCREAMING_SNAKE_CASE_							,       )

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

