





import shutil
import tempfile
import unittest

from transformers import (
    SPIECE_UNDERLINE,
    AddedToken,
    BatchEncoding,
    NllbTokenizer,
    NllbTokenizerFast,
    is_torch_available,
)
from transformers.testing_utils import (
    get_tests_dir,
    nested_simplify,
    require_sentencepiece,
    require_tokenizers,
    require_torch,
)

from ...test_tokenization_common import TokenizerTesterMixin


SCREAMING_SNAKE_CASE_						       =	get_tests_dir("""fixtures/test_sentencepiece.model""")


if is_torch_available():
      from transformers.models.mam_aaa.modeling_mam_aaa import shift_tokens_right

SCREAMING_SNAKE_CASE_						       =	2_5_6_0_4_7
SCREAMING_SNAKE_CASE_						       =	2_5_6_1_4_5

@require_sentencepiece
@require_tokenizers
class 		UpperCamelCase__			(				lowerCAmelCase_							,				unittest.TestCase       ):



     '''simple docstring'''

     __snake_case   :     Union[str, Any]		     =      NllbTokenizer
     __snake_case   :     List[Any]		     =      NllbTokenizerFast
     __snake_case   :     Dict		     =      True
     __snake_case   :     Dict		     =      True
     __snake_case   :     Optional[Any]		     =      {}






     def     SCREAMING_SNAKE_CASE__  (							self						:   Dict	)					->		Any:




           '''simple docstring'''


           super().setUp()

           # We have a SentencePiece fixture for testing
           SCREAMING_SNAKE_CASE		=						NllbTokenizer(lowerCamelCase__						,keep_accents=lowerCamelCase__	)
           tokenizer.save_pretrained(self.tmpdirname	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   Optional[int]	)					->		Dict:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						NllbTokenizer(lowerCamelCase__						,keep_accents=lowerCamelCase__	)

           SCREAMING_SNAKE_CASE		=						tokenizer.tokenize("""This is a test"""	)
           self.assertListEqual(lowerCamelCase__						,["""▁This""", """▁is""", """▁a""", """▁t""", """est"""]	)

           self.assertListEqual(
               tokenizer.convert_tokens_to_ids(lowerCamelCase__	)						,[value + tokenizer.fairseq_offset for value in [285, 46, 10, 170, 382]]						,)

           SCREAMING_SNAKE_CASE		=						tokenizer.tokenize("""I was born in 92000, and this is falsé."""	)
           self.assertListEqual(
               lowerCamelCase__						,[
                   SPIECE_UNDERLINE + """I""",
                   SPIECE_UNDERLINE + """was""",
                   SPIECE_UNDERLINE + """b""",
                   """or""",
                   """n""",
                   SPIECE_UNDERLINE + """in""",
                   SPIECE_UNDERLINE + """""",
                   """9""",
                   """2""",
                   """0""",
                   """0""",
                   """0""",
                   """,""",
                   SPIECE_UNDERLINE + """and""",
                   SPIECE_UNDERLINE + """this""",
                   SPIECE_UNDERLINE + """is""",
                   SPIECE_UNDERLINE + """f""",
                   """al""",
                   """s""",
                   """é""",
                   """.""",
               ]						,)
           SCREAMING_SNAKE_CASE		=						tokenizer.convert_tokens_to_ids(lowerCamelCase__	)
           self.assertListEqual(
               lowerCamelCase__						,[
                   value + tokenizer.fairseq_offset
                   for value in [8, 21, 84, 55, 24, 19, 7, 2, 602, 347, 347, 347, 3, 12, 66, 46, 72, 80, 6, 2, 4]
               ]						,)

           SCREAMING_SNAKE_CASE		=						tokenizer.convert_ids_to_tokens(lowerCamelCase__	)
           self.assertListEqual(
               lowerCamelCase__						,[
                   SPIECE_UNDERLINE + """I""",
                   SPIECE_UNDERLINE + """was""",
                   SPIECE_UNDERLINE + """b""",
                   """or""",
                   """n""",
                   SPIECE_UNDERLINE + """in""",
                   SPIECE_UNDERLINE + """""",
                   """<unk>""",
                   """2""",
                   """0""",
                   """0""",
                   """0""",
                   """,""",
                   SPIECE_UNDERLINE + """and""",
                   SPIECE_UNDERLINE + """this""",
                   SPIECE_UNDERLINE + """is""",
                   SPIECE_UNDERLINE + """f""",
                   """al""",
                   """s""",
                   """<unk>""",
                   """.""",
               ]						,)






     def     SCREAMING_SNAKE_CASE__  (							self						:   List[str]	)					->		Dict:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						(self.rust_tokenizer_class, """hf-internal-testing/tiny-random-nllb""", {})
           for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
                 with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""	):
                       SCREAMING_SNAKE_CASE		=						self.rust_tokenizer_class.from_pretrained(lowerCamelCase__						,**lowerCamelCase__	)
                       SCREAMING_SNAKE_CASE		=						self.tokenizer_class.from_pretrained(lowerCamelCase__						,**lowerCamelCase__	)

                       SCREAMING_SNAKE_CASE		=						tempfile.mkdtemp()

                       SCREAMING_SNAKE_CASE		=						tokenizer_r.save_pretrained(lowerCamelCase__	)
                       SCREAMING_SNAKE_CASE		=						tokenizer_p.save_pretrained(lowerCamelCase__	)

                       # Checks it save with the same files + the tokenizer.json file for the fast one
                       self.assertTrue(any("""tokenizer.json""" in f for f in tokenizer_r_files	)	)
                       SCREAMING_SNAKE_CASE		=						tuple(f for f in tokenizer_r_files if """tokenizer.json""" not in f	)
                       self.assertSequenceEqual(lowerCamelCase__						,lowerCamelCase__	)

                       # Checks everything loads correctly in the same way
                       SCREAMING_SNAKE_CASE		=						tokenizer_r.from_pretrained(lowerCamelCase__	)
                       SCREAMING_SNAKE_CASE		=						tokenizer_p.from_pretrained(lowerCamelCase__	)

                       # Check special tokens are set accordingly on Rust and Python
                       for key in tokenizer_pp.special_tokens_map:
                             self.assertTrue(hasattr(lowerCamelCase__						,lowerCamelCase__	)	)

                       shutil.rmtree(lowerCamelCase__	)

                       # Save tokenizer rust, legacy_format=True
                       SCREAMING_SNAKE_CASE		=						tempfile.mkdtemp()

                       SCREAMING_SNAKE_CASE		=						tokenizer_r.save_pretrained(lowerCamelCase__						,legacy_format=lowerCamelCase__	)
                       SCREAMING_SNAKE_CASE		=						tokenizer_p.save_pretrained(lowerCamelCase__	)

                       # Checks it save with the same files
                       self.assertSequenceEqual(lowerCamelCase__						,lowerCamelCase__	)

                       # Checks everything loads correctly in the same way
                       SCREAMING_SNAKE_CASE		=						tokenizer_r.from_pretrained(lowerCamelCase__	)
                       SCREAMING_SNAKE_CASE		=						tokenizer_p.from_pretrained(lowerCamelCase__	)

                       # Check special tokens are set accordingly on Rust and Python
                       for key in tokenizer_pp.special_tokens_map:
                             self.assertTrue(hasattr(lowerCamelCase__						,lowerCamelCase__	)	)

                       shutil.rmtree(lowerCamelCase__	)

                       # Save tokenizer rust, legacy_format=False
                       SCREAMING_SNAKE_CASE		=						tempfile.mkdtemp()

                       SCREAMING_SNAKE_CASE		=						tokenizer_r.save_pretrained(lowerCamelCase__						,legacy_format=lowerCamelCase__	)
                       SCREAMING_SNAKE_CASE		=						tokenizer_p.save_pretrained(lowerCamelCase__	)

                       # Checks it saved the tokenizer.json file
                       self.assertTrue(any("""tokenizer.json""" in f for f in tokenizer_r_files	)	)

                       # Checks everything loads correctly in the same way
                       SCREAMING_SNAKE_CASE		=						tokenizer_r.from_pretrained(lowerCamelCase__	)
                       SCREAMING_SNAKE_CASE		=						tokenizer_p.from_pretrained(lowerCamelCase__	)

                       # Check special tokens are set accordingly on Rust and Python
                       for key in tokenizer_pp.special_tokens_map:
                             self.assertTrue(hasattr(lowerCamelCase__						,lowerCamelCase__	)	)

                       shutil.rmtree(lowerCamelCase__	)






     @require_torch
     def     SCREAMING_SNAKE_CASE__  (							self						:   Optional[Any]	)					->		int:




           '''simple docstring'''


           if not self.test_seqaseq:
                 return

           SCREAMING_SNAKE_CASE		=						self.get_tokenizers()
           for tokenizer in tokenizers:
                 with self.subTest(F"""{tokenizer.__class__.__name__}"""	):
                       # Longer text that will definitely require truncation.
                       SCREAMING_SNAKE_CASE		=						[
                           """ UN Chief Says There Is No Military Solution in Syria""",
                           """ Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for"""
                           """ Syria is that 'there is no military solution' to the nearly five-year conflict and more weapons"""
                           """ will only worsen the violence and misery for millions of people.""",
                       ]
                       SCREAMING_SNAKE_CASE		=						[
                           """Şeful ONU declară că nu există o soluţie militară în Siria""",
                           """Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al"""
                           """ Rusiei pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi"""
                           """ că noi arme nu vor face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.""",
                       ]
                       try:
                             SCREAMING_SNAKE_CASE		=						tokenizer.prepare_seqaseq_batch(
                                 src_texts=lowerCamelCase__						,tgt_texts=lowerCamelCase__						,max_length=3						,max_target_length=10						,return_tensors="""pt"""						,src_lang="""eng_Latn"""						,tgt_lang="""ron_Latn"""						,)
                       except NotImplementedError:
                             return
                       self.assertEqual(batch.input_ids.shape[1]						,3	)
                       self.assertEqual(batch.labels.shape[1]						,10	)
                       # max_target_length will default to max_length if not specified
                       SCREAMING_SNAKE_CASE		=						tokenizer.prepare_seqaseq_batch(
                           lowerCamelCase__						,tgt_texts=lowerCamelCase__						,max_length=3						,return_tensors="""pt"""	)
                       self.assertEqual(batch.input_ids.shape[1]						,3	)
                       self.assertEqual(batch.labels.shape[1]						,3	)

                       SCREAMING_SNAKE_CASE		=						tokenizer.prepare_seqaseq_batch(
                           src_texts=lowerCamelCase__						,max_length=3						,max_target_length=10						,return_tensors="""pt"""	)
                       self.assertEqual(batch_encoder_only.input_ids.shape[1]						,3	)
                       self.assertEqual(batch_encoder_only.attention_mask.shape[1]						,3	)
                       self.assertNotIn("""decoder_input_ids"""						,lowerCamelCase__	)






     @unittest.skip("""Unfortunately way too slow to build a BPE with SentencePiece."""	)
     def     SCREAMING_SNAKE_CASE__  (							self						:   Dict	)					->		Dict:




           '''simple docstring'''


           pass






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




           '''simple docstring'''


           for tokenizer, pretrained_name, kwargs in self.tokenizers_list:
                 with self.subTest(F"""{tokenizer.__class__.__name__} ({pretrained_name})"""	):
                       SCREAMING_SNAKE_CASE		=						[AddedToken("""<special>"""						,lstrip=lowerCamelCase__	)]

                       SCREAMING_SNAKE_CASE		=						self.rust_tokenizer_class.from_pretrained(
                           lowerCamelCase__						,additional_special_tokens=lowerCamelCase__						,**lowerCamelCase__	)
                       SCREAMING_SNAKE_CASE		=						tokenizer_r.encode("""Hey this is a <special> token"""	)

                       SCREAMING_SNAKE_CASE		=						tokenizer_r.encode("""<special>"""						,add_special_tokens=lowerCamelCase__	)[0]

                       self.assertTrue(special_token_id in r_output	)

                       if self.test_slow_tokenizer:
                             SCREAMING_SNAKE_CASE		=						self.rust_tokenizer_class.from_pretrained(
                                 lowerCamelCase__						,additional_special_tokens=lowerCamelCase__						,**lowerCamelCase__						,)
                             SCREAMING_SNAKE_CASE		=						self.tokenizer_class.from_pretrained(
                                 lowerCamelCase__						,additional_special_tokens=lowerCamelCase__						,**lowerCamelCase__	)

                             SCREAMING_SNAKE_CASE		=						tokenizer_p.encode("""Hey this is a <special> token"""	)

                             SCREAMING_SNAKE_CASE		=						tokenizer_cr.encode("""Hey this is a <special> token"""	)

                             self.assertEqual(lowerCamelCase__						,lowerCamelCase__	)
                             self.assertEqual(lowerCamelCase__						,lowerCamelCase__	)
                             self.assertTrue(special_token_id in p_output	)
                             self.assertTrue(special_token_id in cr_output	)

