





"""simple docstring"""


import copy
import inspect

from transformers.testing_utils import require_torch, torch_device
from transformers.utils.backbone_utils import BackboneType



@require_torch
class    lowercase_ :
       snake_case__ :							str 							=   ()
       snake_case__ :							Any 							=   True

       def 						_SCREAMING_SNAKE_CASE(	self   ):






        '''simple docstring'''

        snake_case__										= self.config_class

        # test default config
        snake_case__										= config_class()
        self.assertIsNotNone(__SCREAMING_SNAKE_CASE   )
        snake_case__										= ["stem"] + [F"stage{idx}" for idx in range(1      ,    len(config.depths   ) + 1   )]
        self.assertEqual(config.stage_names      ,    __SCREAMING_SNAKE_CASE   )
        self.assertTrue(set(config.out_features   ).issubset(set(config.stage_names   )   )   )

        # Test out_features and out_indices are correctly set
        # out_features and out_indices both None
        snake_case__										= config_class(out_features=__SCREAMING_SNAKE_CASE      ,    out_indices=__SCREAMING_SNAKE_CASE   )
        self.assertEqual(config.out_features      ,    [config.stage_names[-1]]   )
        self.assertEqual(config.out_indices      ,    [len(config.stage_names   ) - 1]   )

        # out_features and out_indices both set
        snake_case__										= config_class(out_features=["stem", "stage1"]      ,    out_indices=[0, 1]   )
        self.assertEqual(config.out_features      ,    ["stem", "stage1"]   )
        self.assertEqual(config.out_indices      ,    [0, 1]   )

        # Only out_features set
        snake_case__										= config_class(out_features=["stage1", "stage3"]   )
        self.assertEqual(config.out_features      ,    ["stage1", "stage3"]   )
        self.assertEqual(config.out_indices      ,    [1, 3]   )

        # Only out_indices set
        snake_case__										= config_class(out_indices=[0, 2]   )
        self.assertEqual(config.out_features      ,    [config.stage_names[0], config.stage_names[2]]   )
        self.assertEqual(config.out_indices      ,    [0, 2]   )

        # Error raised when out_indices do not correspond to out_features
        with self.assertRaises(__SCREAMING_SNAKE_CASE   ):
         snake_case__										= config_class(out_features=["stage1", "stage2"]      ,    out_indices=[0, 2]   )

       def 						_SCREAMING_SNAKE_CASE(	self   ):






        '''simple docstring'''

        snake_case__							,      snake_case__										= self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
         snake_case__										= model_class(__SCREAMING_SNAKE_CASE   )
         snake_case__										= inspect.signature(model.forward   )
         # signature.parameters is an OrderedDict => so arg_names order is deterministic
         snake_case__										= [*signature.parameters.keys()]
         snake_case__										= ["pixel_values"]
         self.assertListEqual(arg_names[:1]      ,    __SCREAMING_SNAKE_CASE   )

       def 						_SCREAMING_SNAKE_CASE(	self   ):






        '''simple docstring'''

        snake_case__							,      snake_case__										= self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
         snake_case__										= model_class(__SCREAMING_SNAKE_CASE   )
         self.assertEqual(len(model.channels   )      ,    len(config.out_features   )   )
         snake_case__										= model.num_features
         snake_case__										= [config.stage_names.index(__SCREAMING_SNAKE_CASE   ) for feat in config.out_features]
         snake_case__										= [num_features[idx] for idx in out_indices]
         self.assertListEqual(model.channels      ,    __SCREAMING_SNAKE_CASE   )

         snake_case__										= copy.deepcopy(__SCREAMING_SNAKE_CASE   )
         snake_case__										= None
         snake_case__										= model_class(__SCREAMING_SNAKE_CASE   )
         self.assertEqual(len(model.channels   )      ,    1   )
         self.assertListEqual(model.channels      ,    [num_features[-1]]   )

         snake_case__										= copy.deepcopy(__SCREAMING_SNAKE_CASE   )
         snake_case__										= None
         snake_case__										= model_class(__SCREAMING_SNAKE_CASE   )
         self.assertEqual(len(model.channels   )      ,    1   )
         self.assertListEqual(model.channels      ,    [num_features[-1]]   )

       def 						_SCREAMING_SNAKE_CASE(	self   ):






        '''simple docstring'''

        snake_case__							,      snake_case__										= self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
         snake_case__										= model_class(__SCREAMING_SNAKE_CASE   )
         model.to(__SCREAMING_SNAKE_CASE   )
         model.eval()
         snake_case__										= model(**__SCREAMING_SNAKE_CASE   )

         self.assertEqual(len(result.feature_maps   )      ,    len(config.out_features   )   )
         self.assertEqual(len(model.channels   )      ,    len(config.out_features   )   )
         self.assertEqual(len(result.feature_maps   )      ,    len(config.out_indices   )   )
         self.assertEqual(len(model.channels   )      ,    len(config.out_indices   )   )

         # Check output of last stage is taken if out_features=None, out_indices=None
         snake_case__										= copy.deepcopy(__SCREAMING_SNAKE_CASE   )
         snake_case__										= None
         snake_case__										= model_class(__SCREAMING_SNAKE_CASE   )
         model.to(__SCREAMING_SNAKE_CASE   )
         model.eval()
         snake_case__										= model(**__SCREAMING_SNAKE_CASE   )

         self.assertEqual(len(result.feature_maps   )      ,    1   )
         self.assertEqual(len(model.channels   )      ,    1   )

         snake_case__										= copy.deepcopy(__SCREAMING_SNAKE_CASE   )
         snake_case__										= None
         snake_case__										= model_class(__SCREAMING_SNAKE_CASE   )
         model.to(__SCREAMING_SNAKE_CASE   )
         model.eval()
         snake_case__										= model(**__SCREAMING_SNAKE_CASE   )

         self.assertEqual(len(result.feature_maps   )      ,    1   )
         self.assertEqual(len(model.channels   )      ,    1   )

         # Check backbone can be initialized with fresh weights
         snake_case__										= copy.deepcopy(__SCREAMING_SNAKE_CASE   )
         snake_case__										= False
         snake_case__										= model_class(__SCREAMING_SNAKE_CASE   )
         model.to(__SCREAMING_SNAKE_CASE   )
         model.eval()
         snake_case__										= model(**__SCREAMING_SNAKE_CASE   )

       def 						_SCREAMING_SNAKE_CASE(	self   ):






        '''simple docstring'''

        snake_case__							,      snake_case__										= self.model_tester.prepare_config_and_inputs_for_common()

        for backbone_class in self.all_model_classes:
         snake_case__										= backbone_class(__SCREAMING_SNAKE_CASE   )

         self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE      ,    "backbone_type"   )   )
         self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE      ,    "stage_names"   )   )
         self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE      ,    "num_features"   )   )
         self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE      ,    "out_indices"   )   )
         self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE      ,    "out_features"   )   )
         self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE      ,    "out_feature_channels"   )   )
         self.assertTrue(hasattr(__SCREAMING_SNAKE_CASE      ,    "channels"   )   )

         self.assertIsInstance(backbone.backbone_type      ,    __SCREAMING_SNAKE_CASE   )
         # Verify num_features has been initialized in the backbone init
         self.assertIsNotNone(backbone.num_features   )
         self.assertTrue(len(backbone.channels   ) == len(backbone.out_indices   )   )
         self.assertTrue(len(backbone.stage_names   ) == len(backbone.num_features   )   )
         self.assertTrue(len(backbone.channels   ) <= len(backbone.num_features   )   )
         self.assertTrue(len(backbone.out_feature_channels   ) == len(backbone.stage_names   )   )

       def 						_SCREAMING_SNAKE_CASE(	self   ):






        '''simple docstring'''

        snake_case__							,      snake_case__										= self.model_tester.prepare_config_and_inputs_for_common()
        snake_case__										= inputs_dict["pixel_values"].shape[0]

        for backbone_class in self.all_model_classes:
         snake_case__										= backbone_class(__SCREAMING_SNAKE_CASE   )
         backbone.to(__SCREAMING_SNAKE_CASE   )
         backbone.eval()

         snake_case__										= backbone(**__SCREAMING_SNAKE_CASE   )

         # Test default outputs and verify feature maps
         self.assertIsInstance(outputs.feature_maps      ,    __SCREAMING_SNAKE_CASE   )
         self.assertTrue(len(outputs.feature_maps   ) == len(backbone.channels   )   )
         for feature_map, n_channels in zip(outputs.feature_maps      ,    backbone.channels   ):
          self.assertTrue(feature_map.shape[:2]      ,    (batch_size, n_channels)   )
         self.assertIsNone(outputs.hidden_states   )
         self.assertIsNone(outputs.attentions   )

         # Test output_hidden_states=True
         snake_case__										= backbone(**__SCREAMING_SNAKE_CASE      ,    output_hidden_states=__SCREAMING_SNAKE_CASE   )
         self.assertIsNotNone(outputs.hidden_states   )
         self.assertTrue(len(outputs.hidden_states   )      ,    len(backbone.stage_names   )   )
         for hidden_state, n_channels in zip(outputs.hidden_states      ,    backbone.channels   ):
          self.assertTrue(hidden_state.shape[:2]      ,    (batch_size, n_channels)   )

         # Test output_attentions=True
         if self.has_attentions:
          snake_case__										= backbone(**__SCREAMING_SNAKE_CASE      ,    output_attentions=__SCREAMING_SNAKE_CASE   )
          self.assertIsNotNone(outputs.attentions   )








