



"""simple docstring"""





import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import cached_download, hf_hub_download, hf_hub_url
from PIL import Image

from transformers import DetaConfig, DetaForObjectDetection, DetaImageProcessor, SwinConfig
from transformers.utils import logging


logging.set_verbosity_info()
lowercase  							=					logging.get_logger(__name__)




def 	UpperCAmelCase     (		A	:						List[str]       ):

		'''simple docstring'''


		_UpperCAmelCase							 =		SwinConfig(
		    embed_dim=192     ,				depths=(2, 2, 18, 2)     ,				num_heads=(6, 12, 24, 48)     ,				window_size=12     ,				out_features=['stage2', 'stage3', 'stage4']     ,				)

		_UpperCAmelCase							 =		DetaConfig(
		    backbone_config=A     ,				num_queries=900     ,				encoder_ffn_dim=2048     ,				decoder_ffn_dim=2048     ,				num_feature_levels=5     ,				assign_first_stage=A     ,				with_box_refine=A     ,				two_stage=A     ,				)

		# set labels
		_UpperCAmelCase							 =		'huggingface/label-files'
		if "o365" in model_name:
				_UpperCAmelCase							 =		366
				_UpperCAmelCase							 =		'object365-id2label.json'
		else:
				_UpperCAmelCase							 =		91
				_UpperCAmelCase							 =		'coco-detection-id2label.json'

		_UpperCAmelCase							 =		num_labels
		_UpperCAmelCase							 =		json.load(open(cached_download(hf_hub_url(A     ,				A     ,				repo_type='dataset'       )       )     ,				'r'       )       )
		_UpperCAmelCase							 =		{int(A       ): v for k, v in idalabel.items()}
		_UpperCAmelCase							 =		idalabel
		_UpperCAmelCase							 =		{v: k for k, v in idalabel.items()}

		return config




