code: from collections import OrderedDict
  from typing import Any, Mapping, Optional
  
  from ... import PreTrainedTokenizer
  from ...configuration_utils import PretrainedConfig
  from ...onnx import OnnxConfig, OnnxConfigWithPast, OnnxSeqaSeqConfigWithPast
  from ...onnx.utils import compute_effective_axis_dimension
  from ...utils import TensorType, is_torch_available, logging
  
  
  _SCREAMING_SNAKE_CASE   						=    logging.get_logger(__name__)
  
  _SCREAMING_SNAKE_CASE   						=    {
      """facebook/mbart-large-cc25""": """https://huggingface.co/facebook/mbart-large-cc25/resolve/main/config.json""",
      # See all MBART models at https://huggingface.co/models?filter=mbart
  }
  
  
  
  
  
  
  
  class 					UpperCAmelCase_				(							a_    ):
  
      '''simple docstring'''
  
  
  
  
  
      UpperCAmelCase_			:       Union[str, Any]						 =							'mbart'
      UpperCAmelCase_			:       Any						 =							['past_key_values']
      UpperCAmelCase_			:       List[str]						 =							{'num_attention_heads': 'encoder_attention_heads', 'hidden_size': 'd_model'}
  
  
  
  
      def __init__(					self  :   Dict      ,      lowerCAmelCase  :   Any=50265      ,      lowerCAmelCase  :   Tuple=1024      ,      lowerCAmelCase  :   int=12      ,      lowerCAmelCase  :   Optional[Any]=4096      ,      lowerCAmelCase  :   List[str]=16      ,      lowerCAmelCase  :   Union[str, Any]=12      ,      lowerCAmelCase  :   Any=4096      ,      lowerCAmelCase  :   Dict=16      ,      lowerCAmelCase  :   Tuple=0.0      ,      lowerCAmelCase  :   str=0.0      ,      lowerCAmelCase  :   List[Any]=True      ,      lowerCAmelCase  :   Dict=True      ,      lowerCAmelCase  :   Union[str, Any]="gelu"      ,      lowerCAmelCase  :   List[Any]=1024      ,      lowerCAmelCase  :   Dict=0.1      ,      lowerCAmelCase  :   Dict=0.0      ,      lowerCAmelCase  :   Union[str, Any]=0.0      ,      lowerCAmelCase  :   List[str]=0.02      ,      lowerCAmelCase  :   Any=0.0      ,      lowerCAmelCase  :   Tuple=False      ,      lowerCAmelCase  :   List[str]=1      ,      lowerCAmelCase  :   Dict=0      ,      lowerCAmelCase  :   int=2      ,      lowerCAmelCase  :   List[str]=2      ,      **lowerCAmelCase  :   List[str]      ,      )	-> Tuple:
        a__     		=     vocab_size
        a__     		=     max_position_embeddings
        a__     		=     d_model
        a__     		=     encoder_ffn_dim
        a__     		=     encoder_layers
        a__     		=     encoder_attention_heads
        a__     		=     decoder_ffn_dim
        a__     		=     decoder_layers
        a__     		=     decoder_attention_heads
        a__     		=     dropout
        a__     		=     attention_dropout
        a__     		=     activation_dropout
        a__     		=     activation_function
        a__     		=     init_std
        a__     		=     encoder_layerdrop
        a__     		=     decoder_layerdrop
        a__     		=     classifier_dropout
        a__     		=     use_cache
        a__     		=     encoder_layers
        a__     		=     scale_embedding  # scale factor will be sqrt(d_model) if True
        super().__init__(
            pad_token_id=_snake_case      ,      bos_token_id=_snake_case      ,      eos_token_id=_snake_case      ,      is_encoder_decoder=_snake_case      ,      forced_eos_token_id=_snake_case      ,      **_snake_case      ,      )
  
  
  
  
  
  
  
  class 					UpperCAmelCase_				(							a_    ):
  
      '''simple docstring'''
  
  
  
  
  
      @property
      def 						__lowerCamelCase (					self  :   Dict   )	-> Mapping[str, Mapping[int, str]]:
        if self.task in ["default", "seq2seq-lm"]:
          a__     		=     OrderedDict(
              [
                  ("input_ids", {0: "batch", 1: "encoder_sequence"}),
                  ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
              ]   )
  
          if self.use_past:
            a__     		=     {0: '''batch'''}
            a__     		=     {0: '''batch''', 1: '''past_decoder_sequence + sequence'''}
          else:
            a__     		=     {0: '''batch''', 1: '''decoder_sequence'''}
            a__     		=     {0: '''batch''', 1: '''decoder_sequence'''}
  
          if self.use_past:
            self.fill_with_past_key_values_(_snake_case      ,      direction="inputs"   )
        elif self.task == "causal-lm":
          # TODO: figure this case out.
          a__     		=     OrderedDict(
              [
                  ("input_ids", {0: "batch", 1: "encoder_sequence"}),
                  ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
              ]   )
          if self.use_past:
            a__     		=     self.num_layers
            for i in range(_snake_case   ):
              a__     		=     {0: '''batch''', 2: '''past_sequence + sequence'''}
              a__     		=     {0: '''batch''', 2: '''past_sequence + sequence'''}
        else:
          a__     		=     OrderedDict(
              [
                  ("input_ids", {0: "batch", 1: "encoder_sequence"}),
                  ("attention_mask", {0: "batch", 1: "encoder_sequence"}),
                  ("decoder_input_ids", {0: "batch", 1: "decoder_sequence"}),
                  ("decoder_attention_mask", {0: "batch", 1: "decoder_sequence"}),
              ]   )
  
        return common_inputs
  
  
  
  
      @property
      def 						__lowerCamelCase (					self  :   List[Any]   )	-> Mapping[str, Mapping[int, str]]:
        if self.task in ["default", "seq2seq-lm"]:
          a__     		=     super().outputs
        else:
          a__     		=     super(_snake_case      ,      self   ).outputs
          if self.use_past:
            a__     		=     self.num_layers
            for i in range(_snake_case   ):
              a__     		=     {0: '''batch''', 2: '''past_sequence + sequence'''}
              a__     		=     {0: '''batch''', 2: '''past_sequence + sequence'''}
        return common_outputs
  
  
  
  
      def 						__lowerCamelCase (					self  :   Any      ,      lowerCAmelCase  :   Optional[Any]      ,      lowerCAmelCase  :   int = -1      ,      lowerCAmelCase  :   str = -1      ,      lowerCAmelCase  :   int = False      ,      lowerCAmelCase  :   List[Any] = None      ,      )	-> Mapping[str, Any]:
        a__     		=     self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
            _snake_case      ,      _snake_case      ,      _snake_case      ,      _snake_case      ,      _snake_case   )
  
        # Generate decoder inputs
        a__     		=     seq_length if not self.use_past else 1
        a__     		=     self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
            _snake_case      ,      _snake_case      ,      _snake_case      ,      _snake_case      ,      _snake_case   )
        a__     		=     {f"decoder_{name}": tensor for name, tensor in decoder_inputs.items()}
        a__     		=     dict(**_snake_case      ,      **_snake_case   )
  
        if self.use_past:
          if not is_torch_available():
            raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed."   )
          else:
            import torch
          a__     		=     common_inputs['''input_ids'''].shape
          a__     		=     common_inputs['''decoder_input_ids'''].shape[1]
          a__     		=     self.num_attention_heads
          a__     		=     (
              batch,
              num_encoder_attention_heads,
              encoder_seq_length,
              self._config.hidden_size // num_encoder_attention_heads,
          )
          a__     		=     decoder_seq_length + 3
          a__     		=     (
              batch,
              num_decoder_attention_heads,
              decoder_past_length,
              self._config.hidden_size // num_decoder_attention_heads,
          )
  
          a__     		=     torch.cat(
              [common_inputs["decoder_attention_mask"], torch.ones(_snake_case      ,      _snake_case   )]      ,      dim=1   )
  
          a__     		=     []
          # If the number of encoder and decoder layers are present in the model configuration, both are considered
          a__     		=     self.num_layers
          a__     		=     min(_snake_case      ,      _snake_case   )
          a__     		=     max(_snake_case      ,      _snake_case   ) - min_num_layers
          a__     		=     '''encoder''' if num_encoder_layers > num_decoder_layers else '''decoder'''
  
          for _ in range(_snake_case   ):
            common_inputs["past_key_values"].append(
                (
                    torch.zeros(_snake_case   ),
                    torch.zeros(_snake_case   ),
                    torch.zeros(_snake_case   ),
                    torch.zeros(_snake_case   ),
                )   )
          # TODO: test this.
          a__     		=     encoder_shape if remaining_side_name == '''encoder''' else decoder_shape
          for _ in range(_snake_case      ,      _snake_case   ):
            common_inputs["past_key_values"].append((torch.zeros(_snake_case   ), torch.zeros(_snake_case   ))   )
        return common_inputs
  
  
  
  
      def 						__lowerCamelCase (					self  :   int      ,      lowerCAmelCase  :   Tuple      ,      lowerCAmelCase  :   Optional[int] = -1      ,      lowerCAmelCase  :   List[str] = -1      ,      lowerCAmelCase  :   Optional[int] = False      ,      lowerCAmelCase  :   str = None      ,      )	-> Mapping[str, Any]:
        a__     		=     self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
            _snake_case      ,      _snake_case      ,      _snake_case      ,      _snake_case      ,      _snake_case   )
  
        if self.use_past:
          if not is_torch_available():
            raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed."   )
          else:
            import torch
          a__     		=     common_inputs['''input_ids'''].shape
          # Not using the same length for past_key_values
          a__     		=     seqlen + 2
          a__     		=     self.num_layers
          a__     		=     self.num_attention_heads
          a__     		=     (
              batch,
              num_encoder_attention_heads,
              past_key_values_length,
              self._config.hidden_size // num_encoder_attention_heads,
          )
  
          a__     		=     common_inputs['''attention_mask'''].dtype
          a__     		=     torch.cat(
              [common_inputs["attention_mask"], torch.ones(_snake_case      ,      _snake_case      ,      dtype=_snake_case   )]      ,      dim=1   )
          a__     		=     [
              (torch.zeros(_snake_case   ), torch.zeros(_snake_case   )) for _ in range(_snake_case   )
          ]
        return common_inputs
  
  
  
  
      def 						__lowerCamelCase (					self  :   Union[str, Any]      ,      lowerCAmelCase  :   List[str]      ,      lowerCAmelCase  :   Optional[int] = -1      ,      lowerCAmelCase  :   Any = -1      ,      lowerCAmelCase  :   str = False      ,      lowerCAmelCase  :   List[Any] = None      ,      )	-> Mapping[str, Any]:
        # Copied from OnnxConfig.generate_dummy_inputs
        # Did not use super(OnnxConfigWithPast, self).generate_dummy_inputs for code clarity.
        # If dynamic axis (-1) we forward with a fixed dimension of 2 samples to avoid optimizations made by ONNX
        a__     		=     compute_effective_axis_dimension(
            _snake_case      ,      fixed_dimension=OnnxConfig.default_fixed_batch      ,      num_token_to_add=0   )
  
        # If dynamic axis (-1) we forward with a fixed dimension of 8 tokens to avoid optimizations made by ONNX
        a__     		=     tokenizer.num_special_tokens_to_add(_snake_case   )
        a__     		=     compute_effective_axis_dimension(
            _snake_case      ,      fixed_dimension=OnnxConfig.default_fixed_sequence      ,      num_token_to_add=_snake_case   )
  
        # Generate dummy inputs according to compute batch and sequence
        a__     		=     [''' '''.join([tokenizer.unk_token]   ) * seq_length] * batch_size
        a__     		=     dict(tokenizer(_snake_case      ,      return_tensors=_snake_case   )   )
        return common_inputs
  
  
  
  
      def 						__lowerCamelCase (					self  :   List[str]      ,      lowerCAmelCase  :   Optional[Any]      ,      lowerCAmelCase  :   Optional[Any] = -1      ,      lowerCAmelCase  :   Any = -1      ,      lowerCAmelCase  :   str = False      ,      lowerCAmelCase  :   Any = None      ,      )	-> Mapping[str, Any]:
        if self.task in ["default", "seq2seq-lm"]:
          a__     		=     self._generate_dummy_inputs_for_default_and_seqaseq_lm(
              _snake_case      ,      batch_size=_snake_case      ,      seq_length=_snake_case      ,      is_pair=_snake_case      ,      framework=_snake_case   )
  
        elif self.task == "causal-lm":
          a__     		=     self._generate_dummy_inputs_for_causal_lm(
              _snake_case      ,      batch_size=_snake_case      ,      seq_length=_snake_case      ,      is_pair=_snake_case      ,      framework=_snake_case   )
        else:
          a__     		=     self._generate_dummy_inputs_for_sequence_classification_and_question_answering(
              _snake_case      ,      batch_size=_snake_case      ,      seq_length=_snake_case      ,      is_pair=_snake_case      ,      framework=_snake_case   )
  
        return common_inputs
  
  
  
  
      def 						__lowerCamelCase (					self  :   Any      ,      lowerCAmelCase  :   Dict      ,      lowerCAmelCase  :   List[str]      ,      lowerCAmelCase  :   Optional[int]      ,      lowerCAmelCase  :   Optional[Any]   )	-> Optional[int]:
        if self.task in ["default", "seq2seq-lm"]:
          a__     		=     super()._flatten_past_key_values_(_snake_case      ,      _snake_case      ,      _snake_case      ,      _snake_case   )
        else:
          a__     		=     super(_snake_case      ,      self   )._flatten_past_key_values_(
              _snake_case      ,      _snake_case      ,      _snake_case      ,      _snake_case   )
  
  
style_context: from unittest.mock import patch
  
  import datasets
  from datasets import Dataset
  def 				__lowercase	(						)				->Union[str, Any]:
  
    '''simple docstring'''
  
  
  
  
    a__     		=     Dataset.from_dict({"col_1": [3, 2, 0, 1]}					)
  
    with patch("tqdm.auto.tqdm"					) as mock_tqdm:
      datasets.disable_progress_bar()
      dset.map(lambda lowerCamelCase__					: {"col_2": x["col_1"] + 1}					)
      mock_tqdm.assert_not_called()
  
      mock_tqdm.reset_mock()
  
      datasets.enable_progress_bar()
      dset.map(lambda lowerCamelCase__					: {"col_2": x["col_1"] + 1}					)
      mock_tqdm.assert_called()
  
  