



'''simple docstring'''





import copy
import json
import os
import tempfile

from transformers import is_torch_available

from .test_configuration_utils import config_common_kwargs


class      __lowerCAmelCase     (		UpperCAmelCase_      ):
					"""simple docstring"""






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






								"""simple docstring"""


								A__       =    parent
								A__       =    config_class
								A__       =    has_text_modality
								A__       =    kwargs
								A__       =    common_properties



					def     _a							(     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     _a							(     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     _a							(     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     _a							(     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     _a							(     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     _a							(     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     _a							(     self					:       List[Any]					):






								"""simple docstring"""


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



					def     _a							(     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     _a							(     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 pytest

import datasets


# Import fixture modules as plugins
SCREAMING_SNAKE_CASE__       =      ['''tests.fixtures.files''', '''tests.fixtures.hub''', '''tests.fixtures.fsspec''']


def A						(       __UpperCamelCase ,	__UpperCamelCase					)						->      Optional[int]:
			# Mark tests as "unit" by default if not marked as "integration" (or already marked as "unit")
			for item in items:
						if any(marker in item.keywords for marker in ['integration', 'unit']					):
									continue
						item.add_marker(pytest.mark.unit					)


def A						(       __UpperCamelCase					)						->      str:
			config.addinivalue_line('markers' ,	'torchaudio_latest: mark test to run with torchaudio>=0.12'					)


@pytest.fixture(autouse=__UpperCamelCase					)
def A						(       __UpperCamelCase ,	__UpperCamelCase					)						->      Union[str, Any]:
			# test_hf_cache_home = tmp_path_factory.mktemp("cache")  # TODO: why a cache dir per test function does not work?
			A__       =    tmp_path_factory.getbasetemp() / 'cache'
			A__       =    test_hf_cache_home / 'datasets'
			A__       =    test_hf_cache_home / 'metrics'
			A__       =    test_hf_cache_home / 'modules'
			monkeypatch.setattr('datasets.config.HF_DATASETS_CACHE' ,	str(__UpperCamelCase					)					)
			monkeypatch.setattr('datasets.config.HF_METRICS_CACHE' ,	str(__UpperCamelCase					)					)
			monkeypatch.setattr('datasets.config.HF_MODULES_CACHE' ,	str(__UpperCamelCase					)					)
			A__       =    test_hf_datasets_cache / 'downloads'
			monkeypatch.setattr('datasets.config.DOWNLOADED_DATASETS_PATH' ,	str(__UpperCamelCase					)					)
			A__       =    test_hf_datasets_cache / 'downloads' / 'extracted'
			monkeypatch.setattr('datasets.config.EXTRACTED_DATASETS_PATH' ,	str(__UpperCamelCase					)					)


@pytest.fixture(autouse=__UpperCamelCase ,	scope='session'					)
def A						(       )						->      Union[str, Any]:
			datasets.disable_progress_bar()


@pytest.fixture(autouse=__UpperCamelCase					)
def A						(       __UpperCamelCase					)						->      int:
			# don't take tests into account when counting downloads
			monkeypatch.setattr('datasets.config.HF_UPDATE_DOWNLOAD_COUNTS' ,	__UpperCamelCase					)






@pytest.fixture
def A						(       __UpperCamelCase					)						->      Any:
			# Required to suppress RemovedIn20Warning when feature(s) are not compatible with SQLAlchemy 2.0
			# To be removed once SQLAlchemy 2.0 supported
			monkeypatch.setattr('sqlalchemy.util.deprecations.SILENCE_UBER_WARNING' ,	__UpperCamelCase					)




