code: 
  '''simple docstring'''
  def       _UpperCamelCase	(					SCREAMING_SNAKE_CASE__ = "mytext.txt"   ,					SCREAMING_SNAKE_CASE__ = False )     ->       Optional[int]:
  
  
  		'''simple docstring'''
  
  
  		import socket
  
  		snake_case     :					Tuple     =	1_2312  # Reserve a port for your service.
  		snake_case     :					str     =	socket.socket()  # Create a socket object
  		snake_case     :					Optional[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:
  				snake_case ,snake_case     :					Tuple     =	sock.accept()  # Establish connection with client.
  				print(F'Got connection from {addr}' )
  				snake_case     :					List[str]     =	conn.recv(1024 )
  				print(F'Server received: {data = }' )
  
  				with open(lowercase__   ,					'''rb''' ) as in_file:
  						snake_case     :					List[str]     =	in_file.read(1024 )
  						while data:
  								conn.send(lowercase__ )
  								print(F'Sent {data!r}' )
  								snake_case     :					List[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()
  
  
  
style_context: 
  '''simple docstring'''
  import numpy as np
  
  
  
  
  def       _UpperCamelCase	(					SCREAMING_SNAKE_CASE__ )     ->       Optional[Any]:
  
  
  		'''simple docstring'''
  
  
  		snake_case ,snake_case     :					str     =	a.shape
  		snake_case     :					Union[str, Any]     =	min(SCREAMING_SNAKE_CASE__   ,					SCREAMING_SNAKE_CASE__ )
  		snake_case     :					List[Any]     =	np.eye(SCREAMING_SNAKE_CASE__ )
  		snake_case     :					Union[str, Any]     =	a.copy()
  
  		for k in range(t - 1 ):
  				# select a column of modified matrix A':
  				snake_case     :					Union[str, Any]     =	r[k:, [k]]
  				# construct first basis vector
  				snake_case     :					str     =	np.zeros_like(SCREAMING_SNAKE_CASE__ )
  				snake_case     :					List[str]     =	1.0
  				# determine scaling factor
  				snake_case     :					int     =	np.linalg.norm(SCREAMING_SNAKE_CASE__ )
  				# construct vector v for Householder reflection
  				snake_case     :					Optional[int]     =	x + np.sign(x[0] ) * alpha * ea
  				v /= np.linalg.norm(SCREAMING_SNAKE_CASE__ )
  
  				# construct the Householder matrix
  				snake_case     :					Tuple     =	np.eye(m - k ) - 2.0 * v @ v.T
  				# pad with ones and zeros as necessary
  				snake_case     :					int     =	np.block([[np.eye(SCREAMING_SNAKE_CASE__ ), np.zeros((k, m - k) )], [np.zeros((m - k, k) ), q_k]] )
  
  				snake_case     :					int     =	q @ q_k.T
  				snake_case     :					Dict     =	q_k @ r
  
  		return q, r
  
  
  if __name__ == "__main__":
  						import doctest
  
  						doctest.testmod()
  
  
  