





import uuid
from typing import Any, Dict, List, Optional, Union

from ..utils import add_end_docstrings, is_tf_available, is_torch_available, logging
from .base import PIPELINE_INIT_ARGS, Pipeline


if is_tf_available():
			import tensorflow as tf

if is_torch_available():
			import torch


_UpperCAmelCase			:		Any   				=    logging.get_logger(__name__)
class  lowerCAmelCase_       :




							def __init__(   self     :   Optional[int] ,							SCREAMING_SNAKE_CASE_     :   str = None ,							SCREAMING_SNAKE_CASE_     :   uuid.UUID = None ,							SCREAMING_SNAKE_CASE_     :   str=None ,							SCREAMING_SNAKE_CASE_     :   str=None	):






											if not conversation_id:
															lowerCAmelCase__      			=						uuid.uuida()
											if past_user_inputs is None:
															lowerCAmelCase__      			=						[]
											if generated_responses is None:
															lowerCAmelCase__      			=						[]

											lowerCAmelCase__      			=						conversation_id
											lowerCAmelCase__      			=						past_user_inputs
											lowerCAmelCase__      			=						generated_responses
											lowerCAmelCase__      			=						text




							def __eq__(   self     :   Tuple ,							SCREAMING_SNAKE_CASE_     :   Union[str, Any]	):






											if not isinstance(lowerCamelCase__ ,							lowerCamelCase__	):
															return False
											if self.uuid == other.uuid:
															return True
											return (
											    self.new_user_input == other.new_user_input
											    and self.past_user_inputs == other.past_user_inputs
											    and self.generated_responses == other.generated_responses
											)




							def 						__snake_case					(   self     :   Union[str, Any] ,							SCREAMING_SNAKE_CASE_     :   str ,							SCREAMING_SNAKE_CASE_     :   bool = False	):






											if self.new_user_input:
															if overwrite:
																			logger.warning(
																			    f'User input added while unprocessed input was existing: \"{self.new_user_input}\" was overwritten '
																			    f'with: \"{text}\".'	)
																			lowerCAmelCase__      			=						text
															else:
																			logger.warning(
																			    f'User input added while unprocessed input was existing: \"{self.new_user_input}\" new input '
																			    f'ignored: \"{text}\". Set `overwrite` to True to overwrite unprocessed user input'	)
											else:
															lowerCAmelCase__      			=						text




							def 						__snake_case					(   self     :   str	):






											if self.new_user_input:
															self.past_user_inputs.append(self.new_user_input	)
											lowerCAmelCase__      			=						None




							def 						__snake_case					(   self     :   List[Any] ,							SCREAMING_SNAKE_CASE_     :   str	):
											self.generated_responses.append(lowerCamelCase__	)




							def 						__snake_case					(   self     :   Tuple	):






											for user_input, generated_response in zip(self.past_user_inputs ,							self.generated_responses	):
															yield True, user_input
															yield False, generated_response
											if self.new_user_input:
															yield True, self.new_user_input




							def __repr__(   self     :   str	):
											lowerCAmelCase__      			=						f'Conversation id: {self.uuid} \n'
											for is_user, text in self.iter_texts():
															lowerCAmelCase__      			=						'''user''' if is_user else '''bot'''
															output += f'{name} >> {text} \n'
											return output



@add_end_docstrings(
    __lowerCAmelCase     ,    R'\n        min_length_for_response (`int`, *optional*, defaults to 32):\n            The minimum length (in number of tokens) for a response.\n        minimum_tokens (`int`, *optional*, defaults to 10):\n            The minimum length of tokens to leave for a response.\n    '     ,    )
