






"""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      a						(					unittest.TestCase		):






    def    UpperCamelCase       (       self     :							str					)     ->		List[Any]:
      lowerCamelCase_         =						tempfile.mkdtemp()

      lowerCamelCase_         =						[
          """[UNK]""",
          """[CLS]""",
          """[SEP]""",
          """[PAD]""",
          """[MASK]""",
          """的""",
          """价""",
          """格""",
          """是""",
          """15""",
          """便""",
          """alex""",
          """##andra""",
          """，""",
          """。""",
          """-""",
          """t""",
          """shirt""",
      ]
      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""": {"""height""": 224, """width""": 224},
          """do_center_crop""": True,
          """crop_size""": {"""height""": 18, """width""": 18},
          """do_normalize""": True,
          """image_mean""": [0.48_145_466, 0.4_578_275, 0.40_821_073],
          """image_std""": [0.26_862_954, 0.26_130_258, 0.27_577_711],
          """do_convert_rgb""": True,
      }
      lowerCamelCase_         =						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    UpperCamelCase       (       self     :							Tuple       ,						**__SCREAMING_SNAKE_CASE     :							Union[str, Any]					)     ->		Dict:
      return BertTokenizer.from_pretrained(self.tmpdirname       ,						**__SCREAMING_SNAKE_CASE					)






    def    UpperCamelCase       (       self     :							List[str]       ,						**__SCREAMING_SNAKE_CASE     :							int					)     ->		Optional[Any]:
      return BertTokenizerFast.from_pretrained(self.tmpdirname       ,						**__SCREAMING_SNAKE_CASE					)






    def    UpperCamelCase       (       self     :							Any       ,						**__SCREAMING_SNAKE_CASE     :							Union[str, Any]					)     ->		Any:
      return ChineseCLIPImageProcessor.from_pretrained(self.tmpdirname       ,						**__SCREAMING_SNAKE_CASE					)






    def    UpperCamelCase       (       self     :							List[Any]					)     ->		int:
      shutil.rmtree(self.tmpdirname					)






    def    UpperCamelCase       (       self     :							str					)     ->		str:
      lowerCamelCase_         =						[np.random.randint(255       ,						size=(3, 30, 400)       ,						dtype=np.uinta					)]

      lowerCamelCase_         =						[Image.fromarray(np.moveaxis(__SCREAMING_SNAKE_CASE       ,						0       ,						-1					)					) for x in image_inputs]

      return image_inputs






    def    UpperCamelCase       (       self     :							Union[str, Any]					)     ->		List[Any]:
      lowerCamelCase_         =						self.get_tokenizer()
      lowerCamelCase_         =						self.get_rust_tokenizer()
      lowerCamelCase_         =						self.get_image_processor()

      lowerCamelCase_         =						ChineseCLIPProcessor(tokenizer=__SCREAMING_SNAKE_CASE       ,						image_processor=__SCREAMING_SNAKE_CASE					)
      processor_slow.save_pretrained(self.tmpdirname					)
      lowerCamelCase_         =						ChineseCLIPProcessor.from_pretrained(self.tmpdirname       ,						use_fast=__SCREAMING_SNAKE_CASE					)

      lowerCamelCase_         =						ChineseCLIPProcessor(tokenizer=__SCREAMING_SNAKE_CASE       ,						image_processor=__SCREAMING_SNAKE_CASE					)
      processor_fast.save_pretrained(self.tmpdirname					)
      lowerCamelCase_         =						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       ,						__SCREAMING_SNAKE_CASE					)
      self.assertIsInstance(processor_fast.tokenizer       ,						__SCREAMING_SNAKE_CASE					)

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






    def    UpperCamelCase       (       self     :							str					)     ->		str:
      lowerCamelCase_         =						ChineseCLIPProcessor(tokenizer=self.get_tokenizer()       ,						image_processor=self.get_image_processor()					)
      processor.save_pretrained(self.tmpdirname					)

      lowerCamelCase_         =						self.get_tokenizer(cls_token='(CLS)'       ,						sep_token='(SEP)'					)
      lowerCamelCase_         =						self.get_image_processor(do_normalize=__SCREAMING_SNAKE_CASE					)

      lowerCamelCase_         =						ChineseCLIPProcessor.from_pretrained(
          self.tmpdirname       ,						cls_token='(CLS)'       ,						sep_token='(SEP)'       ,						do_normalize=__SCREAMING_SNAKE_CASE					)

      self.assertEqual(processor.tokenizer.get_vocab()       ,						tokenizer_add_kwargs.get_vocab()					)
      self.assertIsInstance(processor.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    UpperCamelCase       (       self     :							List[Any]					)     ->		str:
      lowerCamelCase_         =						self.get_image_processor()
      lowerCamelCase_         =						self.get_tokenizer()

      lowerCamelCase_         =						ChineseCLIPProcessor(tokenizer=__SCREAMING_SNAKE_CASE       ,						image_processor=__SCREAMING_SNAKE_CASE					)

      lowerCamelCase_         =						self.prepare_image_inputs()

      lowerCamelCase_         =						image_processor(__SCREAMING_SNAKE_CASE       ,						return_tensors='np'					)
      lowerCamelCase_         =						processor(images=__SCREAMING_SNAKE_CASE       ,						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    UpperCamelCase       (       self     :							List[Any]					)     ->		Union[str, Any]:
      lowerCamelCase_         =						self.get_image_processor()
      lowerCamelCase_         =						self.get_tokenizer()

      lowerCamelCase_         =						ChineseCLIPProcessor(tokenizer=__SCREAMING_SNAKE_CASE       ,						image_processor=__SCREAMING_SNAKE_CASE					)

      lowerCamelCase_         =						"""Alexandra，T-shirt的价格是15便士。"""

      lowerCamelCase_         =						processor(text=__SCREAMING_SNAKE_CASE					)

      lowerCamelCase_         =						tokenizer(__SCREAMING_SNAKE_CASE					)

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






    def    UpperCamelCase       (       self     :							List[Any]					)     ->		List[str]:
      lowerCamelCase_         =						self.get_image_processor()
      lowerCamelCase_         =						self.get_tokenizer()

      lowerCamelCase_         =						ChineseCLIPProcessor(tokenizer=__SCREAMING_SNAKE_CASE       ,						image_processor=__SCREAMING_SNAKE_CASE					)

      lowerCamelCase_         =						"""Alexandra，T-shirt的价格是15便士。"""
      lowerCamelCase_         =						self.prepare_image_inputs()

      lowerCamelCase_         =						processor(text=__SCREAMING_SNAKE_CASE       ,						images=__SCREAMING_SNAKE_CASE					)

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






    def    UpperCamelCase       (       self     :							int					)     ->		str:
      lowerCamelCase_         =						self.get_image_processor()
      lowerCamelCase_         =						self.get_tokenizer()

      lowerCamelCase_         =						ChineseCLIPProcessor(tokenizer=__SCREAMING_SNAKE_CASE       ,						image_processor=__SCREAMING_SNAKE_CASE					)

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

      lowerCamelCase_         =						processor.batch_decode(__SCREAMING_SNAKE_CASE					)
      lowerCamelCase_         =						tokenizer.batch_decode(__SCREAMING_SNAKE_CASE					)

      self.assertListEqual(__SCREAMING_SNAKE_CASE       ,						__SCREAMING_SNAKE_CASE					)






    def    UpperCamelCase       (       self     :							List[str]					)     ->		List[str]:
      lowerCamelCase_         =						self.get_image_processor()
      lowerCamelCase_         =						self.get_tokenizer()

      lowerCamelCase_         =						ChineseCLIPProcessor(tokenizer=__SCREAMING_SNAKE_CASE       ,						image_processor=__SCREAMING_SNAKE_CASE					)

      lowerCamelCase_         =						"""Alexandra，T-shirt的价格是15便士。"""
      lowerCamelCase_         =						self.prepare_image_inputs()

      lowerCamelCase_         =						processor(text=__SCREAMING_SNAKE_CASE       ,						images=__SCREAMING_SNAKE_CASE					)

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








"""simple docstring"""






def      lowerCamelCase       (     _UpperCamelCase		:      float       ,			_UpperCamelCase		:      float       ,			_UpperCamelCase		:      int							)		->       float:

							'''simple docstring'''



							if principal <= 0:
														raise Exception("""Principal borrowed must be > 0"""							)
							if rate_per_annum < 0:
														raise Exception("""Rate of interest must be >= 0"""							)
							if years_to_repay <= 0 or not isinstance(_UpperCamelCase       ,			_UpperCamelCase							):
														raise Exception("""Years to repay must be an integer > 0"""							)

							# Yearly rate is divided by 12 to get monthly rate
							__UpperCAmelCase   :						List[Any]      							=					rate_per_annum / 1_2

							# Years to repay is multiplied by 12 to get number of payments as payment is monthly
							__UpperCAmelCase   :						Optional[int]      							=					years_to_repay * 1_2

							return (
							    principal
							    * rate_per_month
							    * (1 + rate_per_month) ** number_of_payments
							    / ((1 + rate_per_month) ** number_of_payments - 1)
							)


if __name__ == "__main__":
							import doctest

							doctest.testmod()