"""simple docstring"""


from typing import List

import PIL
import torch
from PIL import Image

from ...configuration_utils import ConfigMixin
from ...models.modeling_utils import ModelMixin
from ...utils import PIL_INTERPOLATION



class    lowercase_ (   __lowerCAmelCase ,__lowerCAmelCase							):

       def __init__(	self   ):






        '''simple docstring'''

        super().__init__()

        self.register_buffer("watermark_image"      ,    torch.zeros((62, 62, 4)   )   )
        snake_case__										= None

       def 						_SCREAMING_SNAKE_CASE(	self      ,    __SCREAMING_SNAKE_CASE      ,    __SCREAMING_SNAKE_CASE=None   ):






        '''simple docstring'''

        snake_case__										= images[0].height
        snake_case__										= images[0].width

        snake_case__										= sample_size or h

        snake_case__										= min(h / sample_size      ,    w / sample_size   )
        snake_case__							,      snake_case__										= (int(h / coef   ), int(w / coef   )) if coef < 1 else (h, w)

        snake_case__							,      snake_case__										= 1024**2, img_w * img_h
        snake_case__										= (Sa / Sa) ** 0.5
        snake_case__							,      snake_case__							,      snake_case__										= int(K * 62   ), img_w - int(14 * K   ), img_h - int(14 * K   )

        if self.watermark_image_as_pil is None:
         snake_case__										= self.watermark_image.to(torch.uinta   ).cpu().numpy()
         snake_case__										= Image.fromarray(__SCREAMING_SNAKE_CASE      ,    mode="RGBA"   )
         snake_case__										= watermark_image

        snake_case__										= self.watermark_image_as_pil.resize(
            (wm_size, wm_size)      ,    PIL_INTERPOLATION["bicubic"]      ,    reducing_gap=__SCREAMING_SNAKE_CASE   )

        for pil_img in images:
         pil_img.paste(__SCREAMING_SNAKE_CASE      ,    box=(wm_x - wm_size, wm_y - wm_size, wm_x, wm_y)      ,    mask=wm_img.split()[-1]   )

        return images

