






import os
import tempfile
import unittest

import numpy as np
import torch

from diffusers.models import ModelMixin, UNetaDConditionModel
from diffusers.models.attention_processor import AttnProcessor, LoRAAttnProcessor
from diffusers.utils import (
    floats_tensor,
    logging,
    skip_mps,
    torch_device,
)
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


enable_full_determinism()

__UpperCamelCase   :						List[str]							=  logging.get_logger(__name__)
def        a_	( _A ,				_A = True					)     ->     str:







				"""simple docstring"""
				snake_case__													=       {}
				for name in model.attn_processors.keys():
								snake_case__													=       name.endswith('attn2.processor'					) and not (
								    name.startswith('transformer_in'					) or 'temp_attentions' in name.split('.'					)
								)
								snake_case__													=       model.config.cross_attention_dim if has_cross_attention else None
								if name.startswith('mid_block'					):
												snake_case__													=       model.config.block_out_channels[-1]
								elif name.startswith('up_blocks'					):
												snake_case__													=       int(name[len('up_blocks.'					)]					)
												snake_case__													=       list(reversed(model.config.block_out_channels					)					)[block_id]
								elif name.startswith('down_blocks'					):
												snake_case__													=       int(name[len('down_blocks.'					)]					)
												snake_case__													=       model.config.block_out_channels[block_id]
								elif name.startswith('transformer_in'					):
												# Note that the `8 * ...` comes from: https://github.com/huggingface/diffusers/blob/7139f0e874f10b2463caa8cbd585762a309d12d6/src/diffusers/models/unet_3d_condition.py#L148
												snake_case__													=       8 * model.config.attention_head_dim

								snake_case__													=       LoRAAttnProcessor(hidden_size=_A ,				cross_attention_dim=_A					)
								snake_case__													=       lora_attn_procs[name].to(model.device					)

								if mock_weights:
												# add 1 to weights to mock trained weights
												with torch.no_grad():
																lora_attn_procs[name].to_q_lora.up.weight += 1
																lora_attn_procs[name].to_k_lora.up.weight += 1
																lora_attn_procs[name].to_v_lora.up.weight += 1
																lora_attn_procs[name].to_out_lora.up.weight += 1

				return lora_attn_procs


