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        a_				(		unittest.TestCase		):






	'''simple docstring'''






	def 	__snake_case		(    self      :						Optional[Any]    ,					lowercase__      :						List[Any]):







								'''simple docstring'''



								lowerCAmelCase__  			=      list(tokenizer_class.max_model_input_sizes.keys())
								for model_name in sa_models[:1]:
															lowerCAmelCase__  			=      tokenizer_class.from_pretrained(lowercase__)
															self.assertIsNotNone(lowercase__)
															self.assertIsInstance(lowercase__    ,					lowercase__)
															self.assertIsInstance(lowercase__    ,					lowercase__)

															for special_tok in tokenizer.all_special_tokens:
																						self.assertIsInstance(lowercase__    ,					lowercase__)
																						lowerCAmelCase__  			=      tokenizer.convert_tokens_to_ids(lowercase__)
																						self.assertIsInstance(lowercase__    ,					lowercase__)




	def 	__snake_case		(    self      :						List[str]    ,					lowercase__      :						BatchEncoding    ,					lowercase__      :						Optional[Callable] = None):







								'''simple docstring'''



								lowerCAmelCase__  			=      pickle.dumps(lowercase__)
								self.assertIsNotNone(lowercase__)

								lowerCAmelCase__  			=      pickle.loads(lowercase__)

								# 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(lowercase__    ,					lowercase__))
															else:
																						self.assertEqual(lowercase__    ,					lowercase__)




	@slow
	def 	__snake_case		(    self      :						List[str]):







								'''simple docstring'''



								self.check_tokenizer_from_pretrained(lowercase__)




	def 	__snake_case		(    self      :						List[str]):







								'''simple docstring'''



								self.assertEqual(TensorType('tf')    ,					TensorType.TENSORFLOW)
								self.assertEqual(TensorType('pt')    ,					TensorType.PYTORCH)
								self.assertEqual(TensorType('np')    ,					TensorType.NUMPY)




	@require_tokenizers
	def 	__snake_case		(    self      :						str):







								'''simple docstring'''



								import numpy as np

								lowerCAmelCase__  			=      BertTokenizer.from_pretrained('bert-base-cased')
								lowerCAmelCase__  			=      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 	__snake_case		(    self      :						Union[str, Any]):







								'''simple docstring'''



								import tensorflow as tf

								def tf_array_equals(lowercase__      :						Tuple    ,					lowercase__      :						Optional[int]):
															return tf.reduce_all(tf.equal(lowercase__    ,					lowercase__))

								lowerCAmelCase__  			=      BertTokenizer.from_pretrained('bert-base-cased')
								lowerCAmelCase__  			=      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)    ,					lowercase__)

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




	@require_torch
	@require_tokenizers
	def 	__snake_case		(    self      :						Optional[Any]):







								'''simple docstring'''



								import torch

								lowerCAmelCase__  			=      BertTokenizer.from_pretrained('bert-base-cased')
								lowerCAmelCase__  			=      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 	__snake_case		(    self      :						int):







								'''simple docstring'''



								lowerCAmelCase__  			=      BertTokenizer.from_pretrained('bert-base-cased')
								lowerCAmelCase__  			=      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 	__snake_case		(    self      :						Dict):







								'''simple docstring'''



								lowerCAmelCase__  			=      BertTokenizerFast.from_pretrained('bert-base-cased')
								lowerCAmelCase__  			=      tokenizer_r(['Test', '\xad', 'test']    ,					is_split_into_words=lowercase__)

								self.assertEqual(encoded.word_to_tokens(0)    ,					TokenSpan(start=1    ,					end=2))
								self.assertEqual(encoded.word_to_tokens(1)    ,					lowercase__)
								self.assertEqual(encoded.word_to_tokens(2)    ,					TokenSpan(start=2    ,					end=3))




	def 	__snake_case		(    self      :						Tuple):







								'''simple docstring'''



								lowerCAmelCase__  			=      BatchEncoding({'inputs': [[1, 2, 3], [4, 5, 6]], 'labels': [0, 1]})
								lowerCAmelCase__  			=      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:
															lowerCAmelCase__  			=      batch.convert_to_tensors(tensor_type='np')
								self.assertFalse(len(cs.err)    ,					msg=F"""should have no warning, but got {cs.err}""")

								lowerCAmelCase__  			=      BatchEncoding({'inputs': [1, 2, 3], 'labels': 0})
								lowerCAmelCase__  			=      batch.convert_to_tensors(tensor_type='np'    ,					prepend_batch_axis=lowercase__)
								self.assertEqual(tensor_batch['inputs'].shape    ,					(1, 3))
								self.assertEqual(tensor_batch['labels'].shape    ,					(1,))




	@require_torch
	def 	__snake_case		(    self      :						Any):







								'''simple docstring'''



								lowerCAmelCase__  			=      BatchEncoding({'inputs': [[1, 2, 3], [4, 5, 6]], 'labels': [0, 1]})
								lowerCAmelCase__  			=      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:
															lowerCAmelCase__  			=      batch.convert_to_tensors(tensor_type='pt')
								self.assertFalse(len(cs.err)    ,					msg=F"""should have no warning, but got {cs.err}""")

								lowerCAmelCase__  			=      BatchEncoding({'inputs': [1, 2, 3], 'labels': 0})
								lowerCAmelCase__  			=      batch.convert_to_tensors(tensor_type='pt'    ,					prepend_batch_axis=lowercase__)
								self.assertEqual(tensor_batch['inputs'].shape    ,					(1, 3))
								self.assertEqual(tensor_batch['labels'].shape    ,					(1,))




	@require_tf
	def 	__snake_case		(    self      :						Dict):







								'''simple docstring'''



								lowerCAmelCase__  			=      BatchEncoding({'inputs': [[1, 2, 3], [4, 5, 6]], 'labels': [0, 1]})
								lowerCAmelCase__  			=      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:
															lowerCAmelCase__  			=      batch.convert_to_tensors(tensor_type='tf')
								self.assertFalse(len(cs.err)    ,					msg=F"""should have no warning, but got {cs.err}""")

								lowerCAmelCase__  			=      BatchEncoding({'inputs': [1, 2, 3], 'labels': 0})
								lowerCAmelCase__  			=      batch.convert_to_tensors(tensor_type='tf'    ,					prepend_batch_axis=lowercase__)
								self.assertEqual(tensor_batch['inputs'].shape    ,					(1, 3))
								self.assertEqual(tensor_batch['labels'].shape    ,					(1,))




	@require_flax
	def 	__snake_case		(    self      :						Optional[int]):







								'''simple docstring'''



								lowerCAmelCase__  			=      BatchEncoding({'inputs': [[1, 2, 3], [4, 5, 6]], 'labels': [0, 1]})
								lowerCAmelCase__  			=      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:
															lowerCAmelCase__  			=      batch.convert_to_tensors(tensor_type='jax')
								self.assertFalse(len(cs.err)    ,					msg=F"""should have no warning, but got {cs.err}""")

								lowerCAmelCase__  			=      BatchEncoding({'inputs': [1, 2, 3], 'labels': 0})
								lowerCAmelCase__  			=      batch.convert_to_tensors(tensor_type='jax'    ,					prepend_batch_axis=lowercase__)
								self.assertEqual(tensor_batch['inputs'].shape    ,					(1, 3))
								self.assertEqual(tensor_batch['labels'].shape    ,					(1,))




	def 	__snake_case		(    self      :						List[Any]):







								'''simple docstring'''



								lowerCAmelCase__  			=      [{'input_ids': np.array([0, 1, 2])}, {'input_ids': np.array([0, 1, 2, 3])}]
								lowerCAmelCase__  			=      BertTokenizer.from_pretrained('bert-base-cased')

								lowerCAmelCase__  			=      tokenizer.pad(lowercase__    ,					padding=lowercase__)
								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]])
								lowerCAmelCase__  			=      tokenizer.pad(lowercase__    ,					padding=lowercase__    ,					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 	__snake_case		(    self      :						Optional[Any]):







								'''simple docstring'''



								import torch

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

								lowerCAmelCase__  			=      tokenizer.pad(lowercase__    ,					padding=lowercase__)
								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]])
								lowerCAmelCase__  			=      tokenizer.pad(lowercase__    ,					padding=lowercase__    ,					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 	__snake_case		(    self      :						List[Any]):







								'''simple docstring'''



								import tensorflow as tf

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

								lowerCAmelCase__  			=      tokenizer.pad(lowercase__    ,					padding=lowercase__)
								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]])
								lowerCAmelCase__  			=      tokenizer.pad(lowercase__    ,					padding=lowercase__    ,					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 	__snake_case		(    self      :						List[str]):







								'''simple docstring'''



								lowerCAmelCase__  			=      Tokenizer(WordPiece(unk_token='[UNK]'))
								PreTrainedTokenizerFast(tokenizer_object=lowercase__)




	@require_tokenizers
	def 	__snake_case		(    self      :						Tuple):







								'''simple docstring'''



								lowerCAmelCase__  			=      Tokenizer(WordPiece(unk_token='[UNK]'))
								with tempfile.TemporaryDirectory() as tmpdirname:
															bert_tokenizer.save(os.path.join(lowercase__    ,					'tokenizer.json'))
															PreTrainedTokenizerFast(tokenizer_file=os.path.join(lowercase__    ,					'tokenizer.json'))

from ...configuration_utils import PretrainedConfig
from ...utils import logging


lowerCAmelCase__					=				logging.get_logger(__name__)

lowerCAmelCase__					=				{
    'ZinengTang/tvlt-base': 'https://huggingface.co/ZinengTang/tvlt-base/blob/main/config.json',
}
class        a_				(		SCREAMING_SNAKE_CASE		):






 '''simple docstring'''






 UpperCAmelCase_							=      'tvlt'




 def __init__(    self      :						Dict    ,					lowercase__      :						str=224    ,					lowercase__      :						int=2_048    ,					lowercase__      :						int=128    ,					lowercase__      :						Optional[Any]=[16, 16]    ,					lowercase__      :						List[str]=[16, 16]    ,					lowercase__      :						Optional[int]=3    ,					lowercase__      :						Tuple=1    ,					lowercase__      :						Union[str, Any]=8    ,					lowercase__      :						int=768    ,					lowercase__      :						Tuple=12    ,					lowercase__      :						List[str]=12    ,					lowercase__      :						Union[str, Any]=3_072    ,					lowercase__      :						Union[str, Any]="gelu"    ,					lowercase__      :						Dict=0.0    ,					lowercase__      :						Tuple=0.0    ,					lowercase__      :						Union[str, Any]=0.02    ,					lowercase__      :						Any=1e-6    ,					lowercase__      :						Dict=True    ,					lowercase__      :						int=False    ,					lowercase__      :						Tuple=16    ,					lowercase__      :						Optional[int]=512    ,					lowercase__      :						int=8    ,					lowercase__      :						List[Any]=2_048    ,					lowercase__      :						Optional[int]=0.75    ,					lowercase__      :						Union[str, Any]=0.15    ,					lowercase__      :						List[str]="frame-level"    ,					lowercase__      :						Dict=True    ,					lowercase__      :						Tuple=True    ,					lowercase__      :						Any="classification"    ,					**lowercase__      :						Union[str, Any]    ,					):







        '''simple docstring'''



        super().__init__(**lowercase__)

        if audio_mask_type not in ("frame-level", "patch_level"):
               raise ValueError(
                   'audio_mask_type must be one of two acceptable strategies - {\'frame_level\', \'patch-level\') '
                   F"""got {audio_mask_type}""")

        lowerCAmelCase__  			=      image_size
        lowerCAmelCase__  			=      spectrogram_length
        lowerCAmelCase__  			=      frequency_length
        lowerCAmelCase__  			=      image_patch_size
        lowerCAmelCase__  			=      audio_patch_size
        lowerCAmelCase__  			=      num_image_channels
        lowerCAmelCase__  			=      num_audio_channels
        lowerCAmelCase__  			=      num_frames

        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__  			=      initializer_range
        lowerCAmelCase__  			=      layer_norm_eps
        lowerCAmelCase__  			=      qkv_bias
        lowerCAmelCase__  			=      use_mean_pooling

        lowerCAmelCase__  			=      decoder_num_attention_heads
        lowerCAmelCase__  			=      decoder_hidden_size
        lowerCAmelCase__  			=      decoder_num_hidden_layers
        lowerCAmelCase__  			=      decoder_intermediate_size
        lowerCAmelCase__  			=      pixel_mask_ratio
        lowerCAmelCase__  			=      audio_mask_ratio
        lowerCAmelCase__  			=      audio_mask_type

        lowerCAmelCase__  			=      task_matching
        lowerCAmelCase__  			=      task_mae
        lowerCAmelCase__  			=      loss_type
