




'''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}""")










'''simple docstring'''
import argparse

import torch

from transformers import OpenAIGPTConfig, OpenAIGPTModel, load_tf_weights_in_openai_gpt
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()





def 			lowerCamelCase(							SCREAMING_SNAKE_CASE_       ,SCREAMING_SNAKE_CASE_       ,SCREAMING_SNAKE_CASE_     )		->		str:
			# Construct model
			if openai_config_file == "":
						A_									= OpenAIGPTConfig()
			else:
						A_									= OpenAIGPTConfig.from_json_file(SCREAMING_SNAKE_CASE_     )
			A_									= OpenAIGPTModel(SCREAMING_SNAKE_CASE_     )

			# Load weights from numpy
			load_tf_weights_in_openai_gpt(SCREAMING_SNAKE_CASE_       ,SCREAMING_SNAKE_CASE_       ,SCREAMING_SNAKE_CASE_     )

			# Save pytorch-model
			A_									= pytorch_dump_folder_path + '/' + WEIGHTS_NAME
			A_									= pytorch_dump_folder_path + '/' + CONFIG_NAME
			print(F'Save PyTorch model to {pytorch_weights_dump_path}'     )
			torch.save(model.state_dict()       ,SCREAMING_SNAKE_CASE_     )
			print(F'Save configuration file to {pytorch_config_dump_path}'     )
			with open(SCREAMING_SNAKE_CASE_       ,'w'       ,encoding='utf-8'     ) as f:
						f.write(config.to_json_string()     )


if __name__ == "__main__":
							_SCREAMING_SNAKE_CASE			=						argparse.ArgumentParser()
							# Required parameters
							parser.add_argument(
							    "--openai_checkpoint_folder_path",
							    default=None,
							    type=str,
							    required=True,
							    help="Path to the TensorFlow checkpoint path.",
							)
							parser.add_argument(
							    "--pytorch_dump_folder_path", default=None, type=str, required=True, help="Path to the output PyTorch model."
							)
							parser.add_argument(
							    "--openai_config_file",
							    default="",
							    type=str,
							    help=(
							        "An optional config json file corresponding to the pre-trained OpenAI model. \n"
							        "This specifies the model architecture."
							    ),
							)
							_SCREAMING_SNAKE_CASE			=						parser.parse_args()
							convert_openai_checkpoint_to_pytorch(
							    args.openai_checkpoint_folder_path, args.openai_config_file, args.pytorch_dump_folder_path
							)




