





import shutil
import tempfile
import unittest

import numpy as np

from transformers.testing_utils import (
    is_pt_tf_cross_test,
    require_tf,
    require_torch,
    require_torchvision,
    require_vision,
)
from transformers.utils import is_tf_available, is_torch_available, is_vision_available


if is_vision_available():
      from PIL import Image

      from transformers import AutoProcessor, SamImageProcessor, SamProcessor

if is_torch_available():
      import torch

if is_tf_available():
      import tensorflow as tf

@require_vision
@require_torchvision
class 		UpperCamelCase__			(				unittest.TestCase       ):



     '''simple docstring'''

     def     SCREAMING_SNAKE_CASE__  (							self						:   List[Any]	)					->		str:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						tempfile.mkdtemp()
           SCREAMING_SNAKE_CASE		=						SamImageProcessor()
           SCREAMING_SNAKE_CASE		=						SamProcessor(lowerCamelCase__	)
           processor.save_pretrained(self.tmpdirname	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   int						,**lowerCamelCase__						:   Any	)					->		Union[str, Any]:




           '''simple docstring'''


           return AutoProcessor.from_pretrained(self.tmpdirname						,**lowerCamelCase__	).image_processor






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




           '''simple docstring'''


           shutil.rmtree(self.tmpdirname	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   List[Any]	)					->		Dict:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						[np.random.randint(255						,size=(3, 30, 400)						,dtype=np.uinta	)]

           SCREAMING_SNAKE_CASE		=						[Image.fromarray(np.moveaxis(lowerCamelCase__						,0						,-1	)	) for x in image_inputs]

           return image_inputs






     def     SCREAMING_SNAKE_CASE__  (							self						:   Tuple	)					->		Optional[int]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						SamProcessor(image_processor=self.get_image_processor()	)
           processor.save_pretrained(self.tmpdirname	)

           SCREAMING_SNAKE_CASE		=						self.get_image_processor(do_normalize=lowerCamelCase__						,padding_value=1.0	)

           SCREAMING_SNAKE_CASE		=						SamProcessor.from_pretrained(self.tmpdirname						,do_normalize=lowerCamelCase__						,padding_value=1.0	)

           self.assertEqual(processor.image_processor.to_json_string()						,image_processor_add_kwargs.to_json_string()	)
           self.assertIsInstance(processor.image_processor						,lowerCamelCase__	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   Any	)					->		List[str]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.get_image_processor()

           SCREAMING_SNAKE_CASE		=						SamProcessor(image_processor=lowerCamelCase__	)

           SCREAMING_SNAKE_CASE		=						self.prepare_image_inputs()

           SCREAMING_SNAKE_CASE		=						image_processor(lowerCamelCase__						,return_tensors="""np"""	)
           SCREAMING_SNAKE_CASE		=						processor(images=lowerCamelCase__						,return_tensors="""np"""	)

           input_feat_extract.pop("""original_sizes"""	)  # pop original_sizes as it is popped in the processor
           input_feat_extract.pop("""reshaped_input_sizes"""	)  # pop original_sizes as it is popped in the processor

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






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




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.get_image_processor()

           SCREAMING_SNAKE_CASE		=						SamProcessor(image_processor=lowerCamelCase__	)
           SCREAMING_SNAKE_CASE		=						[torch.ones((1, 3, 5, 5)	)]

           SCREAMING_SNAKE_CASE		=						[[1764, 2646]]

           SCREAMING_SNAKE_CASE		=						[[683, 1024]]
           SCREAMING_SNAKE_CASE		=						processor.post_process_masks(lowerCamelCase__						,lowerCamelCase__						,lowerCamelCase__	)
           self.assertEqual(masks[0].shape						,(1, 3, 1764, 2646)	)

           SCREAMING_SNAKE_CASE		=						processor.post_process_masks(
               lowerCamelCase__						,torch.tensor(lowerCamelCase__	)						,torch.tensor(lowerCamelCase__	)	)
           self.assertEqual(masks[0].shape						,(1, 3, 1764, 2646)	)

           # should also work with np
           SCREAMING_SNAKE_CASE		=						[np.ones((1, 3, 5, 5)	)]
           SCREAMING_SNAKE_CASE		=						processor.post_process_masks(lowerCamelCase__						,np.array(lowerCamelCase__	)						,np.array(lowerCamelCase__	)	)

           self.assertEqual(masks[0].shape						,(1, 3, 1764, 2646)	)

           SCREAMING_SNAKE_CASE		=						[[1, 0], [0, 1]]
           with self.assertRaises(lowerCamelCase__	):
                 SCREAMING_SNAKE_CASE		=						processor.post_process_masks(lowerCamelCase__						,np.array(lowerCamelCase__	)						,np.array(lowerCamelCase__	)	)

