



"""simple docstring"""







from typing import TYPE_CHECKING

from ..utils import OptionalDependencyNotAvailable, _LazyModule, is_flax_available, is_tf_available, is_torch_available


UpperCAmelCase:   int       			=							{
    """configuration_utils""": ["""GenerationConfig"""],
    """streamers""": ["""TextIteratorStreamer""", """TextStreamer"""],
}

try:
		if not is_torch_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		UpperCAmelCase:   List[Any]       			=							[
		    """Constraint""",
		    """ConstraintListState""",
		    """DisjunctiveConstraint""",
		    """PhrasalConstraint""",
		]
		UpperCAmelCase:   Optional[Any]       			=							[
		    """BeamHypotheses""",
		    """BeamScorer""",
		    """BeamSearchScorer""",
		    """ConstrainedBeamSearchScorer""",
		]
		UpperCAmelCase:   Any       			=							[
		    """EpsilonLogitsWarper""",
		    """EtaLogitsWarper""",
		    """ForcedBOSTokenLogitsProcessor""",
		    """ForcedEOSTokenLogitsProcessor""",
		    """HammingDiversityLogitsProcessor""",
		    """InfNanRemoveLogitsProcessor""",
		    """LogitsProcessor""",
		    """LogitsProcessorList""",
		    """LogitsWarper""",
		    """MinLengthLogitsProcessor""",
		    """MinNewTokensLengthLogitsProcessor""",
		    """NoBadWordsLogitsProcessor""",
		    """NoRepeatNGramLogitsProcessor""",
		    """PrefixConstrainedLogitsProcessor""",
		    """RepetitionPenaltyLogitsProcessor""",
		    """SequenceBiasLogitsProcessor""",
		    """EncoderRepetitionPenaltyLogitsProcessor""",
		    """TemperatureLogitsWarper""",
		    """TopKLogitsWarper""",
		    """TopPLogitsWarper""",
		    """TypicalLogitsWarper""",
		    """EncoderNoRepeatNGramLogitsProcessor""",
		    """ExponentialDecayLengthPenalty""",
		    """LogitNormalization""",
		]
		UpperCAmelCase:   str       			=							[
		    """MaxNewTokensCriteria""",
		    """MaxLengthCriteria""",
		    """MaxTimeCriteria""",
		    """StoppingCriteria""",
		    """StoppingCriteriaList""",
		    """validate_stopping_criteria""",
		]
		UpperCAmelCase:   Optional[Any]       			=							[
		    """GenerationMixin""",
		    """top_k_top_p_filtering""",
		    """GreedySearchEncoderDecoderOutput""",
		    """GreedySearchDecoderOnlyOutput""",
		    """SampleEncoderDecoderOutput""",
		    """SampleDecoderOnlyOutput""",
		    """BeamSearchEncoderDecoderOutput""",
		    """BeamSearchDecoderOnlyOutput""",
		    """BeamSampleEncoderDecoderOutput""",
		    """BeamSampleDecoderOnlyOutput""",
		    """ContrastiveSearchEncoderDecoderOutput""",
		    """ContrastiveSearchDecoderOnlyOutput""",
		]

try:
		if not is_tf_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		UpperCAmelCase:   Any       			=							[
		    """TFForcedBOSTokenLogitsProcessor""",
		    """TFForcedEOSTokenLogitsProcessor""",
		    """TFLogitsProcessor""",
		    """TFLogitsProcessorList""",
		    """TFLogitsWarper""",
		    """TFMinLengthLogitsProcessor""",
		    """TFNoBadWordsLogitsProcessor""",
		    """TFNoRepeatNGramLogitsProcessor""",
		    """TFRepetitionPenaltyLogitsProcessor""",
		    """TFTemperatureLogitsWarper""",
		    """TFTopKLogitsWarper""",
		    """TFTopPLogitsWarper""",
		    """TFForceTokensLogitsProcessor""",
		    """TFSuppressTokensAtBeginLogitsProcessor""",
		    """TFSuppressTokensLogitsProcessor""",
		]
		UpperCAmelCase:   Tuple       			=							[
		    """TFGenerationMixin""",
		    """tf_top_k_top_p_filtering""",
		    """TFGreedySearchDecoderOnlyOutput""",
		    """TFGreedySearchEncoderDecoderOutput""",
		    """TFSampleEncoderDecoderOutput""",
		    """TFSampleDecoderOnlyOutput""",
		    """TFBeamSearchEncoderDecoderOutput""",
		    """TFBeamSearchDecoderOnlyOutput""",
		    """TFBeamSampleEncoderDecoderOutput""",
		    """TFBeamSampleDecoderOnlyOutput""",
		    """TFContrastiveSearchEncoderDecoderOutput""",
		    """TFContrastiveSearchDecoderOnlyOutput""",
		]

