import copy
import json
import os
import tempfile

from transformers import is_torch_available

from .test_configuration_utils import config_common_kwargs
class     a_			(						SCREAMING_SNAKE_CASE						):






 '''simple docstring'''






 def __init__(      self :  List[Any]      ,   lowercase__ :  Tuple      ,   lowercase__ :  int=None      ,   lowercase__ :  int=True      ,   lowercase__ :  Any=None      ,   **lowercase__ :  Tuple):







        '''simple docstring'''



        lowerCAmelCase__					     = parent
        lowerCAmelCase__					     = config_class
        lowerCAmelCase__					     = has_text_modality
        lowerCAmelCase__					     = kwargs
        lowerCAmelCase__					     = common_properties




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







        '''simple docstring'''



        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(lowercase__      ,   lowercase__)      ,   msg=F"""`{prop}` does not exist""")

        # Test that config has the common properties as setter
        for idx, name in enumerate(lowercase__):
               try:
                      setattr(lowercase__      ,   lowercase__      ,   lowercase__)
                      self.parent.assertEqual(
                          getattr(lowercase__      ,   lowercase__)      ,   lowercase__      ,   msg=F"""`{name} value {idx} expected, but was {getattr(lowercase__      ,   lowercase__)}""")
               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(lowercase__):
               try:
                      lowerCAmelCase__					     = self.config_class(**{name: idx})
                      self.parent.assertEqual(
                          getattr(lowercase__      ,   lowercase__)      ,   lowercase__      ,   msg=F"""`{name} value {idx} expected, but was {getattr(lowercase__      ,   lowercase__)}""")
               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 :  Dict):







        '''simple docstring'''



        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]      ,   lowercase__)




 def 		__snake_case						(      self :  Any):







        '''simple docstring'''



        lowerCAmelCase__					     = self.config_class(**self.inputs_dict)

        with tempfile.TemporaryDirectory() as tmpdirname:
               lowerCAmelCase__					     = os.path.join(lowercase__      ,   'config.json')
               config_first.to_json_file(lowercase__)
               lowerCAmelCase__					     = self.config_class.from_json_file(lowercase__)

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




 def 		__snake_case						(      self :  Optional[Any]):







        '''simple docstring'''



        lowerCAmelCase__					     = self.config_class(**self.inputs_dict)

        with tempfile.TemporaryDirectory() as tmpdirname:
               config_first.save_pretrained(lowercase__)
               lowerCAmelCase__					     = self.config_class.from_pretrained(lowercase__)

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




 def 		__snake_case						(      self :  Optional[int]):







        '''simple docstring'''



        lowerCAmelCase__					     = self.config_class(**self.inputs_dict)

        lowerCAmelCase__					     = 'test'
        with tempfile.TemporaryDirectory() as tmpdirname:
               lowerCAmelCase__					     = os.path.join(lowercase__      ,   lowercase__)
               config_first.save_pretrained(lowercase__)
               lowerCAmelCase__					     = self.config_class.from_pretrained(lowercase__      ,   subfolder=lowercase__)

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




 def 		__snake_case						(      self :  List[str]):







        '''simple docstring'''



        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 :  List[str]):







        '''simple docstring'''



        if self.config_class.is_composition:
               return
        lowerCAmelCase__					     = self.config_class()
        self.parent.assertIsNotNone(lowercase__)




 def 		__snake_case						(      self :  Optional[Any]):







        '''simple docstring'''



        lowerCAmelCase__					     = copy.deepcopy(lowercase__)
        lowerCAmelCase__					     = self.config_class(**lowercase__)
        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(lowercase__      ,   lowercase__) != value:
                      wrong_values.append((key, getattr(lowercase__      ,   lowercase__), value))

        if len(lowercase__) > 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 :  Any):







        '''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()

from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


lowerCAmelCase__     						=			{
    'configuration_x_clip': [
        'XCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP',
        'XCLIPConfig',
        'XCLIPTextConfig',
        'XCLIPVisionConfig',
    ],
    'processing_x_clip': ['XCLIPProcessor'],
}

try:
    if not is_torch_available():
        raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
    pass
else:
    lowerCAmelCase__     						=			[
        'XCLIP_PRETRAINED_MODEL_ARCHIVE_LIST',
        'XCLIPModel',
        'XCLIPPreTrainedModel',
        'XCLIPTextModel',
        'XCLIPVisionModel',
    ]

if TYPE_CHECKING:
    from .configuration_x_clip import (
        XCLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
        XCLIPConfig,
        XCLIPTextConfig,
        XCLIPVisionConfig,
    )
    from .processing_x_clip import XCLIPProcessor

    try:
        if not is_torch_available():
            raise OptionalDependencyNotAvailable()
    except OptionalDependencyNotAvailable:
        pass
    else:
        from .modeling_x_clip import (
            XCLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
            XCLIPModel,
            XCLIPPreTrainedModel,
            XCLIPTextModel,
            XCLIPVisionModel,
        )

else:
    import sys

    lowerCAmelCase__     						=			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
