



"""simple docstring"""


import unittest

import numpy as np

from transformers.testing_utils import require_torch, require_vision
from transformers.utils import is_torch_available, is_vision_available

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_video_inputs


if is_torch_available():
				import torch

if is_vision_available():
				from PIL import Image

				from transformers import VideoMAEImageProcessor







class    A_    (  unittest.TestCase       ):



						"""simple docstring"""






						def __init__(      self				:Dict     ,						lowercase_				:Dict     ,						lowercase_				:Dict=7     ,						lowercase_				:str=3     ,						lowercase_				:str=10     ,						lowercase_				:Optional[int]=18     ,						lowercase_				:Dict=30     ,						lowercase_				:Optional[int]=4_00     ,						lowercase_				:Any=True     ,						lowercase_				:Union[str, Any]=None     ,						lowercase_				:List[str]=True     ,						lowercase_				:Any=[0.5, 0.5, 0.5]     ,						lowercase_				:Tuple=[0.5, 0.5, 0.5]     ,						lowercase_				:Union[str, Any]=None     ,						)       ->    str:
												UpperCAmelCase    =				size if size is not None else {'shortest_edge': 18}
												UpperCAmelCase    =				crop_size if crop_size is not None else {'height': 18, 'width': 18}

												UpperCAmelCase    =				parent
												UpperCAmelCase    =				batch_size
												UpperCAmelCase    =				num_channels
												UpperCAmelCase    =				num_frames
												UpperCAmelCase    =				image_size
												UpperCAmelCase    =				min_resolution
												UpperCAmelCase    =				max_resolution
												UpperCAmelCase    =				do_resize
												UpperCAmelCase    =				size
												UpperCAmelCase    =				do_normalize
												UpperCAmelCase    =				image_mean
												UpperCAmelCase    =				image_std
												UpperCAmelCase    =				crop_size






						def 			UpperCAmelCase__  (      self				:Tuple      )       ->    Optional[int]:
												return {
												    "image_mean": self.image_mean,
												    "image_std": self.image_std,
												    "do_normalize": self.do_normalize,
												    "do_resize": self.do_resize,
												    "size": self.size,
												    "crop_size": self.crop_size,
												}







