


'''simple docstring'''



import asyncio
import os
import shutil
import subprocess
import sys
import tempfile
import unittest
from distutils.util import strtobool
from functools import partial
from pathlib import Path
from typing import List, Union
from unittest import mock

import torch

from ..state import AcceleratorState, PartialState
from ..utils import (
    gather,
    is_bnb_available,
    is_comet_ml_available,
    is_datasets_available,
    is_deepspeed_available,
    is_mps_available,
    is_safetensors_available,
    is_tensorboard_available,
    is_torch_version,
    is_tpu_available,
    is_transformers_available,
    is_wandb_available,
    is_xpu_available,
)






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   Dict						,      _SCREAMING_SNAKE_CASE      :   Any=False   ):
					try:
										__a			:       Optional[int]					    =  os.environ[key]
					except KeyError:
										# KEY isn't set, default to `default`.
										__a			:       Dict					    =  default
					else:
										# KEY is set, convert it to True or False.
										try:
															__a			:       Any					    =  strtobool(_SCREAMING_SNAKE_CASE   )
										except ValueError:
															# More values are supported, but let's keep the message simple.
															raise ValueError(F"""If set, {key} must be yes or no."""   )
					return _value


__lowercase	:						Tuple       =	parse_flag_from_env('RUN_SLOW', default=False)






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   Union[str, Any]   ):
					return unittest.skip('Test was skipped'   )(_SCREAMING_SNAKE_CASE   )






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   Dict   ):
					return unittest.skipUnless(_run_slow_tests						,      'test is slow'   )(_SCREAMING_SNAKE_CASE   )






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   List[Any]   ):
					return unittest.skipUnless(not torch.cuda.is_available()						,      'test requires only a CPU'   )(_SCREAMING_SNAKE_CASE   )






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   List[Any]   ):
					return unittest.skipUnless(torch.cuda.is_available()						,      'test requires a GPU'   )(_SCREAMING_SNAKE_CASE   )






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   Tuple   ):
					return unittest.skipUnless(is_xpu_available()						,      'test requires a XPU'   )(_SCREAMING_SNAKE_CASE   )






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   Tuple   ):
					return unittest.skipUnless(is_mps_available()						,      'test requires a `mps` backend support in `torch`'   )(_SCREAMING_SNAKE_CASE   )






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   int   ):
					return unittest.skipUnless(
					    is_transformers_available() and is_datasets_available()						,      'test requires the Hugging Face suite'   )(_SCREAMING_SNAKE_CASE   )






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   Tuple   ):
					return unittest.skipUnless(is_bnb_available()						,      'test requires the bitsandbytes library'   )(_SCREAMING_SNAKE_CASE   )






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   Any   ):
					return unittest.skipUnless(is_tpu_available()						,      'test requires TPU'   )(_SCREAMING_SNAKE_CASE   )






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   str   ):
					return unittest.skipUnless(torch.cuda.device_count() == 1						,      'test requires a GPU'   )(_SCREAMING_SNAKE_CASE   )






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   Tuple   ):
					return unittest.skipUnless(torch.xpu.device_count() == 1						,      'test requires a XPU'   )(_SCREAMING_SNAKE_CASE   )






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   Any   ):
					return unittest.skipUnless(torch.cuda.device_count() > 1						,      'test requires multiple GPUs'   )(_SCREAMING_SNAKE_CASE   )






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   Dict   ):
					return unittest.skipUnless(torch.xpu.device_count() > 1						,      'test requires multiple XPUs'   )(_SCREAMING_SNAKE_CASE   )






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   List[str]   ):
					return unittest.skipUnless(is_safetensors_available()						,      'test requires safetensors'   )(_SCREAMING_SNAKE_CASE   )






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   List[Any]   ):
					return unittest.skipUnless(is_deepspeed_available()						,      'test requires DeepSpeed'   )(_SCREAMING_SNAKE_CASE   )






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   Any   ):
					return unittest.skipUnless(is_torch_version('>='						,      '1.12.0'   )						,      'test requires torch version >= 1.12.0'   )(_SCREAMING_SNAKE_CASE   )






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   Union[str, Any]=None						,      _SCREAMING_SNAKE_CASE      :   int=None   ):
					if test_case is None:
										return partial(_SCREAMING_SNAKE_CASE						,      version=_SCREAMING_SNAKE_CASE   )
					return unittest.skipUnless(is_torch_version('>='						,      _SCREAMING_SNAKE_CASE   )						,      F"""test requires torch version >= {version}"""   )(_SCREAMING_SNAKE_CASE   )






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   Tuple   ):
					return unittest.skipUnless(is_tensorboard_available()						,      'test requires Tensorboard'   )(_SCREAMING_SNAKE_CASE   )






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   List[Any]   ):
					return unittest.skipUnless(is_wandb_available()						,      'test requires wandb'   )(_SCREAMING_SNAKE_CASE   )






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   Union[str, Any]   ):
					return unittest.skipUnless(is_comet_ml_available()						,      'test requires comet_ml'   )(_SCREAMING_SNAKE_CASE   )


