

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





    def       snake_case_				(      self):
         lowercase__    :   Optional[int]      =       {
             'task_specific_params': {
                 'summarization': {'length_penalty': 1.0, 'max_length': 128, 'min_length': 12, 'num_beams': 4},
                 'summarization_cnn': {'length_penalty': 2.0, 'max_length': 142, 'min_length': 56, 'num_beams': 4},
                 'summarization_xsum': {'length_penalty': 1.0, 'max_length': 62, 'min_length': 11, 'num_beams': 6},
             }
         }
         lowercase__    :   Union[str, Any]      =       {
             'task_specific_params.summarization.length_penalty': 1.0,
             'task_specific_params.summarization.max_length': 128,
             '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': 142,
             '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(a)						,   a)





    def       snake_case_				(      self):
         lowercase__    :   Any      =       np.random.randn(3						,   4)
         self.assertTrue(np.allclose(transpose(a)						,   x.transpose()))

         lowercase__    :   Any      =       np.random.randn(3						,   4						,   5)
         self.assertTrue(np.allclose(transpose(a						,   axes=(1, 2, 0))						,   x.transpose((1, 2, 0))))





    @require_torch
    def       snake_case_				(      self):
         lowercase__    :   str      =       np.random.randn(3						,   4)
         lowercase__    :   int      =       torch.tensor(a)
         self.assertTrue(np.allclose(transpose(a)						,   transpose(a).numpy()))

         lowercase__    :   Any      =       np.random.randn(3						,   4						,   5)
         lowercase__    :   Optional[Any]      =       torch.tensor(a)
         self.assertTrue(np.allclose(transpose(a						,   axes=(1, 2, 0))						,   transpose(a						,   axes=(1, 2, 0)).numpy()))





    @require_tf
    def       snake_case_				(      self):
         lowercase__    :   Dict      =       np.random.randn(3						,   4)
         lowercase__    :   List[str]      =       tf.constant(a)
         self.assertTrue(np.allclose(transpose(a)						,   transpose(a).numpy()))

         lowercase__    :   Any      =       np.random.randn(3						,   4						,   5)
         lowercase__    :   str      =       tf.constant(a)
         self.assertTrue(np.allclose(transpose(a						,   axes=(1, 2, 0))						,   transpose(a						,   axes=(1, 2, 0)).numpy()))





    @require_flax
    def       snake_case_				(      self):
         lowercase__    :   Tuple      =       np.random.randn(3						,   4)
         lowercase__    :   Optional[Any]      =       jnp.array(a)
         self.assertTrue(np.allclose(transpose(a)						,   np.asarray(transpose(a))))

         lowercase__    :   Optional[int]      =       np.random.randn(3						,   4						,   5)
         lowercase__    :   Optional[Any]      =       jnp.array(a)
         self.assertTrue(np.allclose(transpose(a						,   axes=(1, 2, 0))						,   np.asarray(transpose(a						,   axes=(1, 2, 0)))))





    def       snake_case_				(      self):
         lowercase__    :   Any      =       np.random.randn(3						,   4)
         self.assertTrue(np.allclose(reshape(a						,   (4, 3))						,   np.reshape(a						,   (4, 3))))

         lowercase__    :   Union[str, Any]      =       np.random.randn(3						,   4						,   5)
         self.assertTrue(np.allclose(reshape(a						,   (12, 5))						,   np.reshape(a						,   (12, 5))))





    @require_torch
    def       snake_case_				(      self):
         lowercase__    :   List[str]      =       np.random.randn(3						,   4)
         lowercase__    :   Optional[int]      =       torch.tensor(a)
         self.assertTrue(np.allclose(reshape(a						,   (4, 3))						,   reshape(a						,   (4, 3)).numpy()))

         lowercase__    :   str      =       np.random.randn(3						,   4						,   5)
         lowercase__    :   List[str]      =       torch.tensor(a)
         self.assertTrue(np.allclose(reshape(a						,   (12, 5))						,   reshape(a						,   (12, 5)).numpy()))





    @require_tf
    def       snake_case_				(      self):
         lowercase__    :   Tuple      =       np.random.randn(3						,   4)
         lowercase__    :   Dict      =       tf.constant(a)
         self.assertTrue(np.allclose(reshape(a						,   (4, 3))						,   reshape(a						,   (4, 3)).numpy()))

         lowercase__    :   str      =       np.random.randn(3						,   4						,   5)
         lowercase__    :   List[str]      =       tf.constant(a)
         self.assertTrue(np.allclose(reshape(a						,   (12, 5))						,   reshape(a						,   (12, 5)).numpy()))





    @require_flax
    def       snake_case_				(      self):
         lowercase__    :   Optional[int]      =       np.random.randn(3						,   4)
         lowercase__    :   Union[str, Any]      =       jnp.array(a)
         self.assertTrue(np.allclose(reshape(a						,   (4, 3))						,   np.asarray(reshape(a						,   (4, 3)))))

         lowercase__    :   List[str]      =       np.random.randn(3						,   4						,   5)
         lowercase__    :   Tuple      =       jnp.array(a)
         self.assertTrue(np.allclose(reshape(a						,   (12, 5))						,   np.asarray(reshape(a						,   (12, 5)))))





    def       snake_case_				(      self):
         lowercase__    :   Optional[Any]      =       np.random.randn(1						,   3						,   4)
         self.assertTrue(np.allclose(squeeze(a)						,   np.squeeze(a)))

         lowercase__    :   Union[str, Any]      =       np.random.randn(1						,   4						,   1						,   5)
         self.assertTrue(np.allclose(squeeze(a						,   axis=2)						,   np.squeeze(a						,   axis=2)))





    @require_torch
    def       snake_case_				(      self):
         lowercase__    :   int      =       np.random.randn(1						,   3						,   4)
         lowercase__    :   Any      =       torch.tensor(a)
         self.assertTrue(np.allclose(squeeze(a)						,   squeeze(a).numpy()))

         lowercase__    :   int      =       np.random.randn(1						,   4						,   1						,   5)
         lowercase__    :   List[Any]      =       torch.tensor(a)
         self.assertTrue(np.allclose(squeeze(a						,   axis=2)						,   squeeze(a						,   axis=2).numpy()))





    @require_tf
    def       snake_case_				(      self):
         lowercase__    :   Optional[Any]      =       np.random.randn(1						,   3						,   4)
         lowercase__    :   Union[str, Any]      =       tf.constant(a)
         self.assertTrue(np.allclose(squeeze(a)						,   squeeze(a).numpy()))

         lowercase__    :   Union[str, Any]      =       np.random.randn(1						,   4						,   1						,   5)
         lowercase__    :   List[str]      =       tf.constant(a)
         self.assertTrue(np.allclose(squeeze(a						,   axis=2)						,   squeeze(a						,   axis=2).numpy()))





    @require_flax
    def       snake_case_				(      self):
         lowercase__    :   Optional[int]      =       np.random.randn(1						,   3						,   4)
         lowercase__    :   int      =       jnp.array(a)
         self.assertTrue(np.allclose(squeeze(a)						,   np.asarray(squeeze(a))))

         lowercase__    :   Tuple      =       np.random.randn(1						,   4						,   1						,   5)
         lowercase__    :   Optional[int]      =       jnp.array(a)
         self.assertTrue(np.allclose(squeeze(a						,   axis=2)						,   np.asarray(squeeze(a						,   axis=2))))





    def       snake_case_				(      self):
         lowercase__    :   Optional[int]      =       np.random.randn(3						,   4)
         self.assertTrue(np.allclose(expand_dims(a						,   axis=1)						,   np.expand_dims(a						,   axis=1)))





    @require_torch
    def       snake_case_				(      self):
         lowercase__    :   Optional[Any]      =       np.random.randn(3						,   4)
         lowercase__    :   List[str]      =       torch.tensor(a)
         self.assertTrue(np.allclose(expand_dims(a						,   axis=1)						,   expand_dims(a						,   axis=1).numpy()))





    @require_tf
    def       snake_case_				(      self):
         lowercase__    :   Optional[Any]      =       np.random.randn(3						,   4)
         lowercase__    :   Union[str, Any]      =       tf.constant(a)
         self.assertTrue(np.allclose(expand_dims(a						,   axis=1)						,   expand_dims(a						,   axis=1).numpy()))





    @require_flax
    def       snake_case_				(      self):
         lowercase__    :   Optional[Any]      =       np.random.randn(3						,   4)
         lowercase__    :   Union[str, Any]      =       jnp.array(a)
         self.assertTrue(np.allclose(expand_dims(a						,   axis=1)						,   np.asarray(expand_dims(a						,   axis=1))))




import unittest

from transformers import DonutProcessor


snake_case_			  = '''naver-clova-ix/donut-base'''


class       SCREAMING_SNAKE_CASE__					(unittest.TestCase     ):





    def       snake_case_				(      self):
         lowercase__    :   Dict      =       DonutProcessor.from_pretrained(a)





    def       snake_case_				(      self):
         lowercase__    :   Tuple      =       {
             'name': 'John Doe',
             'age': '99',
             'city': 'Atlanta',
             'state': 'GA',
             'zip': '30301',
             'phone': '123-4567',
             'nicknames': [{'nickname': 'Johnny'}, {'nickname': 'JD'}],
         }

         lowercase__    :   Tuple      =       (
             '<s_name>John Doe</s_name><s_age>99</s_age><s_city>Atlanta</s_city>'
             '<s_state>GA</s_state><s_zip>30301</s_zip><s_phone>123-4567</s_phone>'
             '<s_nicknames><s_nickname>Johnny</s_nickname>'
             '<sep/><s_nickname>JD</s_nickname></s_nicknames>'
         )
         lowercase__    :   str      =       self.processor.tokenajson(a)

         self.assertDictEqual(a						,   a)

