from __future__ import annotations

import os
import tempfile
import unittest

import numpy as np
from huggingface_hub import hf_hub_download

from transformers import is_tensorflow_text_available, is_tf_available
from transformers.testing_utils import require_tensorflow_text, require_tf, slow

from ..test_modeling_tf_common import floats_tensor
from .test_framework_agnostic import GenerationIntegrationTestsMixin


if is_tf_available():
    import tensorflow as tf

    from transformers import (
        AutoTokenizer,
        TFAutoModelForCausalLM,
        TFAutoModelForSeqaSeqLM,
        TFAutoModelForSpeechSeqaSeq,
        TFAutoModelForVisionaSeq,
        TFBartForConditionalGeneration,
        TFLogitsProcessorList,
        TFMinLengthLogitsProcessor,
        tf_top_k_top_p_filtering,
    )

if is_tensorflow_text_available():
    import tensorflow_text as text



@require_tf
class  SCREAMING_SNAKE_CASE_ (					unittest.TestCase			):
  '''simple docstring'''


  def 		SCREAMING_SNAKE_CASE_		(				self    :					Any     )    ->				List[str]:
         A						:     List[str]         =tf.convert_to_tensor(
             [
                 [
                     8.2_2_2_0_9_9_1,  # 3rd highest value; idx. 0
                     -0.5_6_2_0_0_4_4,
                     5.2_3_2_2_9_7_5_2,
                     4.0_3_8_6_3_9_3,
                     -6.8_7_9_8_3_7_8,
                     -0.5_4_7_8_5_8_0_2,
                     -3.2_0_1_2_1_5_3,
                     2.9_2_7_7_7_1_7_6,
                     1.8_8_1_7_1_9_5_3,
                     7.3_5_3_4_1_2_7_6,  # 5th highest value; idx. 9
                     8.4_3_2_0_7_8_3_3,  # 2nd highest value; idx. 10
                     -9.8_5_7_1_1_8_3_6,
                     -5.9_6_2_0_9_2_3_6,
                     -1.1_3_0_3_9_1_6_1,
                     -7.1_1_1_5_2_9_4,
                     -0.8_3_6_9_6_3_3,
                     -5.3_1_8_6_4_0_8,
                     7.0_6_4_2_7_4_0_7,
                     0.8_1_3_6_9_3_4_4,
                     -0.8_2_0_2_3_8_1_7,
                     -5.9_1_7_9_7_9_6,
                     0.5_8_8_1_3_4_4_3,
                     -6.9_9_7_7_8_4_3_8,
                     4.7_1_5_5_1_1_8_9,
                     -0.1_8_7_7_1_6_3_7,
                     7.4_4_0_2_0_7_5_9,  # 4th highest value; idx. 25
                     9.3_8_4_5_0_9_8_7,  # 1st highest value; idx. 26
                     2.1_2_6_6_2_9_4_1,
                     -9.3_2_5_6_2_0_3_8,
                     2.3_5_6_5_2_5_2_2,
                 ],  # cummulative prob of 5 highest values <= 0.6
                 [
                     0.5_8_4_2_5_5_1_8,
                     4.5_3_1_3_9_2_3_8,
                     -5.5_7_5_1_0_4_6_4,
                     -6.2_8_0_3_0_6_9_9,
                     -7.1_9_5_2_9_5_0_3,
                     -4.0_2_1_2_2_5_5_1,
                     1.3_9_3_3_7_0_3_7,
                     -6.0_6_7_0_7_0_5_7,
                     1.5_9_4_8_0_5_1_7,
                     -9.6_4_3_1_1_9,
                     0.0_3_9_0_7_7_9_9,
                     0.6_7_2_3_1_7_6_2,
                     -8.8_8_2_0_6_7_2_6,
                     6.2_7_1_1_5_9_2_2,  # 4th highest value; idx. 13
                     2.2_8_5_2_0_7_2_3,
                     4.8_2_7_6_7_5_0_6,
                     4.3_0_4_2_1_3_6_8,
                     8.8_2_7_5_3_1_3,  # 2nd highest value; idx. 17
                     5.4_4_0_2_9_9_5_8,  # 5th highest value; idx. 18
                     -4.4_7_3_5_7_9_4,
                     7.3_8_5_7_9_5_3_6,  # 3rd highest value; idx. 20
                     -2.9_1_0_5_1_6_6_3,
                     2.6_1_9_4_6_0_7_7,
                     -2.5_6_7_4_7_6_2,
                     -9.4_8_9_5_9_3_0_2,
                     -4.0_2_9_2_2_6_4_5,
                     -1.3_5_4_1_6_9_1_8,
                     9.6_7_7_0_2_3_2_3,  # 1st highest value; idx. 27
                     -5.8_9_4_7_8_5_5_3,
                     1.8_5_3_7_0_4_6_7,
                 ],  # cummulative prob of 5 highest values <= 0.6
             ]      ,	dtype=tf.floataa      ,	)

         A						:     List[str]         =tf.convert_to_tensor(
             [[0, 0], [0, 9], [0, 10], [0, 25], [0, 26], [1, 13], [1, 17], [1, 18], [1, 20], [1, 27]]      ,	dtype=tf.intaa      ,	)  # expected non filtered idx as noted above

         A						:     str         =tf.convert_to_tensor(
             [8.2_2_2_0_9_9, 7.3_5_3_4_1_2_6, 8.4_3_2_0_7_8, 7.4_4_0_2_0_7_5, 9.3_8_4_5_1, 6.2_7_1_1_5_9, 8.8_2_7_5_3_1, 5.4_4_0_2_9_9_5, 7.3_8_5_7_9_5_6, 9.6_7_7_0_2_3]      ,	dtype=tf.floataa      ,	)  # expected non filtered values as noted above

         A						:     List[Any]         =tf_top_k_top_p_filtering(SCREAMING_SNAKE_CASE__      ,	top_k=10      ,	top_p=0.6      ,	min_tokens_to_keep=4     )

         A						:     Dict         =output[output != -float('inf'     )]
         A						:     Dict         =tf.cast(
             tf.where(tf.not_equal(SCREAMING_SNAKE_CASE__      ,	tf.constant(-float('inf'     )      ,	dtype=tf.floataa     )     )     )      ,	dtype=tf.intaa      ,	)

         tf.debugging.assert_near(SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	rtol=1e-12     )
         tf.debugging.assert_equal(SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__     )







