




'''simple docstring'''







import unittest

from transformers import PegasusTokenizer, PegasusTokenizerFast
from transformers.testing_utils import get_tests_dir, require_sentencepiece, require_tokenizers, require_torch, slow
from transformers.utils import cached_property

from ...test_tokenization_common import TokenizerTesterMixin


lowercase      :   Union[str, Any]      =       get_tests_dir("""fixtures/test_sentencepiece_no_bos.model""")







@require_sentencepiece
@require_tokenizers
class 					_a (a__,		unittest.TestCase	):





     '''simple docstring'''



     lowerCAmelCase_  :     str          =					PegasusTokenizer
     lowerCAmelCase_  :     Tuple          =					PegasusTokenizerFast
     lowerCAmelCase_  :     Any          =					True
     lowerCAmelCase_  :     List[str]          =					True







     def 			snake_case_      (				self							)      ->				int:
          super().setUp()

          # We have a SentencePiece fixture for testing
          snake_case			:      Optional[int]        =			PegasusTokenizer(__a							)
          tokenizer.save_pretrained(self.tmpdirname							)







     @cached_property
     def 			snake_case_      (				self							)      ->				Dict:
          return PegasusTokenizer.from_pretrained("""google/pegasus-large"""							)







     def 			snake_case_      (				self							,**__a							)      ->				PegasusTokenizer:
          return PegasusTokenizer.from_pretrained(self.tmpdirname							,**__a							)







     def 			snake_case_      (				self							,__a							)      ->				str:
          return ("This is a test", "This is a test")







     def 			snake_case_      (				self							)      ->				int:
          snake_case			:      int        =			"""</s>"""
          snake_case			:      Optional[Any]        =			1

          self.assertEqual(self.get_tokenizer()._convert_token_to_id(__a							)							,__a							)
          self.assertEqual(self.get_tokenizer()._convert_id_to_token(__a							)							,__a							)







     def 			snake_case_      (				self							)      ->				List[str]:
          snake_case			:      List[Any]        =			list(self.get_tokenizer().get_vocab().keys()							)

          self.assertEqual(vocab_keys[0]							,"""<pad>"""							)
          self.assertEqual(vocab_keys[1]							,"""</s>"""							)
          self.assertEqual(vocab_keys[-1]							,"""v"""							)
          self.assertEqual(len(__a							)							,1_103							)







     def 			snake_case_      (				self							)      ->				Optional[Any]:
          self.assertEqual(self.get_tokenizer().vocab_size							,1_103							)







     def 			snake_case_      (				self							)      ->				Any:
          snake_case			:      Optional[Any]        =			self.rust_tokenizer_class.from_pretrained(self.tmpdirname							)
          snake_case			:      Union[str, Any]        =			self.tokenizer_class.from_pretrained(self.tmpdirname							)
          snake_case			:      List[str]        =			(
              """Let's see which <unk> is the better <unk_token_11> one <mask_1> It seems like this <mask_2> was important"""
              """ </s> <pad> <pad> <pad>"""
          )
          snake_case			:      Union[str, Any]        =			rust_tokenizer([raw_input_str]							,return_tensors=__a							,add_special_tokens=__a							).input_ids[0]
          snake_case			:      Tuple        =			py_tokenizer([raw_input_str]							,return_tensors=__a							,add_special_tokens=__a							).input_ids[0]
          self.assertListEqual(__a							,__a							)







     def 			snake_case_      (				self							)      ->				int:
          snake_case			:      Any        =			self._large_tokenizer
          # <mask_1> masks whole sentence while <mask_2> masks single word
          snake_case			:      Dict        =			"""<mask_1> To ensure a <mask_2> flow of bank resolutions."""
          snake_case			:      int        =			[2, 413, 615, 114, 3, 1_971, 113, 1_679, 10_710, 107, 1]
          snake_case			:      int        =			tokenizer([raw_input_str]							,return_tensors=__a							).input_ids[0]
          self.assertListEqual(__a							,__a							)







     def 			snake_case_      (				self							)      ->				Optional[Any]:
          snake_case			:      Tuple        =			self._large_tokenizer
          # The tracebacks for the following asserts are **better** without messages or self.assertEqual
          assert tokenizer.vocab_size == 96_103
          assert tokenizer.pad_token_id == 0
          assert tokenizer.eos_token_id == 1
          assert tokenizer.offset == 103
          assert tokenizer.unk_token_id == tokenizer.offset + 2 == 105
          assert tokenizer.unk_token == "<unk>"
          assert tokenizer.model_max_length == 1_024
          snake_case			:      List[Any]        =			"""To ensure a smooth flow of bank resolutions."""
          snake_case			:      List[Any]        =			[413, 615, 114, 2_291, 1_971, 113, 1_679, 10_710, 107, 1]
          snake_case			:      str        =			tokenizer([raw_input_str]							,return_tensors=__a							).input_ids[0]
          self.assertListEqual(__a							,__a							)
          assert tokenizer.convert_ids_to_tokens([0, 1, 2, 3]							) == ["<pad>", "</s>", "<mask_1>", "<mask_2>"]







     @require_torch
     def 			snake_case_      (				self							)      ->				Union[str, Any]:
          snake_case			:      List[str]        =			["""This is going to be way too long.""" * 150, """short example"""]
          snake_case			:      Dict        =			["""not super long but more than 5 tokens""", """tiny"""]
          snake_case			:      Union[str, Any]        =			self._large_tokenizer(__a							,padding=__a							,truncation=__a							,return_tensors="""pt"""							)
          snake_case			:      List[Any]        =			self._large_tokenizer(
              text_target=__a							,max_length=5							,padding=__a							,truncation=__a							,return_tensors="""pt"""							)

          assert batch.input_ids.shape == (2, 1_024)
          assert batch.attention_mask.shape == (2, 1_024)
          assert targets["input_ids"].shape == (2, 5)
          assert len(__a							) == 2  # input_ids, attention_mask.







     @slow
     def 			snake_case_      (				self							)      ->				Union[str, Any]:
          # fmt: off
          snake_case			:      Dict        =			{"""input_ids""": [[38_979, 143, 18_485, 606, 130, 26_669, 87_686, 121, 54_189, 1_129, 111, 26_669, 87_686, 121, 9_114, 14_787, 121, 13_249, 158, 592, 956, 121, 14_621, 31_576, 143, 62_613, 108, 9_688, 930, 43_430, 11_562, 62_613, 304, 108, 11_443, 897, 108, 9_314, 17_415, 63_399, 108, 11_443, 7_614, 18_316, 118, 4_284, 7_148, 12_430, 143, 1_400, 25_703, 158, 111, 4_284, 7_148, 11_772, 143, 21_297, 1_064, 158, 122, 204, 3_506, 1_754, 1_133, 14_787, 1_581, 115, 33_224, 4_482, 111, 1_355, 110, 29_173, 317, 50_833, 108, 20_147, 94_665, 111, 77_198, 107, 1], [110, 62_613, 117, 638, 112, 1_133, 121, 20_098, 1_355, 79_050, 13_872, 135, 1_596, 53_541, 1_352, 141, 13_039, 5_542, 124, 302, 518, 111, 268, 2_956, 115, 149, 4_427, 107, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [139, 1_235, 2_799, 18_289, 17_780, 204, 109, 9_474, 1_296, 107, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]], """attention_mask""": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]]}  # noqa: E501
          # fmt: on

          self.tokenizer_integration_test_util(
              expected_encoding=__a							,model_name="""google/bigbird-pegasus-large-arxiv"""							,revision="""ba85d0851d708441f91440d509690f1ab6353415"""							,)







