




'''simple docstring'''
from ...configuration_utils import PretrainedConfig
from ...utils import logging


_SCREAMING_SNAKE_CASE			=						logging.get_logger(__name__)

_SCREAMING_SNAKE_CASE			=						{
    "microsoft/trocr-base-handwritten": (
        "https://huggingface.co/microsoft/trocr-base-handwritten/resolve/main/config.json"
    ),
    # See all TrOCR models at https://huggingface.co/models?filter=trocr
}
class   __UpperCAmelCase				(     lowerCAmelCase				):



					'''simple docstring'''





					_UpperCamelCase							=		"""trocr"""
					_UpperCamelCase							=		["""past_key_values"""]
					_UpperCamelCase							=		{
					    """num_attention_heads""": """decoder_attention_heads""",
					    """hidden_size""": """d_model""",
					    """num_hidden_layers""": """decoder_layers""",
					}



					def __init__(	self     :						Any      ,       _lowercase     :						Union[str, Any]=50_265      ,       _lowercase     :						str=1_024      ,       _lowercase     :						Optional[int]=12      ,       _lowercase     :						Union[str, Any]=16      ,       _lowercase     :						Tuple=4_096      ,       _lowercase     :						Dict="gelu"      ,       _lowercase     :						Optional[Any]=512      ,       _lowercase     :						Tuple=0.1      ,       _lowercase     :						int=0.0      ,       _lowercase     :						List[str]=0.0      ,       _lowercase     :						str=2      ,       _lowercase     :						List[Any]=0.02      ,       _lowercase     :						Any=0.0      ,       _lowercase     :						Optional[Any]=True      ,       _lowercase     :						Dict=False      ,       _lowercase     :						Optional[int]=True      ,       _lowercase     :						Any=True      ,       _lowercase     :						Dict=1      ,       _lowercase     :						Optional[int]=0      ,       _lowercase     :						Union[str, Any]=2      ,       **_lowercase     :						Any      ,       )    ->							Optional[int]:
								A_									= vocab_size
								A_									= d_model
								A_									= decoder_layers
								A_									= decoder_attention_heads
								A_									= decoder_ffn_dim
								A_									= activation_function
								A_									= max_position_embeddings
								A_									= dropout
								A_									= attention_dropout
								A_									= activation_dropout
								A_									= init_std
								A_									= decoder_layerdrop
								A_									= use_cache
								A_									= scale_embedding
								A_									= use_learned_position_embeddings
								A_									= layernorm_embedding

								super().__init__(
								    pad_token_id=_lowercase      ,       bos_token_id=_lowercase      ,       eos_token_id=_lowercase      ,       decoder_start_token_id=_lowercase      ,       **_lowercase      ,       )










'''simple docstring'''
def 			lowerCamelCase(							SCREAMING_SNAKE_CASE_       ,SCREAMING_SNAKE_CASE_     )		->		bool:
			A_									= len(SCREAMING_SNAKE_CASE_     ) + 1
			A_									= len(SCREAMING_SNAKE_CASE_     ) + 1

			# dp is a 2d matrix where dp[i][j] denotes whether prefix string of
			# length i of input_string matches with prefix string of length j of
			# given pattern.
			# "dp" stands for dynamic programming.
			A_									= [[0 for i in range(SCREAMING_SNAKE_CASE_     )] for j in range(SCREAMING_SNAKE_CASE_     )]

			# since string of zero length match pattern of zero length
			A_									= 1

			# since pattern of zero length will never match with string of non-zero length
			for i in range(1       ,SCREAMING_SNAKE_CASE_     ):
						A_									= 0

			# since string of zero length will match with pattern where there
			# is at least one * alternatively
			for j in range(1       ,SCREAMING_SNAKE_CASE_     ):
						A_									= dp[0][j - 2] if pattern[j - 1] == '*' else 0

			# now using bottom-up approach to find for all remaining lengths
			for i in range(1       ,SCREAMING_SNAKE_CASE_     ):
						for j in range(1       ,SCREAMING_SNAKE_CASE_     ):
									if input_string[i - 1] == pattern[j - 1] or pattern[j - 1] == ".":
												A_									= dp[i - 1][j - 1]

									elif pattern[j - 1] == "*":
												if dp[i][j - 2] == 1:
															A_									= 1
												elif pattern[j - 2] in (input_string[i - 1], "."):
															A_									= dp[i - 1][j]
												else:
															A_									= 0
									else:
												A_									= 0

			return bool(dp[-1][-1]     )


if __name__ == "__main__":
							import doctest

							doctest.testmod()
							# inputing the strings
							# input_string = input("input a string :")
							# pattern = input("input a pattern :")

							_SCREAMING_SNAKE_CASE			=						"aab"
							_SCREAMING_SNAKE_CASE			=						"c*a*b"

							# using function to check whether given string matches the given pattern
							if match_pattern(input_string, pattern):
														print(f"""{input_string} matches the given pattern {pattern}""")
							else:
														print(f"""{input_string} does not match with the given pattern {pattern}""")