@require_tf
class  SCREAMING_SNAKE_CASE_ (					unittest.TestCase   ,						lowerCAmelCase_			):
  '''simple docstring'''


  if is_tf_available():
    lowercase		:     Any            =				{
        "AutoModelForCausalLM": TFAutoModelForCausalLM,
        "AutoModelForSpeechSeq2Seq": TFAutoModelForSpeechSeqaSeq,
        "AutoModelForSeq2SeqLM": TFAutoModelForSeqaSeqLM,
        "AutoModelForVision2Seq": TFAutoModelForVisionaSeq,
        "LogitsProcessorList": TFLogitsProcessorList,
        "MinLengthLogitsProcessor": TFMinLengthLogitsProcessor,
        "create_tensor_fn": tf.convert_to_tensor,
        "floats_tensor": floats_tensor,
        "return_tensors": "tf",
    }







  @slow
  def 		SCREAMING_SNAKE_CASE_		(				self    :					Tuple     )    ->				List[Any]:
         # TF-only test: tf.saved_model export
         A						:     List[Any]         =TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2'     )
         A						:     Optional[Any]         =2
         A						:     Union[str, Any]         =2



         class  SCREAMING_SNAKE_CASE_ (					tf.Module			):
           '''simple docstring'''


           def __init__(				self    :					Dict      ,	SCREAMING_SNAKE_CASE__    :					Optional[int]     )    ->				int:
                  super(SCREAMING_SNAKE_CASE__      ,	self     ).__init__()
                  A						:     str         =model







           @tf.function(
               input_signature=(
                   tf.TensorSpec((None, input_length)      ,	tf.intaa      ,	name='input_ids'     ),
                   tf.TensorSpec((None, input_length)      ,	tf.intaa      ,	name='attention_mask'     ),
               )      ,	jit_compile=SCREAMING_SNAKE_CASE__      ,	)
           def 		SCREAMING_SNAKE_CASE_		(				self    :					List[Any]      ,	SCREAMING_SNAKE_CASE__    :					List[Any]      ,	SCREAMING_SNAKE_CASE__    :					Optional[int]     )    ->				int:
                  A						:     str         =self.model.generate(
                      input_ids=SCREAMING_SNAKE_CASE__      ,	attention_mask=SCREAMING_SNAKE_CASE__      ,	max_new_tokens=SCREAMING_SNAKE_CASE__      ,	return_dict_in_generate=SCREAMING_SNAKE_CASE__      ,	)
                  return {"sequences": outputs["sequences"]}







         A						:     List[Any]         =[[2, 0], [1_02, 1_03]]
         A						:     Dict         =[[1, 0], [1, 1]]
         A						:     Optional[Any]         =DummyModel(model=SCREAMING_SNAKE_CASE__     )
         with tempfile.TemporaryDirectory() as tmp_dir:
                tf.saved_model.save(SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	signatures={'serving_default': dummy_model.serving}     )
                A						:     Union[str, Any]         =tf.saved_model.load(SCREAMING_SNAKE_CASE__     ).signatures['serving_default']
                for batch_size in range(1      ,	len(SCREAMING_SNAKE_CASE__     ) + 1     ):
                       A						:     List[str]         ={
                           'input_ids': tf.constant(dummy_input_ids[:batch_size]     ),
                           'attention_mask': tf.constant(dummy_attention_masks[:batch_size]     ),
                       }
                       A						:     List[Any]         =serving_func(**SCREAMING_SNAKE_CASE__     )['sequences']
                       A						:     Dict         =test_model.generate(**SCREAMING_SNAKE_CASE__      ,	max_new_tokens=SCREAMING_SNAKE_CASE__     )
                       tf.debugging.assert_equal(SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__     )







  @slow
  def 		SCREAMING_SNAKE_CASE_		(				self    :					Optional[Any]     )    ->				Optional[Any]:
         # TF-only test: tf.saved_model export
         A						:     List[str]         =TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2'     )
         A						:     Dict         =1
         A						:     str         =2



         class  SCREAMING_SNAKE_CASE_ (					tf.Module			):
           '''simple docstring'''


           def __init__(				self    :					Union[str, Any]      ,	SCREAMING_SNAKE_CASE__    :					Dict     )    ->				Union[str, Any]:
                  super(SCREAMING_SNAKE_CASE__      ,	self     ).__init__()
                  A						:     Tuple         =model







           @tf.function(
               input_signature=(
                   tf.TensorSpec((batch_size, None)      ,	tf.intaa      ,	name='input_ids'     ),
                   tf.TensorSpec((batch_size, None)      ,	tf.intaa      ,	name='attention_mask'     ),
               )      ,	jit_compile=SCREAMING_SNAKE_CASE__      ,	)
           def 		SCREAMING_SNAKE_CASE_		(				self    :					Any      ,	SCREAMING_SNAKE_CASE__    :					Optional[Any]      ,	SCREAMING_SNAKE_CASE__    :					int     )    ->				List[str]:
                  A						:     str         =self.model.generate(
                      input_ids=SCREAMING_SNAKE_CASE__      ,	attention_mask=SCREAMING_SNAKE_CASE__      ,	max_new_tokens=SCREAMING_SNAKE_CASE__      ,	return_dict_in_generate=SCREAMING_SNAKE_CASE__      ,	)
                  return {"sequences": outputs["sequences"]}







         A						:     int         =[[2], [1_02, 1_03]]
         A						:     Optional[int]         =[[1], [1, 1]]
         A						:     List[str]         =DummyModel(model=SCREAMING_SNAKE_CASE__     )
         with tempfile.TemporaryDirectory() as tmp_dir:
                tf.saved_model.save(SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	signatures={'serving_default': dummy_model.serving}     )
                A						:     List[Any]         =tf.saved_model.load(SCREAMING_SNAKE_CASE__     ).signatures['serving_default']
                for input_row in range(len(SCREAMING_SNAKE_CASE__     )     ):
                       A						:     str         ={
                           'input_ids': tf.constant([dummy_input_ids[input_row]]     ),
                           'attention_mask': tf.constant([dummy_attention_masks[input_row]]     ),
                       }
                       A						:     List[str]         =serving_func(**SCREAMING_SNAKE_CASE__     )['sequences']
                       A						:     Tuple         =test_model.generate(**SCREAMING_SNAKE_CASE__      ,	max_new_tokens=SCREAMING_SNAKE_CASE__     )
                       tf.debugging.assert_equal(SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__     )







  @slow
  @require_tensorflow_text
  def 		SCREAMING_SNAKE_CASE_		(				self    :					List[Any]     )    ->				Dict:
         # TF-only test: tf.saved_model export
         with tempfile.TemporaryDirectory() as tmp_dir:
                # file needed to load the TF tokenizer
                hf_hub_download(repo_id='google/flan-t5-small'      ,	filename='spiece.model'      ,	local_dir=SCREAMING_SNAKE_CASE__     )



                class  SCREAMING_SNAKE_CASE_ (					tf.keras.layers.Layer			):
                  '''simple docstring'''


                  def __init__(				self    :					List[str]     )    ->				int:
                         super().__init__()
                         A						:     Union[str, Any]         =text.SentencepieceTokenizer(
                             model=tf.io.gfile.GFile(os.path.join(SCREAMING_SNAKE_CASE__      ,	'spiece.model'     )      ,	'rb'     ).read()     )
                         A						:     str         =TFAutoModelForSeqaSeqLM.from_pretrained('hf-internal-testing/tiny-random-t5'     )







                  def 		SCREAMING_SNAKE_CASE_		(				self    :					Any      ,	SCREAMING_SNAKE_CASE__    :					str      ,	*SCREAMING_SNAKE_CASE__    :					List[str]      ,	**SCREAMING_SNAKE_CASE__    :					str     )    ->				Optional[Any]:
                         A						:     str         =self.tokenizer.tokenize(SCREAMING_SNAKE_CASE__     )
                         A  ,  A						:     int         =text.pad_model_inputs(
                             SCREAMING_SNAKE_CASE__      ,	max_seq_length=64      ,	pad_value=self.model.config.pad_token_id     )
                         A						:     Any         =self.model.generate(input_ids=SCREAMING_SNAKE_CASE__      ,	attention_mask=SCREAMING_SNAKE_CASE__     )
                         return self.tokenizer.detokenize(SCREAMING_SNAKE_CASE__     )







                A						:     List[str]         =CompleteSentenceTransformer()
                A						:     Tuple         =tf.keras.layers.Input(shape=(1,)      ,	dtype=tf.string      ,	name='inputs'     )
                A						:     Optional[Any]         =complete_model(SCREAMING_SNAKE_CASE__     )
                A						:     List[str]         =tf.keras.Model(SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__     )
                keras_model.save(SCREAMING_SNAKE_CASE__     )







  def 		SCREAMING_SNAKE_CASE_		(				self    :					str     )    ->				Dict:
         # Has PT equivalent: this test relies on random sampling
         A						:     Optional[int]         ={
             'do_sample': True,
             'num_beams': 1,
             'top_p': 0.7,
             'top_k': 10,
             'temperature': 0.7,
         }
         A						:     Tuple         =14

         A						:     List[str]         =AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-gpt2'     )
         A						:     List[Any]         ='Hello, my dog is cute and'
         A						:     str         =tokenizer(SCREAMING_SNAKE_CASE__      ,	return_tensors='tf'     )
         A						:     str         =TFAutoModelForCausalLM.from_pretrained('hf-internal-testing/tiny-random-gpt2'     )

         A						:     List[Any]         =6_38
         # forces the generation to happen on CPU, to avoid GPU-related quirks
         with tf.device(':/CPU:0'     ):
                tf.random.set_seed(0     )
                A						:     Dict         =model.generate(**SCREAMING_SNAKE_CASE__      ,	eos_token_id=SCREAMING_SNAKE_CASE__      ,	**SCREAMING_SNAKE_CASE__     )
         self.assertTrue(expectation == len(generated_tokens[0]     )     )

         A						:     Union[str, Any]         =[6_38, 1_98]
         with tf.device(':/CPU:0'     ):
                tf.random.set_seed(0     )
                A						:     Dict         =model.generate(**SCREAMING_SNAKE_CASE__      ,	eos_token_id=SCREAMING_SNAKE_CASE__      ,	**SCREAMING_SNAKE_CASE__     )
         self.assertTrue(expectation == len(generated_tokens[0]     )     )







  def 		SCREAMING_SNAKE_CASE_		(				self    :					Any     )    ->				str:
         # Has PT equivalent: ample use of framework-specific code
         A						:     Optional[int]         =AutoTokenizer.from_pretrained('hf-internal-testing/tiny-random-bart'     )
         A						:     Dict         ='Hugging Face is a technology company based in New York and Paris.'
         A						:     Any         =bart_tokenizer(SCREAMING_SNAKE_CASE__      ,	return_tensors='tf'     ).input_ids
         A						:     Any         =TFBartForConditionalGeneration.from_pretrained('hf-internal-testing/tiny-random-bart'     )
         A						:     Dict         =bart_model.generate(SCREAMING_SNAKE_CASE__     ).numpy()



         class  SCREAMING_SNAKE_CASE_ (					lowerCAmelCase_			):
           '''simple docstring'''


           def 		SCREAMING_SNAKE_CASE_		(				self    :					Tuple      ,	SCREAMING_SNAKE_CASE__    :					List[str]      ,	SCREAMING_SNAKE_CASE__    :					int=None      ,	**SCREAMING_SNAKE_CASE__    :					Any     )    ->				List[Any]:
                  return super().call(SCREAMING_SNAKE_CASE__      ,	**SCREAMING_SNAKE_CASE__     )







         A						:     Optional[Any]         =FakeBart.from_pretrained('hf-internal-testing/tiny-random-bart'     )
         A						:     List[Any]         =bart_model.generate(SCREAMING_SNAKE_CASE__      ,	foo='bar'     ).numpy()
         self.assertTrue(np.array_equal(SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__     )     )



         class  SCREAMING_SNAKE_CASE_ (					bart_model.model.encoder.__class__			):
           '''simple docstring'''


           def 		SCREAMING_SNAKE_CASE_		(				self    :					Any      ,	SCREAMING_SNAKE_CASE__    :					Tuple      ,	**SCREAMING_SNAKE_CASE__    :					Tuple     )    ->				Optional[int]:
                  return super().call(SCREAMING_SNAKE_CASE__      ,	**SCREAMING_SNAKE_CASE__     )







         A						:     Any         =FakeEncoder(bart_model.config      ,	bart_model.model.shared     )
         A						:     Tuple         =fake_encoder

         # Normal generation still works (the output will be different because the encoder weights are different)
         A						:     Tuple         =bart_model.generate(SCREAMING_SNAKE_CASE__     ).numpy()
         with self.assertRaises(SCREAMING_SNAKE_CASE__     ):
                # FakeEncoder.call() accepts **kwargs -> no filtering -> value error due to unexpected input "foo"
                bart_model.generate(SCREAMING_SNAKE_CASE__      ,	foo='bar'     )