class  lowerCAmelCase_       (				__lowerCAmelCase					):




							def __init__(   self     :   Dict ,							*SCREAMING_SNAKE_CASE_     :   Any ,							**SCREAMING_SNAKE_CASE_     :   int	):
											super().__init__(*lowerCamelCase__ ,							**lowerCamelCase__	)
											if self.tokenizer.pad_token_id is None:
															lowerCAmelCase__      			=						self.tokenizer.eos_token




							def 						__snake_case					(   self     :   Tuple ,							SCREAMING_SNAKE_CASE_     :   int=None ,							SCREAMING_SNAKE_CASE_     :   Optional[int]=None ,							SCREAMING_SNAKE_CASE_     :   Optional[int]=None ,							**SCREAMING_SNAKE_CASE_     :   str	):
											lowerCAmelCase__      			=						{}
											lowerCAmelCase__      			=						{}
											lowerCAmelCase__      			=						{}

											if min_length_for_response is not None:
															lowerCAmelCase__      			=						min_length_for_response
											if minimum_tokens is not None:
															lowerCAmelCase__      			=						minimum_tokens

											if "max_length" in generate_kwargs:
															lowerCAmelCase__      			=						generate_kwargs['''max_length''']
															# self.max_length = generate_kwargs.get("max_length", self.model.config.max_length)
											if clean_up_tokenization_spaces is not None:
															lowerCAmelCase__      			=						clean_up_tokenization_spaces

											if generate_kwargs:
															forward_params.update(lowerCamelCase__	)
											return preprocess_params, forward_params, postprocess_params




							def __call__(   self     :   Any ,							SCREAMING_SNAKE_CASE_     :   Union[Conversation, List[Conversation]] ,							SCREAMING_SNAKE_CASE_     :   List[str]=0 ,							**SCREAMING_SNAKE_CASE_     :   Optional[int]	):
											lowerCAmelCase__      			=						super().__call__(lowerCamelCase__ ,							num_workers=lowerCamelCase__ ,							**lowerCamelCase__	)
											if isinstance(lowerCamelCase__ ,							lowerCamelCase__	) and len(lowerCamelCase__	) == 1:
															return outputs[0]
											return outputs




							def 						__snake_case					(   self     :   Optional[Any] ,							SCREAMING_SNAKE_CASE_     :   Conversation ,							SCREAMING_SNAKE_CASE_     :   Any=32	):






											if not isinstance(lowerCamelCase__ ,							lowerCamelCase__	):
															raise ValueError('''ConversationalPipeline, expects Conversation as inputs'''	)
											if conversation.new_user_input is None:
															raise ValueError(
															    f'Conversation with UUID {type(conversation.uuid	)} does not contain new user input to process. '
															    '''Add user inputs with the conversation\'s `add_user_input` method'''	)
											if hasattr(self.tokenizer ,							'''_build_conversation_input_ids'''	):
															lowerCAmelCase__      			=						self.tokenizer._build_conversation_input_ids(lowerCamelCase__	)
											else:
															# If the tokenizer cannot handle conversations, we default to only the old version
															lowerCAmelCase__      			=						self._legacy_parse_and_tokenize(lowerCamelCase__	)

											if self.framework == "pt":
															lowerCAmelCase__      			=						torch.LongTensor([input_ids]	)
											elif self.framework == "tf":
															lowerCAmelCase__      			=						tf.constant([input_ids]	)
											return {"input_ids": input_ids, "conversation": conversation}




							def 						__snake_case					(   self     :   Any ,							SCREAMING_SNAKE_CASE_     :   Dict ,							SCREAMING_SNAKE_CASE_     :   Optional[Any]=10 ,							**SCREAMING_SNAKE_CASE_     :   str	):
											lowerCAmelCase__      			=						generate_kwargs.get('''max_length''' ,							self.model.config.max_length	)

											lowerCAmelCase__      			=						model_inputs['''input_ids'''].shape[1]
											if max_length - minimum_tokens < n:
															logger.warning(f'Conversation input is to long ({n}), trimming it to ({max_length} - {minimum_tokens})'	)
															lowerCAmelCase__      			=						max_length - minimum_tokens
															lowerCAmelCase__      			=						model_inputs['''input_ids'''][:, -trim:]
															if "attention_mask" in model_inputs:
																			lowerCAmelCase__      			=						model_inputs['''attention_mask'''][:, -trim:]
											lowerCAmelCase__      			=						model_inputs.pop('''conversation'''	)
											lowerCAmelCase__      			=						max_length
											lowerCAmelCase__      			=						self.model.generate(**lowerCamelCase__ ,							**lowerCamelCase__	)
											if self.model.config.is_encoder_decoder:
															lowerCAmelCase__      			=						1
											else:
															lowerCAmelCase__      			=						n
											return {"output_ids": output_ids[:, start_position:], "conversation": conversation}




							def 						__snake_case					(   self     :   Union[str, Any] ,							SCREAMING_SNAKE_CASE_     :   Tuple ,							SCREAMING_SNAKE_CASE_     :   Optional[int]=True	):
											lowerCAmelCase__      			=						model_outputs['''output_ids''']
											lowerCAmelCase__      			=						self.tokenizer.decode(
											    output_ids[0] ,							skip_special_tokens=lowerCamelCase__ ,							clean_up_tokenization_spaces=lowerCamelCase__ ,							)
											lowerCAmelCase__      			=						model_outputs['''conversation''']
											conversation.mark_processed()
											conversation.append_response(lowerCamelCase__	)
											return conversation




							def 						__snake_case					(   self     :   Tuple ,							SCREAMING_SNAKE_CASE_     :   Conversation	):
											lowerCAmelCase__      			=						self.tokenizer.eos_token_id
											lowerCAmelCase__      			=						[]
											for is_user, text in conversation.iter_texts():
															if eos_token_id is not None:
																			input_ids.extend(self.tokenizer.encode(lowerCamelCase__ ,							add_special_tokens=lowerCamelCase__	) + [eos_token_id]	)
															else:
																			input_ids.extend(self.tokenizer.encode(lowerCamelCase__ ,							add_special_tokens=lowerCamelCase__	)	)

											if len(lowerCamelCase__	) > self.tokenizer.model_max_length:
															lowerCAmelCase__      			=						input_ids[-self.tokenizer.model_max_length :]
											return input_ids