__lowercase	:						Optional[Any]       =	(
    any([is_wandb_available(), is_tensorboard_available()]) and not is_comet_ml_available()
)






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   List[Any]   ):
					return unittest.skipUnless(
					    _atleast_one_tracker_available						,      'test requires at least one tracker to be available and for `comet_ml` to not be installed'						,      )(_SCREAMING_SNAKE_CASE   )





class 							__UpperCamelCase				(		unittest.TestCase					):
	A_				=    True




	@classmethod
	def       __UpperCAmelCase							(   cls							):

						'''simple docstring'''





						__a			:       int					    =  tempfile.mkdtemp()




	@classmethod
	def       __UpperCAmelCase							(   cls							):

						'''simple docstring'''





						if os.path.exists(cls.tmpdir							):
											shutil.rmtree(cls.tmpdir							)





	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						if self.clear_on_setup:
											for path in Path(self.tmpdir							).glob('**/*'							):
																if path.is_file():
																					path.unlink()
																elif path.is_dir():
																					shutil.rmtree(__a							)





class 							__UpperCamelCase				(		unittest.TestCase					):




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						super().tearDown()
						# Reset the state of the AcceleratorState singleton.
						AcceleratorState._reset_state()
						PartialState._reset_state()





class 							__UpperCamelCase				(		unittest.TestCase					):




	def       __UpperCAmelCase							(   self						,				__a							):

						'''simple docstring'''





						__a			:       Union[str, Any]					    =  mocks if isinstance(__a						,				(tuple, list)							) else [mocks]
						for m in self.mocks:
											m.start()
											self.addCleanup(m.stop							)






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   List[str]   ):
					__a			:       str					    =  AcceleratorState()
					__a			:       List[str]					    =  tensor[None].clone().to(state.device   )
					__a			:       List[str]					    =  gather(_SCREAMING_SNAKE_CASE   ).cpu()
					__a			:       List[str]					    =  tensor[0].cpu()
					for i in range(tensors.shape[0]   ):
										if not torch.equal(tensors[i]						,      _SCREAMING_SNAKE_CASE   ):
															return False
					return True





class 							__UpperCamelCase				:




	def __init__(   self						,				__a						,				__a						,				__a							):

						'''simple docstring'''





						__a			:       List[Any]					    =  returncode
						__a			:       List[str]					    =  stdout
						__a			:       Optional[Any]					    =  stderr






async def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   Dict						,      _SCREAMING_SNAKE_CASE      :   Union[str, Any]   ):
					while True:
										__a			:       Dict					    =  await stream.readline()
										if line:
															callback(_SCREAMING_SNAKE_CASE   )
										else:
															break






