

import json
import os
import shutil
import tempfile
import unittest

import numpy as np
import pytest

from transformers import CLIPTokenizer, CLIPTokenizerFast
from transformers.models.clip.tokenization_clip 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 CLIPImageProcessor, CLIPProcessor


@require_vision
class  A						(							unittest.TestCase ):







    """simple docstring"""





    def 						snake_case__     (      self :       Dict		)->    Any:





        '''simple docstring'''







        A__          =   tempfile.mkdtemp()

        # fmt: off
        A__          =   ["l", "o", "w", "e", "r", "s", "t", "i", "d", "n", "lo", "l</w>", "w</w>", "r</w>", "t</w>", "low</w>", "er</w>", "lowest</w>", "newer</w>", "wider", "<unk>", "<|startoftext|>", "<|endoftext|>"]
        # fmt: on
        A__          =   dict(zip(snake_case__,range(len(snake_case__		)		)		)		)
        A__          =   ["#version: 0.2", "l o", "lo w</w>", "e r</w>", ""]
        A__          =   {"unk_token": "<unk>"}

        A__          =   os.path.join(self.tmpdirname,VOCAB_FILES_NAMES['vocab_file']		)
        A__          =   os.path.join(self.tmpdirname,VOCAB_FILES_NAMES['merges_file']		)
        with open(self.vocab_file,'w',encoding='utf-8'		) as fp:
            fp.write(json.dumps(snake_case__		) + '\n'		)
        with open(self.merges_file,'w',encoding='utf-8'		) as fp:
            fp.write('\n'.join(snake_case__		)		)

        A__          =   {
            "do_resize": True,
            "size": 2_0,
            "do_center_crop": True,
            "crop_size": 1_8,
            "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],
        }
        A__          =   os.path.join(self.tmpdirname,snake_case__		)
        with open(self.image_processor_file,'w',encoding='utf-8'		) as fp:
            json.dump(snake_case__,snake_case__		)


    def 						snake_case__     (      self :       Union[str, Any],**lowercase_ :       Tuple		)->    Optional[int]:





        '''simple docstring'''







        return CLIPTokenizer.from_pretrained(self.tmpdirname,**snake_case__		)


    def 						snake_case__     (      self :       int,**lowercase_ :       int		)->    Dict:





        '''simple docstring'''







        return CLIPTokenizerFast.from_pretrained(self.tmpdirname,**snake_case__		)


    def 						snake_case__     (      self :       Any,**lowercase_ :       Tuple		)->    int:





        '''simple docstring'''







        return CLIPImageProcessor.from_pretrained(self.tmpdirname,**snake_case__		)


    def 						snake_case__     (      self :       Optional[Any]		)->    str:





        '''simple docstring'''







        shutil.rmtree(self.tmpdirname		)


    def 						snake_case__     (      self :       int		)->    Optional[int]:





        '''simple docstring'''







        A__          =   [np.random.randint(2_5_5,size=(3, 3_0, 4_0_0),dtype=np.uinta		)]

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

        return image_inputs


    def 						snake_case__     (      self :       Optional[Any]		)->    Tuple:





        '''simple docstring'''







        A__          =   self.get_tokenizer()
        A__          =   self.get_rust_tokenizer()
        A__          =   self.get_image_processor()

        A__          =   CLIPProcessor(tokenizer=snake_case__,image_processor=snake_case__		)
        processor_slow.save_pretrained(self.tmpdirname		)
        A__          =   CLIPProcessor.from_pretrained(self.tmpdirname,use_fast=snake_case__		)

        A__          =   CLIPProcessor(tokenizer=snake_case__,image_processor=snake_case__		)
        processor_fast.save_pretrained(self.tmpdirname		)
        A__          =   CLIPProcessor.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,snake_case__		)
        self.assertIsInstance(processor_fast.tokenizer,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,snake_case__		)
        self.assertIsInstance(processor_fast.image_processor,snake_case__		)


    def 						snake_case__     (      self :       Any		)->    Any:





        '''simple docstring'''







        A__          =   CLIPProcessor(tokenizer=self.get_tokenizer(),image_processor=self.get_image_processor()		)
        processor.save_pretrained(self.tmpdirname		)

        A__          =   self.get_tokenizer(bos_token='(BOS)',eos_token='(EOS)'		)
        A__          =   self.get_image_processor(do_normalize=snake_case__,padding_value=1.0		)

        A__          =   CLIPProcessor.from_pretrained(
            self.tmpdirname,bos_token='(BOS)',eos_token='(EOS)',do_normalize=snake_case__,padding_value=1.0		)

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

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


    def 						snake_case__     (      self :       str		)->    Optional[int]:





        '''simple docstring'''







        A__          =   self.get_image_processor()
        A__          =   self.get_tokenizer()

        A__          =   CLIPProcessor(tokenizer=snake_case__,image_processor=snake_case__		)

        A__          =   self.prepare_image_inputs()

        A__          =   image_processor(snake_case__,return_tensors='np'		)
        A__          =   processor(images=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 						snake_case__     (      self :       Any		)->    str:





        '''simple docstring'''







        A__          =   self.get_image_processor()
        A__          =   self.get_tokenizer()

        A__          =   CLIPProcessor(tokenizer=snake_case__,image_processor=snake_case__		)

        A__          =   "lower newer"

        A__          =   processor(text=snake_case__		)

        A__          =   tokenizer(snake_case__		)

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


    def 						snake_case__     (      self :       List[str]		)->    str:





        '''simple docstring'''







        A__          =   self.get_image_processor()
        A__          =   self.get_tokenizer()

        A__          =   CLIPProcessor(tokenizer=snake_case__,image_processor=snake_case__		)

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

        A__          =   processor(text=snake_case__,images=snake_case__		)

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

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


    def 						snake_case__     (      self :       str		)->    Optional[Any]:





        '''simple docstring'''







        A__          =   self.get_image_processor()
        A__          =   self.get_tokenizer()

        A__          =   CLIPProcessor(tokenizer=snake_case__,image_processor=snake_case__		)

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

        A__          =   processor.batch_decode(snake_case__		)
        A__          =   tokenizer.batch_decode(snake_case__		)

        self.assertListEqual(snake_case__,snake_case__		)


    def 						snake_case__     (      self :       Union[str, Any]		)->    int:





        '''simple docstring'''







        A__          =   self.get_image_processor()
        A__          =   self.get_tokenizer()

        A__          =   CLIPProcessor(tokenizer=snake_case__,image_processor=snake_case__		)

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

        A__          =   processor(text=snake_case__,images=snake_case__		)

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





"""simple docstring"""







def 					a__			(				SCREAMING_SNAKE_CASE    :    float				,      SCREAMING_SNAKE_CASE    :    float				,      SCREAMING_SNAKE_CASE    :    int				):


  '''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(SCREAMING_SNAKE_CASE				,      SCREAMING_SNAKE_CASE				):
    raise Exception("Years to repay must be an integer > 0"				)

  # Yearly rate is divided by 12 to get monthly rate
  lowerCAmelCase     :     Tuple								=							rate_per_annum / 1_2

  # Years to repay is multiplied by 12 to get number of payments as payment is monthly
  lowerCAmelCase     :     List[Any]								=							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()





