






from __future__ import annotations

import copy
import tempfile
import unittest

from transformers import CONFIG_MAPPING, AutoConfig, BertConfig, GPTaConfig, TaConfig, TapasConfig, is_tf_available
from transformers.testing_utils import (
    DUMMY_UNKNOWN_IDENTIFIER,
    SMALL_MODEL_IDENTIFIER,
    RequestCounter,
    require_tensorflow_probability,
    require_tf,
    slow,
)

from ..bert.test_modeling_bert import BertModelTester


if is_tf_available():
					from transformers import (
					    TFAutoModel,
					    TFAutoModelForCausalLM,
					    TFAutoModelForMaskedLM,
					    TFAutoModelForPreTraining,
					    TFAutoModelForQuestionAnswering,
					    TFAutoModelForSeqaSeqLM,
					    TFAutoModelForSequenceClassification,
					    TFAutoModelForTableQuestionAnswering,
					    TFAutoModelForTokenClassification,
					    TFAutoModelWithLMHead,
					    TFBertForMaskedLM,
					    TFBertForPreTraining,
					    TFBertForQuestionAnswering,
					    TFBertForSequenceClassification,
					    TFBertModel,
					    TFFunnelBaseModel,
					    TFFunnelModel,
					    TFGPTaLMHeadModel,
					    TFRobertaForMaskedLM,
					    TFTaForConditionalGeneration,
					    TFTapasForQuestionAnswering,
					)
					from transformers.models.auto.modeling_tf_auto import (
					    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
					    TF_MODEL_FOR_MASKED_LM_MAPPING,
					    TF_MODEL_FOR_PRETRAINING_MAPPING,
					    TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
					    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
					    TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
					    TF_MODEL_MAPPING,
					)
					from transformers.models.bert.modeling_tf_bert import TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST
					from transformers.models.gpta.modeling_tf_gpta import TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST
					from transformers.models.ta.modeling_tf_ta import TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST
					from transformers.models.tapas.modeling_tf_tapas import TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST


class     __SCREAMING_SNAKE_CASE					(   __lowercase):
						_SCREAMING_SNAKE_CASE	:       List[Any]   =					'''new-model'''


if is_tf_available():


					class     __SCREAMING_SNAKE_CASE					(   __lowercase):
											_SCREAMING_SNAKE_CASE	:       int   =					NewModelConfig


