
'''simple docstring'''

import gc
import math
import unittest

import torch

from diffusers import UNetaDModel
from diffusers.utils import floats_tensor, logging, slow, torch_all_close, torch_device
from diffusers.utils.testing_utils import enable_full_determinism

from .test_modeling_common import ModelTesterMixin, UNetTesterMixin


snake_case									=    logging.get_logger(__name__)

enable_full_determinism()




class    lowerCAmelCase       (     UpperCamelCase_    ,  UpperCamelCase_    ,  unittest.TestCase  ):
 A_				:				str	=			UNetaDModel
 A_				:				List[str]	=			"""sample"""


 @property
 def    _A	(    self  : Tuple    ):
  '''simple docstring'''

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

  lowerCAmelCase__     :   int     		=	floats_tensor((batch_size, num_channels) + sizes    ).to(a__    )
  lowerCAmelCase__     :   Tuple     		=	torch.tensor([10]    ).to(a__    )

  return {"sample": noise, "timestep": time_step}


 @property
 def    _A	(    self  : List[str]    ):
  '''simple docstring'''

  return (3, 32, 32)


 @property
 def    _A	(    self  : str    ):
  '''simple docstring'''

  return (3, 32, 32)


 def    _A	(    self  : List[str]    ):
  '''simple docstring'''

  lowerCAmelCase__     :   int     		=	{
      "block_out_channels": (32, 64),
      "down_block_types": ("DownBlock2D", "AttnDownBlock2D"),
      "up_block_types": ("AttnUpBlock2D", "UpBlock2D"),
      "attention_head_dim": 3,
      "out_channels": 3,
      "in_channels": 3,
      "layers_per_block": 2,
      "sample_size": 32,
  }
  lowerCAmelCase__     :   str     		=	self.dummy_input
  return init_dict, inputs_dict