def 	UpperCAmelCase     (		A	:						Optional[Any]       ):

		'''simple docstring'''


		_UpperCAmelCase							 =		[]

		# stem
		# fmt: off
		rename_keys.append(('backbone.0.body.patch_embed.proj.weight', 'model.backbone.model.embeddings.patch_embeddings.projection.weight')       )
		rename_keys.append(('backbone.0.body.patch_embed.proj.bias', 'model.backbone.model.embeddings.patch_embeddings.projection.bias')       )
		rename_keys.append(('backbone.0.body.patch_embed.norm.weight', 'model.backbone.model.embeddings.norm.weight')       )
		rename_keys.append(('backbone.0.body.patch_embed.norm.bias', 'model.backbone.model.embeddings.norm.bias')       )
		# stages
		for i in range(len(config.backbone_config.depths       )       ):
				for j in range(config.backbone_config.depths[i]       ):
						rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.norm1.weight', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.weight')       )
						rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.norm1.bias', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_before.bias')       )
						rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_bias_table', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_bias_table')       )
						rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.attn.relative_position_index', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.self.relative_position_index')       )
						rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.attn.proj.weight', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.weight')       )
						rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.attn.proj.bias', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.attention.output.dense.bias')       )
						rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.norm2.weight', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.weight')       )
						rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.norm2.bias', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.layernorm_after.bias')       )
						rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.weight', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.weight')       )
						rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.mlp.fc1.bias', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.intermediate.dense.bias')       )
						rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.weight', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.weight')       )
						rename_keys.append((f'backbone.0.body.layers.{i}.blocks.{j}.mlp.fc2.bias', f'model.backbone.model.encoder.layers.{i}.blocks.{j}.output.dense.bias')       )

				if i < 3:
						rename_keys.append((f'backbone.0.body.layers.{i}.downsample.reduction.weight', f'model.backbone.model.encoder.layers.{i}.downsample.reduction.weight')       )
						rename_keys.append((f'backbone.0.body.layers.{i}.downsample.norm.weight', f'model.backbone.model.encoder.layers.{i}.downsample.norm.weight')       )
						rename_keys.append((f'backbone.0.body.layers.{i}.downsample.norm.bias', f'model.backbone.model.encoder.layers.{i}.downsample.norm.bias')       )

		rename_keys.append(('backbone.0.body.norm1.weight', 'model.backbone.model.hidden_states_norms.stage2.weight')       )
		rename_keys.append(('backbone.0.body.norm1.bias', 'model.backbone.model.hidden_states_norms.stage2.bias')       )
		rename_keys.append(('backbone.0.body.norm2.weight', 'model.backbone.model.hidden_states_norms.stage3.weight')       )
		rename_keys.append(('backbone.0.body.norm2.bias', 'model.backbone.model.hidden_states_norms.stage3.bias')       )
		rename_keys.append(('backbone.0.body.norm3.weight', 'model.backbone.model.hidden_states_norms.stage4.weight')       )
		rename_keys.append(('backbone.0.body.norm3.bias', 'model.backbone.model.hidden_states_norms.stage4.bias')       )

		# transformer encoder
		for i in range(config.encoder_layers       ):
				rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.sampling_offsets.weight', f'model.encoder.layers.{i}.self_attn.sampling_offsets.weight')       )
				rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.sampling_offsets.bias', f'model.encoder.layers.{i}.self_attn.sampling_offsets.bias')       )
				rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.attention_weights.weight', f'model.encoder.layers.{i}.self_attn.attention_weights.weight')       )
				rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.attention_weights.bias', f'model.encoder.layers.{i}.self_attn.attention_weights.bias')       )
				rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.value_proj.weight', f'model.encoder.layers.{i}.self_attn.value_proj.weight')       )
				rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.value_proj.bias', f'model.encoder.layers.{i}.self_attn.value_proj.bias')       )
				rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.output_proj.weight', f'model.encoder.layers.{i}.self_attn.output_proj.weight')       )
				rename_keys.append((f'transformer.encoder.layers.{i}.self_attn.output_proj.bias', f'model.encoder.layers.{i}.self_attn.output_proj.bias')       )
				rename_keys.append((f'transformer.encoder.layers.{i}.norm1.weight', f'model.encoder.layers.{i}.self_attn_layer_norm.weight')       )
				rename_keys.append((f'transformer.encoder.layers.{i}.norm1.bias', f'model.encoder.layers.{i}.self_attn_layer_norm.bias')       )
				rename_keys.append((f'transformer.encoder.layers.{i}.linear1.weight', f'model.encoder.layers.{i}.fc1.weight')       )
				rename_keys.append((f'transformer.encoder.layers.{i}.linear1.bias', f'model.encoder.layers.{i}.fc1.bias')       )
				rename_keys.append((f'transformer.encoder.layers.{i}.linear2.weight', f'model.encoder.layers.{i}.fc2.weight')       )
				rename_keys.append((f'transformer.encoder.layers.{i}.linear2.bias', f'model.encoder.layers.{i}.fc2.bias')       )
				rename_keys.append((f'transformer.encoder.layers.{i}.norm2.weight', f'model.encoder.layers.{i}.final_layer_norm.weight')       )
				rename_keys.append((f'transformer.encoder.layers.{i}.norm2.bias', f'model.encoder.layers.{i}.final_layer_norm.bias')       )

		# transformer decoder
		for i in range(config.decoder_layers       ):
				rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.sampling_offsets.weight', f'model.decoder.layers.{i}.encoder_attn.sampling_offsets.weight')       )
				rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.sampling_offsets.bias', f'model.decoder.layers.{i}.encoder_attn.sampling_offsets.bias')       )
				rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.attention_weights.weight', f'model.decoder.layers.{i}.encoder_attn.attention_weights.weight')       )
				rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.attention_weights.bias', f'model.decoder.layers.{i}.encoder_attn.attention_weights.bias')       )
				rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.value_proj.weight', f'model.decoder.layers.{i}.encoder_attn.value_proj.weight')       )
				rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.value_proj.bias', f'model.decoder.layers.{i}.encoder_attn.value_proj.bias')       )
				rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.output_proj.weight', f'model.decoder.layers.{i}.encoder_attn.output_proj.weight')       )
				rename_keys.append((f'transformer.decoder.layers.{i}.cross_attn.output_proj.bias', f'model.decoder.layers.{i}.encoder_attn.output_proj.bias')       )
				rename_keys.append((f'transformer.decoder.layers.{i}.norm1.weight', f'model.decoder.layers.{i}.encoder_attn_layer_norm.weight')       )
				rename_keys.append((f'transformer.decoder.layers.{i}.norm1.bias', f'model.decoder.layers.{i}.encoder_attn_layer_norm.bias')       )
				rename_keys.append((f'transformer.decoder.layers.{i}.self_attn.out_proj.weight', f'model.decoder.layers.{i}.self_attn.out_proj.weight')       )
				rename_keys.append((f'transformer.decoder.layers.{i}.self_attn.out_proj.bias', f'model.decoder.layers.{i}.self_attn.out_proj.bias')       )
				rename_keys.append((f'transformer.decoder.layers.{i}.norm2.weight', f'model.decoder.layers.{i}.self_attn_layer_norm.weight')       )
				rename_keys.append((f'transformer.decoder.layers.{i}.norm2.bias', f'model.decoder.layers.{i}.self_attn_layer_norm.bias')       )
				rename_keys.append((f'transformer.decoder.layers.{i}.linear1.weight', f'model.decoder.layers.{i}.fc1.weight')       )
				rename_keys.append((f'transformer.decoder.layers.{i}.linear1.bias', f'model.decoder.layers.{i}.fc1.bias')       )
				rename_keys.append((f'transformer.decoder.layers.{i}.linear2.weight', f'model.decoder.layers.{i}.fc2.weight')       )
				rename_keys.append((f'transformer.decoder.layers.{i}.linear2.bias', f'model.decoder.layers.{i}.fc2.bias')       )
				rename_keys.append((f'transformer.decoder.layers.{i}.norm3.weight', f'model.decoder.layers.{i}.final_layer_norm.weight')       )
				rename_keys.append((f'transformer.decoder.layers.{i}.norm3.bias', f'model.decoder.layers.{i}.final_layer_norm.bias')       )

		# fmt: on

		return rename_keys




