code: 
  
  
  
  
  import unittest
  
  from transformers.image_processing_utils import get_size_dict
  
  
  class 							_lowerCAmelCase		(     unittest.TestCase	):
  
  
  
  
  				def     __a		( self							)    ->      Tuple:
  											# Test a dict with the wrong keys raises an error
  											SCREAMING_SNAKE_CASE			: Dict	     ={'''wrong_key''': 224}
  											with self.assertRaises(snake_case_							):
  																		get_size_dict(snake_case_							)
  
  											SCREAMING_SNAKE_CASE			: List[Any]	     ={'''height''': 224}
  											with self.assertRaises(snake_case_							):
  																		get_size_dict(snake_case_							)
  
  											SCREAMING_SNAKE_CASE			: Optional[int]	     ={'''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
  											SCREAMING_SNAKE_CASE			: str	     ={'''height''': 224, '''width''': 224}
  											SCREAMING_SNAKE_CASE			: Optional[Any]	     =get_size_dict(snake_case_							)
  											self.assertEqual(snake_case_		,		snake_case_							)
  
  											SCREAMING_SNAKE_CASE			: int	     ={'''shortest_edge''': 224}
  											SCREAMING_SNAKE_CASE			: List[Any]	     =get_size_dict(snake_case_							)
  											self.assertEqual(snake_case_		,		{'''shortest_edge''': 224}							)
  
  											SCREAMING_SNAKE_CASE			: Union[str, Any]	     ={'''longest_edge''': 224, '''shortest_edge''': 224}
  											SCREAMING_SNAKE_CASE			: Optional[Any]	     =get_size_dict(snake_case_							)
  											self.assertEqual(snake_case_		,		{'''longest_edge''': 224, '''shortest_edge''': 224}							)
  
  											# Test a single int value which  represents (size, size)
  											SCREAMING_SNAKE_CASE			: Union[str, Any]	     =get_size_dict(224							)
  											self.assertEqual(snake_case_		,		{'''height''': 224, '''width''': 224}							)
  
  											# Test a single int value which represents the shortest edge
  											SCREAMING_SNAKE_CASE			: Dict	     =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)
  											SCREAMING_SNAKE_CASE			: Dict	     =get_size_dict((150, 200)							)
  											self.assertEqual(snake_case_		,		{'''height''': 150, '''width''': 200}							)
  
  											# Test a tuple of ints which represents (width, height)
  											SCREAMING_SNAKE_CASE			: List[Any]	     =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
  											SCREAMING_SNAKE_CASE			: Union[str, 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_							)
  
  
  
  
  
  
  
style_context: 
  
  
  
  
  def 						lowerCAmelCase_       (	__a = "mytext.txt"	,	__a = False )       ->			None:
  
  
  
  
  
  							"""simple docstring"""
  
  
  
  
  
  							import socket
  
  							SCREAMING_SNAKE_CASE			: int	     =12312  # Reserve a port for your service.
  							SCREAMING_SNAKE_CASE			: Dict	     =socket.socket()  # Create a socket object
  							SCREAMING_SNAKE_CASE			: Any	     =socket.gethostname()  # Get local machine name
  							sock.bind((host, port) )  # Bind to the port
  							sock.listen(5 )  # Now wait for client connection.
  
  							print('''Server listening....''' )
  
  							while True:
  														SCREAMING_SNAKE_CASE     ,							SCREAMING_SNAKE_CASE			: Optional[int]	     =sock.accept()  # Establish connection with client.
  														print(f'Got connection from {addr}' )
  														SCREAMING_SNAKE_CASE			: List[str]	     =conn.recv(1024 )
  														print(f'Server received: {data = }' )
  
  														with open(__a	,	'''rb''' ) as in_file:
  																					SCREAMING_SNAKE_CASE			: Dict	     =in_file.read(1024 )
  																					while data:
  																												conn.send(__a )
  																												print(f'Sent {data!r}' )
  																												SCREAMING_SNAKE_CASE			: str	     =in_file.read(1024 )
  
  														print('''Done sending''' )
  														conn.close()
  														if testing:  # Allow the test to complete
  																					break
  
  							sock.shutdown(1 )
  							sock.close()
  
  
  if __name__ == "__main__":
  							send_file()
  
  
  
  
  
  
  