@require_torch
@require_sentencepiece
@require_tokenizers
class 		UpperCamelCase__			(				unittest.TestCase       ):



     '''simple docstring'''

     __snake_case   :     str		     =      "facebook/nllb-200-distilled-600M"
     __snake_case   :     Any		     =      [
         " UN Chief Says There Is No Military Solution in Syria",
         " Secretary-General Ban Ki-moon says his response to Russia's stepped up military support for Syria is that \"there is no military solution\" to the nearly five-year conflict and more weapons will only worsen the violence and misery for millions of people.",
     ]
     __snake_case   :     Any		     =      [
         "Şeful ONU declară că nu există o soluţie militară în Siria",
         "Secretarul General Ban Ki-moon declară că răspunsul său la intensificarea sprijinului militar al Rusiei"
         " pentru Siria este că \"nu există o soluţie militară\" la conflictul de aproape cinci ani şi că noi arme nu vor"
         " face decât să înrăutăţească violenţele şi mizeria pentru milioane de oameni.",
     ]
     __snake_case   :     Optional[int]		     =      [
         256047,
         16297,
         134408,
         8165,
         248066,
         14734,
         950,
         1135,
         105721,
         3573,
         83,
         27352,
         108,
         49486,
         2,
     ]






     @classmethod
     def     SCREAMING_SNAKE_CASE__  (							cls						:   List[str]	)					->		Optional[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						NllbTokenizer.from_pretrained(
               cls.checkpoint_name						,src_lang="""eng_Latn"""						,tgt_lang="""ron_Latn"""	)
           SCREAMING_SNAKE_CASE		=						1
           return cls






     def     SCREAMING_SNAKE_CASE__  (							self						:   List[Any]	)					->		Optional[Any]:




           '''simple docstring'''


           self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""ace_Arab"""]						,256001	)
           self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""ace_Latn"""]						,256002	)
           self.assertEqual(self.tokenizer.fairseq_tokens_to_ids["""fra_Latn"""]						,256057	)






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




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.tokenizer.batch_encode_plus(self.src_text	).input_ids[0]
           self.assertListEqual(self.expected_src_tokens						,lowerCamelCase__	)






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




           '''simple docstring'''


           self.assertIn(lowerCamelCase__						,self.tokenizer.all_special_ids	)
           # fmt: off
           SCREAMING_SNAKE_CASE		=						[RO_CODE, 4254, 98068, 112923, 39072, 3909, 713, 102767, 26, 17314, 35642, 14683, 33118, 2022, 66987, 2, 256047]
           # fmt: on

           SCREAMING_SNAKE_CASE		=						self.tokenizer.decode(lowerCamelCase__						,skip_special_tokens=lowerCamelCase__	)
           SCREAMING_SNAKE_CASE		=						self.tokenizer.decode(generated_ids[1:]						,skip_special_tokens=lowerCamelCase__	)
           self.assertEqual(lowerCamelCase__						,lowerCamelCase__	)
           self.assertNotIn(self.tokenizer.eos_token						,lowerCamelCase__	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   str	)					->		str:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						["""this is gunna be a long sentence """ * 20]
           assert isinstance(src_text[0]						,lowerCamelCase__	)
           SCREAMING_SNAKE_CASE		=						10
           SCREAMING_SNAKE_CASE		=						self.tokenizer(lowerCamelCase__						,max_length=lowerCamelCase__						,truncation=lowerCamelCase__	).input_ids[0]
           self.assertEqual(ids[-1]						,2	)
           self.assertEqual(ids[0]						,lowerCamelCase__	)
           self.assertEqual(len(lowerCamelCase__	)						,lowerCamelCase__	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   Any	)					->		Dict:




           '''simple docstring'''


           self.assertListEqual(self.tokenizer.convert_tokens_to_ids(["""<mask>""", """ar_AR"""]	)						,[256203, 3]	)






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




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						tempfile.mkdtemp()
           SCREAMING_SNAKE_CASE		=						self.tokenizer.fairseq_tokens_to_ids
           self.tokenizer.save_pretrained(lowerCamelCase__	)
           SCREAMING_SNAKE_CASE		=						NllbTokenizer.from_pretrained(lowerCamelCase__	)
           self.assertDictEqual(new_tok.fairseq_tokens_to_ids						,lowerCamelCase__	)






     @require_torch
     def     SCREAMING_SNAKE_CASE__  (							self						:   Dict	)					->		Dict:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.tokenizer(
               self.src_text						,text_target=self.tgt_text						,padding=lowerCamelCase__						,truncation=lowerCamelCase__						,max_length=len(self.expected_src_tokens	)						,return_tensors="""pt"""						,)
           SCREAMING_SNAKE_CASE		=						shift_tokens_right(
               batch["""labels"""]						,self.tokenizer.pad_token_id						,self.tokenizer.lang_code_to_id["""ron_Latn"""]	)

           self.assertIsInstance(lowerCamelCase__						,lowerCamelCase__	)

           self.assertEqual((2, 15)						,batch.input_ids.shape	)
           self.assertEqual((2, 15)						,batch.attention_mask.shape	)
           SCREAMING_SNAKE_CASE		=						batch.input_ids.tolist()[0]
           self.assertListEqual(self.expected_src_tokens						,lowerCamelCase__	)
           self.assertEqual(lowerCamelCase__						,batch.decoder_input_ids[0, 0]	)  # EOS
           # Test that special tokens are reset
           self.assertEqual(self.tokenizer.prefix_tokens						,[EN_CODE]	)
           self.assertEqual(self.tokenizer.suffix_tokens						,[self.tokenizer.eos_token_id]	)






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




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.tokenizer(self.src_text						,padding=lowerCamelCase__						,truncation=lowerCamelCase__						,max_length=3						,return_tensors="""pt"""	)
           SCREAMING_SNAKE_CASE		=						self.tokenizer(
               text_target=self.tgt_text						,padding=lowerCamelCase__						,truncation=lowerCamelCase__						,max_length=10						,return_tensors="""pt"""	)
           SCREAMING_SNAKE_CASE		=						targets["""input_ids"""]
           SCREAMING_SNAKE_CASE		=						shift_tokens_right(
               lowerCamelCase__						,self.tokenizer.pad_token_id						,decoder_start_token_id=self.tokenizer.lang_code_to_id[self.tokenizer.tgt_lang]						,)

           self.assertEqual(batch.input_ids.shape[1]						,3	)
           self.assertEqual(batch.decoder_input_ids.shape[1]						,10	)






     @require_torch
     def     SCREAMING_SNAKE_CASE__  (							self						:   Optional[Any]	)					->		Tuple:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.tokenizer._build_translation_inputs(
               """A test"""						,return_tensors="""pt"""						,src_lang="""eng_Latn"""						,tgt_lang="""fra_Latn"""	)

           self.assertEqual(
               nested_simplify(lowerCamelCase__	)						,{
                   # A, test, EOS, en_XX
                   """input_ids""": [[256047, 70, 7356, 2]],
                   """attention_mask""": [[1, 1, 1, 1]],
                   # ar_AR
                   """forced_bos_token_id""": 256057,
               }						,)






     @require_torch
     def     SCREAMING_SNAKE_CASE__  (							self						:   int	)					->		Any:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						True
           SCREAMING_SNAKE_CASE		=						self.tokenizer(
               """UN Chief says there is no military solution in Syria"""						,src_lang="""eng_Latn"""						,tgt_lang="""fra_Latn"""	)
           self.assertEqual(
               inputs.input_ids						,[16297, 134408, 25653, 6370, 248, 254, 103929, 94995, 108, 49486, 2, 256047]	)

           SCREAMING_SNAKE_CASE		=						False
           SCREAMING_SNAKE_CASE		=						self.tokenizer(
               """UN Chief says there is no military solution in Syria"""						,src_lang="""eng_Latn"""						,tgt_lang="""fra_Latn"""	)
           self.assertEqual(
               inputs.input_ids						,[256047, 16297, 134408, 25653, 6370, 248, 254, 103929, 94995, 108, 49486, 2]	)









