
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 						__lowercase:


       """simple docstring"""







       def __init__(     self					:			Optional[int]  ,      _lowerCAmelCase					:			List[Any]  ,      _lowerCAmelCase					:			Tuple=99  ,      _lowerCAmelCase					:			Dict=13  ,      _lowerCAmelCase					:			Dict=16  ,      _lowerCAmelCase					:			Any=7  ,      _lowerCAmelCase					:			Union[str, Any]=True  ,      _lowerCAmelCase					:			str=True  ,      _lowerCAmelCase					:			List[str]=True  ,      _lowerCAmelCase					:			int=False  ,      _lowerCAmelCase					:			str=True  ,      _lowerCAmelCase					:			List[Any]=2  ,      _lowerCAmelCase					:			List[str]=32  ,      _lowerCAmelCase					:			Dict=4  ,      _lowerCAmelCase					:			Optional[int]=4  ,      _lowerCAmelCase					:			Dict=30  ,      _lowerCAmelCase					:			int=0  ,      _lowerCAmelCase					:			List[str]=1  ,      _lowerCAmelCase					:			str=2  ,      _lowerCAmelCase					:			Tuple=None  ,      )					->   List[str]:
         _lowerCAmelCase						=		parent
         _lowerCAmelCase						=		batch_size
         _lowerCAmelCase						=		decoder_seq_length
         # For common tests
         _lowerCAmelCase						=		self.decoder_seq_length
         _lowerCAmelCase						=		is_training
         _lowerCAmelCase						=		use_attention_mask
         _lowerCAmelCase						=		use_labels

         _lowerCAmelCase						=		vocab_size
         _lowerCAmelCase						=		d_model
         _lowerCAmelCase						=		d_model
         _lowerCAmelCase						=		decoder_layers
         _lowerCAmelCase						=		decoder_layers
         _lowerCAmelCase						=		decoder_ffn_dim
         _lowerCAmelCase						=		decoder_attention_heads
         _lowerCAmelCase						=		decoder_attention_heads
         _lowerCAmelCase						=		eos_token_id
         _lowerCAmelCase						=		bos_token_id
         _lowerCAmelCase						=		pad_token_id
         _lowerCAmelCase						=		decoder_start_token_id
         _lowerCAmelCase						=		use_cache
         _lowerCAmelCase						=		max_position_embeddings

         _lowerCAmelCase						=		None
         _lowerCAmelCase						=		decoder_seq_length
         _lowerCAmelCase						=		2
         _lowerCAmelCase						=		1



       def SCREAMING_SNAKE_CASE_				(     self					:			str       )					->   List[str]:
         _lowerCAmelCase						=		ids_tensor([self.batch_size, self.decoder_seq_length]  ,      self.vocab_size       )

         _lowerCAmelCase						=		None
         if self.use_attention_mask:
           _lowerCAmelCase						=		ids_tensor([self.batch_size, self.decoder_seq_length]  ,      vocab_size=2       )

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

         _lowerCAmelCase						=		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 SCREAMING_SNAKE_CASE_				(     self					:			Union[str, Any]  ,      _lowerCAmelCase					:			Optional[Any]  ,      _lowerCAmelCase					:			Optional[int]  ,      _lowerCAmelCase					:			Any  ,      _lowerCAmelCase					:			List[Any]  ,      )					->   Any:
         _lowerCAmelCase						=		True
         _lowerCAmelCase						=		SpeechaTextaDecoder(config=_lowerCAmelCase       ).to(_lowerCAmelCase       ).eval()
         _lowerCAmelCase						=		input_ids[:2]

         input_ids[input_ids == 0] += 1
         # first forward pass
         _lowerCAmelCase						=		model(_lowerCAmelCase  ,      use_cache=_lowerCAmelCase       )
         _lowerCAmelCase						=		model(_lowerCAmelCase       )
         _lowerCAmelCase						=		model(_lowerCAmelCase  ,      use_cache=_lowerCAmelCase       )

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

         _lowerCAmelCase						=		outputs['past_key_values']

         # create hypothetical next token and extent to next_input_ids
         _lowerCAmelCase						=		ids_tensor((2, 1)  ,      config.vocab_size - 1       ) + 1

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

         print(_lowerCAmelCase       )

         _lowerCAmelCase						=		model(_lowerCAmelCase       )['last_hidden_state']
         _lowerCAmelCase						=		model(_lowerCAmelCase  ,      past_key_values=_lowerCAmelCase       )['last_hidden_state']

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

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






       def SCREAMING_SNAKE_CASE_				(     self					:			List[Any]       )					->   Any:
         _lowerCAmelCase						=		self.prepare_config_and_inputs()
         (
             (
             _lowerCAmelCase
         )	,       (
             _lowerCAmelCase
         )	,       (
             _lowerCAmelCase
         )	,       (
             _lowerCAmelCase
         )	,       
         )						=		config_and_inputs

         _lowerCAmelCase						=		{
             'input_ids': input_ids,
             'attention_mask': attention_mask,
         }
         return config, inputs_dict





