"""simple docstring"""





import doctest
import sys
import warnings
from os.path import abspath, dirname, join

import _pytest

from transformers.testing_utils import HfDoctestModule, HfDocTestParser


# allow having multiple repository checkouts and not needing to remember to rerun
# 'pip install -e .[dev]' when switching between checkouts and running tests.
__A  =				abspath(join(dirname(__file__), '''src'''))
sys.path.insert(1, git_repo_path)

# silence FutureWarning warnings in tests since often we can't act on them until
# they become normal warnings - i.e. the tests still need to test the current functionality
warnings.simplefilter(action='''ignore''', category=FutureWarning)


def    lowercase_   (   _lowerCamelCase:	List[Any]      ) ->      Union[str, Any]:



       '''simple docstring'''

       config.addinivalue_line(
           "markers"						,   "is_pt_tf_cross_test: mark test to run only when PT and TF interactions are tested"      )
       config.addinivalue_line(
           "markers"						,   "is_pt_flax_cross_test: mark test to run only when PT and FLAX interactions are tested"      )
       config.addinivalue_line("markers"						,   "is_pipeline_test: mark test to run only when pipelines are tested"      )
       config.addinivalue_line("markers"						,   "is_staging_test: mark test to run only in the staging environment"      )
       config.addinivalue_line("markers"						,   "accelerate_tests: mark test that require accelerate"      )
       config.addinivalue_line("markers"						,   "tool_tests: mark the tool tests that are run on their specific schedule"      )


def    lowercase_   (   _lowerCamelCase:	Union[str, Any]      ) ->      Any:



       '''simple docstring'''

       from transformers.testing_utils import pytest_addoption_shared

       pytest_addoption_shared(_lowerCamelCase      )


def    lowercase_   (   _lowerCamelCase:	Optional[int]      ) ->      Tuple:



       '''simple docstring'''

       from transformers.testing_utils import pytest_terminal_summary_main

       __lowerCamelCase					:		Any		   =     terminalreporter.config.getoption("--make-reports"      )
       if make_reports:
              pytest_terminal_summary_main(_lowerCamelCase						,   id=_lowerCamelCase      )


def    lowercase_   (   _lowerCamelCase:	Union[str, Any]						,   _lowerCamelCase:	Tuple      ) ->      Dict:



       '''simple docstring'''

       if exitstatus == 5:
              __lowerCamelCase					:		Optional[int]		   =     0


# Doctest custom flag to ignore output.
__A  =				doctest.register_optionflag('''IGNORE_RESULT''')

__A  =				doctest.OutputChecker
class  _snake_case     (					a__		):






      def       lowerCamelCase__     (       self      :			List[str]							,					UpperCAmelCase      :			int							,					UpperCAmelCase      :			Any							,					UpperCAmelCase      :			int    ):
             if IGNORE_RESULT & optionflags:
                    return True
             return OutputChecker.check_output(self							,					UpperCAmelCase							,					UpperCAmelCase							,					UpperCAmelCase    )

__A  =				CustomOutputChecker
__A  =				HfDoctestModule







__A  =				HfDocTestParser
"""simple docstring"""





import argparse

from transformers import TaConfig, TaForConditionalGeneration, load_tf_weights_in_ta
from transformers.utils import logging


logging.set_verbosity_info()


def    lowercase_   (   _lowerCamelCase:	Dict						,   _lowerCamelCase:	str						,   _lowerCamelCase:	Dict      ) ->      List[str]:



							'''simple docstring'''

							__lowerCamelCase					:		List[Any]		   =     TaConfig.from_json_file(_lowerCamelCase      )
							print(F"""Building PyTorch model from configuration: {config}"""      )
							__lowerCamelCase					:		Optional[int]		   =     TaForConditionalGeneration(_lowerCamelCase      )

							# Load weights from tf checkpoint
							load_tf_weights_in_ta(_lowerCamelCase						,   _lowerCamelCase						,   _lowerCamelCase      )

							# Save pytorch-model
							print(F"""Save PyTorch model to {pytorch_dump_path}"""      )
							model.save_pretrained(_lowerCamelCase      )


if __name__ == "__main__":
				__A  =				argparse.ArgumentParser()
				# Required parameters
				parser.add_argument(
				    '''--tf_checkpoint_path''', default=None, type=str, required=True, help='''Path to the TensorFlow checkpoint path.'''
				)
				parser.add_argument(
				    '''--config_file''',
				    default=None,
				    type=str,
				    required=True,
				    help=(
				        '''The config json file corresponding to the pre-trained T5 model. \nThis specifies the model architecture.'''
				    ),
				)
				parser.add_argument(
				    '''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.'''
				)
				__A  =				parser.parse_args()
				convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path)