
import flax.linen as nn
import jax.numpy as jnp

from .attention_flax import FlaxTransformeraDModel
from .resnet_flax import FlaxDownsampleaD, FlaxResnetBlockaD, FlaxUpsampleaD





class 						_a   (						nn.Module       ):

       """simple docstring"""





       snake_case				=4_2
       snake_case				=4_2
       snake_case				=0.0
       snake_case				=1
       snake_case				=1
       snake_case				=True
       snake_case				=False
       snake_case				=False
       snake_case				=False
       snake_case				=jnp.floataa
       def     SCREAMING_SNAKE_CASE  (					self	):
        _UpperCAmelCase 				=[]
        _UpperCAmelCase 				=[]

        for i in range(self.num_layers	):
         _UpperCAmelCase 				=self.in_channels if i == 0 else self.out_channels

         _UpperCAmelCase 				=FlaxResnetBlockaD(
             in_channels=__lowerCamelCase       ,					out_channels=self.out_channels       ,					dropout_prob=self.dropout       ,					dtype=self.dtype       ,					)
         resnets.append(__lowerCamelCase	)

         _UpperCAmelCase 				=FlaxTransformeraDModel(
             in_channels=self.out_channels       ,					n_heads=self.num_attention_heads       ,					d_head=self.out_channels // self.num_attention_heads       ,					depth=1       ,					use_linear_projection=self.use_linear_projection       ,					only_cross_attention=self.only_cross_attention       ,					use_memory_efficient_attention=self.use_memory_efficient_attention       ,					dtype=self.dtype       ,					)
         attentions.append(__lowerCamelCase	)

        _UpperCAmelCase 				=resnets
        _UpperCAmelCase 				=attentions

        if self.add_downsample:
         _UpperCAmelCase 				=FlaxDownsampleaD(self.out_channels       ,					dtype=self.dtype	)

       def __call__(					self       ,					_snake_case       ,					_snake_case       ,					_snake_case       ,					_snake_case=True	):
        _UpperCAmelCase 				=()

        for resnet, attn in zip(self.resnets       ,					self.attentions	):
         _UpperCAmelCase 				=resnet(__lowerCamelCase       ,					__lowerCamelCase       ,					deterministic=__lowerCamelCase	)
         _UpperCAmelCase 				=attn(__lowerCamelCase       ,					__lowerCamelCase       ,					deterministic=__lowerCamelCase	)
         output_states += (hidden_states,)

        if self.add_downsample:
         _UpperCAmelCase 				=self.downsamplers_a(__lowerCamelCase	)
         output_states += (hidden_states,)

        return hidden_states, output_states







class 						_a   (						nn.Module       ):

       """simple docstring"""





       snake_case				=4_2
       snake_case				=4_2
       snake_case				=0.0
       snake_case				=1
       snake_case				=True
       snake_case				=jnp.floataa
       def     SCREAMING_SNAKE_CASE  (					self	):
        _UpperCAmelCase 				=[]

        for i in range(self.num_layers	):
         _UpperCAmelCase 				=self.in_channels if i == 0 else self.out_channels

         _UpperCAmelCase 				=FlaxResnetBlockaD(
             in_channels=__lowerCamelCase       ,					out_channels=self.out_channels       ,					dropout_prob=self.dropout       ,					dtype=self.dtype       ,					)
         resnets.append(__lowerCamelCase	)
        _UpperCAmelCase 				=resnets

        if self.add_downsample:
         _UpperCAmelCase 				=FlaxDownsampleaD(self.out_channels       ,					dtype=self.dtype	)

       def __call__(					self       ,					_snake_case       ,					_snake_case       ,					_snake_case=True	):
        _UpperCAmelCase 				=()

        for resnet in self.resnets:
         _UpperCAmelCase 				=resnet(__lowerCamelCase       ,					__lowerCamelCase       ,					deterministic=__lowerCamelCase	)
         output_states += (hidden_states,)

        if self.add_downsample:
         _UpperCAmelCase 				=self.downsamplers_a(__lowerCamelCase	)
         output_states += (hidden_states,)

        return hidden_states, output_states







class 						_a   (						nn.Module       ):

       """simple docstring"""





       snake_case				=4_2
       snake_case				=4_2
       snake_case				=4_2
       snake_case				=0.0
       snake_case				=1
       snake_case				=1
       snake_case				=True
       snake_case				=False
       snake_case				=False
       snake_case				=False
       snake_case				=jnp.floataa
       def     SCREAMING_SNAKE_CASE  (					self	):
        _UpperCAmelCase 				=[]
        _UpperCAmelCase 				=[]

        for i in range(self.num_layers	):
         _UpperCAmelCase 				=self.in_channels if (i == self.num_layers - 1) else self.out_channels
         _UpperCAmelCase 				=self.prev_output_channel if i == 0 else self.out_channels

         _UpperCAmelCase 				=FlaxResnetBlockaD(
             in_channels=resnet_in_channels + res_skip_channels       ,					out_channels=self.out_channels       ,					dropout_prob=self.dropout       ,					dtype=self.dtype       ,					)
         resnets.append(__lowerCamelCase	)

         _UpperCAmelCase 				=FlaxTransformeraDModel(
             in_channels=self.out_channels       ,					n_heads=self.num_attention_heads       ,					d_head=self.out_channels // self.num_attention_heads       ,					depth=1       ,					use_linear_projection=self.use_linear_projection       ,					only_cross_attention=self.only_cross_attention       ,					use_memory_efficient_attention=self.use_memory_efficient_attention       ,					dtype=self.dtype       ,					)
         attentions.append(__lowerCamelCase	)

        _UpperCAmelCase 				=resnets
        _UpperCAmelCase 				=attentions

        if self.add_upsample:
         _UpperCAmelCase 				=FlaxUpsampleaD(self.out_channels       ,					dtype=self.dtype	)

       def __call__(					self       ,					_snake_case       ,					_snake_case       ,					_snake_case       ,					_snake_case       ,					_snake_case=True	):
        for resnet, attn in zip(self.resnets       ,					self.attentions	):
         # pop res hidden states
         _UpperCAmelCase 				=res_hidden_states_tuple[-1]
         _UpperCAmelCase 				=res_hidden_states_tuple[:-1]
         _UpperCAmelCase 				=jnp.concatenate((hidden_states, res_hidden_states)       ,					axis=-1	)

         _UpperCAmelCase 				=resnet(__lowerCamelCase       ,					__lowerCamelCase       ,					deterministic=__lowerCamelCase	)
         _UpperCAmelCase 				=attn(__lowerCamelCase       ,					__lowerCamelCase       ,					deterministic=__lowerCamelCase	)

        if self.add_upsample:
         _UpperCAmelCase 				=self.upsamplers_a(__lowerCamelCase	)

        return hidden_states







class 						_a   (						nn.Module       ):

       """simple docstring"""





       snake_case				=4_2
       snake_case				=4_2
       snake_case				=4_2
       snake_case				=0.0
       snake_case				=1
       snake_case				=True
       snake_case				=jnp.floataa
       def     SCREAMING_SNAKE_CASE  (					self	):
        _UpperCAmelCase 				=[]

        for i in range(self.num_layers	):
         _UpperCAmelCase 				=self.in_channels if (i == self.num_layers - 1) else self.out_channels
         _UpperCAmelCase 				=self.prev_output_channel if i == 0 else self.out_channels

         _UpperCAmelCase 				=FlaxResnetBlockaD(
             in_channels=resnet_in_channels + res_skip_channels       ,					out_channels=self.out_channels       ,					dropout_prob=self.dropout       ,					dtype=self.dtype       ,					)
         resnets.append(__lowerCamelCase	)

        _UpperCAmelCase 				=resnets

        if self.add_upsample:
         _UpperCAmelCase 				=FlaxUpsampleaD(self.out_channels       ,					dtype=self.dtype	)

       def __call__(					self       ,					_snake_case       ,					_snake_case       ,					_snake_case       ,					_snake_case=True	):
        for resnet in self.resnets:
         # pop res hidden states
         _UpperCAmelCase 				=res_hidden_states_tuple[-1]
         _UpperCAmelCase 				=res_hidden_states_tuple[:-1]
         _UpperCAmelCase 				=jnp.concatenate((hidden_states, res_hidden_states)       ,					axis=-1	)

         _UpperCAmelCase 				=resnet(__lowerCamelCase       ,					__lowerCamelCase       ,					deterministic=__lowerCamelCase	)

        if self.add_upsample:
         _UpperCAmelCase 				=self.upsamplers_a(__lowerCamelCase	)

        return hidden_states







class 						_a   (						nn.Module       ):

       """simple docstring"""





       snake_case				=4_2
       snake_case				=0.0
       snake_case				=1
       snake_case				=1
       snake_case				=False
       snake_case				=False
       snake_case				=jnp.floataa
       def     SCREAMING_SNAKE_CASE  (					self	):
        # there is always at least one resnet
        _UpperCAmelCase 				=[
            FlaxResnetBlockaD(
                in_channels=self.in_channels       ,					out_channels=self.in_channels       ,					dropout_prob=self.dropout       ,					dtype=self.dtype       ,					)
        ]

        _UpperCAmelCase 				=[]

        for _ in range(self.num_layers	):
         _UpperCAmelCase 				=FlaxTransformeraDModel(
             in_channels=self.in_channels       ,					n_heads=self.num_attention_heads       ,					d_head=self.in_channels // self.num_attention_heads       ,					depth=1       ,					use_linear_projection=self.use_linear_projection       ,					use_memory_efficient_attention=self.use_memory_efficient_attention       ,					dtype=self.dtype       ,					)
         attentions.append(__lowerCamelCase	)

         _UpperCAmelCase 				=FlaxResnetBlockaD(
             in_channels=self.in_channels       ,					out_channels=self.in_channels       ,					dropout_prob=self.dropout       ,					dtype=self.dtype       ,					)
         resnets.append(__lowerCamelCase	)

        _UpperCAmelCase 				=resnets
        _UpperCAmelCase 				=attentions

       def __call__(					self       ,					_snake_case       ,					_snake_case       ,					_snake_case       ,					_snake_case=True	):
        _UpperCAmelCase 				=self.resnets[0](__lowerCamelCase       ,					__lowerCamelCase	)
        for attn, resnet in zip(self.attentions       ,					self.resnets[1:]	):
         _UpperCAmelCase 				=attn(__lowerCamelCase       ,					__lowerCamelCase       ,					deterministic=__lowerCamelCase	)
         _UpperCAmelCase 				=resnet(__lowerCamelCase       ,					__lowerCamelCase       ,					deterministic=__lowerCamelCase	)

        return hidden_states












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 ):



 def 							UpperCamelCase     (				self					):
        A__		   =		tempfile.mkdtemp()
        A__		   =		SamImageProcessor()
        A__		   =		SamProcessor(__lowerCamelCase					)
        processor.save_pretrained(self.tmpdirname					)



 def 							UpperCamelCase     (				self,**__lowerCamelCase					):
        return AutoProcessor.from_pretrained(self.tmpdirname,**__lowerCamelCase					).image_processor



 def 							UpperCamelCase     (				self					):
        shutil.rmtree(self.tmpdirname					)



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

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

        return image_inputs



 def 							UpperCamelCase     (				self					):
        A__		   =		SamProcessor(image_processor=self.get_image_processor()					)
        processor.save_pretrained(self.tmpdirname					)

        A__		   =		self.get_image_processor(do_normalize=__lowerCamelCase,padding_value=1.0					)

        A__		   =		SamProcessor.from_pretrained(self.tmpdirname,do_normalize=__lowerCamelCase,padding_value=1.0					)

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



 def 							UpperCamelCase     (				self					):
        A__		   =		self.get_image_processor()

        A__		   =		SamProcessor(image_processor=__lowerCamelCase					)

        A__		   =		self.prepare_image_inputs()

        A__		   =		image_processor(__lowerCamelCase,return_tensors='''np'''					)
        A__		   =		processor(images=__lowerCamelCase,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 							UpperCamelCase     (				self					):
        A__		   =		self.get_image_processor()

        A__		   =		SamProcessor(image_processor=__lowerCamelCase					)
        A__		   =		[torch.ones((1, 3, 5, 5)					)]

        A__		   =		[[1764, 2646]]

        A__		   =		[[683, 1024]]
        A__		   =		processor.post_process_masks(__lowerCamelCase,__lowerCamelCase,__lowerCamelCase					)
        self.assertEqual(masks[0].shape,(1, 3, 1764, 2646)					)

        A__		   =		processor.post_process_masks(
            __lowerCamelCase,torch.tensor(__lowerCamelCase					),torch.tensor(__lowerCamelCase					)					)
        self.assertEqual(masks[0].shape,(1, 3, 1764, 2646)					)

        # should also work with np
        A__		   =		[np.ones((1, 3, 5, 5)					)]
        A__		   =		processor.post_process_masks(__lowerCamelCase,np.array(__lowerCamelCase					),np.array(__lowerCamelCase					)					)

        self.assertEqual(masks[0].shape,(1, 3, 1764, 2646)					)

        A__		   =		[[1, 0], [0, 1]]
        with self.assertRaises(__lowerCamelCase					):
               A__		   =		processor.post_process_masks(__lowerCamelCase,np.array(__lowerCamelCase					),np.array(__lowerCamelCase					)					)




@require_vision
@require_tf
class        SCREAMING_SNAKE_CASE__					(		unittest.TestCase ):



 def 							UpperCamelCase     (				self					):
        A__		   =		tempfile.mkdtemp()
        A__		   =		SamImageProcessor()
        A__		   =		SamProcessor(__lowerCamelCase					)
        processor.save_pretrained(self.tmpdirname					)



 def 							UpperCamelCase     (				self,**__lowerCamelCase					):
        return AutoProcessor.from_pretrained(self.tmpdirname,**__lowerCamelCase					).image_processor



 def 							UpperCamelCase     (				self					):
        shutil.rmtree(self.tmpdirname					)



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

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

        return image_inputs



 def 							UpperCamelCase     (				self					):
        A__		   =		SamProcessor(image_processor=self.get_image_processor()					)
        processor.save_pretrained(self.tmpdirname					)

        A__		   =		self.get_image_processor(do_normalize=__lowerCamelCase,padding_value=1.0					)

        A__		   =		SamProcessor.from_pretrained(self.tmpdirname,do_normalize=__lowerCamelCase,padding_value=1.0					)

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



 def 							UpperCamelCase     (				self					):
        A__		   =		self.get_image_processor()

        A__		   =		SamProcessor(image_processor=__lowerCamelCase					)

        A__		   =		self.prepare_image_inputs()

        A__		   =		image_processor(__lowerCamelCase,return_tensors='''np'''					)
        A__		   =		processor(images=__lowerCamelCase,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 							UpperCamelCase     (				self					):
        A__		   =		self.get_image_processor()

        A__		   =		SamProcessor(image_processor=__lowerCamelCase					)
        A__		   =		[tf.ones((1, 3, 5, 5)					)]

        A__		   =		[[1764, 2646]]

        A__		   =		[[683, 1024]]
        A__		   =		processor.post_process_masks(__lowerCamelCase,__lowerCamelCase,__lowerCamelCase,return_tensors='''tf'''					)
        self.assertEqual(masks[0].shape,(1, 3, 1764, 2646)					)

        A__		   =		processor.post_process_masks(
            __lowerCamelCase,tf.convert_to_tensor(__lowerCamelCase					),tf.convert_to_tensor(__lowerCamelCase					),return_tensors='''tf''',)
        self.assertEqual(masks[0].shape,(1, 3, 1764, 2646)					)

        # should also work with np
        A__		   =		[np.ones((1, 3, 5, 5)					)]
        A__		   =		processor.post_process_masks(
            __lowerCamelCase,np.array(__lowerCamelCase					),np.array(__lowerCamelCase					),return_tensors='''tf'''					)

        self.assertEqual(masks[0].shape,(1, 3, 1764, 2646)					)

        A__		   =		[[1, 0], [0, 1]]
        with self.assertRaises(tf.errors.InvalidArgumentError					):
               A__		   =		processor.post_process_masks(
                   __lowerCamelCase,np.array(__lowerCamelCase					),np.array(__lowerCamelCase					),return_tensors='''tf'''					)




@require_vision
@require_torchvision
class        SCREAMING_SNAKE_CASE__					(		unittest.TestCase ):



 def 							UpperCamelCase     (				self					):
        A__		   =		tempfile.mkdtemp()
        A__		   =		SamImageProcessor()
        A__		   =		SamProcessor(__lowerCamelCase					)
        processor.save_pretrained(self.tmpdirname					)



 def 							UpperCamelCase     (				self,**__lowerCamelCase					):
        return AutoProcessor.from_pretrained(self.tmpdirname,**__lowerCamelCase					).image_processor



 def 							UpperCamelCase     (				self					):
        shutil.rmtree(self.tmpdirname					)



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

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

        return image_inputs



 @is_pt_tf_cross_test
 def 							UpperCamelCase     (				self					):
        A__		   =		self.get_image_processor()

        A__		   =		SamProcessor(image_processor=__lowerCamelCase					)
        A__		   =		np.random.randint(0,2,size=(1, 3, 5, 5)					).astype(np.floataa					)
        A__		   =		[tf.convert_to_tensor(__lowerCamelCase					)]
        A__		   =		[torch.tensor(__lowerCamelCase					)]

        A__		   =		[[1764, 2646]]

        A__		   =		[[683, 1024]]
        A__		   =		processor.post_process_masks(
            __lowerCamelCase,__lowerCamelCase,__lowerCamelCase,return_tensors='''tf'''					)
        A__		   =		processor.post_process_masks(
            __lowerCamelCase,__lowerCamelCase,__lowerCamelCase,return_tensors='''pt'''					)

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




 @is_pt_tf_cross_test
 def 							UpperCamelCase     (				self					):
        A__		   =		self.get_image_processor()

        A__		   =		SamProcessor(image_processor=__lowerCamelCase					)

        A__		   =		self.prepare_image_inputs()

        A__		   =		image_processor(__lowerCamelCase,return_tensors='''pt'''					)['''pixel_values'''].numpy()
        A__		   =		processor(images=__lowerCamelCase,return_tensors='''pt'''					)['''pixel_values'''].numpy()

        A__		   =		image_processor(__lowerCamelCase,return_tensors='''tf'''					)['''pixel_values'''].numpy()
        A__		   =		processor(images=__lowerCamelCase,return_tensors='''tf'''					)['''pixel_values'''].numpy()

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





