




'''simple docstring'''







from collections import deque

class 	_snake_case:






 def __init__(self       :  Tuple    ,		a       :  str    ,		a       :  int    ,		a       :  int    )       ->   None:






    """simple docstring"""


    A__       =     process_name  # process name
    A__       =     arrival_time  # arrival time of the process
    # completion time of finished process or last interrupted time
    A__       =     arrival_time
    A__       =     burst_time  # remaining burst time
    A__       =     0  # total time of the process wait in ready queue
    A__       =     0  # time from arrival time to completion time




class 	_snake_case:






 def __init__(self       :  Dict    ,		a       :  int    ,		a       :  list[int]    ,		a       :  deque[Process]    ,		a       :  int    ,		)       ->   None:






    """simple docstring"""


    A__       =     number_of_queues
    # time slice of queues that round robin algorithm applied
    A__       =     time_slices
    # unfinished process is in this ready_queue
    A__       =     queue
    # current time
    A__       =     current_time
    # finished process is in this sequence queue
    A__       =     deque()






 def 						_UpperCamelCase (self       :  Any    )       ->   list[str]:






    """simple docstring"""


    A__       =     []
    for i in range(len(self.finish_queue    )    ):
       sequence.append(self.finish_queue[i].process_name    )
    return sequence






 def 						_UpperCamelCase (self       :  Tuple    ,		a       :  list[Process]    )       ->   list[int]:






    """simple docstring"""


    A__       =     []
    for i in range(len(a    )    ):
       waiting_times.append(queue[i].waiting_time    )
    return waiting_times






 def 						_UpperCamelCase (self       :  List[str]    ,		a       :  list[Process]    )       ->   list[int]:






    """simple docstring"""


    A__       =     []
    for i in range(len(a    )    ):
       turnaround_times.append(queue[i].turnaround_time    )
    return turnaround_times






 def 						_UpperCamelCase (self       :  Tuple    ,		a       :  list[Process]    )       ->   list[int]:






    """simple docstring"""


    A__       =     []
    for i in range(len(a    )    ):
       completion_times.append(queue[i].stop_time    )
    return completion_times






 def 						_UpperCamelCase (self       :  str    ,		a       :  deque[Process]    )       ->   list[int]:






    """simple docstring"""


    return [q.burst_time for q in queue]






 def 						_UpperCamelCase (self       :  Dict    ,		a       :  Process    )       ->   int:






    """simple docstring"""


    process.waiting_time += self.current_time - process.stop_time
    return process.waiting_time






 def 						_UpperCamelCase (self       :  Optional[Any]    ,		a       :  deque[Process]    )       ->   deque[Process]:






    """simple docstring"""


    A__       =     deque()  # sequence deque of finished process
    while len(a    ) != 0:
       A__       =     ready_queue.popleft()  # current process

       # if process's arrival time is later than current time, update current time
       if self.current_time < cp.arrival_time:
          self.current_time += cp.arrival_time

       # update waiting time of current process
       self.update_waiting_time(a    )
       # update current time
       self.current_time += cp.burst_time
       # finish the process and set the process's burst-time 0
       A__       =     0
       # set the process's turnaround time because it is finished
       A__       =     self.current_time - cp.arrival_time
       # set the completion time
       A__       =     self.current_time
       # add the process to queue that has finished queue
       finished.append(a    )

    self.finish_queue.extend(a    )  # add finished process to finish queue
    # FCFS will finish all remaining processes
    return finished






 def 						_UpperCamelCase (self       :  Any    ,		a       :  deque[Process]    ,		a       :  int    )       ->   tuple[deque[Process], deque[Process]]:






    """simple docstring"""


    A__       =     deque()  # sequence deque of terminated process
    # just for 1 cycle and unfinished processes will go back to queue
    for _ in range(len(a    )    ):
       A__       =     ready_queue.popleft()  # current process

       # if process's arrival time is later than current time, update current time
       if self.current_time < cp.arrival_time:
          self.current_time += cp.arrival_time

       # update waiting time of unfinished processes
       self.update_waiting_time(a    )
       # if the burst time of process is bigger than time-slice
       if cp.burst_time > time_slice:
          # use CPU for only time-slice
          self.current_time += time_slice
          # update remaining burst time
          cp.burst_time -= time_slice
          # update end point time
          A__       =     self.current_time
          # locate the process behind the queue because it is not finished
          ready_queue.append(a    )
       else:
          # use CPU for remaining burst time
          self.current_time += cp.burst_time
          # set burst time 0 because the process is finished
          A__       =     0
          # set the finish time
          A__       =     self.current_time
          # update the process' turnaround time because it is finished
          A__       =     self.current_time - cp.arrival_time
          # add the process to queue that has finished queue
          finished.append(a    )

    self.finish_queue.extend(a    )  # add finished process to finish queue
    # return finished processes queue and remaining processes queue
    return finished, ready_queue






 def 						_UpperCamelCase (self       :  int    )       ->   deque[Process]:






    """simple docstring"""


    for i in range(self.number_of_queues - 1    ):
       A__  ,			A__       =     self.round_robin(
           self.ready_queue    ,		self.time_slices[i]    )
    #  the last queue has first_come_first_served algorithm
    self.first_come_first_served(self.ready_queue    )

    return self.finish_queue


