




import functools
import gc
import inspect

import torch

from .imports import is_npu_available, is_xpu_available




def 		lowerCAmelCase_ (						*lowerCamelCase ):
				if not isinstance(lowerCamelCase						,  lowerCamelCase ):
								__magic_name__						:						Union[str, Any]										=list(lowerCamelCase )
				for i in range(len(lowerCamelCase ) ):
								__magic_name__						:						Dict										=None
				gc.collect()
				if is_xpu_available():
								torch.xpu.empty_cache()
				elif is_npu_available():
								torch.npu.empty_cache()
				else:
								torch.cuda.empty_cache()
				return objects




def 		lowerCAmelCase_ (						lowerCamelCase ):
				__magic_name__						:						List[str]										=[
				    """CUDA out of memory.""",  # CUDA OOM
				    """cuDNN error: CUDNN_STATUS_NOT_SUPPORTED.""",  # CUDNN SNAFU
				    """DefaultCPUAllocator: can't allocate memory""",  # CPU OOM
				]
				if isinstance(lowerCamelCase						,  lowerCamelCase ) and len(exception.args ) == 1:
								return any(err in exception.args[0] for err in _statements )
				return False




def 		lowerCAmelCase_ (						lowerCamelCase = None						,  lowerCamelCase = 128 ):
				if function is None:
								return functools.partial(lowerCamelCase						,  starting_batch_size=lowerCamelCase )

				__magic_name__						:						List[Any]										=starting_batch_size

				def decorator(*lowerCamelCase						,  **lowerCamelCase ):
								nonlocal batch_size
								gc.collect()
								if is_xpu_available():
												torch.xpu.empty_cache()
								elif is_npu_available():
												torch.npu.empty_cache()
								else:
												torch.cuda.empty_cache()
								__magic_name__						:						Optional[Any]										=list(inspect.signature(lowerCamelCase ).parameters.keys() )
								# Guard against user error
								if len(lowerCamelCase ) < (len(lowerCamelCase ) + 1):
												__magic_name__						:						Optional[int]										=""", """.join([F"{arg}={value}" for arg, value in zip(params[1:]						,  args[1:] )] )
												raise TypeError(
												    F"Batch size was passed into `{function.__name__}` as the first argument when called."
												    F"Remove this as the decorator already does so: `{function.__name__}({arg_str})`" )
								while True:
												if batch_size == 0:
																raise RuntimeError("""No executable batch size found, reached zero.""" )
												try:
																return function(lowerCamelCase						,  *lowerCamelCase						,  **lowerCamelCase )
												except Exception as e:
																if should_reduce_batch_size(lowerCamelCase ):
																				gc.collect()
																				if is_xpu_available():
																								torch.xpu.empty_cache()
																				elif is_npu_available():
																								torch.npu.empty_cache()
																				else:
																								torch.cuda.empty_cache()
																				batch_size //= 2
																else:
																				raise

				return decorator












import copy
from typing import TYPE_CHECKING, Any, Mapping, Optional, OrderedDict

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging
from ..auto.configuration_auto import AutoConfig


if TYPE_CHECKING:
 from ... import PreTrainedTokenizerBase, TensorType

snake_case__   :						List[str]													=   logging.get_logger(__name__)