import shutil
import tempfile
import unittest

import numpy as np

from transformers.testing_utils import (
    is_pt_tf_cross_test,
    require_tf,
    require_torch,
    require_torchvision,
    require_vision,
)
from transformers.utils import is_tf_available, is_torch_available, is_vision_available


if is_vision_available():
    from PIL import Image

    from transformers import AutoProcessor, SamImageProcessor, SamProcessor

if is_torch_available():
    import torch

if is_tf_available():
    import tensorflow as tf



@require_vision
@require_torchvision
class  SCREAMING_SNAKE_CASE_ (					unittest.TestCase			):
  '''simple docstring'''


  def 		SCREAMING_SNAKE_CASE_		(				self    :					List[str]     )    ->				Union[str, Any]:
         A						:     Dict         =tempfile.mkdtemp()
         A						:     int         =SamImageProcessor()
         A						:     Union[str, Any]         =SamProcessor(SCREAMING_SNAKE_CASE__     )
         processor.save_pretrained(self.tmpdirname     )







  def 		SCREAMING_SNAKE_CASE_		(				self    :					Optional[int]      ,	**SCREAMING_SNAKE_CASE__    :					Optional[Any]     )    ->				Optional[int]:
         return AutoProcessor.from_pretrained(self.tmpdirname      ,	**SCREAMING_SNAKE_CASE__     ).image_processor







  def 		SCREAMING_SNAKE_CASE_		(				self    :					List[str]     )    ->				Any:
         shutil.rmtree(self.tmpdirname     )







  def 		SCREAMING_SNAKE_CASE_		(				self    :					List[str]     )    ->				Optional[int]:
         A						:     str         =[np.random.randint(2_55      ,	size=(3, 30, 4_00)      ,	dtype=np.uinta     )]

         A						:     Optional[int]         =[Image.fromarray(np.moveaxis(SCREAMING_SNAKE_CASE__      ,	0      ,	-1     )     ) for x in image_inputs]

         return image_inputs







  def 		SCREAMING_SNAKE_CASE_		(				self    :					str     )    ->				Tuple:
         A						:     Optional[int]         =SamProcessor(image_processor=self.get_image_processor()     )
         processor.save_pretrained(self.tmpdirname     )

         A						:     str         =self.get_image_processor(do_normalize=SCREAMING_SNAKE_CASE__      ,	padding_value=1.0     )

         A						:     Union[str, Any]         =SamProcessor.from_pretrained(self.tmpdirname      ,	do_normalize=SCREAMING_SNAKE_CASE__      ,	padding_value=1.0     )

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







  def 		SCREAMING_SNAKE_CASE_		(				self    :					Tuple     )    ->				Optional[int]:
         A						:     Optional[Any]         =self.get_image_processor()

         A						:     Optional[Any]         =SamProcessor(image_processor=SCREAMING_SNAKE_CASE__     )

         A						:     Dict         =self.prepare_image_inputs()

         A						:     Optional[int]         =image_processor(SCREAMING_SNAKE_CASE__      ,	return_tensors='np'     )
         A						:     Optional[Any]         =processor(images=SCREAMING_SNAKE_CASE__      ,	return_tensors='np'     )

         input_feat_extract.pop('original_sizes'     )  # pop original_sizes as it is popped in the processor
         input_feat_extract.pop('reshaped_input_sizes'     )  # pop original_sizes as it is popped in the processor

         for key in input_feat_extract.keys():
                self.assertAlmostEqual(input_feat_extract[key].sum()      ,	input_processor[key].sum()      ,	delta=1e-2     )







  @require_torch
  def 		SCREAMING_SNAKE_CASE_		(				self    :					int     )    ->				Any:
         A						:     str         =self.get_image_processor()

         A						:     Union[str, Any]         =SamProcessor(image_processor=SCREAMING_SNAKE_CASE__     )
         A						:     str         =[torch.ones((1, 3, 5, 5)     )]

         A						:     Optional[Any]         =[[17_64, 26_46]]

         A						:     List[Any]         =[[6_83, 10_24]]
         A						:     Union[str, Any]         =processor.post_process_masks(SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__     )
         self.assertEqual(masks[0].shape      ,	(1, 3, 17_64, 26_46)     )

         A						:     Any         =processor.post_process_masks(
             SCREAMING_SNAKE_CASE__      ,	torch.tensor(SCREAMING_SNAKE_CASE__     )      ,	torch.tensor(SCREAMING_SNAKE_CASE__     )     )
         self.assertEqual(masks[0].shape      ,	(1, 3, 17_64, 26_46)     )

         # should also work with np
         A						:     str         =[np.ones((1, 3, 5, 5)     )]
         A						:     int         =processor.post_process_masks(SCREAMING_SNAKE_CASE__      ,	np.array(SCREAMING_SNAKE_CASE__     )      ,	np.array(SCREAMING_SNAKE_CASE__     )     )

         self.assertEqual(masks[0].shape      ,	(1, 3, 17_64, 26_46)     )

         A						:     Any         =[[1, 0], [0, 1]]
         with self.assertRaises(SCREAMING_SNAKE_CASE__     ):
                A						:     Any         =processor.post_process_masks(SCREAMING_SNAKE_CASE__      ,	np.array(SCREAMING_SNAKE_CASE__     )      ,	np.array(SCREAMING_SNAKE_CASE__     )     )







