






import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import MgpstrTokenizer
from transformers.models.mgp_str.tokenization_mgp_str import VOCAB_FILES_NAMES
from transformers.testing_utils import require_torch, require_vision
from transformers.utils import IMAGE_PROCESSOR_NAME, is_torch_available, is_vision_available


if is_torch_available():
							import torch


if is_vision_available():
							from PIL import Image

							from transformers import MgpstrProcessor, ViTImageProcessor




@require_torch
@require_vision
class 		UpperCAmelCase_						(	unittest.TestCase					):


						'''simple docstring'''




						A     :   Tuple						=					ViTImageProcessor if is_vision_available() else None






						@property
						def       _lowerCAmelCase       (	self				) ->				str:
								return self.image_processor_tester.prepare_image_processor_dict()






						def       _lowerCAmelCase       (	self				) ->				Dict:
								snake_case_				:							Union[str, Any]						 =       (3, 32, 128)
								snake_case_				:							Union[str, Any]						 =       tempfile.mkdtemp()

								# fmt: off
								snake_case_				:							Dict						 =       ["[GO]", "[s]", "0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"]
								# fmt: on
								snake_case_				:							Optional[int]						 =       dict(zip(_SCREAMING_SNAKE_CASE		,				range(len(_SCREAMING_SNAKE_CASE				)				)				)				)

								snake_case_				:							Any						 =       os.path.join(self.tmpdirname		,				VOCAB_FILES_NAMES["vocab_file"]				)
								with open(self.vocab_file		,				"w"		,				encoding="utf-8"				) as fp:
										fp.write(json.dumps(_SCREAMING_SNAKE_CASE				) + "\n"				)

								snake_case_				:							Dict						 =       {
								    "do_normalize": False,
								    "do_resize": True,
								    "image_processor_type": "ViTImageProcessor",
								    "resample": 3,
								    "size": {"height": 32, "width": 128},
								}
								snake_case_				:							Optional[int]						 =       os.path.join(self.tmpdirname		,				_SCREAMING_SNAKE_CASE				)
								with open(self.image_processor_file		,				"w"		,				encoding="utf-8"				) as fp:
										json.dump(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				)






						def       _lowerCAmelCase       (	self		,				**_SCREAMING_SNAKE_CASE				) ->				Tuple:
								return MgpstrTokenizer.from_pretrained(self.tmpdirname		,				**_SCREAMING_SNAKE_CASE				)






						def       _lowerCAmelCase       (	self		,				**_SCREAMING_SNAKE_CASE				) ->				Union[str, Any]:
								return ViTImageProcessor.from_pretrained(self.tmpdirname		,				**_SCREAMING_SNAKE_CASE				)






						def       _lowerCAmelCase       (	self				) ->				List[str]:
								shutil.rmtree(self.tmpdirname				)






						def       _lowerCAmelCase       (	self				) ->				Dict:
								snake_case_				:							Union[str, Any]						 =       np.random.randint(255		,				size=(3, 30, 400)		,				dtype=np.uinta				)

								snake_case_				:							Union[str, Any]						 =       Image.fromarray(np.moveaxis(_SCREAMING_SNAKE_CASE		,				0		,				-1				)				)

								return image_input






						def       _lowerCAmelCase       (	self				) ->				List[str]:
								snake_case_				:							Dict						 =       self.get_tokenizer()
								snake_case_				:							Dict						 =       self.get_image_processor()

								snake_case_				:							str						 =       MgpstrProcessor(tokenizer=_SCREAMING_SNAKE_CASE		,				image_processor=_SCREAMING_SNAKE_CASE				)
								processor.save_pretrained(self.tmpdirname				)
								snake_case_				:							Optional[Any]						 =       MgpstrProcessor.from_pretrained(self.tmpdirname		,				use_fast=_SCREAMING_SNAKE_CASE				)

								self.assertEqual(processor.char_tokenizer.get_vocab()		,				tokenizer.get_vocab()				)
								self.assertIsInstance(processor.char_tokenizer		,				_SCREAMING_SNAKE_CASE				)

								self.assertEqual(processor.image_processor.to_json_string()		,				image_processor.to_json_string()				)
								self.assertIsInstance(processor.image_processor		,				_SCREAMING_SNAKE_CASE				)






						def       _lowerCAmelCase       (	self				) ->				Union[str, Any]:
								snake_case_				:							Tuple						 =       self.get_tokenizer()
								snake_case_				:							int						 =       self.get_image_processor()

								snake_case_				:							str						 =       MgpstrProcessor(tokenizer=_SCREAMING_SNAKE_CASE		,				image_processor=_SCREAMING_SNAKE_CASE				)
								processor.save_pretrained(self.tmpdirname				)

								snake_case_				:							Union[str, Any]						 =       self.get_tokenizer(bos_token="(BOS)"		,				eos_token="(EOS)"				)
								snake_case_				:							List[Any]						 =       self.get_image_processor(do_normalize=_SCREAMING_SNAKE_CASE		,				padding_value=1.0				)

								snake_case_				:							Dict						 =       MgpstrProcessor.from_pretrained(
								    self.tmpdirname		,				bos_token="(BOS)"		,				eos_token="(EOS)"		,				do_normalize=_SCREAMING_SNAKE_CASE		,				padding_value=1.0				)

								self.assertEqual(processor.char_tokenizer.get_vocab()		,				tokenizer_add_kwargs.get_vocab()				)
								self.assertIsInstance(processor.char_tokenizer		,				_SCREAMING_SNAKE_CASE				)

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






						def       _lowerCAmelCase       (	self				) ->				str:
								snake_case_				:							Optional[Any]						 =       self.get_image_processor()
								snake_case_				:							Any						 =       self.get_tokenizer()

								snake_case_				:							Tuple						 =       MgpstrProcessor(tokenizer=_SCREAMING_SNAKE_CASE		,				image_processor=_SCREAMING_SNAKE_CASE				)

								snake_case_				:							Optional[Any]						 =       self.prepare_image_inputs()

								snake_case_				:							int						 =       image_processor(_SCREAMING_SNAKE_CASE		,				return_tensors="np"				)
								snake_case_				:							Dict						 =       processor(images=_SCREAMING_SNAKE_CASE		,				return_tensors="np"				)

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






						def       _lowerCAmelCase       (	self				) ->				int:
								snake_case_				:							Optional[int]						 =       self.get_image_processor()
								snake_case_				:							Dict						 =       self.get_tokenizer()

								snake_case_				:							int						 =       MgpstrProcessor(tokenizer=_SCREAMING_SNAKE_CASE		,				image_processor=_SCREAMING_SNAKE_CASE				)

								snake_case_				:							List[Any]						 =       "test"

								snake_case_				:							str						 =       processor(text=_SCREAMING_SNAKE_CASE				)

								snake_case_				:							Any						 =       tokenizer(_SCREAMING_SNAKE_CASE				)
								for key in encoded_tok.keys():
										self.assertListEqual(encoded_tok[key]		,				encoded_processor[key]				)






						def       _lowerCAmelCase       (	self				) ->				Any:
								snake_case_				:							Dict						 =       self.get_image_processor()
								snake_case_				:							Optional[Any]						 =       self.get_tokenizer()

								snake_case_				:							Tuple						 =       MgpstrProcessor(tokenizer=_SCREAMING_SNAKE_CASE		,				image_processor=_SCREAMING_SNAKE_CASE				)

								snake_case_				:							Tuple						 =       "test"
								snake_case_				:							str						 =       self.prepare_image_inputs()

								snake_case_				:							Dict						 =       processor(text=_SCREAMING_SNAKE_CASE		,				images=_SCREAMING_SNAKE_CASE				)

								self.assertListEqual(list(inputs.keys()				)		,				["pixel_values", "labels"]				)

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






						def       _lowerCAmelCase       (	self				) ->				Optional[Any]:
								snake_case_				:							Optional[int]						 =       self.get_image_processor()
								snake_case_				:							Any						 =       self.get_tokenizer()

								snake_case_				:							Dict						 =       MgpstrProcessor(tokenizer=_SCREAMING_SNAKE_CASE		,				image_processor=_SCREAMING_SNAKE_CASE				)

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

								snake_case_				:							Dict						 =       processor.char_decode(_SCREAMING_SNAKE_CASE				)
								snake_case_				:							Optional[Any]						 =       tokenizer.batch_decode(_SCREAMING_SNAKE_CASE				)
								snake_case_				:							Dict						 =       [seq.replace(" "		,				""				) for seq in decoded_tok]

								self.assertListEqual(_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				)






						def       _lowerCAmelCase       (	self				) ->				Union[str, Any]:
								snake_case_				:							Union[str, Any]						 =       self.get_image_processor()
								snake_case_				:							Any						 =       self.get_tokenizer()

								snake_case_				:							List[str]						 =       MgpstrProcessor(tokenizer=_SCREAMING_SNAKE_CASE		,				image_processor=_SCREAMING_SNAKE_CASE				)

								snake_case_				:							Optional[int]						 =       None
								snake_case_				:							List[Any]						 =       self.prepare_image_inputs()

								snake_case_				:							str						 =       processor(text=_SCREAMING_SNAKE_CASE		,				images=_SCREAMING_SNAKE_CASE				)

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






						def       _lowerCAmelCase       (	self				) ->				Tuple:
								snake_case_				:							List[Any]						 =       self.get_image_processor()
								snake_case_				:							List[str]						 =       self.get_tokenizer()

								snake_case_				:							Tuple						 =       MgpstrProcessor(tokenizer=_SCREAMING_SNAKE_CASE		,				image_processor=_SCREAMING_SNAKE_CASE				)

								snake_case_				:							List[Any]						 =       torch.randn(1		,				27		,				38				)
								snake_case_				:							int						 =       torch.randn(1		,				27		,				5_0257				)
								snake_case_				:							Tuple						 =       torch.randn(1		,				27		,				3_0522				)

								snake_case_				:							Tuple						 =       processor.batch_decode([char_input, bpe_input, wp_input]				)

								self.assertListEqual(list(results.keys()				)		,				["generated_text", "scores", "char_preds", "bpe_preds", "wp_preds"]				)








def      lowerCAmelCase__	(    _a       :			int    ):
		snake_case_				:							str						 =       1
		for i in range(1  ,      num + 1    ):
				fact *= i
		return fact

def      lowerCAmelCase__	(    _a       :			int    ):
		snake_case_				:							List[str]						 =       0
		while number > 0:
				snake_case_				:							Dict						 =       number % 10
				sum_of_digits += last_digit
				snake_case_				:							List[Any]						 =       number // 10  # Removing the last_digit from the given number
		return sum_of_digits

def      lowerCAmelCase__	(    _a       :			int = 1_00    ):
		snake_case_				:							Optional[Any]						 =       factorial(_a    )
		snake_case_				:							Optional[int]						 =       split_and_add(_a    )
		return result


if __name__ == "__main__":
							print(solution(int(input('''Enter the Number: ''').strip())))
