



import copy
import json
import os
import tempfile

from transformers import is_torch_available

from .test_configuration_utils import config_common_kwargs

class 	lowerCamelCase_    ( _A						):






						'''simple docstring'''







						def __init__(	self      :			Optional[int]	,	__lowerCamelCase      :			Union[str, Any]	,	__lowerCamelCase      :			str=None	,	__lowerCamelCase      :			Any=True	,	__lowerCamelCase      :			Tuple=None	,	**__lowerCamelCase      :			Any )      ->				Optional[Any]:
									A							:					Optional[int]              =						parent
									A							:					List[str]              =						config_class
									A							:					List[Any]              =						has_text_modality
									A							:					Tuple              =						kwargs
									A							:					List[str]              =						common_properties







						def 			SCREAMING_SNAKE_CASE__		(	self      :			str )      ->				List[Any]:
									A							:					Tuple              =						self.config_class(**self.inputs_dict )
									A							:					Any              =						(
									    ["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(__lowerCamelCase	,	__lowerCamelCase )	,	msg=F"""`{prop}` does not exist""" )

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







						def 			SCREAMING_SNAKE_CASE__		(	self      :			str )      ->				Optional[Any]:
									A							:					List[str]              =						self.config_class(**self.inputs_dict )
									A							:					Optional[int]              =						json.loads(config.to_json_string() )
									for key, value in self.inputs_dict.items():
												self.parent.assertEqual(obj[key]	,	__lowerCamelCase )







						def 			SCREAMING_SNAKE_CASE__		(	self      :			Optional[int] )      ->				List[Any]:
									A							:					str              =						self.config_class(**self.inputs_dict )

									with tempfile.TemporaryDirectory() as tmpdirname:
												A							:					Optional[Any]              =						os.path.join(__lowerCamelCase	,	"config.json" )
												config_first.to_json_file(__lowerCamelCase )
												A							:					Optional[Any]              =						self.config_class.from_json_file(__lowerCamelCase )

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







						def 			SCREAMING_SNAKE_CASE__		(	self      :			Any )      ->				List[str]:
									A							:					Union[str, Any]              =						self.config_class(**self.inputs_dict )

									with tempfile.TemporaryDirectory() as tmpdirname:
												config_first.save_pretrained(__lowerCamelCase )
												A							:					Optional[Any]              =						self.config_class.from_pretrained(__lowerCamelCase )

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







						def 			SCREAMING_SNAKE_CASE__		(	self      :			Any )      ->				Optional[int]:
									A							:					List[Any]              =						self.config_class(**self.inputs_dict )

									A							:					str              =						"test"
									with tempfile.TemporaryDirectory() as tmpdirname:
												A							:					Dict              =						os.path.join(__lowerCamelCase	,	__lowerCamelCase )
												config_first.save_pretrained(__lowerCamelCase )
												A							:					str              =						self.config_class.from_pretrained(__lowerCamelCase	,	subfolder=__lowerCamelCase )

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







						def 			SCREAMING_SNAKE_CASE__		(	self      :			List[Any] )      ->				Any:
									A							:					Any              =						self.config_class(**self.inputs_dict	,	num_labels=5 )
									self.parent.assertEqual(len(config.idalabel )	,	5 )
									self.parent.assertEqual(len(config.labelaid )	,	5 )

									A							:					Optional[int]              =						3
									self.parent.assertEqual(len(config.idalabel )	,	3 )
									self.parent.assertEqual(len(config.labelaid )	,	3 )







						def 			SCREAMING_SNAKE_CASE__		(	self      :			Optional[Any] )      ->				str:
									if self.config_class.is_composition:
												return
									A							:					Union[str, Any]              =						self.config_class()
									self.parent.assertIsNotNone(__lowerCamelCase )







						def 			SCREAMING_SNAKE_CASE__		(	self      :			Any )      ->				int:
									A							:					str              =						copy.deepcopy(__lowerCamelCase )
									A							:					List[str]              =						self.config_class(**__lowerCamelCase )
									A							:					Any              =						[]
									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(__lowerCamelCase	,	__lowerCamelCase ) != value:
															wrong_values.append((key, getattr(__lowerCamelCase	,	__lowerCamelCase ), value) )

									if len(__lowerCamelCase ) > 0:
												A							:					Tuple              =						"\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 			SCREAMING_SNAKE_CASE__		(	self      :			str )      ->				Dict:
									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()




from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_tokenizers_available, is_torch_available


__SCREAMING_SNAKE_CASE           =  {
    """configuration_altclip""": [
        """ALTCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """AltCLIPConfig""",
        """AltCLIPTextConfig""",
        """AltCLIPVisionConfig""",
    ],
    """processing_altclip""": ["""AltCLIPProcessor"""],
}

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							__SCREAMING_SNAKE_CASE           =  [
							    """ALTCLIP_PRETRAINED_MODEL_ARCHIVE_LIST""",
							    """AltCLIPPreTrainedModel""",
							    """AltCLIPModel""",
							    """AltCLIPTextModel""",
							    """AltCLIPVisionModel""",
							]


if TYPE_CHECKING:
							from .configuration_altclip import (
							    ALTCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
							    AltCLIPConfig,
							    AltCLIPTextConfig,
							    AltCLIPVisionConfig,
							)
							from .processing_altclip import AltCLIPProcessor

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_altclip import (
														    ALTCLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
														    AltCLIPModel,
														    AltCLIPPreTrainedModel,
														    AltCLIPTextModel,
														    AltCLIPVisionModel,
														)


else:
							import sys

							__SCREAMING_SNAKE_CASE           =  _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)