




"""simple docstring"""

import os
import shutil
from pathlib import Path
from typing import Optional, Union

import numpy as np
from huggingface_hub import hf_hub_download

from ..utils import ONNX_EXTERNAL_WEIGHTS_NAME, ONNX_WEIGHTS_NAME, is_onnx_available, logging


if is_onnx_available():
       import onnxruntime as ort


a							      =     logging.get_logger(__name__)

a							      =     {
    '''tensor(bool)''': np.bool_,
    '''tensor(int8)''': np.inta,
    '''tensor(uint8)''': np.uinta,
    '''tensor(int16)''': np.intaa,
    '''tensor(uint16)''': np.uintaa,
    '''tensor(int32)''': np.intaa,
    '''tensor(uint32)''': np.uintaa,
    '''tensor(int64)''': np.intaa,
    '''tensor(uint64)''': np.uintaa,
    '''tensor(float16)''': np.floataa,
    '''tensor(float)''': np.floataa,
    '''tensor(double)''': np.floataa,
}





class 							lowercase_			:



 '''simple docstring'''

 def __init__(					self			:			Optional[Any]       ,				_UpperCAmelCase			:			Dict=None       ,				**_UpperCAmelCase			:			Optional[Any]						):
       logger.info('`diffusers.OnnxRuntimeModel` is experimental and might change in the future.'						)
       _A     =  model
       _A     =  kwargs.get('model_save_dir'       ,				_UpperCAmelCase						)
       _A     =  kwargs.get('latest_model_name'       ,				_UpperCAmelCase						)

 def __call__(					self			:			Dict       ,				**_UpperCAmelCase			:			List[Any]						):
       _A     =  {k: np.array(_UpperCAmelCase						) for k, v in kwargs.items()}
       return self.model.run(_UpperCAmelCase       ,				_UpperCAmelCase						)

 @staticmethod
 def      lowerCAmelCase_				(					_UpperCAmelCase			:			Union[str, Path]       ,				_UpperCAmelCase			:			List[str]=None       ,				_UpperCAmelCase			:			List[Any]=None						):
       if provider is None:
             logger.info('No onnxruntime provider specified, using CPUExecutionProvider'						)
             _A     =  'CPUExecutionProvider'

       return ort.InferenceSession(_UpperCAmelCase       ,				providers=[provider]       ,				sess_options=_UpperCAmelCase						)

 def      lowerCAmelCase_				(					self			:			int       ,				_UpperCAmelCase			:			Union[str, Path]       ,				_UpperCAmelCase			:			Optional[str] = None       ,				**_UpperCAmelCase			:			List[Any]						):
       _A     =  file_name if file_name is not None else ONNX_WEIGHTS_NAME

       _A     =  self.model_save_dir.joinpath(self.latest_model_name						)
       _A     =  Path(_UpperCAmelCase						).joinpath(_UpperCAmelCase						)
       try:
             shutil.copyfile(_UpperCAmelCase       ,				_UpperCAmelCase						)
       except shutil.SameFileError:
             pass

       # copy external weights (for models >2GB)
       _A     =  self.model_save_dir.joinpath(_UpperCAmelCase						)
       if src_path.exists():
             _A     =  Path(_UpperCAmelCase						).joinpath(_UpperCAmelCase						)
             try:
                   shutil.copyfile(_UpperCAmelCase       ,				_UpperCAmelCase						)
             except shutil.SameFileError:
                   pass

 def      lowerCAmelCase_				(					self			:			List[Any]       ,				_UpperCAmelCase			:			Union[str, os.PathLike]       ,				**_UpperCAmelCase			:			List[str]       ,				):
       if os.path.isfile(_UpperCAmelCase						):
             logger.error(F'''Provided path ({save_directory}) should be a directory, not a file'''						)
             return

       os.makedirs(_UpperCAmelCase       ,				exist_ok=_UpperCAmelCase						)

       # saving model weights/files
       self._save_pretrained(_UpperCAmelCase       ,				**_UpperCAmelCase						)

 @classmethod
 def      lowerCAmelCase_				(					cls			:			Tuple       ,				_UpperCAmelCase			:			Union[str, Path]       ,				_UpperCAmelCase			:			Optional[Union[bool, str, None]] = None       ,				_UpperCAmelCase			:			Optional[Union[str, None]] = None       ,				_UpperCAmelCase			:			bool = False       ,				_UpperCAmelCase			:			Optional[str] = None       ,				_UpperCAmelCase			:			Optional[str] = None       ,				_UpperCAmelCase			:			Optional[str] = None       ,				_UpperCAmelCase			:			Optional["ort.SessionOptions"] = None       ,				**_UpperCAmelCase			:			Union[str, Any]       ,				):
       _A     =  file_name if file_name is not None else ONNX_WEIGHTS_NAME
       # load model from local directory
       if os.path.isdir(_UpperCAmelCase						):
             _A     =  OnnxRuntimeModel.load_model(
                 os.path.join(_UpperCAmelCase       ,				_UpperCAmelCase						)       ,				provider=_UpperCAmelCase       ,				sess_options=_UpperCAmelCase						)
             _A     =  Path(_UpperCAmelCase						)
       # load model from hub
       else:
             # download model
             _A     =  hf_hub_download(
                 repo_id=_UpperCAmelCase       ,				filename=_UpperCAmelCase       ,				use_auth_token=_UpperCAmelCase       ,				revision=_UpperCAmelCase       ,				cache_dir=_UpperCAmelCase       ,				force_download=_UpperCAmelCase       ,				)
             _A     =  Path(_UpperCAmelCase						).parent
             _A     =  Path(_UpperCAmelCase						).name
             _A     =  OnnxRuntimeModel.load_model(_UpperCAmelCase       ,				provider=_UpperCAmelCase       ,				sess_options=_UpperCAmelCase						)
       return cls(model=_UpperCAmelCase       ,				**_UpperCAmelCase						)



 @classmethod
 def      lowerCAmelCase_				(					cls			:			List[Any]       ,				_UpperCAmelCase			:			Union[str, Path]       ,				_UpperCAmelCase			:			bool = True       ,				_UpperCAmelCase			:			Optional[str] = None       ,				_UpperCAmelCase			:			Optional[str] = None       ,				**_UpperCAmelCase			:			Tuple       ,				):
       _A     =  None
       if len(str(_UpperCAmelCase						).split('@'						)						) == 2:
             _A  ,       _A     =  model_id.split('@'						)

       return cls._from_pretrained(
           model_id=_UpperCAmelCase       ,				revision=_UpperCAmelCase       ,				cache_dir=_UpperCAmelCase       ,				force_download=_UpperCAmelCase       ,				use_auth_token=_UpperCAmelCase       ,				**_UpperCAmelCase       ,				)









