





import unittest

import numpy as np

from transformers.testing_utils import require_flax, require_tf, require_torch
from transformers.utils import (
    expand_dims,
    flatten_dict,
    is_flax_available,
    is_tf_available,
    is_torch_available,
    reshape,
    squeeze,
    transpose,
)


if is_flax_available():
					import jax.numpy as jnp

if is_tf_available():
					import tensorflow as tf

if is_torch_available():
					import torch


class     A     (unittest.TestCase       ):
			'''simple docstring'''




			def   a_			(     self  :       int  )      ->      Any:







					"""simple docstring"""






					A__     =  {
					    """task_specific_params""": {
					        """summarization""": {"""length_penalty""": 1.0, """max_length""": 1_28, """min_length""": 12, """num_beams""": 4},
					        """summarization_cnn""": {"""length_penalty""": 2.0, """max_length""": 1_42, """min_length""": 56, """num_beams""": 4},
					        """summarization_xsum""": {"""length_penalty""": 1.0, """max_length""": 62, """min_length""": 11, """num_beams""": 6},
					    }
					}
					A__     =  {
					    """task_specific_params.summarization.length_penalty""": 1.0,
					    """task_specific_params.summarization.max_length""": 1_28,
					    """task_specific_params.summarization.min_length""": 12,
					    """task_specific_params.summarization.num_beams""": 4,
					    """task_specific_params.summarization_cnn.length_penalty""": 2.0,
					    """task_specific_params.summarization_cnn.max_length""": 1_42,
					    """task_specific_params.summarization_cnn.min_length""": 56,
					    """task_specific_params.summarization_cnn.num_beams""": 4,
					    """task_specific_params.summarization_xsum.length_penalty""": 1.0,
					    """task_specific_params.summarization_xsum.max_length""": 62,
					    """task_specific_params.summarization_xsum.min_length""": 11,
					    """task_specific_params.summarization_xsum.num_beams""": 6,
					}

					self.assertEqual(flatten_dict(__lowerCAmelCase  )				,      __lowerCAmelCase  )






			def   a_			(     self  :       str  )      ->      Optional[Any]:







					"""simple docstring"""






					A__     =  np.random.randn(3				,      4  )
					self.assertTrue(np.allclose(transpose(__lowerCAmelCase  )				,      x.transpose()  )  )

					A__     =  np.random.randn(3				,      4				,      5  )
					self.assertTrue(np.allclose(transpose(__lowerCAmelCase				,      axes=(1, 2, 0)  )				,      x.transpose((1, 2, 0)  )  )  )






			@require_torch
			def   a_			(     self  :       int  )      ->      List[Any]:







					"""simple docstring"""






					A__     =  np.random.randn(3				,      4  )
					A__     =  torch.tensor(__lowerCAmelCase  )
					self.assertTrue(np.allclose(transpose(__lowerCAmelCase  )				,      transpose(__lowerCAmelCase  ).numpy()  )  )

					A__     =  np.random.randn(3				,      4				,      5  )
					A__     =  torch.tensor(__lowerCAmelCase  )
					self.assertTrue(np.allclose(transpose(__lowerCAmelCase				,      axes=(1, 2, 0)  )				,      transpose(__lowerCAmelCase				,      axes=(1, 2, 0)  ).numpy()  )  )






			@require_tf
			def   a_			(     self  :       Dict  )      ->      List[Any]:







					"""simple docstring"""






					A__     =  np.random.randn(3				,      4  )
					A__     =  tf.constant(__lowerCAmelCase  )
					self.assertTrue(np.allclose(transpose(__lowerCAmelCase  )				,      transpose(__lowerCAmelCase  ).numpy()  )  )

					A__     =  np.random.randn(3				,      4				,      5  )
					A__     =  tf.constant(__lowerCAmelCase  )
					self.assertTrue(np.allclose(transpose(__lowerCAmelCase				,      axes=(1, 2, 0)  )				,      transpose(__lowerCAmelCase				,      axes=(1, 2, 0)  ).numpy()  )  )






			@require_flax
			def   a_			(     self  :       str  )      ->      List[Any]:







					"""simple docstring"""






					A__     =  np.random.randn(3				,      4  )
					A__     =  jnp.array(__lowerCAmelCase  )
					self.assertTrue(np.allclose(transpose(__lowerCAmelCase  )				,      np.asarray(transpose(__lowerCAmelCase  )  )  )  )

					A__     =  np.random.randn(3				,      4				,      5  )
					A__     =  jnp.array(__lowerCAmelCase  )
					self.assertTrue(np.allclose(transpose(__lowerCAmelCase				,      axes=(1, 2, 0)  )				,      np.asarray(transpose(__lowerCAmelCase				,      axes=(1, 2, 0)  )  )  )  )






			def   a_			(     self  :       Tuple  )      ->      Any:







					"""simple docstring"""






					A__     =  np.random.randn(3				,      4  )
					self.assertTrue(np.allclose(reshape(__lowerCAmelCase				,      (4, 3)  )				,      np.reshape(__lowerCAmelCase				,      (4, 3)  )  )  )

					A__     =  np.random.randn(3				,      4				,      5  )
					self.assertTrue(np.allclose(reshape(__lowerCAmelCase				,      (12, 5)  )				,      np.reshape(__lowerCAmelCase				,      (12, 5)  )  )  )






			@require_torch
			def   a_			(     self  :       Tuple  )      ->      Any:







					"""simple docstring"""






					A__     =  np.random.randn(3				,      4  )
					A__     =  torch.tensor(__lowerCAmelCase  )
					self.assertTrue(np.allclose(reshape(__lowerCAmelCase				,      (4, 3)  )				,      reshape(__lowerCAmelCase				,      (4, 3)  ).numpy()  )  )

					A__     =  np.random.randn(3				,      4				,      5  )
					A__     =  torch.tensor(__lowerCAmelCase  )
					self.assertTrue(np.allclose(reshape(__lowerCAmelCase				,      (12, 5)  )				,      reshape(__lowerCAmelCase				,      (12, 5)  ).numpy()  )  )






			@require_tf
			def   a_			(     self  :       List[Any]  )      ->      Dict:







					"""simple docstring"""






					A__     =  np.random.randn(3				,      4  )
					A__     =  tf.constant(__lowerCAmelCase  )
					self.assertTrue(np.allclose(reshape(__lowerCAmelCase				,      (4, 3)  )				,      reshape(__lowerCAmelCase				,      (4, 3)  ).numpy()  )  )

					A__     =  np.random.randn(3				,      4				,      5  )
					A__     =  tf.constant(__lowerCAmelCase  )
					self.assertTrue(np.allclose(reshape(__lowerCAmelCase				,      (12, 5)  )				,      reshape(__lowerCAmelCase				,      (12, 5)  ).numpy()  )  )






			@require_flax
			def   a_			(     self  :       List[str]  )      ->      Any:







					"""simple docstring"""






					A__     =  np.random.randn(3				,      4  )
					A__     =  jnp.array(__lowerCAmelCase  )
					self.assertTrue(np.allclose(reshape(__lowerCAmelCase				,      (4, 3)  )				,      np.asarray(reshape(__lowerCAmelCase				,      (4, 3)  )  )  )  )

					A__     =  np.random.randn(3				,      4				,      5  )
					A__     =  jnp.array(__lowerCAmelCase  )
					self.assertTrue(np.allclose(reshape(__lowerCAmelCase				,      (12, 5)  )				,      np.asarray(reshape(__lowerCAmelCase				,      (12, 5)  )  )  )  )






			def   a_			(     self  :       List[str]  )      ->      Optional[int]:







					"""simple docstring"""






					A__     =  np.random.randn(1				,      3				,      4  )
					self.assertTrue(np.allclose(squeeze(__lowerCAmelCase  )				,      np.squeeze(__lowerCAmelCase  )  )  )

					A__     =  np.random.randn(1				,      4				,      1				,      5  )
					self.assertTrue(np.allclose(squeeze(__lowerCAmelCase				,      axis=2  )				,      np.squeeze(__lowerCAmelCase				,      axis=2  )  )  )






			@require_torch
			def   a_			(     self  :       Any  )      ->      int:







					"""simple docstring"""






					A__     =  np.random.randn(1				,      3				,      4  )
					A__     =  torch.tensor(__lowerCAmelCase  )
					self.assertTrue(np.allclose(squeeze(__lowerCAmelCase  )				,      squeeze(__lowerCAmelCase  ).numpy()  )  )

					A__     =  np.random.randn(1				,      4				,      1				,      5  )
					A__     =  torch.tensor(__lowerCAmelCase  )
					self.assertTrue(np.allclose(squeeze(__lowerCAmelCase				,      axis=2  )				,      squeeze(__lowerCAmelCase				,      axis=2  ).numpy()  )  )






			@require_tf
			def   a_			(     self  :       int  )      ->      Optional[int]:







					"""simple docstring"""






					A__     =  np.random.randn(1				,      3				,      4  )
					A__     =  tf.constant(__lowerCAmelCase  )
					self.assertTrue(np.allclose(squeeze(__lowerCAmelCase  )				,      squeeze(__lowerCAmelCase  ).numpy()  )  )

					A__     =  np.random.randn(1				,      4				,      1				,      5  )
					A__     =  tf.constant(__lowerCAmelCase  )
					self.assertTrue(np.allclose(squeeze(__lowerCAmelCase				,      axis=2  )				,      squeeze(__lowerCAmelCase				,      axis=2  ).numpy()  )  )






			@require_flax
			def   a_			(     self  :       int  )      ->      Union[str, Any]:







					"""simple docstring"""






					A__     =  np.random.randn(1				,      3				,      4  )
					A__     =  jnp.array(__lowerCAmelCase  )
					self.assertTrue(np.allclose(squeeze(__lowerCAmelCase  )				,      np.asarray(squeeze(__lowerCAmelCase  )  )  )  )

					A__     =  np.random.randn(1				,      4				,      1				,      5  )
					A__     =  jnp.array(__lowerCAmelCase  )
					self.assertTrue(np.allclose(squeeze(__lowerCAmelCase				,      axis=2  )				,      np.asarray(squeeze(__lowerCAmelCase				,      axis=2  )  )  )  )






			def   a_			(     self  :       Optional[Any]  )      ->      List[Any]:







					"""simple docstring"""






					A__     =  np.random.randn(3				,      4  )
					self.assertTrue(np.allclose(expand_dims(__lowerCAmelCase				,      axis=1  )				,      np.expand_dims(__lowerCAmelCase				,      axis=1  )  )  )






			@require_torch
			def   a_			(     self  :       List[Any]  )      ->      Any:







					"""simple docstring"""






					A__     =  np.random.randn(3				,      4  )
					A__     =  torch.tensor(__lowerCAmelCase  )
					self.assertTrue(np.allclose(expand_dims(__lowerCAmelCase				,      axis=1  )				,      expand_dims(__lowerCAmelCase				,      axis=1  ).numpy()  )  )






			@require_tf
			def   a_			(     self  :       int  )      ->      Optional[Any]:







					"""simple docstring"""






					A__     =  np.random.randn(3				,      4  )
					A__     =  tf.constant(__lowerCAmelCase  )
					self.assertTrue(np.allclose(expand_dims(__lowerCAmelCase				,      axis=1  )				,      expand_dims(__lowerCAmelCase				,      axis=1  ).numpy()  )  )







			@require_flax
			def   a_			(     self  :       Optional[Any]  )      ->      Union[str, Any]:







					"""simple docstring"""






					A__     =  np.random.randn(3				,      4  )
					A__     =  jnp.array(__lowerCAmelCase  )
					self.assertTrue(np.allclose(expand_dims(__lowerCAmelCase				,      axis=1  )				,      np.asarray(expand_dims(__lowerCAmelCase				,      axis=1  )  )  )  )










from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_sentencepiece_available,
    is_tokenizers_available,
    is_torch_available,
    is_vision_available,
)


A       :   Dict					= {'''processing_layoutxlm''': ['''LayoutXLMProcessor''']}

try:
					if not is_sentencepiece_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					A       :   Dict					= ['''LayoutXLMTokenizer''']

try:
					if not is_tokenizers_available():
										raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
					pass
else:
					A       :   Dict					= ['''LayoutXLMTokenizerFast''']

if TYPE_CHECKING:
					from .processing_layoutxlm import LayoutXLMProcessor

					try:
										if not is_sentencepiece_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_layoutxlm import LayoutXLMTokenizer

					try:
										if not is_tokenizers_available():
															raise OptionalDependencyNotAvailable()
					except OptionalDependencyNotAvailable:
										pass
					else:
										from .tokenization_layoutxlm_fast import LayoutXLMTokenizerFast

else:
					import sys

					A       :   int					= _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)



