






from __future__ import annotations

import unittest

from transformers import XGLMConfig, XGLMTokenizer, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
					import tensorflow as tf

					from transformers.models.xglm.modeling_tf_xglm import (
					    TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST,
					    TFXGLMForCausalLM,
					    TFXGLMModel,
					)


@require_tf
class     __SCREAMING_SNAKE_CASE					:
						_SCREAMING_SNAKE_CASE	:       str   =					XGLMConfig
						_SCREAMING_SNAKE_CASE	:       Union[str, Any]   =					{}
						_SCREAMING_SNAKE_CASE	:       Tuple   =					'''gelu'''






						def __init__(	self     ,						_UpperCamelCase     ,						_UpperCamelCase=14     ,						_UpperCamelCase=7     ,						_UpperCamelCase=True     ,						_UpperCamelCase=True     ,						_UpperCamelCase=True     ,						_UpperCamelCase=99     ,						_UpperCamelCase=32     ,						_UpperCamelCase=2     ,						_UpperCamelCase=4     ,						_UpperCamelCase=37     ,						_UpperCamelCase="gelu"     ,						_UpperCamelCase=0.1     ,						_UpperCamelCase=0.1     ,						_UpperCamelCase=5_12     ,						_UpperCamelCase=0.02     ,						):






												"""simple docstring"""
												lowerCAmelCase__    						=						parent
												lowerCAmelCase__    						=						batch_size
												lowerCAmelCase__    						=						seq_length
												lowerCAmelCase__    						=						is_training
												lowerCAmelCase__    						=						use_input_mask
												lowerCAmelCase__    						=						use_labels
												lowerCAmelCase__    						=						vocab_size
												lowerCAmelCase__    						=						d_model
												lowerCAmelCase__    						=						num_hidden_layers
												lowerCAmelCase__    						=						num_attention_heads
												lowerCAmelCase__    						=						ffn_dim
												lowerCAmelCase__    						=						activation_function
												lowerCAmelCase__    						=						activation_dropout
												lowerCAmelCase__    						=						attention_dropout
												lowerCAmelCase__    						=						max_position_embeddings
												lowerCAmelCase__    						=						initializer_range
												lowerCAmelCase__    						=						None
												lowerCAmelCase__    						=						0
												lowerCAmelCase__    						=						2
												lowerCAmelCase__    						=						1






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												return XGLMConfig.from_pretrained('facebook/xglm-564M'   )






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						tf.clip_by_value(
												    ids_tensor([self.batch_size, self.seq_length]     ,						self.vocab_size   )     ,						clip_value_min=0     ,						clip_value_max=3   )

												lowerCAmelCase__    						=						None
												if self.use_input_mask:
																		lowerCAmelCase__    						=						random_attention_mask([self.batch_size, self.seq_length]   )

												lowerCAmelCase__    						=						self.get_config()

												lowerCAmelCase__    						=						floats_tensor([self.num_hidden_layers, self.num_attention_heads]     ,						2   )

												return (
												    config,
												    input_ids,
												    input_mask,
												    head_mask,
												)






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												return XGLMConfig(
												    vocab_size=self.vocab_size     ,						d_model=self.hidden_size     ,						num_layers=self.num_hidden_layers     ,						attention_heads=self.num_attention_heads     ,						ffn_dim=self.ffn_dim     ,						activation_function=self.activation_function     ,						activation_dropout=self.activation_dropout     ,						attention_dropout=self.attention_dropout     ,						max_position_embeddings=self.max_position_embeddings     ,						initializer_range=self.initializer_range     ,						use_cache=_UpperCamelCase     ,						bos_token_id=self.bos_token_id     ,						eos_token_id=self.eos_token_id     ,						pad_token_id=self.pad_token_id     ,						return_dict=_UpperCamelCase     ,						)







						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						self.prepare_config_and_inputs()

												(
												    (
												    lowerCAmelCase__       
												)						,       (
												    lowerCAmelCase__       
												)						,       (
												    lowerCAmelCase__       
												)						,       (
												    lowerCAmelCase__       
												)						,              
												)    						=						config_and_inputs

												lowerCAmelCase__    						=						{
												    'input_ids': input_ids,
												    'head_mask': head_mask,
												}

												return config, inputs_dict




@require_tf
class     __SCREAMING_SNAKE_CASE					(   __lowercase		,					__lowercase		,					unittest.TestCase):
						_SCREAMING_SNAKE_CASE	:       int   =					(TFXGLMModel, TFXGLMForCausalLM) if is_tf_available() else ()
						_SCREAMING_SNAKE_CASE	:       str   =					(TFXGLMForCausalLM,) if is_tf_available() else ()
						_SCREAMING_SNAKE_CASE	:       List[Any]   =					(
						    {'''feature-extraction''': TFXGLMModel, '''text-generation''': TFXGLMForCausalLM} if is_tf_available() else {}
						)
						_SCREAMING_SNAKE_CASE	:       Any   =					False
						_SCREAMING_SNAKE_CASE	:       int   =					False
						_SCREAMING_SNAKE_CASE	:       int   =					False






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						TFXGLMModelTester(self   )
												lowerCAmelCase__    						=						ConfigTester(self     ,						config_class=_UpperCamelCase     ,						n_embd=37   )






						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												self.config_tester.run_common_tests()






						@slow
						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												for model_name in TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																		lowerCAmelCase__    						=						TFXGLMModel.from_pretrained(_UpperCamelCase   )
																		self.assertIsNotNone(_UpperCamelCase   )







						@unittest.skip(reason='Currently, model embeddings are going to undergo a major refactor.'   )
						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												super().test_resize_token_embeddings()




