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




				def __init__( self    ,    _UpperCamelCase    ,    _UpperCamelCase=13    ,    _UpperCamelCase=32    ,    _UpperCamelCase=2    ,    _UpperCamelCase=3    ,    _UpperCamelCase=16    ,    _UpperCamelCase=[1, 2, 1]    ,    _UpperCamelCase=[2, 2, 4]    ,    _UpperCamelCase=2    ,    _UpperCamelCase=2.0    ,    _UpperCamelCase=True    ,    _UpperCamelCase=0.0    ,    _UpperCamelCase=0.0    ,    _UpperCamelCase=0.1    ,    _UpperCamelCase="gelu"    ,    _UpperCamelCase=False    ,    _UpperCamelCase=True    ,    _UpperCamelCase=0.02    ,    _UpperCamelCase=1e-5    ,    _UpperCamelCase=True    ,    _UpperCamelCase=None    ,    _UpperCamelCase=True    ,    _UpperCamelCase=10    ,    _UpperCamelCase=8    ,    )    ->				None:
							lowerCAmelCase_      =     parent
							lowerCAmelCase_      =     batch_size
							lowerCAmelCase_      =     image_size
							lowerCAmelCase_      =     patch_size
							lowerCAmelCase_      =     num_channels
							lowerCAmelCase_      =     embed_dim
							lowerCAmelCase_      =     depths
							lowerCAmelCase_      =     num_heads
							lowerCAmelCase_      =     window_size
							lowerCAmelCase_      =     mlp_ratio
							lowerCAmelCase_      =     qkv_bias
							lowerCAmelCase_      =     hidden_dropout_prob
							lowerCAmelCase_      =     attention_probs_dropout_prob
							lowerCAmelCase_      =     drop_path_rate
							lowerCAmelCase_      =     hidden_act
							lowerCAmelCase_      =     use_absolute_embeddings
							lowerCAmelCase_      =     patch_norm
							lowerCAmelCase_      =     layer_norm_eps
							lowerCAmelCase_      =     initializer_range
							lowerCAmelCase_      =     is_training
							lowerCAmelCase_      =     scope
							lowerCAmelCase_      =     use_labels
							lowerCAmelCase_      =     type_sequence_label_size
							lowerCAmelCase_      =     encoder_stride




				def 					__a						( self					)    ->				str:
							lowerCAmelCase_      =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

							lowerCAmelCase_      =     None
							if self.use_labels:
										lowerCAmelCase_      =     ids_tensor([self.batch_size]    ,    self.type_sequence_label_size					)

							lowerCAmelCase_      =     self.get_config()

							return config, pixel_values, labels




				def 					__a						( self					)    ->				Optional[Any]:
							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 					__a						( self    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase					)    ->				Optional[Any]:
							lowerCAmelCase_      =     TFSwinModel(config=_UpperCamelCase					)
							lowerCAmelCase_      =     model(_UpperCamelCase					)

							lowerCAmelCase_      =     ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths					) - 1))
							lowerCAmelCase_      =     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 					__a						( self    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase					)    ->				Dict:
							lowerCAmelCase_      =     TFSwinForMaskedImageModeling(config=_UpperCamelCase					)
							lowerCAmelCase_      =     model(_UpperCamelCase					)
							self.parent.assertEqual(
							    result.logits.shape    ,    (self.batch_size, self.num_channels, self.image_size, self.image_size)					)

							# test greyscale images
							lowerCAmelCase_      =     1
							lowerCAmelCase_      =     TFSwinForMaskedImageModeling(_UpperCamelCase					)

							lowerCAmelCase_      =     floats_tensor([self.batch_size, 1, self.image_size, self.image_size]					)
							lowerCAmelCase_      =     model(_UpperCamelCase					)
							self.parent.assertEqual(result.logits.shape    ,    (self.batch_size, 1, self.image_size, self.image_size)					)




				def 					__a						( self    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase					)    ->				Optional[Any]:
							lowerCAmelCase_      =     self.type_sequence_label_size
							lowerCAmelCase_      =     TFSwinForImageClassification(_UpperCamelCase					)
							lowerCAmelCase_      =     model(_UpperCamelCase    ,    labels=_UpperCamelCase					)
							self.parent.assertEqual(result.logits.shape    ,    (self.batch_size, self.type_sequence_label_size)					)

							# test greyscale images
							lowerCAmelCase_      =     1
							lowerCAmelCase_      =     TFSwinForImageClassification(_UpperCamelCase					)
							lowerCAmelCase_      =     floats_tensor([self.batch_size, 1, self.image_size, self.image_size]					)
							lowerCAmelCase_      =     model(_UpperCamelCase					)
							self.parent.assertEqual(result.logits.shape    ,    (self.batch_size, self.type_sequence_label_size)					)




				def 					__a						( self					)    ->				Optional[int]:
							lowerCAmelCase_      =     self.prepare_config_and_inputs()
							lowerCAmelCase_     ,  lowerCAmelCase_     ,  lowerCAmelCase_      =     config_and_inputs
							lowerCAmelCase_      =     {"pixel_values": pixel_values}
							return config, inputs_dict