@require_tf
class     __SCREAMING_SNAKE_CASE					(   unittest.TestCase):






						@slow
						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						'bert-base-cased'
												lowerCAmelCase__    						=						AutoConfig.from_pretrained(_A   )
												self.assertIsNotNone(_A   )
												self.assertIsInstance(_A     ,						_A   )

												lowerCAmelCase__    						=						TFAutoModel.from_pretrained(_A   )
												self.assertIsNotNone(_A   )
												self.assertIsInstance(_A     ,						_A   )






						@slow
						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						'bert-base-cased'
												lowerCAmelCase__    						=						AutoConfig.from_pretrained(_A   )
												self.assertIsNotNone(_A   )
												self.assertIsInstance(_A     ,						_A   )

												lowerCAmelCase__    						=						TFAutoModelForPreTraining.from_pretrained(_A   )
												self.assertIsNotNone(_A   )
												self.assertIsInstance(_A     ,						_A   )






						@slow
						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												for model_name in TF_GPT2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		lowerCAmelCase__    						=						AutoConfig.from_pretrained(_A   )
																		self.assertIsNotNone(_A   )
																		self.assertIsInstance(_A     ,						_A   )

																		lowerCAmelCase__    						=						TFAutoModelForCausalLM.from_pretrained(_A   )
																		lowerCAmelCase__						,       lowerCAmelCase__    						=						TFAutoModelForCausalLM.from_pretrained(_A     ,						output_loading_info=_A   )
																		self.assertIsNotNone(_A   )
																		self.assertIsInstance(_A     ,						_A   )






						@slow
						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		lowerCAmelCase__    						=						AutoConfig.from_pretrained(_A   )
																		self.assertIsNotNone(_A   )
																		self.assertIsInstance(_A     ,						_A   )

																		lowerCAmelCase__    						=						TFAutoModelWithLMHead.from_pretrained(_A   )
																		self.assertIsNotNone(_A   )
																		self.assertIsInstance(_A     ,						_A   )






						@slow
						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		lowerCAmelCase__    						=						AutoConfig.from_pretrained(_A   )
																		self.assertIsNotNone(_A   )
																		self.assertIsInstance(_A     ,						_A   )

																		lowerCAmelCase__    						=						TFAutoModelForMaskedLM.from_pretrained(_A   )
																		lowerCAmelCase__						,       lowerCAmelCase__    						=						TFAutoModelForMaskedLM.from_pretrained(_A     ,						output_loading_info=_A   )
																		self.assertIsNotNone(_A   )
																		self.assertIsInstance(_A     ,						_A   )






						@slow
						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												for model_name in TF_T5_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		lowerCAmelCase__    						=						AutoConfig.from_pretrained(_A   )
																		self.assertIsNotNone(_A   )
																		self.assertIsInstance(_A     ,						_A   )

																		lowerCAmelCase__    						=						TFAutoModelForSeqaSeqLM.from_pretrained(_A   )
																		lowerCAmelCase__						,       lowerCAmelCase__    						=						TFAutoModelForSeqaSeqLM.from_pretrained(_A     ,						output_loading_info=_A   )
																		self.assertIsNotNone(_A   )
																		self.assertIsInstance(_A     ,						_A   )






						@slow
						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												# for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												for model_name in ["bert-base-uncased"]:
																		lowerCAmelCase__    						=						AutoConfig.from_pretrained(_A   )
																		self.assertIsNotNone(_A   )
																		self.assertIsInstance(_A     ,						_A   )

																		lowerCAmelCase__    						=						TFAutoModelForSequenceClassification.from_pretrained(_A   )
																		self.assertIsNotNone(_A   )
																		self.assertIsInstance(_A     ,						_A   )






						@slow
						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												# for model_name in TF_BERT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
												for model_name in ["bert-base-uncased"]:
																		lowerCAmelCase__    						=						AutoConfig.from_pretrained(_A   )
																		self.assertIsNotNone(_A   )
																		self.assertIsInstance(_A     ,						_A   )

																		lowerCAmelCase__    						=						TFAutoModelForQuestionAnswering.from_pretrained(_A   )
																		self.assertIsNotNone(_A   )
																		self.assertIsInstance(_A     ,						_A   )






						@slow
						@require_tensorflow_probability
						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												for model_name in TF_TAPAS_PRETRAINED_MODEL_ARCHIVE_LIST[5:6]:
																		lowerCAmelCase__    						=						AutoConfig.from_pretrained(_A   )
																		self.assertIsNotNone(_A   )
																		self.assertIsInstance(_A     ,						_A   )

																		lowerCAmelCase__    						=						TFAutoModelForTableQuestionAnswering.from_pretrained(_A   )
																		lowerCAmelCase__						,       lowerCAmelCase__    						=						TFAutoModelForTableQuestionAnswering.from_pretrained(
																		    _A     ,						output_loading_info=_A   )
																		self.assertIsNotNone(_A   )
																		self.assertIsInstance(_A     ,						_A   )






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						TFAutoModelWithLMHead.from_pretrained(_A   )
												self.assertIsInstance(_A     ,						_A   )
												self.assertEqual(model.num_parameters()     ,						1_44_10   )
												self.assertEqual(model.num_parameters(only_trainable=_A   )     ,						1_44_10   )






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						TFAutoModelWithLMHead.from_pretrained(_A   )
												self.assertIsInstance(_A     ,						_A   )
												self.assertEqual(model.num_parameters()     ,						1_44_10   )
												self.assertEqual(model.num_parameters(only_trainable=_A   )     ,						1_44_10   )






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												# For the auto model mapping, FunnelConfig has two models: FunnelModel and FunnelBaseModel
												lowerCAmelCase__    						=						TFAutoModel.from_pretrained('sgugger/funnel-random-tiny'   )
												self.assertIsInstance(_A     ,						_A   )

												lowerCAmelCase__    						=						copy.deepcopy(model.config   )
												lowerCAmelCase__    						=						['FunnelBaseModel']
												lowerCAmelCase__    						=						TFAutoModel.from_config(_A   )
												self.assertIsInstance(_A     ,						_A   )

												with tempfile.TemporaryDirectory() as tmp_dir:
																		model.save_pretrained(_A   )
																		lowerCAmelCase__    						=						TFAutoModel.from_pretrained(_A   )
																		self.assertIsInstance(_A     ,						_A   )






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												try:
																		AutoConfig.register('new-model'     ,						_A   )

																		lowerCAmelCase__    						=						[
																		    TFAutoModel,
																		    TFAutoModelForCausalLM,
																		    TFAutoModelForMaskedLM,
																		    TFAutoModelForPreTraining,
																		    TFAutoModelForQuestionAnswering,
																		    TFAutoModelForSequenceClassification,
																		    TFAutoModelForTokenClassification,
																		]

																		for auto_class in auto_classes:
																								with self.subTest(auto_class.__name__   ):
																														# Wrong config class will raise an error
																														with self.assertRaises(_A   ):
																																				auto_class.register(_A     ,						_A   )
																														auto_class.register(_A     ,						_A   )
																														# Trying to register something existing in the Transformers library will raise an error
																														with self.assertRaises(_A   ):
																																				auto_class.register(_A     ,						_A   )

																														# Now that the config is registered, it can be used as any other config with the auto-API
																														lowerCAmelCase__    						=						BertModelTester(self   ).get_config()
																														lowerCAmelCase__    						=						NewModelConfig(**tiny_config.to_dict()   )
																														lowerCAmelCase__    						=						auto_class.from_config(_A   )
																														self.assertIsInstance(_A     ,						_A   )

																														with tempfile.TemporaryDirectory() as tmp_dir:
																																				model.save_pretrained(_A   )
																																				lowerCAmelCase__    						=						auto_class.from_pretrained(_A   )
																																				self.assertIsInstance(_A     ,						_A   )

												finally:
																		if "new-model" in CONFIG_MAPPING._extra_content:
																								del CONFIG_MAPPING._extra_content["new-model"]
																		for mapping in (
																		    TF_MODEL_MAPPING,
																		    TF_MODEL_FOR_PRETRAINING_MAPPING,
																		    TF_MODEL_FOR_QUESTION_ANSWERING_MAPPING,
																		    TF_MODEL_FOR_SEQUENCE_CLASSIFICATION_MAPPING,
																		    TF_MODEL_FOR_TOKEN_CLASSIFICATION_MAPPING,
																		    TF_MODEL_FOR_CAUSAL_LM_MAPPING,
																		    TF_MODEL_FOR_MASKED_LM_MAPPING,
																		):
																								if NewModelConfig in mapping._extra_content:
																														del mapping._extra_content[NewModelConfig]






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												with self.assertRaisesRegex(
												    _A     ,						'bert-base is not a local folder and is not a valid model identifier'   ):
																		lowerCAmelCase__    						=						TFAutoModel.from_pretrained('bert-base'   )






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												with self.assertRaisesRegex(
												    _A     ,						r'aaaaaa is not a valid git identifier \(branch name, tag name or commit id\)'   ):
																		lowerCAmelCase__    						=						TFAutoModel.from_pretrained(_A     ,						revision='aaaaaa'   )






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												with self.assertRaisesRegex(
												    _A     ,						'hf-internal-testing/config-no-model does not appear to have a file named pytorch_model.bin'     ,						):
																		lowerCAmelCase__    						=						TFAutoModel.from_pretrained('hf-internal-testing/config-no-model'   )






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												with self.assertRaisesRegex(_A     ,						'Use `from_pt=True` to load this model'   ):
																		lowerCAmelCase__    						=						TFAutoModel.from_pretrained('hf-internal-testing/tiny-bert-pt-only'   )







						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												# Make sure we have cached the model.
												lowerCAmelCase__    						=						TFAutoModel.from_pretrained('hf-internal-testing/tiny-random-bert'   )
												with RequestCounter() as counter:
																		lowerCAmelCase__    						=						TFAutoModel.from_pretrained('hf-internal-testing/tiny-random-bert'   )
																		self.assertEqual(counter.get_request_count     ,						0   )
																		self.assertEqual(counter.head_request_count     ,						1   )
																		self.assertEqual(counter.other_request_count     ,						0   )

												# With a sharded checkpoint
												lowerCAmelCase__    						=						TFAutoModel.from_pretrained('ArthurZ/tiny-random-bert-sharded'   )
												with RequestCounter() as counter:
																		lowerCAmelCase__    						=						TFAutoModel.from_pretrained('ArthurZ/tiny-random-bert-sharded'   )
																		self.assertEqual(counter.get_request_count     ,						0   )
																		self.assertEqual(counter.head_request_count     ,						1   )
																		self.assertEqual(counter.other_request_count     ,						0   )













