





from typing import Dict, List, Optional, Union

import numpy as np

from .feature_extraction_utils import BatchFeature, FeatureExtractionMixin
from .utils import PaddingStrategy, TensorType, is_tf_tensor, is_torch_tensor, logging, to_numpy


_snake_case    :       Optional[Any]		       =    logging.get_logger(__name__)



class 							_UpperCAmelCase       (       _UpperCamelCase       ):

  """simple docstring"""


  def __init__(							self					:						str   ,    lowerCAmelCase_					:						int   ,    lowerCAmelCase_					:						int   ,    lowerCAmelCase_					:						float   ,    **lowerCAmelCase_					:						List[str]	)				->		Any:
     __lowerCAmelCase				      =      feature_size
     __lowerCAmelCase				      =      sampling_rate
     __lowerCAmelCase				      =      padding_value

     __lowerCAmelCase				      =      kwargs.pop('padding_side'   ,    'right'	)
     __lowerCAmelCase				      =      kwargs.pop('return_attention_mask'   ,    lowerCAmelCase_	)

     super().__init__(**lowerCAmelCase_	)






  def 							lowercase						(							self					:						Union[str, Any]   ,    lowerCAmelCase_					:						Union[
          BatchFeature,
          List[BatchFeature],
          Dict[str, BatchFeature],
          Dict[str, List[BatchFeature]],
          List[Dict[str, BatchFeature]],
      ]   ,    lowerCAmelCase_					:						Union[bool, str, PaddingStrategy] = True   ,    lowerCAmelCase_					:						Optional[int] = None   ,    lowerCAmelCase_					:						bool = False   ,    lowerCAmelCase_					:						Optional[int] = None   ,    lowerCAmelCase_					:						Optional[bool] = None   ,    lowerCAmelCase_					:						Optional[Union[str, TensorType]] = None   ,    )				->		BatchFeature:
     # If we have a list of dicts, let's convert it in a dict of lists
     # We do this to allow using this method as a collate_fn function in PyTorch Dataloader
     if isinstance(lowerCAmelCase_   ,    (list, tuple)	) and isinstance(processed_features[0]   ,    (dict, BatchFeature)	):
        __lowerCAmelCase				      =      {
            key: [example[key] for example in processed_features] for key in processed_features[0].keys()
        }

     # The model's main input name, usually `input_values`, has be passed for padding
     if self.model_input_names[0] not in processed_features:
        raise ValueError(
            'You should supply an instance of `transformers.BatchFeature` or list of `transformers.BatchFeature`'
            f""" to this method that includes {self.model_input_names[0]}, but you provided"""
            f""" {list(processed_features.keys()	)}"""	)

     __lowerCAmelCase				      =      processed_features[self.model_input_names[0]]
     __lowerCAmelCase				      =      (
         return_attention_mask if return_attention_mask is not None else self.return_attention_mask
     )

     if len(lowerCAmelCase_	) == 0:
        if return_attention_mask:
           __lowerCAmelCase				      =      []
        return processed_features

     # If we have PyTorch/TF tensors or lists as inputs, we cast them as Numpy arrays
     # and rebuild them afterwards if no return_tensors is specified
     # Note that we lose the specific device the tensor may be on for PyTorch

     __lowerCAmelCase				      =      required_input[0]
     if isinstance(lowerCAmelCase_   ,    (list, tuple)	):
        # first_element might be an empty list/tuple in some edge cases so we grab the first non empty element.
        __lowerCAmelCase				      =      0
        while len(required_input[index]	) == 0:
           index += 1
        if index < len(lowerCAmelCase_	):
           __lowerCAmelCase				      =      required_input[index][0]

     if return_tensors is None:
        if is_tf_tensor(lowerCAmelCase_	):
           __lowerCAmelCase				      =      'tf'
        elif is_torch_tensor(lowerCAmelCase_	):
           __lowerCAmelCase				      =      'pt'
        elif isinstance(lowerCAmelCase_   ,    (int, float, list, tuple, np.ndarray)	):
           __lowerCAmelCase				      =      'np'
        else:
           raise ValueError(
               f"""type of {first_element} unknown: {type(lowerCAmelCase_	)}. """
               'Should be one of a python, numpy, pytorch or tensorflow object.'	)

     for key, value in processed_features.items():
        if isinstance(value[0]   ,    (int, float)	):
           __lowerCAmelCase				      =      to_numpy(lowerCAmelCase_	)
        else:
           __lowerCAmelCase				      =      [to_numpy(lowerCAmelCase_	) for v in value]

        # Convert padding_strategy in PaddingStrategy
     __lowerCAmelCase				      =      self._get_padding_strategies(padding=lowerCAmelCase_   ,    max_length=lowerCAmelCase_	)

     __lowerCAmelCase				      =      processed_features[self.model_input_names[0]]

     __lowerCAmelCase				      =      len(lowerCAmelCase_	)
     if not all(len(lowerCAmelCase_	) == batch_size for v in processed_features.values()	):
        raise ValueError('Some items in the output dictionary have a different batch size than others.'	)

     __lowerCAmelCase				      =      []
     for i in range(lowerCAmelCase_	):
        __lowerCAmelCase				      =      {k: v[i] for k, v in processed_features.items()}
        # truncation
        __lowerCAmelCase				      =      self._truncate(
            lowerCAmelCase_   ,    max_length=lowerCAmelCase_   ,    pad_to_multiple_of=lowerCAmelCase_   ,    truncation=lowerCAmelCase_   ,    )
        truncated_inputs.append(lowerCAmelCase_	)

     if padding_strategy == PaddingStrategy.LONGEST:
        # make sure that `max_length` cannot be longer than the longest truncated length
        __lowerCAmelCase				      =      max(len(input_slice[self.model_input_names[0]]	) for input_slice in truncated_inputs	)
        __lowerCAmelCase				      =      PaddingStrategy.MAX_LENGTH

     __lowerCAmelCase				      =      {}
     for i in range(lowerCAmelCase_	):
        # padding
        __lowerCAmelCase				      =      self._pad(
            truncated_inputs[i]   ,    max_length=lowerCAmelCase_   ,    padding_strategy=lowerCAmelCase_   ,    pad_to_multiple_of=lowerCAmelCase_   ,    return_attention_mask=lowerCAmelCase_   ,    )

        for key, value in outputs.items():
           if key not in batch_outputs:
              __lowerCAmelCase				      =      []
           if value.dtype is np.dtype(np.floataa	):
              __lowerCAmelCase				      =      value.astype(np.floataa	)
           batch_outputs[key].append(lowerCAmelCase_	)

     return BatchFeature(lowerCAmelCase_   ,    tensor_type=lowerCAmelCase_	)






  def 							lowercase						(							self					:						Tuple   ,    lowerCAmelCase_					:						Union[Dict[str, np.ndarray], BatchFeature]   ,    lowerCAmelCase_					:						Optional[int] = None   ,    lowerCAmelCase_					:						PaddingStrategy = PaddingStrategy.DO_NOT_PAD   ,    lowerCAmelCase_					:						Optional[int] = None   ,    lowerCAmelCase_					:						Optional[bool] = None   ,    )				->		dict:
     __lowerCAmelCase				      =      processed_features[self.model_input_names[0]]

     if padding_strategy == PaddingStrategy.LONGEST:
        __lowerCAmelCase				      =      len(lowerCAmelCase_	)

     if max_length is not None and pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0):
        __lowerCAmelCase				      =      ((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of

     __lowerCAmelCase				      =      padding_strategy != PaddingStrategy.DO_NOT_PAD and len(lowerCAmelCase_	) < max_length

     if return_attention_mask and "attention_mask" not in processed_features:
        __lowerCAmelCase				      =      np.ones(len(lowerCAmelCase_	)   ,    dtype=np.intaa	)

     if needs_to_be_padded:
        __lowerCAmelCase				      =      max_length - len(lowerCAmelCase_	)
        if self.padding_side == "right":
           if return_attention_mask:
              __lowerCAmelCase				      =      np.pad(
                  processed_features['attention_mask']   ,    (0, difference)	)
           __lowerCAmelCase				      =      ((0, difference), (0, 0)) if self.feature_size > 1 else (0, difference)
           __lowerCAmelCase				      =      np.pad(
               lowerCAmelCase_   ,    lowerCAmelCase_   ,    'constant'   ,    constant_values=self.padding_value	)
        elif self.padding_side == "left":
           if return_attention_mask:
              __lowerCAmelCase				      =      np.pad(
                  processed_features['attention_mask']   ,    (difference, 0)	)
           __lowerCAmelCase				      =      ((difference, 0), (0, 0)) if self.feature_size > 1 else (difference, 0)
           __lowerCAmelCase				      =      np.pad(
               lowerCAmelCase_   ,    lowerCAmelCase_   ,    'constant'   ,    constant_values=self.padding_value	)
        else:
           raise ValueError('Invalid padding strategy:' + str(self.padding_side	)	)

     return processed_features






  def 							lowercase						(							self					:						Union[str, Any]   ,    lowerCAmelCase_					:						Union[Dict[str, np.ndarray], BatchFeature]   ,    lowerCAmelCase_					:						Optional[int] = None   ,    lowerCAmelCase_					:						Optional[int] = None   ,    lowerCAmelCase_					:						Optional[bool] = None   ,    )				->		Any:
     if not truncation:
        return processed_features
     elif truncation and max_length is None:
        raise ValueError('When setting ``truncation=True``, make sure that ``max_length`` is defined.'	)

     __lowerCAmelCase				      =      processed_features[self.model_input_names[0]]

     # find `max_length` that fits `pad_to_multiple_of`
     if max_length is not None and pad_to_multiple_of is not None and (max_length % pad_to_multiple_of != 0):
        __lowerCAmelCase				      =      ((max_length // pad_to_multiple_of) + 1) * pad_to_multiple_of

     __lowerCAmelCase				      =      len(lowerCAmelCase_	) > max_length

     if needs_to_be_truncated:
        __lowerCAmelCase				      =      processed_features[self.model_input_names[0]][:max_length]
        if "attention_mask" in processed_features:
           __lowerCAmelCase				      =      processed_features['attention_mask'][:max_length]

     return processed_features






  def 							lowercase						(							self					:						Tuple   ,    lowerCAmelCase_					:						str=False   ,    lowerCAmelCase_					:						Optional[Any]=None	)				->		List[str]:

     # Get padding strategy
     if padding is not False:
        if padding is True:
           __lowerCAmelCase				      =      PaddingStrategy.LONGEST  # Default to pad to the longest sequence in the batch
        elif not isinstance(lowerCAmelCase_   ,    lowerCAmelCase_	):
           __lowerCAmelCase				      =      PaddingStrategy(lowerCAmelCase_	)
        elif isinstance(lowerCAmelCase_   ,    lowerCAmelCase_	):
           __lowerCAmelCase				      =      padding
     else:
        __lowerCAmelCase				      =      PaddingStrategy.DO_NOT_PAD

     # Set max length if needed
     if max_length is None:
        if padding_strategy == PaddingStrategy.MAX_LENGTH:
           raise ValueError(
               f"""When setting ``padding={PaddingStrategy.MAX_LENGTH}``, make sure that max_length is defined"""	)

        # Test if we have a padding value
     if padding_strategy != PaddingStrategy.DO_NOT_PAD and (self.padding_value is None):
        raise ValueError(
            'Asking to pad but the feature_extractor does not have a padding value. Please select a value to use'
            ' as `padding_value`. For example: `feature_extractor.padding_value = 0.0`.'	)

     return padding_strategy


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


__a    :	int         =    logging.get_logger(__name__)

__a    :	Optional[int]         =    {
    """google/pegasus-large""": """https://huggingface.co/google/pegasus-large/resolve/main/config.json""",
    # See all PEGASUS models at https://huggingface.co/models?filter=pegasus
}




class   _UpperCamelCase (		_UpperCAmelCase					):


			"""simple docstring"""






			__a    :					Any     					=		'''pegasus'''
			__a    :					Optional[Any]     					=		['''past_key_values''']
			__a    :					Tuple     					=		{'''num_attention_heads''': '''encoder_attention_heads''', '''hidden_size''': '''d_model'''}





			def __init__(  self ,  lowerCAmelCase__=5_02_65 ,  lowerCAmelCase__=10_24 ,  lowerCAmelCase__=12 ,  lowerCAmelCase__=40_96 ,  lowerCAmelCase__=16 ,  lowerCAmelCase__=12 ,  lowerCAmelCase__=40_96 ,  lowerCAmelCase__=16 ,  lowerCAmelCase__=0.0 ,  lowerCAmelCase__=0.0 ,  lowerCAmelCase__=True ,  lowerCAmelCase__=True ,  lowerCAmelCase__="gelu" ,  lowerCAmelCase__=10_24 ,  lowerCAmelCase__=0.1 ,  lowerCAmelCase__=0.0 ,  lowerCAmelCase__=0.0 ,  lowerCAmelCase__=0.02 ,  lowerCAmelCase__=0 ,  lowerCAmelCase__=False ,  lowerCAmelCase__=0 ,  lowerCAmelCase__=1 ,  lowerCAmelCase__=1 ,  **lowerCAmelCase__ ,  )	->   Dict:

							'''simple docstring'''


							__lowercase					     =				vocab_size
							__lowercase					     =				max_position_embeddings
							__lowercase					     =				d_model
							__lowercase					     =				encoder_ffn_dim
							__lowercase					     =				encoder_layers
							__lowercase					     =				encoder_attention_heads
							__lowercase					     =				decoder_ffn_dim
							__lowercase					     =				decoder_layers
							__lowercase					     =				decoder_attention_heads
							__lowercase					     =				dropout
							__lowercase					     =				attention_dropout
							__lowercase					     =				activation_dropout
							__lowercase					     =				activation_function
							__lowercase					     =				init_std
							__lowercase					     =				encoder_layerdrop
							__lowercase					     =				decoder_layerdrop
							__lowercase					     =				use_cache
							__lowercase					     =				encoder_layers
							__lowercase					     =				scale_embedding  # scale factor will be sqrt(d_model) if True
							super().__init__(
							    pad_token_id=lowerCAmelCase__ ,  eos_token_id=lowerCAmelCase__ ,  is_encoder_decoder=lowerCAmelCase__ ,  decoder_start_token_id=lowerCAmelCase__ ,  forced_eos_token_id=lowerCAmelCase__ ,  **lowerCAmelCase__ ,  )





			@property
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   int:

							'''simple docstring'''


							return self.encoder_attention_heads





			@property
			def 			_SCREAMING_SNAKE_CASE     (  self		)	->   int:

							'''simple docstring'''


							return self.d_model