code: 
  
  
  """simple docstring"""
  
  
  
  
  def 			a_   (  lowercase__   :str = "mytext.txt", lowercase__   :bool = False    ):
  			import socket
  
  			__lowerCamelCase        =			1_2312  # Reserve a port for your service.
  			__lowerCamelCase        =			socket.socket()  # Create a socket object
  			__lowerCamelCase        =			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:
  						__lowerCamelCase    ,__lowerCamelCase        =			sock.accept()  # Establish connection with client.
  						print(f'Got connection from {addr}'    )
  						__lowerCamelCase        =			conn.recv(1024    )
  						print(f'Server received: {data = }'    )
  
  						with open(lowercase__, """rb"""    ) as in_file:
  									__lowerCamelCase        =			in_file.read(1024    )
  									while data:
  												conn.send(lowercase__    )
  												print(f'Sent {data!r}'    )
  												__lowerCamelCase        =			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()
  
  
  
  
  
style_context: 
  
  
  """simple docstring"""
  
  
  
  
  # Lint as: python3
  
  import hashlib
  from typing import Union
  
  
  
  
  
  def 			a_   (  lowercase__   :Union[str, int, bytes]    ):
  			if isinstance(lowercase__, lowercase__    ):
  						# Data already in bytes, returns as it as
  						return hash_data
  			elif isinstance(lowercase__, lowercase__    ):
  						# We keep the data as it as for it ot be later encoded to UTF-8
  						# However replace `\\` with `/` for Windows compatibility
  						__lowerCamelCase        =			hash_data.replace("""\\""", """/"""    )
  			elif isinstance(lowercase__, lowercase__    ):
  						__lowerCamelCase        =			str(lowercase__    )
  			else:
  						# If data is not of the required type, raise error
  						raise InvalidKeyError(lowercase__    )
  
  			return hash_data.encode("""utf-8"""    )
  
  
  
  
  class  __snake_case      (lowerCamelCase     ):
  
  
  
  
  							def __init__(    self:						Union[str, Any]    ,       A_:						Tuple      ):
  										__lowerCamelCase        =			"""\nFAILURE TO GENERATE DATASET: Invalid key type detected"""
  										__lowerCamelCase        =			f'\nFound Key {hash_data} of type {type(A_      )}'
  										__lowerCamelCase        =			"""\nKeys should be either str, int or bytes type"""
  										super().__init__(f'{self.prefix}{self.err_msg}{self.suffix}'      )
  
  
  
  
  class  __snake_case      (lowerCamelCase     ):
  
  
  
  
  							def __init__(    self:						Any    ,       A_:						Dict    ,       A_:						List[Any]    ,       A_:						List[str]=""      ):
  										__lowerCamelCase        =			key
  										__lowerCamelCase        =			duplicate_key_indices
  										__lowerCamelCase        =			fix_msg
  										__lowerCamelCase        =			"""Found multiple examples generated with the same key"""
  										if len(A_      ) <= 20:
  													__lowerCamelCase        =			f'\nThe examples at index {", ".join(A_      )} have the key {key}'
  										else:
  													__lowerCamelCase        =			f'\nThe examples at index {", ".join(duplicate_key_indices[:20]      )}... ({len(A_      ) - 20} more) have the key {key}'
  										__lowerCamelCase        =			"""\n""" + fix_msg if fix_msg else """"""
  										super().__init__(f'{self.prefix}{self.err_msg}{self.suffix}'      )
  
  
  
  
  class  __snake_case      :
  
  
  
  
  							def __init__(    self:						Dict    ,       A_:						str      ):
  										__lowerCamelCase        =			hashlib.mda(_as_bytes(A_      )      )
  
  
  
  
  							def      __a      (    self:						int    ,       A_:						Union[str, int, bytes]      ):
  										__lowerCamelCase        =			self._split_mda.copy()
  										__lowerCamelCase        =			_as_bytes(A_      )
  										mda.update(A_      )
  										# Convert to integer with hexadecimal conversion
  										return int(mda.hexdigest()    ,       16      )
  
  
  
  
  