"""simple docstring"""




# Copyright 2022 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
from typing import List



def 				__a       (			_lowercase							, _lowercase						):







					"""simple docstring"""





					if name != "training_function" and name != "main":
										raise ValueError(f"""Incorrect function name passed: {name}, choose either 'main' or 'training_function'"""						)
					lowerCamelCase__				,						lowerCamelCase__		:   List[str]  				=					[], False
					for line in lines:
										if not found_start and f"""def {name}""" in line:
															lowerCamelCase__		:   Tuple  				=					True
															good_lines.append(_lowercase						)
															continue
										if found_start:
															if name == "training_function" and "def main" in line:
																				return good_lines
															if name == "main" and "if __name__" in line:
																				return good_lines
															good_lines.append(_lowercase						)



def 				__a       (			_lowercase						):







					"""simple docstring"""





					return [line for line in lines if not line.lstrip().startswith('''#'''						) and line != "\n"]





def 				__a       (			_lowercase							, _lowercase							, _lowercase							, _lowercase = None						):







					"""simple docstring"""





					with open(_lowercase							, '''r'''						) as f:
										lowerCamelCase__		:   Optional[Any]  				=					f.readlines()
					with open(os.path.abspath(os.path.join('''examples'''							, '''nlp_example.py'''						)						)							, '''r'''						) as f:
										lowerCamelCase__		:   Union[str, Any]  				=					f.readlines()
					with open(_lowercase							, '''r'''						) as f:
										lowerCamelCase__		:   Union[str, Any]  				=					f.readlines()
					if secondary_filename is not None:
										with open(_lowercase							, '''r'''						) as f:
															lowerCamelCase__		:   Any  				=					f.readlines()

    # This is our base, we remove all the code from here in our `full_filename` and `feature_filename` to find the new content
					if parser_only:
										lowerCamelCase__		:   int  				=					clean_lines(get_function_contents_by_name(_lowercase							, '''main'''						)						)
										lowerCamelCase__		:   Dict  				=					clean_lines(get_function_contents_by_name(_lowercase							, '''main'''						)						)
										lowerCamelCase__		:   Any  				=					clean_lines(get_function_contents_by_name(_lowercase							, '''main'''						)						)
										if secondary_filename is not None:
															lowerCamelCase__		:   List[Any]  				=					clean_lines(get_function_contents_by_name(_lowercase							, '''main'''						)						)
					else:
										lowerCamelCase__		:   List[str]  				=					clean_lines(get_function_contents_by_name(_lowercase							, '''training_function'''						)						)
										lowerCamelCase__		:   Any  				=					clean_lines(get_function_contents_by_name(_lowercase							, '''training_function'''						)						)
										lowerCamelCase__		:   List[Any]  				=					clean_lines(get_function_contents_by_name(_lowercase							, '''training_function'''						)						)
										if secondary_filename is not None:
															lowerCamelCase__		:   List[Any]  				=					clean_lines(
															    get_function_contents_by_name(_lowercase							, '''training_function'''						)						)

					lowerCamelCase__		:   Tuple  				=					'''train_dataloader, eval_dataloader = get_dataloaders(accelerator, batch_size)\n'''

					# Specific code in our script that differs from the full version, aka what is new
					lowerCamelCase__		:   int  				=					[]
					lowerCamelCase__		:   Optional[Any]  				=					[]  # We keep track of the idxs just in case it's a repeated statement
					lowerCamelCase__		:   Union[str, Any]  				=					iter(_lowercase						)
					for i in range(len(_lowercase						) - 1						):
										if i not in passed_idxs:
															lowerCamelCase__		:   Optional[int]  				=					next(_lowercase						)
															if (line not in full_file_func) and (line.lstrip() != _dl_line):
																				if "TESTING_MOCKED_DATALOADERS" not in line:
																									new_feature_code.append(_lowercase						)
																									passed_idxs.append(_lowercase						)
																				else:
																									# Skip over the `config['num_epochs'] = 2` statement
																									lowerCamelCase__		:   int  				=					next(_lowercase						)

    # Extract out just the new parts from the full_file_training_func
					lowerCamelCase__		:   Dict  				=					[]
					lowerCamelCase__		:   List[str]  				=					[]  # We keep track of the idxs just in case it's a repeated statement
					for i, line in enumerate(_lowercase						):
										if i not in passed_idxs:
															if (line not in full_file_func) and (line.lstrip() != _dl_line):
																				if "TESTING_MOCKED_DATALOADERS" not in line:
																									new_full_example_parts.append(_lowercase						)
																									passed_idxs.append(_lowercase						)

    # Finally, get the overall diff
					lowerCamelCase__		:   List[Any]  				=					[line for line in new_feature_code if line not in new_full_example_parts]
					if secondary_filename is not None:
										lowerCamelCase__		:   Union[str, Any]  				=					[line for line in full_file_contents if line not in secondary_file_func]
										lowerCamelCase__		:   Optional[int]  				=					[line for line in diff_from_example if line not in diff_from_two]

					return diff_from_example