class    lowerCAmelCase       (     UpperCamelCase_    ,  UpperCamelCase_    ,  unittest.TestCase  ):
 A_				:				Dict	=			UNetaDModel
 A_				:				int	=			"""sample"""


 @property
 def    _A	(    self  : str    ):
  '''simple docstring'''

  lowerCAmelCase__     :   Optional[Any]     		=	4
  lowerCAmelCase__     :   List[Any]     		=	4
  lowerCAmelCase__     :   str     		=	(32, 32)

  lowerCAmelCase__     :   Union[str, Any]     		=	floats_tensor((batch_size, num_channels) + sizes    ).to(a__    )
  lowerCAmelCase__     :   List[Any]     		=	torch.tensor([10]    ).to(a__    )

  return {"sample": noise, "timestep": time_step}


 @property
 def    _A	(    self  : Any    ):
  '''simple docstring'''

  return (4, 32, 32)


 @property
 def    _A	(    self  : Any    ):
  '''simple docstring'''

  return (4, 32, 32)


 def    _A	(    self  : Optional[int]    ):
  '''simple docstring'''

  lowerCAmelCase__     :   Any     		=	{
      "sample_size": 32,
      "in_channels": 4,
      "out_channels": 4,
      "layers_per_block": 2,
      "block_out_channels": (32, 64),
      "attention_head_dim": 32,
      "down_block_types": ("DownBlock2D", "DownBlock2D"),
      "up_block_types": ("UpBlock2D", "UpBlock2D"),
  }
  lowerCAmelCase__     :   Dict     		=	self.dummy_input
  return init_dict, inputs_dict


 def    _A	(    self  : List[str]    ):
  '''simple docstring'''

  lowerCAmelCase__		,     lowerCAmelCase__     :   List[str]     		=	UNetaDModel.from_pretrained("fusing/unet-ldm-dummy-update"			,							output_loading_info=a__    )

  self.assertIsNotNone(a__    )
  self.assertEqual(len(loading_info["missing_keys"]    )			,							0    )

  model.to(a__    )
  lowerCAmelCase__     :   str     		=	model(**self.dummy_input    ).sample

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


 @unittest.skipIf(torch_device != "cuda"			,							"This test is supposed to run on GPU"    )
 def    _A	(    self  : Union[str, Any]    ):
  '''simple docstring'''

  lowerCAmelCase__		,     lowerCAmelCase__     :   List[str]     		=	UNetaDModel.from_pretrained("fusing/unet-ldm-dummy-update"			,							output_loading_info=a__    )
  model.to(a__    )
  lowerCAmelCase__     :   Union[str, Any]     		=	model(**self.dummy_input    ).sample

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


 @unittest.skipIf(torch_device != "cuda"			,							"This test is supposed to run on GPU"    )
 def    _A	(    self  : str    ):
  '''simple docstring'''

  lowerCAmelCase__		,     lowerCAmelCase__     :   int     		=	UNetaDModel.from_pretrained("fusing/unet-ldm-dummy-update"			,							output_loading_info=a__    )
  model_accelerate.to(a__    )
  model_accelerate.eval()

  lowerCAmelCase__     :   Union[str, Any]     		=	torch.randn(
      1			,							model_accelerate.config.in_channels			,							model_accelerate.config.sample_size			,							model_accelerate.config.sample_size			,							generator=torch.manual_seed(0    )			,							)
  lowerCAmelCase__     :   Tuple     		=	noise.to(a__    )
  lowerCAmelCase__     :   str     		=	torch.tensor([10] * noise.shape[0]    ).to(a__    )

  lowerCAmelCase__     :   Optional[int]     		=	model_accelerate(a__			,							a__    )["sample"]

  # two models don't need to stay in the device at the same time
  del model_accelerate
  torch.cuda.empty_cache()
  gc.collect()

  lowerCAmelCase__		,     lowerCAmelCase__     :   Tuple     		=	UNetaDModel.from_pretrained(
      "fusing/unet-ldm-dummy-update"			,							output_loading_info=a__			,							low_cpu_mem_usage=a__    )
  model_normal_load.to(a__    )
  model_normal_load.eval()
  lowerCAmelCase__     :   Any     		=	model_normal_load(a__			,							a__    )["sample"]

  assert torch_all_close(a__			,							a__			,							rtol=1e-3    )


 def    _A	(    self  : int    ):
  '''simple docstring'''

  lowerCAmelCase__     :   Any     		=	UNetaDModel.from_pretrained("fusing/unet-ldm-dummy-update"    )
  model.eval()
  model.to(a__    )

  lowerCAmelCase__     :   Optional[Any]     		=	torch.randn(
      1			,							model.config.in_channels			,							model.config.sample_size			,							model.config.sample_size			,							generator=torch.manual_seed(0    )			,							)
  lowerCAmelCase__     :   Dict     		=	noise.to(a__    )
  lowerCAmelCase__     :   List[Any]     		=	torch.tensor([10] * noise.shape[0]    ).to(a__    )

  with torch.no_grad():
   lowerCAmelCase__     :   List[str]     		=	model(a__			,							a__    ).sample

  lowerCAmelCase__     :   Tuple     		=	output[0, -1, -3:, -3:].flatten().cpu()
  # fmt: off
  lowerCAmelCase__     :   str     		=	torch.tensor([-13.3258, -20.1100, -15.9873, -17.6617, -23.0596, -17.9419, -13.3675, -16.1889, -12.3800]    )
  # fmt: on

  self.assertTrue(torch_all_close(a__			,							a__			,							rtol=1e-3    )    )