def 	UpperCAmelCase     (		A	:						Any     ,				A	:						List[Any]     ,				A	:						List[Any]       ):

		'''simple docstring'''


		_UpperCAmelCase							 =		dct.pop(A       )
		_UpperCAmelCase							 =		val




def 	UpperCAmelCase     (		A	:						Any     ,				A	:						List[str]       ):

		'''simple docstring'''


		_UpperCAmelCase							 =		[int(backbone_config.embed_dim * 2**i       ) for i in range(len(backbone_config.depths       )       )]
		for i in range(len(backbone_config.depths       )       ):
				_UpperCAmelCase							 =		num_features[i]
				for j in range(backbone_config.depths[i]       ):
						# fmt: off
						# read in weights + bias of input projection layer (in original implementation, this is a single matrix + bias)
						_UpperCAmelCase							 =		state_dict.pop(f'backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.weight'       )
						_UpperCAmelCase							 =		state_dict.pop(f'backbone.0.body.layers.{i}.blocks.{j}.attn.qkv.bias'       )
						# next, add query, keys and values (in that order) to the state dict
						_UpperCAmelCase							 =		in_proj_weight[:dim, :]
						_UpperCAmelCase							 =		in_proj_bias[: dim]
						_UpperCAmelCase							 =		in_proj_weight[
						    dim : dim * 2, :
						]
						_UpperCAmelCase							 =		in_proj_bias[
						    dim : dim * 2
						]
						_UpperCAmelCase							 =		in_proj_weight[
						    -dim :, :
						]
						_UpperCAmelCase							 =		in_proj_bias[-dim :]
						# fmt: on




