


"""simple docstring"""







lowerCamelCase_   :   Any									=  {0: [2, 3], 1: [0], 2: [1], 3: [4], 4: []}

lowerCamelCase_   :   Optional[int]									=  {0: [1, 2, 3], 1: [2], 2: [0], 3: [4], 4: [5], 5: [3]}
def _A						(						lowercase       ,    lowercase       ,    lowercase		):







    """simple docstring"""
    a 		=True
    a 		=[]

    for neighbour in graph[vert]:
        if not visited[neighbour]:
            order += topology_sort(lowercase       ,    lowercase       ,    lowercase		)

    order.append(lowercase		)

    return order
def _A						(						lowercase       ,    lowercase       ,    lowercase		):







    """simple docstring"""
    a 		=True
    a 		=[vert]

    for neighbour in reversed_graph[vert]:
        if not visited[neighbour]:
            component += find_components(lowercase       ,    lowercase       ,    lowercase		)

    return component





def _A						(						lowercase		):







    """simple docstring"""
    a 		=len(lowercase		) * [False]
    a 		={vert: [] for vert in range(len(lowercase		)		)}

    for vert, neighbours in graph.items():
        for neighbour in neighbours:
            reversed_graph[neighbour].append(lowercase		)

    a 		=[]
    for i, was_visited in enumerate(lowercase		):
        if not was_visited:
            order += topology_sort(lowercase       ,    lowercase       ,    lowercase		)

    a 		=[]
    a 		=len(lowercase		) * [False]

    for i in range(len(lowercase		)		):
        a 		=order[len(lowercase		) - i - 1]
        if not visited[vert]:
            a 		=find_components(lowercase       ,    lowercase       ,    lowercase		)
            components_list.append(lowercase		)

    return components_list


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        UpperCamelCase_(							_snake_case   :  Dict       ,     _snake_case   :  Optional[int]       ,     _snake_case   :  str	):




			"""simple docstring"""






			if openai_config_file == "":
						__a        =OpenAIGPTConfig()
			else:
						__a        =OpenAIGPTConfig.from_json_file(_snake_case	)
			__a        =OpenAIGPTModel(_snake_case	)

			# Load weights from numpy
			load_tf_weights_in_openai_gpt(_snake_case       ,     _snake_case       ,     _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()       ,     _snake_case	)
			print(F'Save configuration file to {pytorch_config_dump_path}'	)
			with open(_snake_case       ,     'w'       ,     encoding='utf-8'	) as f:
						f.write(config.to_json_string()	)


if __name__ == "__main__":
						_lowerCAmelCase					:			Tuple  				=			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."
						    ),
						)
						_lowerCAmelCase					:			int  				=			parser.parse_args()
						convert_openai_checkpoint_to_pytorch(
						    args.openai_checkpoint_folder_path, args.openai_config_file, args.pytorch_dump_folder_path
						)