@skip_mps
class 					__SCREAMING_SNAKE_CASE(		a_      ,					a_      ,					unittest.TestCase		):
							_UpperCAmelCase	      =    UNetaDConditionModel
							_UpperCAmelCase	      =    "sample"
							@property
							def lowerCAmelCase_	(       self: Optional[Any]  )						->						Tuple:
											snake_case__													=       4
											snake_case__													=       4
											snake_case__													=       4
											snake_case__													=       (32, 32)

											snake_case__													=       floats_tensor((batch_size, num_channels, num_frames) + sizes  ).to(UpperCamelCase  )
											snake_case__													=       torch.tensor([10]  ).to(UpperCamelCase  )
											snake_case__													=       floats_tensor((batch_size, 4, 32)  ).to(UpperCamelCase  )

											return {"sample": noise, "timestep": time_step, "encoder_hidden_states": encoder_hidden_states}
							@property
							def lowerCAmelCase_	(       self: Any  )						->						int:
											return (4, 4, 32, 32)
							@property
							def lowerCAmelCase_	(       self: Union[str, Any]  )						->						Any:
											return (4, 4, 32, 32)
							def lowerCAmelCase_	(       self: int  )						->						int:
											snake_case__													=       {
											    'block_out_channels': (32, 64),
											    'down_block_types': (
											        'CrossAttnDownBlock3D',
											        'DownBlock3D',
											    ),
											    'up_block_types': ('UpBlock3D', 'CrossAttnUpBlock3D'),
											    'cross_attention_dim': 32,
											    'attention_head_dim': 8,
											    'out_channels': 4,
											    'in_channels': 4,
											    'layers_per_block': 1,
											    'sample_size': 32,
											}
											snake_case__													=       self.dummy_input
											return init_dict, inputs_dict
							@unittest.skipIf(
							    torch_device != 'cuda' or not is_xformers_available()    ,		reason='XFormers attention is only available with CUDA and `xformers` installed'    ,		)
							def lowerCAmelCase_	(       self: str  )						->						List[Any]:
											snake_case__							,  snake_case__													=       self.prepare_init_args_and_inputs_for_common()
											snake_case__													=       self.model_class(**UpperCamelCase  )

											model.enable_xformers_memory_efficient_attention()

											assert (
											    model.mid_block.attentions[0].transformer_blocks[0].attna.processor.__class__.__name__
											    == "XFormersAttnProcessor"
											), "xformers is not enabled"
							def lowerCAmelCase_	(       self: Tuple  )						->						int:
											snake_case__							,  snake_case__													=       self.prepare_init_args_and_inputs_for_common()

											snake_case__													=       32

											snake_case__													=       self.model_class(**UpperCamelCase  )
											model.to(UpperCamelCase  )
											model.eval()

											with torch.no_grad():
															snake_case__													=       model(**UpperCamelCase  )

															if isinstance(UpperCamelCase    ,		UpperCamelCase  ):
																			snake_case__													=       output.sample

											self.assertIsNotNone(UpperCamelCase  )
											snake_case__													=       inputs_dict['sample'].shape
											self.assertEqual(output.shape    ,		UpperCamelCase    ,		'Input and output shapes do not match'  )
							def lowerCAmelCase_	(       self: Optional[Any]  )						->						Dict:
											snake_case__							,  snake_case__													=       self.prepare_init_args_and_inputs_for_common()
											snake_case__													=       self.model_class(**UpperCamelCase  )
											model.to(UpperCamelCase  )
											model.eval()

											with torch.no_grad():
															# Warmup pass when using mps (see #372)
															if torch_device == "mps" and isinstance(UpperCamelCase    ,		UpperCamelCase  ):
																			model(**self.dummy_input  )

															snake_case__													=       model(**UpperCamelCase  )
															if isinstance(UpperCamelCase    ,		UpperCamelCase  ):
																			snake_case__													=       first.sample

															snake_case__													=       model(**UpperCamelCase  )
															if isinstance(UpperCamelCase    ,		UpperCamelCase  ):
																			snake_case__													=       second.sample

											snake_case__													=       first.cpu().numpy()
											snake_case__													=       second.cpu().numpy()
											snake_case__													=       out_a[~np.isnan(UpperCamelCase  )]
											snake_case__													=       out_a[~np.isnan(UpperCamelCase  )]
											snake_case__													=       np.amax(np.abs(out_a - out_a  )  )
											self.assertLessEqual(UpperCamelCase    ,		1e-5  )
							def lowerCAmelCase_	(       self: Optional[Any]  )						->						List[str]:
											snake_case__							,  snake_case__													=       self.prepare_init_args_and_inputs_for_common()

											snake_case__													=       8

											snake_case__													=       self.model_class(**UpperCamelCase  )
											model.to(UpperCamelCase  )
											model.eval()

											model.set_attention_slice('auto'  )
											with torch.no_grad():
															snake_case__													=       model(**UpperCamelCase  )
											assert output is not None

											model.set_attention_slice('max'  )
											with torch.no_grad():
															snake_case__													=       model(**UpperCamelCase  )
											assert output is not None

											model.set_attention_slice(2  )
											with torch.no_grad():
															snake_case__													=       model(**UpperCamelCase  )
											assert output is not None
							def lowerCAmelCase_	(       self: List[Any]  )						->						List[Any]:
											snake_case__							,  snake_case__													=       self.prepare_init_args_and_inputs_for_common()

											snake_case__													=       8

											snake_case__													=       self.model_class(**UpperCamelCase  )
											model.to(UpperCamelCase  )

											with torch.no_grad():
															snake_case__													=       model(**UpperCamelCase  ).sample

											snake_case__													=       create_lora_layers(UpperCamelCase  )

											# make sure we can set a list of attention processors
											model.set_attn_processor(UpperCamelCase  )
											model.to(UpperCamelCase  )

											# test that attn processors can be set to itself
											model.set_attn_processor(model.attn_processors  )

											with torch.no_grad():
															snake_case__													=       model(**UpperCamelCase    ,		cross_attention_kwargs={'scale': 0.0}  ).sample
															snake_case__													=       model(**UpperCamelCase    ,		cross_attention_kwargs={'scale': 0.5}  ).sample
															snake_case__													=       model(**UpperCamelCase    ,		cross_attention_kwargs={'scale': 0.5}  ).sample

											assert (samplea - samplea).abs().max() < 3e-3
											assert (samplea - samplea).abs().max() < 3e-3

											# sample 2 and sample 3 should be different
											assert (samplea - samplea).abs().max() > 3e-3
							def lowerCAmelCase_	(       self: List[str]  )						->						List[str]:
											snake_case__							,  snake_case__													=       self.prepare_init_args_and_inputs_for_common()

											snake_case__													=       8

											torch.manual_seed(0  )
											snake_case__													=       self.model_class(**UpperCamelCase  )
											model.to(UpperCamelCase  )

											with torch.no_grad():
															snake_case__													=       model(**UpperCamelCase  ).sample

											snake_case__													=       create_lora_layers(UpperCamelCase  )
											model.set_attn_processor(UpperCamelCase  )

											with torch.no_grad():
															snake_case__													=       model(**UpperCamelCase    ,		cross_attention_kwargs={'scale': 0.5}  ).sample

											with tempfile.TemporaryDirectory() as tmpdirname:
															model.save_attn_procs(UpperCamelCase  )
															self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase    ,		'pytorch_lora_weights.bin'  )  )  )
															torch.manual_seed(0  )
															snake_case__													=       self.model_class(**UpperCamelCase  )
															new_model.to(UpperCamelCase  )
															new_model.load_attn_procs(UpperCamelCase  )

											with torch.no_grad():
															snake_case__													=       new_model(**UpperCamelCase    ,		cross_attention_kwargs={'scale': 0.5}  ).sample

											assert (sample - new_sample).abs().max() < 1e-3

											# LoRA and no LoRA should NOT be the same
											assert (sample - old_sample).abs().max() > 1e-4
							def lowerCAmelCase_	(       self: Any  )						->						Union[str, Any]:
											snake_case__							,  snake_case__													=       self.prepare_init_args_and_inputs_for_common()

											snake_case__													=       8

											torch.manual_seed(0  )
											snake_case__													=       self.model_class(**UpperCamelCase  )
											model.to(UpperCamelCase  )

											with torch.no_grad():
															snake_case__													=       model(**UpperCamelCase  ).sample

											snake_case__													=       create_lora_layers(UpperCamelCase  )
											model.set_attn_processor(UpperCamelCase  )

											with torch.no_grad():
															snake_case__													=       model(**UpperCamelCase    ,		cross_attention_kwargs={'scale': 0.5}  ).sample

											with tempfile.TemporaryDirectory() as tmpdirname:
															model.save_attn_procs(UpperCamelCase    ,		safe_serialization=UpperCamelCase  )
															self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase    ,		'pytorch_lora_weights.safetensors'  )  )  )
															torch.manual_seed(0  )
															snake_case__													=       self.model_class(**UpperCamelCase  )
															new_model.to(UpperCamelCase  )
															new_model.load_attn_procs(UpperCamelCase  )

											with torch.no_grad():
															snake_case__													=       new_model(**UpperCamelCase    ,		cross_attention_kwargs={'scale': 0.5}  ).sample

											assert (sample - new_sample).abs().max() < 3e-3

											# LoRA and no LoRA should NOT be the same
											assert (sample - old_sample).abs().max() > 1e-4
							def lowerCAmelCase_	(       self: Any  )						->						Union[str, Any]:
											# enable deterministic behavior for gradient checkpointing
											snake_case__							,  snake_case__													=       self.prepare_init_args_and_inputs_for_common()

											snake_case__													=       8

											torch.manual_seed(0  )
											snake_case__													=       self.model_class(**UpperCamelCase  )
											model.to(UpperCamelCase  )

											snake_case__													=       create_lora_layers(UpperCamelCase    ,		mock_weights=UpperCamelCase  )
											model.set_attn_processor(UpperCamelCase  )
											# Saving as torch, properly reloads with directly filename
											with tempfile.TemporaryDirectory() as tmpdirname:
															model.save_attn_procs(UpperCamelCase  )
															self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase    ,		'pytorch_lora_weights.bin'  )  )  )
															torch.manual_seed(0  )
															snake_case__													=       self.model_class(**UpperCamelCase  )
															new_model.to(UpperCamelCase  )
															new_model.load_attn_procs(UpperCamelCase    ,		weight_name='pytorch_lora_weights.bin'  )
							def lowerCAmelCase_	(       self: Optional[int]  )						->						List[Any]:
											snake_case__							,  snake_case__													=       self.prepare_init_args_and_inputs_for_common()

											snake_case__													=       8

											torch.manual_seed(0  )
											snake_case__													=       self.model_class(**UpperCamelCase  )
											model.to(UpperCamelCase  )

											snake_case__													=       create_lora_layers(UpperCamelCase    ,		mock_weights=UpperCamelCase  )
											model.set_attn_processor(UpperCamelCase  )
											# Saving as torch, properly reloads with directly filename
											with tempfile.TemporaryDirectory() as tmpdirname:
															model.save_attn_procs(UpperCamelCase  )
															self.assertTrue(os.path.isfile(os.path.join(UpperCamelCase    ,		'pytorch_lora_weights.bin'  )  )  )
															torch.manual_seed(0  )
															snake_case__													=       self.model_class(**UpperCamelCase  )
															new_model.to(UpperCamelCase  )
															with self.assertRaises(UpperCamelCase  ) as e:
																			new_model.load_attn_procs(UpperCamelCase    ,		use_safetensors=UpperCamelCase  )
															self.assertIn('Error no file named pytorch_lora_weights.safetensors'    ,		str(e.exception  )  )
							def lowerCAmelCase_	(       self: Optional[int]  )						->						List[str]:
											snake_case__							,  snake_case__													=       self.prepare_init_args_and_inputs_for_common()

											snake_case__													=       8

											torch.manual_seed(0  )
											snake_case__													=       self.model_class(**UpperCamelCase  )
											model.to(UpperCamelCase  )

											with torch.no_grad():
															snake_case__													=       model(**UpperCamelCase  ).sample

											snake_case__													=       create_lora_layers(UpperCamelCase  )
											model.set_attn_processor(UpperCamelCase  )

											with torch.no_grad():
															snake_case__													=       model(**UpperCamelCase    ,		cross_attention_kwargs={'scale': 0.0}  ).sample

											model.set_attn_processor(AttnProcessor()  )

											with torch.no_grad():
															snake_case__													=       model(**UpperCamelCase  ).sample

											assert (sample - new_sample).abs().max() < 1e-4
											assert (sample - old_sample).abs().max() < 3e-3
							@unittest.skipIf(
							    torch_device != 'cuda' or not is_xformers_available()    ,		reason='XFormers attention is only available with CUDA and `xformers` installed'    ,		)
							def lowerCAmelCase_	(       self: Tuple  )						->						Union[str, Any]:
											# enable deterministic behavior for gradient checkpointing
											snake_case__							,  snake_case__													=       self.prepare_init_args_and_inputs_for_common()

											snake_case__													=       4

											torch.manual_seed(0  )
											snake_case__													=       self.model_class(**UpperCamelCase  )
											model.to(UpperCamelCase  )
											snake_case__													=       create_lora_layers(UpperCamelCase  )
											model.set_attn_processor(UpperCamelCase  )

											# default
											with torch.no_grad():
															snake_case__													=       model(**UpperCamelCase  ).sample

															model.enable_xformers_memory_efficient_attention()
															snake_case__													=       model(**UpperCamelCase  ).sample

															model.disable_xformers_memory_efficient_attention()
															snake_case__													=       model(**UpperCamelCase  ).sample

											assert (sample - on_sample).abs().max() < 1e-4
											assert (sample - off_sample).abs().max() < 1e-4


							def lowerCAmelCase_	(       self: Any  )						->						List[Any]:
											snake_case__							,  snake_case__													=       self.prepare_init_args_and_inputs_for_common()
											snake_case__													=       32

											snake_case__													=       self.model_class(**UpperCamelCase  )
											model.to(UpperCamelCase  )
											model.eval()

											with torch.no_grad():
															snake_case__													=       model(**UpperCamelCase  )[0]

											model.enable_forward_chunking()
											with torch.no_grad():
															snake_case__													=       model(**UpperCamelCase  )[0]

											self.assertEqual(output.shape    ,		output_a.shape    ,		'Shape doesn\'t match'  )
											assert np.abs(output.cpu() - output_a.cpu()  ).max() < 1e-2