@require_vision
@require_tf
class 		UpperCamelCase__			(				unittest.TestCase       ):



     '''simple docstring'''

     def     SCREAMING_SNAKE_CASE__  (							self						:   str	)					->		str:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						tempfile.mkdtemp()
           SCREAMING_SNAKE_CASE		=						SamImageProcessor()
           SCREAMING_SNAKE_CASE		=						SamProcessor(lowerCamelCase__	)
           processor.save_pretrained(self.tmpdirname	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   Dict						,**lowerCamelCase__						:   Optional[Any]	)					->		int:




           '''simple docstring'''


           return AutoProcessor.from_pretrained(self.tmpdirname						,**lowerCamelCase__	).image_processor






     def     SCREAMING_SNAKE_CASE__  (							self						:   int	)					->		List[Any]:




           '''simple docstring'''


           shutil.rmtree(self.tmpdirname	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   Optional[int]	)					->		Optional[int]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						[np.random.randint(255						,size=(3, 30, 400)						,dtype=np.uinta	)]

           SCREAMING_SNAKE_CASE		=						[Image.fromarray(np.moveaxis(lowerCamelCase__						,0						,-1	)	) for x in image_inputs]

           return image_inputs






     def     SCREAMING_SNAKE_CASE__  (							self						:   Optional[int]	)					->		Union[str, Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						SamProcessor(image_processor=self.get_image_processor()	)
           processor.save_pretrained(self.tmpdirname	)

           SCREAMING_SNAKE_CASE		=						self.get_image_processor(do_normalize=lowerCamelCase__						,padding_value=1.0	)

           SCREAMING_SNAKE_CASE		=						SamProcessor.from_pretrained(self.tmpdirname						,do_normalize=lowerCamelCase__						,padding_value=1.0	)

           self.assertEqual(processor.image_processor.to_json_string()						,image_processor_add_kwargs.to_json_string()	)
           self.assertIsInstance(processor.image_processor						,lowerCamelCase__	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   List[Any]	)					->		Union[str, Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.get_image_processor()

           SCREAMING_SNAKE_CASE		=						SamProcessor(image_processor=lowerCamelCase__	)

           SCREAMING_SNAKE_CASE		=						self.prepare_image_inputs()

           SCREAMING_SNAKE_CASE		=						image_processor(lowerCamelCase__						,return_tensors="""np"""	)
           SCREAMING_SNAKE_CASE		=						processor(images=lowerCamelCase__						,return_tensors="""np"""	)

           input_feat_extract.pop("""original_sizes"""	)  # pop original_sizes as it is popped in the processor
           input_feat_extract.pop("""reshaped_input_sizes"""	)  # pop reshaped_input_sizes as it is popped in the processor

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






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




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.get_image_processor()

           SCREAMING_SNAKE_CASE		=						SamProcessor(image_processor=lowerCamelCase__	)
           SCREAMING_SNAKE_CASE		=						[tf.ones((1, 3, 5, 5)	)]

           SCREAMING_SNAKE_CASE		=						[[1764, 2646]]

           SCREAMING_SNAKE_CASE		=						[[683, 1024]]
           SCREAMING_SNAKE_CASE		=						processor.post_process_masks(lowerCamelCase__						,lowerCamelCase__						,lowerCamelCase__						,return_tensors="""tf"""	)
           self.assertEqual(masks[0].shape						,(1, 3, 1764, 2646)	)

           SCREAMING_SNAKE_CASE		=						processor.post_process_masks(
               lowerCamelCase__						,tf.convert_to_tensor(lowerCamelCase__	)						,tf.convert_to_tensor(lowerCamelCase__	)						,return_tensors="""tf"""						,)
           self.assertEqual(masks[0].shape						,(1, 3, 1764, 2646)	)

           # should also work with np
           SCREAMING_SNAKE_CASE		=						[np.ones((1, 3, 5, 5)	)]
           SCREAMING_SNAKE_CASE		=						processor.post_process_masks(
               lowerCamelCase__						,np.array(lowerCamelCase__	)						,np.array(lowerCamelCase__	)						,return_tensors="""tf"""	)

           self.assertEqual(masks[0].shape						,(1, 3, 1764, 2646)	)

           SCREAMING_SNAKE_CASE		=						[[1, 0], [0, 1]]
           with self.assertRaises(tf.errors.InvalidArgumentError	):
                 SCREAMING_SNAKE_CASE		=						processor.post_process_masks(
                     lowerCamelCase__						,np.array(lowerCamelCase__	)						,np.array(lowerCamelCase__	)						,return_tensors="""tf"""	)

@require_vision
@require_torchvision
class 		UpperCamelCase__			(				unittest.TestCase       ):



     '''simple docstring'''

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




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						tempfile.mkdtemp()
           SCREAMING_SNAKE_CASE		=						SamImageProcessor()
           SCREAMING_SNAKE_CASE		=						SamProcessor(lowerCamelCase__	)
           processor.save_pretrained(self.tmpdirname	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   Any						,**lowerCamelCase__						:   Optional[int]	)					->		List[str]:




           '''simple docstring'''


           return AutoProcessor.from_pretrained(self.tmpdirname						,**lowerCamelCase__	).image_processor






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




           '''simple docstring'''


           shutil.rmtree(self.tmpdirname	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   Optional[Any]	)					->		Any:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						[np.random.randint(255						,size=(3, 30, 400)						,dtype=np.uinta	)]

           SCREAMING_SNAKE_CASE		=						[Image.fromarray(np.moveaxis(lowerCamelCase__						,0						,-1	)	) for x in image_inputs]

           return image_inputs






     @is_pt_tf_cross_test
     def     SCREAMING_SNAKE_CASE__  (							self						:   Any	)					->		List[str]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.get_image_processor()

           SCREAMING_SNAKE_CASE		=						SamProcessor(image_processor=lowerCamelCase__	)
           SCREAMING_SNAKE_CASE		=						np.random.randint(0						,2						,size=(1, 3, 5, 5)	).astype(np.floataa	)
           SCREAMING_SNAKE_CASE		=						[tf.convert_to_tensor(lowerCamelCase__	)]
           SCREAMING_SNAKE_CASE		=						[torch.tensor(lowerCamelCase__	)]

           SCREAMING_SNAKE_CASE		=						[[1764, 2646]]

           SCREAMING_SNAKE_CASE		=						[[683, 1024]]
           SCREAMING_SNAKE_CASE		=						processor.post_process_masks(
               lowerCamelCase__						,lowerCamelCase__						,lowerCamelCase__						,return_tensors="""tf"""	)
           SCREAMING_SNAKE_CASE		=						processor.post_process_masks(
               lowerCamelCase__						,lowerCamelCase__						,lowerCamelCase__						,return_tensors="""pt"""	)

           self.assertTrue(np.all(tf_masks[0].numpy() == pt_masks[0].numpy()	)	)






     @is_pt_tf_cross_test
     def     SCREAMING_SNAKE_CASE__  (							self						:   Union[str, Any]	)					->		int:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.get_image_processor()

           SCREAMING_SNAKE_CASE		=						SamProcessor(image_processor=lowerCamelCase__	)

           SCREAMING_SNAKE_CASE		=						self.prepare_image_inputs()

           SCREAMING_SNAKE_CASE		=						image_processor(lowerCamelCase__						,return_tensors="""pt"""	)["""pixel_values"""].numpy()
           SCREAMING_SNAKE_CASE		=						processor(images=lowerCamelCase__						,return_tensors="""pt"""	)["""pixel_values"""].numpy()

           SCREAMING_SNAKE_CASE		=						image_processor(lowerCamelCase__						,return_tensors="""tf"""	)["""pixel_values"""].numpy()
           SCREAMING_SNAKE_CASE		=						processor(images=lowerCamelCase__						,return_tensors="""tf"""	)["""pixel_values"""].numpy()

           self.assertTrue(np.allclose(lowerCamelCase__						,lowerCamelCase__	)	)
           self.assertTrue(np.allclose(lowerCamelCase__						,lowerCamelCase__	)	)
           self.assertTrue(np.allclose(lowerCamelCase__						,lowerCamelCase__	)	)









def        __lowercase       (				_SCREAMING_SNAKE_CASE = 50     )			->       int:


      '''simple docstring'''


      SCREAMING_SNAKE_CASE		=						[1] * (length + 1)

      for row_length in range(3			,						length + 1     ):
            for block_length in range(3			,						row_length + 1     ):
                  for block_start in range(row_length - block_length     ):
                        ways_number[row_length] += ways_number[
                            row_length - block_start - block_length - 1
                        ]

                  ways_number[row_length] += 1

      return ways_number[length]


if __name__ == "__main__":
      print(F'''{solution() = }''')