def 	UpperCAmelCase     (		A	:						Optional[int]     ,				A	:						int       ):

		'''simple docstring'''


		_UpperCAmelCase							 =		config.d_model
		for i in range(config.decoder_layers       ):
				# read in weights + bias of input projection layer of self-attention
				_UpperCAmelCase							 =		state_dict.pop(f'transformer.decoder.layers.{i}.self_attn.in_proj_weight'       )
				_UpperCAmelCase							 =		state_dict.pop(f'transformer.decoder.layers.{i}.self_attn.in_proj_bias'       )
				# next, add query, keys and values (in that order) to the state dict
				_UpperCAmelCase							 =		in_proj_weight[:hidden_size, :]
				_UpperCAmelCase							 =		in_proj_bias[:hidden_size]
				_UpperCAmelCase							 =		in_proj_weight[
				    hidden_size : hidden_size * 2, :
				]
				_UpperCAmelCase							 =		in_proj_bias[hidden_size : hidden_size * 2]
				_UpperCAmelCase							 =		in_proj_weight[-hidden_size:, :]
				_UpperCAmelCase							 =		in_proj_bias[-hidden_size:]




def 	UpperCAmelCase     (		):

		'''simple docstring'''


		_UpperCAmelCase							 =		'http://images.cocodataset.org/val2017/000000039769.jpg'
		_UpperCAmelCase							 =		Image.open(requests.get(A     ,				stream=A       ).raw       )

		return im




@torch.no_grad()
def 	UpperCAmelCase     (		A	:						Dict     ,				A	:						List[str]     ,				A	:						List[str]       ):

		'''simple docstring'''


		_UpperCAmelCase							 =		get_deta_config(A       )

		# load original state dict
		if model_name == "deta-swin-large":
				_UpperCAmelCase							 =		hf_hub_download(repo_id='nielsr/deta-checkpoints'     ,				filename='adet_swin_ft.pth'       )
		elif model_name == "deta-swin-large-o365":
				_UpperCAmelCase							 =		hf_hub_download(repo_id='jozhang97/deta-swin-l-o365'     ,				filename='deta_swin_pt_o365.pth'       )
		else:
				raise ValueError(f'Model name {model_name} not supported'       )

		_UpperCAmelCase							 =		torch.load(A     ,				map_location='cpu'       )['model']

		# original state dict
		for name, param in state_dict.items():
				print(A     ,				param.shape       )

		# rename keys
		_UpperCAmelCase							 =		create_rename_keys(A       )
		for src, dest in rename_keys:
				rename_key(A     ,				A     ,				A       )
		read_in_swin_q_k_v(A     ,				config.backbone_config       )
		read_in_decoder_q_k_v(A     ,				A       )

		# fix some prefixes
		for key in state_dict.copy().keys():
				if "transformer.decoder.class_embed" in key or "transformer.decoder.bbox_embed" in key:
						_UpperCAmelCase							 =		state_dict.pop(A       )
						_UpperCAmelCase							 =		val
				if "input_proj" in key:
						_UpperCAmelCase							 =		state_dict.pop(A       )
						_UpperCAmelCase							 =		val
				if "level_embed" in key or "pos_trans" in key or "pix_trans" in key or "enc_output" in key:
						_UpperCAmelCase							 =		state_dict.pop(A       )
						_UpperCAmelCase							 =		val

    # finally, create HuggingFace model and load state dict
		_UpperCAmelCase							 =		DetaForObjectDetection(A       )
		model.load_state_dict(A       )
		model.eval()

		_UpperCAmelCase							 =		'cuda' if torch.cuda.is_available() else 'cpu'
		model.to(A       )

		# load image processor
		_UpperCAmelCase							 =		DetaImageProcessor(format='coco_detection'       )

		# verify our conversion on image
		_UpperCAmelCase							 =		prepare_img()
		_UpperCAmelCase							 =		processor(images=A     ,				return_tensors='pt'       )
		_UpperCAmelCase							 =		encoding['pixel_values']
		_UpperCAmelCase							 =		model(pixel_values.to(A       )       )

		# verify logits
		print('Logits:'     ,				outputs.logits[0, :3, :3]       )
		print('Boxes:'     ,				outputs.pred_boxes[0, :3, :3]       )
		if model_name == "deta-swin-large":
				_UpperCAmelCase							 =		torch.tensor(
				    [[-7.6308, -2.8485, -5.3737], [-7.2037, -4.5505, -4.8027], [-7.2943, -4.2611, -4.6617]]       )
				_UpperCAmelCase							 =		torch.tensor([[0.4987, 0.4969, 0.9999], [0.2549, 0.5498, 0.4805], [0.5498, 0.2757, 0.0569]]       )
		elif model_name == "deta-swin-large-o365":
				_UpperCAmelCase							 =		torch.tensor(
				    [[-8.0122, -3.5720, -4.9717], [-8.1547, -3.6886, -4.6389], [-7.6610, -3.6194, -5.0134]]       )
				_UpperCAmelCase							 =		torch.tensor([[0.2523, 0.5549, 0.4881], [0.7715, 0.4149, 0.4601], [0.5503, 0.2753, 0.0575]]       )
		assert torch.allclose(outputs.logits[0, :3, :3]     ,				expected_logits.to(A       )     ,				atol=1e-4       )
		assert torch.allclose(outputs.pred_boxes[0, :3, :3]     ,				expected_boxes.to(A       )     ,				atol=1e-4       )
		print('Everything ok!'       )

		if pytorch_dump_folder_path:
				# Save model and processor
				logger.info(f'Saving PyTorch model and processor to {pytorch_dump_folder_path}...'       )
				Path(A       ).mkdir(exist_ok=A       )
				model.save_pretrained(A       )
				processor.save_pretrained(A       )

		# Push to hub
		if push_to_hub:
				print('Pushing model and processor to hub...'       )
				model.push_to_hub(f'jozhang97/{model_name}'       )
				processor.push_to_hub(f'jozhang97/{model_name}'       )


