code: 
  '''simple docstring'''
  
  from ..utils import DummyObject, requires_backends
  
  class 			UpperCAmelCase				(					metaclass=SCREAMING_SNAKE_CASE__ ):
  
  
  
  
  
  		"""simple docstring"""
  
  
  
  
  
  		A__  :   List[str]          =    ['torch', 'transformers', 'invisible_watermark']
  		def __init__(    self  ,					*_snake_case  ,					**_snake_case     )				->    int:
  				requires_backends(self  ,					['''torch''', '''transformers''', '''invisible_watermark''']     )
  		@classmethod
  		def _lowercase  (    cls  ,					*_snake_case  ,					**_snake_case     )				->    List[str]:
  				requires_backends(cls  ,					['''torch''', '''transformers''', '''invisible_watermark''']     )
  
  
  
  
  		@classmethod
  		def _lowercase  (    cls  ,					*_snake_case  ,					**_snake_case     )				->    Tuple:
  				requires_backends(cls  ,					['''torch''', '''transformers''', '''invisible_watermark''']     )
  
  
  
  
  
  
  
  class 			UpperCAmelCase				(					metaclass=SCREAMING_SNAKE_CASE__ ):
  
  
  
  
  
  		"""simple docstring"""
  
  
  
  
  
  		A__  :   str          =    ['torch', 'transformers', 'invisible_watermark']
  		def __init__(    self  ,					*_snake_case  ,					**_snake_case     )				->    Optional[int]:
  				requires_backends(self  ,					['''torch''', '''transformers''', '''invisible_watermark''']     )
  		@classmethod
  		def _lowercase  (    cls  ,					*_snake_case  ,					**_snake_case     )				->    int:
  				requires_backends(cls  ,					['''torch''', '''transformers''', '''invisible_watermark''']     )
  
  
  
  
  		@classmethod
  		def _lowercase  (    cls  ,					*_snake_case  ,					**_snake_case     )				->    Optional[int]:
  				requires_backends(cls  ,					['''torch''', '''transformers''', '''invisible_watermark''']     )
  
  
  
  
  
  
style_context: 
  '''simple docstring'''
  
  import unittest
  
  from transformers.image_processing_utils import get_size_dict
  
  class 			UpperCAmelCase				(					unittest.TestCase ):
  
  
  
  
  
  		"""simple docstring"""
  
  
  
  
  
  		def _lowercase  (    self     )				->    Dict:
  				# Test a dict with the wrong keys raises an error
  				_UpperCamelCase       : List[Any]    =      {'''wrong_key''': 224}
  				with self.assertRaises(_snake_case     ):
  						get_size_dict(_snake_case     )
  
  				_UpperCamelCase       : Dict    =      {'''height''': 224}
  				with self.assertRaises(_snake_case     ):
  						get_size_dict(_snake_case     )
  
  				_UpperCamelCase       : str    =      {'''width''': 224, '''shortest_edge''': 224}
  				with self.assertRaises(_snake_case     ):
  						get_size_dict(_snake_case     )
  
  				# Test a dict with the correct keys is returned as is
  				_UpperCamelCase       : Any    =      {'''height''': 224, '''width''': 224}
  				_UpperCamelCase       : Optional[int]    =      get_size_dict(_snake_case     )
  				self.assertEqual(_snake_case  ,					_snake_case     )
  
  				_UpperCamelCase       : Optional[Any]    =      {'''shortest_edge''': 224}
  				_UpperCamelCase       : int    =      get_size_dict(_snake_case     )
  				self.assertEqual(_snake_case  ,					{'''shortest_edge''': 224}     )
  
  				_UpperCamelCase       : int    =      {'''longest_edge''': 224, '''shortest_edge''': 224}
  				_UpperCamelCase       : Tuple    =      get_size_dict(_snake_case     )
  				self.assertEqual(_snake_case  ,					{'''longest_edge''': 224, '''shortest_edge''': 224}     )
  
  				# Test a single int value which  represents (size, size)
  				_UpperCamelCase       : Any    =      get_size_dict(224     )
  				self.assertEqual(_snake_case  ,					{'''height''': 224, '''width''': 224}     )
  
  				# Test a single int value which represents the shortest edge
  				_UpperCamelCase       : List[Any]    =      get_size_dict(224  ,					default_to_square=_snake_case     )
  				self.assertEqual(_snake_case  ,					{'''shortest_edge''': 224}     )
  
  				# Test a tuple of ints which represents (height, width)
  				_UpperCamelCase       : Any    =      get_size_dict((150, 200)     )
  				self.assertEqual(_snake_case  ,					{'''height''': 150, '''width''': 200}     )
  
  				# Test a tuple of ints which represents (width, height)
  				_UpperCamelCase       : List[str]    =      get_size_dict((150, 200)  ,					height_width_order=_snake_case     )
  				self.assertEqual(_snake_case  ,					{'''height''': 200, '''width''': 150}     )
  
  				# Test an int representing the shortest edge and max_size which represents the longest edge
  				_UpperCamelCase       : Any    =      get_size_dict(224  ,					max_size=256  ,					default_to_square=_snake_case     )
  				self.assertEqual(_snake_case  ,					{'''shortest_edge''': 224, '''longest_edge''': 256}     )
  
  				# Test int with default_to_square=True and max_size fails
  				with self.assertRaises(_snake_case     ):
  						get_size_dict(224  ,					max_size=256  ,					default_to_square=_snake_case     )
  
  
  
  
  
  