@require_torch
class 						__lowercase(     SCREAMING_SNAKE_CASE		,  SCREAMING_SNAKE_CASE		,  SCREAMING_SNAKE_CASE		,  unittest.TestCase   ):


       """simple docstring"""







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



       def SCREAMING_SNAKE_CASE_				(     self					:			List[Any]  ,      )					->   Tuple:
         _lowerCAmelCase						=		SpeechaTextaStandaloneDecoderModelTester(self  ,      is_training=_lowerCAmelCase       )
         _lowerCAmelCase						=		ConfigTester(self  ,      config_class=_lowerCAmelCase       )



       def SCREAMING_SNAKE_CASE_				(     self					:			List[Any]       )					->   Dict:
         pass



       def SCREAMING_SNAKE_CASE_				(     self					:			Any       )					->   str:
         pass



       def SCREAMING_SNAKE_CASE_				(     self					:			Any       )					->   Optional[int]:
         pass



       def SCREAMING_SNAKE_CASE_				(     self					:			str       )					->   Dict:
         self.config_tester.run_common_tests()



       def SCREAMING_SNAKE_CASE_				(     self					:			List[str]       )					->   Dict:
         _lowerCAmelCase						=		self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_decoder_model_past(*_lowerCAmelCase       )






       def SCREAMING_SNAKE_CASE_				(     self					:			Union[str, Any]       )					->   str:
         return


import abc
import copy
import dataclasses
from dataclasses import dataclass
from typing import ClassVar, Dict, Type, TypeVar

from ..features import Features


_UpperCamelCase:					List[Any]     =TypeVar('T', bound='TaskTemplate')





@dataclass(frozen=SCREAMING_SNAKE_CASE   )
class 						__lowercase(     abc.ABC   ):


       """simple docstring"""







       UpperCamelCase_				 =							42
       UpperCamelCase_				 =							42
       UpperCamelCase_				 =							42



       def SCREAMING_SNAKE_CASE_				(     self					:			T  ,      _lowerCAmelCase					:			Features       )					->   T:
         return copy.deepcopy(self       )



       @property
       def SCREAMING_SNAKE_CASE_				(     self					:			str       )					->   Features:
         return Features(**self.input_schema  ,      **self.label_schema       )



       @property
       @abc.abstractmethod
       def SCREAMING_SNAKE_CASE_				(     self					:			Dict       )					->   Dict[str, str]:
         raise NotImplementedError






       @classmethod
       def SCREAMING_SNAKE_CASE_				(     cls					:			Type[T]  ,      _lowerCAmelCase					:			dict       )					->   T:
         _lowerCAmelCase						=		{f.name for f in dataclasses.fields(cls       )}
         return cls(**{k: v for k, v in template_dict.items() if k in field_names}       )
