



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    :





   def __init__(						self							,  _lowerCAmelCase							,  _lowerCAmelCase=99							,  _lowerCAmelCase=13							,  _lowerCAmelCase=16							,  _lowerCAmelCase=7							,  _lowerCAmelCase=True							,  _lowerCAmelCase=True							,  _lowerCAmelCase=True							,  _lowerCAmelCase=False							,  _lowerCAmelCase=True							,  _lowerCAmelCase=2							,  _lowerCAmelCase=32							,  _lowerCAmelCase=4							,  _lowerCAmelCase=4							,  _lowerCAmelCase=30							,  _lowerCAmelCase=0							,  _lowerCAmelCase=1							,  _lowerCAmelCase=2							,  _lowerCAmelCase=None							,  ):
         _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 						__lowerCAmelCase				(						self      ):
         _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 						__lowerCAmelCase				(						self							,  _lowerCAmelCase							,  _lowerCAmelCase							,  _lowerCAmelCase							,  _lowerCAmelCase							,  ):
         _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 						__lowerCAmelCase				(						self      ):
         _lowerCAmelCase			      =	self.prepare_config_and_inputs()
         (
             _lowerCAmelCase		
         )			      =	config_and_inputs

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






@require_torch
class 		UpperCAmelCase    (    snake_case_							,snake_case_							,snake_case_							,unittest.TestCase					):
   SCREAMING_SNAKE_CASE__					      =  (SpeechaTextaDecoder, SpeechaTextaForCausalLM) if is_torch_available() else ()
   SCREAMING_SNAKE_CASE__					      =  (SpeechaTextaForCausalLM,) if is_torch_available() else ()
   SCREAMING_SNAKE_CASE__					      =  {'''text-generation''': SpeechaTextaForCausalLM} if is_torch_available() else {}
   SCREAMING_SNAKE_CASE__					      =  True
   SCREAMING_SNAKE_CASE__					      =  False





   def 						__lowerCAmelCase				(						self							,  ):
         _lowerCAmelCase			      =	SpeechaTextaStandaloneDecoderModelTester(self							,  is_training=_lowerCAmelCase      )
         _lowerCAmelCase			      =	ConfigTester(self							,  config_class=_lowerCAmelCase      )





   def 						__lowerCAmelCase				(						self      ):
         pass





   def 						__lowerCAmelCase				(						self      ):
         pass





   def 						__lowerCAmelCase				(						self      ):
         pass





   def 						__lowerCAmelCase				(						self      ):
         self.config_tester.run_common_tests()





   def 						__lowerCAmelCase				(						self      ):
         _lowerCAmelCase			      =	self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_decoder_model_past(*_lowerCAmelCase      )





   def 						__lowerCAmelCase				(						self      ):
         return




def 						_lowerCAmelCase    (					__lowerCamelCase :  int  ):



 """simple docstring"""





 if not isinstance(__lowerCamelCase		,						__lowerCamelCase  ):
  __SCREAMING_SNAKE_CASE							:     Union[str, Any]							=						(
      "operation can not be conducted on a object of type "
      F"""{type(__lowerCamelCase  ).__name__}"""
  )
  raise TypeError(__lowerCamelCase  )
 __SCREAMING_SNAKE_CASE							:     List[str]							=						""
 for _ in range(0		,						32  ):
  bit_string += str(number % 2  )
  __SCREAMING_SNAKE_CASE							:     Union[str, Any]							=						number >> 1
 return bit_string






def 						_lowerCAmelCase    (					__lowerCamelCase :  int  ):



 """simple docstring"""





 if number < 0:
  raise ValueError("the value of input must be positive"  )
 elif isinstance(__lowerCamelCase		,						__lowerCamelCase  ):
  raise TypeError("Input value must be a 'int' type"  )
 elif isinstance(__lowerCamelCase		,						__lowerCamelCase  ):
  raise TypeError("'<' not supported between instances of 'str' and 'int'"  )
 __SCREAMING_SNAKE_CASE							:     Any							=						0
 # iterator over [1 to 32],since we are dealing with 32 bit integer
 for _ in range(1		,						33  ):
  # left shift the bits by unity
  __SCREAMING_SNAKE_CASE							:     Optional[int]							=						result << 1
  # get the end bit
  __SCREAMING_SNAKE_CASE							:     Union[str, Any]							=						number % 2
  # right shift the bits by unity
  __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						number >> 1
  # add that bit to our ans
  __SCREAMING_SNAKE_CASE							:     Optional[int]							=						result | end_bit
 return get_reverse_bit_string(__lowerCamelCase  )


if __name__ == "__main__":
      import doctest

      doctest.testmod()






