






'''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.
UpperCamelCase    :      Optional[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 						A__			(				__lowerCAmelCase		:			List[str]						):
						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 						A__			(				__lowerCAmelCase		:			Optional[int]						):
						from transformers.testing_utils import pytest_addoption_shared

						pytest_addoption_shared(lowercase_						)
def 						A__			(				__lowerCAmelCase		:			List[str]						):
						from transformers.testing_utils import pytest_terminal_summary_main

						lowerCamelCase__         =  terminalreporter.config.getoption("""--make-reports"""						)
						if make_reports:
												pytest_terminal_summary_main(lowercase_   ,    id=lowercase_						)
def 						A__			(				__lowerCAmelCase		:			Union[str, Any]   ,    __lowerCAmelCase		:			int						):
						# If no tests are collected, pytest exists with code 5, which makes the CI fail.
						if exitstatus == 5:
												lowerCamelCase__         =  0


# Doctest custom flag to ignore output.
UpperCamelCase    :      Tuple  			=		doctest.register_optionflag('IGNORE_RESULT')

UpperCamelCase    :      Dict  			=		doctest.OutputChecker




class 		UpperCamelCase__    (a			):




		'''simple docstring'''





		def 			UpperCamelCase_					(      self   ,_lowerCAmelCase   ,_lowerCAmelCase   ,_lowerCAmelCase       ):
								if IGNORE_RESULT & optionflags:
														return True
								return OutputChecker.check_output(self   ,A__   ,A__   ,A__       )



UpperCamelCase    :      str  			=		CustomOutputChecker
UpperCamelCase    :      Dict  			=		HfDoctestModule





UpperCamelCase    :      Optional[int]  			=		HfDocTestParser









'''simple docstring'''







import argparse

import torch
from torch import nn

from transformers import MaMaaaConfig, MaMaaaForConditionalGeneration
def 						A__			(				__lowerCAmelCase		:			Union[str, Any]						):
						lowerCamelCase__         =  [
						    """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(__lowerCAmelCase   ,    __lowerCAmelCase						)
def 						A__			(				__lowerCAmelCase		:			Tuple						):
						lowerCamelCase__       ,			lowerCamelCase__         =  emb.weight.shape
						lowerCamelCase__         =  nn.Linear(__lowerCAmelCase   ,    __lowerCAmelCase   ,    bias=__lowerCAmelCase						)
						lowerCamelCase__         =  emb.weight.data
						return lin_layer
def 						A__			(				__lowerCAmelCase		:			Dict						):
						lowerCamelCase__         =  torch.load(__lowerCAmelCase   ,    map_location="""cpu"""						)
						lowerCamelCase__         =  mam_aaa["""args"""] or mam_aaa["""cfg"""]["""model"""]
						lowerCamelCase__         =  mam_aaa["""model"""]
						remove_ignore_keys_(__lowerCAmelCase						)
						lowerCamelCase__         =  state_dict["""encoder.embed_tokens.weight"""].shape[0]

						lowerCamelCase__         =  MaMaaaConfig(
						    vocab_size=__lowerCAmelCase   ,    max_position_embeddings=1024   ,    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   ,    encoder_layerdrop=args.encoder_layerdrop   ,    decoder_layerdrop=args.decoder_layerdrop   ,    dropout=args.dropout   ,    attention_dropout=args.attention_dropout   ,    activation_dropout=args.activation_dropout   ,    activation_function="""relu"""   ,    )

						lowerCamelCase__         =  state_dict["""decoder.embed_tokens.weight"""]
						lowerCamelCase__         =  MaMaaaForConditionalGeneration(__lowerCAmelCase						)
						model.model.load_state_dict(__lowerCAmelCase   ,    strict=__lowerCAmelCase						)
						lowerCamelCase__         =  make_linear_from_emb(model.model.shared						)

						return model


if __name__ == "__main__":
							UpperCamelCase    :      Optional[Any]  			=		argparse.ArgumentParser()
							# Required parameters
							parser.add_argument('fairseq_path', type=str, help='path to a model.pt on local filesystem.')
							parser.add_argument('pytorch_dump_folder_path', default=None, type=str, help='Path to the output PyTorch model.')
							UpperCamelCase    :      Tuple  			=		parser.parse_args()
							UpperCamelCase    :      List[Any]  			=		convert_fairseq_mamaaa_checkpoint_from_disk(args.fairseq_pathß)
							model.save_pretrained(args.pytorch_dump_folder_path)