import unittest

import numpy as np

from transformers.file_utils import is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_vision

from ...test_image_processing_common import ImageProcessingSavingTestMixin, prepare_image_inputs


if is_torch_available():
      import torch

if is_vision_available():
      from PIL import Image

      from transformers import DPTImageProcessor

class 		UpperCamelCase__			(				unittest.TestCase       ):



     '''simple docstring'''

     def __init__(							self						:   Optional[Any]						,lowerCamelCase__						:   List[str]						,lowerCamelCase__						:   Optional[Any]=7						,lowerCamelCase__						:   Optional[Any]=3						,lowerCamelCase__						:   Union[str, Any]=18						,lowerCamelCase__						:   Optional[int]=30						,lowerCamelCase__						:   int=400						,lowerCamelCase__						:   List[str]=True						,lowerCamelCase__						:   Union[str, Any]=None						,lowerCamelCase__						:   Union[str, Any]=True						,lowerCamelCase__						:   Optional[int]=[0.5, 0.5, 0.5]						,lowerCamelCase__						:   Any=[0.5, 0.5, 0.5]						,)					->		List[str]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						size if size is not None else {"""height""": 18, """width""": 18}
           SCREAMING_SNAKE_CASE		=						parent
           SCREAMING_SNAKE_CASE		=						batch_size
           SCREAMING_SNAKE_CASE		=						num_channels
           SCREAMING_SNAKE_CASE		=						image_size
           SCREAMING_SNAKE_CASE		=						min_resolution
           SCREAMING_SNAKE_CASE		=						max_resolution
           SCREAMING_SNAKE_CASE		=						do_resize
           SCREAMING_SNAKE_CASE		=						size
           SCREAMING_SNAKE_CASE		=						do_normalize
           SCREAMING_SNAKE_CASE		=						image_mean
           SCREAMING_SNAKE_CASE		=						image_std






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




           '''simple docstring'''


           return {
               "image_mean": self.image_mean,
               "image_std": self.image_std,
               "do_normalize": self.do_normalize,
               "do_resize": self.do_resize,
               "size": self.size,
           }