try:
		if not is_flax_available():
				raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
		pass
else:
		UpperCAmelCase:   Tuple       			=							[
		    """FlaxForcedBOSTokenLogitsProcessor""",
		    """FlaxForcedEOSTokenLogitsProcessor""",
		    """FlaxLogitsProcessor""",
		    """FlaxLogitsProcessorList""",
		    """FlaxLogitsWarper""",
		    """FlaxMinLengthLogitsProcessor""",
		    """FlaxTemperatureLogitsWarper""",
		    """FlaxTopKLogitsWarper""",
		    """FlaxTopPLogitsWarper""",
		]
		UpperCAmelCase:   int       			=							[
		    """FlaxGenerationMixin""",
		    """FlaxGreedySearchOutput""",
		    """FlaxSampleOutput""",
		    """FlaxBeamSearchOutput""",
		]

if TYPE_CHECKING:
		from .configuration_utils import GenerationConfig
		from .streamers import TextIteratorStreamer, TextStreamer

		try:
				if not is_torch_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .beam_constraints import Constraint, ConstraintListState, DisjunctiveConstraint, PhrasalConstraint
				from .beam_search import BeamHypotheses, BeamScorer, BeamSearchScorer, ConstrainedBeamSearchScorer
				from .logits_process import (
				    EncoderNoRepeatNGramLogitsProcessor,
				    EncoderRepetitionPenaltyLogitsProcessor,
				    EpsilonLogitsWarper,
				    EtaLogitsWarper,
				    ExponentialDecayLengthPenalty,
				    ForcedBOSTokenLogitsProcessor,
				    ForcedEOSTokenLogitsProcessor,
				    HammingDiversityLogitsProcessor,
				    InfNanRemoveLogitsProcessor,
				    LogitNormalization,
				    LogitsProcessor,
				    LogitsProcessorList,
				    LogitsWarper,
				    MinLengthLogitsProcessor,
				    MinNewTokensLengthLogitsProcessor,
				    NoBadWordsLogitsProcessor,
				    NoRepeatNGramLogitsProcessor,
				    PrefixConstrainedLogitsProcessor,
				    RepetitionPenaltyLogitsProcessor,
				    SequenceBiasLogitsProcessor,
				    TemperatureLogitsWarper,
				    TopKLogitsWarper,
				    TopPLogitsWarper,
				    TypicalLogitsWarper,
				)
				from .stopping_criteria import (
				    MaxLengthCriteria,
				    MaxNewTokensCriteria,
				    MaxTimeCriteria,
				    StoppingCriteria,
				    StoppingCriteriaList,
				    validate_stopping_criteria,
				)
				from .utils import (
				    BeamSampleDecoderOnlyOutput,
				    BeamSampleEncoderDecoderOutput,
				    BeamSearchDecoderOnlyOutput,
				    BeamSearchEncoderDecoderOutput,
				    ContrastiveSearchDecoderOnlyOutput,
				    ContrastiveSearchEncoderDecoderOutput,
				    GenerationMixin,
				    GreedySearchDecoderOnlyOutput,
				    GreedySearchEncoderDecoderOutput,
				    SampleDecoderOnlyOutput,
				    SampleEncoderDecoderOutput,
				    top_k_top_p_filtering,
				)

		try:
				if not is_tf_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .tf_logits_process import (
				    TFForcedBOSTokenLogitsProcessor,
				    TFForcedEOSTokenLogitsProcessor,
				    TFForceTokensLogitsProcessor,
				    TFLogitsProcessor,
				    TFLogitsProcessorList,
				    TFLogitsWarper,
				    TFMinLengthLogitsProcessor,
				    TFNoBadWordsLogitsProcessor,
				    TFNoRepeatNGramLogitsProcessor,
				    TFRepetitionPenaltyLogitsProcessor,
				    TFSuppressTokensAtBeginLogitsProcessor,
				    TFSuppressTokensLogitsProcessor,
				    TFTemperatureLogitsWarper,
				    TFTopKLogitsWarper,
				    TFTopPLogitsWarper,
				)
				from .tf_utils import (
				    TFBeamSampleDecoderOnlyOutput,
				    TFBeamSampleEncoderDecoderOutput,
				    TFBeamSearchDecoderOnlyOutput,
				    TFBeamSearchEncoderDecoderOutput,
				    TFContrastiveSearchDecoderOnlyOutput,
				    TFContrastiveSearchEncoderDecoderOutput,
				    TFGenerationMixin,
				    TFGreedySearchDecoderOnlyOutput,
				    TFGreedySearchEncoderDecoderOutput,
				    TFSampleDecoderOnlyOutput,
				    TFSampleEncoderDecoderOutput,
				    tf_top_k_top_p_filtering,
				)

		try:
				if not is_flax_available():
						raise OptionalDependencyNotAvailable()
		except OptionalDependencyNotAvailable:
				pass
		else:
				from .flax_logits_process import (
				    FlaxForcedBOSTokenLogitsProcessor,
				    FlaxForcedEOSTokenLogitsProcessor,
				    FlaxLogitsProcessor,
				    FlaxLogitsProcessorList,
				    FlaxLogitsWarper,
				    FlaxMinLengthLogitsProcessor,
				    FlaxTemperatureLogitsWarper,
				    FlaxTopKLogitsWarper,
				    FlaxTopPLogitsWarper,
				)
				from .flax_utils import FlaxBeamSearchOutput, FlaxGenerationMixin, FlaxGreedySearchOutput, FlaxSampleOutput
