
from unittest import TestCase

from datasets import Sequence, Value
from datasets.arrow_dataset import Dataset






class   UpperCAmelCase		(						A_ ):



   def 				_SCREAMING_SNAKE_CASE   (self		:					str )		->	List[Any]:


          '''simple docstring'''


          return [
              {"col_1": 3, "col_2": "a"},
              {"col_1": 2, "col_2": "b"},
              {"col_1": 1, "col_2": "c"},
              {"col_1": 0, "col_2": "d"},
          ]



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[int] )		->	Tuple:


          '''simple docstring'''


          snake_case       :   List[Any]							=      {"col_1": [3, 2, 1, 0], "col_2": ["a", "b", "c", "d"]}
          return Dataset.from_dict(snake_case__ )



   def 				_SCREAMING_SNAKE_CASE   (self		:					int )		->	Union[str, Any]:


          '''simple docstring'''


          snake_case       :   Tuple							=      self._create_example_records()
          snake_case       :   Tuple							=      Dataset.from_list(snake_case__ )
          self.assertListEqual(dset.column_names    ,						["col_1", "col_2"] )
          for i, r in enumerate(snake_case__ ):
                 self.assertDictEqual(snake_case__    ,						example_records[i] )



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[int] )		->	Optional[Any]:


          '''simple docstring'''


          snake_case       :   Any							=      self._create_example_records()
          snake_case       :   Union[str, Any]							=      Dataset.from_list(snake_case__ )
          snake_case       :   Tuple							=      Dataset.from_dict({k: [r[k] for r in example_records] for k in example_records[0]} )
          self.assertEqual(dset.info    ,						dset_from_dict.info )



   def 				_SCREAMING_SNAKE_CASE   (self		:					Optional[int] )		->	str:  # checks what happens with missing columns


          '''simple docstring'''


          snake_case       :   str							=      [{"col_1": 1}, {"col_2": "x"}]
          snake_case       :   str							=      Dataset.from_list(snake_case__ )
          self.assertDictEqual(dset[0]    ,						{"col_1": 1} )
          self.assertDictEqual(dset[1]    ,						{"col_1": None} )  # NB: first record is used for columns



   def 				_SCREAMING_SNAKE_CASE   (self		:					str )		->	List[Any]:  # checks if the type can be inferred from the second record


          '''simple docstring'''


          snake_case       :   Optional[Any]							=      [{"col_1": []}, {"col_1": [1, 2]}]
          snake_case       :   str							=      Dataset.from_list(snake_case__ )
          self.assertEqual(dset.info.features["col_1"]    ,						Sequence(Value("int64" ) ) )



   def 				_SCREAMING_SNAKE_CASE   (self		:					Union[str, Any] )		->	List[str]:


          '''simple docstring'''


          snake_case       :   List[Any]							=      Dataset.from_list([] )
          self.assertEqual(len(snake_case__ )    ,						0 )
          self.assertListEqual(dset.column_names    ,						[] )









"""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   _UpperCamelCase  (   lowerCAmelCase__		):
							'''simple docstring'''







							def __init__(     self    ,   __a    ,   __a=None    ,   __a=True    ,   __a=None    ,   **__a	):
										__lowerCAmelCase				    =			parent
										__lowerCAmelCase				    =			config_class
										__lowerCAmelCase				    =			has_text_modality
										__lowerCAmelCase				    =			kwargs
										__lowerCAmelCase				    =			common_properties

							def 			snake_case				(     self	):
										__lowerCAmelCase				    =			self.config_class(**self.inputs_dict	)
										__lowerCAmelCase				    =			(
										    ["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(__a    ,   __a	)    ,   msg=f"`{prop}` does not exist"	)

										# Test that config has the common properties as setter
										for idx, name in enumerate(__a	):
													try:
																setattr(__a    ,   __a    ,   __a	)
																self.parent.assertEqual(
																    getattr(__a    ,   __a	)    ,   __a    ,   msg=f"`{name} value {idx} expected, but was {getattr(__a    ,   __a	)}"	)
													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(__a	):
													try:
																__lowerCAmelCase				    =			self.config_class(**{name: idx}	)
																self.parent.assertEqual(
																    getattr(__a    ,   __a	)    ,   __a    ,   msg=f"`{name} value {idx} expected, but was {getattr(__a    ,   __a	)}"	)
													except NotImplementedError:
																# Some models might not be able to implement setters for common_properties
																# In that case, a NotImplementedError is raised
																pass

							def 			snake_case				(     self	):
										__lowerCAmelCase				    =			self.config_class(**self.inputs_dict	)
										__lowerCAmelCase				    =			json.loads(config.to_json_string()	)
										for key, value in self.inputs_dict.items():
													self.parent.assertEqual(obj[key]    ,   __a	)

							def 			snake_case				(     self	):
										__lowerCAmelCase				    =			self.config_class(**self.inputs_dict	)

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

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

							def 			snake_case				(     self	):
										__lowerCAmelCase				    =			self.config_class(**self.inputs_dict	)

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

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

							def 			snake_case				(     self	):
										__lowerCAmelCase				    =			self.config_class(**self.inputs_dict	)

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

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

							def 			snake_case				(     self	):
										__lowerCAmelCase				    =			self.config_class(**self.inputs_dict    ,   num_labels=5	)
										self.parent.assertEqual(len(config.idalabel	)    ,   5	)
										self.parent.assertEqual(len(config.labelaid	)    ,   5	)

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

							def 			snake_case				(     self	):
										if self.config_class.is_composition:
													return
										__lowerCAmelCase				    =			self.config_class()
										self.parent.assertIsNotNone(__a	)

							def 			snake_case				(     self	):
										__lowerCAmelCase				    =			copy.deepcopy(__a	)
										__lowerCAmelCase				    =			self.config_class(**__a	)
										__lowerCAmelCase				    =			[]
										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(__a    ,   __a	) != value:
																wrong_values.append((key, getattr(__a    ,   __a	), value)	)

										if len(__a	) > 0:
													__lowerCAmelCase				    =			"\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 			snake_case				(     self	):
										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()