'''simple docstring'''



import copy
import os
from typing import TYPE_CHECKING, List, Union


if TYPE_CHECKING:
 pass

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


__UpperCamelCase   :							int         =   logging.get_logger(__name__)

__UpperCamelCase   :							int         =   {
    """kakaobrain/align-base""": """https://huggingface.co/kakaobrain/align-base/resolve/main/config.json""",
}
class 				__SCREAMING_SNAKE_CASE							(				_lowerCAmelCase  ):
      __a	       ="align_text_model"




      def __init__(	self			, lowerCamelCase=3_0522			, lowerCamelCase=768			, lowerCamelCase=12			, lowerCamelCase=12			, lowerCamelCase=3072			, lowerCamelCase="gelu"			, lowerCamelCase=0.1			, lowerCamelCase=0.1			, lowerCamelCase=512			, lowerCamelCase=2			, lowerCamelCase=0.02			, lowerCamelCase=1e-12			, lowerCamelCase=0			, lowerCamelCase="absolute"			, lowerCamelCase=True			, **lowerCamelCase			, )				->List[Any]:



         '''simple docstring'''
         super().__init__(**lowerCamelCase   )

         __a					  =     vocab_size
         __a					  =     hidden_size
         __a					  =     num_hidden_layers
         __a					  =     num_attention_heads
         __a					  =     hidden_act
         __a					  =     intermediate_size
         __a					  =     hidden_dropout_prob
         __a					  =     attention_probs_dropout_prob
         __a					  =     max_position_embeddings
         __a					  =     type_vocab_size
         __a					  =     initializer_range
         __a					  =     layer_norm_eps
         __a					  =     position_embedding_type
         __a					  =     use_cache
         __a					  =     pad_token_id






      @classmethod
      def 			__UpperCamelCase				(	cls			, lowerCamelCase			, **lowerCamelCase   )				->"PretrainedConfig":



         '''simple docstring'''
         cls._set_token_in_kwargs(lowerCamelCase   )

         __a  ,      __a					  =     cls.get_config_dict(lowerCamelCase			, **lowerCamelCase   )

         # get the text config dict if we are loading from AlignConfig
         if config_dict.get('model_type'   ) == "align":
            __a					  =     config_dict['text_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(lowerCamelCase			, **lowerCamelCase   )







class 				__SCREAMING_SNAKE_CASE							(				_lowerCAmelCase  ):
      __a	       ="align_vision_model"




      def __init__(	self			, lowerCamelCase = 3			, lowerCamelCase = 600			, lowerCamelCase = 2.0			, lowerCamelCase = 3.1			, lowerCamelCase = 8			, lowerCamelCase = [3, 3, 5, 3, 5, 5, 3]			, lowerCamelCase = [32, 16, 24, 40, 80, 112, 192]			, lowerCamelCase = [16, 24, 40, 80, 112, 192, 320]			, lowerCamelCase = []			, lowerCamelCase = [1, 2, 2, 2, 1, 2, 1]			, lowerCamelCase = [1, 2, 2, 3, 3, 4, 1]			, lowerCamelCase = [1, 6, 6, 6, 6, 6, 6]			, lowerCamelCase = 0.25			, lowerCamelCase = "swish"			, lowerCamelCase = 2560			, lowerCamelCase = "mean"			, lowerCamelCase = 0.02			, lowerCamelCase = 0.001			, lowerCamelCase = 0.99			, lowerCamelCase = 0.2			, **lowerCamelCase			, )				->Dict:



         '''simple docstring'''
         super().__init__(**lowerCamelCase   )

         __a					  =     num_channels
         __a					  =     image_size
         __a					  =     width_coefficient
         __a					  =     depth_coefficient
         __a					  =     depth_divisor
         __a					  =     kernel_sizes
         __a					  =     in_channels
         __a					  =     out_channels
         __a					  =     depthwise_padding
         __a					  =     strides
         __a					  =     num_block_repeats
         __a					  =     expand_ratios
         __a					  =     squeeze_expansion_ratio
         __a					  =     hidden_act
         __a					  =     hidden_dim
         __a					  =     pooling_type
         __a					  =     initializer_range
         __a					  =     batch_norm_eps
         __a					  =     batch_norm_momentum
         __a					  =     drop_connect_rate
         __a					  =     sum(lowerCamelCase   ) * 4






      @classmethod
      def 			__UpperCamelCase				(	cls			, lowerCamelCase			, **lowerCamelCase   )				->"PretrainedConfig":



         '''simple docstring'''
         cls._set_token_in_kwargs(lowerCamelCase   )

         __a  ,      __a					  =     cls.get_config_dict(lowerCamelCase			, **lowerCamelCase   )

         # get the vision config dict if we are loading from AlignConfig
         if config_dict.get('model_type'   ) == "align":
            __a					  =     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(lowerCamelCase			, **lowerCamelCase   )







class 				__SCREAMING_SNAKE_CASE							(				_lowerCAmelCase  ):
      __a	       ="align"
      __a	       =True




      def __init__(	self			, lowerCamelCase=None			, lowerCamelCase=None			, lowerCamelCase=640			, lowerCamelCase=1.0			, lowerCamelCase=0.02			, **lowerCamelCase			, )				->Union[str, Any]:



         '''simple docstring'''
         super().__init__(**lowerCamelCase   )

         if text_config is None:
            __a					  =     {}
            logger.info('text_config is None. Initializing the AlignTextConfig with default values.'   )

         if vision_config is None:
            __a					  =     {}
            logger.info('vision_config is None. Initializing the AlignVisionConfig with default values.'   )

         __a					  =     AlignTextConfig(**lowerCamelCase   )
         __a					  =     AlignVisionConfig(**lowerCamelCase   )

         __a					  =     projection_dim
         __a					  =     temperature_init_value
         __a					  =     initializer_range




      @classmethod
      def 			__UpperCamelCase				(	cls			, lowerCamelCase			, lowerCamelCase			, **lowerCamelCase   )				->int:



         '''simple docstring'''
         return cls(text_config=text_config.to_dict()			, vision_config=vision_config.to_dict()			, **lowerCamelCase   )






      def 			__UpperCamelCase				(	self   )				->Tuple:



         '''simple docstring'''
         __a					  =     copy.deepcopy(self.__dict__   )
         __a					  =     self.text_config.to_dict()
         __a					  =     self.vision_config.to_dict()
         __a					  =     self.__class__.model_type
         return output