






from dataclasses import dataclass
from enum import Enum
from typing import List, Optional, Union

import numpy as np
import PIL
from PIL import Image

from ...utils import BaseOutput, is_torch_available, is_transformers_available







@dataclass
class     UpperCAmelCase_		(      lowercase				):



      """simple docstring"""
      UpperCamelCase_       :      int     ={
          'sld_warmup_steps': 15,
          'sld_guidance_scale': 20,
          'sld_threshold': 0.0,
          'sld_momentum_scale': 0.0,
          'sld_mom_beta': 0.0,
      }
      UpperCamelCase_       :      str     ={
          'sld_warmup_steps': 10,
          'sld_guidance_scale': 1000,
          'sld_threshold': 0.01,
          'sld_momentum_scale': 0.3,
          'sld_mom_beta': 0.4,
      }
      UpperCamelCase_       :      Any     ={
          'sld_warmup_steps': 7,
          'sld_guidance_scale': 2000,
          'sld_threshold': 0.025,
          'sld_momentum_scale': 0.5,
          'sld_mom_beta': 0.7,
      }
      UpperCamelCase_       :      Dict     ={
          'sld_warmup_steps': 0,
          'sld_guidance_scale': 5000,
          'sld_threshold': 1.0,
          'sld_momentum_scale': 0.5,
          'sld_mom_beta': 0.7,
      }







@dataclass
class     UpperCAmelCase_		(      lowercase				):



      """simple docstring"""
      UpperCamelCase_       :      Union[List[PIL.Image.Image], np.ndarray]
      UpperCamelCase_       :      Optional[List[bool]]
      UpperCamelCase_       :      Optional[Union[List[PIL.Image.Image], np.ndarray]]
      UpperCamelCase_       :      Optional[str]


if is_transformers_available() and is_torch_available():
 from .pipeline_stable_diffusion_safe import StableDiffusionPipelineSafe
 from .safety_checker import SafeStableDiffusionSafetyChecker













from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import SwinConfig
from transformers.testing_utils import require_tf, require_vision, slow, to_atuple
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
 import tensorflow as tf

 from transformers.models.swin.modeling_tf_swin import (
     TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
     TFSwinForImageClassification,
     TFSwinForMaskedImageModeling,
     TFSwinModel,
 )


if is_vision_available():
 from PIL import Image

 from transformers import AutoImageProcessor







