



'''simple docstring'''



import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import BertTokenizer, BertTokenizerFast
from transformers.models.bert.tokenization_bert import VOCAB_FILES_NAMES
from transformers.testing_utils import require_vision
from transformers.utils import FEATURE_EXTRACTOR_NAME, is_vision_available


if is_vision_available():
							from PIL import Image

							from transformers import ChineseCLIPImageProcessor, ChineseCLIPProcessor
@require_vision
class 	lowerCamelCase_							(					unittest.TestCase			):







						def 					__lowercase    (  self   :      Optional[int]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			tempfile.mkdtemp()

													SCREAMING_SNAKE_CASE					:      int     					=			[
													    '''[UNK]''',
													    '''[CLS]''',
													    '''[SEP]''',
													    '''[PAD]''',
													    '''[MASK]''',
													    '''的''',
													    '''价''',
													    '''格''',
													    '''是''',
													    '''15''',
													    '''便''',
													    '''alex''',
													    '''##andra''',
													    '''，''',
													    '''。''',
													    '''-''',
													    '''t''',
													    '''shirt''',
													]
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			os.path.join(self.tmpdirname				,    VOCAB_FILES_NAMES['''vocab_file''']				)
													with open(self.vocab_file				,    '''w'''				,    encoding='''utf-8'''				) as vocab_writer:
																				vocab_writer.write(''''''.join([x + '''\n''' for x in vocab_tokens]				)				)

													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			{
													    '''do_resize''': True,
													    '''size''': {'''height''': 2_24, '''width''': 2_24},
													    '''do_center_crop''': True,
													    '''crop_size''': {'''height''': 18, '''width''': 18},
													    '''do_normalize''': True,
													    '''image_mean''': [0.4814_5466, 0.457_8275, 0.4082_1073],
													    '''image_std''': [0.2686_2954, 0.2613_0258, 0.2757_7711],
													    '''do_convert_rgb''': True,
													}
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			os.path.join(self.tmpdirname				,    lowerCAmelCase__				)
													with open(self.image_processor_file				,    '''w'''				,    encoding='''utf-8'''				) as fp:
																				json.dump(lowerCAmelCase__				,    lowerCAmelCase__				)







						def 					__lowercase    (  self   :      str				,    **lowerCAmelCase__   :      int				):

													"""simple docstring"""
													return BertTokenizer.from_pretrained(self.tmpdirname				,    **lowerCAmelCase__				)







						def 					__lowercase    (  self   :      Any				,    **lowerCAmelCase__   :      Dict				):

													"""simple docstring"""
													return BertTokenizerFast.from_pretrained(self.tmpdirname				,    **lowerCAmelCase__				)







						def 					__lowercase    (  self   :      List[Any]				,    **lowerCAmelCase__   :      Dict				):

													"""simple docstring"""
													return ChineseCLIPImageProcessor.from_pretrained(self.tmpdirname				,    **lowerCAmelCase__				)







						def 					__lowercase    (  self   :      List[Any]				):

													"""simple docstring"""
													shutil.rmtree(self.tmpdirname				)







						def 					__lowercase    (  self   :      int				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Dict     					=			[np.random.randint(2_55				,    size=(3, 30, 4_00)				,    dtype=np.uinta				)]

													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			[Image.fromarray(np.moveaxis(lowerCAmelCase__				,    0				,    -1				)				) for x in image_inputs]

													return image_inputs







						def 					__lowercase    (  self   :      int				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Dict     					=			self.get_tokenizer()
													SCREAMING_SNAKE_CASE					:      str     					=			self.get_rust_tokenizer()
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			self.get_image_processor()

													SCREAMING_SNAKE_CASE					:      Dict     					=			ChineseCLIPProcessor(tokenizer=lowerCAmelCase__				,    image_processor=lowerCAmelCase__				)
													processor_slow.save_pretrained(self.tmpdirname				)
													SCREAMING_SNAKE_CASE					:      List[str]     					=			ChineseCLIPProcessor.from_pretrained(self.tmpdirname				,    use_fast=lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      int     					=			ChineseCLIPProcessor(tokenizer=lowerCAmelCase__				,    image_processor=lowerCAmelCase__				)
													processor_fast.save_pretrained(self.tmpdirname				)
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			ChineseCLIPProcessor.from_pretrained(self.tmpdirname				)

													self.assertEqual(processor_slow.tokenizer.get_vocab()				,    tokenizer_slow.get_vocab()				)
													self.assertEqual(processor_fast.tokenizer.get_vocab()				,    tokenizer_fast.get_vocab()				)
													self.assertEqual(tokenizer_slow.get_vocab()				,    tokenizer_fast.get_vocab()				)
													self.assertIsInstance(processor_slow.tokenizer				,    lowerCAmelCase__				)
													self.assertIsInstance(processor_fast.tokenizer				,    lowerCAmelCase__				)

													self.assertEqual(processor_slow.image_processor.to_json_string()				,    image_processor.to_json_string()				)
													self.assertEqual(processor_fast.image_processor.to_json_string()				,    image_processor.to_json_string()				)
													self.assertIsInstance(processor_slow.image_processor				,    lowerCAmelCase__				)
													self.assertIsInstance(processor_fast.image_processor				,    lowerCAmelCase__				)







						def 					__lowercase    (  self   :      Tuple				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Optional[int]     					=			ChineseCLIPProcessor(tokenizer=self.get_tokenizer()				,    image_processor=self.get_image_processor()				)
													processor.save_pretrained(self.tmpdirname				)

													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			self.get_tokenizer(cls_token='''(CLS)'''				,    sep_token='''(SEP)'''				)
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			self.get_image_processor(do_normalize=lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			ChineseCLIPProcessor.from_pretrained(
													    self.tmpdirname				,    cls_token='''(CLS)'''				,    sep_token='''(SEP)'''				,    do_normalize=lowerCAmelCase__				)

													self.assertEqual(processor.tokenizer.get_vocab()				,    tokenizer_add_kwargs.get_vocab()				)
													self.assertIsInstance(processor.tokenizer				,    lowerCAmelCase__				)

													self.assertEqual(processor.image_processor.to_json_string()				,    image_processor_add_kwargs.to_json_string()				)
													self.assertIsInstance(processor.image_processor				,    lowerCAmelCase__				)







						def 					__lowercase    (  self   :      Optional[Any]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Any     					=			self.get_image_processor()
													SCREAMING_SNAKE_CASE					:      str     					=			self.get_tokenizer()

													SCREAMING_SNAKE_CASE					:      Tuple     					=			ChineseCLIPProcessor(tokenizer=lowerCAmelCase__				,    image_processor=lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      Tuple     					=			self.prepare_image_inputs()

													SCREAMING_SNAKE_CASE					:      List[Any]     					=			image_processor(lowerCAmelCase__				,    return_tensors='''np'''				)
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			processor(images=lowerCAmelCase__				,    return_tensors='''np'''				)

													for key in input_feat_extract.keys():
																				self.assertAlmostEqual(input_feat_extract[key].sum()				,    input_processor[key].sum()				,    delta=1e-2				)







						def 					__lowercase    (  self   :      Dict				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			self.get_image_processor()
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			self.get_tokenizer()

													SCREAMING_SNAKE_CASE					:      Tuple     					=			ChineseCLIPProcessor(tokenizer=lowerCAmelCase__				,    image_processor=lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      int     					=			'''Alexandra，T-shirt的价格是15便士。'''

													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			processor(text=lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      List[str]     					=			tokenizer(lowerCAmelCase__				)

													for key in encoded_tok.keys():
																				self.assertListEqual(encoded_tok[key]				,    encoded_processor[key]				)







						def 					__lowercase    (  self   :      Optional[int]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			self.get_image_processor()
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			self.get_tokenizer()

													SCREAMING_SNAKE_CASE					:      Tuple     					=			ChineseCLIPProcessor(tokenizer=lowerCAmelCase__				,    image_processor=lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      str     					=			'''Alexandra，T-shirt的价格是15便士。'''
													SCREAMING_SNAKE_CASE					:      Tuple     					=			self.prepare_image_inputs()

													SCREAMING_SNAKE_CASE					:      List[str]     					=			processor(text=lowerCAmelCase__				,    images=lowerCAmelCase__				)

													self.assertListEqual(list(inputs.keys()				)				,    ['''input_ids''', '''token_type_ids''', '''attention_mask''', '''pixel_values''']				)

													# test if it raises when no input is passed
													with pytest.raises(lowerCAmelCase__				):
																				processor()







						def 					__lowercase    (  self   :      Dict				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Tuple     					=			self.get_image_processor()
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			self.get_tokenizer()

													SCREAMING_SNAKE_CASE					:      Tuple     					=			ChineseCLIPProcessor(tokenizer=lowerCAmelCase__				,    image_processor=lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      List[Any]     					=			[[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

													SCREAMING_SNAKE_CASE					:      Any     					=			processor.batch_decode(lowerCAmelCase__				)
													SCREAMING_SNAKE_CASE					:      Tuple     					=			tokenizer.batch_decode(lowerCAmelCase__				)

													self.assertListEqual(lowerCAmelCase__				,    lowerCAmelCase__				)







						def 					__lowercase    (  self   :      Dict				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      str     					=			self.get_image_processor()
													SCREAMING_SNAKE_CASE					:      List[str]     					=			self.get_tokenizer()

													SCREAMING_SNAKE_CASE					:      Dict     					=			ChineseCLIPProcessor(tokenizer=lowerCAmelCase__				,    image_processor=lowerCAmelCase__				)

													SCREAMING_SNAKE_CASE					:      int     					=			'''Alexandra，T-shirt的价格是15便士。'''
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			self.prepare_image_inputs()

													SCREAMING_SNAKE_CASE					:      Any     					=			processor(text=lowerCAmelCase__				,    images=lowerCAmelCase__				)

													self.assertListEqual(list(inputs.keys()				)				,    processor.model_input_names				)









'''simple docstring'''



from collections import deque
class 	lowerCamelCase_							:







						def __init__(  self   :      Tuple				,    lowerCAmelCase__   :      str				,    lowerCAmelCase__   :      int				,    lowerCAmelCase__   :      int				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			process_name  # process name
													SCREAMING_SNAKE_CASE					:      int     					=			arrival_time  # arrival time of the process
													# completion time of finished process or last interrupted time
													SCREAMING_SNAKE_CASE					:      List[str]     					=			arrival_time
													SCREAMING_SNAKE_CASE					:      List[Any]     					=			burst_time  # remaining burst time
													SCREAMING_SNAKE_CASE					:      List[str]     					=			0  # total time of the process wait in ready queue
													SCREAMING_SNAKE_CASE					:      Optional[int]     					=			0  # time from arrival time to completion time


class 	lowerCamelCase_							:







						def __init__(  self   :      str				,    lowerCAmelCase__   :      int				,    lowerCAmelCase__   :      list[int]				,    lowerCAmelCase__   :      deque[Process]				,    lowerCAmelCase__   :      int				,    ):

													"""simple docstring"""
													# total number of mlfq's queues
													SCREAMING_SNAKE_CASE					:      str     					=			number_of_queues
													# time slice of queues that round robin algorithm applied
													SCREAMING_SNAKE_CASE					:      int     					=			time_slices
													# unfinished process is in this ready_queue
													SCREAMING_SNAKE_CASE					:      str     					=			queue
													# current time
													SCREAMING_SNAKE_CASE					:      Any     					=			current_time
													# finished process is in this sequence queue
													SCREAMING_SNAKE_CASE					:      deque[Process]     					=			deque()







						def 					__lowercase    (  self   :      Optional[int]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      List[str]     					=			[]
													for i in range(len(self.finish_queue				)				):
																				sequence.append(self.finish_queue[i].process_name				)
													return sequence







						def 					__lowercase    (  self   :      int				,    lowerCAmelCase__   :      list[Process]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			[]
													for i in range(len(lowerCAmelCase__				)				):
																				waiting_times.append(queue[i].waiting_time				)
													return waiting_times







						def 					__lowercase    (  self   :      List[Any]				,    lowerCAmelCase__   :      list[Process]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Dict     					=			[]
													for i in range(len(lowerCAmelCase__				)				):
																				turnaround_times.append(queue[i].turnaround_time				)
													return turnaround_times







						def 					__lowercase    (  self   :      Dict				,    lowerCAmelCase__   :      list[Process]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			[]
													for i in range(len(lowerCAmelCase__				)				):
																				completion_times.append(queue[i].stop_time				)
													return completion_times







						def 					__lowercase    (  self   :      Union[str, Any]				,    lowerCAmelCase__   :      deque[Process]				):

													"""simple docstring"""
													return [q.burst_time for q in queue]







						def 					__lowercase    (  self   :      Optional[int]				,    lowerCAmelCase__   :      Process				):

													"""simple docstring"""
													process.waiting_time += self.current_time - process.stop_time
													return process.waiting_time







						def 					__lowercase    (  self   :      Dict				,    lowerCAmelCase__   :      deque[Process]				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      deque[Process]     					=			deque()  # sequence deque of finished process
													while len(lowerCAmelCase__				) != 0:
																				SCREAMING_SNAKE_CASE					:      Tuple     					=			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(lowerCAmelCase__				)
																				# update current time
																				self.current_time += cp.burst_time
																				# finish the process and set the process's burst-time 0
																				SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			0
																				# set the process's turnaround time because it is finished
																				SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			self.current_time - cp.arrival_time
																				# set the completion time
																				SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			self.current_time
																				# add the process to queue that has finished queue
																				finished.append(lowerCAmelCase__				)

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







						def 					__lowercase    (  self   :      Optional[int]				,    lowerCAmelCase__   :      deque[Process]				,    lowerCAmelCase__   :      int				):

													"""simple docstring"""
													SCREAMING_SNAKE_CASE					:      deque[Process]     					=			deque()  # sequence deque of terminated process
													# just for 1 cycle and unfinished processes will go back to queue
													for _ in range(len(lowerCAmelCase__				)				):
																				SCREAMING_SNAKE_CASE					:      List[Any]     					=			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(lowerCAmelCase__				)
																				# 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
																											SCREAMING_SNAKE_CASE					:      Union[str, Any]     					=			self.current_time
																											# locate the process behind the queue because it is not finished
																											ready_queue.append(lowerCAmelCase__				)
																				else:
																											# use CPU for remaining burst time
																											self.current_time += cp.burst_time
																											# set burst time 0 because the process is finished
																											SCREAMING_SNAKE_CASE					:      Optional[Any]     					=			0
																											# set the finish time
																											SCREAMING_SNAKE_CASE					:      Tuple     					=			self.current_time
																											# update the process' turnaround time because it is finished
																											SCREAMING_SNAKE_CASE					:      List[Any]     					=			self.current_time - cp.arrival_time
																											# add the process to queue that has finished queue
																											finished.append(lowerCAmelCase__				)

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







						def 					__lowercase    (  self   :      Union[str, Any]				):

													"""simple docstring"""

													#  all queues except last one have round_robin algorithm
													for i in range(self.number_of_queues - 1				):
																				SCREAMING_SNAKE_CASE					,SCREAMING_SNAKE_CASE					:      Optional[int]     					=			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_     :       str								=						Process('P1', 0, 53)
							lowerCAmelCase_     :       Optional[int]								=						Process('P2', 0, 17)
							lowerCAmelCase_     :       Optional[Any]								=						Process('P3', 0, 68)
							lowerCAmelCase_     :       Optional[int]								=						Process('P4', 0, 24)
							lowerCAmelCase_     :       List[str]								=						3
							lowerCAmelCase_     :       str								=						[17, 25]
							lowerCAmelCase_     :       Optional[Any]								=						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_     :       Tuple								=						Process('P1', 0, 53)
							lowerCAmelCase_     :       int								=						Process('P2', 0, 17)
							lowerCAmelCase_     :       Union[str, Any]								=						Process('P3', 0, 68)
							lowerCAmelCase_     :       Any								=						Process('P4', 0, 24)
							lowerCAmelCase_     :       int								=						3
							lowerCAmelCase_     :       Optional[Any]								=						[17, 25]
							lowerCAmelCase_     :       Dict								=						deque([Pa, Pa, Pa, Pa])
							lowerCAmelCase_     :       Union[str, Any]								=						MLFQ(number_of_queues, time_slices, queue, 0)
							lowerCAmelCase_     :       List[Any]								=						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()}'
							)