import unittest

from transformers import BertGenerationConfig, is_torch_available
from transformers.testing_utils import require_torch, slow, torch_device

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


if is_torch_available():
			import torch

			from transformers import BertGenerationDecoder, BertGenerationEncoder
class  lowerCAmelCase_       :




							def __init__(   self     :   List[Any] ,							SCREAMING_SNAKE_CASE_     :   str ,							SCREAMING_SNAKE_CASE_     :   Union[str, Any]=13 ,							SCREAMING_SNAKE_CASE_     :   Dict=7 ,							SCREAMING_SNAKE_CASE_     :   Dict=True ,							SCREAMING_SNAKE_CASE_     :   Optional[Any]=True ,							SCREAMING_SNAKE_CASE_     :   List[str]=99 ,							SCREAMING_SNAKE_CASE_     :   str=32 ,							SCREAMING_SNAKE_CASE_     :   Union[str, Any]=5 ,							SCREAMING_SNAKE_CASE_     :   str=4 ,							SCREAMING_SNAKE_CASE_     :   Tuple=37 ,							SCREAMING_SNAKE_CASE_     :   List[Any]="gelu" ,							SCREAMING_SNAKE_CASE_     :   Tuple=0.1 ,							SCREAMING_SNAKE_CASE_     :   Union[str, Any]=0.1 ,							SCREAMING_SNAKE_CASE_     :   Optional[Any]=50 ,							SCREAMING_SNAKE_CASE_     :   List[str]=0.02 ,							SCREAMING_SNAKE_CASE_     :   List[str]=True ,							SCREAMING_SNAKE_CASE_     :   Optional[Any]=None ,							):
											lowerCAmelCase__      			=						parent
											lowerCAmelCase__      			=						batch_size
											lowerCAmelCase__      			=						seq_length
											lowerCAmelCase__      			=						is_training
											lowerCAmelCase__      			=						use_input_mask
											lowerCAmelCase__      			=						vocab_size
											lowerCAmelCase__      			=						hidden_size
											lowerCAmelCase__      			=						num_hidden_layers
											lowerCAmelCase__      			=						num_attention_heads
											lowerCAmelCase__      			=						intermediate_size
											lowerCAmelCase__      			=						hidden_act
											lowerCAmelCase__      			=						hidden_dropout_prob
											lowerCAmelCase__      			=						attention_probs_dropout_prob
											lowerCAmelCase__      			=						max_position_embeddings
											lowerCAmelCase__      			=						initializer_range
											lowerCAmelCase__      			=						use_labels
											lowerCAmelCase__      			=						scope




							def 						__snake_case					(   self     :   Union[str, Any]	):
											lowerCAmelCase__      			=						ids_tensor([self.batch_size, self.seq_length] ,							self.vocab_size	)

											lowerCAmelCase__      			=						None
											if self.use_input_mask:
															lowerCAmelCase__      			=						random_attention_mask([self.batch_size, self.seq_length]	)

											if self.use_labels:
															lowerCAmelCase__      			=						ids_tensor([self.batch_size, self.seq_length] ,							self.vocab_size	)

											lowerCAmelCase__      			=						self.get_config()

											return config, input_ids, input_mask, token_labels




							def 						__snake_case					(   self     :   List[str]	):
											return BertGenerationConfig(
											    vocab_size=self.vocab_size ,							hidden_size=self.hidden_size ,							num_hidden_layers=self.num_hidden_layers ,							num_attention_heads=self.num_attention_heads ,							intermediate_size=self.intermediate_size ,							hidden_act=self.hidden_act ,							hidden_dropout_prob=self.hidden_dropout_prob ,							attention_probs_dropout_prob=self.attention_probs_dropout_prob ,							max_position_embeddings=self.max_position_embeddings ,							is_decoder=SCREAMING_SNAKE_CASE_ ,							initializer_range=self.initializer_range ,							)




							def 						__snake_case					(   self     :   str	):
											(
											    (
											    lowerCAmelCase__
											)			,		(
											    lowerCAmelCase__
											)			,		(
											    lowerCAmelCase__
											)			,		(
											    lowerCAmelCase__
											)			,		
											)      			=						self.prepare_config_and_inputs()

											lowerCAmelCase__      			=						True
											lowerCAmelCase__      			=						floats_tensor([self.batch_size, self.seq_length, self.hidden_size]	)
											lowerCAmelCase__      			=						ids_tensor([self.batch_size, self.seq_length] ,							vocab_size=2	)

											return (
											    config,
											    input_ids,
											    input_mask,
											    token_labels,
											    encoder_hidden_states,
											    encoder_attention_mask,
											)




							def 						__snake_case					(   self     :   Union[str, Any] ,							SCREAMING_SNAKE_CASE_     :   List[str] ,							SCREAMING_SNAKE_CASE_     :   str ,							SCREAMING_SNAKE_CASE_     :   List[Any] ,							SCREAMING_SNAKE_CASE_     :   List[Any] ,							**SCREAMING_SNAKE_CASE_     :   Union[str, Any] ,							):
											lowerCAmelCase__      			=						BertGenerationEncoder(config=SCREAMING_SNAKE_CASE_	)
											model.to(SCREAMING_SNAKE_CASE_	)
											model.eval()
											lowerCAmelCase__      			=						model(SCREAMING_SNAKE_CASE_ ,							attention_mask=SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						model(SCREAMING_SNAKE_CASE_	)
											self.parent.assertEqual(result.last_hidden_state.shape ,							(self.batch_size, self.seq_length, self.hidden_size)	)




							def 						__snake_case					(   self     :   Dict ,							SCREAMING_SNAKE_CASE_     :   Any ,							SCREAMING_SNAKE_CASE_     :   Any ,							SCREAMING_SNAKE_CASE_     :   Optional[int] ,							SCREAMING_SNAKE_CASE_     :   Union[str, Any] ,							SCREAMING_SNAKE_CASE_     :   Tuple ,							SCREAMING_SNAKE_CASE_     :   Optional[int] ,							**SCREAMING_SNAKE_CASE_     :   str ,							):
											lowerCAmelCase__      			=						True
											lowerCAmelCase__      			=						BertGenerationEncoder(config=SCREAMING_SNAKE_CASE_	)
											model.to(SCREAMING_SNAKE_CASE_	)
											model.eval()
											lowerCAmelCase__      			=						model(
											    SCREAMING_SNAKE_CASE_ ,							attention_mask=SCREAMING_SNAKE_CASE_ ,							encoder_hidden_states=SCREAMING_SNAKE_CASE_ ,							encoder_attention_mask=SCREAMING_SNAKE_CASE_ ,							)
											lowerCAmelCase__      			=						model(
											    SCREAMING_SNAKE_CASE_ ,							attention_mask=SCREAMING_SNAKE_CASE_ ,							encoder_hidden_states=SCREAMING_SNAKE_CASE_ ,							)
											self.parent.assertEqual(result.last_hidden_state.shape ,							(self.batch_size, self.seq_length, self.hidden_size)	)




							def 						__snake_case					(   self     :   List[Any] ,							SCREAMING_SNAKE_CASE_     :   Union[str, Any] ,							SCREAMING_SNAKE_CASE_     :   Dict ,							SCREAMING_SNAKE_CASE_     :   List[Any] ,							SCREAMING_SNAKE_CASE_     :   List[Any] ,							SCREAMING_SNAKE_CASE_     :   Tuple ,							SCREAMING_SNAKE_CASE_     :   Optional[int] ,							**SCREAMING_SNAKE_CASE_     :   Optional[Any] ,							):
											lowerCAmelCase__      			=						True
											lowerCAmelCase__      			=						True
											lowerCAmelCase__      			=						BertGenerationDecoder(config=SCREAMING_SNAKE_CASE_	).to(SCREAMING_SNAKE_CASE_	).eval()

											# first forward pass
											lowerCAmelCase__      			=						model(
											    SCREAMING_SNAKE_CASE_ ,							attention_mask=SCREAMING_SNAKE_CASE_ ,							encoder_hidden_states=SCREAMING_SNAKE_CASE_ ,							encoder_attention_mask=SCREAMING_SNAKE_CASE_ ,							use_cache=SCREAMING_SNAKE_CASE_ ,							)
											lowerCAmelCase__      			=						outputs.past_key_values

											# create hypothetical multiple next token and extent to next_input_ids
											lowerCAmelCase__      			=						ids_tensor((self.batch_size, 3) ,							config.vocab_size	)
											lowerCAmelCase__      			=						ids_tensor((self.batch_size, 3) ,							vocab_size=2	)

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

											lowerCAmelCase__      			=						model(
											    SCREAMING_SNAKE_CASE_ ,							attention_mask=SCREAMING_SNAKE_CASE_ ,							encoder_hidden_states=SCREAMING_SNAKE_CASE_ ,							encoder_attention_mask=SCREAMING_SNAKE_CASE_ ,							output_hidden_states=SCREAMING_SNAKE_CASE_ ,							)['''hidden_states'''][0]
											lowerCAmelCase__      			=						model(
											    SCREAMING_SNAKE_CASE_ ,							attention_mask=SCREAMING_SNAKE_CASE_ ,							encoder_hidden_states=SCREAMING_SNAKE_CASE_ ,							encoder_attention_mask=SCREAMING_SNAKE_CASE_ ,							past_key_values=SCREAMING_SNAKE_CASE_ ,							output_hidden_states=SCREAMING_SNAKE_CASE_ ,							)['''hidden_states'''][0]

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

											self.parent.assertTrue(output_from_past_slice.shape[1] == next_tokens.shape[1]	)

											# test that outputs are equal for slice
											self.parent.assertTrue(torch.allclose(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_ ,							atol=1e-3	)	)




							def 						__snake_case					(   self     :   List[Any] ,							SCREAMING_SNAKE_CASE_     :   Any ,							SCREAMING_SNAKE_CASE_     :   int ,							SCREAMING_SNAKE_CASE_     :   Optional[Any] ,							SCREAMING_SNAKE_CASE_     :   Optional[Any] ,							*SCREAMING_SNAKE_CASE_     :   Tuple ,							):
											lowerCAmelCase__      			=						BertGenerationDecoder(SCREAMING_SNAKE_CASE_	)
											model.to(SCREAMING_SNAKE_CASE_	)
											model.eval()
											lowerCAmelCase__      			=						model(SCREAMING_SNAKE_CASE_ ,							attention_mask=SCREAMING_SNAKE_CASE_ ,							labels=SCREAMING_SNAKE_CASE_	)
											self.parent.assertEqual(result.logits.shape ,							(self.batch_size, self.seq_length, self.vocab_size)	)




							def 						__snake_case					(   self     :   List[Any]	):
											lowerCAmelCase__			,		lowerCAmelCase__			,		lowerCAmelCase__			,		lowerCAmelCase__      			=						self.prepare_config_and_inputs()
											lowerCAmelCase__      			=						{'''input_ids''': input_ids, '''attention_mask''': input_mask}
											return config, inputs_dict



@require_torch
class  lowerCAmelCase_       (				snake_case__     ,    snake_case__     ,    snake_case__     ,    unittest.TestCase					):
							UpperCamelCase_		:Dict		      =    (BertGenerationEncoder, BertGenerationDecoder) if is_torch_available() else ()
							UpperCamelCase_		:str		      =    (BertGenerationDecoder,) if is_torch_available() else ()
							UpperCamelCase_		:List[str]		      =    (
							    {'feature-extraction': BertGenerationEncoder, 'text-generation': BertGenerationDecoder}
							    if is_torch_available()
							    else {}
							)




							def 						__snake_case					(   self     :   List[str]	):
											lowerCAmelCase__      			=						BertGenerationEncoderTester(self	)
											lowerCAmelCase__      			=						ConfigTester(self ,							config_class=SCREAMING_SNAKE_CASE_ ,							hidden_size=37	)




							def 						__snake_case					(   self     :   Optional[Any]	):
											self.config_tester.run_common_tests()




							def 						__snake_case					(   self     :   List[Any]	):
											lowerCAmelCase__      			=						self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_	)




							def 						__snake_case					(   self     :   str	):
											lowerCAmelCase__			,		lowerCAmelCase__			,		lowerCAmelCase__			,		lowerCAmelCase__      			=						self.model_tester.prepare_config_and_inputs()
											lowerCAmelCase__      			=						'''bert'''
											self.model_tester.create_and_check_model(SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_	)




							def 						__snake_case					(   self     :   int	):
											lowerCAmelCase__      			=						self.model_tester.prepare_config_and_inputs_for_decoder()
											self.model_tester.create_and_check_model_as_decoder(*SCREAMING_SNAKE_CASE_	)




							def 						__snake_case					(   self     :   List[Any]	):
											lowerCAmelCase__      			=						self.model_tester.prepare_config_and_inputs_for_decoder()
											self.model_tester.create_and_check_decoder_model_past_large_inputs(*SCREAMING_SNAKE_CASE_	)




							def 						__snake_case					(   self     :   Any	):
											# This regression test was failing with PyTorch < 1.3
											(
											    (
											    lowerCAmelCase__
											)			,		(
											    lowerCAmelCase__
											)			,		(
											    lowerCAmelCase__
											)			,		(
											    lowerCAmelCase__
											)			,		(
											    lowerCAmelCase__
											)			,		(
											    lowerCAmelCase__
											)			,		
											)      			=						self.model_tester.prepare_config_and_inputs_for_decoder()

											lowerCAmelCase__      			=						None

											self.model_tester.create_and_check_model_as_decoder(
											    SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_ ,							SCREAMING_SNAKE_CASE_ ,							)




							def 						__snake_case					(   self     :   int	):
											lowerCAmelCase__      			=						self.model_tester.prepare_config_and_inputs_for_decoder()
											self.model_tester.create_and_check_for_causal_lm(*SCREAMING_SNAKE_CASE_	)




							@slow
							def 						__snake_case					(   self     :   str	):
											lowerCAmelCase__      			=						BertGenerationEncoder.from_pretrained('''google/bert_for_seq_generation_L-24_bbc_encoder'''	)
											self.assertIsNotNone(SCREAMING_SNAKE_CASE_	)