class    lowerCAmelCase       (     UpperCamelCase_    ,  UpperCamelCase_    ,  unittest.TestCase  ):
 A_				:				Dict	=			UNetaDModel
 A_				:				str	=			"""sample"""


 @property
 def    _A	(    self  : str			,							a__  : List[Any]=(32, 32)    ):
  '''simple docstring'''

  lowerCAmelCase__     :   Union[str, Any]     		=	4
  lowerCAmelCase__     :   Union[str, Any]     		=	3

  lowerCAmelCase__     :   str     		=	floats_tensor((batch_size, num_channels) + sizes    ).to(a__    )
  lowerCAmelCase__     :   Optional[Any]     		=	torch.tensor(batch_size * [10]    ).to(dtype=torch.intaa			,							device=a__    )

  return {"sample": noise, "timestep": time_step}


 @property
 def    _A	(    self  : Optional[Any]    ):
  '''simple docstring'''

  return (3, 32, 32)


 @property
 def    _A	(    self  : List[Any]    ):
  '''simple docstring'''

  return (3, 32, 32)


 def    _A	(    self  : Optional[Any]    ):
  '''simple docstring'''

  lowerCAmelCase__     :   int     		=	{
      "block_out_channels": [32, 64, 64, 64],
      "in_channels": 3,
      "layers_per_block": 1,
      "out_channels": 3,
      "time_embedding_type": "fourier",
      "norm_eps": 1e-6,
      "mid_block_scale_factor": math.sqrt(2.0    ),
      "norm_num_groups": None,
      "down_block_types": [
          "SkipDownBlock2D",
          "AttnSkipDownBlock2D",
          "SkipDownBlock2D",
          "SkipDownBlock2D",
      ],
      "up_block_types": [
          "SkipUpBlock2D",
          "SkipUpBlock2D",
          "AttnSkipUpBlock2D",
          "SkipUpBlock2D",
      ],
  }
  lowerCAmelCase__     :   Dict     		=	self.dummy_input
  return init_dict, inputs_dict


 @slow
 def    _A	(    self  : Tuple    ):
  '''simple docstring'''

  lowerCAmelCase__		,     lowerCAmelCase__     :   int     		=	UNetaDModel.from_pretrained("google/ncsnpp-celebahq-256"			,							output_loading_info=a__    )
  self.assertIsNotNone(a__    )
  self.assertEqual(len(loading_info["missing_keys"]    )			,							0    )

  model.to(a__    )
  lowerCAmelCase__     :   Optional[int]     		=	self.dummy_input
  lowerCAmelCase__     :   int     		=	floats_tensor((4, 3) + (256, 256)    ).to(a__    )
  lowerCAmelCase__     :   List[str]     		=	noise
  lowerCAmelCase__     :   Any     		=	model(**a__    )

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


 @slow
 def    _A	(    self  : Tuple    ):
  '''simple docstring'''

  lowerCAmelCase__     :   List[Any]     		=	UNetaDModel.from_pretrained("google/ncsnpp-celebahq-256"    )
  model.to(a__    )

  lowerCAmelCase__     :   Any     		=	4
  lowerCAmelCase__     :   Optional[Any]     		=	3
  lowerCAmelCase__     :   List[Any]     		=	(256, 256)

  lowerCAmelCase__     :   Optional[int]     		=	torch.ones((batch_size, num_channels) + sizes    ).to(a__    )
  lowerCAmelCase__     :   List[Any]     		=	torch.tensor(batch_size * [1e-4]    ).to(a__    )

  with torch.no_grad():
   lowerCAmelCase__     :   List[str]     		=	model(a__			,							a__    ).sample

  lowerCAmelCase__     :   Tuple     		=	output[0, -3:, -3:, -1].flatten().cpu()
  # fmt: off
  lowerCAmelCase__     :   Tuple     		=	torch.tensor([-4842.8691, -6499.6631, -3800.1953, -7978.2686, -10980.7129, -20028.8535, 8148.2822, 2342.2905, 567.7608]    )
  # fmt: on

  self.assertTrue(torch_all_close(a__			,							a__			,							rtol=1e-2    )    )


 def    _A	(    self  : List[str]    ):
  '''simple docstring'''

  lowerCAmelCase__     :   Optional[int]     		=	UNetaDModel.from_pretrained("fusing/ncsnpp-ffhq-ve-dummy-update"    )
  model.to(a__    )

  lowerCAmelCase__     :   int     		=	4
  lowerCAmelCase__     :   List[str]     		=	3
  lowerCAmelCase__     :   List[Any]     		=	(32, 32)

  lowerCAmelCase__     :   Tuple     		=	torch.ones((batch_size, num_channels) + sizes    ).to(a__    )
  lowerCAmelCase__     :   List[str]     		=	torch.tensor(batch_size * [1e-4]    ).to(a__    )

  with torch.no_grad():
   lowerCAmelCase__     :   Optional[Any]     		=	model(a__			,							a__    ).sample

  lowerCAmelCase__     :   List[Any]     		=	output[0, -3:, -3:, -1].flatten().cpu()
  # fmt: off
  lowerCAmelCase__     :   List[Any]     		=	torch.tensor([-0.0325, -0.0900, -0.0869, -0.0332, -0.0725, -0.0270, -0.0101, 0.0227, 0.0256]    )
  # fmt: on

  self.assertTrue(torch_all_close(a__			,							a__			,							rtol=1e-2    )    )


 def    _A	(    self  : List[str]    ):
  '''simple docstring'''

  pass







'''simple docstring'''

from __future__ import annotations

import pandas as pd