if __name__ == "__main__":
    import doctest

    lowerCAmelCase_     						=				Process('''P1''', 0, 5_3)
    lowerCAmelCase_     						=				Process('''P2''', 0, 1_7)
    lowerCAmelCase_     						=				Process('''P3''', 0, 6_8)
    lowerCAmelCase_     						=				Process('''P4''', 0, 2_4)
    lowerCAmelCase_     						=				3
    lowerCAmelCase_     						=				[1_7, 2_5]
    lowerCAmelCase_     						=				deque([Pa, Pa, Pa, Pa])

    if len(time_slices) != number_of_queues - 1:
        raise SystemExit(0)

    doctest.testmod(extraglobs={'''queue''': deque([Pa, Pa, Pa, Pa])})

    lowerCAmelCase_     						=				Process('''P1''', 0, 5_3)
    lowerCAmelCase_     						=				Process('''P2''', 0, 1_7)
    lowerCAmelCase_     						=				Process('''P3''', 0, 6_8)
    lowerCAmelCase_     						=				Process('''P4''', 0, 2_4)
    lowerCAmelCase_     						=				3
    lowerCAmelCase_     						=				[1_7, 2_5]
    lowerCAmelCase_     						=				deque([Pa, Pa, Pa, Pa])
    lowerCAmelCase_     						=				MLFQ(number_of_queues, time_slices, queue, 0)
    lowerCAmelCase_     						=				mlfq.multi_level_feedback_queue()

    # print total waiting times of processes(P1, P2, P3, P4)
    print(
        f'''waiting time:\
        \t\t\t{MLFQ.calculate_waiting_time(mlfq, [Pa, Pa, Pa, Pa])}'''
    )
    # print completion times of processes(P1, P2, P3, P4)
    print(
        f'''completion time:\
        \t\t{MLFQ.calculate_completion_time(mlfq, [Pa, Pa, Pa, Pa])}'''
    )
    # print total turnaround times of processes(P1, P2, P3, P4)
    print(
        f'''turnaround time:\
        \t\t{MLFQ.calculate_turnaround_time(mlfq, [Pa, Pa, Pa, Pa])}'''
    )
    # print sequence of finished processes
    print(
        f'''sequence of finished processes:\
        {mlfq.calculate_sequence_of_finish_queue()}'''
    )








'''simple docstring'''







import re
import string

import numpy as np

import datasets


lowerCAmelCase_     						=				'''
Returns the rate at which the input predicted strings exactly match their references, ignoring any strings input as part of the regexes_to_ignore list.
'''

