



'''simple docstring'''





import unittest

from transformers import is_torch_available
from transformers.testing_utils import require_torch


if is_torch_available():
  import torch

  from transformers.generation import DisjunctiveConstraint






@require_torch
class __A    (						unittest.TestCase		):



 '''simple docstring'''







 def       a__						(self )					->  Optional[int]:


      """simple docstring"""



      _a											=						[[1, 2, 4], [1, 2, 3, 4]]
      _a											=						DisjunctiveConstraint(A )
      self.assertTrue(isinstance(dc.token_ids				,     A ) )

      with self.assertRaises(A ):
           DisjunctiveConstraint(torch.LongTensor([[1, 2, 4], [1, 2, 3]] ) )

      with self.assertRaises(A ):
           DisjunctiveConstraint([torch.LongTensor([1, 2, 4] ), torch.LongTensor([1, 2, 3, 4, 5] )] )



 def       a__						(self )					->  Any:


      """simple docstring"""



      _a											=						[[1, 2], [1, 2, 3, 4]]

      with self.assertRaises(A ):
           DisjunctiveConstraint(A )  # fails here



 def       a__						(self )					->  Dict:


      """simple docstring"""



      _a											=						[[1, 2, 3], [1, 2, 4]]

      _a											=						DisjunctiveConstraint(A )

      _a						,					_a						,					_a											=						dc.update(1 )
      _a											=						stepped is True and completed is False and reset is False
      self.assertTrue(A )
      self.assertTrue(not dc.completed )
      self.assertTrue(dc.current_seq == [1] )

      _a						,					_a						,					_a											=						dc.update(2 )
      _a											=						stepped is True and completed is False and reset is False
      self.assertTrue(A )
      self.assertTrue(not dc.completed )
      self.assertTrue(dc.current_seq == [1, 2] )

      _a						,					_a						,					_a											=						dc.update(3 )
      _a											=						stepped is True and completed is True and reset is False
      self.assertTrue(A )
      self.assertTrue(dc.completed )  # Completed!
      self.assertTrue(dc.current_seq == [1, 2, 3] )



 def       a__						(self )					->  List[Any]:


      """simple docstring"""



      _a											=						[[1, 2, 3], [1, 2, 4, 5], [1, 2, 5]]

      _a											=						DisjunctiveConstraint(A )

      _a						,					_a						,					_a											=						dc.update(1 )
      self.assertTrue(not dc.completed )
      self.assertTrue(dc.current_seq == [1] )

      _a						,					_a						,					_a											=						dc.update(2 )
      self.assertTrue(not dc.completed )
      self.assertTrue(dc.current_seq == [1, 2] )

      _a						,					_a						,					_a											=						dc.update(4 )
      self.assertTrue(not dc.completed )
      self.assertTrue(dc.current_seq == [1, 2, 4] )

      _a						,					_a						,					_a											=						dc.update(5 )
      self.assertTrue(dc.completed )  # Completed!
      self.assertTrue(dc.current_seq == [1, 2, 4, 5] )

      dc.reset()

      _a						,					_a						,					_a											=						dc.update(1 )
      self.assertTrue(not dc.completed )
      self.assertTrue(dc.remaining() == 3 )
      self.assertTrue(dc.current_seq == [1] )

      _a						,					_a						,					_a											=						dc.update(2 )
      self.assertTrue(not dc.completed )
      self.assertTrue(dc.remaining() == 2 )
      self.assertTrue(dc.current_seq == [1, 2] )

      _a						,					_a						,					_a											=						dc.update(5 )
      self.assertTrue(dc.completed )  # Completed!
      self.assertTrue(dc.remaining() == 0 )
      self.assertTrue(dc.current_seq == [1, 2, 5] )








'''simple docstring'''





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


lowercase_	 =						logging.get_logger(__name__)

lowercase_	 =						{
    "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 __A    (						A		):



 '''simple docstring'''







 __lowerCamelCase					: Union[str, Any]    = 'pegasus'
 __lowerCamelCase					: Tuple    = ['past_key_values']
 __lowerCamelCase					: List[Any]    = {'num_attention_heads': 'encoder_attention_heads', 'hidden_size': 'd_model'}



 def __init__(self				,     A=50_265				,     A=1_024				,     A=12				,     A=4_096				,     A=16				,     A=12				,     A=4_096				,     A=16				,     A=0.0				,     A=0.0				,     A=True				,     A=True				,     A="gelu"				,     A=1_024				,     A=0.1				,     A=0.0				,     A=0.0				,     A=0.02				,     A=0				,     A=False				,     A=0				,     A=1				,     A=1				,     **A				,     )					->  str:


      """simple docstring"""



      _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											=						use_cache
      _a											=						encoder_layers
      _a											=						scale_embedding  # scale factor will be sqrt(d_model) if True
      super().__init__(
          pad_token_id=A				,     eos_token_id=A				,     is_encoder_decoder=A				,     decoder_start_token_id=A				,     forced_eos_token_id=A				,     **A				,     )



 @property
 def       a__						(self )					->  int:


      """simple docstring"""



      return self.encoder_attention_heads



 @property
 def       a__						(self )					->  int:


      """simple docstring"""



      return self.d_model