def        UpperCAmelCase_ (  lowerCamelCase_      ,			lowerCamelCase_      ,			lowerCamelCase_			):







 """simple docstring"""


 lowerCAmelCase__     :   Tuple     		=	[0] * no_of_processes
 lowerCAmelCase__     :   Any     		=	[0] * no_of_processes
 # Copy the burst time into remaining_time[]
 for i in range(lowerCamelCase_			):
  lowerCAmelCase__     :   Dict     		=	burst_time[i]

 lowerCAmelCase__     :   str     		=	0
 lowerCAmelCase__     :   Optional[Any]     		=	0
 lowerCAmelCase__     :   Optional[Any]     		=	9_9_9_9_9_9_9_9_9
 lowerCAmelCase__     :   int     		=	0
 lowerCAmelCase__     :   str     		=	False

 # Process until all processes are completed
 while complete != no_of_processes:
  for j in range(lowerCamelCase_			):
   if arrival_time[j] <= increment_time and remaining_time[j] > 0:
    if remaining_time[j] < minm:
     lowerCAmelCase__     :   Any     		=	remaining_time[j]
     lowerCAmelCase__     :   str     		=	j
     lowerCAmelCase__     :   List[Any]     		=	True

  if not check:
   increment_time += 1
   continue
  remaining_time[short] -= 1

  lowerCAmelCase__     :   Optional[Any]     		=	remaining_time[short]
  if minm == 0:
   lowerCAmelCase__     :   Optional[int]     		=	9_9_9_9_9_9_9_9_9

  if remaining_time[short] == 0:
   complete += 1
   lowerCAmelCase__     :   int     		=	False

   # Find finish time of current process
   lowerCAmelCase__     :   Tuple     		=	increment_time + 1

   # Calculate waiting time
   lowerCAmelCase__     :   Dict     		=	finish_time - arrival_time[short]
   lowerCAmelCase__     :   Optional[Any]     		=	finar - burst_time[short]

   if waiting_time[short] < 0:
    lowerCAmelCase__     :   Tuple     		=	0

        # Increment time
  increment_time += 1
 return waiting_time


def        UpperCAmelCase_ (  lowerCamelCase_      ,			lowerCamelCase_      ,			lowerCamelCase_			):







 """simple docstring"""


 lowerCAmelCase__     :   Optional[Any]     		=	[0] * no_of_processes
 for i in range(lowerCamelCase_			):
  lowerCAmelCase__     :   Dict     		=	burst_time[i] + waiting_time[i]
 return turn_around_time


def        UpperCAmelCase_ (  lowerCamelCase_      ,			lowerCamelCase_      ,			lowerCamelCase_			):







 """simple docstring"""


 lowerCAmelCase__     :   Union[str, Any]     		=	0
 lowerCAmelCase__     :   Optional[int]     		=	0
 for i in range(lowerCamelCase_			):
  lowerCAmelCase__     :   Tuple     		=	total_waiting_time + waiting_time[i]
  lowerCAmelCase__     :   str     		=	total_turn_around_time + turn_around_time[i]
 print(f'''Average waiting time = {total_waiting_time / no_of_processes:.5f}'''			)
 print("Average turn around time ="      ,			total_turn_around_time / no_of_processes			)


if __name__ == "__main__":
     print("""Enter how many process you want to analyze""")
     snake_case									=    int(input())
     snake_case									=    [0] * no_of_processes
     snake_case									=    [0] * no_of_processes
     snake_case									=    list(range(1, no_of_processes + 1))

     for i in range(no_of_processes):
          print("""Enter the arrival time and burst time for process:--""" + str(i + 1))
          snake_case					,					snake_case									=    map(int, input().split())

     snake_case									=    calculate_waitingtime(arrival_time, burst_time, no_of_processes)

     snake_case									=    burst_time
     snake_case									=    no_of_processes
     snake_case									=    waiting_time
     snake_case									=    calculate_turnaroundtime(bt, n, wt)

     calculate_average_times(waiting_time, turn_around_time, no_of_processes)

     snake_case									=    pd.DataFrame(
         list(zip(processes, burst_time, arrival_time, waiting_time, turn_around_time)),
         columns=[
             """Process""",
             """BurstTime""",
             """ArrivalTime""",
             """WaitingTime""",
             """TurnAroundTime""",
         ],
     )

     # Printing the dataFrame
     pd.set_option("""display.max_rows""", fcfs.shape[0] + 1)
     print(fcfs)





