
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 		lowercase__    (		unittest.TestCase    ):
	def 	A_							(     self				:  List[Any]				):
						SCREAMING_SNAKE_CASE__						=					tempfile.mkdtemp()
						SCREAMING_SNAKE_CASE__						=					SamImageProcessor()
						SCREAMING_SNAKE_CASE__						=					SamProcessor(UpperCAmelCase_				)
						processor.save_pretrained(self.tmpdirname				)
	def 	A_							(     self				:  str			,  **UpperCAmelCase_				:  Optional[int]				):
						return AutoProcessor.from_pretrained(self.tmpdirname			,  **UpperCAmelCase_				).image_processor
	def 	A_							(     self				:  int				):
						shutil.rmtree(self.tmpdirname				)
	def 	A_							(     self				:  Optional[int]				):
						SCREAMING_SNAKE_CASE__						=					[np.random.randint(255			,  size=(3, 30, 400)			,  dtype=np.uinta				)]

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

						return image_inputs
	def 	A_							(     self				:  Optional[Any]				):
						SCREAMING_SNAKE_CASE__						=					SamProcessor(image_processor=self.get_image_processor()				)
						processor.save_pretrained(self.tmpdirname				)

						SCREAMING_SNAKE_CASE__						=					self.get_image_processor(do_normalize=UpperCAmelCase_			,  padding_value=1.0				)

						SCREAMING_SNAKE_CASE__						=					SamProcessor.from_pretrained(self.tmpdirname			,  do_normalize=UpperCAmelCase_			,  padding_value=1.0				)

						self.assertEqual(processor.image_processor.to_json_string()			,  image_processor_add_kwargs.to_json_string()				)
						self.assertIsInstance(processor.image_processor			,  UpperCAmelCase_				)
	def 	A_							(     self				:  Optional[int]				):
						SCREAMING_SNAKE_CASE__						=					self.get_image_processor()

						SCREAMING_SNAKE_CASE__						=					SamProcessor(image_processor=UpperCAmelCase_				)

						SCREAMING_SNAKE_CASE__						=					self.prepare_image_inputs()

						SCREAMING_SNAKE_CASE__						=					image_processor(UpperCAmelCase_			,  return_tensors='np'				)
						SCREAMING_SNAKE_CASE__						=					processor(images=UpperCAmelCase_			,  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 	A_							(     self				:  List[Any]				):
						SCREAMING_SNAKE_CASE__						=					self.get_image_processor()

						SCREAMING_SNAKE_CASE__						=					SamProcessor(image_processor=UpperCAmelCase_				)
						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(UpperCAmelCase_			,  UpperCAmelCase_			,  UpperCAmelCase_				)
						self.assertEqual(masks[0].shape			,  (1, 3, 1764, 2646)				)

						SCREAMING_SNAKE_CASE__						=					processor.post_process_masks(
						    UpperCAmelCase_			,  torch.tensor(UpperCAmelCase_				)			,  torch.tensor(UpperCAmelCase_				)				)
						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(UpperCAmelCase_			,  np.array(UpperCAmelCase_				)			,  np.array(UpperCAmelCase_				)				)

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

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





@require_vision
@require_tf
class 		lowercase__    (		unittest.TestCase    ):
	def 	A_							(     self				:  List[Any]				):
						SCREAMING_SNAKE_CASE__						=					tempfile.mkdtemp()
						SCREAMING_SNAKE_CASE__						=					SamImageProcessor()
						SCREAMING_SNAKE_CASE__						=					SamProcessor(UpperCAmelCase_				)
						processor.save_pretrained(self.tmpdirname				)
	def 	A_							(     self				:  int			,  **UpperCAmelCase_				:  List[Any]				):
						return AutoProcessor.from_pretrained(self.tmpdirname			,  **UpperCAmelCase_				).image_processor
	def 	A_							(     self				:  Optional[int]				):
						shutil.rmtree(self.tmpdirname				)
	def 	A_							(     self				:  int				):
						SCREAMING_SNAKE_CASE__						=					[np.random.randint(255			,  size=(3, 30, 400)			,  dtype=np.uinta				)]

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

						return image_inputs
	def 	A_							(     self				:  Union[str, Any]				):
						SCREAMING_SNAKE_CASE__						=					SamProcessor(image_processor=self.get_image_processor()				)
						processor.save_pretrained(self.tmpdirname				)

						SCREAMING_SNAKE_CASE__						=					self.get_image_processor(do_normalize=UpperCAmelCase_			,  padding_value=1.0				)

						SCREAMING_SNAKE_CASE__						=					SamProcessor.from_pretrained(self.tmpdirname			,  do_normalize=UpperCAmelCase_			,  padding_value=1.0				)

						self.assertEqual(processor.image_processor.to_json_string()			,  image_processor_add_kwargs.to_json_string()				)
						self.assertIsInstance(processor.image_processor			,  UpperCAmelCase_				)
	def 	A_							(     self				:  Optional[int]				):
						SCREAMING_SNAKE_CASE__						=					self.get_image_processor()

						SCREAMING_SNAKE_CASE__						=					SamProcessor(image_processor=UpperCAmelCase_				)

						SCREAMING_SNAKE_CASE__						=					self.prepare_image_inputs()

						SCREAMING_SNAKE_CASE__						=					image_processor(UpperCAmelCase_			,  return_tensors='np'				)
						SCREAMING_SNAKE_CASE__						=					processor(images=UpperCAmelCase_			,  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 	A_							(     self				:  int				):
						SCREAMING_SNAKE_CASE__						=					self.get_image_processor()

						SCREAMING_SNAKE_CASE__						=					SamProcessor(image_processor=UpperCAmelCase_				)
						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(UpperCAmelCase_			,  UpperCAmelCase_			,  UpperCAmelCase_			,  return_tensors='tf'				)
						self.assertEqual(masks[0].shape			,  (1, 3, 1764, 2646)				)

						SCREAMING_SNAKE_CASE__						=					processor.post_process_masks(
						    UpperCAmelCase_			,  tf.convert_to_tensor(UpperCAmelCase_				)			,  tf.convert_to_tensor(UpperCAmelCase_				)			,  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(
						    UpperCAmelCase_			,  np.array(UpperCAmelCase_				)			,  np.array(UpperCAmelCase_				)			,  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(
											    UpperCAmelCase_			,  np.array(UpperCAmelCase_				)			,  np.array(UpperCAmelCase_				)			,  return_tensors='tf'				)





@require_vision
@require_torchvision
class 		lowercase__    (		unittest.TestCase    ):
	def 	A_							(     self				:  int				):
						SCREAMING_SNAKE_CASE__						=					tempfile.mkdtemp()
						SCREAMING_SNAKE_CASE__						=					SamImageProcessor()
						SCREAMING_SNAKE_CASE__						=					SamProcessor(UpperCAmelCase_				)
						processor.save_pretrained(self.tmpdirname				)
	def 	A_							(     self				:  List[Any]			,  **UpperCAmelCase_				:  Union[str, Any]				):
						return AutoProcessor.from_pretrained(self.tmpdirname			,  **UpperCAmelCase_				).image_processor
	def 	A_							(     self				:  int				):
						shutil.rmtree(self.tmpdirname				)
	def 	A_							(     self				:  Optional[int]				):
						SCREAMING_SNAKE_CASE__						=					[np.random.randint(255			,  size=(3, 30, 400)			,  dtype=np.uinta				)]

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

						return image_inputs
	@is_pt_tf_cross_test
	def 	A_							(     self				:  List[Any]				):
						SCREAMING_SNAKE_CASE__						=					self.get_image_processor()

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

						SCREAMING_SNAKE_CASE__						=					[[1764, 2646]]

						SCREAMING_SNAKE_CASE__						=					[[683, 1024]]
						SCREAMING_SNAKE_CASE__						=					processor.post_process_masks(
						    UpperCAmelCase_			,  UpperCAmelCase_			,  UpperCAmelCase_			,  return_tensors='tf'				)
						SCREAMING_SNAKE_CASE__						=					processor.post_process_masks(
						    UpperCAmelCase_			,  UpperCAmelCase_			,  UpperCAmelCase_			,  return_tensors='pt'				)

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





	@is_pt_tf_cross_test
	def 	A_							(     self				:  int				):
						SCREAMING_SNAKE_CASE__						=					self.get_image_processor()

						SCREAMING_SNAKE_CASE__						=					SamProcessor(image_processor=UpperCAmelCase_				)

						SCREAMING_SNAKE_CASE__						=					self.prepare_image_inputs()

						SCREAMING_SNAKE_CASE__						=					image_processor(UpperCAmelCase_			,  return_tensors='pt'				)['pixel_values'].numpy()
						SCREAMING_SNAKE_CASE__						=					processor(images=UpperCAmelCase_			,  return_tensors='pt'				)['pixel_values'].numpy()

						SCREAMING_SNAKE_CASE__						=					image_processor(UpperCAmelCase_			,  return_tensors='tf'				)['pixel_values'].numpy()
						SCREAMING_SNAKE_CASE__						=					processor(images=UpperCAmelCase_			,  return_tensors='tf'				)['pixel_values'].numpy()

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











'''simple docstring'''







def 						_A      ( ):






   '''simple docstring'''







   A__       =     [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31]

   A__       =     6
   A__       =     1
   A__       =     1901

   A__       =     0

   while year < 2001:
      day += 7

      if (year % 4 == 0 and year % 100 != 0) or (year % 400 == 0):
         if day > days_per_month[month - 1] and month != 2:
            month += 1
            A__       =     day - days_per_month[month - 2]
         elif day > 29 and month == 2:
            month += 1
            A__       =     day - 29
      else:
         if day > days_per_month[month - 1]:
            month += 1
            A__       =     day - days_per_month[month - 2]

      if month > 12:
         year += 1
         A__       =     1

      if year < 2001 and day == 1:
         sundays += 1
   return sundays


if __name__ == "__main__":
    print(solution())


