



import copy
import json
import os
import tempfile

from transformers import is_torch_available

from .test_configuration_utils import config_common_kwargs






class    SCREAMING_SNAKE_CASE			(							UpperCAmelCase_					):





       def __init__(   self		:		List[str]      ,				__lowercase		:		Optional[int]      ,				__lowercase		:		Optional[Any]=None      ,				__lowercase		:		Dict=True      ,				__lowercase		:		Union[str, Any]=None      ,				**__lowercase		:		int	):

           '''simple docstring'''
           __a       =		parent
           __a       =		config_class
           __a       =		has_text_modality
           __a       =		kwargs
           __a       =		common_properties





       def 						UpperCamelCase_					(   self		:		Tuple	):

           '''simple docstring'''
           __a       =		self.config_class(**self.inputs_dict	)
           __a       =		(
               ["""hidden_size""", """num_attention_heads""", """num_hidden_layers"""]
               if self.common_properties is None
               else self.common_properties
           )

           # Add common fields for text models
           if self.has_text_modality:
               common_properties.extend(["""vocab_size"""]	)

           # Test that config has the common properties as getters
           for prop in common_properties:
               self.parent.assertTrue(hasattr(_snake_case      ,				_snake_case	)      ,				msg=F"`{prop}` does not exist"	)

           # Test that config has the common properties as setter
           for idx, name in enumerate(_snake_case	):
               try:
                   setattr(_snake_case      ,				_snake_case      ,				_snake_case	)
                   self.parent.assertEqual(
                       getattr(_snake_case      ,				_snake_case	)      ,				_snake_case      ,				msg=F"`{name} value {idx} expected, but was {getattr(_snake_case      ,				_snake_case	)}"	)
               except NotImplementedError:
                   # Some models might not be able to implement setters for common_properties
                   # In that case, a NotImplementedError is raised
                   pass

        # Test if config class can be called with Config(prop_name=..)
           for idx, name in enumerate(_snake_case	):
               try:
                   __a       =		self.config_class(**{name: idx}	)
                   self.parent.assertEqual(
                       getattr(_snake_case      ,				_snake_case	)      ,				_snake_case      ,				msg=F"`{name} value {idx} expected, but was {getattr(_snake_case      ,				_snake_case	)}"	)
               except NotImplementedError:
                   # Some models might not be able to implement setters for common_properties
                   # In that case, a NotImplementedError is raised
                   pass





       def 						UpperCamelCase_					(   self		:		Optional[int]	):

           '''simple docstring'''
           __a       =		self.config_class(**self.inputs_dict	)
           __a       =		json.loads(config.to_json_string()	)
           for key, value in self.inputs_dict.items():
               self.parent.assertEqual(obj[key]      ,				_snake_case	)





       def 						UpperCamelCase_					(   self		:		Optional[int]	):

           '''simple docstring'''
           __a       =		self.config_class(**self.inputs_dict	)

           with tempfile.TemporaryDirectory() as tmpdirname:
               __a       =		os.path.join(_snake_case      ,				"""config.json"""	)
               config_first.to_json_file(_snake_case	)
               __a       =		self.config_class.from_json_file(_snake_case	)

           self.parent.assertEqual(config_second.to_dict()      ,				config_first.to_dict()	)





       def 						UpperCamelCase_					(   self		:		List[str]	):

           '''simple docstring'''
           __a       =		self.config_class(**self.inputs_dict	)

           with tempfile.TemporaryDirectory() as tmpdirname:
               config_first.save_pretrained(_snake_case	)
               __a       =		self.config_class.from_pretrained(_snake_case	)

           self.parent.assertEqual(config_second.to_dict()      ,				config_first.to_dict()	)





       def 						UpperCamelCase_					(   self		:		Dict	):

           '''simple docstring'''
           __a       =		self.config_class(**self.inputs_dict	)

           __a       =		"""test"""
           with tempfile.TemporaryDirectory() as tmpdirname:
               __a       =		os.path.join(_snake_case      ,				_snake_case	)
               config_first.save_pretrained(_snake_case	)
               __a       =		self.config_class.from_pretrained(_snake_case      ,				subfolder=_snake_case	)

           self.parent.assertEqual(config_second.to_dict()      ,				config_first.to_dict()	)





       def 						UpperCamelCase_					(   self		:		Dict	):

           '''simple docstring'''
           __a       =		self.config_class(**self.inputs_dict      ,				num_labels=5	)
           self.parent.assertEqual(len(config.idalabel	)      ,				5	)
           self.parent.assertEqual(len(config.labelaid	)      ,				5	)

           __a       =		3
           self.parent.assertEqual(len(config.idalabel	)      ,				3	)
           self.parent.assertEqual(len(config.labelaid	)      ,				3	)





       def 						UpperCamelCase_					(   self		:		List[Any]	):

           '''simple docstring'''


           if self.config_class.is_composition:
               return
           __a       =		self.config_class()
           self.parent.assertIsNotNone(_snake_case	)





       def 						UpperCamelCase_					(   self		:		Optional[Any]	):

           '''simple docstring'''
           __a       =		copy.deepcopy(_snake_case	)
           __a       =		self.config_class(**_snake_case	)
           __a       =		[]
           for key, value in config_common_kwargs.items():
               if key == "torch_dtype":
                   if not is_torch_available():
                       continue
                   else:
                       import torch

                       if config.torch_dtype != torch.floataa:
                           wrong_values.append(("""torch_dtype""", config.torch_dtype, torch.floataa)	)
               elif getattr(_snake_case      ,				_snake_case	) != value:
                   wrong_values.append((key, getattr(_snake_case      ,				_snake_case	), value)	)

           if len(_snake_case	) > 0:
               __a       =		"""\n""".join([F"- {v[0]}: got {v[1]} instead of {v[2]}" for v in wrong_values]	)
               raise ValueError(F"The following keys were not properly set in the config:\n{errors}"	)







       def 						UpperCamelCase_					(   self		:		Dict	):

           '''simple docstring'''
           self.create_and_test_config_common_properties()
           self.create_and_test_config_to_json_string()
           self.create_and_test_config_to_json_file()
           self.create_and_test_config_from_and_save_pretrained()
           self.create_and_test_config_from_and_save_pretrained_subfolder()
           self.create_and_test_config_with_num_labels()
           self.check_config_can_be_init_without_params()
           self.check_config_arguments_init()