class     _a							(	UpperCAmelCase__     ):






  """simple docstring"""





  A_						       = """vision-encoder-decoder"""
  A_						       = True




  def __init__(  self		,		**_UpperCAmelCase			)      ->			Dict:
     super().__init__(**_UpperCAmelCase			)
     if "encoder" not in kwargs or "decoder" not in kwargs:
        raise ValueError(
            f"""A configuraton of type {self.model_type} cannot be instantiated because """
            f"""not both `encoder` and `decoder` sub-configurations are passed, but only {kwargs}"""			)

     UpperCamelCase_						=  kwargs.pop('encoder'			)
     UpperCamelCase_						=  encoder_config.pop('model_type'			)
     UpperCamelCase_						=  kwargs.pop('decoder'			)
     UpperCamelCase_						=  decoder_config.pop('model_type'			)

     UpperCamelCase_						=  AutoConfig.for_model(_UpperCAmelCase		,		**_UpperCAmelCase			)
     UpperCamelCase_						=  AutoConfig.for_model(_UpperCAmelCase		,		**_UpperCAmelCase			)
     UpperCamelCase_						=  True




  @classmethod
  def  _UpperCAmelCase  (  cls		,		_UpperCAmelCase		,		_UpperCAmelCase		,		**_UpperCAmelCase			)      ->			PretrainedConfig:
     logger.info('Setting `config.is_decoder=True` and `config.add_cross_attention=True` for decoder_config'			)
     UpperCamelCase_						=  True
     UpperCamelCase_						=  True

     return cls(encoder=encoder_config.to_dict()		,		decoder=decoder_config.to_dict()		,		**_UpperCAmelCase			)




  def  _UpperCAmelCase  (  self			)      ->			int:
     UpperCamelCase_						=  copy.deepcopy(self.__dict__			)
     UpperCamelCase_						=  self.encoder.to_dict()
     UpperCamelCase_						=  self.decoder.to_dict()
     UpperCamelCase_						=  self.__class__.model_type
     return output




class     _a							(	UpperCAmelCase__     ):






  """simple docstring"""





  A_						       = version.parse("""1.11"""     )




  @property
  def  _UpperCAmelCase  (  self			)      ->			Mapping[str, Mapping[int, str]]:
     return OrderedDict(
         [
             ('pixel_values', {0: 'batch', 1: 'num_channels', 2: 'height', 3: 'width'}),
         ]			)




  @property
  def  _UpperCAmelCase  (  self			)      ->			float:
     return 1e-4




  @property
  def  _UpperCAmelCase  (  self			)      ->			Mapping[str, Mapping[int, str]]:
     return OrderedDict({'last_hidden_state': {0: 'batch', 1: 'encoder_sequence'}}			)




class     _a							(	UpperCAmelCase__     ):






  """simple docstring"""





  @property
  def  _UpperCAmelCase  (  self			)      ->			Mapping[str, Mapping[int, str]]:
     UpperCamelCase_						=  OrderedDict()
     UpperCamelCase_						=  {0: 'batch', 1: 'past_decoder_sequence + sequence'}
     UpperCamelCase_						=  {0: 'batch', 1: 'past_decoder_sequence + sequence'}
     UpperCamelCase_						=  {0: 'batch', 1: 'encoder_sequence'}

     return common_inputs




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase = -1		,		_UpperCAmelCase = -1		,		_UpperCAmelCase = False		,		_UpperCAmelCase = None		,		)      ->			Mapping[str, Any]:
     import torch

     UpperCamelCase_						=  OrderedDict()

     UpperCamelCase_						=  super().generate_dummy_inputs(
         _UpperCAmelCase		,		batch_size=_UpperCAmelCase		,		seq_length=_UpperCAmelCase		,		is_pair=_UpperCAmelCase		,		framework=_UpperCAmelCase			)

     UpperCamelCase_		,   UpperCamelCase_						=  dummy_input['input_ids'].shape
     UpperCamelCase_						=  (batch, encoder_sequence, self._config.encoder_hidden_size)
     UpperCamelCase_						=  dummy_input.pop('input_ids'			)
     UpperCamelCase_						=  dummy_input.pop('attention_mask'			)
     UpperCamelCase_						=  torch.zeros(_UpperCAmelCase			)

     return common_inputs




class     _a							(	UpperCAmelCase__     ):






  """simple docstring"""





  @property
  def  _UpperCAmelCase  (  self			)      ->			None:
     pass




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase			)      ->			OnnxConfig:
     return VisionEncoderDecoderEncoderOnnxConfig(_UpperCAmelCase			)




  def  _UpperCAmelCase  (  self		,		_UpperCAmelCase		,		_UpperCAmelCase		,		_UpperCAmelCase = "default"			)      ->			OnnxConfig:
     UpperCamelCase_						=  encoder_config.hidden_size
     return VisionEncoderDecoderDecoderOnnxConfig(_UpperCAmelCase		,		_UpperCAmelCase			)





