





import gc
import unittest

import torch
from parameterized import parameterized

from diffusers import AutoencoderKL
from diffusers.utils import floats_tensor, load_hf_numpy, require_torch_gpu, slow, torch_all_close, torch_device
from diffusers.utils.import_utils import is_xformers_available
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


enable_full_determinism()
class SCREAMING_SNAKE_CASE_						(					_UpperCAmelCase       ,				_UpperCAmelCase       ,				unittest.TestCase					):
						__magic_name__:			Any       =       AutoencoderKL
						__magic_name__:			Dict       =       'sample'
						__magic_name__:			List[str]       =       1E-2






						@property
						def UpperCAmelCase_				(      self      :      Any	)							->    List[Any]:







							"""simple docstring"""


							snake_case_		:			List[str]											=	4
							snake_case_		:			Union[str, Any]											=	3
							snake_case_		:			Optional[Any]											=	(32, 32)

							snake_case_		:			int											=	floats_tensor((batch_size, num_channels) + sizes	).to(__UpperCamelCase	)

							return {"sample": image}






						@property
						def UpperCAmelCase_				(      self      :      Tuple	)							->    Optional[int]:







							"""simple docstring"""


							return (3, 32, 32)






						@property
						def UpperCAmelCase_				(      self      :      Tuple	)							->    Any:







							"""simple docstring"""


							return (3, 32, 32)






						def UpperCAmelCase_				(      self      :      Dict	)							->    Dict:







							"""simple docstring"""


							snake_case_		:			Union[str, Any]											=	{
							    'block_out_channels': [32, 64],
							    'in_channels': 3,
							    'out_channels': 3,
							    'down_block_types': ['DownEncoderBlock2D', 'DownEncoderBlock2D'],
							    'up_block_types': ['UpDecoderBlock2D', 'UpDecoderBlock2D'],
							    'latent_channels': 4,
							}
							snake_case_		:			Union[str, Any]											=	self.dummy_input
							return init_dict, inputs_dict






						def UpperCAmelCase_				(      self      :      int	)							->    Any:







							"""simple docstring"""


							pass






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







							"""simple docstring"""


							pass






						@unittest.skipIf(torch_device == 'mps'		,   'Gradient checkpointing skipped on MPS'	)
						def UpperCAmelCase_				(      self      :      Optional[int]	)							->    List[Any]:







							"""simple docstring"""


							snake_case_						,snake_case_		:			Optional[int]											=	self.prepare_init_args_and_inputs_for_common()
							snake_case_		:			Optional[int]											=	self.model_class(**__UpperCamelCase	)
							model.to(__UpperCamelCase	)

							assert not model.is_gradient_checkpointing and model.training

							snake_case_		:			Tuple											=	model(**__UpperCamelCase	).sample
							# run the backwards pass on the model. For backwards pass, for simplicity purpose,
							# we won't calculate the loss and rather backprop on out.sum()
							model.zero_grad()

							snake_case_		:			int											=	torch.randn_like(__UpperCamelCase	)
							snake_case_		:			Optional[int]											=	(out - labels).mean()
							loss.backward()

							# re-instantiate the model now enabling gradient checkpointing
							snake_case_		:			Tuple											=	self.model_class(**__UpperCamelCase	)
							# clone model
							model_a.load_state_dict(model.state_dict()	)
							model_a.to(__UpperCamelCase	)
							model_a.enable_gradient_checkpointing()

							assert model_a.is_gradient_checkpointing and model_a.training

							snake_case_		:			Tuple											=	model_a(**__UpperCamelCase	).sample
							# run the backwards pass on the model. For backwards pass, for simplicity purpose,
							# we won't calculate the loss and rather backprop on out.sum()
							model_a.zero_grad()
							snake_case_		:			Any											=	(out_a - labels).mean()
							loss_a.backward()

							# compare the output and parameters gradients
							self.assertTrue((loss - loss_a).abs() < 1E-5	)
							snake_case_		:			int											=	dict(model.named_parameters()	)
							snake_case_		:			Optional[Any]											=	dict(model_a.named_parameters()	)
							for name, param in named_params.items():
								self.assertTrue(torch_all_close(param.grad.data		,   named_params_a[name].grad.data		,   atol=5E-5	)	)






						def UpperCAmelCase_				(      self      :      int	)							->    Optional[Any]:







							"""simple docstring"""


							snake_case_						,snake_case_		:			int											=	AutoencoderKL.from_pretrained('fusing/autoencoder-kl-dummy'		,   output_loading_info=__UpperCamelCase	)
							self.assertIsNotNone(__UpperCamelCase	)
							self.assertEqual(len(loading_info['missing_keys']	)		,   0	)

							model.to(__UpperCamelCase	)
							snake_case_		:			Dict											=	model(**self.dummy_input	)

							assert image is not None, "Make sure output is not None"






						def UpperCAmelCase_				(      self      :      Union[str, Any]	)							->    Dict:







							"""simple docstring"""


							snake_case_		:			Tuple											=	AutoencoderKL.from_pretrained('fusing/autoencoder-kl-dummy'	)
							snake_case_		:			List[str]											=	model.to(__UpperCamelCase	)
							model.eval()

							if torch_device == "mps":
								snake_case_		:			Optional[int]											=	torch.manual_seed(0	)
							else:
								snake_case_		:			str											=	torch.Generator(device=__UpperCamelCase	).manual_seed(0	)

							snake_case_		:			Union[str, Any]											=	torch.randn(
							    1		,   model.config.in_channels		,   model.config.sample_size		,   model.config.sample_size		,   generator=torch.manual_seed(0	)		,   )
							snake_case_		:			Dict											=	image.to(__UpperCamelCase	)
							with torch.no_grad():
								snake_case_		:			Optional[Any]											=	model(__UpperCamelCase		,   sample_posterior=__UpperCamelCase		,   generator=__UpperCamelCase	).sample

							snake_case_		:			Union[str, Any]											=	output[0, -1, -3:, -3:].flatten().cpu()

							# Since the VAE Gaussian prior's generator is seeded on the appropriate device,
							# the expected output slices are not the same for CPU and GPU.
							if torch_device == "mps":
								snake_case_		:			int											=	torch.tensor(
								    [
								        -4.0078E-01,
								        -3.8323E-04,
								        -1.2681E-01,
								        -1.1462E-01,
								        2.0095E-01,
								        1.0893E-01,
								        -8.8247E-02,
								        -3.0361E-01,
								        -9.8644E-03,
								    ]	)
							elif torch_device == "cpu":
								snake_case_		:			int											=	torch.tensor(
								    [-0.1_3_5_2, 0.0_8_7_8, 0.0_4_1_9, -0.0_8_1_8, -0.1_0_6_9, 0.0_6_8_8, -0.1_4_5_8, -0.4_4_4_6, -0.0_0_2_6]	)
							else:
								snake_case_		:			Union[str, Any]											=	torch.tensor(
								    [-0.2_4_2_1, 0.4_6_4_2, 0.2_5_0_7, -0.0_4_3_8, 0.0_6_8_2, 0.3_1_6_0, -0.2_0_1_8, -0.0_7_2_7, 0.2_4_8_5]	)

							self.assertTrue(torch_all_close(__UpperCamelCase		,   __UpperCamelCase		,   rtol=1E-2	)	)