else:
		import sys

		UpperCAmelCase:   Optional[Any]       			=							_LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)











"""simple docstring"""







import unittest

from transformers import SpeechaTextaConfig
from transformers.testing_utils import is_torch_available, require_torch, torch_device

from ...generation.test_utils import GenerationTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
			import torch

			from transformers.models.speech_to_text_a.modeling_speech_to_text_a import (
			    SpeechaTextaDecoder,
			    SpeechaTextaForCausalLM,
			)


@require_torch
class     __UpperCAmelCase:




						"""simple docstring"""




						def __init__(   self       ,  snake_case__       ,  snake_case__=99       ,  snake_case__=13       ,  snake_case__=16       ,  snake_case__=7       ,  snake_case__=True       ,  snake_case__=True       ,  snake_case__=True       ,  snake_case__=False       ,  snake_case__=True       ,  snake_case__=2       ,  snake_case__=32       ,  snake_case__=4       ,  snake_case__=4       ,  snake_case__=30       ,  snake_case__=0       ,  snake_case__=1       ,  snake_case__=2       ,  snake_case__=None       ,  ):
												'''simple docstring'''
												lowercase__				:      List[str]=       parent
												lowercase__				:      Dict=       batch_size
												lowercase__				:      List[str]=       decoder_seq_length
												# For common tests
												lowercase__				:      List[str]=       self.decoder_seq_length
												lowercase__				:      int=       is_training
												lowercase__				:      Any=       use_attention_mask
												lowercase__				:      List[str]=       use_labels

												lowercase__				:      Dict=       vocab_size
												lowercase__				:      Dict=       d_model
												lowercase__				:      Union[str, Any]=       d_model
												lowercase__				:      List[str]=       decoder_layers
												lowercase__				:      Optional[Any]=       decoder_layers
												lowercase__				:      Optional[Any]=       decoder_ffn_dim
												lowercase__				:      Union[str, Any]=       decoder_attention_heads
												lowercase__				:      Tuple=       decoder_attention_heads
												lowercase__				:      Optional[Any]=       eos_token_id
												lowercase__				:      List[Any]=       bos_token_id
												lowercase__				:      Any=       pad_token_id
												lowercase__				:      Union[str, Any]=       decoder_start_token_id
												lowercase__				:      Optional[Any]=       use_cache
												lowercase__				:      List[Any]=       max_position_embeddings

												lowercase__				:      Tuple=       None
												lowercase__				:      Optional[Any]=       decoder_seq_length
												lowercase__				:      Optional[int]=       2
												lowercase__				:      Tuple=       1




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      List[Any]=       ids_tensor([self.batch_size, self.decoder_seq_length]       ,  self.vocab_size			)

												lowercase__				:      Tuple=       None
												if self.use_attention_mask:
																		lowercase__				:      List[str]=       ids_tensor([self.batch_size, self.decoder_seq_length]       ,  vocab_size=2			)

												lowercase__				:      Any=       None
												if self.use_labels:
																		lowercase__				:      str=       ids_tensor([self.batch_size, self.decoder_seq_length]       ,  self.vocab_size			)

												lowercase__				:      Dict=       SpeechaTextaConfig(
												    vocab_size=self.vocab_size       ,  d_model=self.d_model       ,  decoder_layers=self.decoder_layers       ,  decoder_ffn_dim=self.decoder_ffn_dim       ,  decoder_attention_heads=self.decoder_attention_heads       ,  eos_token_id=self.eos_token_id       ,  bos_token_id=self.bos_token_id       ,  use_cache=self.use_cache       ,  pad_token_id=self.pad_token_id       ,  decoder_start_token_id=self.decoder_start_token_id       ,  max_position_embeddings=self.max_position_embeddings       ,  )

												return (
												    config,
												    input_ids,
												    attention_mask,
												    lm_labels,
												)




						def 		UpperCAmelCase_       (   self       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  snake_case__       ,  ):
												'''simple docstring'''
												lowercase__				:      Union[str, Any]=       True
												lowercase__				:      List[Any]=       SpeechaTextaDecoder(config=snake_case__			).to(snake_case__			).eval()
												lowercase__				:      Any=       input_ids[:2]

												input_ids[input_ids == 0] += 1
												# first forward pass
												lowercase__				:      List[str]=       model(snake_case__       ,  use_cache=snake_case__			)
												lowercase__				:      Optional[Any]=       model(snake_case__			)
												lowercase__				:      List[Any]=       model(snake_case__       ,  use_cache=snake_case__			)

												self.parent.assertTrue(len(snake_case__			) == len(snake_case__			)			)
												self.parent.assertTrue(len(snake_case__			) == len(snake_case__			) + 1			)

												lowercase__				:      List[Any]=       outputs["past_key_values"]

												# create hypothetical next token and extent to next_input_ids
												lowercase__				:      List[Any]=       ids_tensor((2, 1)       ,  config.vocab_size - 1			) + 1

												# append to next input_ids and
												lowercase__				:      Tuple=       torch.cat([input_ids, next_tokens]       ,  dim=-1			)

												print(snake_case__			)

												lowercase__				:      int=       model(snake_case__			)["last_hidden_state"]
												lowercase__				:      int=       model(snake_case__       ,  past_key_values=snake_case__			)["last_hidden_state"]

												# select random slice
												lowercase__				:      str=       ids_tensor((1,)       ,  output_from_past.shape[-1]			).item()
												lowercase__				:      Any=       output_from_no_past[:, next_input_ids.shape[-1] - 1, random_slice_idx].detach()
												lowercase__				:      int=       output_from_past[:, 0, random_slice_idx].detach()

												# test that outputs are equal for slice
												assert torch.allclose(snake_case__       ,  snake_case__       ,  atol=1e-3			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      str=       self.prepare_config_and_inputs()
												(
												    (
												    lowercase__
												),	(
												    lowercase__
												),	(
												    lowercase__
												),	(
												    lowercase__
												),	
												)				:      Dict=       config_and_inputs

												lowercase__				:      Optional[int]=       {
												    "input_ids": input_ids,
												    "attention_mask": attention_mask,
												}
												return config, inputs_dict


@require_torch
class     __UpperCAmelCase(   SCREAMING_SNAKE_CASE__  ,  SCREAMING_SNAKE_CASE__  ,  SCREAMING_SNAKE_CASE__  ,  unittest.TestCase							):




						"""simple docstring"""




						__lowerCamelCase				       =					(SpeechaTextaDecoder, SpeechaTextaForCausalLM) if is_torch_available() else ()
						__lowerCamelCase				       =					(SpeechaTextaForCausalLM,) if is_torch_available() else ()
						__lowerCamelCase				       =					{"text-generation": SpeechaTextaForCausalLM} if is_torch_available() else {}
						__lowerCamelCase				       =					True
						__lowerCamelCase				       =					False




						def 		UpperCAmelCase_       (   self       ,  ):
												'''simple docstring'''
												lowercase__				:      List[str]=       SpeechaTextaStandaloneDecoderModelTester(self       ,  is_training=snake_case__			)
												lowercase__				:      int=       ConfigTester(self       ,  config_class=snake_case__			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												pass




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												pass




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												pass




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												self.config_tester.run_common_tests()




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												lowercase__				:      Optional[int]=       self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_decoder_model_past(*snake_case__			)




						def 		UpperCAmelCase_       (   self			):
												'''simple docstring'''
												return






