


"""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 IMAGE_PROCESSOR_NAME, is_vision_available


if is_vision_available():
	from PIL import Image

	from transformers import AlignProcessor, EfficientNetImageProcessor
@require_vision
class 						_UpperCamelCase						(     unittest.TestCase	):
							'''simple docstring'''







							def     snake_case       (  self			):
										__lowerCAmelCase       					=    tempfile.mkdtemp()

										__lowerCAmelCase       					=    [
										    "[UNK]",
										    "[CLS]",
										    "[SEP]",
										    "[PAD]",
										    "[MASK]",
										    "want",
										    "##want",
										    "##ed",
										    "wa",
										    "un",
										    "runn",
										    "##ing",
										    ",",
										    "low",
										    "lowest",
										]
										__lowerCAmelCase       					=    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]			)			)

										__lowerCAmelCase       					=    {
										    "do_resize": True,
										    "size": 20,
										    "do_center_crop": True,
										    "crop_size": 18,
										    "do_normalize": True,
										    "image_mean": [0.4_8_1_4_5_4_6_6, 0.4_5_7_8_2_7_5, 0.4_0_8_2_1_0_7_3],
										    "image_std": [0.2_6_8_6_2_9_5_4, 0.2_6_1_3_0_2_5_8, 0.2_7_5_7_7_7_1_1],
										}
										__lowerCAmelCase       					=    os.path.join(self.tmpdirname					,     __a			)
										with open(self.image_processor_file					,     "w"					,     encoding="utf-8"			) as fp:
													json.dump(__a					,     __a			)

							def     snake_case       (  self					,     **__a			):
										return BertTokenizer.from_pretrained(self.tmpdirname					,     **__a			)

							def     snake_case       (  self					,     **__a			):
										return BertTokenizerFast.from_pretrained(self.tmpdirname					,     **__a			)

							def     snake_case       (  self					,     **__a			):
										return EfficientNetImageProcessor.from_pretrained(self.tmpdirname					,     **__a			)

							def     snake_case       (  self			):
										shutil.rmtree(self.tmpdirname			)

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    [np.random.randint(2_55					,     size=(3, 30, 4_00)					,     dtype=np.uinta			)]
										__lowerCAmelCase       					=    [Image.fromarray(np.moveaxis(__a					,     0					,     -1			)			) for x in image_inputs]
										return image_inputs

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    self.get_tokenizer()
										__lowerCAmelCase       					=    self.get_rust_tokenizer()
										__lowerCAmelCase       					=    self.get_image_processor()

										__lowerCAmelCase       					=    AlignProcessor(tokenizer=__a					,     image_processor=__a			)
										processor_slow.save_pretrained(self.tmpdirname			)
										__lowerCAmelCase       					=    AlignProcessor.from_pretrained(self.tmpdirname					,     use_fast=__a			)

										__lowerCAmelCase       					=    AlignProcessor(tokenizer=__a					,     image_processor=__a			)
										processor_fast.save_pretrained(self.tmpdirname			)
										__lowerCAmelCase       					=    AlignProcessor.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					,     __a			)
										self.assertIsInstance(processor_fast.tokenizer					,     __a			)

										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					,     __a			)
										self.assertIsInstance(processor_fast.image_processor					,     __a			)

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    AlignProcessor(tokenizer=self.get_tokenizer()					,     image_processor=self.get_image_processor()			)
										processor.save_pretrained(self.tmpdirname			)

										__lowerCAmelCase       					=    self.get_tokenizer(bos_token="(BOS)"					,     eos_token="(EOS)"			)
										__lowerCAmelCase       					=    self.get_image_processor(do_normalize=__a					,     padding_value=1.0			)

										__lowerCAmelCase       					=    AlignProcessor.from_pretrained(
										    self.tmpdirname					,     bos_token="(BOS)"					,     eos_token="(EOS)"					,     do_normalize=__a					,     padding_value=1.0			)

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

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

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    self.get_image_processor()
										__lowerCAmelCase       					=    self.get_tokenizer()

										__lowerCAmelCase       					=    AlignProcessor(tokenizer=__a					,     image_processor=__a			)

										__lowerCAmelCase       					=    self.prepare_image_inputs()

										__lowerCAmelCase       					=    image_processor(__a					,     return_tensors="np"			)
										__lowerCAmelCase       					=    processor(images=__a					,     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     snake_case       (  self			):
										__lowerCAmelCase       					=    self.get_image_processor()
										__lowerCAmelCase       					=    self.get_tokenizer()

										__lowerCAmelCase       					=    AlignProcessor(tokenizer=__a					,     image_processor=__a			)

										__lowerCAmelCase       					=    "lower newer"

										__lowerCAmelCase       					=    processor(text=__a			)

										__lowerCAmelCase       					=    tokenizer(__a					,     padding="max_length"					,     max_length=64			)

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

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    self.get_image_processor()
										__lowerCAmelCase       					=    self.get_tokenizer()

										__lowerCAmelCase       					=    AlignProcessor(tokenizer=__a					,     image_processor=__a			)

										__lowerCAmelCase       					=    "lower newer"
										__lowerCAmelCase       					=    self.prepare_image_inputs()

										__lowerCAmelCase       					=    processor(text=__a					,     images=__a			)

										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(__a			):
													processor()

							def     snake_case       (  self			):
										__lowerCAmelCase       					=    self.get_image_processor()
										__lowerCAmelCase       					=    self.get_tokenizer()

										__lowerCAmelCase       					=    AlignProcessor(tokenizer=__a					,     image_processor=__a			)

										__lowerCAmelCase       					=    [[1, 4, 5, 8, 1, 0, 8], [3, 4, 3, 1, 1, 8, 9]]

										__lowerCAmelCase       					=    processor.batch_decode(__a			)
										__lowerCAmelCase       					=    tokenizer.batch_decode(__a			)

										self.assertListEqual(__a					,     __a			)



							def     snake_case       (  self			):
										__lowerCAmelCase       					=    self.get_image_processor()
										__lowerCAmelCase       					=    self.get_tokenizer()

										__lowerCAmelCase       					=    AlignProcessor(tokenizer=__a					,     image_processor=__a			)

										__lowerCAmelCase       					=    "lower newer"
										__lowerCAmelCase       					=    self.prepare_image_inputs()

										__lowerCAmelCase       					=    processor(text=__a					,     images=__a			)

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




"""simple docstring"""


A  :     List[Any]    					=    [4, 1, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
A  :     Optional[int]    					=    [3, 7, 7, 4, 2, 6, 4, 1, 5, 3, 7, 5]
A  :     Optional[int]    					=    {
    0: "Sunday",
    1: "Monday",
    2: "Tuesday",
    3: "Wednesday",
    4: "Thursday",
    5: "Friday",
    6: "Saturday",
}


def _lowerCamelCase			(	_UpperCamelCase					,				_UpperCamelCase					,				_UpperCamelCase   ):

			'''simple docstring'''




			assert len(str(_UpperCamelCase   )   ) > 2, "year should be in YYYY format"
			assert 1 <= month <= 12, "month should be between 1 to 12"
			assert 1 <= day <= 31, "day should be between 1 to 31"

			# Doomsday algorithm:
			__lowerCAmelCase       					=    year // 100
			__lowerCAmelCase       					=    (5 * (century % 4) + 2) % 7
			__lowerCAmelCase       					=    year % 100
			__lowerCAmelCase       					=    centurian % 12
			__lowerCAmelCase       					=    (
			    (centurian // 12) + centurian_m + (centurian_m // 4) + century_anchor
			) % 7
			__lowerCAmelCase       					=    (
			    DOOMSDAY_NOT_LEAP[month - 1]
			    if (year % 4 != 0) or (centurian == 0 and (year % 400) == 0)
			    else DOOMSDAY_LEAP[month - 1]
			)
			__lowerCAmelCase       					=    (dooms_day + day - day_anchor) % 7
			return WEEK_DAY_NAMES[week_day]


if __name__ == "__main__":
	import doctest

	doctest.testmod()




