





'''simple docstring'''




import shutil
import tempfile
import unittest

import pytest

from transformers import WhisperTokenizer, is_speech_available
from transformers.testing_utils import require_sentencepiece, require_torch, require_torchaudio

from .test_feature_extraction_whisper import floats_list


if is_speech_available():
			from transformers import WhisperFeatureExtractor, WhisperProcessor


a__				: List[str]									=    5_0358
a__				: Dict									=    5_0362






@require_torch
@require_torchaudio
@require_sentencepiece
class 							__snake_case    (				unittest.TestCase       ):





	def      _snake_case      (		self		)			->		Optional[Any]:
		snake_case__  					=      'openai/whisper-small.en'
		snake_case__  					=      tempfile.mkdtemp()





	def      _snake_case      (		self			,					**UpperCamelCase_		)			->		Dict:
		return WhisperTokenizer.from_pretrained(self.checkpoint			,					**UpperCamelCase_		)





	def      _snake_case      (		self			,					**UpperCamelCase_		)			->		int:
		return WhisperFeatureExtractor.from_pretrained(self.checkpoint			,					**UpperCamelCase_		)





	def      _snake_case      (		self		)			->		Any:
		shutil.rmtree(self.tmpdirname		)





	def      _snake_case      (		self		)			->		int:
		snake_case__  					=      self.get_tokenizer()
		snake_case__  					=      self.get_feature_extractor()

		snake_case__  					=      WhisperProcessor(tokenizer=UpperCamelCase_			,					feature_extractor=UpperCamelCase_		)

		processor.save_pretrained(self.tmpdirname		)
		snake_case__  					=      WhisperProcessor.from_pretrained(self.tmpdirname		)

		self.assertEqual(processor.tokenizer.get_vocab()			,					tokenizer.get_vocab()		)
		self.assertIsInstance(processor.tokenizer			,					UpperCamelCase_		)

		self.assertEqual(processor.feature_extractor.to_json_string()			,					feature_extractor.to_json_string()		)
		self.assertIsInstance(processor.feature_extractor			,					UpperCamelCase_		)





	def      _snake_case      (		self		)			->		List[str]:
		snake_case__  					=      WhisperProcessor(tokenizer=self.get_tokenizer()			,					feature_extractor=self.get_feature_extractor()		)
		processor.save_pretrained(self.tmpdirname		)

		snake_case__  					=      self.get_tokenizer(bos_token='(BOS)'			,					eos_token='(EOS)'		)
		snake_case__  					=      self.get_feature_extractor(do_normalize=UpperCamelCase_			,					padding_value=1.0		)

		snake_case__  					=      WhisperProcessor.from_pretrained(
		    self.tmpdirname			,					bos_token='(BOS)'			,					eos_token='(EOS)'			,					do_normalize=UpperCamelCase_			,					padding_value=1.0		)

		self.assertEqual(processor.tokenizer.get_vocab()			,					tokenizer_add_kwargs.get_vocab()		)
		self.assertIsInstance(processor.tokenizer			,					UpperCamelCase_		)

		self.assertEqual(processor.feature_extractor.to_json_string()			,					feature_extractor_add_kwargs.to_json_string()		)
		self.assertIsInstance(processor.feature_extractor			,					UpperCamelCase_		)





	def      _snake_case      (		self		)			->		List[Any]:
		snake_case__  					=      self.get_feature_extractor()
		snake_case__  					=      self.get_tokenizer()

		snake_case__  					=      WhisperProcessor(tokenizer=UpperCamelCase_			,					feature_extractor=UpperCamelCase_		)

		snake_case__  					=      floats_list((3, 1000)		)

		snake_case__  					=      feature_extractor(UpperCamelCase_			,					return_tensors='np'		)
		snake_case__  					=      processor(UpperCamelCase_			,					return_tensors='np'		)

		for key in input_feat_extract.keys():
			self.assertAlmostEqual(input_feat_extract[key].sum()			,					input_processor[key].sum()			,					delta=1E-2		)





	def      _snake_case      (		self		)			->		Optional[Any]:
		snake_case__  					=      self.get_feature_extractor()
		snake_case__  					=      self.get_tokenizer()

		snake_case__  					=      WhisperProcessor(tokenizer=UpperCamelCase_			,					feature_extractor=UpperCamelCase_		)

		snake_case__  					=      'This is a test string'

		snake_case__  					=      processor(text=UpperCamelCase_		)

		snake_case__  					=      tokenizer(UpperCamelCase_		)

		for key in encoded_tok.keys():
			self.assertListEqual(encoded_tok[key]			,					encoded_processor[key]		)





	def      _snake_case      (		self		)			->		Optional[int]:
		snake_case__  					=      self.get_feature_extractor()
		snake_case__  					=      self.get_tokenizer()

		snake_case__  					=      WhisperProcessor(tokenizer=UpperCamelCase_			,					feature_extractor=UpperCamelCase_		)

		snake_case__  					=      [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

		snake_case__  					=      processor.batch_decode(UpperCamelCase_		)
		snake_case__  					=      tokenizer.batch_decode(UpperCamelCase_		)

		self.assertListEqual(UpperCamelCase_			,					UpperCamelCase_		)





	def      _snake_case      (		self		)			->		Any:
		snake_case__  					=      self.get_feature_extractor()
		snake_case__  					=      self.get_tokenizer()

		snake_case__  					=      WhisperProcessor(tokenizer=UpperCamelCase_			,					feature_extractor=UpperCamelCase_		)

		self.assertListEqual(
		    processor.model_input_names			,					feature_extractor.model_input_names			,					msg='`processor` and `feature_extractor` model input names do not match'			,					)





	def      _snake_case      (		self		)			->		Optional[Any]:
		snake_case__  					=      self.get_feature_extractor()
		snake_case__  					=      self.get_tokenizer()

		snake_case__  					=      WhisperProcessor(tokenizer=UpperCamelCase_			,					feature_extractor=UpperCamelCase_		)
		snake_case__  					=      processor.get_decoder_prompt_ids(task='transcribe'			,					no_timestamps=UpperCamelCase_		)

		self.assertIsInstance(UpperCamelCase_			,					UpperCamelCase_		)
		for ids in forced_decoder_ids:
			self.assertIsInstance(UpperCamelCase_			,					(list, tuple)		)

		snake_case__  					=      [TRANSCRIBE, NOTIMESTAMPS]
		self.assertListEqual([ids[-1] for ids in forced_decoder_ids]			,					UpperCamelCase_		)





	def      _snake_case      (		self		)			->		Optional[int]:
		snake_case__  					=      WhisperProcessor(tokenizer=self.get_tokenizer()			,					feature_extractor=self.get_feature_extractor()		)
		snake_case__  					=      processor.get_prompt_ids('Mr. Quilter'		)
		snake_case__  					=      processor.tokenizer.decode(UpperCamelCase_		)

		self.assertListEqual(prompt_ids.tolist()			,					[5_0360, 1770, 13, 2264, 346, 353]		)
		self.assertEqual(UpperCamelCase_			,					'<|startofprev|> Mr. Quilter'		)





	def      _snake_case      (		self		)			->		Optional[int]:
		snake_case__  					=      WhisperProcessor(tokenizer=self.get_tokenizer()			,					feature_extractor=self.get_feature_extractor()		)
		snake_case__  					=      processor.get_prompt_ids(''		)
		snake_case__  					=      processor.tokenizer.decode(UpperCamelCase_		)

		self.assertListEqual(prompt_ids.tolist()			,					[5_0360, 220]		)
		self.assertEqual(UpperCamelCase_			,					'<|startofprev|> '		)





	def      _snake_case      (		self		)			->		Any:
		snake_case__  					=      WhisperProcessor(tokenizer=self.get_tokenizer()			,					feature_extractor=self.get_feature_extractor()		)

		def _test_prompt_error_raised_helper(UpperCamelCase_			,					UpperCamelCase_		):
			with pytest.raises(UpperCamelCase_		) as excinfo:
				processor.get_prompt_ids(UpperCamelCase_		)
			snake_case__  					=      F'''Encountered text in the prompt corresponding to disallowed special token: {special_token}.'''
			self.assertEqual(UpperCamelCase_			,					str(excinfo.value		)		)

		_test_prompt_error_raised_helper('<|startofprev|> test'			,					'<|startofprev|>'		)
		_test_prompt_error_raised_helper('test <|notimestamps|>'			,					'<|notimestamps|>'		)
		_test_prompt_error_raised_helper('test <|zh|> test <|transcribe|>'			,					'<|zh|>'		)










'''simple docstring'''




from ...configuration_utils import PretrainedConfig
from ...utils import is_detectrona_available, logging


a__				: Optional[Any]									=    logging.get_logger(__name__)

a__				: List[str]									=    {
    '''layoutlmv2-base-uncased''': '''https://huggingface.co/microsoft/layoutlmv2-base-uncased/resolve/main/config.json''',
    '''layoutlmv2-large-uncased''': '''https://huggingface.co/microsoft/layoutlmv2-large-uncased/resolve/main/config.json''',
    # See all LayoutLMv2 models at https://huggingface.co/models?filter=layoutlmv2
}

# soft dependency
if is_detectrona_available():
			import detectrona






class 							__snake_case    (				__magic_name__       ):
	__lowerCAmelCase						=     '''layoutlmv2'''





	def __init__(		self			,					UpperCamelCase_=3_0522			,					UpperCamelCase_=768			,					UpperCamelCase_=12			,					UpperCamelCase_=12			,					UpperCamelCase_=3072			,					UpperCamelCase_="gelu"			,					UpperCamelCase_=0.1			,					UpperCamelCase_=0.1			,					UpperCamelCase_=512			,					UpperCamelCase_=2			,					UpperCamelCase_=0.0_2			,					UpperCamelCase_=1E-1_2			,					UpperCamelCase_=0			,					UpperCamelCase_=1024			,					UpperCamelCase_=128			,					UpperCamelCase_=32			,					UpperCamelCase_=True			,					UpperCamelCase_=256			,					UpperCamelCase_=64			,					UpperCamelCase_=True			,					UpperCamelCase_=[7, 7, 256]			,					UpperCamelCase_=128			,					UpperCamelCase_=128			,					UpperCamelCase_=True			,					UpperCamelCase_=True			,					UpperCamelCase_=False			,					UpperCamelCase_=None			,					**UpperCamelCase_			,					)			->		Tuple:
		super().__init__(
		    vocab_size=UpperCamelCase_			,					hidden_size=UpperCamelCase_			,					num_hidden_layers=UpperCamelCase_			,					num_attention_heads=UpperCamelCase_			,					intermediate_size=UpperCamelCase_			,					hidden_act=UpperCamelCase_			,					hidden_dropout_prob=UpperCamelCase_			,					attention_probs_dropout_prob=UpperCamelCase_			,					max_position_embeddings=UpperCamelCase_			,					type_vocab_size=UpperCamelCase_			,					initializer_range=UpperCamelCase_			,					layer_norm_eps=UpperCamelCase_			,					pad_token_id=UpperCamelCase_			,					**UpperCamelCase_			,					)
		snake_case__  					=      max_ad_position_embeddings
		snake_case__  					=      max_rel_pos
		snake_case__  					=      rel_pos_bins
		snake_case__  					=      fast_qkv
		snake_case__  					=      max_rel_ad_pos
		snake_case__  					=      rel_ad_pos_bins
		snake_case__  					=      convert_sync_batchnorm
		snake_case__  					=      image_feature_pool_shape
		snake_case__  					=      coordinate_size
		snake_case__  					=      shape_size
		snake_case__  					=      has_relative_attention_bias
		snake_case__  					=      has_spatial_attention_bias
		snake_case__  					=      has_visual_segment_embedding
		snake_case__  					=      (
		    detectrona_config_args if detectrona_config_args is not None else self.get_default_detectrona_config()
		)





	@classmethod
	def      _snake_case      (		self		)			->		Dict:
		return {
		    "MODEL.MASK_ON": True,
		    "MODEL.PIXEL_STD": [5_7.3_7_5, 5_7.1_2_0, 5_8.3_9_5],
		    "MODEL.BACKBONE.NAME": "build_resnet_fpn_backbone",
		    "MODEL.FPN.IN_FEATURES": ["res2", "res3", "res4", "res5"],
		    "MODEL.ANCHOR_GENERATOR.SIZES": [[32], [64], [128], [256], [512]],
		    "MODEL.RPN.IN_FEATURES": ["p2", "p3", "p4", "p5", "p6"],
		    "MODEL.RPN.PRE_NMS_TOPK_TRAIN": 2000,
		    "MODEL.RPN.PRE_NMS_TOPK_TEST": 1000,
		    "MODEL.RPN.POST_NMS_TOPK_TRAIN": 1000,
		    "MODEL.POST_NMS_TOPK_TEST": 1000,
		    "MODEL.ROI_HEADS.NAME": "StandardROIHeads",
		    "MODEL.ROI_HEADS.NUM_CLASSES": 5,
		    "MODEL.ROI_HEADS.IN_FEATURES": ["p2", "p3", "p4", "p5"],
		    "MODEL.ROI_BOX_HEAD.NAME": "FastRCNNConvFCHead",
		    "MODEL.ROI_BOX_HEAD.NUM_FC": 2,
		    "MODEL.ROI_BOX_HEAD.POOLER_RESOLUTION": 14,
		    "MODEL.ROI_MASK_HEAD.NAME": "MaskRCNNConvUpsampleHead",
		    "MODEL.ROI_MASK_HEAD.NUM_CONV": 4,
		    "MODEL.ROI_MASK_HEAD.POOLER_RESOLUTION": 7,
		    "MODEL.RESNETS.DEPTH": 101,
		    "MODEL.RESNETS.SIZES": [[32], [64], [128], [256], [512]],
		    "MODEL.RESNETS.ASPECT_RATIOS": [[0.5, 1.0, 2.0]],
		    "MODEL.RESNETS.OUT_FEATURES": ["res2", "res3", "res4", "res5"],
		    "MODEL.RESNETS.NUM_GROUPS": 32,
		    "MODEL.RESNETS.WIDTH_PER_GROUP": 8,
		    "MODEL.RESNETS.STRIDE_IN_1X1": False,
		}





	def      _snake_case      (		self		)			->		Optional[Any]:
		snake_case__  					=      detectrona.config.get_cfg()
		for k, v in self.detectrona_config_args.items():
			snake_case__  					=      k.split('.'		)
			snake_case__  					=      detectrona_config
			for attribute in attributes[:-1]:
				snake_case__  					=      getattr(UpperCamelCase_			,					UpperCamelCase_		)
			setattr(UpperCamelCase_			,					attributes[-1]			,					UpperCamelCase_		)

		return detectrona_config