@require_torch
class  lowerCAmelCase_       (				unittest.TestCase					):




							@slow
							def 						__snake_case					(   self     :   Tuple	):
											lowerCAmelCase__      			=						BertGenerationEncoder.from_pretrained('''google/bert_for_seq_generation_L-24_bbc_encoder'''	)
											lowerCAmelCase__      			=						torch.tensor([[101, 7_592, 1_010, 2_026, 3_899, 2_003, 10_140, 102]]	)
											with torch.no_grad():
															lowerCAmelCase__      			=						model(SCREAMING_SNAKE_CASE_	)[0]
											lowerCAmelCase__      			=						torch.Size([1, 8, 1_024]	)
											self.assertEqual(output.shape ,							SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						torch.tensor(
											    [[[0.1_775, 0.0_083, -0.0_321], [1.6_002, 0.1_287, 0.3_912], [2.1_473, 0.5_791, 0.6_066]]]	)
											self.assertTrue(torch.allclose(output[:, :3, :3] ,							SCREAMING_SNAKE_CASE_ ,							atol=1e-4	)	)



@require_torch
class  lowerCAmelCase_       (				unittest.TestCase					):




							@slow
							def 						__snake_case					(   self     :   Any	):
											lowerCAmelCase__      			=						BertGenerationDecoder.from_pretrained('''google/bert_for_seq_generation_L-24_bbc_encoder'''	)
											lowerCAmelCase__      			=						torch.tensor([[101, 7_592, 1_010, 2_026, 3_899, 2_003, 10_140, 102]]	)
											with torch.no_grad():
															lowerCAmelCase__      			=						model(SCREAMING_SNAKE_CASE_	)[0]
											lowerCAmelCase__      			=						torch.Size([1, 8, 50_358]	)
											self.assertEqual(output.shape ,							SCREAMING_SNAKE_CASE_	)
											lowerCAmelCase__      			=						torch.tensor(
											    [[[-0.5_788, -2.5_994, -3.7_054], [0.0_438, 4.7_997, 1.8_795], [1.5_862, 6.6_409, 4.4_638]]]	)
											self.assertTrue(torch.allclose(output[:, :3, :3] ,							SCREAMING_SNAKE_CASE_ ,							atol=1e-4	)	)