@require_sentencepiece
@require_tokenizers
class 					_a (a__,		unittest.TestCase	):





     '''simple docstring'''



     lowerCAmelCase_  :     Optional[int]          =					PegasusTokenizer
     lowerCAmelCase_  :     List[Any]          =					PegasusTokenizerFast
     lowerCAmelCase_  :     Tuple          =					True
     lowerCAmelCase_  :     Union[str, Any]          =					True







     def 			snake_case_      (				self							)      ->				List[str]:
          super().setUp()

          # We have a SentencePiece fixture for testing
          snake_case			:      Union[str, Any]        =			PegasusTokenizer(__a							,offset=0							,mask_token_sent=__a							,mask_token="""[MASK]"""							)
          tokenizer.save_pretrained(self.tmpdirname							)







     @cached_property
     def 			snake_case_      (				self							)      ->				str:
          return PegasusTokenizer.from_pretrained("""google/bigbird-pegasus-large-arxiv"""							)







     def 			snake_case_      (				self							,**__a							)      ->				PegasusTokenizer:
          return PegasusTokenizer.from_pretrained(self.tmpdirname							,**__a							)







     def 			snake_case_      (				self							,__a							)      ->				List[Any]:
          return ("This is a test", "This is a test")







     def 			snake_case_      (				self							)      ->				List[str]:
          snake_case			:      Union[str, Any]        =			self.rust_tokenizer_class.from_pretrained(self.tmpdirname							)
          snake_case			:      List[str]        =			self.tokenizer_class.from_pretrained(self.tmpdirname							)
          snake_case			:      List[Any]        =			(
              """Let's see which <unk> is the better <unk_token> one [MASK] It seems like this [MASK] was important </s>"""
              """ <pad> <pad> <pad>"""
          )
          snake_case			:      Union[str, Any]        =			rust_tokenizer([raw_input_str]							,return_tensors=__a							,add_special_tokens=__a							).input_ids[0]
          snake_case			:      Optional[int]        =			py_tokenizer([raw_input_str]							,return_tensors=__a							,add_special_tokens=__a							).input_ids[0]
          self.assertListEqual(__a							,__a							)







     @require_torch
     def 			snake_case_      (				self							)      ->				List[Any]:
          snake_case			:      Union[str, Any]        =			["""This is going to be way too long.""" * 1_000, """short example"""]
          snake_case			:      Dict        =			["""not super long but more than 5 tokens""", """tiny"""]
          snake_case			:      Union[str, Any]        =			self._large_tokenizer(__a							,padding=__a							,truncation=__a							,return_tensors="""pt"""							)
          snake_case			:      Optional[int]        =			self._large_tokenizer(
              text_target=__a							,max_length=5							,padding=__a							,truncation=__a							,return_tensors="""pt"""							)

          assert batch.input_ids.shape == (2, 4_096)
          assert batch.attention_mask.shape == (2, 4_096)
          assert targets["input_ids"].shape == (2, 5)
          assert len(__a							) == 2  # input_ids, attention_mask.







     def 			snake_case_      (				self							)      ->				Dict:
          snake_case			:      List[Any]        =			(
              """This is an example string that is used to test the original TF implementation against the HF"""
              """ implementation"""
          )

          snake_case			:      Any        =			self._large_tokenizer(__a							).input_ids

          self.assertListEqual(
              __a							,[182, 117, 142, 587, 4_211, 120, 117, 263, 112, 804, 109, 856, 25_016, 3_137, 464, 109, 26_955, 3_137, 1]							,)









