






import copy
import os
from typing import Union

from ...configuration_utils import PretrainedConfig
from ...utils import logging


snake_case__      :	Any       	=      logging.get_logger(__name__)

snake_case__      :	List[Any]       	=      {
    """BAAI/AltCLIP""": """https://huggingface.co/BAAI/AltCLIP/resolve/main/config.json""",
    # See all AltCLIP models at https://huggingface.co/models?filter=altclip
}


class 						_a       (  UpperCAmelCase__    ):






  """simple docstring"""





  A_						=   """altclip_text_model"""




  def __init__(     self		,		_UpperCAmelCase=250002		,		_UpperCAmelCase=1024		,		_UpperCAmelCase=24		,		_UpperCAmelCase=16		,		_UpperCAmelCase=4096		,		_UpperCAmelCase="gelu"		,		_UpperCAmelCase=0.1		,		_UpperCAmelCase=0.1		,		_UpperCAmelCase=514		,		_UpperCAmelCase=1		,		_UpperCAmelCase=0.0_2		,		_UpperCAmelCase=0.0_2		,		_UpperCAmelCase=1e-05		,		_UpperCAmelCase=1		,		_UpperCAmelCase=0		,		_UpperCAmelCase=2		,		_UpperCAmelCase="absolute"		,		_UpperCAmelCase=True		,		_UpperCAmelCase=768		,		**_UpperCAmelCase		,		)			-> List[str]:
     super().__init__(pad_token_id=_UpperCAmelCase		,		bos_token_id=_UpperCAmelCase		,		eos_token_id=_UpperCAmelCase		,		**_UpperCAmelCase )

     UpperCamelCase_									=     vocab_size
     UpperCamelCase_									=     hidden_size
     UpperCamelCase_									=     num_hidden_layers
     UpperCamelCase_									=     num_attention_heads
     UpperCamelCase_									=     hidden_act
     UpperCamelCase_									=     intermediate_size
     UpperCamelCase_									=     hidden_dropout_prob
     UpperCamelCase_									=     attention_probs_dropout_prob
     UpperCamelCase_									=     max_position_embeddings
     UpperCamelCase_									=     type_vocab_size
     UpperCamelCase_									=     initializer_range
     UpperCamelCase_									=     initializer_factor
     UpperCamelCase_									=     layer_norm_eps
     UpperCamelCase_									=     position_embedding_type
     UpperCamelCase_									=     use_cache
     UpperCamelCase_									=     project_dim




class 						_a       (  UpperCAmelCase__    ):






  """simple docstring"""





  A_						=   """altclip_vision_model"""




  def __init__(     self		,		_UpperCAmelCase=768		,		_UpperCAmelCase=3072		,		_UpperCAmelCase=512		,		_UpperCAmelCase=12		,		_UpperCAmelCase=12		,		_UpperCAmelCase=3		,		_UpperCAmelCase=224		,		_UpperCAmelCase=32		,		_UpperCAmelCase="quick_gelu"		,		_UpperCAmelCase=1e-5		,		_UpperCAmelCase=0.0		,		_UpperCAmelCase=0.0_2		,		_UpperCAmelCase=1.0		,		**_UpperCAmelCase		,		)			-> Optional[int]:
     super().__init__(**_UpperCAmelCase )

     UpperCamelCase_									=     hidden_size
     UpperCamelCase_									=     intermediate_size
     UpperCamelCase_									=     projection_dim
     UpperCamelCase_									=     num_hidden_layers
     UpperCamelCase_									=     num_attention_heads
     UpperCamelCase_									=     num_channels
     UpperCamelCase_									=     patch_size
     UpperCamelCase_									=     image_size
     UpperCamelCase_									=     initializer_range
     UpperCamelCase_									=     initializer_factor
     UpperCamelCase_									=     attention_dropout
     UpperCamelCase_									=     layer_norm_eps
     UpperCamelCase_									=     hidden_act




  @classmethod
  def    _UpperCAmelCase     (     cls		,		_UpperCAmelCase		,		**_UpperCAmelCase )			-> "PretrainedConfig":
     cls._set_token_in_kwargs(_UpperCAmelCase )

     UpperCamelCase_		,      UpperCamelCase_									=     cls.get_config_dict(_UpperCAmelCase		,		**_UpperCAmelCase )

     # get the vision config dict if we are loading from AltCLIPConfig
     if config_dict.get('model_type' ) == "altclip":
        UpperCamelCase_									=     config_dict['vision_config']

     if "model_type" in config_dict and hasattr(cls		,		'model_type' ) and config_dict["model_type"] != cls.model_type:
        logger.warning(
            f"""You are using a model of type {config_dict["model_type"]} to instantiate a model of type """
            f"""{cls.model_type}. This is not supported for all configurations of models and can yield errors.""" )

     return cls.from_dict(_UpperCAmelCase		,		**_UpperCAmelCase )




