






from __future__ import annotations

import unittest

import numpy as np

from transformers import LayoutLMConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
					import tensorflow as tf

					from transformers.models.layoutlm.modeling_tf_layoutlm import (
					    TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST,
					    TFLayoutLMForMaskedLM,
					    TFLayoutLMForQuestionAnswering,
					    TFLayoutLMForSequenceClassification,
					    TFLayoutLMForTokenClassification,
					    TFLayoutLMModel,
					)


class       __SCREAMING_SNAKE_CASE   :






						def __init__(		self       ,  _UpperCamelCase       ,  _UpperCamelCase=13       ,  _UpperCamelCase=7       ,  _UpperCamelCase=True       ,  _UpperCamelCase=True       ,  _UpperCamelCase=True       ,  _UpperCamelCase=True       ,  _UpperCamelCase=99       ,  _UpperCamelCase=32       ,  _UpperCamelCase=2       ,  _UpperCamelCase=4       ,  _UpperCamelCase=37       ,  _UpperCamelCase="gelu"       ,  _UpperCamelCase=0.1       ,  _UpperCamelCase=0.1       ,  _UpperCamelCase=5_12       ,  _UpperCamelCase=16       ,  _UpperCamelCase=2       ,  _UpperCamelCase=0.02       ,  _UpperCamelCase=3       ,  _UpperCamelCase=4       ,  _UpperCamelCase=None       ,  _UpperCamelCase=10_00       ,  ):






												"""simple docstring"""
												lowerCAmelCase__        =  parent
												lowerCAmelCase__        =  batch_size
												lowerCAmelCase__        =  seq_length
												lowerCAmelCase__        =  is_training
												lowerCAmelCase__        =  use_input_mask
												lowerCAmelCase__        =  use_token_type_ids
												lowerCAmelCase__        =  use_labels
												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__        =  type_vocab_size
												lowerCAmelCase__        =  type_sequence_label_size
												lowerCAmelCase__        =  initializer_range
												lowerCAmelCase__        =  num_labels
												lowerCAmelCase__        =  num_choices
												lowerCAmelCase__        =  scope
												lowerCAmelCase__        =  range_bbox






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  ids_tensor([self.batch_size, self.seq_length]       ,  self.vocab_size				)

												# convert bbox to numpy since TF does not support item assignment
												lowerCAmelCase__        =  ids_tensor([self.batch_size, self.seq_length, 4]       ,  self.range_bbox				).numpy()
												# Ensure that bbox is legal
												for i in range(bbox.shape[0]				):
																		for j in range(bbox.shape[1]				):
																								if bbox[i, j, 3] < bbox[i, j, 1]:
																														lowerCAmelCase__        =  bbox[i, j, 3]
																														lowerCAmelCase__        =  bbox[i, j, 1]
																														lowerCAmelCase__        =  t
																								if bbox[i, j, 2] < bbox[i, j, 0]:
																														lowerCAmelCase__        =  bbox[i, j, 2]
																														lowerCAmelCase__        =  bbox[i, j, 0]
																														lowerCAmelCase__        =  t
												lowerCAmelCase__        =  tf.convert_to_tensor(_snake_case				)

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

												lowerCAmelCase__        =  None
												if self.use_token_type_ids:
																		lowerCAmelCase__        =  ids_tensor([self.batch_size, self.seq_length]       ,  self.type_vocab_size				)

												lowerCAmelCase__        =  None
												lowerCAmelCase__        =  None
												lowerCAmelCase__        =  None
												if self.use_labels:
																		lowerCAmelCase__        =  ids_tensor([self.batch_size]       ,  self.type_sequence_label_size				)
																		lowerCAmelCase__        =  ids_tensor([self.batch_size, self.seq_length]       ,  self.num_labels				)
																		lowerCAmelCase__        =  ids_tensor([self.batch_size]       ,  self.num_choices				)

												lowerCAmelCase__        =  LayoutLMConfig(
												    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       ,  type_vocab_size=self.type_vocab_size       ,  initializer_range=self.initializer_range       ,  )

												return config, input_ids, bbox, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase				):






												"""simple docstring"""
												lowerCAmelCase__        =  TFLayoutLMModel(config=_snake_case				)

												lowerCAmelCase__        =  model(_snake_case       ,  _snake_case       ,  attention_mask=_snake_case       ,  token_type_ids=_snake_case				)
												lowerCAmelCase__        =  model(_snake_case       ,  _snake_case       ,  token_type_ids=_snake_case				)
												lowerCAmelCase__        =  model(_snake_case       ,  _snake_case				)
												self.parent.assertEqual(result.last_hidden_state.shape       ,  (self.batch_size, self.seq_length, self.hidden_size)				)
												self.parent.assertEqual(result.pooler_output.shape       ,  (self.batch_size, self.hidden_size)				)






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase				):






												"""simple docstring"""
												lowerCAmelCase__        =  TFLayoutLMForMaskedLM(config=_snake_case				)

												lowerCAmelCase__        =  model(_snake_case       ,  _snake_case       ,  attention_mask=_snake_case       ,  token_type_ids=_snake_case       ,  labels=_snake_case				)
												self.parent.assertEqual(result.logits.shape       ,  (self.batch_size, self.seq_length, self.vocab_size)				)






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.num_labels
												lowerCAmelCase__        =  TFLayoutLMForSequenceClassification(config=_snake_case				)

												lowerCAmelCase__        =  model(_snake_case       ,  _snake_case       ,  attention_mask=_snake_case       ,  token_type_ids=_snake_case				)
												self.parent.assertEqual(result.logits.shape       ,  (self.batch_size, self.num_labels)				)






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.num_labels
												lowerCAmelCase__        =  TFLayoutLMForTokenClassification(config=_snake_case				)

												lowerCAmelCase__        =  model(_snake_case       ,  _snake_case       ,  attention_mask=_snake_case       ,  token_type_ids=_snake_case       ,  labels=_snake_case				)
												self.parent.assertEqual(result.logits.shape       ,  (self.batch_size, self.seq_length, self.num_labels)				)






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase       ,  _UpperCamelCase				):






												"""simple docstring"""
												lowerCAmelCase__        =  TFLayoutLMForQuestionAnswering(config=_snake_case				)

												lowerCAmelCase__        =  model(_snake_case       ,  _snake_case       ,  attention_mask=_snake_case       ,  token_type_ids=_snake_case				)
												self.parent.assertEqual(result.start_logits.shape       ,  (self.batch_size, self.seq_length)				)
												self.parent.assertEqual(result.end_logits.shape       ,  (self.batch_size, self.seq_length)				)







						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.prepare_config_and_inputs()
												(
												    (
												    lowerCAmelCase__					
												)  ,    (
												    lowerCAmelCase__					
												)  ,    (
												    lowerCAmelCase__					
												)  ,    (
												    lowerCAmelCase__					
												)  ,    (
												    lowerCAmelCase__					
												)  ,    (
												    lowerCAmelCase__					
												)  ,    (
												    lowerCAmelCase__					
												)  ,    (
												    lowerCAmelCase__					
												)  ,    					
												)        =  config_and_inputs
												lowerCAmelCase__        =  {
												    'input_ids': input_ids,
												    'bbox': bbox,
												    'token_type_ids': token_type_ids,
												    'attention_mask': input_mask,
												}
												return config, inputs_dict




