



'''simple docstring'''

import unittest

from transformers import BigBirdTokenizer, BigBirdTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


UpperCAmelCase     		=   '▁'

UpperCAmelCase     		=   get_tests_dir('fixtures/test_sentencepiece.model')

@require_sentencepiece
@require_tokenizers
class __snake_case(				_lowerCAmelCase		,							unittest.TestCase ):


						'''simple docstring'''



						UpperCAmelCase							:   str									=		BigBirdTokenizer
						UpperCAmelCase							:   Tuple									=		BigBirdTokenizerFast
						UpperCAmelCase							:   List[Any]									=		True
						UpperCAmelCase							:   int									=		True


						def     __snake_case   ( self				)     ->     List[str]:
							super().setUp()

							lowerCAmelCase   =     self.tokenizer_class(A_     ,	keep_accents=A_				)
							tokenizer.save_pretrained(self.tmpdirname				)


						def     __snake_case   ( self				)     ->     List[str]:
							lowerCAmelCase   =     """<s>"""
							lowerCAmelCase   =     1

							self.assertEqual(self.get_tokenizer()._convert_token_to_id(A_				)     ,	A_				)
							self.assertEqual(self.get_tokenizer()._convert_id_to_token(A_				)     ,	A_				)


						def     __snake_case   ( self				)     ->     int:
							lowerCAmelCase   =     list(self.get_tokenizer().get_vocab().keys()				)

							self.assertEqual(vocab_keys[0]     ,	"""<unk>"""				)
							self.assertEqual(vocab_keys[1]     ,	"""<s>"""				)
							self.assertEqual(vocab_keys[-1]     ,	"""[MASK]"""				)
							self.assertEqual(len(A_				)     ,	1004				)


						def     __snake_case   ( self				)     ->     str:
							self.assertEqual(self.get_tokenizer().vocab_size     ,	1000				)


						def     __snake_case   ( self				)     ->     int:
							if not self.test_rust_tokenizer:
								return

							lowerCAmelCase   =     self.get_tokenizer()
							lowerCAmelCase   =     self.get_rust_tokenizer()

							lowerCAmelCase   =     """I was born in 92000, and this is falsé."""

							lowerCAmelCase   =     tokenizer.tokenize(A_				)
							lowerCAmelCase   =     rust_tokenizer.tokenize(A_				)
							self.assertListEqual(A_     ,	A_				)

							lowerCAmelCase   =     tokenizer.encode(A_     ,	add_special_tokens=A_				)
							lowerCAmelCase   =     rust_tokenizer.encode(A_     ,	add_special_tokens=A_				)
							self.assertListEqual(A_     ,	A_				)

							lowerCAmelCase   =     self.get_rust_tokenizer()
							lowerCAmelCase   =     tokenizer.encode(A_				)
							lowerCAmelCase   =     rust_tokenizer.encode(A_				)
							self.assertListEqual(A_     ,	A_				)


						def     __snake_case   ( self				)     ->     Optional[int]:
							lowerCAmelCase   =     BigBirdTokenizer(A_     ,	keep_accents=A_				)

							lowerCAmelCase   =     tokenizer.tokenize("""This is a test"""				)
							self.assertListEqual(A_     ,	["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]				)

							self.assertListEqual(
							    tokenizer.convert_tokens_to_ids(A_				)     ,	[285, 46, 10, 170, 382]     ,	)

							lowerCAmelCase   =     tokenizer.tokenize("""I was born in 92000, and this is falsé."""				)
							self.assertListEqual(
							    A_     ,	[
							        SPIECE_UNDERLINE + """I""",
							        SPIECE_UNDERLINE + """was""",
							        SPIECE_UNDERLINE + """b""",
							        """or""",
							        """n""",
							        SPIECE_UNDERLINE + """in""",
							        SPIECE_UNDERLINE + """""",
							        """9""",
							        """2""",
							        """0""",
							        """0""",
							        """0""",
							        """,""",
							        SPIECE_UNDERLINE + """and""",
							        SPIECE_UNDERLINE + """this""",
							        SPIECE_UNDERLINE + """is""",
							        SPIECE_UNDERLINE + """f""",
							        """al""",
							        """s""",
							        """é""",
							        """.""",
							    ]     ,	)
							lowerCAmelCase   =     tokenizer.convert_tokens_to_ids(A_				)
							self.assertListEqual(
							    A_     ,	[8, 21, 84, 55, 24, 19, 7, 0, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 0, 4]     ,	)

							lowerCAmelCase   =     tokenizer.convert_ids_to_tokens(A_				)
							self.assertListEqual(
							    A_     ,	[
							        SPIECE_UNDERLINE + """I""",
							        SPIECE_UNDERLINE + """was""",
							        SPIECE_UNDERLINE + """b""",
							        """or""",
							        """n""",
							        SPIECE_UNDERLINE + """in""",
							        SPIECE_UNDERLINE + """""",
							        """<unk>""",
							        """2""",
							        """0""",
							        """0""",
							        """0""",
							        """,""",
							        SPIECE_UNDERLINE + """and""",
							        SPIECE_UNDERLINE + """this""",
							        SPIECE_UNDERLINE + """is""",
							        SPIECE_UNDERLINE + """f""",
							        """al""",
							        """s""",
							        """<unk>""",
							        """.""",
							    ]     ,	)


						@cached_property
						def     __snake_case   ( self				)     ->     List[Any]:
							return BigBirdTokenizer.from_pretrained("""google/bigbird-roberta-base"""				)


						@slow
						def     __snake_case   ( self				)     ->     List[Any]:
							lowerCAmelCase   =     """Hello World!"""
							lowerCAmelCase   =     [65, 1_8536, 2260, 101, 66]

							self.assertListEqual(A_     ,	self.big_tokenizer.encode(A_				)				)


						@slow
						def     __snake_case   ( self				)     ->     int:
							lowerCAmelCase   =     (
							    """This is a very long text with a lot of weird characters, such as: . , ~ ? ( ) \" [ ] ! : - . Also we will"""
							    """ add words that should not exsist and be tokenized to <unk>, such as saoneuhaoesuth"""
							)
							# fmt: off
							lowerCAmelCase   =     [65, 871, 419, 358, 946, 991, 2521, 452, 358, 1357, 387, 7751, 3536, 112, 985, 456, 126, 865, 938, 5400, 5734, 458, 1368, 467, 786, 2462, 5246, 1159, 633, 865, 4519, 457, 582, 852, 2557, 427, 916, 508, 405, 3_4324, 497, 391, 408, 1_1342, 1244, 385, 100, 938, 985, 456, 574, 362, 1_2597, 3200, 3129, 1172, 66]  # noqa: E231
							# fmt: on
							self.assertListEqual(A_     ,	self.big_tokenizer.encode(A_				)				)


						@require_torch
						@slow
						def     __snake_case   ( self				)     ->     Optional[int]:
							import torch

							from transformers import BigBirdConfig, BigBirdModel

							# Build sequence
							lowerCAmelCase   =     list(self.big_tokenizer.get_vocab().keys()				)[:10]
							lowerCAmelCase   =     """ """.join(A_				)
							lowerCAmelCase   =     self.big_tokenizer.encode_plus(A_     ,	return_tensors="""pt"""     ,	return_token_type_ids=A_				)
							lowerCAmelCase   =     self.big_tokenizer.batch_encode_plus(
							    [sequence + """ """ + sequence]     ,	return_tensors="""pt"""     ,	return_token_type_ids=A_				)

							lowerCAmelCase   =     BigBirdConfig(attention_type="""original_full"""				)
							lowerCAmelCase   =     BigBirdModel(A_				)

							assert model.get_input_embeddings().weight.shape[0] >= self.big_tokenizer.vocab_size

							with torch.no_grad():
								model(**A_				)
								model(**A_				)


						@slow
						def     __snake_case   ( self				)     ->     Union[str, Any]:
							lowerCAmelCase   =     BigBirdTokenizer.from_pretrained("""google/bigbird-roberta-base"""				)
							lowerCAmelCase   =     tokenizer.decode(tokenizer("""Paris is the [MASK]."""				).input_ids				)

							self.assertTrue(decoded_text == """[CLS] Paris is the[MASK].[SEP]"""				)




						@slow
						def     __snake_case   ( self				)     ->     Optional[Any]:
							# fmt: off
							lowerCAmelCase   =     {"""input_ids""": [[65, 3_9286, 458, 3_6335, 2001, 456, 1_3073, 1_3266, 455, 113, 7746, 1741, 1_1157, 391, 1_3073, 1_3266, 455, 113, 3967, 3_5412, 113, 4936, 109, 3870, 2377, 113, 3_0084, 4_5720, 458, 134, 1_7496, 112, 503, 1_1672, 113, 118, 112, 5665, 1_3347, 3_8687, 112, 1496, 3_1389, 112, 3268, 4_7264, 134, 962, 112, 1_6377, 8035, 2_3130, 430, 1_2169, 1_5518, 2_8592, 458, 146, 4_1697, 109, 391, 1_2169, 1_5518, 1_6689, 458, 146, 4_1358, 109, 452, 726, 4034, 111, 763, 3_5412, 5082, 388, 1903, 111, 9051, 391, 2870, 4_8918, 1900, 1123, 550, 998, 112, 9586, 1_5985, 455, 391, 410, 2_2955, 3_7636, 114, 66], [65, 448, 1_7496, 419, 3663, 385, 763, 113, 2_7533, 2870, 3283, 1_3043, 1639, 2_4713, 523, 656, 2_4013, 1_8550, 2521, 517, 2_7014, 2_1244, 420, 1212, 1465, 391, 927, 4833, 388, 578, 1_1786, 114, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [65, 484, 2169, 7687, 2_1932, 1_8146, 726, 363, 1_7032, 3391, 114, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], """attention_mask""": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
							# fmt: on

							self.tokenizer_integration_test_util(
							    expected_encoding=A_     ,	model_name="""google/bigbird-roberta-base"""     ,	revision="""215c99f1600e06f83acce68422f2035b2b5c3510"""     ,	)




'''simple docstring'''

from __future__ import annotations

import pandas as pd






def 		_snake_case		( _SCREAMING_SNAKE_CASE					:						list[int]							,		_SCREAMING_SNAKE_CASE					:						list[int]							,		_SCREAMING_SNAKE_CASE					:						int							)      ->						list[int]:







	"""simple docstring"""
	lowerCAmelCase   =     [0] * no_of_processes
	lowerCAmelCase   =     [0] * no_of_processes
	# Copy the burst time into remaining_time[]
	for i in range(_SCREAMING_SNAKE_CASE							):
		lowerCAmelCase   =     burst_time[i]

	lowerCAmelCase   =     0
	lowerCAmelCase   =     0
	lowerCAmelCase   =     999_999_999
	lowerCAmelCase   =     0
	lowerCAmelCase   =     False

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

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

		lowerCAmelCase   =     remaining_time[short]
		if minm == 0:
			lowerCAmelCase   =     999_999_999

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

			# Find finish time of current process
			lowerCAmelCase   =     increment_time + 1

			# Calculate waiting time
			lowerCAmelCase   =     finish_time - arrival_time[short]
			lowerCAmelCase   =     finar - burst_time[short]

			if waiting_time[short] < 0:
				lowerCAmelCase   =     0

        # Increment time
		increment_time += 1
	return waiting_time






def 		_snake_case		( _SCREAMING_SNAKE_CASE					:						list[int]							,		_SCREAMING_SNAKE_CASE					:						int							,		_SCREAMING_SNAKE_CASE					:						list[int]							)      ->						list[int]:







	"""simple docstring"""
	lowerCAmelCase   =     [0] * no_of_processes
	for i in range(_SCREAMING_SNAKE_CASE							):
		lowerCAmelCase   =     burst_time[i] + waiting_time[i]
	return turn_around_time






def 		_snake_case		( _SCREAMING_SNAKE_CASE					:						list[int]							,		_SCREAMING_SNAKE_CASE					:						list[int]							,		_SCREAMING_SNAKE_CASE					:						int							)      ->						None:







	"""simple docstring"""
	lowerCAmelCase   =     0
	lowerCAmelCase   =     0
	for i in range(_SCREAMING_SNAKE_CASE							):
		lowerCAmelCase   =     total_waiting_time + waiting_time[i]
		lowerCAmelCase   =     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')
				UpperCAmelCase     		=   int(input())
				UpperCAmelCase     		=   [0] * no_of_processes
				UpperCAmelCase     		=   [0] * no_of_processes
				UpperCAmelCase     		=   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))
								UpperCAmelCase		,       UpperCAmelCase     		=   map(int, input().split())

				UpperCAmelCase     		=   calculate_waitingtime(arrival_time, burst_time, no_of_processes)

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

				calculate_average_times(waiting_time, turn_around_time, no_of_processes)

				UpperCAmelCase     		=   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)