'''simple docstring'''







import numpy as np
from cva import destroyAllWindows, imread, imshow, waitKey







class 					_a :





     '''simple docstring'''



     def __init__(				self							,__a							,__a							,__a							)      ->				Tuple:
          if dst_width < 0 or dst_height < 0:
               raise ValueError("""Destination width/height should be > 0"""							)

          snake_case			:      str        =			img
          snake_case			:      str        =			img.shape[1]
          snake_case			:      Union[str, Any]        =			img.shape[0]
          snake_case			:      Optional[int]        =			dst_width
          snake_case			:      List[str]        =			dst_height

          snake_case			:      List[str]        =			self.src_w / self.dst_w
          snake_case			:      int        =			self.src_h / self.dst_h

          snake_case			:      List[Any]        =			(
              np.ones((self.dst_h, self.dst_w, 3)							,np.uinta							) * 255
          )







     def 			snake_case_      (				self							)      ->				int:
          for i in range(self.dst_h							):
               for j in range(self.dst_w							):
                    snake_case			:      Optional[Any]        =			self.img[self.get_y(__a							)][self.get_x(__a							)]







     def 			snake_case_      (				self							,__a							)      ->				int:
          return int(self.ratio_x * x							)







     def 			snake_case_      (				self							,__a							)      ->				int:
          return int(self.ratio_y * y							)


if __name__ == "__main__":
      lowercase,	lowercase      :   Optional[int]      =       800, 600
      lowercase      :   Union[str, Any]      =       imread("""image_data/lena.jpg""", 1)
      lowercase      :   int      =       NearestNeighbour(im, dst_w, dst_h)
      n.process()

      imshow(
          F"""Image resized from: {im.shape[1]}x{im.shape[0]} to {dst_w}x{dst_h}""", n.output
      )
      waitKey(0)
      destroyAllWindows()