if __name__ == "__main__":
					lowercase  							=					argparse.ArgumentParser()

					parser.add_argument(
					    '''--model_name''',
					    type=str,
					    default='''deta-swin-large''',
					    choices=['''deta-swin-large''', '''deta-swin-large-o365'''],
					    help='''Name of the model you\'d like to convert.''',
					)
					parser.add_argument(
					    '''--pytorch_dump_folder_path''',
					    default=None,
					    type=str,
					    help='''Path to the folder to output PyTorch model.''',
					)
					parser.add_argument(
					    '''--push_to_hub''', action='''store_true''', help='''Whether or not to push the converted model to the 🤗 hub.'''
					)
					lowercase  							=					parser.parse_args()
					convert_deta_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.push_to_hub)







"""simple docstring"""





import unittest

from transformers import (
    MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
    TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING,
    TextaTextGenerationPipeline,
    pipeline,
)
from transformers.testing_utils import is_pipeline_test, require_tf, require_torch
from transformers.utils import is_torch_available

from .test_pipelines_common import ANY


if is_torch_available():
					import torch




@is_pipeline_test
class 			lowercase__			(      unittest.TestCase    ):
							'''simple docstring'''







							_UpperCAmelCase      				=					MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING
							_UpperCAmelCase      				=					TF_MODEL_FOR_SEQ_TO_SEQ_CAUSAL_LM_MAPPING






							def        lowerCamelCase_   (  self	,       snake_case	,       snake_case	,       snake_case						)			->							Dict:
									_UpperCAmelCase							 =		TextaTextGenerationPipeline(model=snake_case	,       tokenizer=snake_case						)
									return generator, ["Something to write", "Something else"]






							def        lowerCamelCase_   (  self	,       snake_case	,       snake_case						)			->							Dict:
									_UpperCAmelCase							 =		generator('Something there'						)
									self.assertEqual(snake_case	,       [{'generated_text': ANY(snake_case						)}]						)
									# These are encoder decoder, they don't just append to incoming string
									self.assertFalse(outputs[0]['generated_text'].startswith('Something there'						)						)

									_UpperCAmelCase							 =		generator(['This is great !', 'Something else']	,       num_return_sequences=2	,       do_sample=snake_case						)
									self.assertEqual(
									    snake_case	,       [
									        [{'generated_text': ANY(snake_case						)}, {'generated_text': ANY(snake_case						)}],
									        [{'generated_text': ANY(snake_case						)}, {'generated_text': ANY(snake_case						)}],
									    ]	,       )

									_UpperCAmelCase							 =		generator(
									    ['This is great !', 'Something else']	,       num_return_sequences=2	,       batch_size=2	,       do_sample=snake_case						)
									self.assertEqual(
									    snake_case	,       [
									        [{'generated_text': ANY(snake_case						)}, {'generated_text': ANY(snake_case						)}],
									        [{'generated_text': ANY(snake_case						)}, {'generated_text': ANY(snake_case						)}],
									    ]	,       )

									with self.assertRaises(snake_case						):
											generator(4						)






							@require_torch
							def        lowerCamelCase_   (  self						)			->							Dict:
									_UpperCAmelCase							 =		pipeline('text2text-generation'	,       model='patrickvonplaten/t5-tiny-random'	,       framework='pt'						)
									# do_sample=False necessary for reproducibility
									_UpperCAmelCase							 =		generator('Something there'	,       do_sample=snake_case						)
									self.assertEqual(snake_case	,       [{'generated_text': ''}]						)

									_UpperCAmelCase							 =		3
									_UpperCAmelCase							 =		generator(
									    'Something there'	,       num_return_sequences=snake_case	,       num_beams=snake_case	,       )
									_UpperCAmelCase							 =		[
									    {'generated_text': 'Beide Beide Beide Beide Beide Beide Beide Beide Beide'},
									    {'generated_text': 'Beide Beide Beide Beide Beide Beide Beide Beide'},
									    {'generated_text': ''},
									]
									self.assertEqual(snake_case	,       snake_case						)

									_UpperCAmelCase							 =		generator('This is a test'	,       do_sample=snake_case	,       num_return_sequences=2	,       return_tensors=snake_case						)
									self.assertEqual(
									    snake_case	,       [
									        {'generated_token_ids': ANY(torch.Tensor						)},
									        {'generated_token_ids': ANY(torch.Tensor						)},
									    ]	,       )
									_UpperCAmelCase							 =		generator.model.config.eos_token_id
									_UpperCAmelCase							 =		'<pad>'
									_UpperCAmelCase							 =		generator(
									    ['This is a test', 'This is a second test']	,       do_sample=snake_case	,       num_return_sequences=2	,       batch_size=2	,       return_tensors=snake_case	,       )
									self.assertEqual(
									    snake_case	,       [
									        [
									            {'generated_token_ids': ANY(torch.Tensor						)},
									            {'generated_token_ids': ANY(torch.Tensor						)},
									        ],
									        [
									            {'generated_token_ids': ANY(torch.Tensor						)},
									            {'generated_token_ids': ANY(torch.Tensor						)},
									        ],
									    ]	,       )






							@require_tf
							def        lowerCamelCase_   (  self						)			->							Any:
									_UpperCAmelCase							 =		pipeline('text2text-generation'	,       model='patrickvonplaten/t5-tiny-random'	,       framework='tf'						)
									# do_sample=False necessary for reproducibility
									_UpperCAmelCase							 =		generator('Something there'	,       do_sample=snake_case						)
									self.assertEqual(snake_case	,       [{'generated_text': ''}]						)


