
"""simple docstring"""







from ..utils import DummyObject, requires_backends



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Union[str, Any]				   =    ["""tokenizers"""]




 def __init__( self       : Dict     ,   *a_       : Dict     ,   **a_       : List[str] )->					Tuple:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     int				   =    ["""tokenizers"""]




 def __init__( self       : str     ,   *a_       : Tuple     ,   **a_       : int )->					Any:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     List[str]				   =    ["""tokenizers"""]




 def __init__( self       : List[str]     ,   *a_       : int     ,   **a_       : Optional[Any] )->					Dict:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Union[str, Any]				   =    ["""tokenizers"""]




 def __init__( self       : Any     ,   *a_       : List[str]     ,   **a_       : str )->					Tuple:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Union[str, Any]				   =    ["""tokenizers"""]




 def __init__( self       : str     ,   *a_       : str     ,   **a_       : Tuple )->					Tuple:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Optional[int]				   =    ["""tokenizers"""]




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



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Any				   =    ["""tokenizers"""]




 def __init__( self       : List[str]     ,   *a_       : List[Any]     ,   **a_       : Tuple )->					List[Any]:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     List[Any]				   =    ["""tokenizers"""]




 def __init__( self       : Optional[int]     ,   *a_       : List[str]     ,   **a_       : Union[str, Any] )->					Tuple:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Tuple				   =    ["""tokenizers"""]




 def __init__( self       : Dict     ,   *a_       : int     ,   **a_       : List[Any] )->					Union[str, Any]:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Optional[Any]				   =    ["""tokenizers"""]




 def __init__( self       : str     ,   *a_       : Union[str, Any]     ,   **a_       : List[str] )->					Tuple:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Any				   =    ["""tokenizers"""]




 def __init__( self       : int     ,   *a_       : str     ,   **a_       : List[str] )->					int:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Any				   =    ["""tokenizers"""]




 def __init__( self       : Tuple     ,   *a_       : int     ,   **a_       : Optional[int] )->					List[Any]:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Tuple				   =    ["""tokenizers"""]




 def __init__( self       : Optional[Any]     ,   *a_       : List[str]     ,   **a_       : Optional[Any] )->					List[str]:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Any				   =    ["""tokenizers"""]




 def __init__( self       : str     ,   *a_       : List[str]     ,   **a_       : Tuple )->					str:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Optional[int]				   =    ["""tokenizers"""]




 def __init__( self       : Optional[Any]     ,   *a_       : List[str]     ,   **a_       : List[Any] )->					Any:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Dict				   =    ["""tokenizers"""]




 def __init__( self       : Optional[int]     ,   *a_       : int     ,   **a_       : List[str] )->					Optional[int]:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Tuple				   =    ["""tokenizers"""]




 def __init__( self       : Union[str, Any]     ,   *a_       : Optional[int]     ,   **a_       : Optional[int] )->					Tuple:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     List[Any]				   =    ["""tokenizers"""]




 def __init__( self       : List[str]     ,   *a_       : str     ,   **a_       : Union[str, Any] )->					Any:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     List[str]				   =    ["""tokenizers"""]




 def __init__( self       : Dict     ,   *a_       : Any     ,   **a_       : Union[str, Any] )->					Dict:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Optional[Any]				   =    ["""tokenizers"""]




 def __init__( self       : Optional[Any]     ,   *a_       : Union[str, Any]     ,   **a_       : Optional[int] )->					Union[str, Any]:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     str				   =    ["""tokenizers"""]




 def __init__( self       : Optional[int]     ,   *a_       : List[str]     ,   **a_       : List[Any] )->					Union[str, Any]:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Optional[int]				   =    ["""tokenizers"""]




 def __init__( self       : Optional[int]     ,   *a_       : Optional[int]     ,   **a_       : int )->					Dict:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Any				   =    ["""tokenizers"""]




 def __init__( self       : Optional[int]     ,   *a_       : Optional[Any]     ,   **a_       : Union[str, Any] )->					str:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Any				   =    ["""tokenizers"""]




 def __init__( self       : Union[str, Any]     ,   *a_       : Optional[int]     ,   **a_       : str )->					str:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Optional[int]				   =    ["""tokenizers"""]




 def __init__( self       : Dict     ,   *a_       : Any     ,   **a_       : Tuple )->					Optional[int]:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     List[Any]				   =    ["""tokenizers"""]




 def __init__( self       : int     ,   *a_       : List[str]     ,   **a_       : Tuple )->					Optional[int]:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Any				   =    ["""tokenizers"""]




 def __init__( self       : Union[str, Any]     ,   *a_       : str     ,   **a_       : List[str] )->					List[str]:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Optional[int]				   =    ["""tokenizers"""]




 def __init__( self       : str     ,   *a_       : Optional[Any]     ,   **a_       : str )->					int:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Optional[int]				   =    ["""tokenizers"""]




 def __init__( self       : List[str]     ,   *a_       : Tuple     ,   **a_       : Dict )->					Any:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     List[str]				   =    ["""tokenizers"""]




 def __init__( self       : Dict     ,   *a_       : int     ,   **a_       : List[str] )->					List[str]:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Optional[Any]				   =    ["""tokenizers"""]




 def __init__( self       : str     ,   *a_       : str     ,   **a_       : Optional[Any] )->					Optional[Any]:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     int				   =    ["""tokenizers"""]




 def __init__( self       : Any     ,   *a_       : Dict     ,   **a_       : Union[str, Any] )->					Tuple:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Dict				   =    ["""tokenizers"""]




 def __init__( self       : List[str]     ,   *a_       : Optional[Any]     ,   **a_       : Dict )->					str:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     int				   =    ["""tokenizers"""]




 def __init__( self       : Any     ,   *a_       : Tuple     ,   **a_       : List[str] )->					Optional[int]:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Optional[Any]				   =    ["""tokenizers"""]




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



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Tuple				   =    ["""tokenizers"""]




 def __init__( self       : List[Any]     ,   *a_       : Optional[Any]     ,   **a_       : Optional[Any] )->					Optional[Any]:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     int				   =    ["""tokenizers"""]




 def __init__( self       : str     ,   *a_       : List[str]     ,   **a_       : Optional[int] )->					str:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Union[str, Any]				   =    ["""tokenizers"""]




 def __init__( self       : int     ,   *a_       : List[str]     ,   **a_       : Any )->					List[str]:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Union[str, Any]				   =    ["""tokenizers"""]




 def __init__( self       : Optional[int]     ,   *a_       : Dict     ,   **a_       : Tuple )->					str:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     int				   =    ["""tokenizers"""]




 def __init__( self       : Dict     ,   *a_       : int     ,   **a_       : Optional[int] )->					List[Any]:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Dict				   =    ["""tokenizers"""]




 def __init__( self       : int     ,   *a_       : List[Any]     ,   **a_       : Optional[int] )->					Any:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Dict				   =    ["""tokenizers"""]




 def __init__( self       : Union[str, Any]     ,   *a_       : Tuple     ,   **a_       : Dict )->					str:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Optional[Any]				   =    ["""tokenizers"""]




 def __init__( self       : Any     ,   *a_       : Optional[Any]     ,   **a_       : List[str] )->					Optional[Any]:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Dict				   =    ["""tokenizers"""]




 def __init__( self       : Union[str, Any]     ,   *a_       : List[Any]     ,   **a_       : Union[str, Any] )->					List[Any]:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     int				   =    ["""tokenizers"""]




 def __init__( self       : Tuple     ,   *a_       : Any     ,   **a_       : Any )->					Any:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     List[Any]				   =    ["""tokenizers"""]




 def __init__( self       : int     ,   *a_       : str     ,   **a_       : List[str] )->					int:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Optional[int]				   =    ["""tokenizers"""]




 def __init__( self       : Any     ,   *a_       : Dict     ,   **a_       : Any )->					List[Any]:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Optional[int]				   =    ["""tokenizers"""]




 def __init__( self       : List[str]     ,   *a_       : str     ,   **a_       : int )->					Optional[int]:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Any				   =    ["""tokenizers"""]




 def __init__( self       : Optional[int]     ,   *a_       : int     ,   **a_       : str )->					Optional[Any]:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     List[Any]				   =    ["""tokenizers"""]




 def __init__( self       : Optional[Any]     ,   *a_       : List[Any]     ,   **a_       : Tuple )->					List[Any]:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     str				   =    ["""tokenizers"""]




 def __init__( self       : Tuple     ,   *a_       : str     ,   **a_       : Optional[Any] )->					Tuple:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Tuple				   =    ["""tokenizers"""]




 def __init__( self       : Dict     ,   *a_       : int     ,   **a_       : int )->					Tuple:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     List[str]				   =    ["""tokenizers"""]




 def __init__( self       : Dict     ,   *a_       : Any     ,   **a_       : int )->					Tuple:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Optional[Any]				   =    ["""tokenizers"""]




 def __init__( self       : List[str]     ,   *a_       : List[Any]     ,   **a_       : Tuple )->					Union[str, Any]:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     str				   =    ["""tokenizers"""]




 def __init__( self       : List[Any]     ,   *a_       : Union[str, Any]     ,   **a_       : List[str] )->					Tuple:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Optional[int]				   =    ["""tokenizers"""]




 def __init__( self       : Tuple     ,   *a_       : int     ,   **a_       : Tuple )->					List[Any]:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Any				   =    ["""tokenizers"""]




 def __init__( self       : Tuple     ,   *a_       : Optional[int]     ,   **a_       : List[Any] )->					Any:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