@require_vision
@require_tf
class  SCREAMING_SNAKE_CASE_ (					unittest.TestCase			):
  '''simple docstring'''


  def 		SCREAMING_SNAKE_CASE_		(				self    :					str     )    ->				str:
         A						:     Tuple         =tempfile.mkdtemp()
         A						:     Union[str, Any]         =SamImageProcessor()
         A						:     Union[str, Any]         =SamProcessor(SCREAMING_SNAKE_CASE__     )
         processor.save_pretrained(self.tmpdirname     )







  def 		SCREAMING_SNAKE_CASE_		(				self    :					int      ,	**SCREAMING_SNAKE_CASE__    :					str     )    ->				Union[str, Any]:
         return AutoProcessor.from_pretrained(self.tmpdirname      ,	**SCREAMING_SNAKE_CASE__     ).image_processor







  def 		SCREAMING_SNAKE_CASE_		(				self    :					str     )    ->				List[str]:
         shutil.rmtree(self.tmpdirname     )







  def 		SCREAMING_SNAKE_CASE_		(				self    :					List[str]     )    ->				Tuple:
         A						:     Optional[Any]         =[np.random.randint(2_55      ,	size=(3, 30, 4_00)      ,	dtype=np.uinta     )]

         A						:     Any         =[Image.fromarray(np.moveaxis(SCREAMING_SNAKE_CASE__      ,	0      ,	-1     )     ) for x in image_inputs]

         return image_inputs







  def 		SCREAMING_SNAKE_CASE_		(				self    :					List[Any]     )    ->				List[str]:
         A						:     Optional[Any]         =SamProcessor(image_processor=self.get_image_processor()     )
         processor.save_pretrained(self.tmpdirname     )

         A						:     Optional[Any]         =self.get_image_processor(do_normalize=SCREAMING_SNAKE_CASE__      ,	padding_value=1.0     )

         A						:     Dict         =SamProcessor.from_pretrained(self.tmpdirname      ,	do_normalize=SCREAMING_SNAKE_CASE__      ,	padding_value=1.0     )

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







  def 		SCREAMING_SNAKE_CASE_		(				self    :					Union[str, Any]     )    ->				Any:
         A						:     Any         =self.get_image_processor()

         A						:     Any         =SamProcessor(image_processor=SCREAMING_SNAKE_CASE__     )

         A						:     int         =self.prepare_image_inputs()

         A						:     Tuple         =image_processor(SCREAMING_SNAKE_CASE__      ,	return_tensors='np'     )
         A						:     List[Any]         =processor(images=SCREAMING_SNAKE_CASE__      ,	return_tensors='np'     )

         input_feat_extract.pop('original_sizes'     )  # pop original_sizes as it is popped in the processor
         input_feat_extract.pop('reshaped_input_sizes'     )  # pop reshaped_input_sizes as it is popped in the processor

         for key in input_feat_extract.keys():
                self.assertAlmostEqual(input_feat_extract[key].sum()      ,	input_processor[key].sum()      ,	delta=1e-2     )







  @require_tf
  def 		SCREAMING_SNAKE_CASE_		(				self    :					List[Any]     )    ->				Tuple:
         A						:     int         =self.get_image_processor()

         A						:     Any         =SamProcessor(image_processor=SCREAMING_SNAKE_CASE__     )
         A						:     Optional[int]         =[tf.ones((1, 3, 5, 5)     )]

         A						:     Tuple         =[[17_64, 26_46]]

         A						:     Union[str, Any]         =[[6_83, 10_24]]
         A						:     int         =processor.post_process_masks(SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	return_tensors='tf'     )
         self.assertEqual(masks[0].shape      ,	(1, 3, 17_64, 26_46)     )

         A						:     List[Any]         =processor.post_process_masks(
             SCREAMING_SNAKE_CASE__      ,	tf.convert_to_tensor(SCREAMING_SNAKE_CASE__     )      ,	tf.convert_to_tensor(SCREAMING_SNAKE_CASE__     )      ,	return_tensors='tf'      ,	)
         self.assertEqual(masks[0].shape      ,	(1, 3, 17_64, 26_46)     )

         # should also work with np
         A						:     Any         =[np.ones((1, 3, 5, 5)     )]
         A						:     Optional[Any]         =processor.post_process_masks(
             SCREAMING_SNAKE_CASE__      ,	np.array(SCREAMING_SNAKE_CASE__     )      ,	np.array(SCREAMING_SNAKE_CASE__     )      ,	return_tensors='tf'     )

         self.assertEqual(masks[0].shape      ,	(1, 3, 17_64, 26_46)     )

         A						:     Any         =[[1, 0], [0, 1]]
         with self.assertRaises(tf.errors.InvalidArgumentError     ):
                A						:     List[str]         =processor.post_process_masks(
                    SCREAMING_SNAKE_CASE__      ,	np.array(SCREAMING_SNAKE_CASE__     )      ,	np.array(SCREAMING_SNAKE_CASE__     )      ,	return_tensors='tf'     )