async def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   int						,      _SCREAMING_SNAKE_CASE      :   int=None						,      _SCREAMING_SNAKE_CASE      :   Dict=None						,      _SCREAMING_SNAKE_CASE      :   Dict=None						,      _SCREAMING_SNAKE_CASE      :   List[Any]=False						,      _SCREAMING_SNAKE_CASE      :   str=False   ):
					if echo:
										print('\nRunning: '						,      ' '.join(_SCREAMING_SNAKE_CASE   )   )

					__a			:       Dict					    =  await asyncio.create_subprocess_exec(
					    cmd[0]						,      *cmd[1:]						,      stdin=_SCREAMING_SNAKE_CASE						,      stdout=asyncio.subprocess.PIPE						,      stderr=asyncio.subprocess.PIPE						,      env=_SCREAMING_SNAKE_CASE						,      )

					# note: there is a warning for a possible deadlock when using `wait` with huge amounts of data in the pipe
					# https://docs.python.org/3/library/asyncio-subprocess.html#asyncio.asyncio.subprocess.Process.wait
					#
					# If it starts hanging, will need to switch to the following code. The problem is that no data
					# will be seen until it's done and if it hangs for example there will be no debug info.
					# out, err = await p.communicate()
					# return _RunOutput(p.returncode, out, err)

					__a			:       Optional[Any]					    =  []
					__a			:       Union[str, Any]					    =  []

					def tee(_SCREAMING_SNAKE_CASE      :   Any						,      _SCREAMING_SNAKE_CASE      :   Union[str, Any]						,      _SCREAMING_SNAKE_CASE      :   int						,      _SCREAMING_SNAKE_CASE      :   Dict=""   ):
										__a			:       Union[str, Any]					    =  line.decode('utf-8'   ).rstrip()
										sink.append(_SCREAMING_SNAKE_CASE   )
										if not quiet:
															print(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      file=_SCREAMING_SNAKE_CASE   )

    # XXX: the timeout doesn't seem to make any difference here
					await asyncio.wait(
					    [
					        asyncio.create_task(_read_stream(p.stdout						,      lambda _SCREAMING_SNAKE_CASE   : tee(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      sys.stdout						,      label='stdout:'   )   )   ),
					        asyncio.create_task(_read_stream(p.stderr						,      lambda _SCREAMING_SNAKE_CASE   : tee(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      sys.stderr						,      label='stderr:'   )   )   ),
					    ]						,      timeout=_SCREAMING_SNAKE_CASE						,      )
					return _RunOutput(await p.wait()						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   Dict						,      _SCREAMING_SNAKE_CASE      :   Any=None						,      _SCREAMING_SNAKE_CASE      :   int=None						,      _SCREAMING_SNAKE_CASE      :   Dict=180						,      _SCREAMING_SNAKE_CASE      :   Optional[int]=False						,      _SCREAMING_SNAKE_CASE      :   int=True   ):
					__a			:       Optional[int]					    =  asyncio.get_event_loop()
					__a			:       Union[str, Any]					    =  loop.run_until_complete(
					    _stream_subprocess(_SCREAMING_SNAKE_CASE						,      env=_SCREAMING_SNAKE_CASE						,      stdin=_SCREAMING_SNAKE_CASE						,      timeout=_SCREAMING_SNAKE_CASE						,      quiet=_SCREAMING_SNAKE_CASE						,      echo=_SCREAMING_SNAKE_CASE   )   )

					__a			:       Tuple					    =  ' '.join(_SCREAMING_SNAKE_CASE   )
					if result.returncode > 0:
										__a			:       Union[str, Any]					    =  '\n'.join(result.stderr   )
										raise RuntimeError(
										    F"""'{cmd_str}' failed with returncode {result.returncode}\n\n"""
										    F"""The combined stderr from workers follows:\n{stderr}"""   )

					return result





class 							__UpperCamelCase				(		lowerCAmelCase_					):
	pass






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   List[str]						,      _SCREAMING_SNAKE_CASE      :   List[Any]=False   ):
					try:
										__a			:       List[Any]					    =  subprocess.check_output(_SCREAMING_SNAKE_CASE						,      stderr=subprocess.STDOUT   )
										if return_stdout:
															if hasattr(_SCREAMING_SNAKE_CASE						,      'decode'   ):
																				__a			:       List[Any]					    =  output.decode('utf-8'   )
															return output
					except subprocess.CalledProcessError as e:
										raise SubprocessCallException(
										    F"""Command `{" ".join(_SCREAMING_SNAKE_CASE   )}` failed with the following error:\n\n{e.output.decode()}"""   ) from e







'''simple docstring'''



from __future__ import annotations

import copy
import inspect
import unittest

import numpy as np

from transformers import is_tf_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_tf, slow
from transformers.utils import cached_property

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