# (todo: sayakpaul) implement SLOW tests.










import os
import pickle
import tempfile
import unittest
from typing import Callable, Optional

import numpy as np

from transformers import (
    BatchEncoding,
    BertTokenizer,
    BertTokenizerFast,
    PreTrainedTokenizer,
    PreTrainedTokenizerFast,
    TensorType,
    TokenSpan,
    is_tokenizers_available,
)
from transformers.models.gpta.tokenization_gpta import GPTaTokenizer
from transformers.testing_utils import CaptureStderr, require_flax, require_tf, require_tokenizers, require_torch, slow


if is_tokenizers_available():
							from tokenizers import Tokenizer
							from tokenizers.models import WordPiece


class 					__SCREAMING_SNAKE_CASE(		unittest.TestCase		):
							def lowerCAmelCase_	(       self: Any    ,		UpperCamelCase: Union[str, Any]  )						->						Optional[int]:
											snake_case__													=       list(tokenizer_class.max_model_input_sizes.keys()  )
											for model_name in sa_models[:1]:
															snake_case__													=       tokenizer_class.from_pretrained(UpperCamelCase  )
															self.assertIsNotNone(UpperCamelCase  )
															self.assertIsInstance(UpperCamelCase    ,		UpperCamelCase  )
															self.assertIsInstance(UpperCamelCase    ,		UpperCamelCase  )

															for special_tok in tokenizer.all_special_tokens:
																			self.assertIsInstance(UpperCamelCase    ,		UpperCamelCase  )
																			snake_case__													=       tokenizer.convert_tokens_to_ids(UpperCamelCase  )
																			self.assertIsInstance(UpperCamelCase    ,		UpperCamelCase  )
							def lowerCAmelCase_	(       self: Optional[int]    ,		UpperCamelCase: BatchEncoding    ,		UpperCamelCase: Optional[Callable] = None  )						->						List[str]:
											snake_case__													=       pickle.dumps(UpperCamelCase  )
											self.assertIsNotNone(UpperCamelCase  )

											snake_case__													=       pickle.loads(UpperCamelCase  )

											# Ensure is_fast is correctly restored
											self.assertEqual(be_restored.is_fast    ,		be_original.is_fast  )

											# Ensure encodings are potentially correctly restored
											if be_original.is_fast:
															self.assertIsNotNone(be_restored.encodings  )
											else:
															self.assertIsNone(be_restored.encodings  )

											# Ensure the keys are the same
											for original_v, restored_v in zip(be_original.values()    ,		be_restored.values()  ):
															if equal_op:
																			self.assertTrue(equal_op(UpperCamelCase    ,		UpperCamelCase  )  )
															else:
																			self.assertEqual(UpperCamelCase    ,		UpperCamelCase  )
							@slow
							def lowerCAmelCase_	(       self: Optional[int]  )						->						Optional[int]:
											self.check_tokenizer_from_pretrained(UpperCamelCase  )
							def lowerCAmelCase_	(       self: Optional[int]  )						->						Optional[Any]:
											self.assertEqual(TensorType('tf'  )    ,		TensorType.TENSORFLOW  )
											self.assertEqual(TensorType('pt'  )    ,		TensorType.PYTORCH  )
											self.assertEqual(TensorType('np'  )    ,		TensorType.NUMPY  )
							@require_tokenizers
							def lowerCAmelCase_	(       self: Optional[int]  )						->						Optional[Any]:
											import numpy as np

											snake_case__													=       BertTokenizer.from_pretrained('bert-base-cased'  )
											snake_case__													=       BertTokenizerFast.from_pretrained('bert-base-cased'  )

											# Python no tensor
											with self.subTest('BatchEncoding (Python, return_tensors=None)'  ):
															self.assert_dump_and_restore(tokenizer_p('Small example to encode'  )  )

											with self.subTest('BatchEncoding (Python, return_tensors=NUMPY)'  ):
															self.assert_dump_and_restore(
															    tokenizer_p('Small example to encode'    ,		return_tensors=TensorType.NUMPY  )    ,		np.array_equal  )

											with self.subTest('BatchEncoding (Rust, return_tensors=None)'  ):
															self.assert_dump_and_restore(tokenizer_r('Small example to encode'  )  )

											with self.subTest('BatchEncoding (Rust, return_tensors=NUMPY)'  ):
															self.assert_dump_and_restore(
															    tokenizer_r('Small example to encode'    ,		return_tensors=TensorType.NUMPY  )    ,		np.array_equal  )
							@require_tf
							@require_tokenizers
							def lowerCAmelCase_	(       self: Any  )						->						Optional[Any]:
											import tensorflow as tf

											def tf_array_equals(UpperCamelCase: Optional[int]    ,		UpperCamelCase: Dict  ):
															return tf.reduce_all(tf.equal(UpperCamelCase    ,		UpperCamelCase  )  )

											snake_case__													=       BertTokenizer.from_pretrained('bert-base-cased'  )
											snake_case__													=       BertTokenizerFast.from_pretrained('bert-base-cased'  )

											with self.subTest('BatchEncoding (Python, return_tensors=TENSORFLOW)'  ):
															self.assert_dump_and_restore(
															    tokenizer_p('Small example to encode'    ,		return_tensors=TensorType.TENSORFLOW  )    ,		UpperCamelCase  )

											with self.subTest('BatchEncoding (Rust, return_tensors=TENSORFLOW)'  ):
															self.assert_dump_and_restore(
															    tokenizer_r('Small example to encode'    ,		return_tensors=TensorType.TENSORFLOW  )    ,		UpperCamelCase  )
							@require_torch
							@require_tokenizers
							def lowerCAmelCase_	(       self: int  )						->						List[str]:
											import torch

											snake_case__													=       BertTokenizer.from_pretrained('bert-base-cased'  )
											snake_case__													=       BertTokenizerFast.from_pretrained('bert-base-cased'  )

											with self.subTest('BatchEncoding (Python, return_tensors=PYTORCH)'  ):
															self.assert_dump_and_restore(
															    tokenizer_p('Small example to encode'    ,		return_tensors=TensorType.PYTORCH  )    ,		torch.equal  )

											with self.subTest('BatchEncoding (Rust, return_tensors=PYTORCH)'  ):
															self.assert_dump_and_restore(
															    tokenizer_r('Small example to encode'    ,		return_tensors=TensorType.PYTORCH  )    ,		torch.equal  )
							@require_tokenizers
							def lowerCAmelCase_	(       self: Any  )						->						Optional[int]:
											snake_case__													=       BertTokenizer.from_pretrained('bert-base-cased'  )
											snake_case__													=       BertTokenizerFast.from_pretrained('bert-base-cased'  )

											with self.subTest('Python Tokenizer'  ):
															self.assertFalse(tokenizer_p('Small example to_encode'  ).is_fast  )

											with self.subTest('Rust Tokenizer'  ):
															self.assertTrue(tokenizer_r('Small example to_encode'  ).is_fast  )
							@require_tokenizers
							def lowerCAmelCase_	(       self: Dict  )						->						Union[str, Any]:
											snake_case__													=       BertTokenizerFast.from_pretrained('bert-base-cased'  )
											snake_case__													=       tokenizer_r(['Test', '\xad', 'test']    ,		is_split_into_words=UpperCamelCase  )

											self.assertEqual(encoded.word_to_tokens(0  )    ,		TokenSpan(start=1    ,		end=2  )  )
											self.assertEqual(encoded.word_to_tokens(1  )    ,		UpperCamelCase  )
											self.assertEqual(encoded.word_to_tokens(2  )    ,		TokenSpan(start=2    ,		end=3  )  )
							def lowerCAmelCase_	(       self: Dict  )						->						Tuple:
											snake_case__													=       BatchEncoding({'inputs': [[1, 2, 3], [4, 5, 6]], 'labels': [0, 1]}  )
											snake_case__													=       batch.convert_to_tensors(tensor_type='np'  )
											self.assertEqual(tensor_batch['inputs'].shape    ,		(2, 3)  )
											self.assertEqual(tensor_batch['labels'].shape    ,		(2,)  )
											# test converting the converted
											with CaptureStderr() as cs:
															snake_case__													=       batch.convert_to_tensors(tensor_type='np'  )
											self.assertFalse(len(cs.err  )    ,		msg=F'''should have no warning, but got {cs.err}'''  )

											snake_case__													=       BatchEncoding({'inputs': [1, 2, 3], 'labels': 0}  )
											snake_case__													=       batch.convert_to_tensors(tensor_type='np'    ,		prepend_batch_axis=UpperCamelCase  )
											self.assertEqual(tensor_batch['inputs'].shape    ,		(1, 3)  )
											self.assertEqual(tensor_batch['labels'].shape    ,		(1,)  )
							@require_torch
							def lowerCAmelCase_	(       self: List[str]  )						->						Dict:
											snake_case__													=       BatchEncoding({'inputs': [[1, 2, 3], [4, 5, 6]], 'labels': [0, 1]}  )
											snake_case__													=       batch.convert_to_tensors(tensor_type='pt'  )
											self.assertEqual(tensor_batch['inputs'].shape    ,		(2, 3)  )
											self.assertEqual(tensor_batch['labels'].shape    ,		(2,)  )
											# test converting the converted
											with CaptureStderr() as cs:
															snake_case__													=       batch.convert_to_tensors(tensor_type='pt'  )
											self.assertFalse(len(cs.err  )    ,		msg=F'''should have no warning, but got {cs.err}'''  )

											snake_case__													=       BatchEncoding({'inputs': [1, 2, 3], 'labels': 0}  )
											snake_case__													=       batch.convert_to_tensors(tensor_type='pt'    ,		prepend_batch_axis=UpperCamelCase  )
											self.assertEqual(tensor_batch['inputs'].shape    ,		(1, 3)  )
											self.assertEqual(tensor_batch['labels'].shape    ,		(1,)  )
							@require_tf
							def lowerCAmelCase_	(       self: Any  )						->						Optional[int]:
											snake_case__													=       BatchEncoding({'inputs': [[1, 2, 3], [4, 5, 6]], 'labels': [0, 1]}  )
											snake_case__													=       batch.convert_to_tensors(tensor_type='tf'  )
											self.assertEqual(tensor_batch['inputs'].shape    ,		(2, 3)  )
											self.assertEqual(tensor_batch['labels'].shape    ,		(2,)  )
											# test converting the converted
											with CaptureStderr() as cs:
															snake_case__													=       batch.convert_to_tensors(tensor_type='tf'  )
											self.assertFalse(len(cs.err  )    ,		msg=F'''should have no warning, but got {cs.err}'''  )

											snake_case__													=       BatchEncoding({'inputs': [1, 2, 3], 'labels': 0}  )
											snake_case__													=       batch.convert_to_tensors(tensor_type='tf'    ,		prepend_batch_axis=UpperCamelCase  )
											self.assertEqual(tensor_batch['inputs'].shape    ,		(1, 3)  )
											self.assertEqual(tensor_batch['labels'].shape    ,		(1,)  )
							@require_flax
							def lowerCAmelCase_	(       self: Optional[int]  )						->						List[str]:
											snake_case__													=       BatchEncoding({'inputs': [[1, 2, 3], [4, 5, 6]], 'labels': [0, 1]}  )
											snake_case__													=       batch.convert_to_tensors(tensor_type='jax'  )
											self.assertEqual(tensor_batch['inputs'].shape    ,		(2, 3)  )
											self.assertEqual(tensor_batch['labels'].shape    ,		(2,)  )
											# test converting the converted
											with CaptureStderr() as cs:
															snake_case__													=       batch.convert_to_tensors(tensor_type='jax'  )
											self.assertFalse(len(cs.err  )    ,		msg=F'''should have no warning, but got {cs.err}'''  )

											snake_case__													=       BatchEncoding({'inputs': [1, 2, 3], 'labels': 0}  )
											snake_case__													=       batch.convert_to_tensors(tensor_type='jax'    ,		prepend_batch_axis=UpperCamelCase  )
											self.assertEqual(tensor_batch['inputs'].shape    ,		(1, 3)  )
											self.assertEqual(tensor_batch['labels'].shape    ,		(1,)  )
							def lowerCAmelCase_	(       self: Union[str, Any]  )						->						str:
											snake_case__													=       [{'input_ids': np.array([0, 1, 2]  )}, {'input_ids': np.array([0, 1, 2, 3]  )}]
											snake_case__													=       BertTokenizer.from_pretrained('bert-base-cased'  )

											snake_case__													=       tokenizer.pad(UpperCamelCase    ,		padding=UpperCamelCase  )
											self.assertTrue(isinstance(batch['input_ids']    ,		np.ndarray  )  )
											self.assertEqual(batch['input_ids'].tolist()    ,		[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]  )
											snake_case__													=       tokenizer.pad(UpperCamelCase    ,		padding=UpperCamelCase    ,		return_tensors='np'  )
											self.assertTrue(isinstance(batch['input_ids']    ,		np.ndarray  )  )
											self.assertEqual(batch['input_ids'].tolist()    ,		[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]  )
							@require_torch
							def lowerCAmelCase_	(       self: Dict  )						->						str:
											import torch

											snake_case__													=       [{'input_ids': torch.tensor([0, 1, 2]  )}, {'input_ids': torch.tensor([0, 1, 2, 3]  )}]
											snake_case__													=       BertTokenizer.from_pretrained('bert-base-cased'  )

											snake_case__													=       tokenizer.pad(UpperCamelCase    ,		padding=UpperCamelCase  )
											self.assertTrue(isinstance(batch['input_ids']    ,		torch.Tensor  )  )
											self.assertEqual(batch['input_ids'].tolist()    ,		[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]  )
											snake_case__													=       tokenizer.pad(UpperCamelCase    ,		padding=UpperCamelCase    ,		return_tensors='pt'  )
											self.assertTrue(isinstance(batch['input_ids']    ,		torch.Tensor  )  )
											self.assertEqual(batch['input_ids'].tolist()    ,		[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]  )
							@require_tf
							def lowerCAmelCase_	(       self: Optional[int]  )						->						Optional[int]:
											import tensorflow as tf

											snake_case__													=       [{'input_ids': tf.constant([0, 1, 2]  )}, {'input_ids': tf.constant([0, 1, 2, 3]  )}]
											snake_case__													=       BertTokenizer.from_pretrained('bert-base-cased'  )

											snake_case__													=       tokenizer.pad(UpperCamelCase    ,		padding=UpperCamelCase  )
											self.assertTrue(isinstance(batch['input_ids']    ,		tf.Tensor  )  )
											self.assertEqual(batch['input_ids'].numpy().tolist()    ,		[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]  )
											snake_case__													=       tokenizer.pad(UpperCamelCase    ,		padding=UpperCamelCase    ,		return_tensors='tf'  )
											self.assertTrue(isinstance(batch['input_ids']    ,		tf.Tensor  )  )
											self.assertEqual(batch['input_ids'].numpy().tolist()    ,		[[0, 1, 2, tokenizer.pad_token_id], [0, 1, 2, 3]]  )
							@require_tokenizers
							def lowerCAmelCase_	(       self: Any  )						->						List[str]:
											snake_case__													=       Tokenizer(WordPiece(unk_token='[UNK]'  )  )
											PreTrainedTokenizerFast(tokenizer_object=UpperCamelCase  )


							@require_tokenizers
							def lowerCAmelCase_	(       self: Tuple  )						->						str:
											snake_case__													=       Tokenizer(WordPiece(unk_token='[UNK]'  )  )
											with tempfile.TemporaryDirectory() as tmpdirname:
															bert_tokenizer.save(os.path.join(UpperCamelCase    ,		'tokenizer.json'  )  )
															PreTrainedTokenizerFast(tokenizer_file=os.path.join(UpperCamelCase    ,		'tokenizer.json'  )  )