@require_tf
class      _lowerCAmelCase (     __a ,				__a ,				unittest.TestCase	):
				_lowercase      		=(
				    (
				        TFSwinModel,
				        TFSwinForImageClassification,
				        TFSwinForMaskedImageModeling,
				    )
				    if is_tf_available()
				    else ()
				)
				_lowercase      		=(
				    {'''feature-extraction''': TFSwinModel, '''image-classification''': TFSwinForImageClassification}
				    if is_tf_available()
				    else {}
				)

				_lowercase      		=False
				_lowercase      		=False
				_lowercase      		=False
				_lowercase      		=False




				def 					__a						( self					)    ->				Optional[int]:
							lowerCAmelCase_      =     TFSwinModelTester(self					)
							lowerCAmelCase_      =     ConfigTester(self    ,    config_class=_UpperCamelCase    ,    embed_dim=37					)




				def 					__a						( self					)    ->				int:
							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 					__a						( self					)    ->				int:
							return




				def 					__a						( self					)    ->				List[Any]:
							lowerCAmelCase_      =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*_UpperCamelCase					)




				def 					__a						( self					)    ->				Union[str, Any]:
							lowerCAmelCase_      =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_masked_image_modeling(*_UpperCamelCase					)




				def 					__a						( self					)    ->				Any:
							lowerCAmelCase_      =     self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*_UpperCamelCase					)




				@unittest.skip(reason="Swin does not use inputs_embeds"					)
				def 					__a						( self					)    ->				List[str]:
							pass




				def 					__a						( self					)    ->				List[str]:
							lowerCAmelCase_     ,  lowerCAmelCase_      =     self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
										lowerCAmelCase_      =     model_class(_UpperCamelCase					)
										self.assertIsInstance(model.get_input_embeddings()    ,    tf.keras.layers.Layer					)
										lowerCAmelCase_      =     model.get_output_embeddings()
										self.assertTrue(x is None or isinstance(_UpperCamelCase    ,    tf.keras.layers.Dense					)					)




				def 					__a						( self					)    ->				int:
							lowerCAmelCase_     ,  lowerCAmelCase_      =     self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
										lowerCAmelCase_      =     model_class(_UpperCamelCase					)
										lowerCAmelCase_      =     inspect.signature(model.call					)
										# signature.parameters is an OrderedDict => so arg_names order is deterministic
										lowerCAmelCase_      =     [*signature.parameters.keys()]

										lowerCAmelCase_      =     ["pixel_values"]
										self.assertListEqual(arg_names[:1]    ,    _UpperCamelCase					)




				def 					__a						( self					)    ->				Optional[Any]:
							lowerCAmelCase_     ,  lowerCAmelCase_      =     self.model_tester.prepare_config_and_inputs_for_common()
							lowerCAmelCase_      =     True

							for model_class in self.all_model_classes:
										lowerCAmelCase_      =     True
										lowerCAmelCase_      =     False
										lowerCAmelCase_      =     True
										lowerCAmelCase_      =     model_class(_UpperCamelCase					)
										lowerCAmelCase_      =     model(**self._prepare_for_class(_UpperCamelCase    ,    _UpperCamelCase					)					)
										lowerCAmelCase_      =     outputs.attentions
										lowerCAmelCase_      =     len(self.model_tester.depths					)
										self.assertEqual(len(_UpperCamelCase					)    ,    _UpperCamelCase					)

										# check that output_attentions also work using config
										del inputs_dict["output_attentions"]
										lowerCAmelCase_      =     True
										lowerCAmelCase_      =     config.window_size**2
										lowerCAmelCase_      =     model_class(_UpperCamelCase					)
										lowerCAmelCase_      =     model(**self._prepare_for_class(_UpperCamelCase    ,    _UpperCamelCase					)					)
										lowerCAmelCase_      =     outputs.attentions
										self.assertEqual(len(_UpperCamelCase					)    ,    _UpperCamelCase					)

										self.assertListEqual(
										    list(attentions[0].shape[-3:]					)    ,    [self.model_tester.num_heads[0], window_size_squared, window_size_squared]    ,    )
										lowerCAmelCase_      =     len(_UpperCamelCase					)

										# Check attention is always last and order is fine
										lowerCAmelCase_      =     True
										lowerCAmelCase_      =     True
										lowerCAmelCase_      =     model_class(_UpperCamelCase					)
										lowerCAmelCase_      =     model(**self._prepare_for_class(_UpperCamelCase    ,    _UpperCamelCase					)					)

										if hasattr(self.model_tester    ,    "num_hidden_states_types"					):
													lowerCAmelCase_      =     self.model_tester.num_hidden_states_types
										else:
													# also another +1 for reshaped_hidden_states
													lowerCAmelCase_      =     2
										self.assertEqual(out_len + added_hidden_states    ,    len(_UpperCamelCase					)					)

										lowerCAmelCase_      =     outputs.attentions

										self.assertEqual(len(_UpperCamelCase					)    ,    _UpperCamelCase					)

										self.assertListEqual(
										    list(self_attentions[0].shape[-3:]					)    ,    [self.model_tester.num_heads[0], window_size_squared, window_size_squared]    ,    )




				def 					__a						( self    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase					)    ->				Any:
							lowerCAmelCase_      =     model_class(_UpperCamelCase					)
							lowerCAmelCase_      =     model(**self._prepare_for_class(_UpperCamelCase    ,    _UpperCamelCase					)					)
							lowerCAmelCase_      =     outputs.hidden_states

							lowerCAmelCase_      =     getattr(
							    self.model_tester    ,    "expected_num_hidden_layers"    ,    len(self.model_tester.depths					) + 1					)
							self.assertEqual(len(_UpperCamelCase					)    ,    _UpperCamelCase					)

							# Swin has a different seq_length
							lowerCAmelCase_      =     to_atuple(config.patch_size					)

							lowerCAmelCase_      =     (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]    ,    )

							lowerCAmelCase_      =     outputs.reshaped_hidden_states
							self.assertEqual(len(_UpperCamelCase					)    ,    _UpperCamelCase					)

							lowerCAmelCase_     ,  lowerCAmelCase_     ,  lowerCAmelCase_     ,  lowerCAmelCase_      =     reshaped_hidden_states[0].shape

							lowerCAmelCase_      =     tf.reshape(reshaped_hidden_states[0]    ,    (batch_size, num_channels, height * width)					)
							lowerCAmelCase_      =     tf.transpose(_UpperCamelCase    ,    (0, 2, 1)					)

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




				def 					__a						( self					)    ->				List[Any]:
							lowerCAmelCase_     ,  lowerCAmelCase_      =     self.model_tester.prepare_config_and_inputs_for_common()

							lowerCAmelCase_      =     to_atuple(self.model_tester.image_size					)

							for model_class in self.all_model_classes:
										lowerCAmelCase_      =     True
										self.check_hidden_states_output(_UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase					)

										# check that output_hidden_states also work using config
										del inputs_dict["output_hidden_states"]
										lowerCAmelCase_      =     True

										self.check_hidden_states_output(_UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase					)




				def 					__a						( self					)    ->				Any:
							lowerCAmelCase_     ,  lowerCAmelCase_      =     self.model_tester.prepare_config_and_inputs_for_common()
							lowerCAmelCase_      =     3

							lowerCAmelCase_      =     to_atuple(self.model_tester.image_size					)
							lowerCAmelCase_      =     to_atuple(config.patch_size					)

							lowerCAmelCase_      =     image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
							lowerCAmelCase_      =     image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

							for model_class in self.all_model_classes:
										lowerCAmelCase_      =     True
										self.check_hidden_states_output(_UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    (padded_height, padded_width)					)

										# check that output_hidden_states also work using config
										del inputs_dict["output_hidden_states"]
										lowerCAmelCase_      =     True
										self.check_hidden_states_output(_UpperCamelCase    ,    _UpperCamelCase    ,    _UpperCamelCase    ,    (padded_height, padded_width)					)




				@slow
				def 					__a						( self					)    ->				List[Any]:
							for model_name in TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
										lowerCAmelCase_      =     TFSwinModel.from_pretrained(_UpperCamelCase					)
										self.assertIsNotNone(_UpperCamelCase					)





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




				@cached_property
				def 					__a						( self					)    ->				Optional[int]:
							return (
							    AutoImageProcessor.from_pretrained("microsoft/swin-tiny-patch4-window7-224"					)
							    if is_vision_available()
							    else None
							)




				@slow
				def 					__a						( self					)    ->				List[str]:
							lowerCAmelCase_      =     TFSwinForImageClassification.from_pretrained("microsoft/swin-tiny-patch4-window7-224"					)
							lowerCAmelCase_      =     self.default_image_processor

							lowerCAmelCase_      =     Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"					)
							lowerCAmelCase_      =     image_processor(images=_UpperCamelCase    ,    return_tensors="tf"					)

							# forward pass
							lowerCAmelCase_      =     model(_UpperCamelCase					)

							# verify the logits
							lowerCAmelCase_      =     tf.TensorShape((1, 1_000)					)
							self.assertEqual(outputs.logits.shape    ,    _UpperCamelCase					)
							lowerCAmelCase_      =     tf.constant([-0.0948, -0.6454, -0.0921]					)
							self.assertTrue(np.allclose(outputs.logits[0, :3]    ,    _UpperCamelCase    ,    atol=1e-4					)					)