if is_tf_available():
	import tensorflow as tf

	from transformers import (
	    TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST,
	    TF_MODEL_FOR_MULTIPLE_CHOICE_MAPPING,
	    TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
	    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
	    TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
	    LayoutLMvaConfig,
	    TFLayoutLMvaForQuestionAnswering,
	    TFLayoutLMvaForSequenceClassification,
	    TFLayoutLMvaForTokenClassification,
	    TFLayoutLMvaModel,
	)

if is_vision_available():
	from PIL import Image

	from transformers import LayoutLMvaImageProcessor





class 							__UpperCamelCase				:




	def __init__(   self						,				__a						,				__a=2						,				__a=3						,				__a=4						,				__a=2						,				__a=7						,				__a=True						,				__a=True						,				__a=True						,				__a=True						,				__a=99						,				__a=36						,				__a=2						,				__a=4						,				__a=37						,				__a="gelu"						,				__a=0.1						,				__a=0.1						,				__a=512						,				__a=16						,				__a=2						,				__a=0.02						,				__a=6						,				__a=6						,				__a=3						,				__a=4						,				__a=None						,				__a=1000						,				):

						'''simple docstring'''





						__a			:       Optional[Any]					    =  parent
						__a			:       int					    =  batch_size
						__a			:       Any					    =  num_channels
						__a			:       Optional[int]					    =  image_size
						__a			:       Dict					    =  patch_size
						__a			:       int					    =  is_training
						__a			:       Union[str, Any]					    =  use_input_mask
						__a			:       Optional[int]					    =  use_token_type_ids
						__a			:       Dict					    =  use_labels
						__a			:       str					    =  vocab_size
						__a			:       List[Any]					    =  hidden_size
						__a			:       Union[str, Any]					    =  num_hidden_layers
						__a			:       str					    =  num_attention_heads
						__a			:       Union[str, Any]					    =  intermediate_size
						__a			:       Any					    =  hidden_act
						__a			:       List[str]					    =  hidden_dropout_prob
						__a			:       List[str]					    =  attention_probs_dropout_prob
						__a			:       List[Any]					    =  max_position_embeddings
						__a			:       Tuple					    =  type_vocab_size
						__a			:       Any					    =  type_sequence_label_size
						__a			:       Optional[int]					    =  initializer_range
						__a			:       Any					    =  coordinate_size
						__a			:       List[Any]					    =  shape_size
						__a			:       Optional[int]					    =  num_labels
						__a			:       Dict					    =  num_choices
						__a			:       Union[str, Any]					    =  scope
						__a			:       Union[str, Any]					    =  range_bbox

						# LayoutLMv3's sequence length equals the number of text tokens + number of patches + 1 (we add 1 for the CLS token)
						__a			:       Optional[int]					    =  text_seq_length
						__a			:       Any					    =  (image_size // patch_size) ** 2 + 1
						__a			:       Dict					    =  self.text_seq_length + self.image_seq_length




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						__a			:       str					    =  ids_tensor([self.batch_size, self.text_seq_length]						,				self.vocab_size							)

						__a			:       Tuple					    =  ids_tensor([self.batch_size, self.text_seq_length, 4]						,				self.range_bbox							)
						__a			:       Any					    =  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]:
																					__a			:       List[Any]					    =  bbox[i, j, 3]
																					__a			:       Tuple					    =  bbox[i, j, 1]
																					__a			:       str					    =  tmp_coordinate
																if bbox[i, j, 2] < bbox[i, j, 0]:
																					__a			:       int					    =  bbox[i, j, 2]
																					__a			:       Dict					    =  bbox[i, j, 0]
																					__a			:       int					    =  tmp_coordinate
						__a			:       Optional[int]					    =  tf.constant(__a							)

						__a			:       Dict					    =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]							)

						__a			:       str					    =  None
						if self.use_input_mask:
											__a			:       Optional[Any]					    =  random_attention_mask([self.batch_size, self.text_seq_length]							)

						__a			:       str					    =  None
						if self.use_token_type_ids:
											__a			:       List[Any]					    =  ids_tensor([self.batch_size, self.text_seq_length]						,				self.type_vocab_size							)

						__a			:       Optional[Any]					    =  None
						__a			:       Optional[int]					    =  None
						if self.use_labels:
											__a			:       List[Any]					    =  ids_tensor([self.batch_size]						,				self.type_sequence_label_size							)
											__a			:       Optional[int]					    =  ids_tensor([self.batch_size, self.text_seq_length]						,				self.num_labels							)

						__a			:       int					    =  LayoutLMvaConfig(
						    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						,				coordinate_size=self.coordinate_size						,				shape_size=self.shape_size						,				input_size=self.image_size						,				patch_size=self.patch_size						,				)

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




	def       __UpperCAmelCase							(   self						,				__a						,				__a						,				__a						,				__a						,				__a						,				__a							):

						'''simple docstring'''





						__a			:       Dict					    =  TFLayoutLMvaModel(config=__a							)

						# text + image
						__a			:       List[Any]					    =  model(__a						,				pixel_values=__a						,				training=__a							)
						__a			:       Any					    =  model(
						    __a						,				bbox=__a						,				pixel_values=__a						,				attention_mask=__a						,				token_type_ids=__a						,				training=__a						,				)
						__a			:       Optional[int]					    =  model(__a						,				bbox=__a						,				pixel_values=__a						,				training=__a							)

						self.parent.assertEqual(result.last_hidden_state.shape						,				(self.batch_size, self.seq_length, self.hidden_size)							)

						# text only
						__a			:       Any					    =  model(__a						,				training=__a							)
						self.parent.assertEqual(
						    result.last_hidden_state.shape						,				(self.batch_size, self.text_seq_length, self.hidden_size)							)

						# image only
						__a			:       str					    =  model({'pixel_values': pixel_values}						,				training=__a							)
						self.parent.assertEqual(
						    result.last_hidden_state.shape						,				(self.batch_size, self.image_seq_length, self.hidden_size)							)




	def       __UpperCAmelCase							(   self						,				__a						,				__a						,				__a						,				__a						,				__a						,				__a						,				__a							):

						'''simple docstring'''





						__a			:       Any					    =  self.num_labels
						__a			:       Dict					    =  TFLayoutLMvaForSequenceClassification(config=__a							)
						__a			:       List[str]					    =  model(
						    __a						,				bbox=__a						,				pixel_values=__a						,				attention_mask=__a						,				token_type_ids=__a						,				labels=__a						,				training=__a						,				)
						self.parent.assertEqual(result.logits.shape						,				(self.batch_size, self.num_labels)							)




	def       __UpperCAmelCase							(   self						,				__a						,				__a						,				__a						,				__a						,				__a						,				__a						,				__a							):

						'''simple docstring'''





						__a			:       str					    =  self.num_labels
						__a			:       Optional[Any]					    =  TFLayoutLMvaForTokenClassification(config=__a							)
						__a			:       List[str]					    =  model(
						    __a						,				bbox=__a						,				pixel_values=__a						,				attention_mask=__a						,				token_type_ids=__a						,				labels=__a						,				training=__a						,				)
						self.parent.assertEqual(result.logits.shape						,				(self.batch_size, self.text_seq_length, self.num_labels)							)




	def       __UpperCAmelCase							(   self						,				__a						,				__a						,				__a						,				__a						,				__a						,				__a						,				__a							):

						'''simple docstring'''





						__a			:       List[Any]					    =  2
						__a			:       Any					    =  TFLayoutLMvaForQuestionAnswering(config=__a							)
						__a			:       Any					    =  model(
						    __a						,				bbox=__a						,				pixel_values=__a						,				attention_mask=__a						,				token_type_ids=__a						,				start_positions=__a						,				end_positions=__a						,				training=__a						,				)
						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'''





						__a			:       Dict					    =  self.prepare_config_and_inputs()
						((__a)    ,				(__a)    ,				(__a)    ,				(__a)    ,				(__a)    ,				(__a)    ,				(__a)    ,				(__a))			:       Dict					    =  config_and_inputs
						__a			:       Any					    =  {
						    'input_ids': input_ids,
						    'bbox': bbox,
						    'pixel_values': pixel_values,
						    'token_type_ids': token_type_ids,
						    'attention_mask': input_mask,
						}
						return config, inputs_dict





@require_tf
class 							__UpperCamelCase				(		lowerCAmelCase_		,      lowerCAmelCase_		,      unittest.TestCase					):
	A_				=    (
	    (
	        TFLayoutLMvaModel,
	        TFLayoutLMvaForQuestionAnswering,
	        TFLayoutLMvaForSequenceClassification,
	        TFLayoutLMvaForTokenClassification,
	    )
	    if is_tf_available()
	    else ()
	)
	A_				=    (
	    {"document-question-answering": TFLayoutLMvaForQuestionAnswering, "feature-extraction": TFLayoutLMvaModel}
	    if is_tf_available()
	    else {}
	)

	A_				=    False
	A_				=    False
	A_				=    False




	def       __UpperCAmelCase							(   self						,				__a						,				__a						,				__a						,				__a						,				__a							):

						'''simple docstring'''





						return True




	def       __UpperCAmelCase							(   self						,				__a						,				__a						,				__a=False							):

						'''simple docstring'''





						__a			:       str					    =  copy.deepcopy(__a							)

						if model_class in get_values(__a							):
											__a			:       str					    =  {
											    k: tf.tile(tf.expand_dims(__a						,				1							)						,				(1, self.model_tester.num_choices) + (1,) * (v.ndim - 1)							)
											    if isinstance(__a						,				tf.Tensor							) and v.ndim > 0
											    else v
											    for k, v in inputs_dict.items()
											}

						if return_labels:
											if model_class in get_values(__a							):
																__a			:       Optional[int]					    =  tf.ones(self.model_tester.batch_size						,				dtype=tf.intaa							)
											elif model_class in get_values(__a							):
																__a			:       int					    =  tf.zeros(self.model_tester.batch_size						,				dtype=tf.intaa							)
																__a			:       Optional[Any]					    =  tf.zeros(self.model_tester.batch_size						,				dtype=tf.intaa							)
											elif model_class in get_values(__a							):
																__a			:       Any					    =  tf.zeros(self.model_tester.batch_size						,				dtype=tf.intaa							)
											elif model_class in get_values(__a							):
																__a			:       Union[str, Any]					    =  tf.zeros(
																    (self.model_tester.batch_size, self.model_tester.text_seq_length)						,				dtype=tf.intaa							)

						return inputs_dict




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						__a			:       Optional[Any]					    =  TFLayoutLMvaModelTester(self							)
						__a			:       Optional[int]					    =  ConfigTester(self						,				config_class=__a						,				hidden_size=37							)




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						self.config_tester.run_common_tests()




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						__a    ,				__a			:       Dict					    =  self.model_tester.prepare_config_and_inputs_for_common()
						for model_class in self.all_model_classes:
											__a			:       Dict					    =  model_class(__a							)
											if getattr(__a						,				'hf_compute_loss'						,				__a							):
																# The number of elements in the loss should be the same as the number of elements in the label
																__a			:       Union[str, Any]					    =  self._prepare_for_class(inputs_dict.copy()						,				__a						,				return_labels=__a							)
																__a			:       str					    =  prepared_for_class[
																    sorted(prepared_for_class.keys() - inputs_dict.keys()						,				reverse=__a							)[0]
																]
																__a			:       Dict					    =  added_label.shape.as_list()[:1]

																# Test that model correctly compute the loss with kwargs
																__a			:       int					    =  self._prepare_for_class(inputs_dict.copy()						,				__a						,				return_labels=__a							)
																__a			:       Dict					    =  prepared_for_class.pop('input_ids'							)

																__a			:       Tuple					    =  model(__a						,				**__a							)[0]
																self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1]							)

																# Test that model correctly compute the loss when we mask some positions
																__a			:       int					    =  self._prepare_for_class(inputs_dict.copy()						,				__a						,				return_labels=__a							)
																__a			:       str					    =  prepared_for_class.pop('input_ids'							)
																if "labels" in prepared_for_class:
																					__a			:       Union[str, Any]					    =  prepared_for_class['labels'].numpy()
																					if len(labels.shape							) > 1 and labels.shape[1] != 1:
																										__a			:       List[Any]					    =  -100
																										__a			:       List[str]					    =  tf.convert_to_tensor(__a							)
																										__a			:       Any					    =  model(__a						,				**__a							)[0]
																										self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1]							)
																										self.assertTrue(not np.any(np.isnan(loss.numpy()							)							)							)

                # Test that model correctly compute the loss with a dict
																__a			:       Union[str, Any]					    =  self._prepare_for_class(inputs_dict.copy()						,				__a						,				return_labels=__a							)
																__a			:       str					    =  model(__a							)[0]
																self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1]							)

																# Test that model correctly compute the loss with a tuple
																__a			:       Tuple					    =  self._prepare_for_class(inputs_dict.copy()						,				__a						,				return_labels=__a							)

																# Get keys that were added with the _prepare_for_class function
																__a			:       Dict					    =  prepared_for_class.keys() - inputs_dict.keys()
																__a			:       Any					    =  inspect.signature(model.call							).parameters
																__a			:       str					    =  list(signature.keys()							)

																# Create a dictionary holding the location of the tensors in the tuple
																__a			:       List[Any]					    =  {0: 'input_ids'}
																for label_key in label_keys:
																					__a			:       List[Any]					    =  signature_names.index(__a							)
																					__a			:       Union[str, Any]					    =  label_key
																__a			:       List[str]					    =  sorted(tuple_index_mapping.items()							)
																# Initialize a list with their default values, update the values and convert to a tuple
																__a			:       Union[str, Any]					    =  []

																for name in signature_names:
																					if name != "kwargs":
																										list_input.append(signature[name].default							)

																for index, value in sorted_tuple_index_mapping:
																					__a			:       Optional[Any]					    =  prepared_for_class[value]

																__a			:       str					    =  tuple(__a							)

																# Send to model
																__a			:       Tuple					    =  model(tuple_input[:-1]							)[0]

																self.assertTrue(loss.shape.as_list() == expected_loss_size or loss.shape.as_list() == [1]							)




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						(
						    (
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				
						)			:       Optional[int]					    =  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(__a						,				__a						,				__a						,				__a						,				__a						,				__a							)




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						(
						    (
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				
						)			:       Dict					    =  self.model_tester.prepare_config_and_inputs()
						for type in ["absolute", "relative_key", "relative_key_query"]:
											__a			:       Any					    =  type
											self.model_tester.create_and_check_model(__a						,				__a						,				__a						,				__a						,				__a						,				__a							)




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						(
						    (
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				
						)			:       List[str]					    =  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_sequence_classification(
						    __a						,				__a						,				__a						,				__a						,				__a						,				__a						,				__a							)




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						(
						    (
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				
						)			:       Optional[Any]					    =  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_token_classification(
						    __a						,				__a						,				__a						,				__a						,				__a						,				__a						,				__a							)




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						(
						    (
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				(
						    __a
						)    ,				
						)			:       int					    =  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_question_answering(
						    __a						,				__a						,				__a						,				__a						,				__a						,				__a						,				__a							)





	@slow
	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						for model_name in TF_LAYOUTLMV3_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
											__a			:       List[Any]					    =  TFLayoutLMvaModel.from_pretrained(__a							)
											self.assertIsNotNone(__a							)






def   lowerCamelCase							():
					__a			:       Optional[Any]					    =  Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'   )
					return image





@require_tf
class 							__UpperCamelCase				(		unittest.TestCase					):




	@cached_property
	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						return LayoutLMvaImageProcessor(apply_ocr=__a							) if is_vision_available() else None





	@slow
	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						__a			:       str					    =  TFLayoutLMvaModel.from_pretrained('microsoft/layoutlmv3-base'							)

						__a			:       Tuple					    =  self.default_image_processor
						__a			:       List[Any]					    =  prepare_img()
						__a			:       int					    =  image_processor(images=__a						,				return_tensors='tf'							).pixel_values

						__a			:       Union[str, Any]					    =  tf.constant([[1, 2]]							)
						__a			:       Optional[Any]					    =  tf.expand_dims(tf.constant([[1, 2, 3, 4], [5, 6, 7, 8]]							)						,				axis=0							)

						# forward pass
						__a			:       Tuple					    =  model(input_ids=__a						,				bbox=__a						,				pixel_values=__a						,				training=__a							)

						# verify the logits
						__a			:       List[Any]					    =  (1, 199, 768)
						self.assertEqual(outputs.last_hidden_state.shape						,				__a							)

						__a			:       Optional[Any]					    =  tf.constant(
						    [[-0.0529, 0.3618, 0.1632], [-0.1587, -0.1667, -0.0400], [-0.1557, -0.1671, -0.0505]]							)

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