from __future__ import annotations

import pandas as pd







def 	_UpperCamelCase   (    UpperCamelCase_       :					list[int]    ,       UpperCamelCase_       :					list[int]    ,       UpperCamelCase_       :					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(UpperCamelCase_		):
												lowerCAmelCase__    						=						burst_time[i]

						lowerCAmelCase__    						=						0
						lowerCAmelCase__    						=						0
						lowerCAmelCase__    						=						9_9999_9999
						lowerCAmelCase__    						=						0
						lowerCAmelCase__    						=						False

						# Process until all processes are completed
						while complete != no_of_processes:
												for j in range(UpperCamelCase_		):
																		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__    						=						9_9999_9999

												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 	_UpperCamelCase   (    UpperCamelCase_       :					list[int]    ,       UpperCamelCase_       :					int    ,       UpperCamelCase_       :					list[int]		)  ->   list[int]:

						"""simple docstring"""



						lowerCAmelCase__    						=						[0] * no_of_processes
						for i in range(UpperCamelCase_		):
												lowerCAmelCase__    						=						burst_time[i] + waiting_time[i]
						return turn_around_time







def 	_UpperCamelCase   (    UpperCamelCase_       :					list[int]    ,       UpperCamelCase_       :					list[int]    ,       UpperCamelCase_       :					int		)  ->   None:

						"""simple docstring"""



						lowerCAmelCase__    						=						0
						lowerCAmelCase__    						=						0
						for i in range(UpperCamelCase_		):
												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""")
					__snake_case    :    Dict         =     int(input())
					__snake_case    :    List[Any]         =     [0] * no_of_processes
					__snake_case    :    str         =     [0] * no_of_processes
					__snake_case    :    Optional[int]         =     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    :    Any         =     map(int, input().split())

					__snake_case    :    str         =     calculate_waitingtime(arrival_time, burst_time, no_of_processes)

					__snake_case    :    Dict         =     burst_time
					__snake_case    :    Optional[int]         =     no_of_processes
					__snake_case    :    str         =     waiting_time
					__snake_case    :    int         =     calculate_turnaroundtime(bt, n, wt)

					calculate_average_times(waiting_time, turn_around_time, no_of_processes)

					__snake_case    :    Dict         =     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)