class      _lowerCAmelCase :




				def __init__( self					)    ->				None:
							# numbermap keys are the number and its values are lists of indexes sorted
							# in ascending order
							lowerCAmelCase_      =     {}
							# indexmap keys are an index and it's values are the number at that index
							lowerCAmelCase_      =     {}




				def 					__a						( self    ,    _UpperCamelCase    ,    _UpperCamelCase					)    ->				list[int]:
							if isinstance(_UpperCamelCase    ,    (range, str)					):
										lowerCAmelCase_      =     list(_UpperCamelCase					)
							elif not isinstance(_UpperCamelCase    ,    _UpperCamelCase					):
										raise TypeError(
										    "binary_search_delete() only accepts either a list, range or str"					)

							lowerCAmelCase_      =     0
							lowerCAmelCase_      =     len(_UpperCamelCase					) - 1

							while low <= high:
										lowerCAmelCase_      =     (low + high) // 2
										if array[mid] == item:
													array.pop(_UpperCamelCase					)
													return array
										elif array[mid] < item:
													lowerCAmelCase_      =     mid + 1
										else:
													lowerCAmelCase_      =     mid - 1
							raise ValueError(
							    "Either the item is not in the array or the array was unsorted"					)




				def 					__a						( self    ,    _UpperCamelCase    ,    _UpperCamelCase					)    ->				list[int]:
							if isinstance(_UpperCamelCase    ,    (range, str)					):
										lowerCAmelCase_      =     list(_UpperCamelCase					)
							elif not isinstance(_UpperCamelCase    ,    _UpperCamelCase					):
										raise TypeError(
										    "binary_search_insert() only accepts either a list, range or str"					)

							lowerCAmelCase_      =     0
							lowerCAmelCase_      =     len(_UpperCamelCase					) - 1

							while low <= high:
										lowerCAmelCase_      =     (low + high) // 2
										if array[mid] == index:
													# If the item already exists in the array,
													# insert it after the existing item
													array.insert(mid + 1    ,    _UpperCamelCase					)
													return array
										elif array[mid] < index:
													lowerCAmelCase_      =     mid + 1
										else:
													lowerCAmelCase_      =     mid - 1

        # If the item doesn't exist in the array, insert it at the appropriate position
							array.insert(_UpperCamelCase    ,    _UpperCamelCase					)
							return array




				def 					__a						( self    ,    _UpperCamelCase    ,    _UpperCamelCase					)    ->				None:
							# Remove previous index
							if index in self.indexmap:
										lowerCAmelCase_      =     self.indexmap[index]
										if len(self.numbermap[n]					) == 1:
													del self.numbermap[n]
										else:
													lowerCAmelCase_      =     self.binary_search_delete(self.numbermap[n]    ,    _UpperCamelCase					)

        # Set new index
							lowerCAmelCase_      =     number

							# Number not seen before or empty so insert number value
							if number not in self.numbermap:
										lowerCAmelCase_      =     [index]

							# Here we need to perform a binary search insertion in order to insert
							# The item in the correct place
							else:
										lowerCAmelCase_      =     self.binary_search_insert(
										    self.numbermap[number]    ,    _UpperCamelCase					)




				def 					__a						( self    ,    _UpperCamelCase					)    ->				int:
							return self.numbermap.get(_UpperCamelCase    ,    [-1]					)[0]


if __name__ == "__main__":
			import doctest

			doctest.testmod()



