code: 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
  
  
  if is_torch_available():
  		import torch
  
  if is_vision_available():
  		from PIL import Image
  
  		from transformers import SwinaSRImageProcessor
  		from transformers.image_transforms import get_image_size
  
  
  
  
  class 					UpperCamelCase	(     unittest.TestCase      ):
  
  
  
  
  					def __init__( self :					List[Any]      ,_lowerCAmelCase :					Optional[int]      ,_lowerCAmelCase :					List[Any]=7      ,_lowerCAmelCase :					Optional[Any]=3      ,_lowerCAmelCase :					Optional[Any]=18      ,_lowerCAmelCase :					str=30      ,_lowerCAmelCase :					str=400      ,_lowerCAmelCase :					Any=True      ,_lowerCAmelCase :					int=1 / 255      ,_lowerCAmelCase :					Dict=True      ,_lowerCAmelCase :					Tuple=8      ,):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     parent
  							__snake_case		       =     batch_size
  							__snake_case		       =     num_channels
  							__snake_case		       =     image_size
  							__snake_case		       =     min_resolution
  							__snake_case		       =     max_resolution
  							__snake_case		       =     do_rescale
  							__snake_case		       =     rescale_factor
  							__snake_case		       =     do_pad
  							__snake_case		       =     pad_size
  
  
  
  
  					def 							UpperCamelCase_						( self :					Tuple						):
  
  
  							"""simple docstring"""
  
  
  
  
  							return {
  							    "do_rescale": self.do_rescale,
  							    "rescale_factor": self.rescale_factor,
  							    "do_pad": self.do_pad,
  							    "pad_size": self.pad_size,
  							}
  
  
  
  
  
  
  
  					def 							UpperCamelCase_						( self :					str      ,_lowerCAmelCase :					List[Any]=False      ,_lowerCAmelCase :					Any=False      ,_lowerCAmelCase :					Tuple=False						):
  
  
  							"""simple docstring"""
  
  
  
  
  							assert not (numpify and torchify), "You cannot specify both numpy and PyTorch tensors at the same time"
  
  							if equal_resolution:
  									__snake_case		       =     []
  									for i in range(self.batch_size						):
  											image_inputs.append(
  											    np.random.randint(
  											        255      ,size=(self.num_channels, self.max_resolution, self.max_resolution)      ,dtype=np.uinta						)						)
  							else:
  									__snake_case		       =     []
  									for i in range(self.batch_size						):
  											__snake_case       ,       __snake_case		       =     np.random.choice(np.arange(self.min_resolution      ,self.max_resolution						)      ,2						)
  											image_inputs.append(np.random.randint(255      ,size=(self.num_channels, width, height)      ,dtype=np.uinta						)						)
  
  							if not numpify and not torchify:
  									# PIL expects the channel dimension as last dimension
  									__snake_case		       =     [Image.fromarray(np.moveaxis(_lowerCAmelCase      ,0      ,-1						)						) for x in image_inputs]
  
  							if torchify:
  									__snake_case		       =     [torch.from_numpy(_lowerCAmelCase						) for x in image_inputs]
  
  							return image_inputs
  
  
  
  
  @require_torch
  @require_vision
  class 					UpperCamelCase	(     snake_case__			,      unittest.TestCase      ):
  					__UpperCamelCase						=   SwinaSRImageProcessor if is_vision_available() else None
  
  
  
  
  					def 							UpperCamelCase_						( self :					List[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     SwinaSRImageProcessingTester(self						)
  
  
  
  
  					@property
  					def 							UpperCamelCase_						( self :					str						):
  
  
  							"""simple docstring"""
  
  
  
  
  							return self.image_processor_tester.prepare_image_processor_dict()
  
  
  
  
  					def 							UpperCamelCase_						( self :					Dict						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self.image_processing_class(**self.image_processor_dict						)
  							self.assertTrue(hasattr(_lowerCAmelCase      ,"do_rescale"						)						)
  							self.assertTrue(hasattr(_lowerCAmelCase      ,"rescale_factor"						)						)
  							self.assertTrue(hasattr(_lowerCAmelCase      ,"do_pad"						)						)
  							self.assertTrue(hasattr(_lowerCAmelCase      ,"pad_size"						)						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					Dict						):
  
  
  							"""simple docstring"""
  
  
  
  
  							pass
  
  
  
  
  					def 							UpperCamelCase_						( self :					Any      ,_lowerCAmelCase :					Optional[int]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case       ,       __snake_case		       =     get_image_size(_lowerCAmelCase						)
  							__snake_case		       =     self.image_processor_tester.pad_size
  
  							__snake_case		       =     (old_height // size + 1) * size - old_height
  							__snake_case		       =     (old_width // size + 1) * size - old_width
  							return old_height + pad_height, old_width + pad_width
  
  
  
  
  					def 							UpperCamelCase_						( self :					Optional[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self.image_processing_class(**self.image_processor_dict						)
  							# create random PIL images
  							__snake_case		       =     self.image_processor_tester.prepare_inputs(equal_resolution=_lowerCAmelCase						)
  							for image in image_inputs:
  									self.assertIsInstance(_lowerCAmelCase      ,Image.Image						)
  
  							# Test not batched input
  							__snake_case		       =     image_processor(image_inputs[0]      ,return_tensors="pt"						).pixel_values
  							__snake_case       ,       __snake_case		       =     self.calculate_expected_size(np.array(image_inputs[0]						)						)
  							self.assertEqual(
  							    encoded_images.shape      ,(
  							        1,
  							        self.image_processor_tester.num_channels,
  							        expected_height,
  							        expected_width,
  							    )      ,)
  
  
  
  
  					def 							UpperCamelCase_						( self :					Dict						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self.image_processing_class(**self.image_processor_dict						)
  							# create random numpy tensors
  							__snake_case		       =     self.image_processor_tester.prepare_inputs(equal_resolution=_lowerCAmelCase      ,numpify=_lowerCAmelCase						)
  							for image in image_inputs:
  									self.assertIsInstance(_lowerCAmelCase      ,np.ndarray						)
  
  							# Test not batched input
  							__snake_case		       =     image_processor(image_inputs[0]      ,return_tensors="pt"						).pixel_values
  							__snake_case       ,       __snake_case		       =     self.calculate_expected_size(image_inputs[0]						)
  							self.assertEqual(
  							    encoded_images.shape      ,(
  							        1,
  							        self.image_processor_tester.num_channels,
  							        expected_height,
  							        expected_width,
  							    )      ,)
  
  
  
  
  
  
  
  					def 							UpperCamelCase_						( self :					Any						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self.image_processing_class(**self.image_processor_dict						)
  							# create random PyTorch tensors
  							__snake_case		       =     self.image_processor_tester.prepare_inputs(equal_resolution=_lowerCAmelCase      ,torchify=_lowerCAmelCase						)
  							for image in image_inputs:
  									self.assertIsInstance(_lowerCAmelCase      ,torch.Tensor						)
  
  							# Test not batched input
  							__snake_case		       =     image_processor(image_inputs[0]      ,return_tensors="pt"						).pixel_values
  							__snake_case       ,       __snake_case		       =     self.calculate_expected_size(image_inputs[0]						)
  							self.assertEqual(
  							    encoded_images.shape      ,(
  							        1,
  							        self.image_processor_tester.num_channels,
  							        expected_height,
  							        expected_width,
  							    )      ,)
  
  
  
  
  
  
style_context: from __future__ import annotations
  
  from collections.abc import Iterable
  from dataclasses import dataclass
  from typing import Any
  
  
  
  
  class 					UpperCamelCase	:
  					__UpperCamelCase						=   ("""_front""", """_back""", """_len""")
  
  
  
  
  					@dataclass
  					class 					UpperCamelCase	:
  										__UpperCamelCase						=   None
  										__UpperCamelCase						=   None
  										__UpperCamelCase						=   None
  
  
  
  
  					class 					UpperCamelCase	:
  										__UpperCamelCase						=   ("""_cur""",)
  
  
  
  
  										def __init__( self :					Dict      ,_lowerCAmelCase :					Deque._Node | None						):
  
  
  												"""simple docstring"""
  
  
  
  
  												__snake_case		       =     cur
  
  
  
  
  										def __iter__( self :					Dict						):
  
  
  												"""simple docstring"""
  
  
  
  
  												return self
  
  
  
  
  
  
  
  										def 							UpperCamelCase_						( self :					Optional[Any]						):
  
  
  												"""simple docstring"""
  
  
  
  
  												if self._cur is None:
  														# finished iterating
  														raise StopIteration
  												__snake_case		       =     self._cur.val
  												__snake_case		       =     self._cur.next_node
  
  												return val
  
  
  
  
  					def __init__( self :					Optional[int]      ,_lowerCAmelCase :					Iterable[Any] | None = None						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     None
  							__snake_case		       =     None
  							__snake_case		       =     0
  
  							if iterable is not None:
  									# append every value to the deque
  									for val in iterable:
  											self.append(_lowerCAmelCase						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					int      ,_lowerCAmelCase :					Any						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self._Node(_lowerCAmelCase      ,_lowerCAmelCase      ,_lowerCAmelCase						)
  							if self.is_empty():
  									# front = back
  									__snake_case		       =     __snake_case		       =     node
  									__snake_case		       =     1
  							else:
  									# connect nodes
  									__snake_case		       =     node
  									__snake_case		       =     self._back
  									__snake_case		       =     node  # assign new back to the new node
  
  									self._len += 1
  
  									# make sure there were no errors
  									assert not self.is_empty(), "Error on appending value."
  
  
  
  
  					def 							UpperCamelCase_						( self :					Any      ,_lowerCAmelCase :					Any						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     self._Node(_lowerCAmelCase      ,_lowerCAmelCase      ,_lowerCAmelCase						)
  							if self.is_empty():
  									# front = back
  									__snake_case		       =     __snake_case		       =     node
  									__snake_case		       =     1
  							else:
  									# connect nodes
  									__snake_case		       =     self._front
  									__snake_case		       =     node
  									__snake_case		       =     node  # assign new front to the new node
  
  									self._len += 1
  
  									# make sure there were no errors
  									assert not self.is_empty(), "Error on appending value."
  
  
  
  
  					def 							UpperCamelCase_						( self :					int      ,_lowerCAmelCase :					Iterable[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							for val in iterable:
  									self.append(_lowerCAmelCase						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					Optional[int]      ,_lowerCAmelCase :					Iterable[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							for val in iterable:
  									self.appendleft(_lowerCAmelCase						)
  
  
  
  
  					def 							UpperCamelCase_						( self :					List[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							assert not self.is_empty(), "Deque is empty."
  
  							__snake_case		       =     self._back
  							__snake_case		       =     self._back.prev_node  # set new back
  							# drop the last node - python will deallocate memory automatically
  							__snake_case		       =     None
  
  							self._len -= 1
  
  							return topop.val
  
  
  
  
  					def 							UpperCamelCase_						( self :					List[str]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							assert not self.is_empty(), "Deque is empty."
  
  							__snake_case		       =     self._front
  							__snake_case		       =     self._front.next_node  # set new front and drop the first node
  							__snake_case		       =     None
  
  							self._len -= 1
  
  							return topop.val
  
  
  
  
  					def 							UpperCamelCase_						( self :					int						):
  
  
  							"""simple docstring"""
  
  
  
  
  							return self._front is None
  
  
  
  
  					def __len__( self :					Tuple						):
  
  
  							"""simple docstring"""
  
  
  
  
  							return self._len
  
  
  
  
  					def __eq__( self :					Union[str, Any]      ,_lowerCAmelCase :					object						):
  
  
  							"""simple docstring"""
  
  
  
  
  							if not isinstance(_lowerCAmelCase      ,_lowerCAmelCase						):
  									return NotImplemented
  
  							__snake_case		       =     self._front
  							__snake_case		       =     other._front
  
  							# if the length of the dequeues are not the same, they are not equal
  							if len(self						) != len(_lowerCAmelCase						):
  									return False
  
  							while me is not None and oth is not None:
  									# compare every value
  									if me.val != oth.val:
  											return False
  									__snake_case		       =     me.next_node
  									__snake_case		       =     oth.next_node
  
  							return True
  
  
  
  
  					def __iter__( self :					Tuple						):
  
  
  							"""simple docstring"""
  
  
  
  
  							return Deque._Iterator(self._front						)
  
  
  
  
  
  
  
  					def __repr__( self :					List[Any]						):
  
  
  							"""simple docstring"""
  
  
  
  
  							__snake_case		       =     []
  							__snake_case		       =     self._front
  							while aux is not None:
  									# append the values in a list to display
  									values_list.append(aux.val						)
  									__snake_case		       =     aux.next_node
  
  							return F"""[{", ".join(repr(_lowerCAmelCase						) for val in values_list						)}]"""
  
  
  if __name__ == "__main__":
  		import doctest
  
  		doctest.testmod()
  
  
  
  
  
  