"""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 					_A		(			lowerCAmelCase      ):

      def __init__(		self						,			__lowerCAmelCase						,			__lowerCAmelCase=None						,			__lowerCAmelCase=True						,			__lowerCAmelCase=None						,			**__lowerCAmelCase		):







            """simple docstring"""



            lowercase								=      parent
            lowercase								=      config_class
            lowercase								=      has_text_modality
            lowercase								=      kwargs
            lowercase								=      common_properties

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      self.config_class(**self.inputs_dict		)
            lowercase								=      (
                ["""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:
                        lowercase								=      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 							A__			(		self		):







            """simple docstring"""



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

      def 							A__			(		self		):







            """simple docstring"""



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

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

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

      def 							A__			(		self		):







            """simple docstring"""



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

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

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

      def 							A__			(		self		):







            """simple docstring"""



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

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

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

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      self.config_class(**self.inputs_dict						,			num_labels=5		)
            self.parent.assertEqual(len(config.idalabel		)						,			5		)
            self.parent.assertEqual(len(config.labelaid		)						,			5		)

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

      def 							A__			(		self		):







            """simple docstring"""



            if self.config_class.is_composition:
                  return
            lowercase								=      self.config_class()
            self.parent.assertIsNotNone(__lowerCAmelCase		)

      def 							A__			(		self		):







            """simple docstring"""



            lowercase								=      copy.deepcopy(__lowerCAmelCase		)
            lowercase								=      self.config_class(**__lowerCAmelCase		)
            lowercase								=      []
            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:
                  lowercase								=      """\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		):







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




"""simple docstring"""






from typing import TYPE_CHECKING

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


__lowerCAmelCase       :			Optional[int]   	={
    """configuration_chinese_clip""": [
        """CHINESE_CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP""",
        """ChineseCLIPConfig""",
        """ChineseCLIPOnnxConfig""",
        """ChineseCLIPTextConfig""",
        """ChineseCLIPVisionConfig""",
    ],
    """processing_chinese_clip""": ["""ChineseCLIPProcessor"""],
}

try:
       if not is_vision_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __lowerCAmelCase       :			List[Any]   	=["""ChineseCLIPFeatureExtractor"""]
       __lowerCAmelCase       :			List[Any]   	=["""ChineseCLIPImageProcessor"""]

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __lowerCAmelCase       :			Tuple   	=[
           """CHINESE_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST""",
           """ChineseCLIPModel""",
           """ChineseCLIPPreTrainedModel""",
           """ChineseCLIPTextModel""",
           """ChineseCLIPVisionModel""",
       ]

if TYPE_CHECKING:
       from .configuration_chinese_clip import (
           CHINESE_CLIP_PRETRAINED_CONFIG_ARCHIVE_MAP,
           ChineseCLIPConfig,
           ChineseCLIPOnnxConfig,
           ChineseCLIPTextConfig,
           ChineseCLIPVisionConfig,
       )
       from .processing_chinese_clip import ChineseCLIPProcessor

       try:
              if not is_vision_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .feature_extraction_chinese_clip import ChineseCLIPFeatureExtractor, ChineseCLIPImageProcessor

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_chinese_clip import (
                  CHINESE_CLIP_PRETRAINED_MODEL_ARCHIVE_LIST,
                  ChineseCLIPModel,
                  ChineseCLIPPreTrainedModel,
                  ChineseCLIPTextModel,
                  ChineseCLIPVisionModel,
              )

else:
       import sys

       __lowerCAmelCase       :			Optional[Any]   	=_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)