class 		UpperCAmelCase_	(metaclass=lowerCamelCase_						):
 """simple docstring"""




 UpperCamelCase_						:     Optional[int]				   =    ["""tokenizers"""]




 def __init__( self       : Any     ,   *a_       : List[str]     ,   **a_       : Optional[int] )->					Dict:



      """simple docstring"""

      requires_backends(self     ,   ["""tokenizers"""] )



"""simple docstring"""







import unittest

from transformers.image_processing_utils import get_size_dict



class 		UpperCAmelCase_	(unittest.TestCase						):
 """simple docstring"""




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



      """simple docstring"""

      UpperCAmelCase_						:    Any    					=  {"""wrong_key""": 2_24}
      with self.assertRaises(a_ ):
           get_size_dict(a_ )

      UpperCAmelCase_						:    Union[str, Any]    					=  {"""height""": 2_24}
      with self.assertRaises(a_ ):
           get_size_dict(a_ )

      UpperCAmelCase_						:    Union[str, Any]    					=  {"""width""": 2_24, """shortest_edge""": 2_24}
      with self.assertRaises(a_ ):
           get_size_dict(a_ )

      # Test a dict with the correct keys is returned as is
      UpperCAmelCase_						:    int    					=  {"""height""": 2_24, """width""": 2_24}
      UpperCAmelCase_						:    Dict    					=  get_size_dict(a_ )
      self.assertEqual(a_     ,   a_ )

      UpperCAmelCase_						:    Optional[int]    					=  {"""shortest_edge""": 2_24}
      UpperCAmelCase_						:    Tuple    					=  get_size_dict(a_ )
      self.assertEqual(a_     ,   {"""shortest_edge""": 2_24} )

      UpperCAmelCase_						:    str    					=  {"""longest_edge""": 2_24, """shortest_edge""": 2_24}
      UpperCAmelCase_						:    Any    					=  get_size_dict(a_ )
      self.assertEqual(a_     ,   {"""longest_edge""": 2_24, """shortest_edge""": 2_24} )

      # Test a single int value which  represents (size, size)
      UpperCAmelCase_						:    Optional[Any]    					=  get_size_dict(2_24 )
      self.assertEqual(a_     ,   {"""height""": 2_24, """width""": 2_24} )

      # Test a single int value which represents the shortest edge
      UpperCAmelCase_						:    List[str]    					=  get_size_dict(2_24     ,   default_to_square=a_ )
      self.assertEqual(a_     ,   {"""shortest_edge""": 2_24} )

      # Test a tuple of ints which represents (height, width)
      UpperCAmelCase_						:    List[Any]    					=  get_size_dict((1_50, 2_00) )
      self.assertEqual(a_     ,   {"""height""": 1_50, """width""": 2_00} )

      # Test a tuple of ints which represents (width, height)
      UpperCAmelCase_						:    List[str]    					=  get_size_dict((1_50, 2_00)     ,   height_width_order=a_ )
      self.assertEqual(a_     ,   {"""height""": 2_00, """width""": 1_50} )

      # Test an int representing the shortest edge and max_size which represents the longest edge
      UpperCAmelCase_						:    List[Any]    					=  get_size_dict(2_24     ,   max_size=2_56     ,   default_to_square=a_ )
      self.assertEqual(a_     ,   {"""shortest_edge""": 2_24, """longest_edge""": 2_56} )

      # Test int with default_to_square=True and max_size fails
      with self.assertRaises(a_ ):
           get_size_dict(2_24     ,   max_size=2_56     ,   default_to_square=a_ )