@require_vision
@require_torchvision
class  SCREAMING_SNAKE_CASE_ (					unittest.TestCase			):
  '''simple docstring'''


  def 		SCREAMING_SNAKE_CASE_		(				self    :					Optional[int]     )    ->				Union[str, Any]:
         A						:     Optional[int]         =tempfile.mkdtemp()
         A						:     Union[str, Any]         =SamImageProcessor()
         A						:     Dict         =SamProcessor(SCREAMING_SNAKE_CASE__     )
         processor.save_pretrained(self.tmpdirname     )







  def 		SCREAMING_SNAKE_CASE_		(				self    :					int      ,	**SCREAMING_SNAKE_CASE__    :					List[str]     )    ->				Any:
         return AutoProcessor.from_pretrained(self.tmpdirname      ,	**SCREAMING_SNAKE_CASE__     ).image_processor







  def 		SCREAMING_SNAKE_CASE_		(				self    :					Optional[Any]     )    ->				Any:
         shutil.rmtree(self.tmpdirname     )







  def 		SCREAMING_SNAKE_CASE_		(				self    :					Union[str, Any]     )    ->				Tuple:
         A						:     Any         =[np.random.randint(2_55      ,	size=(3, 30, 4_00)      ,	dtype=np.uinta     )]

         A						:     Tuple         =[Image.fromarray(np.moveaxis(SCREAMING_SNAKE_CASE__      ,	0      ,	-1     )     ) for x in image_inputs]

         return image_inputs







  @is_pt_tf_cross_test
  def 		SCREAMING_SNAKE_CASE_		(				self    :					List[str]     )    ->				List[str]:
         A						:     Optional[Any]         =self.get_image_processor()

         A						:     Dict         =SamProcessor(image_processor=SCREAMING_SNAKE_CASE__     )
         A						:     Optional[int]         =np.random.randint(0      ,	2      ,	size=(1, 3, 5, 5)     ).astype(np.floataa     )
         A						:     Optional[int]         =[tf.convert_to_tensor(SCREAMING_SNAKE_CASE__     )]
         A						:     Union[str, Any]         =[torch.tensor(SCREAMING_SNAKE_CASE__     )]

         A						:     int         =[[17_64, 26_46]]

         A						:     int         =[[6_83, 10_24]]
         A						:     Dict         =processor.post_process_masks(
             SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	return_tensors='tf'     )
         A						:     Optional[Any]         =processor.post_process_masks(
             SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__      ,	return_tensors='pt'     )

         self.assertTrue(np.all(tf_masks[0].numpy() == pt_masks[0].numpy()     )     )







  @is_pt_tf_cross_test
  def 		SCREAMING_SNAKE_CASE_		(				self    :					Optional[int]     )    ->				Any:
         A						:     Union[str, Any]         =self.get_image_processor()

         A						:     int         =SamProcessor(image_processor=SCREAMING_SNAKE_CASE__     )

         A						:     int         =self.prepare_image_inputs()

         A						:     List[Any]         =image_processor(SCREAMING_SNAKE_CASE__      ,	return_tensors='pt'     )['pixel_values'].numpy()
         A						:     Tuple         =processor(images=SCREAMING_SNAKE_CASE__      ,	return_tensors='pt'     )['pixel_values'].numpy()

         A						:     Optional[int]         =image_processor(SCREAMING_SNAKE_CASE__      ,	return_tensors='tf'     )['pixel_values'].numpy()
         A						:     Dict         =processor(images=SCREAMING_SNAKE_CASE__      ,	return_tensors='tf'     )['pixel_values'].numpy()

         self.assertTrue(np.allclose(SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__     )     )
         self.assertTrue(np.allclose(SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__     )     )
         self.assertTrue(np.allclose(SCREAMING_SNAKE_CASE__      ,	SCREAMING_SNAKE_CASE__     )     )