"""simple docstring"""




import os
import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device


if is_torch_available():
					import torch

					from transformers import GPTaLMHeadModel

@require_torch
@require_sentencepiece
@require_tokenizers
class        __SCREAMING_SNAKE_CASE     (   unittest.TestCase							):







				@slow
				@unittest.skip('''Model is not available.'''  )
				def   lowercase_		(    self    :Union[str, Any]  )      ->					Optional[int]:




									"""simple docstring"""



									lowerCamelCase__		:   Any  				=					'''nvidia/megatron-gpt2-345m/'''
									if "MYDIR" in os.environ:
														lowerCamelCase__		:   str  				=					os.path.join(os.environ['''MYDIR''']      ,__UpperCAmelCase  )
									lowerCamelCase__		:   Dict  				=					GPTaLMHeadModel.from_pretrained(__UpperCAmelCase  )
									model.to(__UpperCAmelCase  )
									model.half()

									lowerCamelCase__		:   Dict  				=					torch.tensor(
									    [[1_01, 71_10, 10_05, 10_56, 20_23, 1_13_33, 1_74_13, 10_29, 1_02]]      ,device=__UpperCAmelCase      ,dtype=torch.long      ,)

									with torch.no_grad():
														lowerCamelCase__		:   Tuple  				=					model(__UpperCAmelCase  ).logits

									lowerCamelCase__		:   List[str]  				=					torch.Size((1, 9, 5_02_57)  )
									self.assertEqual(output.shape      ,__UpperCAmelCase  )

									lowerCamelCase__		:   Tuple  				=					torch.tensor(
									    [
									        4.9_414,
									        -0.2_920,
									        -1.2_148,
									        -4.0_273,
									        -0.5_161,
									        -5.2_109,
									        -1.2_412,
									        -1.8_301,
									        -1.7_734,
									        -4.7_148,
									        -0.2_317,
									        -1.0_811,
									        -2.1_777,
									        0.4_141,
									        -3.7_969,
									        -4.0_586,
									        -2.5_332,
									        -3.3_809,
									        4.3_867,
									    ]      ,device=__UpperCAmelCase      ,dtype=torch.half      ,)

									for i in range(19  ):
														lowerCamelCase__				,						lowerCamelCase__		:   Dict  				=					8 * i // 17, 27_92 * i  # along the diagonal
														lowerCamelCase__				,						lowerCamelCase__		:   Optional[int]  				=					output[0, r, c], expected_diag[i]
														lowerCamelCase__		:   Dict  				=					F"""row={r} col={c} computed={computed} expected={expected}"""
														self.assertAlmostEqual(__UpperCAmelCase      ,__UpperCAmelCase      ,delta=1E-4      ,msg=__UpperCAmelCase  )