@slow
class SCREAMING_SNAKE_CASE_						(					unittest.TestCase					):






						def UpperCAmelCase_				(      self      :      int		,   _A      :      List[str]		,   _A      :      str	)							->    str:







							"""simple docstring"""


							return F"""gaussian_noise_s={seed}_shape={'_'.join([str(__UpperCamelCase	) for s in shape]	)}.npy"""






						def UpperCAmelCase_				(      self      :      List[str]	)							->    str:







							"""simple docstring"""


							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()






						def UpperCAmelCase_				(      self      :      Tuple		,   _A      :      Tuple=0		,   _A      :      List[Any]=(4, 3, 512, 512)		,   _A      :      Optional[Any]=False	)							->    Union[str, Any]:







							"""simple docstring"""


							snake_case_		:			Dict											=	torch.floataa if fpaa else torch.floataa
							snake_case_		:			Optional[int]											=	torch.from_numpy(load_hf_numpy(self.get_file_format(__UpperCamelCase		,   __UpperCamelCase	)	)	).to(__UpperCamelCase	).to(__UpperCamelCase	)
							return image






						def UpperCAmelCase_				(      self      :      Dict		,   _A      :      Optional[int]="CompVis/stable-diffusion-v1-4"		,   _A      :      int=False	)							->    Optional[Any]:







							"""simple docstring"""


							snake_case_		:			Optional[int]											=	'fp16' if fpaa else None
							snake_case_		:			Optional[int]											=	torch.floataa if fpaa else torch.floataa

							snake_case_		:			Dict											=	AutoencoderKL.from_pretrained(
							    __UpperCamelCase		,   subfolder='vae'		,   torch_dtype=__UpperCamelCase		,   revision=__UpperCamelCase		,   )
							model.to(__UpperCamelCase	).eval()

							return model






						def UpperCAmelCase_				(      self      :      Union[str, Any]		,   _A      :      Tuple=0	)							->    Optional[int]:







							"""simple docstring"""


							if torch_device == "mps":
								return torch.manual_seed(__UpperCamelCase	)
							return torch.Generator(device=__UpperCamelCase	).manual_seed(__UpperCamelCase	)






						@parameterized.expand(
						    [
						        # fmt: off
						        [33, [-0.1_6_0_3, 0.9_8_7_8, -0.0_4_9_5, -0.0_7_9_0, -0.2_7_0_9, 0.8_3_7_5, -0.2_0_6_0, -0.0_8_2_4], [-0.2_3_9_5, 0.0_0_9_8, 0.0_1_0_2, -0.0_7_0_9, -0.2_8_4_0, -0.0_2_7_4, -0.0_7_1_8, -0.1_8_2_4]],
						        [47, [-0.2_3_7_6, 0.1_1_6_8, 0.1_3_3_2, -0.4_8_4_0, -0.2_5_0_8, -0.0_7_9_1, -0.0_4_9_3, -0.4_0_8_9], [0.0_3_5_0, 0.0_8_4_7, 0.0_4_6_7, 0.0_3_4_4, -0.0_8_4_2, -0.0_5_4_7, -0.0_6_3_3, -0.1_1_3_1]],
						        # fmt: on
						    ]	)
						def UpperCAmelCase_				(      self      :      Union[str, Any]		,   _A      :      Dict		,   _A      :      Any		,   _A      :      Any	)							->    Tuple:







							"""simple docstring"""


							snake_case_		:			int											=	self.get_sd_vae_model()
							snake_case_		:			List[str]											=	self.get_sd_image(__UpperCamelCase	)
							snake_case_		:			List[Any]											=	self.get_generator(__UpperCamelCase	)

							with torch.no_grad():
								snake_case_		:			Optional[int]											=	model(__UpperCamelCase		,   generator=__UpperCamelCase		,   sample_posterior=__UpperCamelCase	).sample

							assert sample.shape == image.shape

							snake_case_		:			Any											=	sample[-1, -2:, -2:, :2].flatten().float().cpu()
							snake_case_		:			Dict											=	torch.tensor(expected_slice_mps if torch_device == 'mps' else expected_slice	)

							assert torch_all_close(__UpperCamelCase		,   __UpperCamelCase		,   atol=3E-3	)






						@parameterized.expand(
						    [
						        # fmt: off
						        [33, [-0.0_5_1_3, 0.0_2_8_9, 1.3_7_9_9, 0.2_1_6_6, -0.2_5_7_3, -0.0_8_7_1, 0.5_1_0_3, -0.0_9_9_9]],
						        [47, [-0.4_1_2_8, -0.1_3_2_0, -0.3_7_0_4, 0.1_9_6_5, -0.4_1_1_6, -0.2_3_3_2, -0.3_3_4_0, 0.2_2_4_7]],
						        # fmt: on
						    ]	)
						@require_torch_gpu
						def UpperCAmelCase_				(      self      :      Union[str, Any]		,   _A      :      int		,   _A      :      str	)							->    Any:







							"""simple docstring"""


							snake_case_		:			List[Any]											=	self.get_sd_vae_model(fpaa=__UpperCamelCase	)
							snake_case_		:			List[Any]											=	self.get_sd_image(__UpperCamelCase		,   fpaa=__UpperCamelCase	)
							snake_case_		:			str											=	self.get_generator(__UpperCamelCase	)

							with torch.no_grad():
								snake_case_		:			List[Any]											=	model(__UpperCamelCase		,   generator=__UpperCamelCase		,   sample_posterior=__UpperCamelCase	).sample

							assert sample.shape == image.shape

							snake_case_		:			Optional[int]											=	sample[-1, -2:, :2, -2:].flatten().float().cpu()
							snake_case_		:			Union[str, Any]											=	torch.tensor(__UpperCamelCase	)

							assert torch_all_close(__UpperCamelCase		,   __UpperCamelCase		,   atol=1E-2	)






						@parameterized.expand(
						    [
						        # fmt: off
						        [33, [-0.1_6_0_9, 0.9_8_6_6, -0.0_4_8_7, -0.0_7_7_7, -0.2_7_1_6, 0.8_3_6_8, -0.2_0_5_5, -0.0_8_1_4], [-0.2_3_9_5, 0.0_0_9_8, 0.0_1_0_2, -0.0_7_0_9, -0.2_8_4_0, -0.0_2_7_4, -0.0_7_1_8, -0.1_8_2_4]],
						        [47, [-0.2_3_7_7, 0.1_1_4_7, 0.1_3_3_3, -0.4_8_4_1, -0.2_5_0_6, -0.0_8_0_5, -0.0_4_9_1, -0.4_0_8_5], [0.0_3_5_0, 0.0_8_4_7, 0.0_4_6_7, 0.0_3_4_4, -0.0_8_4_2, -0.0_5_4_7, -0.0_6_3_3, -0.1_1_3_1]],
						        # fmt: on
						    ]	)
						def UpperCAmelCase_				(      self      :      int		,   _A      :      int		,   _A      :      Optional[Any]		,   _A      :      Any	)							->    str:







							"""simple docstring"""


							snake_case_		:			Dict											=	self.get_sd_vae_model()
							snake_case_		:			int											=	self.get_sd_image(__UpperCamelCase	)

							with torch.no_grad():
								snake_case_		:			int											=	model(__UpperCamelCase	).sample

							assert sample.shape == image.shape

							snake_case_		:			str											=	sample[-1, -2:, -2:, :2].flatten().float().cpu()
							snake_case_		:			str											=	torch.tensor(expected_slice_mps if torch_device == 'mps' else expected_slice	)

							assert torch_all_close(__UpperCamelCase		,   __UpperCamelCase		,   atol=3E-3	)






						@parameterized.expand(
						    [
						        # fmt: off
						        [13, [-0.2_0_5_1, -0.1_8_0_3, -0.2_3_1_1, -0.2_1_1_4, -0.3_2_9_2, -0.3_5_7_4, -0.2_9_5_3, -0.3_3_2_3]],
						        [37, [-0.2_6_3_2, -0.2_6_2_5, -0.2_1_9_9, -0.2_7_4_1, -0.4_5_3_9, -0.4_9_9_0, -0.3_7_2_0, -0.4_9_2_5]],
						        # fmt: on
						    ]	)
						@require_torch_gpu
						def UpperCAmelCase_				(      self      :      Optional[int]		,   _A      :      List[str]		,   _A      :      List[str]	)							->    Optional[int]:







							"""simple docstring"""


							snake_case_		:			Dict											=	self.get_sd_vae_model()
							snake_case_		:			Union[str, Any]											=	self.get_sd_image(__UpperCamelCase		,   shape=(3, 4, 64, 64)	)

							with torch.no_grad():
								snake_case_		:			Union[str, Any]											=	model.decode(__UpperCamelCase	).sample

							assert list(sample.shape	) == [3, 3, 512, 512]

							snake_case_		:			str											=	sample[-1, -2:, :2, -2:].flatten().cpu()
							snake_case_		:			Any											=	torch.tensor(__UpperCamelCase	)

							assert torch_all_close(__UpperCamelCase		,   __UpperCamelCase		,   atol=1E-3	)






						@parameterized.expand(
						    [
						        # fmt: off
						        [27, [-0.0_3_6_9, 0.0_2_0_7, -0.0_7_7_6, -0.0_6_8_2, -0.1_7_4_7, -0.1_9_3_0, -0.1_4_6_5, -0.2_0_3_9]],
						        [16, [-0.1_6_2_8, -0.2_1_3_4, -0.2_7_4_7, -0.2_6_4_2, -0.3_7_7_4, -0.4_4_0_4, -0.3_6_8_7, -0.4_2_7_7]],
						        # fmt: on
						    ]	)
						@require_torch_gpu
						def UpperCAmelCase_				(      self      :      List[str]		,   _A      :      Optional[Any]		,   _A      :      Union[str, Any]	)							->    List[Any]:







							"""simple docstring"""


							snake_case_		:			Any											=	self.get_sd_vae_model(fpaa=__UpperCamelCase	)
							snake_case_		:			Optional[Any]											=	self.get_sd_image(__UpperCamelCase		,   shape=(3, 4, 64, 64)		,   fpaa=__UpperCamelCase	)

							with torch.no_grad():
								snake_case_		:			str											=	model.decode(__UpperCamelCase	).sample

							assert list(sample.shape	) == [3, 3, 512, 512]

							snake_case_		:			Dict											=	sample[-1, -2:, :2, -2:].flatten().float().cpu()
							snake_case_		:			str											=	torch.tensor(__UpperCamelCase	)

							assert torch_all_close(__UpperCamelCase		,   __UpperCamelCase		,   atol=5E-3	)






						@parameterized.expand([(13,), (16,), (27,)]	)
						@require_torch_gpu
						@unittest.skipIf(not is_xformers_available()		,   reason='xformers is not required when using PyTorch 2.0.'	)
						def UpperCAmelCase_				(      self      :      Optional[Any]		,   _A      :      List[str]	)							->    Any:







							"""simple docstring"""


							snake_case_		:			Dict											=	self.get_sd_vae_model(fpaa=__UpperCamelCase	)
							snake_case_		:			Union[str, Any]											=	self.get_sd_image(__UpperCamelCase		,   shape=(3, 4, 64, 64)		,   fpaa=__UpperCamelCase	)

							with torch.no_grad():
								snake_case_		:			Any											=	model.decode(__UpperCamelCase	).sample

							model.enable_xformers_memory_efficient_attention()
							with torch.no_grad():
								snake_case_		:			int											=	model.decode(__UpperCamelCase	).sample

							assert list(sample.shape	) == [3, 3, 512, 512]

							assert torch_all_close(__UpperCamelCase		,   __UpperCamelCase		,   atol=1E-1	)






						@parameterized.expand([(13,), (16,), (37,)]	)
						@require_torch_gpu
						@unittest.skipIf(not is_xformers_available()		,   reason='xformers is not required when using PyTorch 2.0.'	)
						def UpperCAmelCase_				(      self      :      Union[str, Any]		,   _A      :      Dict	)							->    Tuple:







							"""simple docstring"""


							snake_case_		:			List[Any]											=	self.get_sd_vae_model()
							snake_case_		:			Optional[Any]											=	self.get_sd_image(__UpperCamelCase		,   shape=(3, 4, 64, 64)	)

							with torch.no_grad():
								snake_case_		:			Optional[Any]											=	model.decode(__UpperCamelCase	).sample

							model.enable_xformers_memory_efficient_attention()
							with torch.no_grad():
								snake_case_		:			int											=	model.decode(__UpperCamelCase	).sample

							assert list(sample.shape	) == [3, 3, 512, 512]

							assert torch_all_close(__UpperCamelCase		,   __UpperCamelCase		,   atol=1E-2	)






						@parameterized.expand(
						    [
						        # fmt: off
						        [33, [-0.3_0_0_1, 0.0_9_1_8, -2.6_9_8_4, -3.9_7_2_0, -3.2_0_9_9, -5.0_3_5_3, 1.7_3_3_8, -0.2_0_6_5, 3.4_2_6_7]],
						        [47, [-1.5_0_3_0, -4.3_8_7_1, -6.0_3_5_5, -9.1_1_5_7, -1.6_6_6_1, -2.7_8_5_3, 2.1_6_0_7, -5.0_8_2_3, 2.5_6_3_3]],
						        # fmt: on
						    ]	)
						def UpperCAmelCase_				(      self      :      str		,   _A      :      Tuple		,   _A      :      Optional[Any]	)							->    Optional[int]:







							"""simple docstring"""


							snake_case_		:			str											=	self.get_sd_vae_model()
							snake_case_		:			Any											=	self.get_sd_image(__UpperCamelCase	)
							snake_case_		:			Union[str, Any]											=	self.get_generator(__UpperCamelCase	)

							with torch.no_grad():
								snake_case_		:			int											=	model.encode(__UpperCamelCase	).latent_dist
								snake_case_		:			Any											=	dist.sample(generator=__UpperCamelCase	)

							assert list(sample.shape	) == [image.shape[0], 4] + [i // 8 for i in image.shape[2:]]

							snake_case_		:			Union[str, Any]											=	sample[0, -1, -3:, -3:].flatten().cpu()
							snake_case_		:			List[str]											=	torch.tensor(__UpperCamelCase	)

							snake_case_		:			Dict											=	3E-3 if torch_device != 'mps' else 1E-2
							assert torch_all_close(__UpperCamelCase		,   __UpperCamelCase		,   atol=__UpperCamelCase	)








from statistics import mean

import numpy as np


def 							SCREAMING_SNAKE_CASE__						(    __a   , __a   , __a   , __a   ):
	snake_case_		:			Optional[Any]											=	0
	# Number of processes finished
	snake_case_		:			List[str]											=	0
	# Displays the finished process.
	# If it is 0, the performance is completed if it is 1, before the performance.
	snake_case_		:			str											=	[0] * no_of_process
	# List to include calculation results
	snake_case_		:			Optional[int]											=	[0] * no_of_process

	# Sort by arrival time.
	snake_case_		:			str											=	[burst_time[i] for i in np.argsort(__a   )]
	snake_case_		:			str											=	[process_name[i] for i in np.argsort(__a   )]
	arrival_time.sort()

	while no_of_process > finished_process_count:
		snake_case_		:			int											=	0
		while finished_process[i] == 1:
			i += 1
		if current_time < arrival_time[i]:
			snake_case_		:			str											=	arrival_time[i]

		snake_case_		:			Optional[Any]											=	0
		# Index showing the location of the process being performed
		snake_case_		:			Tuple											=	0
		# Saves the current response ratio.
		snake_case_		:			List[Any]											=	0
		for i in range(0   , __a   ):
			if finished_process[i] == 0 and arrival_time[i] <= current_time:
				snake_case_		:			Optional[Any]											=	(burst_time[i] + (current_time - arrival_time[i])) / burst_time[
				    i
				]
			if response_ratio < temp:
				snake_case_		:			Optional[int]											=	temp
				snake_case_		:			Optional[Any]											=	i

        # Calculate the turn around time
		snake_case_		:			Any											=	current_time + burst_time[loc] - arrival_time[loc]
		current_time += burst_time[loc]
		# Indicates that the process has been performed.
		snake_case_		:			Optional[Any]											=	1
		# Increase finished_process_count by 1
		finished_process_count += 1

	return turn_around_time


def 							SCREAMING_SNAKE_CASE__						(    __a   , __a   , __a   , __a   ):
	snake_case_		:			List[Any]											=	[0] * no_of_process
	for i in range(0   , __a   ):
		snake_case_		:			Optional[int]											=	turn_around_time[i] - burst_time[i]
	return waiting_time


if __name__ == "__main__":
						_SCREAMING_SNAKE_CASE      	=		5
						_SCREAMING_SNAKE_CASE      	=		["""A""", """B""", """C""", """D""", """E"""]
						_SCREAMING_SNAKE_CASE      	=		[1, 2, 3, 4, 5]
						_SCREAMING_SNAKE_CASE      	=		[1, 2, 3, 4, 5]

						_SCREAMING_SNAKE_CASE      	=		calculate_turn_around_time(
						    process_name, arrival_time, burst_time, no_of_process
						)
						_SCREAMING_SNAKE_CASE      	=		calculate_waiting_time(
						    process_name, turn_around_time, burst_time, no_of_process
						)

						print("""Process name \tArrival time \tBurst time \tTurn around time \tWaiting time""")
						for i in range(0, no_of_process):
												print(
												    F'''{process_name[i]}\t\t{arrival_time[i]}\t\t{burst_time[i]}\t\t'''
												    F'''{turn_around_time[i]}\t\t\t{waiting_time[i]}'''
												)

						print(F'''average waiting time : {mean(waiting_time):.5f}''')
						print(F'''average turn around time : {mean(turn_around_time):.5f}''')