@require_tf
class     __SCREAMING_SNAKE_CASE					(   unittest.TestCase):






						@slow
						def       UpperCamelCase__      (	self     ,						_UpperCamelCase=True   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						TFXGLMForCausalLM.from_pretrained('facebook/xglm-564M'   )
												lowerCAmelCase__    						=						tf.convert_to_tensor([[2, 2_68, 98_65]]     ,						dtype=tf.intaa   )  # The dog
												# </s> The dog is a very friendly dog. He is very affectionate and loves to play with other
												# fmt: off
												lowerCAmelCase__    						=						[2, 2_68, 98_65, 67, 11, 19_88, 5_72_52, 98_65, 5, 9_84, 67, 19_88, 21_38_38, 16_58, 53, 7_04_46, 33, 66_57, 2_78, 15_81]
												# fmt: on
												lowerCAmelCase__    						=						model.generate(_UpperCamelCase     ,						do_sample=_UpperCamelCase     ,						num_beams=1   )
												if verify_outputs:
																		self.assertListEqual(output_ids[0].numpy().tolist()     ,						_UpperCamelCase   )






						@slow
						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						XGLMTokenizer.from_pretrained('facebook/xglm-564M'   )
												lowerCAmelCase__    						=						TFXGLMForCausalLM.from_pretrained('facebook/xglm-564M'   )

												tf.random.set_seed(0   )
												lowerCAmelCase__    						=						tokenizer('Today is a nice day and'     ,						return_tensors='tf'   )
												lowerCAmelCase__    						=						tokenized.input_ids
												# forces the generation to happen on CPU, to avoid GPU-related quirks (and assure same output regardless of the available devices)
												with tf.device(':/CPU:0'   ):
																		lowerCAmelCase__    						=						model.generate(_UpperCamelCase     ,						do_sample=_UpperCamelCase     ,						seed=[7, 0]   )
												lowerCAmelCase__    						=						tokenizer.decode(output_ids[0]     ,						skip_special_tokens=_UpperCamelCase   )

												lowerCAmelCase__    						=						(
												    'Today is a nice day and warm evening here over Southern Alberta!! Today when they closed schools due'
												)
												self.assertEqual(_UpperCamelCase     ,						_UpperCamelCase   )







						@slow
						def       UpperCamelCase__      (	self   ):






												"""simple docstring"""
												lowerCAmelCase__    						=						TFXGLMForCausalLM.from_pretrained('facebook/xglm-564M'   )
												lowerCAmelCase__    						=						XGLMTokenizer.from_pretrained('facebook/xglm-564M'   )

												lowerCAmelCase__    						=						'left'

												# use different length sentences to test batching
												lowerCAmelCase__    						=						[
												    'This is an extremelly long sentence that only exists to test the ability of the model to cope with '
												    'left-padding, such as in batched generation. The output for the sequence below should be the same '
												    'regardless of whether left padding is applied or not. When',
												    'Hello, my dog is a little',
												]

												lowerCAmelCase__    						=						tokenizer(_UpperCamelCase     ,						return_tensors='tf'     ,						padding=_UpperCamelCase   )
												lowerCAmelCase__    						=						inputs['input_ids']

												lowerCAmelCase__    						=						model.generate(input_ids=_UpperCamelCase     ,						attention_mask=inputs['attention_mask']     ,						max_new_tokens=12   )

												lowerCAmelCase__    						=						tokenizer(sentences[0]     ,						return_tensors='tf'   ).input_ids
												lowerCAmelCase__    						=						model.generate(input_ids=_UpperCamelCase     ,						max_new_tokens=12   )

												lowerCAmelCase__    						=						tokenizer(sentences[1]     ,						return_tensors='tf'   ).input_ids
												lowerCAmelCase__    						=						model.generate(input_ids=_UpperCamelCase     ,						max_new_tokens=12   )

												lowerCAmelCase__    						=						tokenizer.batch_decode(_UpperCamelCase     ,						skip_special_tokens=_UpperCamelCase   )
												lowerCAmelCase__    						=						tokenizer.decode(output_non_padded[0]     ,						skip_special_tokens=_UpperCamelCase   )
												lowerCAmelCase__    						=						tokenizer.decode(output_padded[0]     ,						skip_special_tokens=_UpperCamelCase   )

												lowerCAmelCase__    						=						[
												    'This is an extremelly long sentence that only exists to test the ability of the model to cope with '
												    'left-padding, such as in batched generation. The output for the sequence below should be the same '
												    'regardless of whether left padding is applied or not. When left padding is applied, the sequence will be '
												    'a single',
												    'Hello, my dog is a little bit of a shy one, but he is very friendly',
												]
												self.assertListEqual(_UpperCamelCase     ,						_UpperCamelCase   )
												self.assertListEqual(_UpperCamelCase     ,						[non_padded_sentence, padded_sentence]   )













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)