class     UpperCAmelCase_		:



      """simple docstring"""
      def __init__(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_=13					,       SCREAMING_SNAKE_CASE_=32					,       SCREAMING_SNAKE_CASE_=2					,       SCREAMING_SNAKE_CASE_=3					,       SCREAMING_SNAKE_CASE_=16					,       SCREAMING_SNAKE_CASE_=[1, 2, 1]					,       SCREAMING_SNAKE_CASE_=[2, 2, 4]					,       SCREAMING_SNAKE_CASE_=2					,       SCREAMING_SNAKE_CASE_=2.0					,       SCREAMING_SNAKE_CASE_=True					,       SCREAMING_SNAKE_CASE_=0.0					,       SCREAMING_SNAKE_CASE_=0.0					,       SCREAMING_SNAKE_CASE_=0.1					,       SCREAMING_SNAKE_CASE_="gelu"					,       SCREAMING_SNAKE_CASE_=False					,       SCREAMING_SNAKE_CASE_=True					,       SCREAMING_SNAKE_CASE_=0.02					,       SCREAMING_SNAKE_CASE_=1e-5					,       SCREAMING_SNAKE_CASE_=True					,       SCREAMING_SNAKE_CASE_=None					,       SCREAMING_SNAKE_CASE_=True					,       SCREAMING_SNAKE_CASE_=10					,       SCREAMING_SNAKE_CASE_=8					,       )       ->   None:
          UpperCamelCase :Optional[Any]										=     parent
          UpperCamelCase :Optional[Any]										=     batch_size
          UpperCamelCase :List[Any]										=     image_size
          UpperCamelCase :List[Any]										=     patch_size
          UpperCamelCase :List[Any]										=     num_channels
          UpperCamelCase :Optional[Any]										=     embed_dim
          UpperCamelCase :List[Any]										=     depths
          UpperCamelCase :List[Any]										=     num_heads
          UpperCamelCase :Tuple										=     window_size
          UpperCamelCase :Optional[int]										=     mlp_ratio
          UpperCamelCase :int										=     qkv_bias
          UpperCamelCase :str										=     hidden_dropout_prob
          UpperCamelCase :Dict										=     attention_probs_dropout_prob
          UpperCamelCase :Dict										=     drop_path_rate
          UpperCamelCase :Optional[Any]										=     hidden_act
          UpperCamelCase :int										=     use_absolute_embeddings
          UpperCamelCase :Any										=     patch_norm
          UpperCamelCase :str										=     layer_norm_eps
          UpperCamelCase :List[Any]										=     initializer_range
          UpperCamelCase :str										=     is_training
          UpperCamelCase :Union[str, Any]										=     scope
          UpperCamelCase :List[str]										=     use_labels
          UpperCamelCase :Union[str, Any]										=     type_sequence_label_size
          UpperCamelCase :int										=     encoder_stride
      def 					UpperCAmelCase		(       self				)       ->   Optional[int]:
          UpperCamelCase :Dict										=     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

          UpperCamelCase :List[Any]										=     None
          if self.use_labels:
              UpperCamelCase :Tuple										=     ids_tensor([self.batch_size]					,       self.type_sequence_label_size				)

          UpperCamelCase :List[str]										=     self.get_config()

          return config, pixel_values, labels
      def 					UpperCAmelCase		(       self				)       ->   int:
          return SwinConfig(
              image_size=self.image_size					,       patch_size=self.patch_size					,       num_channels=self.num_channels					,       embed_dim=self.embed_dim					,       depths=self.depths					,       num_heads=self.num_heads					,       window_size=self.window_size					,       mlp_ratio=self.mlp_ratio					,       qkv_bias=self.qkv_bias					,       hidden_dropout_prob=self.hidden_dropout_prob					,       attention_probs_dropout_prob=self.attention_probs_dropout_prob					,       drop_path_rate=self.drop_path_rate					,       hidden_act=self.hidden_act					,       use_absolute_embeddings=self.use_absolute_embeddings					,       path_norm=self.patch_norm					,       layer_norm_eps=self.layer_norm_eps					,       initializer_range=self.initializer_range					,       encoder_stride=self.encoder_stride					,       )
      def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)       ->   List[Any]:
          UpperCamelCase :int										=     TFSwinModel(config=SCREAMING_SNAKE_CASE_				)
          UpperCamelCase :Tuple										=     model(SCREAMING_SNAKE_CASE_				)

          UpperCamelCase :str										=     ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths				) - 1))
          UpperCamelCase :Union[str, Any]										=     int(config.embed_dim * 2 ** (len(config.depths				) - 1)				)

          self.parent.assertEqual(result.last_hidden_state.shape					,       (self.batch_size, expected_seq_len, expected_dim)				)
      def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)       ->   Any:
          UpperCamelCase :int										=     TFSwinForMaskedImageModeling(config=SCREAMING_SNAKE_CASE_				)
          UpperCamelCase :List[str]										=     model(SCREAMING_SNAKE_CASE_				)
          self.parent.assertEqual(
              result.logits.shape					,       (self.batch_size, self.num_channels, self.image_size, self.image_size)				)

          # test greyscale images
          UpperCamelCase :Optional[int]										=     1
          UpperCamelCase :int										=     TFSwinForMaskedImageModeling(SCREAMING_SNAKE_CASE_				)

          UpperCamelCase :str										=     floats_tensor([self.batch_size, 1, self.image_size, self.image_size]				)
          UpperCamelCase :str										=     model(SCREAMING_SNAKE_CASE_				)
          self.parent.assertEqual(result.logits.shape					,       (self.batch_size, 1, self.image_size, self.image_size)				)
      def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)       ->   List[str]:
          UpperCamelCase :Optional[Any]										=     self.type_sequence_label_size
          UpperCamelCase :Optional[int]										=     TFSwinForImageClassification(SCREAMING_SNAKE_CASE_				)
          UpperCamelCase :Tuple										=     model(SCREAMING_SNAKE_CASE_					,       labels=SCREAMING_SNAKE_CASE_				)
          self.parent.assertEqual(result.logits.shape					,       (self.batch_size, self.type_sequence_label_size)				)

          # test greyscale images
          UpperCamelCase :Union[str, Any]										=     1
          UpperCamelCase :Tuple										=     TFSwinForImageClassification(SCREAMING_SNAKE_CASE_				)
          UpperCamelCase :Any										=     floats_tensor([self.batch_size, 1, self.image_size, self.image_size]				)
          UpperCamelCase :Tuple										=     model(SCREAMING_SNAKE_CASE_				)
          self.parent.assertEqual(result.logits.shape					,       (self.batch_size, self.type_sequence_label_size)				)




      def 					UpperCAmelCase		(       self				)       ->   int:
          UpperCamelCase :List[str]										=     self.prepare_config_and_inputs()
          UpperCamelCase							,     UpperCamelCase							,     UpperCamelCase :Optional[Any]										=     config_and_inputs
          UpperCamelCase :Any										=     {'''pixel_values''': pixel_values}
          return config, inputs_dict