@require_torch
@require_vision
class    A_    (  SCREAMING_SNAKE_CASE_			,     unittest.TestCase       ):



						"""simple docstring"""
						__UpperCamelCase	       =							VideoMAEImageProcessor if is_vision_available() else None






						def 			UpperCAmelCase__  (      self				:Dict      )       ->    Any:
												UpperCAmelCase    =				VideoMAEImageProcessingTester(self      )






						@property
						def 			UpperCAmelCase__  (      self				:List[str]      )       ->    Dict:
												return self.image_processor_tester.prepare_image_processor_dict()






						def 			UpperCAmelCase__  (      self				:Tuple      )       ->    str:
												UpperCAmelCase    =				self.image_processing_class(**self.image_processor_dict      )
												self.assertTrue(hasattr(lowercase_     ,						'image_mean'      )      )
												self.assertTrue(hasattr(lowercase_     ,						'image_std'      )      )
												self.assertTrue(hasattr(lowercase_     ,						'do_normalize'      )      )
												self.assertTrue(hasattr(lowercase_     ,						'do_resize'      )      )
												self.assertTrue(hasattr(lowercase_     ,						'do_center_crop'      )      )
												self.assertTrue(hasattr(lowercase_     ,						'size'      )      )






						def 			UpperCAmelCase__  (      self				:List[Any]      )       ->    Optional[int]:
												UpperCAmelCase    =				self.image_processing_class.from_dict(self.image_processor_dict      )
												self.assertEqual(image_processor.size     ,						{'shortest_edge': 18}      )
												self.assertEqual(image_processor.crop_size     ,						{'height': 18, 'width': 18}      )

												UpperCAmelCase    =				self.image_processing_class.from_dict(self.image_processor_dict     ,						size=42     ,						crop_size=84      )
												self.assertEqual(image_processor.size     ,						{'shortest_edge': 42}      )
												self.assertEqual(image_processor.crop_size     ,						{'height': 84, 'width': 84}      )






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






						def 			UpperCAmelCase__  (      self				:List[str]      )       ->    Any:
												# Initialize image_processing
												UpperCAmelCase    =				self.image_processing_class(**self.image_processor_dict      )
												# create random PIL videos
												UpperCAmelCase    =				prepare_video_inputs(self.image_processor_tester     ,						equal_resolution=lowercase_      )
												for video in video_inputs:
																		self.assertIsInstance(lowercase_     ,						lowercase_      )
																		self.assertIsInstance(video[0]     ,						Image.Image      )

												# Test not batched input
												UpperCAmelCase    =				image_processing(video_inputs[0]     ,						return_tensors='pt'      ).pixel_values
												self.assertEqual(
												    encoded_videos.shape     ,						(
												        1,
												        self.image_processor_tester.num_frames,
												        self.image_processor_tester.num_channels,
												        self.image_processor_tester.crop_size['height'],
												        self.image_processor_tester.crop_size['width'],
												    )     ,						)

												# Test batched
												UpperCAmelCase    =				image_processing(lowercase_     ,						return_tensors='pt'      ).pixel_values
												self.assertEqual(
												    encoded_videos.shape     ,						(
												        self.image_processor_tester.batch_size,
												        self.image_processor_tester.num_frames,
												        self.image_processor_tester.num_channels,
												        self.image_processor_tester.crop_size['height'],
												        self.image_processor_tester.crop_size['width'],
												    )     ,						)






						def 			UpperCAmelCase__  (      self				:Dict      )       ->    str:
												# Initialize image_processing
												UpperCAmelCase    =				self.image_processing_class(**self.image_processor_dict      )
												# create random numpy tensors
												UpperCAmelCase    =				prepare_video_inputs(self.image_processor_tester     ,						equal_resolution=lowercase_     ,						numpify=lowercase_      )
												for video in video_inputs:
																		self.assertIsInstance(lowercase_     ,						lowercase_      )
																		self.assertIsInstance(video[0]     ,						np.ndarray      )

												# Test not batched input
												UpperCAmelCase    =				image_processing(video_inputs[0]     ,						return_tensors='pt'      ).pixel_values
												self.assertEqual(
												    encoded_videos.shape     ,						(
												        1,
												        self.image_processor_tester.num_frames,
												        self.image_processor_tester.num_channels,
												        self.image_processor_tester.crop_size['height'],
												        self.image_processor_tester.crop_size['width'],
												    )     ,						)

												# Test batched
												UpperCAmelCase    =				image_processing(lowercase_     ,						return_tensors='pt'      ).pixel_values
												self.assertEqual(
												    encoded_videos.shape     ,						(
												        self.image_processor_tester.batch_size,
												        self.image_processor_tester.num_frames,
												        self.image_processor_tester.num_channels,
												        self.image_processor_tester.crop_size['height'],
												        self.image_processor_tester.crop_size['width'],
												    )     ,						)






						def 			UpperCAmelCase__  (      self				:Dict      )       ->    Dict:
												# Initialize image_processing
												UpperCAmelCase    =				self.image_processing_class(**self.image_processor_dict      )
												# create random PyTorch tensors
												UpperCAmelCase    =				prepare_video_inputs(self.image_processor_tester     ,						equal_resolution=lowercase_     ,						torchify=lowercase_      )
												for video in video_inputs:
																		self.assertIsInstance(lowercase_     ,						lowercase_      )
																		self.assertIsInstance(video[0]     ,						torch.Tensor      )

												# Test not batched input
												UpperCAmelCase    =				image_processing(video_inputs[0]     ,						return_tensors='pt'      ).pixel_values
												self.assertEqual(
												    encoded_videos.shape     ,						(
												        1,
												        self.image_processor_tester.num_frames,
												        self.image_processor_tester.num_channels,
												        self.image_processor_tester.crop_size['height'],
												        self.image_processor_tester.crop_size['width'],
												    )     ,						)

												# Test batched
												UpperCAmelCase    =				image_processing(lowercase_     ,						return_tensors='pt'      ).pixel_values
												self.assertEqual(
												    encoded_videos.shape     ,						(
												        self.image_processor_tester.batch_size,
												        self.image_processor_tester.num_frames,
												        self.image_processor_tester.num_channels,
												        self.image_processor_tester.crop_size['height'],
												        self.image_processor_tester.crop_size['width'],
												    )     ,						)










"""simple docstring"""


from collections import Counter

def 				_lowerCAmelCase   (     lowercase_		):
						return sum(socks_by_color // 2 for socks_by_color in Counter(lowercase_		).values()		)


if __name__ == "__main__":
				import doctest

				doctest.testmod()

				snake_case_         = [int(x) for x in input("""Enter socks by color :""").rstrip().split()]
				print(f'''sock_merchant({colors}) = {sock_merchant(colors)}''')