@require_torch
@require_vision
class 		UpperCamelCase__			(				lowerCAmelCase_							,				unittest.TestCase       ):



     '''simple docstring'''

     __snake_case   :     Tuple		     =      DPTImageProcessor if is_vision_available() else None






     def     SCREAMING_SNAKE_CASE__  (							self						:   Union[str, Any]	)					->		Optional[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						DPTImageProcessingTester(self	)






     @property
     def     SCREAMING_SNAKE_CASE__  (							self						:   Union[str, Any]	)					->		int:




           '''simple docstring'''


           return self.image_processor_tester.prepare_image_processor_dict()






     def     SCREAMING_SNAKE_CASE__  (							self						:   Dict	)					->		List[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.image_processing_class(**self.image_processor_dict	)
           self.assertTrue(hasattr(lowerCamelCase__						,"""image_mean"""	)	)
           self.assertTrue(hasattr(lowerCamelCase__						,"""image_std"""	)	)
           self.assertTrue(hasattr(lowerCamelCase__						,"""do_normalize"""	)	)
           self.assertTrue(hasattr(lowerCamelCase__						,"""do_resize"""	)	)
           self.assertTrue(hasattr(lowerCamelCase__						,"""size"""	)	)






     def     SCREAMING_SNAKE_CASE__  (							self						:   int	)					->		List[Any]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.image_processing_class.from_dict(self.image_processor_dict	)
           self.assertEqual(image_processor.size						,{"""height""": 18, """width""": 18}	)

           SCREAMING_SNAKE_CASE		=						self.image_processing_class.from_dict(self.image_processor_dict						,size=42	)
           self.assertEqual(image_processor.size						,{"""height""": 42, """width""": 42}	)






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




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.image_processing_class(**self.image_processor_dict	)
           # create random PIL images
           SCREAMING_SNAKE_CASE		=						prepare_image_inputs(self.image_processor_tester						,equal_resolution=lowerCamelCase__	)
           for image in image_inputs:
                 self.assertIsInstance(lowerCamelCase__						,Image.Image	)

           # Test not batched input
           SCREAMING_SNAKE_CASE		=						image_processing(image_inputs[0]						,return_tensors="""pt"""	).pixel_values
           self.assertEqual(
               encoded_images.shape						,(
                   1,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size["""height"""],
                   self.image_processor_tester.size["""width"""],
               )						,)

           # Test batched
           SCREAMING_SNAKE_CASE		=						image_processing(lowerCamelCase__						,return_tensors="""pt"""	).pixel_values
           self.assertEqual(
               encoded_images.shape						,(
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size["""height"""],
                   self.image_processor_tester.size["""width"""],
               )						,)






     def     SCREAMING_SNAKE_CASE__  (							self						:   List[Any]	)					->		int:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.image_processing_class(**self.image_processor_dict	)
           # create random numpy tensors
           SCREAMING_SNAKE_CASE		=						prepare_image_inputs(self.image_processor_tester						,equal_resolution=lowerCamelCase__						,numpify=lowerCamelCase__	)
           for image in image_inputs:
                 self.assertIsInstance(lowerCamelCase__						,np.ndarray	)

           # Test not batched input
           SCREAMING_SNAKE_CASE		=						image_processing(image_inputs[0]						,return_tensors="""pt"""	).pixel_values
           self.assertEqual(
               encoded_images.shape						,(
                   1,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size["""height"""],
                   self.image_processor_tester.size["""width"""],
               )						,)

           # Test batched
           SCREAMING_SNAKE_CASE		=						image_processing(lowerCamelCase__						,return_tensors="""pt"""	).pixel_values
           self.assertEqual(
               encoded_images.shape						,(
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size["""height"""],
                   self.image_processor_tester.size["""width"""],
               )						,)






     def     SCREAMING_SNAKE_CASE__  (							self						:   Tuple	)					->		Optional[int]:




           '''simple docstring'''


           SCREAMING_SNAKE_CASE		=						self.image_processing_class(**self.image_processor_dict	)
           # create random PyTorch tensors
           SCREAMING_SNAKE_CASE		=						prepare_image_inputs(self.image_processor_tester						,equal_resolution=lowerCamelCase__						,torchify=lowerCamelCase__	)
           for image in image_inputs:
                 self.assertIsInstance(lowerCamelCase__						,torch.Tensor	)

           # Test not batched input
           SCREAMING_SNAKE_CASE		=						image_processing(image_inputs[0]						,return_tensors="""pt"""	).pixel_values
           self.assertEqual(
               encoded_images.shape						,(
                   1,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size["""height"""],
                   self.image_processor_tester.size["""width"""],
               )						,)

           # Test batched
           SCREAMING_SNAKE_CASE		=						image_processing(lowerCamelCase__						,return_tensors="""pt"""	).pixel_values
           self.assertEqual(
               encoded_images.shape						,(
                   self.image_processor_tester.batch_size,
                   self.image_processor_tester.num_channels,
                   self.image_processor_tester.size["""height"""],
                   self.image_processor_tester.size["""width"""],
               )						,)