@require_tf
class     UpperCAmelCase_		(      lowercase,			lowercase,			unittest.TestCase				):



      """simple docstring"""
      UpperCamelCase_       :      int     =(
          (
              TFSwinModel,
              TFSwinForImageClassification,
              TFSwinForMaskedImageModeling,
          )
          if is_tf_available()
          else ()
      )
      UpperCamelCase_       :      Any     =(
          {'feature-extraction': TFSwinModel, 'image-classification': TFSwinForImageClassification}
          if is_tf_available()
          else {}
      )

      UpperCamelCase_       :      Optional[int]     =False
      UpperCamelCase_       :      int     =False
      UpperCamelCase_       :      Optional[int]     =False
      UpperCamelCase_       :      Any     =False
      def 					UpperCAmelCase		(       self				)       ->   Tuple:
          UpperCamelCase :str										=     TFSwinModelTester(self				)
          UpperCamelCase :str										=     ConfigTester(self					,       config_class=SCREAMING_SNAKE_CASE_					,       embed_dim=37				)
      def 					UpperCAmelCase		(       self				)       ->   Dict:
          self.create_and_test_config_common_properties()
          self.config_tester.create_and_test_config_to_json_string()
          self.config_tester.create_and_test_config_to_json_file()
          self.config_tester.create_and_test_config_from_and_save_pretrained()
          self.config_tester.create_and_test_config_with_num_labels()
          self.config_tester.check_config_can_be_init_without_params()
          self.config_tester.check_config_arguments_init()
      def 					UpperCAmelCase		(       self				)       ->   Union[str, Any]:
          return
      def 					UpperCAmelCase		(       self				)       ->   Optional[Any]:
          UpperCamelCase :Any										=     self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_				)
      def 					UpperCAmelCase		(       self				)       ->   Optional[int]:
          UpperCamelCase :Optional[int]										=     self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_masked_image_modeling(*SCREAMING_SNAKE_CASE_				)
      def 					UpperCAmelCase		(       self				)       ->   Optional[Any]:
          UpperCamelCase :Any										=     self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*SCREAMING_SNAKE_CASE_				)
      @unittest.skip(reason='''Swin does not use inputs_embeds'''				)
      def 					UpperCAmelCase		(       self				)       ->   Union[str, Any]:
          pass
      def 					UpperCAmelCase		(       self				)       ->   Optional[int]:
          UpperCamelCase							,     UpperCamelCase :int										=     self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
              UpperCamelCase :Optional[int]										=     model_class(SCREAMING_SNAKE_CASE_				)
              self.assertIsInstance(model.get_input_embeddings()					,       tf.keras.layers.Layer				)
              UpperCamelCase :Union[str, Any]										=     model.get_output_embeddings()
              self.assertTrue(x is None or isinstance(SCREAMING_SNAKE_CASE_					,       tf.keras.layers.Dense				)				)
      def 					UpperCAmelCase		(       self				)       ->   str:
          UpperCamelCase							,     UpperCamelCase :str										=     self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
              UpperCamelCase :Union[str, Any]										=     model_class(SCREAMING_SNAKE_CASE_				)
              UpperCamelCase :Union[str, Any]										=     inspect.signature(model.call				)
              # signature.parameters is an OrderedDict => so arg_names order is deterministic
              UpperCamelCase :Dict										=     [*signature.parameters.keys()]

              UpperCamelCase :Tuple										=     ['''pixel_values''']
              self.assertListEqual(arg_names[:1]					,       SCREAMING_SNAKE_CASE_				)
      def 					UpperCAmelCase		(       self				)       ->   List[Any]:
          UpperCamelCase							,     UpperCamelCase :Optional[int]										=     self.model_tester.prepare_config_and_inputs_for_common()
          UpperCamelCase :str										=     True

          for model_class in self.all_model_classes:
              UpperCamelCase :List[Any]										=     True
              UpperCamelCase :Optional[Any]										=     False
              UpperCamelCase :List[str]										=     True
              UpperCamelCase :Optional[int]										=     model_class(SCREAMING_SNAKE_CASE_				)
              UpperCamelCase :Union[str, Any]										=     model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)				)
              UpperCamelCase :List[Any]										=     outputs.attentions
              UpperCamelCase :int										=     len(self.model_tester.depths				)
              self.assertEqual(len(SCREAMING_SNAKE_CASE_				)					,       SCREAMING_SNAKE_CASE_				)

              # check that output_attentions also work using config
              del inputs_dict["output_attentions"]
              UpperCamelCase :Optional[Any]										=     True
              UpperCamelCase :List[Any]										=     config.window_size**2
              UpperCamelCase :Dict										=     model_class(SCREAMING_SNAKE_CASE_				)
              UpperCamelCase :Dict										=     model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)				)
              UpperCamelCase :List[Any]										=     outputs.attentions
              self.assertEqual(len(SCREAMING_SNAKE_CASE_				)					,       SCREAMING_SNAKE_CASE_				)

              self.assertListEqual(
                  list(attentions[0].shape[-3:]				)					,       [self.model_tester.num_heads[0], window_size_squared, window_size_squared]					,       )
              UpperCamelCase :List[Any]										=     len(SCREAMING_SNAKE_CASE_				)

              # Check attention is always last and order is fine
              UpperCamelCase :int										=     True
              UpperCamelCase :List[str]										=     True
              UpperCamelCase :List[str]										=     model_class(SCREAMING_SNAKE_CASE_				)
              UpperCamelCase :Tuple										=     model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)				)

              if hasattr(self.model_tester					,       '''num_hidden_states_types'''				):
                  UpperCamelCase :Union[str, Any]										=     self.model_tester.num_hidden_states_types
              else:
                  # also another +1 for reshaped_hidden_states
                  UpperCamelCase :Optional[int]										=     2
              self.assertEqual(out_len + added_hidden_states					,       len(SCREAMING_SNAKE_CASE_				)				)

              UpperCamelCase :Optional[int]										=     outputs.attentions

              self.assertEqual(len(SCREAMING_SNAKE_CASE_				)					,       SCREAMING_SNAKE_CASE_				)

              self.assertListEqual(
                  list(self_attentions[0].shape[-3:]				)					,       [self.model_tester.num_heads[0], window_size_squared, window_size_squared]					,       )
      def 					UpperCAmelCase		(       self					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)       ->   Dict:
          UpperCamelCase :Optional[int]										=     model_class(SCREAMING_SNAKE_CASE_				)
          UpperCamelCase :Any										=     model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)				)
          UpperCamelCase :Union[str, Any]										=     outputs.hidden_states

          UpperCamelCase :Any										=     getattr(
              self.model_tester					,       '''expected_num_hidden_layers'''					,       len(self.model_tester.depths				) + 1				)
          self.assertEqual(len(SCREAMING_SNAKE_CASE_				)					,       SCREAMING_SNAKE_CASE_				)

          # Swin has a different seq_length
          UpperCamelCase :str										=     to_atuple(config.patch_size				)

          UpperCamelCase :Optional[int]										=     (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

          self.assertListEqual(
              list(hidden_states[0].shape[-2:]				)					,       [num_patches, self.model_tester.embed_dim]					,       )

          UpperCamelCase :str										=     outputs.reshaped_hidden_states
          self.assertEqual(len(SCREAMING_SNAKE_CASE_				)					,       SCREAMING_SNAKE_CASE_				)

          UpperCamelCase							,     UpperCamelCase							,     UpperCamelCase							,     UpperCamelCase :Optional[int]										=     reshaped_hidden_states[0].shape

          UpperCamelCase :int										=     tf.reshape(reshaped_hidden_states[0]					,       (batch_size, num_channels, height * width)				)
          UpperCamelCase :Dict										=     tf.transpose(SCREAMING_SNAKE_CASE_					,       (0, 2, 1)				)

          self.assertListEqual(
              list(reshaped_hidden_states.shape[-2:]				)					,       [num_patches, self.model_tester.embed_dim]					,       )
      def 					UpperCAmelCase		(       self				)       ->   str:
          UpperCamelCase							,     UpperCamelCase :int										=     self.model_tester.prepare_config_and_inputs_for_common()

          UpperCamelCase :List[Any]										=     to_atuple(self.model_tester.image_size				)

          for model_class in self.all_model_classes:
              UpperCamelCase :List[Any]										=     True
              self.check_hidden_states_output(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)

              # check that output_hidden_states also work using config
              del inputs_dict["output_hidden_states"]
              UpperCamelCase :List[str]										=     True

              self.check_hidden_states_output(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_				)
      def 					UpperCAmelCase		(       self				)       ->   Optional[Any]:
          UpperCamelCase							,     UpperCamelCase :List[Any]										=     self.model_tester.prepare_config_and_inputs_for_common()
          UpperCamelCase :List[Any]										=     3

          UpperCamelCase :Any										=     to_atuple(self.model_tester.image_size				)
          UpperCamelCase :List[Any]										=     to_atuple(config.patch_size				)

          UpperCamelCase :Dict										=     image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
          UpperCamelCase :List[str]										=     image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

          for model_class in self.all_model_classes:
              UpperCamelCase :List[Any]										=     True
              self.check_hidden_states_output(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       (padded_height, padded_width)				)

              # check that output_hidden_states also work using config
              del inputs_dict["output_hidden_states"]
              UpperCamelCase :str										=     True
              self.check_hidden_states_output(SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       SCREAMING_SNAKE_CASE_					,       (padded_height, padded_width)				)




      @slow
      def 					UpperCAmelCase		(       self				)       ->   List[Any]:
          for model_name in TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              UpperCamelCase :Dict										=     TFSwinModel.from_pretrained(SCREAMING_SNAKE_CASE_				)
              self.assertIsNotNone(SCREAMING_SNAKE_CASE_				)







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



      """simple docstring"""
      @cached_property
      def 					UpperCAmelCase		(       self				)       ->   Union[str, Any]:
          return (
              AutoImageProcessor.from_pretrained('''microsoft/swin-tiny-patch4-window7-224'''				)
              if is_vision_available()
              else None
          )




      @slow
      def 					UpperCAmelCase		(       self				)       ->   Optional[int]:
          UpperCamelCase :Tuple										=     TFSwinForImageClassification.from_pretrained('''microsoft/swin-tiny-patch4-window7-224'''				)
          UpperCamelCase :int										=     self.default_image_processor

          UpperCamelCase :Optional[int]										=     Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''				)
          UpperCamelCase :List[str]										=     image_processor(images=SCREAMING_SNAKE_CASE_					,       return_tensors='''tf'''				)

          # forward pass
          UpperCamelCase :Optional[Any]										=     model(SCREAMING_SNAKE_CASE_				)

          # verify the logits
          UpperCamelCase :Tuple										=     tf.TensorShape((1, 1000)				)
          self.assertEqual(outputs.logits.shape					,       SCREAMING_SNAKE_CASE_				)
          UpperCamelCase :List[Any]										=     tf.constant([-0.0948, -0.6454, -0.0921]				)
          self.assertTrue(np.allclose(outputs.logits[0, :3]					,       SCREAMING_SNAKE_CASE_					,       atol=1e-4				)				)