class 						_a       (  UpperCAmelCase__    ):






  """simple docstring"""





  A_						=   """altclip"""
  A_						=   True




  def __init__(     self		,		_UpperCAmelCase=None		,		_UpperCAmelCase=None		,		_UpperCAmelCase=768		,		_UpperCAmelCase=2.6_5_9_2		,		**_UpperCAmelCase )			-> List[str]:
     # If `_config_dict` exist, we use them for the backward compatibility.
     # We pop out these 2 attributes before calling `super().__init__` to avoid them being saved (which causes a lot
     # of confusion!).
     UpperCamelCase_									=     kwargs.pop('text_config_dict'		,		_UpperCAmelCase )
     UpperCamelCase_									=     kwargs.pop('vision_config_dict'		,		_UpperCAmelCase )

     super().__init__(**_UpperCAmelCase )

     # Instead of simply assigning `[text|vision]_config_dict` to `[text|vision]_config`, we use the values in
     # `[text|vision]_config_dict` to update the values in `[text|vision]_config`. The values should be same in most
     # cases, but we don't want to break anything regarding `_config_dict` that existed before commit `8827e1b2`.
     if text_config_dict is not None:
        if text_config is None:
           UpperCamelCase_									=     {}

        # This is the complete result when using `text_config_dict`.
        UpperCamelCase_									=     AltCLIPTextConfig(**_UpperCAmelCase ).to_dict()

        # Give a warning if the values exist in both `_text_config_dict` and `text_config` but being different.
        for key, value in _text_config_dict.items():
           if key in text_config and value != text_config[key] and key not in ["transformers_version"]:
              # If specified in `text_config_dict`
              if key in text_config_dict:
                 UpperCamelCase_									=     (
                     f"""`{key}` is found in both `text_config_dict` and `text_config` but with different values. """
                     f"""The value `text_config_dict[\"{key}\"]` will be used instead."""
                 )
              # If inferred from default argument values (just to be super careful)
              else:
                 UpperCamelCase_									=     (
                     f"""`text_config_dict` is provided which will be used to initialize `AltCLIPTextConfig`. The """
                     f"""value `text_config[\"{key}\"]` will be overriden."""
                 )
              logger.warning(_UpperCAmelCase )

            # Update all values in `text_config` with the ones in `_text_config_dict`.
        text_config.update(_text_config_dict )

     if vision_config_dict is not None:
        if vision_config is None:
           UpperCamelCase_									=     {}

        # This is the complete result when using `vision_config_dict`.
        UpperCamelCase_									=     AltCLIPVisionConfig(**_UpperCAmelCase ).to_dict()
        # convert keys to string instead of integer
        if "id2label" in _vision_config_dict:
           UpperCamelCase_									=     {
               str(_UpperCAmelCase ): value for key, value in _vision_config_dict['id2label'].items()
           }

        # Give a warning if the values exist in both `_vision_config_dict` and `vision_config` but being different.
        for key, value in _vision_config_dict.items():
           if key in vision_config and value != vision_config[key] and key not in ["transformers_version"]:
              # If specified in `vision_config_dict`
              if key in vision_config_dict:
                 UpperCamelCase_									=     (
                     f"""`{key}` is found in both `vision_config_dict` and `vision_config` but with different """
                     f"""values. The value `vision_config_dict[\"{key}\"]` will be used instead."""
                 )
              # If inferred from default argument values (just to be super careful)
              else:
                 UpperCamelCase_									=     (
                     f"""`vision_config_dict` is provided which will be used to initialize `AltCLIPVisionConfig`. """
                     f"""The value `vision_config[\"{key}\"]` will be overriden."""
                 )
              logger.warning(_UpperCAmelCase )

            # Update all values in `vision_config` with the ones in `_vision_config_dict`.
        vision_config.update(_vision_config_dict )

     if text_config is None:
        UpperCamelCase_									=     {}
        logger.info('`text_config` is `None`. Initializing the `AltCLIPTextConfig` with default values.' )

     if vision_config is None:
        UpperCamelCase_									=     {}
        logger.info('`vision_config` is `None`. initializing the `AltCLIPVisionConfig` with default values.' )

     UpperCamelCase_									=     AltCLIPTextConfig(**_UpperCAmelCase )
     UpperCamelCase_									=     AltCLIPVisionConfig(**_UpperCAmelCase )

     UpperCamelCase_									=     projection_dim
     UpperCamelCase_									=     logit_scale_init_value
     UpperCamelCase_									=     1.0




  @classmethod
  def    _UpperCAmelCase     (     cls		,		_UpperCAmelCase		,		_UpperCAmelCase		,		**_UpperCAmelCase )			-> str:
     return cls(text_config=text_config.to_dict()		,		vision_config=vision_config.to_dict()		,		**_UpperCAmelCase )




  def    _UpperCAmelCase     (     self )			-> str:
     UpperCamelCase_									=     copy.deepcopy(self.__dict__ )
     UpperCamelCase_									=     self.text_config.to_dict()
     UpperCamelCase_									=     self.vision_config.to_dict()
     UpperCamelCase_									=     self.__class__.model_type
     return output













from ...utils import (
    OptionalDependencyNotAvailable,
    is_torch_available,
    is_transformers_available,
    is_transformers_version,
)


try:
 if not (is_transformers_available() and is_torch_available()):
  raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
 from ...utils.dummy_torch_and_transformers_objects import (
     ImageTextPipelineOutput,
     UniDiffuserPipeline,
 )
else:
 from .modeling_text_decoder import UniDiffuserTextDecoder
 from .modeling_uvit import UniDiffuserModel, UTransformeraDModel
 from .pipeline_unidiffuser import ImageTextPipelineOutput, UniDiffuserPipeline





