




import unittest

from transformers import load_tool

from .test_tools_common import ToolTesterMixin


UpperCamelCase								=     """
Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf originally as a company that developed a chatbot app targeted at teenagers.[2] After open-sourcing the model behind the chatbot, the company pivoted to focus on being a platform for machine learning.

In March 2021, Hugging Face raised $40 million in a Series B funding round.[3]

On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model.[4] In 2022, the workshop concluded with the announcement of BLOOM, a multilingual large language model with 176 billion parameters.[5]
"""





class  __lowerCamelCase       (    unittest.TestCase	,				SCREAMING_SNAKE_CASE__    ):




    """simple docstring"""

    def    a      (       self     :     List[Any]   )      ->       Optional[int]:
         lowerCAmelCase__		= load_tool("summarization"   )
         self.tool.setup()
         lowerCAmelCase__		= load_tool("summarization"   ,	remote=snake_case__   )


    def    a      (       self     :     str   )      ->       Optional[int]:
         lowerCAmelCase__		= self.tool(snake_case__   )
         self.assertEqual(
             snake_case__   ,	"Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model. In 2022, the workshop concluded with the announcement of BLOOM."   ,	)


    def    a      (       self     :     Optional[Any]   )      ->       Tuple:
         lowerCAmelCase__		= self.remote_tool(snake_case__   )
         self.assertEqual(
             snake_case__   ,	"Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model. In 2022, the workshop concluded with the announcement of BLOOM."   ,	)


    def    a      (       self     :     Dict   )      ->       List[Any]:
         lowerCAmelCase__		= self.tool(text=snake_case__   )
         self.assertEqual(
             snake_case__   ,	"Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model. In 2022, the workshop concluded with the announcement of BLOOM."   ,	)


    def    a      (       self     :     List[Any]   )      ->       int:
         lowerCAmelCase__		= self.remote_tool(text=snake_case__   )
         self.assertEqual(
             snake_case__   ,	"Hugging Face was founded in 2016 by French entrepreneurs Clément Delangue, Julien Chaumond, and Thomas Wolf. In March 2021, Hugging Face raised $40 million in a Series B funding round. On April 28, 2021, the company launched the BigScience Research Workshop in collaboration with several other research groups to release an open large language model. In 2022, the workshop concluded with the announcement of BLOOM."   ,	)








"""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