import unittest
from dataclasses import dataclass

import pytest

from accelerate.commands.config.config_args import SageMakerConfig
from accelerate.utils import ComputeEnvironment
from accelerate.utils.launch import _convert_nargs_to_dict






@dataclass
class    SCREAMING_SNAKE_CASE			(							lowerCamelCase__					):
							__lowerCamelCase	:	List[Any]    =ComputeEnvironment.AMAZON_SAGEMAKER
							__lowerCamelCase	:	Optional[int]    =True
							__lowerCamelCase	:	List[Any]    ='ml.p3.2xlarge'
							__lowerCamelCase	:	Optional[int]    ='accelerate_sagemaker_execution_role'
							__lowerCamelCase	:	Optional[Any]    ='hf-sm'
							__lowerCamelCase	:	Any    ='us-east-1'
							__lowerCamelCase	:	Any    =1
							__lowerCamelCase	:	List[str]    ='accelerate-sagemaker-1'
							__lowerCamelCase	:	Union[str, Any]    ='1.6'
							__lowerCamelCase	:	str    ='4.4'
							__lowerCamelCase	:	List[str]    ='train.py'
							__lowerCamelCase	:	List[Any]    =[
							    '--model_name_or_path',
							    'bert',
							    '--do_train',
							    'False',
							    '--epochs',
							    '3',
							    '--learning_rate',
							    '5e-5',
							    '--max_steps',
							    '50.5',
							]
							__lowerCamelCase	:	Tuple    =[
							    '--model_name_or_path',
							    'bert',
							    '--do_train',
							    '--do_test',
							    'False',
							    '--do_predict',
							    '--epochs',
							    '3',
							    '--learning_rate',
							    '5e-5',
							    '--max_steps',
							    '50.5',
							]






class    SCREAMING_SNAKE_CASE			(							unittest.TestCase					):





							def 						UpperCamelCase_					(   self		:		Union[str, Any]	):

											'''simple docstring'''
											# If no defaults are changed, `to_kwargs` returns an empty dict.
											__a       =		_convert_nargs_to_dict(MockLaunchConfig.success_training_script_args	)
											assert isinstance(converted_args["""model_name_or_path"""]      ,				__lowercase	)
											assert isinstance(converted_args["""do_train"""]      ,				__lowercase	)
											assert isinstance(converted_args["""epochs"""]      ,				__lowercase	)
											assert isinstance(converted_args["""learning_rate"""]      ,				__lowercase	)
											assert isinstance(converted_args["""max_steps"""]      ,				__lowercase	)

											with pytest.raises(__lowercase	):
															_convert_nargs_to_dict(MockLaunchConfig.fail_training_script_args	)
