
'''simple docstring'''







import argparse

import torch
from torch import nn

from transformers import SpeechaTextConfig, SpeechaTextForConditionalGeneration







def 				SCREAMING_SNAKE_CASE__	(   __A	)       ->	Optional[int]:
	_snake_case   						=		[
	    'encoder.version',
	    'decoder.version',
	    'model.encoder.version',
	    'model.decoder.version',
	    'decoder.output_projection.weight',
	    '_float_tensor',
	    'encoder.embed_positions._float_tensor',
	    'decoder.embed_positions._float_tensor',
	]
	for k in ignore_keys:
		state_dict.pop(__A			,				__A	)







def 				SCREAMING_SNAKE_CASE__	(   __A	)       ->	Dict:
	_snake_case   						=		list(s_dict.keys()	)
	for key in keys:
		if "transformer_layers" in key:
			_snake_case   						=		s_dict.pop(__A	)
		elif "subsample" in key:
			_snake_case   						=		s_dict.pop(__A	)







def 				SCREAMING_SNAKE_CASE__	(   __A	)       ->	Dict:
	_snake_case						, _snake_case   						=		emb.weight.shape
	_snake_case   						=		nn.Linear(__A			,				__A			,				bias=__A	)
	_snake_case   						=		emb.weight.data
	return lin_layer







def 				SCREAMING_SNAKE_CASE__	(   __A			,				__A	)       ->	Union[str, Any]:
	_snake_case   						=		torch.load(__A			,				map_location='cpu'	)
	_snake_case   						=		mam_aaa['args']
	_snake_case   						=		mam_aaa['model']
	_snake_case   						=		state_dict['decoder.output_projection.weight']

	remove_ignore_keys_(__A	)
	rename_keys(__A	)

	_snake_case   						=		state_dict['decoder.embed_tokens.weight'].shape[0]

	_snake_case   						=		args.share_decoder_input_output_embed

	_snake_case   						=		[int(__A	) for i in args.conv_kernel_sizes.split(','	)]
	_snake_case   						=		SpeechaTextConfig(
	    vocab_size=__A			,				max_source_positions=args.max_source_positions			,				max_target_positions=args.max_target_positions			,				encoder_layers=args.encoder_layers			,				decoder_layers=args.decoder_layers			,				encoder_attention_heads=args.encoder_attention_heads			,				decoder_attention_heads=args.decoder_attention_heads			,				encoder_ffn_dim=args.encoder_ffn_embed_dim			,				decoder_ffn_dim=args.decoder_ffn_embed_dim			,				d_model=args.encoder_embed_dim			,				dropout=args.dropout			,				attention_dropout=args.attention_dropout			,				activation_dropout=args.activation_dropout			,				activation_function='relu'			,				num_conv_layers=len(__A	)			,				conv_channels=args.conv_channels			,				conv_kernel_sizes=__A			,				input_feat_per_channel=args.input_feat_per_channel			,				input_channels=args.input_channels			,				tie_word_embeddings=__A			,				num_beams=5			,				max_length=200			,				use_cache=__A			,				decoder_start_token_id=2			,				early_stopping=__A			,				)

	_snake_case   						=		SpeechaTextForConditionalGeneration(__A	)
	_snake_case						, _snake_case   						=		model.model.load_state_dict(__A			,				strict=__A	)
	if len(__A	) > 0 and not set(__A	) <= {
	    "encoder.embed_positions.weights",
	    "decoder.embed_positions.weights",
	}:
		raise ValueError(
		    'Only `encoder.embed_positions.weights` and `decoder.embed_positions.weights`  are allowed to be missing,'
		    F' but all the following weights are missing {missing}'	)

	if tie_embeds:
		_snake_case   						=		make_linear_from_emb(model.model.decoder.embed_tokens	)
	else:
		_snake_case   						=		lm_head_weights

	model.save_pretrained(__A	)


if __name__ == "__main__":
					lowercase    :							str      =					argparse.ArgumentParser()
					# Required parameters
					parser.add_argument("--fairseq_path", type=str, help="Path to the fairseq model (.pt) file.")
					parser.add_argument("--pytorch_dump_folder_path", default=None, type=str, help="Path to the output PyTorch model.")
					lowercase    :							Any      =					parser.parse_args()
					convert_fairseq_sat_checkpoint_to_tfms(args.fairseq_path, args.pytorch_dump_folder_path)







'''simple docstring'''

# tests directory-specific settings - this file is run automatically
# by pytest before any tests are run

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  :				int									=  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 		__magic_name__    (	__UpperCAmelCase	)		->					Optional[int]:

					'''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 		__magic_name__    (	__UpperCAmelCase	)		->					int:

					'''simple docstring'''

					from transformers.testing_utils import pytest_addoption_shared

					pytest_addoption_shared(__UpperCAmelCase	)


def 		__magic_name__    (	__UpperCAmelCase	)		->					Union[str, Any]:

					'''simple docstring'''

					from transformers.testing_utils import pytest_terminal_summary_main

					snake_case_									=				terminalreporter.config.getoption('''--make-reports'''	)
					if make_reports:
										pytest_terminal_summary_main(__UpperCAmelCase,      id=__UpperCAmelCase	)


def 		__magic_name__    (	__UpperCAmelCase,      __UpperCAmelCase	)		->					Optional[int]:

					'''simple docstring'''

					if exitstatus == 5:
										snake_case_									=				0


# Doctest custom flag to ignore output.
a  :				Union[str, Any]									=  doctest.register_optionflag('IGNORE_RESULT')

a  :				Optional[int]									=  doctest.OutputChecker






class 						a				(   _lowerCamelCase     ):


				def   A_ (		self    :					List[Any]       ,				lowercase_    :					int       ,				lowercase_    :					Tuple       ,				lowercase_    :					Optional[int]					):
									if IGNORE_RESULT & optionflags:
														return True
									return OutputChecker.check_output(self       ,				lowercase_       ,				lowercase_       ,				lowercase_					)







a  :				List[Any]									=  CustomOutputChecker
a  :				Optional[int]									=  HfDoctestModule

a  :				Tuple									=  HfDocTestParser

