code: 
  
  
  import math
  import os
  
  import cva
  import numpy as np
  
  __lowerCamelCase       :       Optional[int]				   =			2_5_5.0
  
  
  
  def 	SCREAMING_SNAKE_CASE__						(							snake_case_,	snake_case_	)			->							List[str]:
  				A__     :							Any   				=np.mean((original - contrast) ** 2	)
  				if mse == 0:
  								return 1_0_0
  
  				return 2_0 * math.logaa(PIXEL_MAX / math.sqrt(UpperCamelCase__	)	)
  
  
  
  def 	SCREAMING_SNAKE_CASE__						(							)			->							Optional[int]:
  				A__     :							Optional[int]   				=os.path.dirname(os.path.realpath(UpperCamelCase__	)	)
  				# Loading images (original image and compressed image)
  				A__     :							Tuple   				=cva.imread(os.path.join(UpperCamelCase__,	'''image_data/original_image.png'''	)	)
  				A__     :							Union[str, Any]   				=cva.imread(os.path.join(UpperCamelCase__,	'''image_data/compressed_image.png'''	),	1	)
  
  				A__     :							str   				=cva.imread(os.path.join(UpperCamelCase__,	'''image_data/PSNR-example-base.png'''	)	)
  				A__     :							Dict   				=cva.imread(
  				    os.path.join(UpperCamelCase__,	'''image_data/PSNR-example-comp-10.jpg'''	),	1	)
  
  				# Value expected: 29.73dB
  				print('''-- First Test --'''	)
  				print(f'PSNR value is {peak_signal_to_noise_ratio(UpperCamelCase__,	UpperCamelCase__	)} dB'	)
  
  				# # Value expected: 31.53dB (Wikipedia Example)
  				print('''\n-- Second Test --'''	)
  				print(f'PSNR value is {peak_signal_to_noise_ratio(UpperCamelCase__,	UpperCamelCase__	)} dB'	)
  
  
  if __name__ == "__main__":
  						main()
  
  
  
  
style_context: 
  
  
  from __future__ import annotations
  
  
  
  def   SCREAMING_SNAKE_CASE__						(							snake_case_	)			->							list[int]:
  				A__     :							Optional[int]   				=[0] * len(snake_case_	)
  				for i in range(1,	len(snake_case_	)	):
  								A__     :							List[Any]   				=duration_times[i - 1] + waiting_times[i - 1]
  				return waiting_times
  
  
  
  def   SCREAMING_SNAKE_CASE__						(							snake_case_,	snake_case_	)			->							list[int]:
  				return [
  				    duration_time + waiting_times[i]
  				    for i, duration_time in enumerate(snake_case_	)
  				]
  
  
  
  def   SCREAMING_SNAKE_CASE__						(							snake_case_	)			->							float:
  				return sum(snake_case_	) / len(snake_case_	)
  
  
  
  def   SCREAMING_SNAKE_CASE__						(							snake_case_	)			->							float:
  				return sum(snake_case_	) / len(snake_case_	)
  
  
  if __name__ == "__main__":
  						# process id's
  						__lowerCamelCase       :       List[str]				   =			[1, 2, 3]
  
  						# ensure that we actually have processes
  						if len(processes) == 0:
  												print("Zero amount of processes")
  												raise SystemExit(0)
  
  						# duration time of all processes
  						__lowerCamelCase       :       Dict				   =			[19, 8, 9]
  
  						# ensure we can match each id to a duration time
  						if len(duration_times) != len(processes):
  												print("Unable to match all id's with their duration time")
  												raise SystemExit(0)
  
  						# get the waiting times and the turnaround times
  						__lowerCamelCase       :       int				   =			calculate_waiting_times(duration_times)
  						__lowerCamelCase       :       Optional[int]				   =			calculate_turnaround_times(duration_times, waiting_times)
  
  						# get the average times
  						__lowerCamelCase       :       List[str]				   =			calculate_average_waiting_time(waiting_times)
  						__lowerCamelCase       :       Dict				   =			calculate_average_turnaround_time(turnaround_times)
  
  						# print all the results
  						print("Process ID\tDuration Time\tWaiting Time\tTurnaround Time")
  						for i, process in enumerate(processes):
  												print(
  												    F"{process}\t\t{duration_times[i]}\t\t{waiting_times[i]}\t\t"
  												    F"{turnaround_times[i]}"
  												)
  						print(F"Average waiting time = {average_waiting_time}")
  						print(F"Average turn around time = {average_turnaround_time}")
  
  
  
  