@require_tf
class       __SCREAMING_SNAKE_CASE   (				__lowercase						,   __lowercase						,   unittest.TestCase):
						_SCREAMING_SNAKE_CASE		:    Optional[Any]						=   (
						    (
						        TFLayoutLMModel,
						        TFLayoutLMForMaskedLM,
						        TFLayoutLMForTokenClassification,
						        TFLayoutLMForSequenceClassification,
						        TFLayoutLMForQuestionAnswering,
						    )
						    if is_tf_available()
						    else ()
						)
						_SCREAMING_SNAKE_CASE		:    Dict						=   (
						    {
						        '''feature-extraction''': TFLayoutLMModel,
						        '''fill-mask''': TFLayoutLMForMaskedLM,
						        '''text-classification''': TFLayoutLMForSequenceClassification,
						        '''token-classification''': TFLayoutLMForTokenClassification,
						        '''zero-shot''': TFLayoutLMForSequenceClassification,
						    }
						    if is_tf_available()
						    else {}
						)
						_SCREAMING_SNAKE_CASE		:    Optional[Any]						=   False
						_SCREAMING_SNAKE_CASE		:    Union[str, Any]						=   True
						_SCREAMING_SNAKE_CASE		:    str						=   10






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  TFLayoutLMModelTester(self				)
												lowerCAmelCase__        =  ConfigTester(self       ,  config_class=_snake_case       ,  hidden_size=37				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												self.config_tester.run_common_tests()






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*_snake_case				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_masked_lm(*_snake_case				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_sequence_classification(*_snake_case				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_token_classification(*_snake_case				)






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_question_answering(*_snake_case				)






						@slow
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""




												for model_name in TF_LAYOUTLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		lowerCAmelCase__        =  TFLayoutLMModel.from_pretrained(_snake_case				)
																		self.assertIsNotNone(_snake_case				)







						@unittest.skip('Onnx compliancy broke with TF 2.10'				)
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												pass







def 		_UpperCamelCase				(      )					->				Union[str, Any]:

						"""simple docstring"""



						lowerCAmelCase__        =  tf.convert_to_tensor([[101,1019,1014,1016,1037,1_2849,4747,1004,1_4246,2278,5439,4524,5002,2930,2193,2930,4341,3208,1005,1055,2171,2848,1_1300,3531,102],[101,4070,4034,7020,1024,3058,1015,1013,2861,1013,6070,1_9274,2772,6205,2_7814,1_6147,1_6147,4343,2047,1_0283,1_0969,1_4389,1012,2338,102]]						)  # noqa: E231
						lowerCAmelCase__        =  tf.convert_to_tensor([[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],]						)  # noqa: E231
						lowerCAmelCase__        =  tf.convert_to_tensor([[[0,0,0,0],[423,237,440,251],[427,272,441,287],[419,115,437,129],[961,885,992,912],[256,38,330,58],[256,38,330,58],[336,42,353,57],[360,39,401,56],[360,39,401,56],[411,39,471,59],[479,41,528,59],[533,39,630,60],[67,113,134,131],[141,115,209,132],[68,149,133,166],[141,149,187,164],[195,148,287,165],[195,148,287,165],[195,148,287,165],[295,148,349,165],[441,149,492,166],[497,149,546,164],[64,201,125,218],[1000,1000,1000,1000]],[[0,0,0,0],[662,150,754,166],[665,199,742,211],[519,213,554,228],[519,213,554,228],[134,433,187,454],[130,467,204,480],[130,467,204,480],[130,467,204,480],[130,467,204,480],[130,467,204,480],[314,469,376,482],[504,684,582,706],[941,825,973,900],[941,825,973,900],[941,825,973,900],[941,825,973,900],[610,749,652,765],[130,659,168,672],[176,657,237,672],[238,657,312,672],[443,653,628,672],[443,653,628,672],[716,301,825,317],[1000,1000,1000,1000]]]						)  # noqa: E231
						lowerCAmelCase__        =  tf.convert_to_tensor([[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0],[0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0]]						)  # noqa: E231
						# these are sequence labels (i.e. at the token level)
						lowerCAmelCase__        =  tf.convert_to_tensor([[-100,10,10,10,9,1,-100,7,7,-100,7,7,4,2,5,2,8,8,-100,-100,5,0,3,2,-100],[-100,12,12,12,-100,12,10,-100,-100,-100,-100,10,12,9,-100,-100,-100,10,10,10,9,12,-100,10,-100]]						)  # noqa: E231
						# fmt: on

						return input_ids, attention_mask, bbox, token_type_ids, labels


@require_tf
class       __SCREAMING_SNAKE_CASE   (				unittest.TestCase):






						@slow
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  TFLayoutLMModel.from_pretrained('microsoft/layoutlm-base-uncased'				)

												lowerCAmelCase__  ,    lowerCAmelCase__  ,    lowerCAmelCase__  ,    lowerCAmelCase__  ,    lowerCAmelCase__        =  prepare_layoutlm_batch_inputs()

												# forward pass
												lowerCAmelCase__        =  model(input_ids=_snake_case       ,  bbox=_snake_case       ,  attention_mask=_snake_case       ,  token_type_ids=_snake_case				)

												# test the sequence output on [0, :3, :3]
												lowerCAmelCase__        =  tf.convert_to_tensor(
												    [[0.17_85, -0.19_47, -0.04_25], [-0.32_54, -0.28_07, 0.25_53], [-0.53_91, -0.33_22, 0.33_64]]       ,  )

												self.assertTrue(np.allclose(outputs.last_hidden_state[0, :3, :3]       ,  _snake_case       ,  atol=1E-3				)				)

												# test the pooled output on [1, :3]
												lowerCAmelCase__        =  tf.convert_to_tensor([-0.65_80, -0.02_14, 0.85_52]				)

												self.assertTrue(np.allclose(outputs.pooler_output[1, :3]       ,  _snake_case       ,  atol=1E-3				)				)






						@slow
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  TFLayoutLMForSequenceClassification.from_pretrained('microsoft/layoutlm-base-uncased'       ,  num_labels=2				)

												lowerCAmelCase__  ,    lowerCAmelCase__  ,    lowerCAmelCase__  ,    lowerCAmelCase__  ,    lowerCAmelCase__        =  prepare_layoutlm_batch_inputs()

												# forward pass
												lowerCAmelCase__        =  model(
												    input_ids=_snake_case       ,  bbox=_snake_case       ,  attention_mask=_snake_case       ,  token_type_ids=_snake_case       ,  labels=tf.convert_to_tensor([1, 1]				)       ,  )

												# test whether we get a loss as a scalar
												lowerCAmelCase__        =  outputs.loss
												lowerCAmelCase__        =  (2,)
												self.assertEqual(loss.shape       ,  _snake_case				)

												# test the shape of the logits
												lowerCAmelCase__        =  outputs.logits
												lowerCAmelCase__        =  (2, 2)
												self.assertEqual(logits.shape       ,  _snake_case				)






						@slow
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  TFLayoutLMForTokenClassification.from_pretrained('microsoft/layoutlm-base-uncased'       ,  num_labels=13				)

												lowerCAmelCase__  ,    lowerCAmelCase__  ,    lowerCAmelCase__  ,    lowerCAmelCase__  ,    lowerCAmelCase__        =  prepare_layoutlm_batch_inputs()

												# forward pass
												lowerCAmelCase__        =  model(
												    input_ids=_snake_case       ,  bbox=_snake_case       ,  attention_mask=_snake_case       ,  token_type_ids=_snake_case       ,  labels=_snake_case				)

												# test the shape of the logits
												lowerCAmelCase__        =  outputs.logits
												lowerCAmelCase__        =  tf.convert_to_tensor((2, 25, 13)				)
												self.assertEqual(logits.shape       ,  _snake_case				)







						@slow
						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												lowerCAmelCase__        =  TFLayoutLMForQuestionAnswering.from_pretrained('microsoft/layoutlm-base-uncased'				)

												lowerCAmelCase__  ,    lowerCAmelCase__  ,    lowerCAmelCase__  ,    lowerCAmelCase__  ,    lowerCAmelCase__        =  prepare_layoutlm_batch_inputs()

												# forward pass
												lowerCAmelCase__        =  model(input_ids=_snake_case       ,  bbox=_snake_case       ,  attention_mask=_snake_case       ,  token_type_ids=_snake_case				)

												# test the shape of the logits
												lowerCAmelCase__        =  tf.convert_to_tensor((2, 25)				)
												self.assertEqual(outputs.start_logits.shape       ,  _snake_case				)
												self.assertEqual(outputs.end_logits.shape       ,  _snake_case				)













# Copyright 2023 The HuggingFace Inc. team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import torch

from ..models.speechta import SpeechTaForTextToSpeech, SpeechTaHifiGan, SpeechTaProcessor
from ..utils import is_datasets_available
from .base import PipelineTool


if is_datasets_available():
					from datasets import load_dataset


class       __SCREAMING_SNAKE_CASE   (				__lowercase):
						_SCREAMING_SNAKE_CASE		:    List[Any]						=   '''microsoft/speecht5_tts'''
						_SCREAMING_SNAKE_CASE		:    Any						=   (
						    '''This is a tool that reads an English text out loud. It takes an input named `text` which should contain the '''
						    '''text to read (in English) and returns a waveform object containing the sound.'''
						)
						_SCREAMING_SNAKE_CASE		:    int						=   '''text_reader'''
						_SCREAMING_SNAKE_CASE		:    List[str]						=   SpeechTaProcessor
						_SCREAMING_SNAKE_CASE		:    Optional[int]						=   SpeechTaForTextToSpeech
						_SCREAMING_SNAKE_CASE		:    List[Any]						=   SpeechTaHifiGan

						_SCREAMING_SNAKE_CASE		:    Optional[int]						=   ['''text''']
						_SCREAMING_SNAKE_CASE		:    List[Any]						=   ['''audio''']






						def  UpperCamelCase__ (		self				):






												"""simple docstring"""
												if self.post_processor is None:
																		lowerCAmelCase__        =  'microsoft/speecht5_hifigan'
												super().setup()






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase       ,  _UpperCamelCase=None				):






												"""simple docstring"""
												lowerCAmelCase__        =  self.pre_processor(text=_UpperCamelCase       ,  return_tensors='pt'       ,  truncation=_UpperCamelCase				)

												if speaker_embeddings is None:
																		if not is_datasets_available():
																								raise ImportError('Datasets needs to be installed if not passing speaker embeddings.'				)

																		lowerCAmelCase__        =  load_dataset('Matthijs/cmu-arctic-xvectors'       ,  split='validation'				)
																		lowerCAmelCase__        =  torch.tensor(embeddings_dataset[73_05]['xvector']				).unsqueeze(0				)

												return {"input_ids": inputs["input_ids"], "speaker_embeddings": speaker_embeddings}






						def  UpperCamelCase__ (		self       ,  _UpperCamelCase				):






												"""simple docstring"""
												with torch.no_grad():
																		return self.model.generate_speech(**_UpperCamelCase				)







						def  UpperCamelCase__ (		self       ,  _UpperCamelCase				):






												"""simple docstring"""
												with torch.no_grad():
																		return self.post_processor(_UpperCamelCase				).cpu().detach()