lowerCAmelCase_     						=				'''
Args:
    predictions: List of predicted texts.
    references: List of reference texts.
    regexes_to_ignore: List, defaults to None. Regex expressions of characters to
        ignore when calculating the exact matches. Note: these regexes are removed
        from the input data before the changes based on the options below (e.g. ignore_case,
        ignore_punctuation, ignore_numbers) are applied.
    ignore_case: Boolean, defaults to False. If true, turns everything
        to lowercase so that capitalization differences are ignored.
    ignore_punctuation: Boolean, defaults to False. If true, removes all punctuation before
        comparing predictions and references.
    ignore_numbers: Boolean, defaults to False. If true, removes all punctuation before
        comparing predictions and references.
Returns:
    exact_match: Dictionary containing exact_match rate. Possible values are between 0.0 and 100.0, inclusive.
Examples:
    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds)
    >>> print(round(results["exact_match"], 1))
    25.0

    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell"], ignore_case=True, ignore_punctuation=True)
    >>> print(round(results["exact_match"], 1))
    50.0


    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True)
    >>> print(round(results["exact_match"], 1))
    75.0

    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["the cat", "theater", "YELLING", "agent007"]
    >>> preds = ["cat?", "theater", "yelling", "agent"]
    >>> results = exact_match.compute(references=refs, predictions=preds, regexes_to_ignore=["the ", "yell", "YELL"], ignore_case=True, ignore_punctuation=True, ignore_numbers=True)
    >>> print(round(results["exact_match"], 1))
    100.0

    >>> exact_match = datasets.load_metric("exact_match")
    >>> refs = ["The cat sat on the mat.", "Theaters are great.", "It\'s like comparing oranges and apples."]
    >>> preds = ["The cat sat on the mat?", "Theaters are great.", "It\'s like comparing apples and oranges."]
    >>> results = exact_match.compute(references=refs, predictions=preds)
    >>> print(round(results["exact_match"], 1))
    33.3

'''

lowerCAmelCase_     						=				'''
'''

@datasets.utils.file_utils.add_start_docstrings(_DESCRIPTION       , _KWARGS_DESCRIPTION      )
class 	_snake_case(			datasets.Metric      ):






 def 						_UpperCamelCase (self       :  Optional[Any]    )       ->   Dict:






    """simple docstring"""


    return datasets.MetricInfo(
        description=_DESCRIPTION    ,		citation=_CITATION    ,		inputs_description=_KWARGS_DESCRIPTION    ,		features=datasets.Features(
            {
                'predictions': datasets.Value('string'    ,		id='sequence'    ),
                'references': datasets.Value('string'    ,		id='sequence'    ),
            }    )    ,		reference_urls=[]    ,		)






 def 						_UpperCamelCase (self       :  List[str]    ,		a       :  str    ,		a       :  Tuple    ,		a       :  Tuple=None    ,		a       :  Dict=False    ,		a       :  Dict=False    ,		a       :  List[str]=False    ,		)       ->   int:






    """simple docstring"""


    if regexes_to_ignore is not None:
       for s in regexes_to_ignore:
          A__       =     np.array([re.sub(a    ,		''    ,		a    ) for x in predictions]    )
          A__       =     np.array([re.sub(a    ,		''    ,		a    ) for x in references]    )
    else:
       A__       =     np.asarray(a    )
       A__       =     np.asarray(a    )

    if ignore_case:
       A__       =     np.char.lower(a    )
       A__       =     np.char.lower(a    )

    if ignore_punctuation:
       A__       =     string.punctuation.maketrans(''    ,		''    ,		string.punctuation    )
       A__       =     np.char.translate(a    ,		table=a    )
       A__       =     np.char.translate(a    ,		table=a    )

    if ignore_numbers:
       A__       =     string.digits.maketrans(''    ,		''    ,		string.digits    )
       A__       =     np.char.translate(a    ,		table=a    )
       A__       =     np.char.translate(a    ,		table=a    )

    A__       =     predictions == references

    return {"exact_match": np.mean(a    ) * 1_00}


